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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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, self->type);
 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 } /* extend CvMat */
 196
 197 %extend IplImage {
 198         %newobject operator &;
 199         IplImage * operator & (CvArr * src){
 200                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 201                 cvAnd(self, src, res);
 202                 return res;
 203         }
 204         IplImage * operator &= (CvArr * src){
 205                 cvAnd(self, src, self);
 206                 return self;
 207         }
 208         %newobject operator +;
 209         IplImage * operator + (CvArr * src){
 210                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 211                 cvAdd(self, src, res);
 212                 return res;
 213         }
 214         IplImage * operator += (CvArr * src){
 215                 cvAdd(self, src, self);
 216                 return self;
 217         }
 218         %newobject operator *;
 219         IplImage * operator * (CvArr * src){
 220                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 221                 cvMul(self, src, res);
 222                 return res;
 223         }
 224         IplImage * operator *= (CvArr * src){
 225                 cvMul(self, src, self);
 226                 return self;
 227         }
 228         %newobject operator -;
 229         IplImage * operator - (CvArr * src){
 230                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 231                 cvSub(self, src, res);
 232                 return res;
 233         }
 234         IplImage * operator -= (CvArr * src){
 235                 cvSub(self, src, self);
 236                 return self;
 237         }
 238         %newobject operator /;
 239         IplImage * operator / (CvArr * src){
 240                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 241                 cvDiv(self, src, res);
 242                 return res;
 243         }
 244         IplImage * operator /= (CvArr * src){
 245                 cvDiv(self, src, self);
 246                 return self;
 247         }
 248         %newobject operator |;
 249         IplImage * operator | (CvArr * src){
 250                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 251                 cvOr(self, src, res);
 252                 return res;
 253         }
 254         IplImage * operator |= (CvArr * src){
 255                 cvOr(self, src, self);
 256                 return self;
 257         }
 258         %newobject operator ^;
 259         IplImage * operator ^ (CvArr * src){
 260                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 261                 cvXor(self, src, res);
 262                 return res;
 263         }
 264         IplImage * operator ^= (CvArr * src){
 265                 cvXor(self, src, self);
 266                 return self;
 267         }
 268         %newobject operator +;
 269         IplImage * operator + (CvScalar val){
 270                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 271                 cvAddS(self, val, res);
 272                 return res;
 273         }
 274         IplImage * operator += (CvScalar val){
 275                 cvAddS(self, val, self);
 276                 return self;
 277         }
 278         %newobject operator ^;
 279         IplImage * operator ^ (CvScalar val){
 280                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 281                 cvXorS(self, val, res);
 282                 return res;
 283         }
 284         IplImage * operator ^= (CvScalar val){
 285                 cvXorS(self, val, self);
 286                 return self;
 287         }
 288         %newobject operator -;
 289         IplImage * operator - (CvScalar val){
 290                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 291                 cvSubS(self, val, res);
 292                 return res;
 293         }
 294         IplImage * operator -= (CvScalar val){
 295                 cvSubS(self, val, self);
 296                 return self;
 297         }
 298         %newobject operator |;
 299         IplImage * operator | (CvScalar val){
 300                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 301                 cvOrS(self, val, res);
 302                 return res;
 303         }
 304         IplImage * operator |= (CvScalar val){
 305                 cvOrS(self, val, self);
 306                 return self;
 307         }
 308         %newobject operator &;
 309         IplImage * operator & (CvScalar val){
 310                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 311                 cvAndS(self, val, res);
 312                 return res;
 313         }
 314         IplImage * operator &= (CvScalar val){
 315                 cvAndS(self, val, self);
 316                 return self;
 317         }
 318         %newobject operator >=;
 319         IplImage * operator >= (CvArr * src){
 320                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 321                 cvCmp(self, src, res, CV_CMP_GE);
 322                 return res;
 323         }
 324         IplImage * operator >= (double val){
 325                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 326                 cvCmpS(self, val, res, CV_CMP_GE);
 327                 return res;
 328         }
 329         %newobject operator ==;
 330         IplImage * operator == (CvArr * src){
 331                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 332                 cvCmp(self, src, res, CV_CMP_EQ);
 333                 return res;
 334         }
 335         IplImage * operator == (double val){
 336                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 337                 cvCmpS(self, val, res, CV_CMP_EQ);
 338                 return res;
 339         }
 340         %newobject operator <=;
 341         IplImage * operator <= (CvArr * src){
 342                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 343                 cvCmp(self, src, res, CV_CMP_LE);
 344                 return res;
 345         }
 346         IplImage * operator <= (double val){
 347                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 348                 cvCmpS(self, val, res, CV_CMP_LE);
 349                 return res;
 350         }
 351         %newobject operator !=;
 352         IplImage * operator != (CvArr * src){
 353                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 354                 cvCmp(self, src, res, CV_CMP_NE);
 355                 return res;
 356         }
 357         IplImage * operator != (double val){
 358                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 359                 cvCmpS(self, val, res, CV_CMP_NE);
 360                 return res;
 361         }
 362         %newobject operator <;
 363         IplImage * operator < (CvArr * src){
 364                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 365                 cvCmp(self, src, res, CV_CMP_LT);
 366                 return res;
 367         }
 368         IplImage * operator < (double val){
 369                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 370                 cvCmpS(self, val, res, CV_CMP_LT);
 371                 return res;
 372         }
 373         %newobject operator >;
 374         IplImage * operator > (CvArr * src){
 375                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 376                 cvCmp(self, src, res, CV_CMP_GT);
 377                 return res;
 378         }
 379         IplImage * operator > (double val){
 380                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 381                 cvCmpS(self, val, res, CV_CMP_GT);
 382                 return res;
 383         }
 384         %newobject operator /;
 385         IplImage * operator / (double val){
 386                 IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
 387                 cvScale(self, res, val);
 388                 return res;
 389         }
 390 } /* extend IplImage */
 391