git.maemo.org Git - opencv/blob - interfaces/swig/general/cvarr_operators.i

   1 /** This file was automatically generated using util/cvarr_operators.py script */
   2 %extend CvMat {
   3         %newobject operator &;
   4         CvMat * operator & (CvArr * src){
   5                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
   6                 cvAnd(self, src, res);
   7                 return res;
   8         }
   9         CvMat * operator &= (CvArr * src){
  10                 cvAnd(self, src, self);
  11                 return self;
  12         }
  13         %newobject operator +;
  14         CvMat * operator + (CvArr * src){
  15                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  16                 cvAdd(self, src, res);
  17                 return res;
  18         }
  19         CvMat * operator += (CvArr * src){
  20                 cvAdd(self, src, self);
  21                 return self;
  22         }
  23         %newobject operator *;
  24         CvMat * operator * (CvArr * src){
  25                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  26                 cvMul(self, src, res);
  27                 return res;
  28         }
  29         CvMat * operator *= (CvArr * src){
  30                 cvMul(self, src, self);
  31                 return self;
  32         }
  33         %newobject operator -;
  34         CvMat * operator - (CvArr * src){
  35                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  36                 cvSub(self, src, res);
  37                 return res;
  38         }
  39         CvMat * operator -= (CvArr * src){
  40                 cvSub(self, src, self);
  41                 return self;
  42         }
  43         %newobject operator /;
  44         CvMat * operator / (CvArr * src){
  45                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  46                 cvDiv(self, src, res);
  47                 return res;
  48         }
  49         CvMat * operator /= (CvArr * src){
  50                 cvDiv(self, src, self);
  51                 return self;
  52         }
  53         %newobject operator |;
  54         CvMat * operator | (CvArr * src){
  55                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  56                 cvOr(self, src, res);
  57                 return res;
  58         }
  59         CvMat * operator |= (CvArr * src){
  60                 cvOr(self, src, self);
  61                 return self;
  62         }
  63         %newobject operator ^;
  64         CvMat * operator ^ (CvArr * src){
  65                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  66                 cvXor(self, src, res);
  67                 return res;
  68         }
  69         CvMat * operator ^= (CvArr * src){
  70                 cvXor(self, src, self);
  71                 return self;
  72         }
  73         %newobject operator +;
  74         CvMat * operator + (CvScalar val){
  75                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  76                 cvAddS(self, val, res);
  77                 return res;
  78         }
  79         CvMat * operator += (CvScalar val){
  80                 cvAddS(self, val, self);
  81                 return self;
  82         }
  83         %newobject operator ^;
  84         CvMat * operator ^ (CvScalar val){
  85                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  86                 cvXorS(self, val, res);
  87                 return res;
  88         }
  89         CvMat * operator ^= (CvScalar val){
  90                 cvXorS(self, val, self);
  91                 return self;
  92         }
  93         %newobject operator -;
  94         CvMat * operator - (CvScalar val){
  95                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
  96                 cvSubS(self, val, res);
  97                 return res;
  98         }
  99         CvMat * operator -= (CvScalar val){
 100                 cvSubS(self, val, self);
 101                 return self;
 102         }
 103         %newobject operator |;
 104         CvMat * operator | (CvScalar val){
 105                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
 106                 cvOrS(self, val, res);
 107                 return res;
 108         }
 109         CvMat * operator |= (CvScalar val){
 110                 cvOrS(self, val, self);
 111                 return self;
 112         }
 113         %newobject operator &;
 114         CvMat * operator & (CvScalar val){
 115                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
 116                 cvAndS(self, val, res);
 117                 return res;
 118         }
 119         CvMat * operator &= (CvScalar val){
 120                 cvAndS(self, val, self);
 121                 return self;
 122         }
 123         %newobject operator >=;
 124         CvMat * operator >= (CvArr * src){
 125                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 126                 cvCmp(self, src, res, CV_CMP_GE);
 127                 return res;
 128         }
 129         CvMat * operator >= (double val){
 130                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 131                 cvCmpS(self, val, res, CV_CMP_GE);
 132                 return res;
 133         }
 134         %newobject operator ==;
 135         CvMat * operator == (CvArr * src){
 136                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 137                 cvCmp(self, src, res, CV_CMP_EQ);
 138                 return res;
 139         }
 140         CvMat * operator == (double val){
 141                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 142                 cvCmpS(self, val, res, CV_CMP_EQ);
 143                 return res;
 144         }
 145         %newobject operator <=;
 146         CvMat * operator <= (CvArr * src){
 147                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 148                 cvCmp(self, src, res, CV_CMP_LE);
 149                 return res;
 150         }
 151         CvMat * operator <= (double val){
 152                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 153                 cvCmpS(self, val, res, CV_CMP_LE);
 154                 return res;
 155         }
 156         %newobject operator !=;
 157         CvMat * operator != (CvArr * src){
 158                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 159                 cvCmp(self, src, res, CV_CMP_NE);
 160                 return res;
 161         }
 162         CvMat * operator != (double val){
 163                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 164                 cvCmpS(self, val, res, CV_CMP_NE);
 165                 return res;
 166         }
 167         %newobject operator <;
 168         CvMat * operator < (CvArr * src){
 169                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 170                 cvCmp(self, src, res, CV_CMP_LT);
 171                 return res;
 172         }
 173         CvMat * operator < (double val){
 174                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 175                 cvCmpS(self, val, res, CV_CMP_LT);
 176                 return res;
 177         }
 178         %newobject operator >;
 179         CvMat * operator > (CvArr * src){
 180                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 181                 cvCmp(self, src, res, CV_CMP_GT);
 182                 return res;
 183         }
 184         CvMat * operator > (double val){
 185                 CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
 186                 cvCmpS(self, val, res, CV_CMP_GT);
 187                 return res;
 188         }
 189         %newobject operator *;
 190         CvMat * operator * (double val){
 191                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
 192                 cvScale(self, res, val);
 193                 return res;
 194         }
 195         CvMat * operator *= (double val){
 196                 cvScale(self, self, val);
 197                 return self;
 198         }
 199         %newobject operator /;
 200         CvMat * operator / (double val){
 201                 CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
 202                 cvScale(self, res, 1.0/val);
 203                 return res;
 204         }
 205         CvMat * operator /= (double val){
 206                 cvScale(self, self, 1.0/val);
 207                 return self;
 208         }
 209 } /* extend CvMat */
 210
 211 %extend IplImage {
 212         %newobject operator &;
 213         IplImage * operator & (CvArr * src){
 214                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 215                 cvAnd(self, src, res);
 216                 return res;
 217         }
 218         IplImage * operator &= (CvArr * src){
 219                 cvAnd(self, src, self);
 220                 return self;
 221         }
 222         %newobject operator +;
 223         IplImage * operator + (CvArr * src){
 224                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 225                 cvAdd(self, src, res);
 226                 return res;
 227         }
 228         IplImage * operator += (CvArr * src){
 229                 cvAdd(self, src, self);
 230                 return self;
 231         }
 232         %newobject operator *;
 233         IplImage * operator * (CvArr * src){
 234                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 235                 cvMul(self, src, res);
 236                 return res;
 237         }
 238         IplImage * operator *= (CvArr * src){
 239                 cvMul(self, src, self);
 240                 return self;
 241         }
 242         %newobject operator -;
 243         IplImage * operator - (CvArr * src){
 244                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 245                 cvSub(self, src, res);
 246                 return res;
 247         }
 248         IplImage * operator -= (CvArr * src){
 249                 cvSub(self, src, self);
 250                 return self;
 251         }
 252         %newobject operator /;
 253         IplImage * operator / (CvArr * src){
 254                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 255                 cvDiv(self, src, res);
 256                 return res;
 257         }
 258         IplImage * operator /= (CvArr * src){
 259                 cvDiv(self, src, self);
 260                 return self;
 261         }
 262         %newobject operator |;
 263         IplImage * operator | (CvArr * src){
 264                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 265                 cvOr(self, src, res);
 266                 return res;
 267         }
 268         IplImage * operator |= (CvArr * src){
 269                 cvOr(self, src, self);
 270                 return self;
 271         }
 272         %newobject operator ^;
 273         IplImage * operator ^ (CvArr * src){
 274                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 275                 cvXor(self, src, res);
 276                 return res;
 277         }
 278         IplImage * operator ^= (CvArr * src){
 279                 cvXor(self, src, self);
 280                 return self;
 281         }
 282         %newobject operator +;
 283         IplImage * operator + (CvScalar val){
 284                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 285                 cvAddS(self, val, res);
 286                 return res;
 287         }
 288         IplImage * operator += (CvScalar val){
 289                 cvAddS(self, val, self);
 290                 return self;
 291         }
 292         %newobject operator ^;
 293         IplImage * operator ^ (CvScalar val){
 294                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 295                 cvXorS(self, val, res);
 296                 return res;
 297         }
 298         IplImage * operator ^= (CvScalar val){
 299                 cvXorS(self, val, self);
 300                 return self;
 301         }
 302         %newobject operator -;
 303         IplImage * operator - (CvScalar val){
 304                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 305                 cvSubS(self, val, res);
 306                 return res;
 307         }
 308         IplImage * operator -= (CvScalar val){
 309                 cvSubS(self, val, self);
 310                 return self;
 311         }
 312         %newobject operator |;
 313         IplImage * operator | (CvScalar val){
 314                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 315                 cvOrS(self, val, res);
 316                 return res;
 317         }
 318         IplImage * operator |= (CvScalar val){
 319                 cvOrS(self, val, self);
 320                 return self;
 321         }
 322         %newobject operator &;
 323         IplImage * operator & (CvScalar val){
 324                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 325                 cvAndS(self, val, res);
 326                 return res;
 327         }
 328         IplImage * operator &= (CvScalar val){
 329                 cvAndS(self, val, self);
 330                 return self;
 331         }
 332         %newobject operator >=;
 333         IplImage * operator >= (CvArr * src){
 334                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 335                 cvCmp(self, src, res, CV_CMP_GE);
 336                 return res;
 337         }
 338         IplImage * operator >= (double val){
 339                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 340                 cvCmpS(self, val, res, CV_CMP_GE);
 341                 return res;
 342         }
 343         %newobject operator ==;
 344         IplImage * operator == (CvArr * src){
 345                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 346                 cvCmp(self, src, res, CV_CMP_EQ);
 347                 return res;
 348         }
 349         IplImage * operator == (double val){
 350                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 351                 cvCmpS(self, val, res, CV_CMP_EQ);
 352                 return res;
 353         }
 354         %newobject operator <=;
 355         IplImage * operator <= (CvArr * src){
 356                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 357                 cvCmp(self, src, res, CV_CMP_LE);
 358                 return res;
 359         }
 360         IplImage * operator <= (double val){
 361                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 362                 cvCmpS(self, val, res, CV_CMP_LE);
 363                 return res;
 364         }
 365         %newobject operator !=;
 366         IplImage * operator != (CvArr * src){
 367                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 368                 cvCmp(self, src, res, CV_CMP_NE);
 369                 return res;
 370         }
 371         IplImage * operator != (double val){
 372                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 373                 cvCmpS(self, val, res, CV_CMP_NE);
 374                 return res;
 375         }
 376         %newobject operator <;
 377         IplImage * operator < (CvArr * src){
 378                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 379                 cvCmp(self, src, res, CV_CMP_LT);
 380                 return res;
 381         }
 382         IplImage * operator < (double val){
 383                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 384                 cvCmpS(self, val, res, CV_CMP_LT);
 385                 return res;
 386         }
 387         %newobject operator >;
 388         IplImage * operator > (CvArr * src){
 389                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 390                 cvCmp(self, src, res, CV_CMP_GT);
 391                 return res;
 392         }
 393         IplImage * operator > (double val){
 394                 IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
 395                 cvCmpS(self, val, res, CV_CMP_GT);
 396                 return res;
 397         }
 398         %newobject operator *;
 399         IplImage * operator * (double val){
 400                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 401                 cvScale(self, res, val);
 402                 return res;
 403         }
 404         IplImage * operator *= (double val){
 405                 cvScale(self, self, val);
 406                 return self;
 407         }
 408         %newobject operator /;
 409         IplImage * operator / (double val){
 410                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 411                 cvScale(self, res, 1.0/val);
 412                 return res;
 413         }
 414         IplImage * operator /= (double val){
 415                 cvScale(self, self, 1.0/val);
 416                 return self;
 417         }
 418 } /* extend IplImage */
 419