mirror of
https://github.com/opencv/opencv.git
synced 2024-12-11 22:49:21 +08:00
462 lines
16 KiB
OpenEdge ABL
462 lines
16 KiB
OpenEdge ABL
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
//
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
// If you do not agree to this license, do not download, install,
|
|
// copy or use the software.
|
|
//
|
|
//
|
|
// Intel License Agreement
|
|
// For Open Source Computer Vision Library
|
|
//
|
|
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
|
// Third party copyrights are property of their respective owners.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
// this list of conditions and the following disclaimer.
|
|
//
|
|
// * Redistribution's in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// * The name of Intel Corporation may not be used to endorse or promote products
|
|
// derived from this software without specific prior written permission.
|
|
//
|
|
// This software is provided by the copyright holders and contributors "as is" and
|
|
// any express or implied warranties, including, but not limited to, the implied
|
|
// warranties of merchantability and fitness for a particular purpose are disclaimed.
|
|
// In no event shall the Intel Corporation or contributors be liable for any direct,
|
|
// indirect, incidental, special, exemplary, or consequential damages
|
|
// (including, but not limited to, procurement of substitute goods or services;
|
|
// loss of use, data, or profits; or business interruption) however caused
|
|
// and on any theory of liability, whether in contract, strict liability,
|
|
// or tort (including negligence or otherwise) arising in any way out of
|
|
// the use of this software, even if advised of the possibility of such damage.
|
|
//
|
|
//M*/
|
|
|
|
// 2006-02-17 Roman Stanchak <rstancha@cse.wustl.edu>
|
|
// 2006-07-19 Moved most operators to general/cvarr_operators.i for use with other languages
|
|
|
|
/*M//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Macros for extending CvMat and IplImage -- primarily for operator overloading
|
|
//////////////////////////////////////////////////////////////////////////////////////////M*/
|
|
|
|
// Macro to define octave function of form B = A.f(c)
|
|
// where A is a CvArr type, c and B are arbitrary types
|
|
%define %wrap_cvGeneric_CvArr(cname, rettype, octfunc, argtype, cvfunc, newobjcall)
|
|
%newobject cname::octfunc(argtype arg);
|
|
%extend cname {
|
|
rettype octfunc(argtype arg){
|
|
rettype retarg = newobjcall;
|
|
cvfunc;
|
|
return retarg;
|
|
}
|
|
}
|
|
%enddef
|
|
|
|
// Macro to define octave function of the form B = A.f(c)
|
|
// where A and B are both CvArr of same size and type
|
|
%define %wrap_cvArr_binaryop(octfunc, argtype, cvfunc)
|
|
%wrap_cvGeneric_CvArr(CvMat, CvMat *, octfunc, argtype, cvfunc,
|
|
cvCreateMat(self->rows, self->cols, self->type));
|
|
%wrap_cvGeneric_CvArr(IplImage, IplImage *, octfunc, argtype, cvfunc,
|
|
cvCreateImage(cvGetSize(self), self->depth, self->nChannels));
|
|
%enddef
|
|
|
|
// Macro to define octave function of the form A = A.f(c)
|
|
// where f modifies A inplace
|
|
// use for +=, etc
|
|
%define %wrap_cvGeneric_InPlace(cname, rettype, octfunc, argtype, cvfunc)
|
|
%wrap_cvGeneric_CvArr(cname, rettype, octfunc, argtype, cvfunc, self);
|
|
%enddef
|
|
|
|
/*M//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Macros to map operators to specific OpenCV functions
|
|
//////////////////////////////////////////////////////////////////////////////////////////M*/
|
|
|
|
// map any OpenCV function of form cvFunc(src1, src2, dst)
|
|
%define %wrap_cvArith(octfunc, cvfunc)
|
|
%wrap_cvArr_binaryop(octfunc, CvArr *, cvfunc(self, arg, retarg));
|
|
%enddef
|
|
|
|
// map any OpenCV function of form cvFunc(src1, value, dst)
|
|
%define %wrap_cvArithS(octfunc, cvfuncS)
|
|
%wrap_cvArr_binaryop(octfunc, CvScalar, cvfuncS(self, arg, retarg));
|
|
%wrap_cvArr_binaryop(octfunc, double, cvfuncS(self, cvScalar(arg), retarg));
|
|
%enddef
|
|
|
|
// same as wrap_cvArith
|
|
%define %wrap_cvLogic(octfunc, cvfunc)
|
|
%wrap_cvArr_binaryop(octfunc, CvArr *, cvfunc(self, arg, retarg))
|
|
%enddef
|
|
|
|
// same as wrap_cvArithS
|
|
%define %wrap_cvLogicS(octfunc, cvfuncS)
|
|
%wrap_cvArr_binaryop(octfunc, CvScalar, cvfuncS(self, arg, retarg));
|
|
%wrap_cvArr_binaryop(octfunc, double, cvfuncS(self, cvScalar(arg), retarg));
|
|
%enddef
|
|
|
|
// Macro to map logical operations to cvCmp
|
|
%define %wrap_cvCmp(octfunc, cmp_op)
|
|
%wrap_cvGeneric_CvArr(CvMat, CvArr *, octfunc, CvMat *,
|
|
cvCmp(self, arg, retarg, cmp_op),
|
|
cvCreateMat(self->rows, self->cols, CV_8U));
|
|
%wrap_cvGeneric_CvArr(IplImage, CvArr *, octfunc, IplImage *,
|
|
cvCmp(self, arg, retarg, cmp_op),
|
|
cvCreateImage(cvGetSize(self), 8, 1));
|
|
%enddef
|
|
|
|
%define %wrap_cvCmpS(octfunc, cmp_op)
|
|
%wrap_cvGeneric_CvArr(CvMat, CvArr *, octfunc, double,
|
|
cvCmpS(self, arg, retarg, cmp_op),
|
|
cvCreateMat(self->rows, self->cols, CV_8U));
|
|
%wrap_cvGeneric_CvArr(IplImage, CvArr *, octfunc, double,
|
|
cvCmpS(self, arg, retarg, cmp_op),
|
|
cvCreateImage(cvGetSize(self), 8, 1));
|
|
%enddef
|
|
|
|
// special case for cvScale, /, *
|
|
%define %wrap_cvScale(octfunc, scale)
|
|
%wrap_cvGeneric_CvArr(CvMat, CvArr *, octfunc, double,
|
|
cvScale(self, retarg, scale),
|
|
cvCreateMat(self->rows, self->cols, self->type));
|
|
%wrap_cvGeneric_CvArr(IplImage, CvArr *, octfunc, double,
|
|
cvScale(self, retarg, scale),
|
|
cvCreateImage(cvGetSize(self), self->depth, self->nChannels));
|
|
%enddef
|
|
|
|
/*M//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Actual Operator Declarations
|
|
//////////////////////////////////////////////////////////////////////////////////////////M*/
|
|
|
|
// Arithmetic operators
|
|
%wrap_cvArith(__radd__, cvAdd);
|
|
|
|
// special case for reverse operations
|
|
%wrap_cvArr_binaryop(__rsub__, CvArr *, cvSub(arg, self, retarg));
|
|
%wrap_cvArr_binaryop(__rdiv__, CvArr *, cvDiv(arg, self, retarg));
|
|
%wrap_cvArr_binaryop(__rmul__, CvArr *, cvMatMul(arg, self, retarg));
|
|
|
|
%wrap_cvArithS(__radd__, cvAddS);
|
|
%wrap_cvArithS(__rsub__, cvSubRS);
|
|
|
|
|
|
%wrap_cvScale(__rmul__, arg);
|
|
%wrap_cvScale(__rdiv__, 1.0/arg);
|
|
|
|
%wrap_cvLogicS(__ror__, cvOrS)
|
|
%wrap_cvLogicS(__rand__, cvAndS)
|
|
%wrap_cvLogicS(__rxor__, cvXorS)
|
|
|
|
%wrap_cvCmpS(__req__, CV_CMP_EQ);
|
|
%wrap_cvCmpS(__rgt__, CV_CMP_GT);
|
|
%wrap_cvCmpS(__rge__, CV_CMP_GE);
|
|
%wrap_cvCmpS(__rlt__, CV_CMP_LT);
|
|
%wrap_cvCmpS(__rle__, CV_CMP_LE);
|
|
%wrap_cvCmpS(__rne__, CV_CMP_NE);
|
|
|
|
|
|
// misc operators for octave
|
|
%wrap_cvArr_binaryop(__pow__, double, cvPow(self, retarg, arg))
|
|
|
|
// TODO -- other Octave operators listed in SWIG/Octave docs (www.swig.org)
|
|
|
|
// __abs__ -- cvAbs
|
|
// __nonzero__
|
|
// __hash__ ??
|
|
// __repr__ -- full string representation
|
|
// __str__ -- compact representation
|
|
// __call__ -- ??
|
|
// __len__ -- number of rows? or elements?
|
|
// __iter__ -- ??
|
|
// __contains__ -- cvCmpS, cvMax ?
|
|
// __floordiv__ ??
|
|
// __mul__ -- cvGEMM
|
|
// __lshift__ -- ??
|
|
// __rshift__ -- ??
|
|
// __pow__ -- cvPow
|
|
|
|
// Called to implement the unary arithmetic operations (-, +, abs() and ~).
|
|
//__neg__( self)
|
|
//__pos__( self)
|
|
//__abs__( self)
|
|
//__invert__( self)
|
|
|
|
// Called to implement the built-in functions complex(), int(), long(), and float(). Should return a value of the appropriate type. Can I abuse this to return an array of the correct type??? scipy only allows return of length 1 arrays.
|
|
// __complex__( self )
|
|
// __int__( self )
|
|
// __long__( self )
|
|
// __float__( self )
|
|
|
|
/*M//////////////////////////////////////////////////////////////////////////////////////////
|
|
// Slice access and assignment for CvArr types
|
|
//////////////////////////////////////////////////////////////////////////////////////////M*/
|
|
|
|
// TODO: CvMatND
|
|
|
|
%newobject CvMat::__paren(octave_value object);
|
|
%newobject _IplImage::__paren(octave_value object);
|
|
|
|
// Macro to check bounds of slice and throw error if outside
|
|
%define CHECK_SLICE_BOUNDS(rect,w,h,retval)
|
|
//printf("__setitem__ slice(%d:%d, %d:%d) array(%d,%d)", rect.x, rect.y, rect.x+rect.width, rect.y+rect.height, w, h);
|
|
if(rect.width<=0 || rect.height<=0 ||
|
|
rect.width>w || rect.height>h ||
|
|
rect.x<0 || rect.y<0 ||
|
|
rect.x>= w || rect.y >=h){
|
|
char errstr[256];
|
|
// previous function already set error string
|
|
if(rect.width==0 && rect.height==0 && rect.x==0 && rect.y==0) return retval;
|
|
sprintf(errstr, "Requested slice [ %d:%d %d:%d ] oversteps array sized [ %d %d ]",
|
|
rect.x, rect.y, rect.x+rect.width, rect.y+rect.height, w, h);
|
|
error(errstr);
|
|
return retval;
|
|
}
|
|
else{}
|
|
%enddef
|
|
|
|
// slice access and assignment for CvMat
|
|
%extend CvMat
|
|
{
|
|
char * __str(){
|
|
static char str[8];
|
|
cvArrPrint( self );
|
|
str[0]=0;
|
|
return str;
|
|
return "";
|
|
}
|
|
|
|
// scalar assignment
|
|
void __paren_asgn(octave_value object, double val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
cvSet(&tmp, cvScalarAll(val));
|
|
}
|
|
void __paren_asgn(octave_value object, CvPoint val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
cvSet(&tmp, cvScalar(val.x, val.y));
|
|
}
|
|
void __paren_asgn(octave_value object, CvPoint2D32f val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
|
|
cvSet(&tmp, cvScalar(val.x, val.y));
|
|
}
|
|
void __paren_asgn(octave_value object, CvScalar val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
|
|
cvSet(&tmp, val);
|
|
}
|
|
|
|
// array slice assignment
|
|
void __paren_asgn(octave_value object, CvArr * arr){
|
|
CvMat tmp, src_stub, *src;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
|
|
// Reshape source array to fit destination
|
|
// This will be used a lot for small arrays b/c
|
|
// OctObject_to_CvArr tries to compress a 2-D octave
|
|
// array with 1-4 columns into a multichannel vector
|
|
src=cvReshape(arr, &src_stub, CV_MAT_CN(tmp.type), tmp.rows);
|
|
|
|
cvConvert(src, &tmp);
|
|
}
|
|
|
|
// slice access
|
|
octave_value __paren(octave_value object){
|
|
CvMat * mat;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, octave_value() );
|
|
if(subrect.width==1 && subrect.height==1){
|
|
CvScalar * s;
|
|
int type = cvGetElemType( self );
|
|
if(CV_MAT_CN(type) > 1){
|
|
s = new CvScalar;
|
|
*s = cvGet2D( self, subrect.y, subrect.x );
|
|
return SWIG_NewPointerObj( s, $descriptor(CvScalar *), 1 );
|
|
}
|
|
switch(CV_MAT_DEPTH(type)){
|
|
case CV_8U:
|
|
return OctLong_FromUnsignedLong( CV_MAT_ELEM(*self, uchar, subrect.y, subrect.x ) );
|
|
case CV_8S:
|
|
return OctLong_FromLong( CV_MAT_ELEM(*self, char, subrect.y, subrect.x ) );
|
|
case CV_16U:
|
|
return OctLong_FromUnsignedLong( CV_MAT_ELEM(*self, ushort, subrect.y, subrect.x ) );
|
|
case CV_16S:
|
|
return OctLong_FromLong( CV_MAT_ELEM(*self, short, subrect.y, subrect.x ) );
|
|
case CV_32S:
|
|
return OctLong_FromLong( CV_MAT_ELEM(*self, int, subrect.y, subrect.x ) );
|
|
case CV_32F:
|
|
return OctFloat_FromDouble( CV_MAT_ELEM(*self, float, subrect.y, subrect.x) );
|
|
case CV_64F:
|
|
return OctFloat_FromDouble( CV_MAT_ELEM(*self, double, subrect.y, subrect.x) );
|
|
}
|
|
}
|
|
mat = (CvMat *) cvAlloc(sizeof(CvMat));
|
|
cvGetSubRect(self, mat, subrect);
|
|
|
|
// cvGetSubRect doesn't do this since it assumes mat lives on the stack
|
|
mat->hdr_refcount = self->hdr_refcount;
|
|
mat->refcount = self->refcount;
|
|
cvIncRefData(mat);
|
|
|
|
return SWIG_NewPointerObj( mat, $descriptor(CvMat *), 1 );
|
|
}
|
|
|
|
/*
|
|
%octavecode %{
|
|
def __iter__(self):
|
|
"""
|
|
generator function iterating through rows in matrix or elements in vector
|
|
"""
|
|
if self.rows==1:
|
|
return self.colrange()
|
|
return self.rowrange()
|
|
|
|
def rowrange(self):
|
|
"""
|
|
generator function iterating along rows in matrix
|
|
"""
|
|
for i in range(self.rows):
|
|
yield self[i]
|
|
|
|
def colrange(self):
|
|
"""
|
|
generator function iterating along columns in matrix
|
|
"""
|
|
for i in range(self.cols):
|
|
yield self[:,i]
|
|
|
|
# if arg is None, octave still calls our operator overloads
|
|
# but we want
|
|
# if mat != None
|
|
# if mat == None
|
|
# to do the right thing -- so redefine __ne__ and __eq__
|
|
|
|
def __eq__(self, arg):
|
|
"""
|
|
__eq__(self, None)
|
|
__eq__(self, CvArr src)
|
|
__eq__(self, double val)
|
|
"""
|
|
|
|
if not arg:
|
|
return False
|
|
return _cv.CvMat___eq__(self, arg)
|
|
def __ne__(self, arg):
|
|
"""
|
|
__ne__(self, None)
|
|
__ne__(self, CvArr src)
|
|
__ne__(self, double val)
|
|
"""
|
|
|
|
if not arg:
|
|
return True
|
|
return _cv.CvMat___ne__(self, arg)
|
|
%}
|
|
*/
|
|
|
|
}
|
|
|
|
// slice access and assignment for IplImage
|
|
%extend _IplImage
|
|
{
|
|
char * __str(){
|
|
static char str[8];
|
|
cvArrPrint( self );
|
|
str[0]=0;
|
|
return str;
|
|
return "";
|
|
}
|
|
|
|
// scalar assignment
|
|
void __paren_asgn(octave_value object, double val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
cvSet(&tmp, cvScalarAll(val));
|
|
}
|
|
void __paren_asgn(octave_value object, CvPoint val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
cvSet(&tmp, cvScalar(val.x, val.y));
|
|
}
|
|
void __paren_asgn(octave_value object, CvPoint2D32f val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
cvSet(&tmp, cvScalar(val.x, val.y));
|
|
}
|
|
void __paren_asgn(octave_value object, CvScalar val){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
cvSet(&tmp, val);
|
|
}
|
|
|
|
// array slice assignment
|
|
void __paren_asgn(octave_value object, CvArr * arr){
|
|
CvMat tmp;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
cvGetSubRect(self, &tmp, subrect);
|
|
cvConvert(arr, &tmp);
|
|
}
|
|
|
|
// slice access
|
|
octave_value __paren(octave_value object){
|
|
CvMat mat;
|
|
IplImage * im;
|
|
CvRect subrect = OctSlice_to_CvRect( self, object );
|
|
|
|
// return scalar if single element
|
|
if(subrect.width==1 && subrect.height==1){
|
|
CvScalar * s;
|
|
int type = cvGetElemType( self );
|
|
if(CV_MAT_CN(type) > 1){
|
|
s = new CvScalar;
|
|
*s = cvGet2D( self, subrect.y, subrect.x );
|
|
return SWIG_NewPointerObj( s, $descriptor(CvScalar *), 1 );
|
|
}
|
|
switch(CV_MAT_DEPTH(type)){
|
|
case CV_8U:
|
|
return OctLong_FromUnsignedLong( CV_IMAGE_ELEM(self, uchar, subrect.y, subrect.x ) );
|
|
case CV_8S:
|
|
return OctLong_FromLong( CV_IMAGE_ELEM(self, char, subrect.y, subrect.x ) );
|
|
case CV_16U:
|
|
return OctLong_FromUnsignedLong( CV_IMAGE_ELEM(self, ushort, subrect.y, subrect.x ) );
|
|
case CV_16S:
|
|
return OctLong_FromLong( CV_IMAGE_ELEM(self, short, subrect.y, subrect.x ) );
|
|
case CV_32S:
|
|
return OctLong_FromLong( CV_IMAGE_ELEM(self, int, subrect.y, subrect.x ) );
|
|
case CV_32F:
|
|
return OctFloat_FromDouble( CV_IMAGE_ELEM(self, float, subrect.y, subrect.x) );
|
|
case CV_64F:
|
|
return OctFloat_FromDouble( CV_IMAGE_ELEM(self, double, subrect.y, subrect.x) );
|
|
}
|
|
}
|
|
|
|
// otherwise return array
|
|
im = (IplImage *) cvAlloc(sizeof(IplImage));
|
|
cvGetSubRect(self, &mat, subrect);
|
|
im = cvGetImage(&mat, im);
|
|
return SWIG_NewPointerObj( im, $descriptor(_IplImage *), 1 );
|
|
}
|
|
}
|
|
|