generic-library/opencv
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

removed obsolete swig-based python & octave wrappers

Browse Source
This commit is contained in:
Vadim Pisarevsky 2011-04-15 11:14:01 +00:00
parent 1c347f4801
commit 8be541eed2
73 changed files with 0 additions and 355942 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
interfaces/CMakeLists.txt
View File

@ -1,14 +0,0 @@
if(SWIG_FOUND)
add_subdirectory(swig)
endif()
if(MSVC OR MINGW)
if(NOT CMAKE_CL_64)
add_subdirectory(ffopencv)
endif()
endif()
if(PYTHONLIBS_FOUND AND BUILD_NEW_PYTHON_SUPPORT)
add_subdirectory(python)
endif()
#if(IPP_FOUND AND BUILD_CUSTOM_IPP_LIB)
# add_subdirectory(ippopencv)
#endif()

6
interfaces/swig/CMakeLists.txt
View File

@ -1,6 +0,0 @@
if(PYTHONLIBS_FOUND AND BUILD_SWIG_PYTHON_SUPPORT)
add_subdirectory(python)
endif()
if(OCTAVE_FOUND AND BUILD_OCTAVE_SUPPORT)
add_subdirectory(octave)
endif()

13
interfaces/swig/README
View File

@ -1,13 +0,0 @@
The OpenCV Python wrapper is automatically generated using a tool called SWIG (www.swig.org)
using filtered header files from OpenCV and the swig interface definition files (*.i).
If you are interested in simply using the Python interface, SWIG is not required and the generated
wrapper files can be used as is.
If you want to modify the python wrapper, or write bindings for another language supported by SWIG
(say Ruby or C#), you will need SWIG 1.2.24 or greater. The filtered headers are found in the
'filtered' subdirectory and are automatically regenerated at build-time if the originals have changed.
The 'general' subdirectory contains SWIG interface definition files that are not specific to Python, and
can hopefully utilized for other language wrappers. The files in the 'python' subdirectory are Python specific.
When adding new functionality, please try to use the SWIG abstractions rather than the Python API whenever
possible.

1064
interfaces/swig/filtered/constants.h
View File

File diff suppressed because it is too large Load Diff

3915
interfaces/swig/filtered/cv.h
View File

File diff suppressed because it is too large Load Diff

120
interfaces/swig/general/cv.i
View File

@ -1,120 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
%module(package="opencv") cv
%{
#include "cxtypes.h"
#include "cxcore.h"
#include "cvtypes.h"
#include "cv.h"
%}
// The preprocessor "gcc -E" may generate compiler specific storage specifiers that confuse SWIG
// We just define them away
#define __attribute__(arg)
#define __inline inline
#define __const const
// SWIG needs this to be parsed before cv.h
%ignore CV_SET_IMAGE_IO_FUNCTIONS;
%include "./cvmacros.i"
// A couple of typemaps helps wrapping OpenCV functions in a sensible way
%include "./memory.i"
%include "./typemaps.i"
%include "./doublepointers.i"
// hide COI and ROI functions
%ignore cvSetImageCOI;
%ignore cvSetImageROI;
%ignore cvGetImageROI;
%ignore cvGetImageCOI;
// mask some functions that return IplImage *
%ignore cvInitImageHeader;
%ignore cvGetImage;
%ignore cvCreateImageHeader;
// adapt others to return CvMat * instead
%ignore cvCreateImage;
%rename (cvCreateImage) cvCreateImageMat;
%ignore cvCloneImage;
%rename (cvCloneImage) cvCloneImageMat;
%inline %{
CvMat * cvCreateImageMat( CvSize size, int depth, int channels ){
static const signed char icvDepthToType[]=
{
-1, -1, CV_8U, CV_8S, CV_16U, CV_16S, -1, -1,
CV_32F, CV_32S, -1, -1, -1, -1, -1, -1, CV_64F, -1
};
depth = icvDepthToType[((depth & 255) >> 2) + (depth < 0)];
return cvCreateMat( size.height, size.width, CV_MAKE_TYPE(depth, channels));
}
#define cvCloneImageMat( mat ) cvCloneMat( mat )
#ifdef WIN32
CvModuleInfo *CvModule::first=0;
CvModuleInfo *CvModule::last=0;
CvTypeInfo *CvType::first=0;
CvTypeInfo *CvType::last=0;
#endif
%}
CvMat * cvCloneImageMat( CvMat * mat );
// Now include the filtered OpenCV constants and prototypes (includes cxcore as well)
%include "../filtered/constants.h"
%include "../filtered/cv.h"
%include "./extensions.i"
%include "./cvarr_operators.i"

419
interfaces/swig/general/cvarr_operators.i
View File

@ -1,419 +0,0 @@
/** This file was automatically generated using util/cvarr_operators.py script */
%extend CvMat {
%newobject operator &;
CvMat * operator & (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAnd(self, src, res);
return res;
}
CvMat * operator &= (CvArr * src){
cvAnd(self, src, self);
return self;
}
%newobject operator +;
CvMat * operator + (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAdd(self, src, res);
return res;
}
CvMat * operator += (CvArr * src){
cvAdd(self, src, self);
return self;
}
%newobject operator *;
CvMat * operator * (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvMul(self, src, res);
return res;
}
CvMat * operator *= (CvArr * src){
cvMul(self, src, self);
return self;
}
%newobject operator -;
CvMat * operator - (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvSub(self, src, res);
return res;
}
CvMat * operator -= (CvArr * src){
cvSub(self, src, self);
return self;
}
%newobject operator /;
CvMat * operator / (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvDiv(self, src, res);
return res;
}
CvMat * operator /= (CvArr * src){
cvDiv(self, src, self);
return self;
}
%newobject operator |;
CvMat * operator | (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvOr(self, src, res);
return res;
}
CvMat * operator |= (CvArr * src){
cvOr(self, src, self);
return self;
}
%newobject operator ^;
CvMat * operator ^ (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvXor(self, src, res);
return res;
}
CvMat * operator ^= (CvArr * src){
cvXor(self, src, self);
return self;
}
%newobject operator +;
CvMat * operator + (CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAddS(self, val, res);
return res;
}
CvMat * operator += (CvScalar val){
cvAddS(self, val, self);
return self;
}
%newobject operator ^;
CvMat * operator ^ (CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvXorS(self, val, res);
return res;
}
CvMat * operator ^= (CvScalar val){
cvXorS(self, val, self);
return self;
}
%newobject operator -;
CvMat * operator - (CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvSubS(self, val, res);
return res;
}
CvMat * operator -= (CvScalar val){
cvSubS(self, val, self);
return self;
}
%newobject operator |;
CvMat * operator | (CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvOrS(self, val, res);
return res;
}
CvMat * operator |= (CvScalar val){
cvOrS(self, val, self);
return self;
}
%newobject operator &;
CvMat * operator & (CvScalar val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvAndS(self, val, res);
return res;
}
CvMat * operator &= (CvScalar val){
cvAndS(self, val, self);
return self;
}
%newobject operator >=;
CvMat * operator >= (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmp(self, src, res, CV_CMP_GE);
return res;
}
CvMat * operator >= (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmpS(self, val, res, CV_CMP_GE);
return res;
}
%newobject operator ==;
CvMat * operator == (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmp(self, src, res, CV_CMP_EQ);
return res;
}
CvMat * operator == (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmpS(self, val, res, CV_CMP_EQ);
return res;
}
%newobject operator <=;
CvMat * operator <= (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmp(self, src, res, CV_CMP_LE);
return res;
}
CvMat * operator <= (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmpS(self, val, res, CV_CMP_LE);
return res;
}
%newobject operator !=;
CvMat * operator != (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmp(self, src, res, CV_CMP_NE);
return res;
}
CvMat * operator != (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmpS(self, val, res, CV_CMP_NE);
return res;
}
%newobject operator <;
CvMat * operator < (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmp(self, src, res, CV_CMP_LT);
return res;
}
CvMat * operator < (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmpS(self, val, res, CV_CMP_LT);
return res;
}
%newobject operator >;
CvMat * operator > (CvArr * src){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmp(self, src, res, CV_CMP_GT);
return res;
}
CvMat * operator > (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, CV_8U);
cvCmpS(self, val, res, CV_CMP_GT);
return res;
}
%newobject operator *;
CvMat * operator * (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvScale(self, res, val);
return res;
}
CvMat * operator *= (double val){
cvScale(self, self, val);
return self;
}
%newobject operator /;
CvMat * operator / (double val){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvScale(self, res, 1.0/val);
return res;
}
CvMat * operator /= (double val){
cvScale(self, self, 1.0/val);
return self;
}
} /* extend CvMat */
%extend IplImage {
%newobject operator &;
IplImage * operator & (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAnd(self, src, res);
return res;
}
IplImage * operator &= (CvArr * src){
cvAnd(self, src, self);
return self;
}
%newobject operator +;
IplImage * operator + (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAdd(self, src, res);
return res;
}
IplImage * operator += (CvArr * src){
cvAdd(self, src, self);
return self;
}
%newobject operator *;
IplImage * operator * (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvMul(self, src, res);
return res;
}
IplImage * operator *= (CvArr * src){
cvMul(self, src, self);
return self;
}
%newobject operator -;
IplImage * operator - (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvSub(self, src, res);
return res;
}
IplImage * operator -= (CvArr * src){
cvSub(self, src, self);
return self;
}
%newobject operator /;
IplImage * operator / (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvDiv(self, src, res);
return res;
}
IplImage * operator /= (CvArr * src){
cvDiv(self, src, self);
return self;
}
%newobject operator |;
IplImage * operator | (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvOr(self, src, res);
return res;
}
IplImage * operator |= (CvArr * src){
cvOr(self, src, self);
return self;
}
%newobject operator ^;
IplImage * operator ^ (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvXor(self, src, res);
return res;
}
IplImage * operator ^= (CvArr * src){
cvXor(self, src, self);
return self;
}
%newobject operator +;
IplImage * operator + (CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAddS(self, val, res);
return res;
}
IplImage * operator += (CvScalar val){
cvAddS(self, val, self);
return self;
}
%newobject operator ^;
IplImage * operator ^ (CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvXorS(self, val, res);
return res;
}
IplImage * operator ^= (CvScalar val){
cvXorS(self, val, self);
return self;
}
%newobject operator -;
IplImage * operator - (CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvSubS(self, val, res);
return res;
}
IplImage * operator -= (CvScalar val){
cvSubS(self, val, self);
return self;
}
%newobject operator |;
IplImage * operator | (CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvOrS(self, val, res);
return res;
}
IplImage * operator |= (CvScalar val){
cvOrS(self, val, self);
return self;
}
%newobject operator &;
IplImage * operator & (CvScalar val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvAndS(self, val, res);
return res;
}
IplImage * operator &= (CvScalar val){
cvAndS(self, val, self);
return self;
}
%newobject operator >=;
IplImage * operator >= (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmp(self, src, res, CV_CMP_GE);
return res;
}
IplImage * operator >= (double val){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmpS(self, val, res, CV_CMP_GE);
return res;
}
%newobject operator ==;
IplImage * operator == (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmp(self, src, res, CV_CMP_EQ);
return res;
}
IplImage * operator == (double val){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmpS(self, val, res, CV_CMP_EQ);
return res;
}
%newobject operator <=;
IplImage * operator <= (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmp(self, src, res, CV_CMP_LE);
return res;
}
IplImage * operator <= (double val){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmpS(self, val, res, CV_CMP_LE);
return res;
}
%newobject operator !=;
IplImage * operator != (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmp(self, src, res, CV_CMP_NE);
return res;
}
IplImage * operator != (double val){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmpS(self, val, res, CV_CMP_NE);
return res;
}
%newobject operator <;
IplImage * operator < (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmp(self, src, res, CV_CMP_LT);
return res;
}
IplImage * operator < (double val){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmpS(self, val, res, CV_CMP_LT);
return res;
}
%newobject operator >;
IplImage * operator > (CvArr * src){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmp(self, src, res, CV_CMP_GT);
return res;
}
IplImage * operator > (double val){
IplImage * res = cvCreateImage(cvGetSize(self), IPL_DEPTH_8U, 1);
cvCmpS(self, val, res, CV_CMP_GT);
return res;
}
%newobject operator *;
IplImage * operator * (double val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvScale(self, res, val);
return res;
}
IplImage * operator *= (double val){
cvScale(self, self, val);
return self;
}
%newobject operator /;
IplImage * operator / (double val){
IplImage * res = cvCreateImage(cvGetSize(self), self->depth, self->nChannels);
cvScale(self, res, 1.0/val);
return res;
}
IplImage * operator /= (double val){
cvScale(self, self, 1.0/val);
return self;
}
} /* extend IplImage */

127
interfaces/swig/general/cvmacros.i
View File

@ -1,127 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////////////////////////
// This file is automatically generated from the extract_macros.py script found in the 'utils'
// subdirectory of the OpenCV distribution. If the generated function prototypes are missing or
// incorrect, it is likely that a name->type mapping will have to be added to the script
/////////////////////////////////////////////////////////////////////////////////////////////////M*/
// This file was generated from the following header files:
// ../../../include/opencv/cxtypes.h
// ../../../include/opencv/cxcore.h
// ../../../include/opencv/cvtypes.h
// ../../../include/opencv/cv.h
void cvFree(void ** ptr);
void CV_READ_CHAIN_POINT(CvPoint _pt, CvChainPtReader reader);
void * CV_MAT_ELEM_PTR(CvMat mat,int row,int col);
void * CV_MAT_ELEM_PTR_FAST(CvMat mat,int row,int col,int pix_size);
void * CV_NODE_VAL(CvSparseMat* mat,CvSparseNode * node);
int * CV_NODE_IDX(CvSparseMat* mat,CvSparseNode * node);
CvQuadEdge2D* CV_SUBDIV2D_NEXT_EDGE(CvSubdiv2DEdge edge);
void CV_SWAP(int a,int b,int t);
int CV_IMIN(int a,int b);
int CV_IMAX(int a,int b);
int CV_IABS(int a);
void CV_CMP(int a,int b);
void CV_SIGN(int a);
void cvInvSqrt(double value);
void cvSqrt(double value);
int CV_IS_IMAGE_HDR(CvArr * img);
int CV_IS_IMAGE(CvArr * img);
int CV_MAT_DEPTH(int flags);
int CV_MAKETYPE(int depth,int cn);
int CV_8UC(int n);
int CV_8SC(int n);
int CV_16UC(int n);
int CV_16SC(int n);
int CV_32SC(int n);
int CV_32FC(int n);
int CV_64FC(int n);
int CV_MAT_CN(int flags);
int CV_MAT_TYPE(int flags);
int CV_IS_MAT_CONT(int flags);
int CV_IS_TEMP_MAT(int flags);
int CV_IS_MAT_HDR(CvMat* mat);
int CV_IS_MAT(CvMat* mat);
int CV_IS_MASK_ARR(CvMat* mat);
int CV_ARE_TYPES_EQ(CvMat* mat1,CvMat* mat2);
int CV_ARE_CNS_EQ(CvMat* mat1,CvMat* mat2);
int CV_ARE_DEPTHS_EQ(CvMat* mat1,CvMat* mat2);
int CV_ARE_SIZES_EQ(CvMat* mat1,CvMat* mat2);
int CV_IS_MAT_CONST(CvMat* mat);
int CV_ELEM_SIZE1(int type);
int CV_ELEM_SIZE(int type);
int CV_IS_MATND_HDR(CvMat* mat);
int CV_IS_MATND(CvMat* mat);
int CV_IS_SPARSE_MAT_HDR(CvMat* mat);
int CV_IS_SPARSE_MAT(CvMat* mat);
int CV_IS_HIST(CvHistogram * hist);
int CV_IS_UNIFORM_HIST(CvHistogram * hist);
int CV_IS_SPARSE_HIST(CvHistogram * hist);
int CV_HIST_HAS_RANGES(CvHistogram * hist);
int CV_IS_STORAGE(CvMemStorage * storage);
int CV_IS_SET_ELEM(void * ptr);
int CV_IS_SEQ(CvSeq* seq);
int CV_IS_SET(CvSet * set);
int CV_SEQ_ELTYPE(CvSeq* seq);
int CV_SEQ_KIND(CvSeq* seq);
int CV_IS_SEQ_INDEX(CvSeq* seq);
int CV_IS_SEQ_CURVE(CvSeq* seq);
int CV_IS_SEQ_CLOSED(CvSeq* seq);
int CV_IS_SEQ_CONVEX(CvSeq* seq);
int CV_IS_SEQ_HOLE(CvSeq* seq);
int CV_IS_SEQ_SIMPLE(CvSeq* seq);
int CV_IS_SEQ_POINT_SET(CvSeq* seq);
int CV_IS_SEQ_POINT_SUBSET(CvSeq* seq);
int CV_IS_SEQ_POLYLINE(CvSeq* seq);
int CV_IS_SEQ_POLYGON(CvSeq* seq);
int CV_IS_SEQ_CHAIN(CvSeq* seq);
int CV_IS_SEQ_CONTOUR(CvSeq* seq);
int CV_IS_SEQ_CHAIN_CONTOUR(CvSeq* seq);
int CV_IS_SEQ_POLYGON_TREE(CvSeq* seq);
int CV_IS_GRAPH(CvSeq* seq);
int CV_IS_GRAPH_ORIENTED(CvSeq* seq);
int CV_IS_SUBDIV2D(CvSeq* seq);
void CV_WRITE_SEQ_ELEM_VAR(void * elem_ptr,CvSeqWriter writer);
void CV_WRITE_SEQ_ELEM(CvPoint elem,CvSeqWriter writer);
void CV_NEXT_SEQ_ELEM(int elem_size,CvSeqReader reader);
void CV_PREV_SEQ_ELEM(int elem_size,CvSeqReader reader);
void CV_READ_SEQ_ELEM(CvPoint elem,CvSeqReader reader);
void CV_REV_READ_SEQ_ELEM(CvPoint elem,CvSeqReader reader);
CvPoint CV_CURRENT_POINT(CvSeqReader reader);
CvPoint CV_PREV_POINT(CvSeqReader reader);
void CV_READ_EDGE(CvPoint pt1,CvPoint pt2,CvSeqReader reader);
CvGraphEdge * CV_NEXT_GRAPH_EDGE(CvGraphEdge * edge,CvGraphVtx * vertex);
int CV_NODE_TYPE(int flags);
int CV_NODE_IS_INT(int flags);
int CV_NODE_IS_REAL(int flags);
int CV_NODE_IS_STRING(int flags);
int CV_NODE_IS_SEQ(int flags);
int CV_NODE_IS_MAP(int flags);
int CV_NODE_IS_COLLECTION(int flags);
int CV_NODE_IS_FLOW(int flags);
int CV_NODE_IS_EMPTY(int flags);
int CV_NODE_IS_USER(int flags);
int CV_NODE_HAS_NAME(int flags);
int CV_NODE_SEQ_IS_SIMPLE(CvSeq* seq);
void cvReshapeND(CvArr * arr,CvMat * header,int new_cn,int new_dims,int * new_sizes);
void cvConvert(CvArr * src,CvArr * dst);
void cvAXPY(CvArr * A,double real_scalar,CvArr * B,CvArr * C);
void cvAbs(CvArr * src,CvArr * dst);
void cvMatMulAdd(CvArr * src1,CvArr * src2,CvArr * src3,CvArr * dst);
void cvMatMul(CvArr * src1,CvArr * src2,CvArr * dst);
void cvGetGraphVtx(CvGraph * graph,int idx);
int cvGraphVtxIdx(CvGraph * graph,CvGraphVtx * vtx);
int cvGraphEdgeIdx(CvGraph * graph,CvGraphEdge * edge);
int cvGraphGetVtxCount(CvGraph * graph);
int cvGraphGetEdgeCount(CvGraph * graph);
int CV_IS_GRAPH_VERTEX_VISITED(CvGraphVtx * vtx);
int CV_IS_GRAPH_EDGE_VISITED(CvGraphEdge * edge);
CvScalar CV_RGB(double r,double g,int b);
void CV_NEXT_LINE_POINT(CvLineIterator line_iterator);
void CV_SET_IMAGE_IO_FUNCTIONS();
void CV_INIT_3X3_DELTAS(double * deltas,int step,int nch);
int CV_IS_HAAR_CLASSIFIER(void * haar);
double cvContourPerimeter(CvSeq * contour);
void cvCalcBackProject(IplImage * image,CvArr * dst,CvHistogram * hist);
void cvCalcBackProjectPatch(IplImage * image,CvArr * dst,CvSize range,CvHistogram * hist,int method,double factor);

168
interfaces/swig/general/doublepointers.i
View File

@ -1,168 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////////////////////////
// This file was automatically generated from the extract_doublepointers.py script found in the
// 'utils' subdirectory of the OpenCV distribution. Run it on the .cpp file generated by swig to
// generate the double pointer typemaps
/////////////////////////////////////////////////////////////////////////////////////////////////M*/
%typemap(in) CvGraphEdge ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvGraphVtx ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvHistogram ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvMatND ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvPoint ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvSeq ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvSeqBlock ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvSetElem ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvSubdiv2DPoint ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvConnectedComp_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvPoint2D32f_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvPoint_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvQuadEdge2D_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvRect_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvSeq_p_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvTupleTCvPoint_2_t_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) CvTypedSeqTCvTupleTfloat_2_t_t ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) _CvContourScanner ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) _IplImage ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) char ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) float ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) unsigned_char ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}
%typemap(in) void ** (void * vptr, $*1_ltype buffer) {
if ((SWIG_ConvertPtr($input, &vptr, $*1_descriptor, 1)) == -1){
SWIG_fail;
}
buffer = ($*1_ltype) vptr;
$1=&buffer;
}

236
interfaces/swig/general/extensions.i
View File

@ -1,236 +0,0 @@
/*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*/
// 2004-03-23, Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// 2008-05-15, Xavier Delacour <xavier.delacour@gmail.com>
struct CvLSH {};
%extend IplImage { ~IplImage () { IplImage * dummy = self; cvReleaseImage (& dummy); } }
%extend CvMat { ~CvMat () { CvMat * dummy = self; cvReleaseMat (& dummy); } }
%extend CvMatND { ~CvMatND () { CvMatND * dummy = self; cvReleaseMatND (& dummy); } }
%extend CvSparseMat { ~CvSparseMat () { CvSparseMat * dummy = self; cvReleaseSparseMat (& dummy); } }
%extend CvMemStorage { ~CvMemStorage () { CvMemStorage * dummy = self; cvReleaseMemStorage (& dummy); } }
%extend CvGraphScanner { ~CvGraphScanner () { CvGraphScanner * dummy = self; cvReleaseGraphScanner (& dummy); } }
%extend CvFileStorage { ~CvFileStorage () { CvFileStorage * dummy = self; cvReleaseFileStorage (& dummy); } }
%extend IplConvKernel { ~IplConvKernel () { IplConvKernel * dummy = self; cvReleaseStructuringElement (& dummy); } }
%extend CvKalman { ~CvKalman () { CvKalman * dummy = self; cvReleaseKalman (& dummy); } }
%extend CvHistogram { ~CvHistogram () { CvHistogram * dummy = self; cvReleaseHist (& dummy); } }
%extend CvHaarClassifierCascade { ~CvHaarClassifierCascade () { CvHaarClassifierCascade * dummy = self; cvReleaseHaarClassifierCascade (& dummy); } }
%extend CvPOSITObject { ~CvPOSITObject () { CvPOSITObject * dummy = self; cvReleasePOSITObject (& dummy); } }
%extend CvFeatureTree { ~CvFeatureTree () { CvFeatureTree * dummy = self; cvReleaseFeatureTree (& dummy); } }
%extend CvLSH { ~CvLSH () { CvLSH * dummy = self; cvReleaseLSH (& dummy); } }
// string operators for some OpenCV types
%extend CvScalar
{
const char * __str__(){
static char str[256];
snprintf(str, 256, "[%f, %f, %f, %f]", self->val[0], self->val[1], self->val[2], self->val[3]);
return str;
}
const char * __repr__(){
static char str[256];
snprintf(str, 256, "cvScalar(%f, %f, %f, %f)", self->val[0], self->val[1], self->val[2], self->val[3]);
return str;
}
const double __getitem__ (int index) {
if (index >= 4) {
#ifdef defined(SWIGPYTHON)
PyErr_SetString (PyExc_IndexError, "indice must be lower than 4");
#elif defined(SWIGOCTAVE)
error("indice must be lower than 4");
#endif
return 0;
}
if (index < -4) {
#ifdef defined(SWIGPYTHON)
PyErr_SetString (PyExc_IndexError, "indice must be bigger or egal to -4");
#elif defined(SWIGOCTAVE)
error("indice must be bigger or egal to -4");
#endif
return 0;
}
if (index < 0) {
/* negative index means from the end in python */
index = 4 - index;
}
return self->val [index];
}
void __setitem__ (int index, double value) {
if (index >= 4) {
#ifdef defined(SWIGPYTHON)
PyErr_SetString (PyExc_IndexError, "indice must be lower than 4");
#elif defined(SWIGOCTAVE)
error("indice must be lower than 4");
#endif
return;
}
if (index < -4) {
#ifdef defined(SWIGPYTHON)
PyErr_SetString (PyExc_IndexError, "indice must be bigger or egal to -4");
#elif defined(SWIGOCTAVE)
error("indice must be bigger or egal to -4");
#endif
return;
}
if (index < 0) {
/* negative index means from the end in python */
index = 4 - index;
}
self->val [index] = value;
}
};
%extend CvPoint2D32f
{
const char * __str__(){
static char str[64];
snprintf(str, 64, "[%f %f]", self->x, self->y);
return str;
}
const char * __repr__(){
static char str[64];
snprintf(str, 64, "cvPoint2D32f(%f,%f)", self->x, self->y);
return str;
}
};
%extend CvPoint
{
const char * __str__(){
static char str[64];
snprintf(str, 64, "[%d %d]", self->x, self->y);
return str;
}
const char * __repr__(){
static char str[64];
snprintf(str, 64, "cvPoint(%d,%d)", self->x, self->y);
return str;
}
};
// Set up CvMat to emulate IplImage fields
%{
int CvMat_cols_get(CvMat * m){
return m->cols;
}
void CvMat_cols_set(CvMat * m, int cols){
m->cols = cols;
}
int CvMat_rows_get(CvMat *m){
return m->rows;
}
void CvMat_rows_set(CvMat *m, int rows){
m->rows = rows;
}
int CvMat_width_get(CvMat * m){
return m->cols;
}
void CvMat_width_set(CvMat * m, int width){
m->cols = width;
}
int CvMat_height_get(CvMat *m){
return m->rows;
}
void CvMat_height_set(CvMat * m, int height){
m->rows = height;
}
int CvMat_depth_get(CvMat * m){
return cvIplDepth(m->type);
}
void CvMat_depth_set(CvMat *m, int depth){
cvError(CV_StsNotImplemented, "CvMat_depth_set", "Not Implemented", __FILE__, __LINE__);
}
int CvMat_nChannels_get(CvMat * m){
return CV_MAT_CN(m->type);
}
void CvMat_nChannels_set(CvMat *m, int nChannels){
int depth = CV_MAT_DEPTH(m->type);
m->type = CV_MAKETYPE(depth, nChannels);
}
int CvMat_origin_get(CvMat * m){
/* Always 0 - top-left origin */
return 0;
}
void CvMat_origin_set(CvMat * m, int origin){
cvError(CV_StsNotImplemented, "CvMat_origin_get", "IplImage is replaced by CvMat in Python, so its fields are read-only", __FILE__, __LINE__);
}
int CvMat_dataOrder_get(CvMat * m){
cvError(CV_StsNotImplemented, "CvMat_dataOrder_get", "Not Implemented", __FILE__, __LINE__);
return 0;
}
void CvMat_dataOrder_set(CvMat * m, int dataOrder){
cvError(CV_StsNotImplemented, "CvMat_dataOrder_get", "IplImage is replaced by CvMat in Python, so its fields are read-only", __FILE__, __LINE__);
}
int CvMat_imageSize_get(CvMat * m){
int step = m->step ? m->step : CV_ELEM_SIZE(m->type) * m->cols;
return step*m->rows;
}
void CvMat_imageSize_set(CvMat * m, int imageSize){
cvError(CV_StsNotImplemented, "CvMat_imageSize_set", "IplImage is not implemented in Python, so origin is read-only", __FILE__, __LINE__);
}
int CvMat_widthStep_get(CvMat * m){
return m->step;
}
void CvMat_widthStep_set(CvMat *m, int widthStep){
m->step = widthStep;
}
%}
%extend CvMat
{
int depth;
int nChannels;
int dataOrder;
int origin;
int width;
int height;
int imageSize;
int widthStep;
// swig doesn't like the embedded union in CvMat, so re-add these
int rows;
int cols;
};

91
interfaces/swig/general/highgui.i
View File

@ -1,91 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
%module(package="opencv") highgui
%{
#include "highgui.h"
%}
%import "./cv.i"
%include "./memory.i"
%include "./typemaps.i"
%newobject cvLoadImage;
%newobject cvLoadImageM;
%newobject cvLoadImageMat;
%nodefault CvCapture;
%newobject cvCaptureFromFile;
%newobject cvCaptureFromCAM;
%nodefault CvVideoWriter;
%newobject cvCreateVideoWriter;
/** modify the following to return CvMat instead of IplImage */
%ignore cvLoadImage;
%rename (cvLoadImage) cvLoadImageMat;
%inline %{
CvMat * cvLoadImageMat(const char* filename, int iscolor=CV_LOAD_IMAGE_COLOR ){
return cvLoadImageM(filename, iscolor);
}
%}
%typemap_out_CvMat(cvRetrieveFrame, ( CvCapture* capture ), (capture));
%typemap_out_CvMat(cvQueryFrame, ( CvCapture * capture ), (capture));
%include "highgui.h"
struct CvCapture {
};
struct CvVideoWriter {
};
%extend CvCapture { ~CvCapture () { CvCapture * dummy = self; cvReleaseCapture (& dummy); } }
%extend CvVideoWriter { ~CvVideoWriter () { CvVideoWriter * dummy = self; cvReleaseVideoWriter (& dummy); } }

170
interfaces/swig/general/memory.i
View File

@ -1,170 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// 2008-05-15, Xavier Delacour <xavier.delacour@gmail.com>
/****************************************************************************************\
* Array allocation, deallocation, initialization and access to elements *
\****************************************************************************************/
%nodefault _IplImage;
%newobject cvCreateImage;
%newobject cvCreateImageMat;
%newobject cvCreateImageHeader;
%newobject cvCloneImage;
%newobject cvCloneImageMat;
%nodefault CvMat;
%newobject cvCreateMat;
%newobject cvCreateMatHeader;
%newobject cvCloneMat;
%newobject cvGetSubRect;
%newobject cvGetRow;
%newobject cvGetRows;
%newobject cvGetCol;
%newobject cvGetCols;
%newobject cvGetDiag;
%nodefault CvMatND;
%newobject cvCreateMatND;
%newobject cvCreateMatHeaderND;
%newobject cvCloneMatND;
%nodefault CvSparseMat;
%newobject cvCreateSparseMat;
%newobject cvCloneSparseMat;
/****************************************************************************************\
* Dynamic data structures *
\****************************************************************************************/
%nodefault CvMemStorage;
%newobject cvCreateMemStorage;
%newobject cvCreateChildMemStorage;
%nodefault CvGraphScanner;
%newobject cvCreateGraphScanner;
/****************************************************************************************\
* Data Persistence *
\****************************************************************************************/
%nodefault CvFileStorage;
%newobject cvOpenFileStorage;
/// cv.h
/****************************************************************************************\
* Image Processing *
\****************************************************************************************/
%nodefault _IplConvKernel;
%newobject cvCreateStructuringElement;
/****************************************************************************************\
* Structural Analysis *
\****************************************************************************************/
%newobject cvFitEllipse2;
/****************************************************************************************\
* Tracking *
\****************************************************************************************/
%nodefault CvKalman;
%newobject cvCreateKalman;
/****************************************************************************************\
* Histogram functions *
\****************************************************************************************/
%nodefault CvHistogram;
%newobject cvCreateHist;
/****************************************************************************************\
* Haar-like Object Detection functions *
\****************************************************************************************/
%nodefault CvHaarClassifierCascade;
%newobject cvLoadHaarClassifierCascade;
%nodefault CvPOSITObject;
%newobject cvCreatePOSITObject;
%nodefault CvFeatureTree;
%newobject cvCreateFeatureTree;
%nodefault CvLSH;
%newobject cvCreateLSH;
%newobject cvCreateMemoryLSH;
/// This hides all members of the IplImage which OpenCV doesn't use.
%ignore _IplImage::nSize;
%ignore _IplImage::alphaChannel;
%ignore _IplImage::colorModel;
%ignore _IplImage::channelSeq;
%ignore _IplImage::maskROI;
%ignore _IplImage::imageId;
%ignore _IplImage::tileInfo;
%ignore _IplImage::BorderMode;
%ignore _IplImage::BorderConst;
%ignore _IplImage::imageDataOrigin;
/**
* imageData is hidden because the accessors produced by SWIG are not
* working correct. Use imageData_set and imageData_get instead
* (they are defined in "imagedata.i")
*/
%ignore _IplImage::imageData;

7
interfaces/swig/general/sizeof.i
View File

@ -1,7 +0,0 @@
/* wrappers to be able to use cv.sizeof_XXX instead of size () */
%include "cmalloc.i"
%sizeof (CvContour)
%sizeof (CvPoint)
%sizeof (CvSeq)

118
interfaces/swig/general/typemaps.i
View File

@ -1,118 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
/**
* We set our own error handling function using cvRedirectError.
* (See also error.h)
* This function throws an error (OpenCV itself never throws) which
* we catch here. The error handling function (SendErrorToPython)
* sets the Python error.
* We need to return 0 here instead of an PyObject to tell Python
* that an error has occured.
*/
%exception
{
try { $action }
catch (...)
{
SWIG_fail;
}
}
/* include exception.i, so we can generate exceptions when we found errors */
%include "exception.i"
%include "sizeof.i"
/**
* IplImage has no reference counting of underlying data, which creates problems with double
* frees after accessing subarrays in python -- instead, replace IplImage with CvMat, which
* should be functionally equivalent, but has reference counting.
* The potential shortcomings of this method are
* 1. no ROI
* 2. IplImage fields missing or named something else.
*/
%typemap(in) IplImage * (IplImage header){
void * vptr;
int res = SWIG_ConvertPtr($input, (&vptr), $descriptor( CvMat * ), 0);
if ( res == -1 ){
SWIG_exception( SWIG_TypeError, "%%typemap(in) IplImage * : could not convert to CvMat");
SWIG_fail;
}
$1 = cvGetImage((CvMat *)vptr, &header);
}
/** For IplImage * return type, there are cases in which the memory should be freed and
* some not. To avoid leaks and segfaults, deprecate this return type and handle cases
* individually
*/
%typemap(out) IplImage * {
SWIG_exception( SWIG_TypeError, "IplImage * return type is deprecated. Please file a bug report at www.sourceforge.net/opencvlibrary if you see this error message.");
SWIG_fail;
}
/** macro to convert IplImage return type to CvMat. Note that this is only covers the case
* where the returned IplImage need not be freed. If the IplImage header needs to be freed,
* then CvMat must take ownership of underlying data. Instead, just handle these limited cases
* with CvMat equivalent.
*/
%define %typemap_out_CvMat(func, decl, call)
%rename (func##__Deprecated) func;
%rename (func) func##__CvMat;
%inline %{
CvMat * func##__CvMat##decl{
IplImage * im = func##call;
if(im){
CvMat * mat = (CvMat *)cvAlloc(sizeof(CvMat));
mat = cvGetMat(im, mat);
return mat;
}
return false;
}
%}
%enddef

1
interfaces/swig/octave/CMakeLists.txt
View File

@ -1 +0,0 @@

36
interfaces/swig/octave/COPYING
View File

@ -1,36 +0,0 @@
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, 2001, 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.

12
interfaces/swig/octave/DESCRIPTION
View File

@ -1,12 +0,0 @@
Name: opencv
Version: 1.0
Date: 2008-03-15
Author: Various Authors
Maintainer: Xavier Delacour
Title: OpenCV (Open Computer Vision Library) bindings
Description: Bindings for OpenCV, a collection of over 500 functions implementing computer vision, image processing and general-purpose numeric algorithms. The library is compatible with IPL and utilizes Intel Integrated Performance Primitives for better performance. More info at http://sourceforge.net/projects/opencvlibrary.
Depends: octave (>= 2.9.12)
Autoload: yes
SystemRequirements: swig, libcv-dev, libcvaux-dev, libhighgui-dev
License: BSD
Url: http://octave.sf.net

1
interfaces/swig/octave/INDEX
View File

@ -1 +0,0 @@
see the online documentation

178
interfaces/swig/octave/PKG_ADD_template
View File

@ -1,178 +0,0 @@
cv;
ml;
highgui;
IPL_ALIGN_DWORD=IPL_ALIGN_4BYTES;
IPL_ALIGN_QWORD=IPL_ALIGN_8BYTES;
CV_GRAPH=CV_SEQ_KIND_GRAPH;
CV_HIST_TREE=CV_HIST_SPARSE;
CV_TERMCRIT_NUMBER=CV_TERMCRIT_ITER;
CV_SEQ_ELTYPE_PTR=CV_USRTYPE1;
CV_SEQ_CONTOUR=CV_SEQ_POLYGON;
CV_STORAGE_WRITE_TEXT=CV_STORAGE_WRITE;
CV_STORAGE_WRITE_BINARY=CV_STORAGE_WRITE;
CV_NODE_INTEGER=CV_NODE_INT;
CV_NODE_FLOAT=CV_NODE_REAL;
CV_NODE_STRING=CV_NODE_STR;
CV_DXT_INVERSE_SCALE=CV_DXT_INV_SCALE;
CV_RGB2RGBA=CV_BGR2BGRA;
CV_FONT_VECTOR0=CV_FONT_HERSHEY_SIMPLEX;
CV_RGBA2RGB=CV_BGRA2BGR;
CV_RGB2BGRA=CV_BGR2RGBA;
CV_BGRA2RGB=CV_RGBA2BGR;
CV_RGB2BGR=CV_BGR2RGB;
CV_RGBA2BGRA=CV_BGRA2RGBA;
CV_GRAY2RGB=CV_GRAY2BGR;
CV_GRAY2RGBA=CV_GRAY2BGRA;
CV_BayerBG2RGB=CV_BayerRG2BGR;
CV_BayerGB2RGB=CV_BayerGR2BGR;
CV_BayerRG2RGB=CV_BayerBG2BGR;
CV_BayerGR2RGB=CV_BayerGB2BGR;
CV_MAKE_TYPE=@CV_MAKETYPE;
CV_IS_CONT_MAT=@CV_IS_MAT_CONT;
cvGetSubArr=@cvGetSubRect;
cvZero=@cvSetZero;
cvCvtScale=@cvConvertScale;
cvScale=@cvConvertScale;
cvCvtScaleAbs=@cvConvertScaleAbs;
cvCheckArray=@cvCheckArr;
cvMatMulAddEx=@cvGEMM;
cvMatMulAddS=@cvTransform;
cvT=@cvTranspose;
cvMirror=@cvFlip;
cvInv=@cvInvert;
cvMahalonobis=@cvMahalanobis;
cvFFT=@cvDFT;
cvGraphFindEdge=@cvFindGraphEdge;
cvGraphFindEdgeByPtr=@cvFindGraphEdgeByPtr;
cvDrawRect=@cvRectangle;
cvDrawLine=@cvLine;
cvDrawCircle=@cvCircle;
cvDrawEllipse=@cvEllipse;
cvDrawPolyLine=@cvPolyLine;
cvCalcHist=@cvCalcArrHist;
## use subsasgn/assign, combine with above
## or expose octave_swig_type install_global etc
cv.CV_MAKE_TYPE=@CV_MAKETYPE;
cv.CV_IS_CONT_MAT=@CV_IS_MAT_CONT;
cv.cvGetSubArr=@cvGetSubRect;
cv.cvZero=@cvSetZero;
cv.cvCvtScale=@cvConvertScale;
cv.cvScale=@cvConvertScale;
cv.cvCvtScaleAbs=@cvConvertScaleAbs;
cv.cvCheckArray=@cvCheckArr;
cv.cvMatMulAddEx=@cvGEMM;
cv.cvMatMulAddS=@cvTransform;
cv.cvT=@cvTranspose;
cv.cvMirror=@cvFlip;
cv.cvInv=@cvInvert;
cv.cvMahalonobis=@cvMahalanobis;
cv.cvFFT=@cvDFT;
cv.cvGraphFindEdge=@cvFindGraphEdge;
cv.cvGraphFindEdgeByPtr=@cvFindGraphEdgeByPtr;
cv.cvDrawRect=@cvRectangle;
cv.cvDrawLine=@cvLine;
cv.cvDrawCircle=@cvCircle;
cv.cvDrawEllipse=@cvEllipse;
cv.cvDrawPolyLine=@cvPolyLine;
cv.cvCalcHist=@cvCalcArrHist;
## add %octavecode support, or use subsref
function [count,seq] = cvFindContours(varargin)
global cv;
[count, seq] = cv.cvFindContoursUntyped( varargin{:} );
if (swig_this(seq))
seq = cv.CvSeq_CvPoint.cast(seq);
endif
endfunction
cv.cvFindContours=@cvFindContours;
function [count,seq] = cvHoughCircles(varargin)
global cv;
[count, seq] = cv.cvHoughCirclesUntyped( varargin{:} );
if (swig_this(seq))
seq = cv.CvSeq_float_3.cast(seq);
endif
endfunction
cv.cvHoughCircles=@cvHoughCircles;
function [count,seq] = cvPyrSegmentation(varargin)
global cv;
[count, seq] = cv.cvPyrSegmentationUntyped( varargin{:} );
if (swig_this(seq))
seq = cv.CvSeq_CvConnectedComp.cast(seq);
endif
endfunction
cv.cvPyrSegmentation=@cvPyrSegmentation;
function [count,seq] = cvApproxChains(varargin)
global cv;
[count, seq] = cv.cvApproxChainsUntyped( varargin{:} );
if (swig_this(seq))
seq = cv.CvSeq_CvPoint.cast(seq);
endif
endfunction
cv.cvApproxChains=@cvApproxChains;
function [count,seq] = cvContourFromContourTree(varargin)
global cv;
[count, seq] = cv.cvContourFromContourTreeUntyped( varargin{:} );
if (swig_this(seq))
seq = cv.CvSeq_CvPoint.cast(seq);
endif
endfunction
cv.cvContourFromContourTree=@cvContourFromContourTree;
function [count,seq] = cvConvexityDefects(varargin)
global cv;
[count, seq] = cv.cvConvexityDefectsUntyped( varargin{:} );
if (swig_this(seq))
seq = cv.CvSeq_CvConvexityDefect.cast(seq);
endif
endfunction
cv.cvConvexityDefects=@cvConvexityDefects;
function seq = cvHoughLines2(varargin)
global cv;
seq = cv.cvHoughLinesUntyped( varargin{:} );
if (swig_this(seq))
seq = cv.CvSeq_CvPoint.cast(seq);
t = CV_SEQ_ELTYPE(seq)
if (t == cv.CV_32SC4)
seq = cv.CvSeq_CvPoint_2.cast(seq)
else
seq = cv.CvSeq_float_2.cast(seq)
endif
endif
endfunction
cv.cvHoughLines2=@cvHoughLines2;
function c = CvSeq_map(self)
c = cell(1, self.total);
for i = 1:self.total, c{i} = self{i}; end;
endfunction
cv.CvSeq_map=@CvSeq_map;
function c = CvSeq_hrange(self)
c = {};
i = 0;
if swig_this(self)
s = self;
while swig_this(s.h_next), s = s.cast(s.h_next); c{++i} = s; end;
endif
endfunction
cv.CvSeq_hrange=@CvSeq_hrange;
function c = CvSeq_vrange(self)
c = {};
i = 0;
if swig_this(self)
s = self;
while swig_this(s.v_next), s = s.cast(s.v_next); c{++i} = s; end;
endif
endfunction
cv.CvSeq_vrange=@CvSeq_vrange;

452
interfaces/swig/octave/adapters.i
View File

@ -1,452 +0,0 @@
/*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*/
// 2008-04-07, Xavier Delacour <xavier.delacour@gmail.com>
// The trouble here is that Octave arrays are in Fortran order, while OpenCV
// arrays are in C order. Neither Octave nor OpenCV seem to provide n-dim
// transpose, so we do that here.
// For images, we also scale the result to lie within [0-1].
// * add support for sparse matrices
// * add support for complex matrices
// * add support for roi and coi, or complain if either is set
// * test case for channel==1
// * test case for channel=={2,3,4}
// * test case for 2 dim, 1 dim, n dim cases
%{
class ndim_iterator {
int nd;
int dims[CV_MAX_DIM];
int step[CV_MAX_DIM];
int curr[CV_MAX_DIM];
uchar* _data;
int _type;
bool done;
public:
ndim_iterator() {}
ndim_iterator(CvMat* m) {
int c = CV_MAT_CN(m->type);
int elem_size = CV_ELEM_SIZE1(m->type);
nd = c == 1 ? 2 : 3;
dims[0] = m->rows;
dims[1] = m->cols;
dims[2] = c;
step[0] = m->step;
step[1] = c * elem_size;
step[2] = elem_size;
curr[0] = curr[1] = curr[2] = 0;
_data = m->data.ptr;
_type = m->type;
done = false;
}
ndim_iterator(CvMatND* m) {
int c = CV_MAT_CN(m->type);
int elem_size = CV_ELEM_SIZE1(m->type);
nd = m->dims + (c == 1 ? 0 : 1);
for (int j = 0; j < m->dims; ++j) {
dims[j] = m->dim[j].size;
step[j] = m->dim[j].step;
curr[j] = 0;
}
if (c > 1) {
dims[m->dims] = c;
step[m->dims] = elem_size;
curr[m->dims] = 0;
}
_data = m->data.ptr;
_type = m->type;
done = false;
}
ndim_iterator(IplImage* img) {
nd = img->nChannels == 1 ? 2 : 3;
dims[0] = img->height;
dims[1] = img->width;
dims[2] = img->nChannels;
switch (img->depth) {
case IPL_DEPTH_8U: _type = CV_8U; break;
case IPL_DEPTH_8S: _type = CV_8S; break;
case IPL_DEPTH_16U: _type = CV_16U; break;
case IPL_DEPTH_16S: _type = CV_16S; break;
case IPL_DEPTH_32S: _type = CV_32S; break;
case IPL_DEPTH_32F: _type = CV_32F; break;
case IPL_DEPTH_1U: _type = CV_64F; break;
default:
error("unsupported image depth");
return;
}
int elem_size = CV_ELEM_SIZE1(_type);
step[0] = img->widthStep;
step[1] = img->nChannels * elem_size;
step[2] = elem_size;
curr[0] = curr[1] = curr[2] = 0;
_data = (uchar*)img->imageData;
done = false;
}
ndim_iterator(NDArray& nda) {
dim_vector d(nda.dims());
nd = d.length();
int last_step = sizeof(double);
for (int j = 0; j < d.length(); ++j) {
dims[j] = d(j);
step[j] = last_step;
last_step *= dims[j];
curr[j] = 0;
}
_data = (uchar*)const_cast<double*>(nda.data());
_type = CV_64F;
done = false;
}
operator bool () const {
return !done;
}
uchar* data() {
return _data;
}
int type() const {
return _type;
}
ndim_iterator& operator++ () {
int curr_dim = 0;
for (;;) {
_data += step[curr_dim];
if (++curr[curr_dim] < dims[curr_dim])
break;
curr[curr_dim] = 0;
_data -= step[curr_dim] * dims[curr_dim];
++curr_dim;
if (curr_dim == nd) {
done = true;
break;
}
}
return *this;
}
};
template <class T1, class T2>
void transpose_copy_typed(ndim_iterator src_it, ndim_iterator dst_it,
double scale) {
assert(sizeof(T1) == CV_ELEM_SIZE1(src_it.type()));
assert(sizeof(T2) == CV_ELEM_SIZE1(dst_it.type()));
if (scale == 1) {
while (src_it) {
*(T2*)dst_it.data() = (T2)*(T1*)src_it.data();
++src_it;
++dst_it;
}
} else {
while (src_it) {
*(T2*)dst_it.data() = (T2)(scale * (*(T1*)src_it.data()));
++src_it;
++dst_it;
}
}
}
template <class T1>
void transpose_copy2(ndim_iterator src_it, ndim_iterator dst_it,
double scale) {
switch (CV_MAT_DEPTH(dst_it.type())) {
case CV_8U: transpose_copy_typed<T1,unsigned char>(src_it,dst_it,scale); break;
case CV_8S: transpose_copy_typed<T1,signed char>(src_it,dst_it,scale); break;
case CV_16U: transpose_copy_typed<T1,unsigned short>(src_it,dst_it,scale); break;
case CV_16S: transpose_copy_typed<T1,signed short>(src_it,dst_it,scale); break;
case CV_32S: transpose_copy_typed<T1,signed int>(src_it,dst_it,scale); break;
case CV_32F: transpose_copy_typed<T1,float>(src_it,dst_it,scale); break;
case CV_64F: transpose_copy_typed<T1,double>(src_it,dst_it,scale); break;
default:
error("unsupported dest array type (supported types are CV_8U, CV_8S, "
"CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)");
}
}
void transpose_copy(ndim_iterator src_it, ndim_iterator dst_it,
double scale = 1) {
switch (CV_MAT_DEPTH(src_it.type())) {
case CV_8U: transpose_copy2<unsigned char>(src_it,dst_it,scale); break;
case CV_8S: transpose_copy2<signed char>(src_it,dst_it,scale); break;
case CV_16U: transpose_copy2<unsigned short>(src_it,dst_it,scale); break;
case CV_16S: transpose_copy2<signed short>(src_it,dst_it,scale); break;
case CV_32S: transpose_copy2<signed int>(src_it,dst_it,scale); break;
case CV_32F: transpose_copy2<float>(src_it,dst_it,scale); break;
case CV_64F: transpose_copy2<double>(src_it,dst_it,scale); break;
default:
error("unsupported source array type (supported types are CV_8U, CV_8S, "
"CV_16U, CV_16S, CV_32S, CV_32F, CV_64F)");
}
}
octave_value cv2mat(CvArr* arr) {
dim_vector d;
NDArray nda;
if (CV_IS_MAT(arr)) {
// m x n x c
CvMat* m = (CvMat*)arr;
int c = CV_MAT_CN(m->type);
if (c == 1) {
d.resize(2);
d(0) = m->rows;
d(1) = m->cols;
} else {
d.resize(3);
d(0) = m->rows;
d(1) = m->cols;
d(2) = c;
}
nda = NDArray(d);
transpose_copy(m, nda);
}
else if (CV_IS_MATND(arr)) {
// m1 x m2 x ... x mn x c
CvMatND* m = (CvMatND*)arr;
int c = CV_MAT_CN(m->type);
if (c == 1) {
d.resize(m->dims);
for (int j = 0; j < m->dims; ++j)
d(j) = m->dim[j].size;
} else {
d.resize(m->dims + 1);
for (int j = 0; j < m->dims; ++j)
d(j) = m->dim[j].size;
d(m->dims) = c;
}
nda = NDArray(d);
transpose_copy(m, nda);
}
else if (CV_IS_IMAGE(arr)) {
// m x n x c
IplImage* img = (IplImage*)arr;
if (img->nChannels == 1) {
d.resize(2);
d(0) = img->height;
d(1) = img->width;
} else {
d.resize(3);
d(0) = img->height;
d(1) = img->width;
d(2) = img->nChannels;
}
nda = NDArray(d);
transpose_copy(img, nda);
}
else {
error("unsupported array type (supported types are CvMat, CvMatND, IplImage)");
return octave_value();
}
return nda;
}
octave_value mat2cv(const octave_value& ov, int type) {
NDArray nda(ov.array_value());
if (error_state)
return 0;
dim_vector d = ov.dims();
assert(d.length() > 0);
int nd = d.length();
int last_dim = d(d.length() - 1);
int c = CV_MAT_CN(type);
if (c != 1 && c != last_dim) {
error("last dimension and channel must agree, or channel must equal one");
return 0;
}
if (c > 1)
--nd;
if (nd == 2) {
CvMat *m = cvCreateMat(d(0), d(1), type);
transpose_copy(nda, m);
return SWIG_NewPointerObj(m, SWIGTYPE_p_CvMat, SWIG_POINTER_OWN);
}
else {
int tmp[CV_MAX_DIM];
for (int j = 0; j < nd; ++j)
tmp[j] = d(j);
CvMatND *m = cvCreateMatND(nd, tmp, type);
transpose_copy(nda, m);
return SWIG_NewPointerObj(m, SWIGTYPE_p_CvMatND, SWIG_POINTER_OWN);
}
}
octave_value cv2im(CvArr* arr) {
if (!CV_IS_IMAGE(arr) && !CV_IS_MAT(arr)) {
error("input is not an OpenCV image or 2D matrix");
return octave_value();
}
dim_vector d;
NDArray nda;
if (CV_IS_MAT(arr)) {
// m x n x c
CvMat* m = (CvMat*)arr;
int c = CV_MAT_CN(m->type);
if (c == 1) {
d.resize(2);
d(0) = m->rows;
d(1) = m->cols;
} else {
d.resize(3);
d(0) = m->rows;
d(1) = m->cols;
d(2) = c;
}
nda = NDArray(d);
transpose_copy(m, nda, 1/256.0);
}
else if (CV_IS_IMAGE(arr)) {
// m x n x c
IplImage* img = (IplImage*)arr;
if (img->nChannels == 1) {
d.resize(2);
d(0) = img->height;
d(1) = img->width;
} else {
d.resize(3);
d(0) = img->height;
d(1) = img->width;
d(2) = img->nChannels;
}
nda = NDArray(d);
transpose_copy(img, nda, 1/256.0);
}
return nda;
}
CvMat* im2cv(const octave_value& ov, int depth) {
NDArray nda(ov.array_value());
if (error_state)
return 0;
dim_vector d = ov.dims();
assert(d.length() > 0);
if (d.length() != 2 && d.length() != 3 &&
!(d.length() == 3 && d(2) <= 4)) {
error("input must be m x n or m x n x c matrix, where 1<=c<=4");
return 0;
}
int channels = d.length() == 2 ? 1 : d(2);
int type = CV_MAKETYPE(depth, channels);
CvMat *m = cvCreateMat(d(0), d(1), type);
transpose_copy(nda, m, 256);
return m;
}
%}
%newobject im2cv;
%feature("autodoc", 0) cv2mat;
%feature("autodoc", 0) mat2cv;
%feature("autodoc", 0) cv2im;
%feature("autodoc", 0) im2cv;
%docstring cv2mat {
@deftypefn {Loadable Function} @var{m1} = cv2mat (@var{m2})
Convert the CvMat, CvMatND, or IplImage @var{m2} into an Octave real matrix @var{m1}.
The dimensions @var{m1} are those of @var{m2}, plus an addition dimension
if @var{m2} has more than one channel.
@end deftypefn
}
%docstring mat2cv {
@deftypefn {Loadable Function} @var{m1} = mat2cv (@var{m2}, @var{type})
Convert the Octave array @var{m2} into either a CvMat or a CvMatND of type
@var{type}.
@var{type} is one of CV_8UC(n), CV_8SC(n), CV_16UC(n), CV_16SC(n), CV_32SC(n),
CV_32FC(n), CV_64FC(n), where n indicates channel and is between 1 and 4.
If the dimension of @var{m2} is equal to 2 (not counting channels),
a CvMat is returned. Otherwise, a CvMatND is returned.
@end deftypefn
}
%docstring cv2im {
@deftypefn {Loadable Function} @var{im} = cv2im (@var{I})
Convert the OpenCV image or 2D matrix @var{I} into an Octave image @var{im}.
@var{im} is a real matrix of dimension height x width or
height x width x channels, with values within the interval [0,1]).
@end deftypefn
}
%docstring im2cv {
@deftypefn {Loadable Function} @var{I} = im2cv (@var{im}, @var{depth})
Convert the Octave image @var{im} into the OpenCV image @var{I} of depth
@var{depth}.
@var{im} is a real matrix of dimension height x width or
height x width x channels, with values within the interval [0,1].
@var{depth} must be one of CV_8U, CV_8S, CV_16U, CV_16S, CV_32S, CV_32F, CV_64F.
@end deftypefn
}
octave_value cv2mat(CvArr* arr);
octave_value mat2cv(const octave_value& ov, int type);
octave_value cv2im(CvArr* arr);
CvMat* im2cv(const octave_value& ov, int depth);

87
interfaces/swig/octave/cv.i
View File

@ -1,87 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// 2008-04-03, Xavier Delacour <xavier.delacour@gmail.com>
// todo remove these..
#pragma SWIG nowarn=312,362,303,365,366,367,368,370,371,372,451,454,503
%{
#include "octhelpers.h"
#include "octcvseq.hpp"
#include "octerror.h"
%}
// direct SWIG to generate octave docstrings
%feature("autodoc", 1);
// include octave-specific files
%include "./octtypemaps.i"
%include "./cvshadow.i"
// parse OpenCV headers
%include "../general/cv.i"
// Accessors for the CvMat and IplImage data structure are defined here
%include "./cvarr.i"
// Octave sequence compatibility for CvSeq
%include "./cvseq.i"
%include "./imagedata.i"
// include some wrappers to manipulate CvSeq types
%include "./octcvseq.hpp"
// aliases from #defines
%include "./cvaliases.i"
%insert(init) %{
cvRedirectError(function_ptr_generator(), void_ptr_generator(), void_ptrptr_generator());
%}

106279
interfaces/swig/octave/cv_wrap.cpp
View File

File diff suppressed because it is too large Load Diff

53
interfaces/swig/octave/cvaliases.i
View File

@ -1,53 +0,0 @@
/*
%module cv
%pythoncode %{
IPL_ALIGN_DWORD=IPL_ALIGN_4BYTES
IPL_ALIGN_QWORD=IPL_ALIGN_8BYTES
CV_MAKE_TYPE=CV_MAKETYPE
CV_IS_CONT_MAT=CV_IS_MAT_CONT
CV_HIST_TREE=CV_HIST_SPARSE
CV_TERMCRIT_NUMBER=CV_TERMCRIT_ITER
CV_SEQ_ELTYPE_PTR=CV_USRTYPE1
CV_GRAPH=CV_SEQ_KIND_GRAPH
CV_SEQ_CONTOUR=CV_SEQ_POLYGON
CV_STORAGE_WRITE_TEXT=CV_STORAGE_WRITE
CV_STORAGE_WRITE_BINARY=CV_STORAGE_WRITE
CV_NODE_INTEGER=CV_NODE_INT
CV_NODE_FLOAT=CV_NODE_REAL
CV_NODE_STRING=CV_NODE_STR
cvGetSubArr=cvGetSubRect
cvZero=cvSetZero
cvCvtScale=cvConvertScale
cvScale=cvConvertScale
cvCvtScaleAbs=cvConvertScaleAbs
cvCheckArray=cvCheckArr
cvMatMulAddEx=cvGEMM
cvMatMulAddS=cvTransform
cvT=cvTranspose
cvMirror=cvFlip
cvInv=cvInvert
cvMahalonobis=cvMahalanobis
CV_DXT_INVERSE_SCALE=CV_DXT_INV_SCALE
cvFFT=cvDFT
cvGraphFindEdge=cvFindGraphEdge
cvGraphFindEdgeByPtr=cvFindGraphEdgeByPtr
cvDrawRect=cvRectangle
cvDrawLine=cvLine
cvDrawCircle=cvCircle
cvDrawEllipse=cvEllipse
cvDrawPolyLine=cvPolyLine
CV_FONT_VECTOR0=CV_FONT_HERSHEY_SIMPLEX
CV_RGB2RGBA=CV_BGR2BGRA
CV_RGBA2RGB=CV_BGRA2BGR
CV_RGB2BGRA=CV_BGR2RGBA
CV_BGRA2RGB=CV_RGBA2BGR
CV_RGB2BGR=CV_BGR2RGB
CV_RGBA2BGRA=CV_BGRA2RGBA
CV_GRAY2RGB=CV_GRAY2BGR
CV_GRAY2RGBA=CV_GRAY2BGRA
CV_BayerBG2RGB=CV_BayerRG2BGR
CV_BayerGB2RGB=CV_BayerGR2BGR
CV_BayerRG2RGB=CV_BayerBG2BGR
CV_BayerGR2RGB=CV_BayerGB2BGR
%}
*/

461
interfaces/swig/octave/cvarr.i
View File

@ -1,461 +0,0 @@
/*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 );
}
}

76
interfaces/swig/octave/cvseq.i
View File

@ -1,76 +0,0 @@
/*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-08-02 Roman Stanchak <rstancha@cse.wustl.edu>
%include "octcvseq.hpp"
%template (CvTuple_CvPoint_2) CvTuple<CvPoint,2>;
%template (CvTuple_float_2) CvTuple<float,2>;
%template (CvTuple_float_3) CvTuple<float,3>;
%template (CvSeq_CvPoint) CvTypedSeq<CvPoint>;
%template (CvSeq_CvPoint2D32f) CvTypedSeq<CvPoint2D32f>;
%template (CvSeq_CvRect) CvTypedSeq<CvRect>;
%template (CvSeq_CvSeq) CvTypedSeq<CvSeq *>;
%template (CvSeq_CvQuadEdge2D) CvTypedSeq<CvQuadEdge2D>;
%template (CvSeq_CvConnectedComp) CvTypedSeq<CvConnectedComp>;
%template (CvSeq_CvPoint_2) CvTypedSeq< CvTuple<CvPoint,2> >;
%template (CvSeq_float_2) CvTypedSeq< CvTuple<float,2> >;
%template (CvSeq_float_3) CvTypedSeq< CvTuple<float,3> >;
// accessor to turn edges into a typed sequence
%extend CvSubdiv2D {
CvTypedSeq<CvQuadEdge2D> * typed_edges;
CvTypedSeq<CvQuadEdge2D> * typed_edges_get(){
return (CvTypedSeq<CvQuadEdge2D> *) self->edges;
}
void typed_edges_set( CvTypedSeq<CvQuadEdge2D> * ){
}
/* add iterator support to octave...
%pythoncode %{
def __iter__(self):
s = CvSeq_QuadEdge2D.cast(self)
for i in range(s.total):
yield s[i]
%}
*/
}

85
interfaces/swig/octave/cvshadow.cpp
View File

@ -1,85 +0,0 @@
#include <cxcore.h>
#include <cv.h>
#include <stdio.h>
#include "cvshadow.h"
CvArr * cvCvtSeqToArray_Shadow( const CvSeq* seq, CvArr * elements, CvSlice slice){
CvMat stub, *mat=(CvMat *)elements;
if(!CV_IS_MAT(mat)){
mat = cvGetMat(elements, &stub);
}
cvCvtSeqToArray( seq, mat->data.ptr, slice );
return elements;
}
double cvArcLength_Shadow( const CvSeq * seq, CvSlice slice, int is_closed){
return cvArcLength( seq, slice, is_closed );
}
double cvArcLength_Shadow( const CvArr * arr, CvSlice slice, int is_closed){
return cvArcLength( arr, slice, is_closed );
}
CvTypedSeq<CvRect> * cvHaarDetectObjects_Shadow( const CvArr* image, CvHaarClassifierCascade* cascade,
CvMemStorage* storage, double scale_factor, int min_neighbors, int flags,
CvSize min_size )
{
return (CvTypedSeq<CvRect> *) cvHaarDetectObjects( image, cascade, storage, scale_factor,
min_neighbors, flags, min_size);
}
CvTypedSeq<CvConnectedComp> * cvSegmentMotion_Shadow( const CvArr* mhi, CvArr* seg_mask, CvMemStorage* storage,
double timestamp, double seg_thresh ){
return (CvTypedSeq<CvConnectedComp> *) cvSegmentMotion( mhi, seg_mask, storage, timestamp, seg_thresh );
}
CvTypedSeq<CvPoint> * cvApproxPoly_Shadow( const void* src_seq, int header_size, CvMemStorage* storage,
int method, double parameter, int parameter2)
{
return (CvTypedSeq<CvPoint> *) cvApproxPoly( src_seq, header_size, storage, method, parameter, parameter2 );
}
// Always return a new Mat of indices
CvMat * cvConvexHull2_Shadow( const CvArr * points, int orientation, int return_points){
CvMat * hull;
CvMat * points_mat=(CvMat *) points;
CvSeq * points_seq=(CvSeq *) points;
int npoints, type;
CV_FUNCNAME("cvConvexHull2");
__BEGIN__;
if(CV_IS_MAT(points_mat)){
npoints = MAX(points_mat->rows, points_mat->cols);
type = return_points ? points_mat->type : CV_32S;
}
else if(CV_IS_SEQ(points_seq)){
npoints = points_seq->total;
type = return_points ? CV_SEQ_ELTYPE(points_seq) : 1;
}
else{
CV_ERROR(CV_StsBadArg, "points must be a CvSeq or CvMat");
}
CV_CALL( hull=cvCreateMat(1,npoints,type) );
CV_CALL( cvConvexHull2(points, hull, orientation, return_points) );
__END__;
return hull;
}
std::vector<CvPoint> cvSnakeImage_Shadow( const CvMat * image, std::vector<CvPoint> points,
std::vector<float> alpha, std::vector<float> beta,
std::vector<float> gamma,
CvSize win, CvTermCriteria criteria, int calc_gradient ){
IplImage ipl_stub;
CV_FUNCNAME("cvSnakeImage_Shadow");
__BEGIN__;
cvSnakeImage( cvGetImage(image, &ipl_stub), &(points[0]), points.size(),
&((alpha)[0]), &((beta)[0]), &((gamma)[0]),
(alpha.size()>1 && beta.size()>1 && gamma.size()>1 ? CV_ARRAY : CV_VALUE),
win, criteria, calc_gradient );
__END__;
return points;
}

37
interfaces/swig/octave/cvshadow.h
View File

@ -1,37 +0,0 @@
#ifndef CV_SHADOW_H
#define CV_SHADOW_H
#include <vector>
#include "cxtypes.h"
#include "cvtypes.h"
#include "octcvseq.hpp"
// modify cvCvtSeqToArray to take CvArr as input instead of raw data
CvArr * cvCvtSeqToArray_Shadow( const CvSeq* seq, CvArr * elements, CvSlice slice=CV_WHOLE_SEQ);
// formally overload ArcLength and cvContourPerimeter
double cvArcLength_Shadow( const CvSeq * seq, CvSlice slice=CV_WHOLE_SEQ, int is_closed=-1);
double cvArcLength_Shadow( const CvArr * arr, CvSlice slice=CV_WHOLE_SEQ, int is_closed=-1);
// cvContourPerimeter is a macro, but this still works
static double cvContourPerimeter_Shadow(CvSeq * seq){ return cvContourPerimeter( seq ); }
static double cvContourPerimeter_Shadow(CvArr * arr){ return cvContourPerimeter( arr ); }
// Return a typed sequence instead of generic CvSeq
CvTypedSeq<CvRect> * cvHaarDetectObjects_Shadow( const CvArr* image, CvHaarClassifierCascade* cascade,
CvMemStorage* storage, double scale_factor=1.1, int min_neighbors=3, int flags=0,
CvSize min_size=cvSize(0,0) );
CvTypedSeq<CvConnectedComp> * cvSegmentMotion_Shadow( const CvArr* mhi, CvArr* seg_mask, CvMemStorage* storage,
double timestamp, double seg_thresh );
CvTypedSeq<CvPoint> * cvApproxPoly_Shadow( const void* src_seq, int header_size, CvMemStorage* storage,
int method, double parameter, int parameter2=0);
// Always return a new Mat of indices
CvMat * cvConvexHull2_Shadow( const CvArr * points, int orientation=CV_CLOCKWISE,
int return_points=0);
std::vector<CvPoint> cvSnakeImage_Shadow( const CvMat * image, std::vector<CvPoint> points,
std::vector<float> alpha, std::vector<float> beta, std::vector<float> gamma,
CvSize win, CvTermCriteria criteria, int calc_gradient=1 );
#endif

138
interfaces/swig/octave/cvshadow.i
View File

@ -1,138 +0,0 @@
/*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*/
/* This file contains custom python shadow class code for certain troublesome functions */
%{
#include "cvshadow.h"
%}
%define %myshadow(function)
%ignore function;
%rename (function) function##_Shadow;
%enddef
%include "stl.i"
// %ignore, %rename must come before %include
%myshadow(cvCvtSeqToArray);
%myshadow(cvArcLength);
%myshadow(cvHaarDetectObjects);
%myshadow(cvSegmentMotion);
%myshadow(cvApproxPoly);
%myshadow(cvContourPerimeter);
%myshadow(cvConvexHull2);
%newobject cvConvexHull2; // shadowed functioned always returns new object
/* cvSnakeImage shadow uses a vector<CvPoint> and vector<float> */
%template(FloatVector) std::vector<float>;
%template(CvPointVector) std::vector<CvPoint>;
%myshadow(cvSnakeImage);
// eliminates need for IplImage ** typemap
%rename (cvCalcImageHist) cvCalcHist;
// must come after %ignore, %rename
%include "cvshadow.h"
/* return a typed CvSeq instead of generic for CvSubdiv2D edges -- see cvseq.i */
%rename (untyped_edges) CvSubdiv2D::edges;
%ignore CvSubdiv2D::edges;
%rename (edges) CvSubdiv2D::typed_edges;
/* Octave doesn't know what to do with these */
%rename (asIplImage) operator IplImage*;
%rename (asCvMat) operator CvMat*;
%ignore operator const IplImage*;
%ignore operator const CvMat*;
/* Define sequence type for functions returning sequences */
%define %cast_seq( cvfunc, type )
%rename (cvfunc##Untyped) cvfunc;
%enddef
%cast_seq( cvHoughCircles, CvSeq_float_3 );
%cast_seq( cvPyrSegmentation, CvSeq_CvConnectedComp );
%cast_seq( cvApproxChains, CvSeq_CvPoint);
%cast_seq( cvContourFromContourTree, CvSeq_CvPoint );
%cast_seq( cvConvexityDefects, CvSeq_CvConvexityDefect );
/* Special cases ... */
%rename(cvFindContoursUntyped) cvFindContours;
/* cvHoughLines2 returns a different type of sequence depending on its args */
%rename (cvHoughLinesUntyped) cvHoughLines2;
// cvPointSeqFromMat
// cvSeqPartition
// cvSeqSlice
// cvTreeToNodeSeq
/*
// cvRelease* functions don't consider Octave's reference count
// so we get a double-free error when the reference count reaches zero.
// Instead, make these no-ops.
%define %myrelease(function)
%ignore function;
%rename (function) function##_Shadow;
%inline %{
void function##_Shadow(PyObject * obj){
}
%}
%enddef
%myrelease(cvReleaseImage);
%myrelease(cvReleaseMat);
%myrelease(cvReleaseStructuringElement);
%myrelease(cvReleaseKalman);
%myrelease(cvReleaseHist);
%myrelease(cvReleaseHaarClassifierCascade);
%myrelease(cvReleasePOSITObject);
%myrelease(cvReleaseImageHeader);
%myrelease(cvReleaseMatND);
%myrelease(cvReleaseSparseMat);
%myrelease(cvReleaseMemStorage);
%myrelease(cvReleaseGraphScanner);
%myrelease(cvReleaseFileStorage);
%myrelease(cvRelease);
%myrelease(cvReleaseCapture);
%myrelease(cvReleaseVideoWriter);
*/

191
interfaces/swig/octave/highgui.i
View File

@ -1,191 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// 2008-04-09 Xavier Delacour <xavier.delacour@gmail.com>
// todo remove these..
#pragma SWIG nowarn=312,362,303,365,366,367,368,370,371,372,451,454,503
%{
#include <cxtypes.h>
#include <cv.h>
#include <highgui.h>
#include "octhelpers.h"
#include "octcvseq.hpp"
%}
// include octave-specific files
%include "./octtypemaps.i"
%include "exception.i"
// the wrapping code to enable the use of Octave-based mouse callbacks
%{
// This encapsulates the octave callback and user_data for mouse callback
struct OctCvMouseCBData {
octave_value oct_func;
octave_value user_data;
};
// This encapsulates the octave callback and user_data for mouse callback
// C helper function which is responsible for calling
// the Octave real trackbar callback function
static void icvOctOnMouse (int event, int x, int y,
int flags, OctCvMouseCBData * param) {
octave_value oct_func(param->oct_func);
if (!oct_func.is_function() && !oct_func.is_function_handle())
return;
octave_value_list args;
args.append(octave_value(event));
args.append(octave_value(x));
args.append(octave_value(y));
args.append(octave_value(flags));
args.append(param->user_data);
oct_func.subsref ("(", std::list<octave_value_list>(1, args), 0);
}
%}
// adapt cvSetMouseCallback to use octave callback
%rename (cvSetMouseCallbackOld) cvSetMouseCallback;
%rename (cvSetMouseCallback) cvSetMouseCallbackOct;
%inline {
void cvSetMouseCallbackOct( const char* window_name, octave_value on_mouse, octave_value param = octave_value() ){
OctCvMouseCBData * oct_callback = new OctCvMouseCBData;
oct_callback->oct_func = on_mouse;
oct_callback->user_data = param;
cvSetMouseCallback( window_name, (CvMouseCallback) icvOctOnMouse, (void *) oct_callback );
}
}
// The following code enables trackbar callbacks from octave. Unfortunately, there is no
// way to distinguish which trackbar the event originated from, so must hard code a
// fixed number of unique c callback functions using the macros below
%{
// C helper function which is responsible for calling
// the Octave real trackbar callback function
static void icvOctOnTrackbar( octave_value oct_cb_func, int pos) {
if (!oct_cb_func.is_function() && !oct_cb_func.is_function_handle())
return;
octave_value_list args;
args.append(octave_value(pos));
oct_cb_func.subsref ("(", std::list<octave_value_list>(1, args), 0);
}
#define ICV_OCT_MAX_CB 10
struct OctCvTrackbar {
CvTrackbarCallback cv_func;
octave_value oct_func;
octave_value oct_pos;
};
static int my_trackbar_cb_size=0;
extern OctCvTrackbar my_trackbar_cb_funcs[ICV_OCT_MAX_CB];
%}
// Callback table entry
%define %ICV_OCT_CB_TAB_ENTRY(idx)
{(CvTrackbarCallback) icvOctTrackbarCB##idx, octave_value(), octave_value() }
%enddef
// Table of callbacks
%define %ICV_OCT_CB_TAB
%{
OctCvTrackbar my_trackbar_cb_funcs[ICV_OCT_MAX_CB] = {
%ICV_OCT_CB_TAB_ENTRY(0),
%ICV_OCT_CB_TAB_ENTRY(1),
%ICV_OCT_CB_TAB_ENTRY(2),
%ICV_OCT_CB_TAB_ENTRY(3),
%ICV_OCT_CB_TAB_ENTRY(4),
%ICV_OCT_CB_TAB_ENTRY(5),
%ICV_OCT_CB_TAB_ENTRY(6),
%ICV_OCT_CB_TAB_ENTRY(7),
%ICV_OCT_CB_TAB_ENTRY(8),
%ICV_OCT_CB_TAB_ENTRY(9)
};
%}
%enddef
// Callback definition
%define %ICV_OCT_CB_IMPL(idx)
%{
static void icvOctTrackbarCB##idx(int pos){
icvOctOnTrackbar(my_trackbar_cb_funcs[idx].oct_func, pos);
}
%}
%enddef
%ICV_OCT_CB_IMPL(0);
%ICV_OCT_CB_IMPL(1);
%ICV_OCT_CB_IMPL(2);
%ICV_OCT_CB_IMPL(3);
%ICV_OCT_CB_IMPL(4);
%ICV_OCT_CB_IMPL(5);
%ICV_OCT_CB_IMPL(6);
%ICV_OCT_CB_IMPL(7);
%ICV_OCT_CB_IMPL(8);
%ICV_OCT_CB_IMPL(9);
%ICV_OCT_CB_TAB;
// typemap to memorize the Octave callback when doing cvCreateTrackbar ()
%typemap(in) CvTrackbarCallback {
if(my_trackbar_cb_size == ICV_OCT_MAX_CB){
SWIG_exception(SWIG_IndexError, "Exceeded maximum number of trackbars");
}
my_trackbar_cb_size++;
// memorize the Octave address of the callback function
my_trackbar_cb_funcs[my_trackbar_cb_size-1].oct_func = (octave_value) $input;
// prepare to call the C function who will register the callback
$1 = my_trackbar_cb_funcs[ my_trackbar_cb_size-1 ].cv_func;
}
%include "../general/highgui.i"
%include "adapters.i"

8961
interfaces/swig/octave/highgui_wrap.cpp
View File

File diff suppressed because it is too large Load Diff

152
interfaces/swig/octave/imagedata.i
View File

@ -1,152 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// 2006-08-29 Roman Stanchak -- converted to use CvMat rather than IplImage
%{
/// Accessor to convert a Octave string into the imageData.
void CvMat_imageData_set(CvMat * self, octave_value object)
{
/*
char* oct_string = OctString_AsString(object);
int depth = CV_MAT_DEPTH(self->type);
int cn = CV_MAT_CN(self->type);
if (depth == CV_8U && cn==3){
// RGB case
// The data is reordered beause OpenCV uses BGR instead of RGB
for (long line = 0; line < self->rows; ++line)
for (long pixel = 0; pixel < self->cols; ++pixel)
{
// In OpenCV the beginning of the lines are aligned
// to 4 Bytes. So use step instead of cols.
long position = line*self->step + pixel*3;
long sourcepos = line*self->cols*3 + pixel*3;
self->data.ptr[position ] = oct_string[sourcepos+2];
self->data.ptr[position+1] = oct_string[sourcepos+1];
self->data.ptr[position+2] = oct_string[sourcepos ];
}
}
else if (depth == CV_8U && cn==1)
{
// Grayscale 8bit case
for (long line = 0; line < self->rows; ++line)
{
// In OpenCV the beginning of the lines are aligned
// to 4 Bytes. So use step instead of cols.
memcpy
(
self->data.ptr + line*self->step,
oct_string + line*self->cols,
self->step
);
}
}
else if ( depth == CV_32F )
{
// float (32bit) case
for (long line = 0; line < self->rows; ++line)
{
// here we don not have to care about alignment as the Floats are
// as long as the alignment
memcpy
(
self->data.ptr + line*self->step,
oct_string + line*self->cols*sizeof(float),
self->step
);
}
}
else if ( depth == CV_64F )
{
// double (64bit) case
for (long line = 0; line < self->rows; ++line)
{
// here we don not have to care about alignment as the Floats are
// as long as the alignment
memcpy
(
self->data.ptr + line*self->step,
oct_string + line*self->cols*sizeof(double),
self->step
);
}
}
else
{
// make some noise
SendErrorToOctave (SWIG_TypeError,
"CvMat_imageData_set",
"cannot convert string data to this image format",
__FILE__, __LINE__, NULL);
}
*/
}
/// Accessor to convert the imageData into a Octave string.
octave_value CvMat_imageData_get(CvMat * self)
{
/*
if (!self->data.ptr)
{
OctErr_SetString(OctExc_TypeError, "Data pointer of CvMat is NULL");
return NULL;
}
return OctString_FromStringAndSize((const char *)self->data.ptr, self->rows*self->step);
*/
return octave_value();
}
%}
// add virtual member variable to CvMat
%extend CvMat {
octave_value imageData;
};

98
interfaces/swig/octave/ml.i
View File

@ -1,98 +0,0 @@
/*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*/
// 2004-03-16, Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
%module(package="opencv") ml
// todo remove these..
#pragma SWIG nowarn=312,362,303,365,366,367,368,370,371,372,451,454,503
%{
#include <ml.h>
#include <cxtypes.h>
#include <cv.h>
#include <highgui.h>
#include "octhelpers.h"
#include "octcvseq.hpp"
%}
// include octave-specific files
%include "./octtypemaps.i"
%include "exception.i"
%import "../general/cv.i"
%include "../general/memory.i"
%include "../general/typemaps.i"
%newobject cvCreateCNNConvolutionLayer;
%newobject cvCreateCNNSubSamplingLayer;
%newobject cvCreateCNNFullConnectLayer;
%newobject cvCreateCNNetwork;
%newobject cvTrainCNNClassifier;
%newobject cvCreateCrossValidationEstimateModel;
%extend CvEM
{
octave_value get_covs()
{
CvMat ** pointers = const_cast<CvMat **> (self->get_covs());
int n = self->get_nclusters();
octave_value result = OctTuple_New(n);
for (int i=0; i<n; ++i)
{
octave_value obj = SWIG_NewPointerObj(pointers[i], $descriptor(CvMat *), 0);
OctTuple_SetItem(result, i, obj);
}
return result;
}
}
%ignore CvEM::get_covs;
%include "ml.h"

45070
interfaces/swig/octave/ml_wrap.cpp
View File

File diff suppressed because it is too large Load Diff

120
interfaces/swig/octave/octcvseq.hpp
View File

@ -1,120 +0,0 @@
/*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*/
#ifndef OCT_CV_SEQ_H
#define OCT_CV_SEQ_H
#include "cxcore.h"
#include "cvtypes.h"
/** class to make sequence iteration nicer */
template<class T>
class CvTypedSeqReader : public CvSeqReader {
int pos;
public:
CvTypedSeqReader( const CvSeq * seq ){
cvStartReadSeq( seq, this );
pos = 0;
}
T * current(){
return (T*) this->ptr;
}
void next(){
CV_NEXT_SEQ_ELEM( this->seq->elem_size, *this );
pos++;
}
bool valid(){
return pos<this->seq->total;
}
};
template<class T>
class CvTypedSeq : public CvSeq {
public:
static CvTypedSeq<T> * cast(CvSeq * seq){
return (CvTypedSeq<T> *) seq;
}
T * __paren (int i){
return (T *) cvGetSeqElem(this, i);
}
void __paren_asgn (int i, T * obj){
T * ptr = this->__paren(i);
memcpy(ptr, obj, sizeof(T));
}
T * __brace (int i){
return __paren(i);
}
void __brace_asgn (int i, T * obj){
__paren_asgn(i, obj);
}
void append(T * obj){
cvSeqPush( this, obj );
}
T * pop(){
T * obj = new T;
cvSeqPop( this, obj );
return obj;
}
};
template<class T, int size=2>
struct CvTuple {
T val[2];
const T & __paren(int i){
return val[i];
}
void __paren_asgn(int i, T * obj){
val[i] = *obj;
}
const T & __brace(int i){
return __paren(i);
}
void __brace_asgn(int i, T * obj){
return __paren_asgn(i,obj);
}
};
#endif //OCT_CV_SEQ_H

109
interfaces/swig/octave/octerror.cpp
View File

@ -1,109 +0,0 @@
/*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*/
// 2004-03-17, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// 2008-04-19, Xavier Delacour <xavier.delacour@gmail.com>
#include "octerror.h"
#include <sstream>
#include <iostream>
#include <octave/oct.h>
// OpenCV headers
#include "cxcore.h"
#include "cxerror.h"
//=========================================================================
int SendErrorToOctave
(
int status,
const char* func_name,
const char* err_msg,
const char* file_name,
int line,
void* /*userdata*/
)
throw(int)
{
std::stringstream message;
message
<< " openCV Error:"
<< "\n Status=" << cvErrorStr(status)
<< "\n function name=" << (func_name ? func_name : "unknown")
<< "\n error message=" << (err_msg ? err_msg : "unknown")
<< "\n file_name=" << (file_name ? file_name : "unknown")
<< "\n line=" << line
<< std::flush;
// Clear OpenCV's error status for the next call!
cvSetErrStatus( CV_StsOk );
// Set Octave Error.
error(message.str().c_str());
throw 1;
return 0;
}
//=========================================================================
void* void_ptr_generator()
{
return 0;
}
//=========================================================================
void** void_ptrptr_generator()
{
return 0;
}
//=========================================================================
CvErrorCallback function_ptr_generator()
{
return &SendErrorToOctave;
}

68
interfaces/swig/octave/octerror.h
View File

@ -1,68 +0,0 @@
/*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*/
// 2004-03-17, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
#include "cxcore.h"
/**
* This function will set a Octave error and throw an int.
* Exceptions are catched automatically by the SWIG code from "typemaps.i"
*/
int SendErrorToOctave ( int status,
const char * func_name,
const char * err_msg,
const char * file_name,
int line,
void * /*userdata*/) throw(int);
/// Returns the adress of the static method "SendErrorToPython()"
CvErrorCallback function_ptr_generator();
/// Dummy to generate an empty void pointer
void * void_ptr_generator();
/// Dummy to generate an empty void double pointer
void ** void_ptrptr_generator();

368
interfaces/swig/octave/octhelpers.cpp
View File

@ -1,368 +0,0 @@
#include "octhelpers.h"
#include <iostream>
#include <sstream>
int OctSwigObject_Check(octave_value op);
octave_value OctTuple_FromIntArray(int * arr, int len){
octave_value obj = OctTuple_New(len);
for(int i=0; i<len; i++){
OctTuple_SetItem(obj, i, OctLong_FromLong( arr[i] ) );
}
return obj;
}
octave_value SWIG_SetResult(octave_value result, octave_value obj){
result = OctTuple_New(1);
OctTuple_SetItem(result, 0, obj);
return result;
}
octave_value_list* SWIG_AppendResult(octave_value_list* result, octave_value* to_add, int num){
for (int j=0;j<num;++j)
result->append(to_add[j]);
return result;
}
template <typename T>
std::ostream & cv_arr_write(std::ostream & out, T * data, int rows, int nch, int step){
int i,j,k;
char * cdata = (char *) data;
std::string chdelim1="", chdelim2="";
// only output channel parens if > 1
if(nch>1){
chdelim1="(";
chdelim2=")";
}
out<<"[\n";
for(i=0; i<rows; i++){
out<<"[";
// first element
out<<chdelim1;
out<<double(((T*)(cdata+i*step))[0]);
for(k=1; k<nch; k++){
out<<", "<<double(((T*)(cdata+i*step))[k]);
}
out<<chdelim2;
// remaining elements
for(j=nch*sizeof(T); j<step; j+=(nch*sizeof(T))){
out<<", "<<chdelim1;
out<<double(((T*)(cdata+i*step+j))[0]);
for(k=1; k<nch; k++){
out<<", "<<double(((T*)(cdata+i*step+j))[k]);
}
out<<chdelim2;
}
out<<"]\n";
}
out<<"]";
return out;
}
void cvArrPrint(CvArr * arr){
CV_FUNCNAME( "cvArrPrint" );
__BEGIN__;
CvMat * mat;
CvMat stub;
mat = cvGetMat(arr, &stub);
int cn = CV_MAT_CN(mat->type);
int depth = CV_MAT_DEPTH(mat->type);
int step = MAX(mat->step, cn*mat->cols*CV_ELEM_SIZE(depth));
std::ostringstream str;
switch(depth){
case CV_8U:
cv_arr_write(str, (uchar *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_8S:
cv_arr_write(str, (char *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_16U:
cv_arr_write(str, (ushort *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_16S:
cv_arr_write(str, (short *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_32S:
cv_arr_write(str, (int *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_32F:
cv_arr_write(str, (float *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_64F:
cv_arr_write(str, (double *)mat->data.ptr, mat->rows, cn, step);
break;
default:
CV_ERROR( CV_StsError, "Unknown element type");
break;
}
std::cout<<str.str()<<std::endl;
__END__;
}
// deal with negative array indices
int OctLong_AsIndex( octave_value idx_object, int len ){
int idx = OctLong_AsLong( idx_object );
if(idx<0) return len+idx;
return idx;
}
CvRect OctSlice_to_CvRect(CvArr * src, octave_value idx_object){
CvSize sz = cvGetSize(src);
//printf("Size %dx%d\n", sz.height, sz.width);
int lower[2], upper[2];
Oct_ssize_t len, start, stop, step, slicelength;
if(OctInt_Check(idx_object) || OctLong_Check(idx_object)){
// if array is a row vector, assume index into columns
if(sz.height>1){
lower[0] = OctLong_AsIndex( idx_object, sz.height );
upper[0] = lower[0] + 1;
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[0] = 0;
upper[0] = sz.height;
lower[1] = OctLong_AsIndex( idx_object, sz.width );
upper[1] = lower[1]+1;
}
}
// 1. Slice
else if(OctSlice_Check(idx_object)){
len = sz.height;
if(OctSlice_GetIndicesEx( idx_object, len, &start, &stop, &step, &slicelength )!=0){
error("Error in OctSlice_GetIndicesEx: returning NULL");
return cvRect(0,0,0,0);
}
// if array is a row vector, assume index bounds are into columns
if(sz.height>1){
lower[0] = (int) start; // use c convention of start index = 0
upper[0] = (int) stop; // use c convention
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[1] = (int) start; // use c convention of start index = 0
upper[1] = (int) stop; // use c convention
lower[0] = 0;
upper[0] = sz.height;
}
}
// 2. Tuple
else if(OctTuple_Check(idx_object)){
//printf("OctTuple{\n");
if(OctObject_Length(idx_object)!=2){
error("Expected a sequence with 2 elements");
return cvRect(0,0,0,0);
}
for(int i=0; i<2; i++){
octave_value o = OctTuple_GetItem(idx_object, i);
// 2a. Slice -- same as above
if(OctSlice_Check(o)){
//printf("OctSlice\n");
len = (i==0 ? sz.height : sz.width);
if(OctSlice_GetIndicesEx(o, len, &start, &stop, &step, &slicelength )!=0){
error("Error in OctSlice_GetIndicesEx: returning NULL");
return cvRect(0,0,0,0);
}
//printf("OctSlice_GetIndecesEx(%d, %d, %d, %d, %d)\n", len, start, stop, step, slicelength);
lower[i] = start;
upper[i] = stop;
}
// 2b. Integer
else if(OctInt_Check(o) || OctLong_Check(o)){
//printf("OctInt\n");
lower[i] = OctLong_AsIndex(o, i==0 ? sz.height : sz.width);
upper[i] = lower[i]+1;
}
else {
error("Expected a slice or int as sequence item: returning NULL");
return cvRect(0,0,0,0);
}
}
}
else {
error("Expected a slice or sequence: returning NULL");
return cvRect(0,0,0,0);
}
return cvRect(lower[1], lower[0], upper[1]-lower[1], upper[0]-lower[0]);
}
double OctObject_AsDouble(octave_value obj){
if(OctNumber_Check(obj)){
if(OctFloat_Check(obj)){
return OctFloat_AsDouble(obj);
}
else if(OctInt_Check(obj) || OctLong_Check(obj)){
return (double) OctLong_AsLong(obj);
}
}
error("Could not convert octave object to Double");
return -1;
}
long OctObject_AsLong(octave_value obj){
if(OctNumber_Check(obj)){
if(OctFloat_Check(obj)){
return (long) OctFloat_AsDouble(obj);
}
else if(OctInt_Check(obj) || OctLong_Check(obj)){
return OctLong_AsLong(obj);
}
}
error("Could not convert octave object to Long");
return -1;
}
// standard python container routines, adapted to octave
// * should matrix conversions happen here or at typemap layer? or both
bool OctNumber_Check(const octave_value& ov) {
return ov.is_scalar_type();
}
octave_value OctBool_FromLong (long v) {
return !!v;
}
bool OctInt_Check(const octave_value& ov) {
return ov.is_integer_type();
}
long OctInt_AsLong (const octave_value& ov) {
return ov.long_value();
}
octave_value OctInt_FromLong (long v) {
return v;
}
bool OctLong_Check(const octave_value& ov) {
return ov.is_scalar_type();
}
long OctLong_AsLong(const octave_value& ov) {
return ov.long_value();
}
octave_value OctLong_FromLong(long v) {
return v;
}
octave_value OctLong_FromUnsignedLong(unsigned long v) {
return v;
}
bool OctFloat_Check(const octave_value& ov) {
return ov.is_scalar_type();
}
octave_value OctFloat_FromDouble(double v) {
return v;
}
double OctFloat_AsDouble (const octave_value& ov) {
return ov.scalar_value();
}
octave_value OctSequence_New(int n) {
return n ? Cell(1,n) : Cell(dim_vector(0,0));
}
bool OctSequence_Check(const octave_value& ov) {
return ov.is_cell();
}
int OctSequence_Size(const octave_value& ov) {
Cell c(ov.cell_value());
return ov.cell_value().numel();
}
octave_value OctSequence_GetItem(const octave_value& ov,int i) {
Cell c(ov.cell_value());
if (i<0||i>=c.numel()) {
error("index out of bounds");
return octave_value();
}
return c(i);
}
void OctSequence_SetItem(octave_value& ov,int i,const octave_value& v) {
Cell c(ov.cell_value());
if (i<0||i>=c.numel())
error("index out of bounds");
else {
c(i)=v;
ov=c;
}
}
octave_value OctTuple_New(int n) {
return OctSequence_New(n);
}
bool OctTuple_Check(const octave_value& ov) {
return OctSequence_Check(ov);
}
int OctTuple_Size(const octave_value& ov) {
return OctSequence_Size(ov);
}
void OctTuple_SetItem(octave_value& ov,int i,const octave_value& v) {
OctSequence_SetItem(ov,i,v);
}
octave_value OctTuple_GetItem(const octave_value& ov,int i) {
return OctSequence_GetItem(ov,i);
}
octave_value OctList_New(int n) {
return OctSequence_New(n);
}
bool OctList_Check(const octave_value& ov) {
return OctSequence_Check(ov);
}
int OctList_Size(const octave_value& ov) {
return OctSequence_Size(ov);
}
void OctList_SetItem(octave_value& ov,int i,const octave_value& v) {
OctSequence_SetItem(ov,i,v);
}
octave_value OctList_GetItem(const octave_value& ov,int i) {
return OctSequence_GetItem(ov,i);
}
bool OctSlice_Check(const octave_value& ov) {
return false; // todo have these map to range and magic-colon types
}
int OctObject_Length(const octave_value& ov) {
return 0;
}
bool OctSlice_GetIndicesEx(const octave_value& ov, Oct_ssize_t len, Oct_ssize_t* start, Oct_ssize_t* stop, Oct_ssize_t* step, Oct_ssize_t* slicelength ) {
return false;
}

81
interfaces/swig/octave/octhelpers.h
View File

@ -1,81 +0,0 @@
#ifndef OCTHELPERS_H
#define OCTHELPERS_H
#include <octave/oct.h>
#include <octave/Cell.h>
// SWIG sets an include on 'tcl.h' without giving the path, which fails on Ubuntu
#if defined HAVE_TCL_H
#include <tcl.h>
#elif defined HAVE_TCL_TCL_H
#include <tcl/tcl.h>
#endif
#include <cxcore.h>
#include <cv.h>
typedef unsigned int Oct_ssize_t;
// convert octave index object (tuple, integer, or slice) to CvRect for subsequent cvGetSubMat call
CvRect OctSlice_to_CvRect(CvArr * src, octave_value idx_object);
// prints array to stdout
// TODO: octave __str returns a string, so this should write to a string
//
void cvArrPrint( CvArr * mat );
// Convert an integer array to octave tuple
octave_value OctTuple_FromIntArray(int * arr, int len);
// If result is not NULL or OctNone, release object and replace it with obj
octave_value SWIG_SetResult(octave_value result, octave_value obj);
// helper function to append one or more objects to the swig $result array
octave_value_list* SWIG_AppendResult(octave_value_list* result, octave_value* to_add, int num);
int OctObject_AsDoubleArray(octave_value obj, double * array, int len);
int OctObject_AsLongArray(octave_value obj, int * array, int len);
int OctObject_AsFloatArray(octave_value obj, float * array, int len);
// helper function to convert octave scalar or sequence to int, float or double arrays
double OctObject_AsDouble(octave_value obj);
long OctObject_AsLong(octave_value obj);
// standard python container routines, adapted to octave
bool OctNumber_Check(const octave_value& ov);
octave_value OctBool_FromLong (long v);
bool OctInt_Check(const octave_value& ov);
long OctInt_AsLong (const octave_value& ov);
octave_value OctInt_FromLong (long v);
bool OctLong_Check(const octave_value& ov);
long OctLong_AsLong(const octave_value& ov);
octave_value OctLong_FromLong(long v);
octave_value OctLong_FromUnsignedLong(unsigned long v);
bool OctFloat_Check(const octave_value& ov);
octave_value OctFloat_FromDouble(double v);
double OctFloat_AsDouble (const octave_value& ov);
octave_value OctSequence_New(int n);
bool OctSequence_Check(const octave_value& ov);
int OctSequence_Size(const octave_value& ov);
octave_value OctSequence_GetItem(const octave_value& ov,int i);
void OctSequence_SetItem(octave_value& ov,int i,const octave_value& v);
octave_value OctTuple_New(int n);
bool OctTuple_Check(const octave_value& ov);
int OctTuple_Size(const octave_value& ov);
void OctTuple_SetItem(octave_value& c,int i,const octave_value& ov);
octave_value OctTuple_GetItem(const octave_value& c,int i);
octave_value OctList_New(int n);
bool OctList_Check(const octave_value& ov);
int OctList_Size(const octave_value& ov);
void OctList_SetItem(octave_value& ov,int i,const octave_value& ov);
octave_value OctList_GetItem(const octave_value& ov,int i);
bool OctSlice_Check(const octave_value& ov);
int OctObject_Length(const octave_value& ov);
bool OctSlice_GetIndicesEx(const octave_value& ov, Oct_ssize_t len, Oct_ssize_t* start, Oct_ssize_t* stop, Oct_ssize_t* step, Oct_ssize_t* slicelength );
#endif //OCTHELPERS_H

242
interfaces/swig/octave/octhelpers.i
View File

@ -1,242 +0,0 @@
/* These functions need the SWIG_* functions defined in the wrapper */
%{
static inline bool OctSwigObject_Check(const octave_value& ov) {
return ov.type_id()==octave_swig_ref::static_type_id();
}
static CvArr * OctObject_to_CvArr(octave_value obj, bool * freearg);
static CvArr * OctSequence_to_CvArr( octave_value obj );
// convert a octave sequence/array/list object into a c-array
#define OctObject_AsArrayImpl(func, ctype, ptype) \
int func(octave_value obj, ctype * array, int len){ \
void * mat_vptr=NULL; \
void * im_vptr=NULL; \
if(OctNumber_Check(obj)){ \
memset( array, 0, sizeof(ctype)*len ); \
array[0] = OctObject_As##ptype( obj ); \
} \
else if(OctList_Check(obj) || OctTuple_Check(obj)){ \
int seqsize = OctSequence_Size(obj); \
for(int i=0; i<len && i<seqsize; i++){ \
if(i<seqsize){ \
array[i] = OctObject_As##ptype( OctSequence_GetItem(obj, i) ); \
} \
else{ \
array[i] = 0; \
} \
} \
} \
else if( SWIG_ConvertPtr(obj, &mat_vptr, SWIGTYPE_p_CvMat, 0)!=-1 || \
SWIG_ConvertPtr(obj, &im_vptr, SWIGTYPE_p__IplImage, 0)!=-1) \
{ \
CvMat * mat = (CvMat *) mat_vptr; \
CvMat stub; \
if(im_vptr) mat = cvGetMat(im_vptr, &stub); \
if( mat->rows!=1 && mat->cols!=1 ){ \
error("OctObject_As*Array: CvArr must be row or column vector" ); \
return -1; \
} \
if( mat->rows==1 && mat->cols==1 ){ \
CvScalar val; \
if( len!=CV_MAT_CN(mat->type) ){ \
error("OctObject_As*Array: CvArr channels != length" ); \
return -1; \
} \
val = cvGet1D(mat, 0); \
for(int i=0; i<len; i++){ \
array[i] = (ctype) val.val[i]; \
} \
} \
else{ \
mat = cvReshape(mat, &stub, -1, mat->rows*mat->cols); \
if( mat->rows != len ){ \
error("OctObject_As*Array: CvArr rows or cols must equal length" ); \
return -1; \
} \
for(int i=0; i<len; i++){ \
CvScalar val = cvGet1D(mat, i); \
array[i] = (ctype) val.val[0]; \
} \
} \
} \
else{ \
error("OctObject_As*Array: Expected a number, sequence or CvArr" ); \
return -1; \
} \
return 0; \
}
OctObject_AsArrayImpl( OctObject_AsFloatArray, float, Double );
OctObject_AsArrayImpl( OctObject_AsDoubleArray, double, Double );
OctObject_AsArrayImpl( OctObject_AsLongArray, int, Long );
static CvPoint OctObject_to_CvPoint(octave_value obj){
CvPoint val;
CvPoint *ptr;
CvPoint2D32f * ptr2D32f;
CvScalar * scalar;
if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return *ptr;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return cvPointFrom32f( *ptr2D32f );
}
if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
return cvPointFrom32f(cvPoint2D32f( scalar->val[0], scalar->val[1] ));
}
if(OctObject_AsLongArray(obj, (int *) &val, 2) != -1){
return val;
}
error("could not convert to CvPoint");
return cvPoint(0,0);
}
static CvPoint2D32f OctObject_to_CvPoint2D32f(octave_value obj){
CvPoint2D32f val;
CvPoint2D32f *ptr2D32f;
CvPoint *ptr;
CvScalar * scalar;
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return *ptr2D32f;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return cvPointTo32f(*ptr);
}
if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
return cvPoint2D32f( scalar->val[0], scalar->val[1] );
}
if(OctObject_AsFloatArray(obj, (float *) &val, 2) != -1){
return val;
}
error("could not convert to CvPoint2D32f");
return cvPoint2D32f(0,0);
}
static CvScalar OctObject_to_CvScalar(octave_value obj){
CvScalar val;
CvScalar * ptr;
CvPoint2D32f *ptr2D32f;
CvPoint *pt_ptr;
void * vptr;
if( SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0 ) != -1)
{
ptr = (CvScalar *) vptr;
return *ptr;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return cvScalar(ptr2D32f->x, ptr2D32f->y);
}
if( SWIG_ConvertPtr(obj, (void**)&pt_ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return cvScalar(pt_ptr->x, pt_ptr->y);
}
if(OctObject_AsDoubleArray(obj, val.val, 4)!=-1){
return val;
}
return cvScalar(-1,-1,-1,-1);
}
// if octave sequence type, convert to CvMat or CvMatND
static CvArr * OctObject_to_CvArr(octave_value obj, bool * freearg){
CvArr * cvarr;
*freearg = false;
// check if OpenCV type
if ( OctSwigObject_Check(obj) ){
SWIG_ConvertPtr(obj, &cvarr, 0, SWIG_POINTER_EXCEPTION);
}
else if (OctList_Check(obj) || OctTuple_Check(obj)){
cvarr = OctSequence_to_CvArr( obj );
*freearg = (cvarr != NULL);
}
else if (OctLong_Check(obj) && OctLong_AsLong(obj)==0){
return NULL;
}
else {
SWIG_ConvertPtr(obj, (void**)&cvarr, 0, SWIG_POINTER_EXCEPTION);
}
return cvarr;
}
static int OctObject_GetElemType(octave_value obj){
void *vptr;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint, 0) != -1) return CV_32SC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize, 0) != -1) return CV_32SC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvRect, 0) != -1) return CV_32SC4;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize2D32f, 0) != -1) return CV_32FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D32f, 0) != -1) return CV_32FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D32f, 0) != -1) return CV_32FC3;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D64f, 0) != -1) return CV_64FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D64f, 0) != -1) return CV_64FC3;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0) != -1) return CV_64FC4;
if(OctTuple_Check(obj) || OctList_Check(obj)) return CV_MAKE_TYPE(CV_32F, OctSequence_Size( obj ));
if(OctLong_Check(obj)) return CV_32S;
return CV_32F;
}
// Would like this to convert Octave lists to CvMat
// Also lists of CvPoints, CvScalars, CvMats? etc
static CvArr * OctSequence_to_CvArr( octave_value obj ){
int dims[CV_MAX_DIM] = {1,1,1};
int ndim=0;
int cvtype;
octave_value item;
// figure out dimensions
for(item = obj;
(OctTuple_Check(item) || OctList_Check(item));
item = OctSequence_GetItem(item, 0))
{
dims[ndim] = OctSequence_Size( item );
ndim++;
}
if(ndim==0){
error("Cannot convert an empty octave object to a CvArr");
return NULL;
}
cvtype = OctObject_GetElemType(item);
// collapse last dim into NCH if we found a single channel, but the last dim is <=3
if(CV_MAT_CN(cvtype)==1 && dims[ndim-1]>1 && dims[ndim-1]<4){
cvtype=CV_MAKE_TYPE(cvtype, dims[ndim-1]);
dims[ndim-1]=1;
ndim--;
}
if(cvtype==-1){
error("Could not determine OpenCV element type of Octave sequence");
return NULL;
}
// CvMat
if(ndim<=2){
CvMat *m = cvCreateMat(dims[0], dims[1], cvtype);
for(int i=0; i<dims[0]; i++){
octave_value rowobj = OctSequence_GetItem(obj, i);
if( dims[1] > 1 ){
// double check size
assert((OctTuple_Check(rowobj) || OctList_Check(rowobj)) &&
OctSequence_Size(rowobj) == dims[1]);
for(int j=0; j<dims[1]; j++){
octave_value colobj = OctSequence_GetItem(rowobj, j);
cvSet2D( m, i, j, OctObject_to_CvScalar( colobj ) );
}
}
else{
cvSet1D(m, i, OctObject_to_CvScalar( rowobj ) );
}
}
return (CvArr *) m;
}
// CvMatND
error("Cannot convert Octave Object to CvArr -- ndim > 3");
return NULL;
}
%}

896
interfaces/swig/octave/octtypemaps.i
View File

@ -1,896 +0,0 @@
/*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*/
%include "exception.i"
%include "./octhelpers.i"
%typemap(in) (CvArr *) (bool freearg=false){
$1 = OctObject_to_CvArr($input, &freearg);
}
%typemap(freearg) (CvArr *) {
if($1!=NULL && freearg$argnum){
cvReleaseData( $1 );
cvFree(&($1));
}
}
%typecheck(SWIG_TYPECHECK_POINTER) CvArr * {
void *ptr;
if(OctList_Check($input) || OctTuple_Check($input)) {
$1 = 1;
}
else if (SWIG_ConvertPtr($input, &ptr, 0, 0) == -1) {
$1 = 0;
}
else{
$1 = 1;
}
}
// for cvReshape, cvGetRow, where header is passed, then filled in
%typemap(in, numinputs=0) CvMat * OUTPUT (CvMat * header) {
header = (CvMat *)cvAlloc(sizeof(CvMat));
$1 = header;
}
%newobject cvReshape;
%newobject cvGetRow;
%newobject cvGetRows;
%newobject cvGetCol;
%newobject cvGetCols;
%newobject cvGetSubRect;
%newobject cvGetDiag;
%apply CvMat *OUTPUT {CvMat * header};
%apply CvMat *OUTPUT {CvMat * submat};
// In C, these functions assume input will always be around at least as long as header,
// presumably because the most common usage is to pass in a reference to a stack object.
// i.e
// CvMat row;
// cvGetRow(A, &row, 0);
//
// As a result, the header is not refcounted (see the C source for cvGetRow, Reshape, in cxarray.cpp)
// However, in octave, the header parameter is implicitly created so it is easier to create
// situations where the sub-array outlives the original header. A simple example is:
// A = cvReshape(A, -1, A.rows*A.cols)
//
// since octave doesn't have an assignment operator, the new header simply replaces the original,
// the refcount of the original goes to zero, and cvReleaseMat is called on the original, freeing both
// the header and data. The new header is left pointing to invalid data. To avoid this, need to add
// refcount field to the returned header.
%typemap(argout) (const CvArr* arr, CvMat* header) {
$2->hdr_refcount = ((CvMat *)$1)->hdr_refcount;
$2->refcount = ((CvMat *)$1)->refcount;
cvIncRefData($2);
}
%typemap(argout) (const CvArr* arr, CvMat* submat) {
$2->hdr_refcount = ((CvMat *)$1)->hdr_refcount;
$2->refcount = ((CvMat *)$1)->refcount;
cvIncRefData($2);
}
// map scalar or sequence to CvScalar, CvPoint2D32f, CvPoint
%typemap(in) (CvScalar) {
$1 = OctObject_to_CvScalar( $input );
}
%typemap(in) (CvPoint) {
$1 = OctObject_to_CvPoint($input);
}
%typemap(in) (CvPoint2D32f) {
$1 = OctObject_to_CvPoint2D32f($input);
}
// typemap for cvGetDims
%typemap(in) (const CvArr * arr, int * sizes = NULL) (void * myarr, int mysizes[CV_MAX_DIM]){
SWIG_Octave_ConvertPtr($input, &myarr, 0, SWIG_POINTER_EXCEPTION);
$1=(CvArr *)myarr;
$2=mysizes;
}
%typemap(argout) (const CvArr * arr, int * sizes = NULL) {
int len = OctInt_AsLong( $result );
octave_value obj = OctTuple_FromIntArray( $2, len );
%append_output(obj);
}
// map one list of integer to the two parameters dimension/sizes
%typemap(in) (int dims, int* sizes) {
int i;
// get the size of the dimention array
$1 = OctList_Size ($input);
// allocate the needed memory
$2 = (int *)malloc ($1 * sizeof (int));
// extract all the integer values from the list
for (i = 0; i < $1; i++) {
octave_value item = OctList_GetItem ($input, i);
$2 [i] = (int)OctInt_AsLong (item);
}
}
// map one list of integer to the parameter idx of
// cvGetND, cvSetND, cvClearND, cvGetRealND, cvSetRealND and cvClearRealND
%typemap(in) (int* idx) {
int i;
int size;
// get the size of the dimention array
size = OctList_Size ($input);
// allocate the needed memory
$1 = (int *)malloc (size * sizeof (int));
// extract all the integer values from the list
for (i = 0; i < size; i++) {
octave_value item = OctList_GetItem ($input, i);
$1 [i] = (int)OctInt_AsLong (item);
}
}
// map a list of list of float to an matrix of floats
%typemap(in) float** ranges {
int i1;
int i2;
int size1;
int size2 = 0;
// get the number of lines of the matrix
size1 = OctList_Size ($input);
// allocate the correct number of lines for the destination matrix
$1 = (float **)malloc (size1 * sizeof (float *));
for (i1 = 0; i1 < size1; i1++) {
// extract all the lines of the matrix
octave_value list = OctList_GetItem ($input, i1);
if (size2 == 0) {
// size 2 wasn't computed before
size2 = OctList_Size (list);
} else if (size2 != OctList_Size (list)) {
// the current line as a different size than the previous one
// so, generate an exception
SWIG_exception (SWIG_ValueError, "Lines must be the same size");
}
// allocate the correct number of rows for the current line
$1 [i1] = (float *)malloc (size2 * sizeof (float));
// extract all the float values of this row
for (i2 = 0; i2 < size2; i2++) {
octave_value item = OctList_GetItem (list, i2);
$1 [i1][i2] = (float)OctFloat_AsDouble (item);
}
}
}
//
// map the output parameter of the cvGetMinMaxHistValue()
// so, we can call cvGetMinMaxHistValue() in Octave like:
// min_value, max_value = cvGetMinMaxHistValue (hist, None, None)
//
%apply int *OUTPUT {int *min_idx};
%apply int *OUTPUT {int *max_idx};
%apply float *OUTPUT {float *min_value};
%apply float *OUTPUT {float *max_value};
//
// map output parameters of cvMinMaxLoc
//
%apply double *OUTPUT {double* min_val, double* max_val};
//
// the input argument of cvPolyLine "CvPoint** pts" is converted from
// a "list of list" (aka. an array) of CvPoint().
// The next parameters "int* npts" and "int contours" are computed from
// the givne list.
//
%typemap(in) (CvPoint** pts, int* npts, int contours){
int i;
int j;
int size2 = -1;
CvPoint **points = NULL;
int *nb_vertex = NULL;
if(!OctSequence_Check($input)){
SWIG_exception(SWIG_TypeError, "Expected a list for argument $argnum\n");
SWIG_fail;
}
// get the number of polylines input array
int size1 = OctSequence_Size ($input);
$3 = size1;
if(size1>0){
// create the points array
points = (CvPoint **)malloc (size1 * sizeof (CvPoint *));
// point to the created array for passing info to the C function
$1 = points;
// create the array for memorizing the vertex
nb_vertex = (int *)malloc (size1 * sizeof (int));
$2 = nb_vertex;
}
for (i = 0; i < size1; i++) {
// get the current item
octave_value line = OctSequence_GetItem ($input, i);
if(!OctSequence_Check(line)){
SWIG_exception(SWIG_TypeError, "Expected a sequence of sequences of integers for argument $argnum\n");
// TODO: cleanup here
}
// get the size of the current polyline
size2 = OctSequence_Size (line);
if(size2>0){
// allocate the necessary memory to store the points
points [i] = (CvPoint *)malloc (size2 * sizeof (CvPoint));
}
// memorize the size of the polyline in the vertex list
nb_vertex [i] = size2;
for (j = 0; j < size2; j++) {
// get the current item
octave_value item = OctSequence_GetItem (line, j);
points[i][j] = OctObject_to_CvPoint( item );
}
}
}
// Free arguments allocated before the function call
%typemap(freearg) (CvPoint **pts, int* npts, int contours){
int i;
for(i=0;i<$3;i++){
free($1[i]);
}
free($1);
free($2);
}
// Macro to define typemaps to convert a octave list of CvPoints to a C array of CvPoints
%define %typemap_CvPoint_CArr(points_arg, numpoints_arg)
%typemap(in, numinputs=1) (CvPoint * points_arg, int numpoints_arg){
int i;
if(!OctSequence_Check($input)){
SWIG_exception(SWIG_TypeError, "Expected a list for argument $argnum\n");
SWIG_fail;
}
int size = OctSequence_Size($input);
CvPoint * points = (CvPoint *)malloc(size*sizeof(CvPoint));
for(i=0; i<size; i++){
octave_value item = OctSequence_GetItem($input, i);
points[i] = OctObject_to_CvPoint( item );
}
$1 = points;
$2 = size;
}
%typemap(freearg) (CvPoint *points_arg, int numpoints_arg){
free((char *)$1);
}
%enddef
// apply to cvFillConvexPoly
%typemap_CvPoint_CArr(pts, npts)
//
// this is mainly an "output parameter"
// So, just allocate the memory as input
//
%typemap (in, numinputs=0) (CvSeq ** OUTPUT) (CvSeq * seq) {
$1 = &seq;
}
//
// return the finded contours with all the others parametres
//
%typemap(argout) (CvSeq ** OUTPUT) {
octave_value to_add;
// extract the pointer we want to add to the returned tuple
// sequence is allocated in CvMemStorage, so octave_ownership=0
to_add = SWIG_NewPointerObj (*$1, $descriptor(CvSeq*), 0);
$result = SWIG_AppendResult($result, &to_add, 1);
}
%apply CvSeq **OUTPUT {CvSeq **first_contour};
%apply CvSeq **OUTPUT {CvSeq **comp};
//
// CvArr ** image can be either one CvArr or one array of CvArr
// (for example like in cvCalcHist() )
// From Octave, the array of CvArr can be a tuple.
//
%typemap(in) (CvArr ** INPUT) (
CvArr * one_image=NULL,
bool free_one_arg=false,
CvArr ** many_images=NULL,
bool *free_many_args=NULL,
int nimages=0 ) {
// first, check if this is a tuple
if (OctTuple_Check ($input)) {
// This is a tuple, so we need to test each element and pass
// them to the called function
int i;
// get the size of the tuple
nimages = OctTuple_Size ($input);
// allocate the necessary place
many_images = (CvArr **)malloc (nimages * sizeof (CvArr *));
free_many_args = (bool *)malloc(nimages * sizeof(bool));
for (i = 0; i < nimages; i++) {
// convert the current tuple element to a CvArr *, and
// store to many_images [i]
many_images[i] = OctObject_to_CvArr (OctTuple_GetItem ($input, i),
free_many_args+i);
// check that the current item is a correct type
if(!many_images[i]) {
// incorrect !
SWIG_fail;
}
}
// what to give to the called function
$1 = many_images;
} else if((one_image = OctObject_to_CvArr( $input, &free_one_arg ))){
// this is just one CvArr *, so one_image will receive it
$1 = &one_image;
} else {
// not a CvArr *, not a tuple, this is wrong
SWIG_fail;
}
}
%apply CvArr ** INPUT {CvArr ** img};
%apply CvArr ** INPUT {CvArr ** image};
%apply CvArr ** INPUT {CvArr ** arr};
%apply CvArr ** INPUT {CvArr ** vects};
%typemap(freearg) (CvArr ** FREEARG) {
if(free_one_arg$argnum){
cvFree(&(one_image$argnum));
}
else if(free_many_args$argnum){
int i;
for (i=0; i<nimages$argnum; i++){
if(free_many_args$argnum[i]){
cvReleaseData(many_images$argnum[i]);
cvFree(many_images$argnum+i);
}
}
free(many_images$argnum);
free(free_many_args$argnum);
}
}
%apply CvArr ** FREEARG {CvArr ** img};
%apply CvArr ** FREEARG {CvArr ** image};
%apply CvArr ** FREEARG {CvArr ** arr};
%apply CvArr ** FREEARG {CvArr ** vects};
//
// Map the CvFont * parameter from the cvInitFont() as an output parameter
//
%typemap (in, numinputs=1) (CvFont* font, int font_face) {
$1 = (CvFont *)malloc (sizeof (CvFont));
$2 = (int)OctInt_AsLong ($input);
if (SWIG_arg_fail($argnum)) SWIG_fail;
}
%typemap(argout) (CvFont* font, int font_face) {
octave_value to_add;
// extract the pointer we want to add to the returned tuple
to_add = SWIG_NewPointerObj ($1, $descriptor(CvFont *), 0);
$result = SWIG_AppendResult($result, &to_add, 1);
}
//
// these are output parameters for cvGetTextSize
//
%typemap (in, numinputs=0) (CvSize* text_size, int* baseline) {
CvSize *size = (CvSize *)malloc (sizeof (CvSize));
int *baseline = (int *)malloc (sizeof (int));
$1 = size;
$2 = baseline;
}
//
// return the finded parameters for cvGetTextSize
//
%typemap(argout) (CvSize* text_size, int* baseline) {
octave_value to_add[2];
// extract the pointers we want to add to the returned tuple
to_add [0] = SWIG_NewPointerObj ($1, $descriptor(CvSize *), 0);
to_add [1] = OctInt_FromLong (*$2);
$result = SWIG_AppendResult($result, to_add, 2);
}
//
// curr_features is output parameter for cvCalcOpticalFlowPyrLK
//
%typemap (in, numinputs=1) (CvPoint2D32f* curr_features, int count)
(int tmpCount) {
// as input, we only need the size of the wanted features
// memorize the size of the wanted features
tmpCount = (int)OctInt_AsLong ($input);
// create the array for the C call
$1 = (CvPoint2D32f *) malloc(tmpCount * sizeof (CvPoint2D32f));
// the size of the array for the C call
$2 = tmpCount;
}
//
// the features returned by cvCalcOpticalFlowPyrLK
//
%typemap(argout) (CvPoint2D32f* curr_features, int count) {
int i;
octave_value to_add;
// create the list to return
to_add = OctList_New (tmpCount$argnum);
// extract all the points values of the result, and add it to the
// final resulting list
for (i = 0; i < tmpCount$argnum; i++) {
OctList_SetItem (to_add, i,
SWIG_NewPointerObj (&($1 [i]),
$descriptor(CvPoint2D32f *), 0));
}
$result = SWIG_AppendResult($result, &to_add, 1);
}
//
// status is an output parameters for cvCalcOpticalFlowPyrLK
//
%typemap (in, numinputs=1) (char *status) (int tmpCountStatus){
// as input, we still need the size of the status array
// memorize the size of the status array
tmpCountStatus = (int)OctInt_AsLong ($input);
// create the status array for the C call
$1 = (char *)malloc (tmpCountStatus * sizeof (char));
}
//
// the status returned by cvCalcOpticalFlowPyrLK
//
%typemap(argout) (char *status) {
int i;
octave_value to_add;
// create the list to return
to_add = OctList_New (tmpCountStatus$argnum);
// extract all the integer values of the result, and add it to the
// final resulting list
for (i = 0; i < tmpCountStatus$argnum; i++) {
OctList_SetItem (to_add, i, OctBool_FromLong ($1 [i]));
}
$result = SWIG_AppendResult($result, &to_add, 1);
}
// map one list of points to the two parameters dimenssion/sizes
// for cvCalcOpticalFlowPyrLK
%typemap(in) (CvPoint2D32f* prev_features) {
int i;
int size;
// get the size of the input array
size = OctList_Size ($input);
// allocate the needed memory
$1 = (CvPoint2D32f *)malloc (size * sizeof (CvPoint2D32f));
// extract all the points values from the list
for (i = 0; i < size; i++) {
octave_value item = OctList_GetItem ($input, i);
void * vptr;
SWIG_Octave_ConvertPtr (item, &vptr,
$descriptor(CvPoint2D32f*),
SWIG_POINTER_EXCEPTION);
CvPoint2D32f *p = (CvPoint2D32f *)vptr;
$1 [i].x = p->x;
$1 [i].y = p->y;
}
}
//
// the corners returned by cvGoodFeaturesToTrack
//
%typemap (in, numinputs=1) (CvPoint2D32f* corners, int* corner_count)
(int tmpCount) {
// as input, we still need the size of the corners array
// memorize the size of the status corners
tmpCount = (int)OctInt_AsLong ($input);
// create the corners array for the C call
$1 = (CvPoint2D32f *)malloc (tmpCount * sizeof (CvPoint2D32f));
// the size of the array for the C call
$2 = &tmpCount;
}
//
// the corners returned by cvGoodFeaturesToTrack
//
%typemap(argout) (CvPoint2D32f* corners, int* corner_count) {
int i;
octave_value to_add;
// create the list to return
to_add = OctList_New (tmpCount$argnum);
// extract all the integer values of the result, and add it to the
// final resulting list
for (i = 0; i < tmpCount$argnum; i++) {
OctList_SetItem (to_add, i,
SWIG_NewPointerObj (&($1 [i]),
$descriptor(CvPoint2D32f *), 0));
}
$result = SWIG_AppendResult($result, &to_add, 1);
}
// map one list of points to the two parameters dimension/sizes
// for cvFindCornerSubPix
%typemap(in, numinputs=1) (CvPoint2D32f* corners, int count)
(int cornersCount, CvPoint2D32f* corners){
int i;
if(!OctList_Check($input)){
error("Expected a list");
SWIG_fail;
}
// get the size of the input array
cornersCount = OctList_Size ($input);
$2 = cornersCount;
// allocate the needed memory
corners = (CvPoint2D32f *)malloc ($2 * sizeof (CvPoint2D32f));
$1 = corners;
// the size of the array for the C call
// extract all the points values from the list
for (i = 0; i < $2; i++) {
octave_value item = OctList_GetItem ($input, i);
void *vptr;
SWIG_Octave_ConvertPtr (item, &vptr,
$descriptor(CvPoint2D32f*),
SWIG_POINTER_EXCEPTION);
CvPoint2D32f *p = (CvPoint2D32f *) vptr;;
$1 [i].x = p->x;
$1 [i].y = p->y;
}
}
//
// the corners returned by cvFindCornerSubPix
//
%typemap(argout) (CvPoint2D32f* corners, int count) {
int i;
octave_value to_add;
// create the list to return
to_add = OctList_New (cornersCount$argnum);
// extract all the corner values of the result, and add it to the
// final resulting list
for (i = 0; i < cornersCount$argnum; i++) {
OctList_SetItem (to_add, i,
SWIG_NewPointerObj (&(corners$argnum [i]),
$descriptor(CvPoint2D32f *), 0));
}
$result = SWIG_AppendResult( $result, &to_add, 1);
}
//
// return the corners for cvFindChessboardCorners
//
%typemap(in, numinputs=1) (CvSize pattern_size, CvPoint2D32f * corners, int * corner_count )
(CvSize * pattern_size, CvPoint2D32f * tmp_corners, int tmp_ncorners) {
void * vptr;
if( SWIG_ConvertPtr($input, &vptr, $descriptor( CvSize * ), SWIG_POINTER_EXCEPTION ) == -1){
SWIG_fail;
}
pattern_size=(CvSize *)vptr;
tmp_ncorners = pattern_size->width*pattern_size->height;
tmp_corners = (CvPoint2D32f *) malloc(sizeof(CvPoint2D32f)*tmp_ncorners);
$1 = *pattern_size;
$2 = tmp_corners;
$3 = &tmp_ncorners;
}
%typemap(argout) (CvSize pattern_size, CvPoint2D32f * corners, int * corner_count){
int i;
octave_value to_add;
// create the list to return
to_add = OctList_New ( tmp_ncorners$argnum );
// extract all the corner values of the result, and add it to the
// final resulting list
for (i = 0; i < tmp_ncorners$argnum; i++) {
CvPoint2D32f * pt = new CvPoint2D32f;
pt->x = tmp_corners$argnum[i].x;
pt->y = tmp_corners$argnum[i].y;
OctList_SetItem (to_add, i,
SWIG_NewPointerObj( pt, $descriptor(CvPoint2D32f *), 0));
}
$result = SWIG_AppendResult( $result, &to_add, 1);
free(tmp_corners$argnum);
}
//
// return the matrices for cvCameraCalibrate
//
%typemap(in, numinputs=0) (CvMat * intrinsic_matrix, CvMat * distortion_coeffs)
{
$1 = cvCreateMat(3,3,CV_32F);
$2 = cvCreateMat(4,1,CV_32F);
}
%typemap(argout) (CvMat * intrinsic_matrix, CvMat * distortion_coeffs)
{
octave_value to_add[2];
to_add[0] = SWIG_NewPointerObj($1, $descriptor(CvMat *), 1);
to_add[1] = SWIG_NewPointerObj($2, $descriptor(CvMat *), 1);
$result = SWIG_AppendResult( $result, to_add, 2 );
}
//
// Fix OpenCV inheritance for CvSeq, CvSet, CvGraph
// Otherwise, can't call CvSeq functions on CvSet or CvGraph
//
%typemap(in, numinputs=1) (CvSeq *) (void * ptr)
{
if( SWIG_ConvertPtr($input, &ptr, $descriptor(CvSeq *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvSet *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvGraph *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvSubdiv2D *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvChain *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvContour *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvContourTree *), 0) == -1 )
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSeq");
SWIG_fail;
}
$1 = (CvSeq *) ptr;
}
%typemap(in, numinputs=1) (CvSet *) (void * ptr)
{
if( SWIG_ConvertPtr($input, &ptr, $descriptor(CvSet *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvGraph *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvSubdiv2D *), 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvSet");
SWIG_fail;
}
$1 = (CvSet *)ptr;
}
%typemap(in, numinputs=1) (CvGraph *) (void * ptr)
{
if( SWIG_ConvertPtr($input, &ptr, $descriptor(CvGraph *), 0) == -1 &&
SWIG_ConvertPtr($input, &ptr, $descriptor(CvSubdiv2D *), 0) == -1)
{
SWIG_exception (SWIG_TypeError, "could not convert to CvGraph");
SWIG_fail;
}
$1 = (CvGraph *)ptr;
}
//
// Remap output arguments to multiple return values for cvMinEnclosingCircle
//
%typemap(in, numinputs=0) (CvPoint2D32f * center, float * radius) (CvPoint2D32f * tmp_center, float tmp_radius)
{
tmp_center = (CvPoint2D32f *) malloc(sizeof(CvPoint2D32f));
$1 = tmp_center;
$2 = &tmp_radius;
}
%typemap(argout) (CvPoint2D32f * center, float * radius)
{
octave_value to_add[2];
to_add[0] = SWIG_NewPointerObj( tmp_center$argnum, $descriptor(CvPoint2D32f *), 1);
to_add[1] = OctFloat_FromDouble( tmp_radius$argnum );
$result = SWIG_AppendResult($result, to_add, 2);
}
// BoxPoints
%typemap(in, numinputs=0) (CvPoint2D32f pt[4]) (CvPoint2D32f tmp_pts[4])
{
$1 = tmp_pts;
}
%typemap(argout) (CvPoint2D32f pt[4])
{
octave_value to_add = OctList_New(4);
int i;
for(i=0; i<4; i++){
CvPoint2D32f * p = new CvPoint2D32f;
*p = tmp_pts$argnum[i];
OctList_SetItem(to_add, i, SWIG_NewPointerObj( p, $descriptor(CvPoint2D32f *), 1 ) );
}
$result = SWIG_AppendResult($result, &to_add, 1);
}
// Macro to wrap a built-in type that is used as an object like CvRNG and CvSubdiv2DEdge
%define %wrap_builtin(type)
%inline %{
// Wrapper class
class type##_Wrapper {
private:
type m_val;
public:
type##_Wrapper( const type & val ) :
m_val(val)
{
}
type * ptr() { return &m_val; }
type & ref() { return m_val; }
bool operator==(const type##_Wrapper & x){
return m_val==x.m_val;
}
bool operator!=(const type##_Wrapper & x){
return m_val!=x.m_val;
}
};
%}
%typemap(out) type
{
type##_Wrapper * wrapper = new type##_Wrapper( $1 );
$result = SWIG_NewPointerObj( wrapper, $descriptor( type##_Wrapper * ), 1 );
}
%typemap(out) type *
{
type##_Wrapper * wrapper = new type##_Wrapper( *($1) );
$result = SWIG_NewPointerObj( wrapper, $descriptor( type##_Wrapper * ), 1 );
}
%typemap(in) (type *) (void * vptr, type##_Wrapper * wrapper){
if(SWIG_ConvertPtr($input, &vptr, $descriptor(type##_Wrapper *), 0)==-1){
SWIG_exception( SWIG_TypeError, "could not convert Octave object to C value");
SWIG_fail;
}
wrapper = (type##_Wrapper *) vptr;
$1 = wrapper->ptr();
}
%typemap(in) (type) (void * vptr, type##_Wrapper * wrapper){
if(SWIG_ConvertPtr($input, &vptr, $descriptor(type##_Wrapper *), 0)==-1){
SWIG_exception( SWIG_TypeError, "could not convert Octave object to C value");
SWIG_fail;
}
wrapper = (type##_Wrapper *) vptr;
$1 = wrapper->ref();
}
%enddef
// Application of wrapper class to built-in types
%wrap_builtin(CvRNG);
%wrap_builtin(CvSubdiv2DEdge);
//
// Allow CvQuadEdge2D to be interpreted as CvSubdiv2DEdge
//
%typemap(in, numinputs=1) (CvSubdiv2DEdge) (CvSubdiv2DEdge_Wrapper * wrapper, CvQuadEdge2D * qedge, void *vptr)
{
if( SWIG_ConvertPtr($input, &vptr, $descriptor(CvSubdiv2DEdge_Wrapper *), 0) != -1 ){
wrapper = (CvSubdiv2DEdge_Wrapper *) vptr;
$1 = wrapper->ref();
}
else if( SWIG_ConvertPtr($input, &vptr, $descriptor(CvQuadEdge2D *), 0) != -1 ){
qedge = (CvQuadEdge2D *) vptr;
$1 = (CvSubdiv2DEdge)qedge;
}
else{
SWIG_exception( SWIG_TypeError, "could not convert to CvSubdiv2DEdge");
SWIG_fail;
}
}
//
// return the vertex and edge for cvSubdiv2DLocate
//
%typemap(in, numinputs=0) (CvSubdiv2DEdge * edge, CvSubdiv2DPoint ** vertex)
(CvSubdiv2DEdge tmpEdge, CvSubdiv2DPoint * tmpVertex)
{
$1 = &tmpEdge;
$2 = &tmpVertex;
}
%typemap(argout) (CvSubdiv2DEdge * edge, CvSubdiv2DPoint ** vertex)
{
octave_value to_add[2];
if(result==CV_PTLOC_INSIDE || result==CV_PTLOC_ON_EDGE){
CvSubdiv2DEdge_Wrapper * wrapper = new CvSubdiv2DEdge_Wrapper( tmpEdge$argnum );
to_add[0] = SWIG_NewPointerObj( wrapper, $descriptor(CvSubdiv2DEdge_Wrapper *), 0);
to_add[1] = octave_value();
}
if(result==CV_PTLOC_VERTEX){
to_add[0] = octave_value();
to_add[1] = SWIG_NewPointerObj( tmpVertex$argnum, $descriptor(CvSubdiv2DPoint *), 0);
}
$result = SWIG_AppendResult($result, to_add, 2);
}
//
// int *value in cvCreateTrackbar() is only used for input in the Octave wrapper.
// for output, use the pos in the callback
// TODO: remove the memory leak introducted by the malloc () (if needed).
//
%typemap(in, numinputs=1) (int *value)
{
$1 = (int *)malloc (sizeof (int));
*$1 = OctInt_AsLong ($input);
}

3
interfaces/swig/octave/opencv.m
View File

@ -1,3 +0,0 @@
_cv
_ml
_highgui

1
interfaces/swig/python/.cvsignore
View File

@ -1 +0,0 @@
build

118
interfaces/swig/python/CMakeLists.txt
View File

@ -1,118 +0,0 @@
# ----------------------------------------------------------------------------
# CMake file for python support
# ----------------------------------------------------------------------------
project(python_support)
find_package(SWIG REQUIRED)
include(${SWIG_USE_FILE})
include_directories(${PYTHON_INCLUDE_PATH})
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../filtered)
if(MSVC)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3")
endif()
# ----------------------------------- cv module ------------------------------
set_source_files_properties(cv.i PROPERTIES
CPLUSPLUS ON
SWIG_FLAGS -includeall
SWIG_FLAGS -DSKIP_INCLUDES
)
set(opencv_headers
${CMAKE_SOURCE_DIR}/include/opencv/cxtypes.h
${CMAKE_SOURCE_DIR}/include/opencv/cxcore.h
${CMAKE_SOURCE_DIR}/include/opencv/cvtypes.h
${CMAKE_SOURCE_DIR}/include/opencv/cv.h
)
add_custom_command(
OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/cvaliases_autogen.i
COMMAND ${PYTHON_EXECUTABLE} ${CMAKE_SOURCE_DIR}/utils/extract_aliases.py
${opencv_headers} > ${CMAKE_CURRENT_BINARY_DIR}/cvaliases_autogen.i
DEPENDS ${opencv_headers}
)
set(SWIG_MODULE_cv_EXTRA_DEPS
imagedata.i cvarr.i ${CMAKE_CURRENT_BINARY_DIR}/cvaliases_autogen.i cvaliases.i pyhelpers.i
nointpb.i pytypemaps.i cvshadow.i cvseq.i
../general/cv.i ../general/memory.i ../general/typemaps.i
../general/extensions.i ../general/doublepointers.i
../general/sizeof.i ../general/cvmacros.i
)
SWIG_ADD_MODULE(cv python cv.i cvshadow.cpp error.cpp error.h pyhelpers.cpp pyhelpers.h cvshadow.h pycvseq.hpp)
SWIG_LINK_LIBRARIES(cv ${PYTHON_LIBRARIES} cxcore cv)
# ----------------------------------- ml module ------------------------------
set_source_files_properties(ml.i PROPERTIES
CPLUSPLUS ON
SWIG_FLAGS -includeall
SWIG_FLAGS -DSKIP_INCLUDES
)
set(SWIG_MODULE_ml_EXTRA_DEPS
nointpb.i pytypemaps.i
../general/memory.i ../general/typemaps.i
${CMAKE_SOURCE_DIR}/include/opencv/ml.h
)
SWIG_ADD_MODULE(ml python ml.i pyhelpers.cpp pyhelpers.h)
SWIG_LINK_LIBRARIES(ml ${PYTHON_LIBRARIES} cxcore ml)
# --------------------------------highgui module ------------------------------
set_source_files_properties(highgui.i PROPERTIES
CPLUSPLUS ON
SWIG_FLAGS -includeall
SWIG_FLAGS -DSKIP_INCLUDES
)
set(SWIG_MODULE_highgui_EXTRA_DEPS
nointpb.i pytypemaps.i
../general/highgui.i
../general/memory.i ../general/typemaps.i
${CMAKE_SOURCE_DIR}/include/opencv/highgui.h
)
SWIG_ADD_MODULE(highgui python highgui.i pyhelpers.cpp pyhelpers.h)
SWIG_LINK_LIBRARIES(highgui ${PYTHON_LIBRARIES} cxcore cv highgui)
# ------------------------------ installation ----------------------------------
if(WIN32)
set_target_properties(
${SWIG_MODULE_cv_REAL_NAME}
${SWIG_MODULE_ml_REAL_NAME}
${SWIG_MODULE_highgui_REAL_NAME}
PROPERTIES SUFFIX ".pyd")
endif()
get_target_property(LOC_CV ${SWIG_MODULE_cv_REAL_NAME} LOCATION)
get_target_property(LOC_ML ${SWIG_MODULE_ml_REAL_NAME} LOCATION)
get_target_property(LOC_HIGHGUI ${SWIG_MODULE_highgui_REAL_NAME} LOCATION)
set(pyopencv_files __init__.py adaptors.py matlab_syntax.py
${CMAKE_CURRENT_BINARY_DIR}/cv.py
${CMAKE_CURRENT_BINARY_DIR}/ml.py
${CMAKE_CURRENT_BINARY_DIR}/highgui.py)
foreach(m ${LOC_CV} ${LOC_ML} ${LOC_HIGHGUI})
string(REPLACE "\$(OutDir)" "\${CMAKE_INSTALL_CONFIG_NAME}" m1 ${m})
set(pyopencv_files ${pyopencv_files} ${m1})
endforeach()
# TODO: need to compile *.py files
if(WIN32)
install(FILES ${pyopencv_files} DESTINATION
"Python${PYTHON_VERSION_MAJOR_MINOR}/Lib/site-packages/opencv"
COMPONENT main)
else()
install(FILES ${pyopencv_files} DESTINATION ${PYTHON_PLUGIN_INSTALL_PATH} COMPONENT main)
endif()

76
interfaces/swig/python/__init__.py
View File

@ -1,76 +0,0 @@
#########################################################################################
#
# 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.
#
#########################################################################################
# 2004-03-16, Mark Asbach <asbach@ient.rwth-aachen.de>
# Institute of Communications Engineering, RWTH Aachen University
"""The Open Computer Vision Library
OpenCV is the Open Computer Vision library, an open source effort originally started
by intel to provide computer vision algorithms for standard PC hardware.
This wrapper was semi-automatically created from the C/C++ headers and therefore
contains no Python documentation. Because all identifiers are identical to their
C/C++ counterparts, you can consult the standard manuals that come with OpenCV.
In detail, this python package contains four sub-modules:
cv core components (cxcore and cv)
ml machine learning
highgui simple user interface, video and image I/O
adaptors pure python module offering conversion to numpy/scipy matrices
and PIL (python imaging library) images
matlab_syntax pure python module offering syntax that is similar to Matlab
for those who switched
All methods and data types from cv, ml and adaptors are automatically imported into
the opencv namespace. Contents from highgui and matlab_syntax must be explicitly
imported - to avoid conflicts with other UI toolkits and the python matlab interface.
"""
# the module consists of these four sub-modules
__all__ = ['cv', 'ml', 'highgui', 'adaptors', 'matlab_syntax']
# always import functionality from cxcore, cv and ml to this namespace
# try to import PIL and numpy adaptors
from cv import *
from ml import *
from adaptors import *

109468
interfaces/swig/python/_cv.cpp
View File

File diff suppressed because it is too large Load Diff

9429
interfaces/swig/python/_highgui.cpp
View File

File diff suppressed because it is too large Load Diff

50413
interfaces/swig/python/_ml.cpp
View File

File diff suppressed because it is too large Load Diff

339
interfaces/swig/python/adaptors.py
View File

@ -1,339 +0,0 @@
#########################################################################################
#
# 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.
#
#########################################################################################
# 2004-03-16, Mark Asbach <asbach@ient.rwth-aachen.de>
# Institute of Communications Engineering, RWTH Aachen University
# 2007-02-xx, direct interface to numpy by Vicent Mas <vmas@carabos.com>
# Carabos Coop. V.
# 2007-10-08, try/catch
"""Adaptors to interchange data with numpy and/or PIL
This module provides explicit conversion of OpenCV images/matrices to and from
the Python Imaging Library (PIL) and python's newest numeric library (numpy).
Currently supported image/matrix formats are:
- 3 x 8 bit RGB (GBR)
- 1 x 8 bit Grayscale
- 1 x 32 bit Float
In numpy, images are represented as multidimensional arrays with
a third dimension representing the image channels if more than one
channel is present.
"""
import cv
try:
import PIL.Image
###########################################################################
def Ipl2PIL(input):
"""Converts an OpenCV/IPL image to PIL the Python Imaging Library.
Supported input image formats are
IPL_DEPTH_8U x 1 channel
IPL_DEPTH_8U x 3 channels
IPL_DEPTH_32F x 1 channel
"""
if not isinstance(input, cv.CvMat):
raise TypeError, 'must be called with a cv.CvMat!'
#orientation
if input.origin == 0:
orientation = 1 # top left
elif input.origin == 1:
orientation = -1 # bottom left
else:
raise ValueError, 'origin must be 0 or 1!'
# mode dictionary:
# (channels, depth) : (source mode, dest mode, depth in byte)
mode_list = {
(1, cv.IPL_DEPTH_8U) : ("L", "L", 1),
(3, cv.IPL_DEPTH_8U) : ("BGR", "RGB", 3),
(1, cv.IPL_DEPTH_32F) : ("F", "F", 4)
}
key = (input.nChannels, input.depth)
if not mode_list.has_key(key):
raise ValueError, 'unknown or unsupported input mode'
modes = mode_list[key]
return PIL.Image.fromstring(
modes[1], # mode
(input.width, input.height), # size tuple
input.imageData, # data
"raw",
modes[0], # raw mode
input.widthStep, # stride
orientation # orientation
)
###########################################################################
def PIL2Ipl(input):
"""Converts a PIL image to the OpenCV/IPL CvMat data format.
Supported input image formats are:
RGB
L
F
"""
if not (isinstance(input, PIL.Image.Image)):
raise TypeError, 'Must be called with PIL.Image.Image!'
# mode dictionary:
# (pil_mode : (ipl_depth, ipl_channels)
mode_list = {
"RGB" : (cv.IPL_DEPTH_8U, 3),
"L" : (cv.IPL_DEPTH_8U, 1),
"F" : (cv.IPL_DEPTH_32F, 1)
}
if not mode_list.has_key(input.mode):
raise ValueError, 'unknown or unsupported input mode'
result = cv.cvCreateImage(
cv.cvSize(input.size[0], input.size[1]), # size
mode_list[input.mode][0], # depth
mode_list[input.mode][1] # channels
)
# set imageData
result.imageData = input.tostring()
return result
except ImportError:
pass
#############################################################################
#############################################################################
try:
import numpy
###########################################################################
def NumPy2Ipl(input):
"""Converts a numpy array to the OpenCV/IPL CvMat data format.
Supported input array layouts:
2 dimensions of numpy.uint8
3 dimensions of numpy.uint8
2 dimensions of numpy.float32
2 dimensions of numpy.float64
"""
if not isinstance(input, numpy.ndarray):
raise TypeError, 'Must be called with numpy.ndarray!'
# Check the number of dimensions of the input array
ndim = input.ndim
if not ndim in (2, 3):
raise ValueError, 'Only 2D-arrays and 3D-arrays are supported!'
# Get the number of channels
if ndim == 2:
channels = 1
else:
channels = input.shape[2]
# Get the image depth
if input.dtype == numpy.uint8:
depth = cv.IPL_DEPTH_8U
elif input.dtype == numpy.float32:
depth = cv.IPL_DEPTH_32F
elif input.dtype == numpy.float64:
depth = cv.IPL_DEPTH_64F
# supported modes list: [(channels, dtype), ...]
modes_list = [(1, numpy.uint8), (3, numpy.uint8), (1, numpy.float32), (1, numpy.float64)]
# Check if the input array layout is supported
if not (channels, input.dtype) in modes_list:
raise ValueError, 'Unknown or unsupported input mode'
result = cv.cvCreateImage(
cv.cvSize(input.shape[1], input.shape[0]), # size
depth, # depth
channels # channels
)
# set imageData
result.imageData = input.tostring()
return result
###########################################################################
def Ipl2NumPy(input):
"""Converts an OpenCV/IPL image to a numpy array.
Supported input image formats are
IPL_DEPTH_8U x 1 channel
IPL_DEPTH_8U x 3 channels
IPL_DEPTH_32F x 1 channel
IPL_DEPTH_32F x 2 channels
IPL_DEPTH_32S x 1 channel
IPL_DEPTH_64F x 1 channel
IPL_DEPTH_64F x 2 channels
"""
if not isinstance(input, cv.CvMat):
raise TypeError, 'must be called with a cv.CvMat!'
# data type dictionary:
# (channels, depth) : numpy dtype
ipl2dtype = {
(1, cv.IPL_DEPTH_8U) : numpy.uint8,
(3, cv.IPL_DEPTH_8U) : numpy.uint8,
(1, cv.IPL_DEPTH_32F) : numpy.float32,
(2, cv.IPL_DEPTH_32F) : numpy.float32,
(1, cv.IPL_DEPTH_32S) : numpy.int32,
(1, cv.IPL_DEPTH_64F) : numpy.float64,
(2, cv.IPL_DEPTH_64F) : numpy.float64
}
key = (input.nChannels, input.depth)
if not ipl2dtype.has_key(key):
raise ValueError, 'unknown or unsupported input mode'
# Get the numpy array and reshape it correctly
# ATTENTION: flipped dimensions width/height on 2007-11-15
if input.nChannels == 1:
array_1d = numpy.fromstring(input.imageData, dtype=ipl2dtype[key])
return numpy.reshape(array_1d, (input.height, input.width))
elif input.nChannels == 2:
array_1d = numpy.fromstring(input.imageData, dtype=ipl2dtype[key])
return numpy.reshape(array_1d, (input.height, input.width, 2))
elif input.nChannels == 3:
# Change the order of channels from BGR to RGB
rgb = cv.cvCreateImage(cv.cvSize(input.width, input.height), input.depth, 3)
cv.cvCvtColor(input, rgb, cv.CV_BGR2RGB)
array_1d = numpy.fromstring(rgb.imageData, dtype=ipl2dtype[key])
return numpy.reshape(array_1d, (input.height, input.width, 3))
except ImportError:
pass
###########################################################################
###########################################################################
try:
import PIL.Image
import numpy
###########################################################################
def PIL2NumPy(input):
"""THIS METHOD IS DEPRECATED
Converts a PIL image to a numpy array.
Supported input image formats are:
RGB
L
F
"""
if not (isinstance(input, PIL.Image.Image)):
raise TypeError, 'Must be called with PIL.Image.Image!'
# modes dictionary:
# pil_mode : numpy dtype
modes_map = {
"RGB" : numpy.uint8,
"L" : numpy.uint8,
"F" : numpy.float32
}
if not modes_map.has_key(input.mode):
raise ValueError, 'Unknown or unsupported input mode!. Supported modes are RGB, L and F.'
result_ro = numpy.asarray(input, dtype=modes_map[input.mode]) # Read-only array
return result_ro.copy() # Return a writeable array
###########################################################################
def NumPy2PIL(input):
"""THIS METHOD IS DEPRECATED
Converts a numpy array to a PIL image.
Supported input array layouts:
2 dimensions of numpy.uint8
3 dimensions of numpy.uint8
2 dimensions of numpy.float32
"""
if not isinstance(input, numpy.ndarray):
raise TypeError, 'Must be called with numpy.ndarray!'
# Check the number of dimensions of the input array
ndim = input.ndim
if not ndim in (2, 3):
raise ValueError, 'Only 2D-arrays and 3D-arrays are supported!'
if ndim == 2:
channels = 1
else:
channels = input.shape[2]
# supported modes list: [(channels, dtype), ...]
modes_list = [(1, numpy.uint8), (3, numpy.uint8), (1, numpy.float32)]
mode = (channels, input.dtype)
if not mode in modes_list:
raise ValueError, 'Unknown or unsupported input mode'
return PIL.Image.fromarray(input)
except ImportError:
pass

98
interfaces/swig/python/cv.i
View File

@ -1,98 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
%{
#include "pyhelpers.h"
#include "pycvseq.hpp"
#include "error.h"
%}
// direct SWIG to generate python docstrings
%feature("autodoc", 1);
// include python-specific files
%include "./nointpb.i"
%include "./pytypemaps.i"
%include "./cvshadow.i"
// parse OpenCV headers
%include "../general/cv.i"
// Accessors for the CvMat and IplImage data structure are defined here
%include "./cvarr.i"
// Python sequence compatibility for CvSeq
%include "./cvseq.i"
%include "./imagedata.i"
// We integrate OpenCV error handling into the Python exception mechanism
%include "./error.h"
// include some wrappers to manipulate CvSeq types
%include "./pycvseq.hpp"
// aliases from #defines
%include "./cvaliases_autogen.i"
%include "./cvaliases.i"
%pythoncode
%{
__doc__ = """
OpenCV is the Intel Open CV library, an open source effort to provide
computer vision algorithms for standard PC hardware.
This wrapper was semi-automatically created from the C/C++ headers and therefore
contains no Python documentation. Because all identifiers are identical to their
C/C++ counterparts, you can consult the standard manuals that come with OpenCV.
"""
# this tells OpenCV not to call exit() on errors but throw a python exception instead
cvRedirectError(function_ptr_generator(), void_ptr_generator(), void_ptrptr_generator())
%}

8627
interfaces/swig/python/cv.py
View File

File diff suppressed because it is too large Load Diff

61
interfaces/swig/python/cvaliases.i
View File

@ -1,61 +0,0 @@
/*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*/
/*M//
// This file contains custom python-based aliases for some methods where
// an autogenerated wrapper was unusable or missing.
//M*/
// This macro removes the wrapper for the function from_name, and creates
// an alias to to_name, so calling from_name() will invoke to_name()
%define %myalias(from_name, to_name)
%ignore from_name;
%pythoncode%{
from_name = to_name;
%}
%enddef
// Map functions using IplImage ** argument to CvArr ** function instead
%myalias(cvCalcBackProject, cvCalcArrBackProject);
%myalias(cvCalcBackProjectPatch, cvCalcArrBackProjectPatch);
%myalias(cvCalcImageHist, cvCalcArrHist);
%myalias(cvCalcHist, cvCalcArrHist);

56
interfaces/swig/python/cvaliases_autogen.i
View File

@ -1,56 +0,0 @@
/** This file was automatically generated using util/extract_aliases.py script */
%module cv
%pythoncode %{
IPL_ALIGN_DWORD=IPL_ALIGN_4BYTES
IPL_ALIGN_QWORD=IPL_ALIGN_8BYTES
CV_MAKE_TYPE=CV_MAKETYPE
CV_IS_CONT_MAT=CV_IS_MAT_CONT
CV_HIST_TREE=CV_HIST_SPARSE
CV_TERMCRIT_NUMBER=CV_TERMCRIT_ITER
CV_SEQ_ELTYPE_PTR=CV_USRTYPE1
CV_GRAPH=CV_SEQ_KIND_GRAPH
CV_SEQ_CONTOUR=CV_SEQ_POLYGON
CV_STORAGE_WRITE_TEXT=CV_STORAGE_WRITE
CV_STORAGE_WRITE_BINARY=CV_STORAGE_WRITE
CV_NODE_INTEGER=CV_NODE_INT
CV_NODE_FLOAT=CV_NODE_REAL
CV_NODE_STRING=CV_NODE_STR
cvGetSubArr=cvGetSubRect
cvZero=cvSetZero
cvCvtScale=cvConvertScale
cvScale=cvConvertScale
cvCvtScaleAbs=cvConvertScaleAbs
cvCheckArray=cvCheckArr
cvMatMulAddEx=cvGEMM
cvMatMulAddS=cvTransform
cvT=cvTranspose
cvMirror=cvFlip
cvInv=cvInvert
cvMahalonobis=cvMahalanobis
CV_DXT_INVERSE_SCALE=CV_DXT_INV_SCALE
cvFFT=cvDFT
cvGraphFindEdge=cvFindGraphEdge
cvGraphFindEdgeByPtr=cvFindGraphEdgeByPtr
cvDrawRect=cvRectangle
cvDrawLine=cvLine
cvDrawCircle=cvCircle
cvDrawEllipse=cvEllipse
cvDrawPolyLine=cvPolyLine
CV_FONT_VECTOR0=CV_FONT_HERSHEY_SIMPLEX
CV_RGB2RGBA=CV_BGR2BGRA
CV_RGBA2RGB=CV_BGRA2BGR
CV_RGB2BGRA=CV_BGR2RGBA
CV_BGRA2RGB=CV_RGBA2BGR
CV_RGB2BGR=CV_BGR2RGB
CV_RGBA2BGRA=CV_BGRA2RGBA
CV_GRAY2RGB=CV_GRAY2BGR
CV_GRAY2RGBA=CV_GRAY2BGRA
CV_BayerBG2RGB=CV_BayerRG2BGR
CV_BayerGB2RGB=CV_BayerGR2BGR
CV_BayerRG2RGB=CV_BayerBG2BGR
CV_BayerGR2RGB=CV_BayerGB2BGR
CV_FM_LMEDS_ONLY=CV_LMEDS
CV_FM_RANSAC_ONLY=CV_RANSAC
CV_FM_LMEDS=CV_LMEDS
CV_FM_RANSAC=CV_RANSAC
%}

534
interfaces/swig/python/cvarr.i
View File

@ -1,534 +0,0 @@
/*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
// 2009-01-07 Added numpy array interface, Mark Asbach <asbach@ient.rwth-aachen.de>
/*M//////////////////////////////////////////////////////////////////////////////////////////
// Macros for extending CvMat and IplImage -- primarily for operator overloading
//////////////////////////////////////////////////////////////////////////////////////////M*/
// Macro to define python 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, pyfunc, argtype, cvfunc, newobjcall)
%newobject cname::pyfunc(argtype arg);
%extend cname {
rettype pyfunc(argtype arg){
rettype retarg = newobjcall;
cvfunc;
return retarg;
}
}
%enddef
// Macro to define python function of the form B = A.f(c)
// where A and B are both CvArr of same size and type
%define %wrap_cvArr_binaryop(pyfunc, argtype, cvfunc)
%wrap_cvGeneric_CvArr(CvMat, CvMat *, pyfunc, argtype, cvfunc,
cvCreateMat(self->rows, self->cols, self->type));
%wrap_cvGeneric_CvArr(IplImage, IplImage *, pyfunc, argtype, cvfunc,
cvCreateImage(cvGetSize(self), self->depth, self->nChannels));
%enddef
// Macro to define python function of the form A = A.f(c)
// where f modifies A inplace
// use for +=, etc
%define %wrap_cvGeneric_InPlace(cname, rettype, pyfunc, argtype, cvfunc)
%wrap_cvGeneric_CvArr(cname, rettype, pyfunc, 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(pyfunc, cvfunc)
%wrap_cvArr_binaryop(pyfunc, CvArr *, cvfunc(self, arg, retarg));
%enddef
// map any OpenCV function of form cvFunc(src1, value, dst)
%define %wrap_cvArithS(pyfunc, cvfuncS)
%wrap_cvArr_binaryop(pyfunc, CvScalar, cvfuncS(self, arg, retarg));
%wrap_cvArr_binaryop(pyfunc, double, cvfuncS(self, cvScalar(arg), retarg));
%enddef
// same as wrap_cvArith
%define %wrap_cvLogic(pyfunc, cvfunc)
%wrap_cvArr_binaryop(pyfunc, CvArr *, cvfunc(self, arg, retarg))
%enddef
// same as wrap_cvArithS
%define %wrap_cvLogicS(pyfunc, cvfuncS)
%wrap_cvArr_binaryop(pyfunc, CvScalar, cvfuncS(self, arg, retarg));
%wrap_cvArr_binaryop(pyfunc, double, cvfuncS(self, cvScalar(arg), retarg));
%enddef
// Macro to map logical operations to cvCmp
%define %wrap_cvCmp(pyfunc, cmp_op)
%wrap_cvGeneric_CvArr(CvMat, CvMat *, pyfunc, CvMat *,
cvCmp(self, arg, retarg, cmp_op),
cvCreateMat(self->rows, self->cols, CV_8U));
%wrap_cvGeneric_CvArr(IplImage, IplImage *, pyfunc, IplImage *,
cvCmp(self, arg, retarg, cmp_op),
cvCreateImage(cvGetSize(self), 8, 1));
%enddef
%define %wrap_cvCmpS(pyfunc, cmp_op)
%wrap_cvGeneric_CvArr(CvMat, CvMat *, pyfunc, double,
cvCmpS(self, arg, retarg, cmp_op),
cvCreateMat(self->rows, self->cols, CV_8U));
%wrap_cvGeneric_CvArr(IplImage, IplImage *, pyfunc, double,
cvCmpS(self, arg, retarg, cmp_op),
cvCreateImage(cvGetSize(self), 8, 1));
%enddef
// special case for cvScale, /, *
%define %wrap_cvScale(pyfunc, scale)
%wrap_cvGeneric_CvArr(CvMat, CvMat *, pyfunc, double,
cvScale(self, retarg, scale),
cvCreateMat(self->rows, self->cols, self->type));
%wrap_cvGeneric_CvArr(IplImage, IplImage *, pyfunc, 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 *, cvMul(arg, self, retarg));
%wrap_cvArithS(__radd__, cvAddS);
%wrap_cvArithS(__rsub__, cvSubRS);
%wrap_cvScale(__rmul__, 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);
// special case for scalar-array division
%wrap_cvGeneric_CvArr(CvMat, CvMat *, __rdiv__, double,
cvDiv(NULL, self, retarg, arg),
cvCreateMat(self->rows, self->cols, self->type));
// misc operators for python
%wrap_cvArr_binaryop(__pow__, double, cvPow(self, retarg, arg))
// TODO -- other Python operators listed below and at:
// http://docs.python.org/ref/numeric-types.html
// __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::__getitem__(PyObject * object);
%newobject _IplImage::__getitem__(PyObject * object);
%header %{
int checkSliceBounds(const CvRect & rect, int w, int h){
//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 -1;
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);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return -1;
}
return 0;
}
%}
// Macro to check bounds of slice and throw error if outside
%define CHECK_SLICE_BOUNDS(rect,w,h,retval)
if(CheckSliceBounds(&rect,w,h)==-1){ 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;
}
// scalar assignment
void __setitem__(PyObject * object, double val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalarAll(val));
}
void __setitem__(PyObject * object, CvPoint val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalar(val.x, val.y));
}
void __setitem__(PyObject * object, CvPoint2D32f val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
cvSet(&tmp, cvScalar(val.x, val.y));
}
void __setitem__(PyObject * object, CvScalar val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, );
cvSet(&tmp, val);
}
// array slice assignment
void __setitem__(PyObject * object, CvArr * arr){
CvMat tmp, src_stub, *src;
CvRect subrect = PySlice_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
// PyObject_to_CvArr tries to compress a 2-D python
// 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
PyObject * __getitem__(PyObject * object){
CvMat * mat;
CvRect subrect = PySlice_to_CvRect( self, object );
CHECK_SLICE_BOUNDS( subrect, self->cols, self->rows, NULL );
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 PyLong_FromUnsignedLong( CV_MAT_ELEM(*self, uchar, subrect.y, subrect.x ) );
case CV_8S:
return PyLong_FromLong( CV_MAT_ELEM(*self, char, subrect.y, subrect.x ) );
case CV_16U:
return PyLong_FromUnsignedLong( CV_MAT_ELEM(*self, ushort, subrect.y, subrect.x ) );
case CV_16S:
return PyLong_FromLong( CV_MAT_ELEM(*self, short, subrect.y, subrect.x ) );
case CV_32S:
return PyLong_FromLong( CV_MAT_ELEM(*self, int, subrect.y, subrect.x ) );
case CV_32F:
return PyFloat_FromDouble( CV_MAT_ELEM(*self, float, subrect.y, subrect.x) );
case CV_64F:
return PyFloat_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 );
}
// ~ operator -- swig doesn't generate this from the C++ equivalent
CvMat * __invert__(){
CvMat * res = cvCreateMat(self->rows, self->cols, self->type);
cvNot( self, res );
return res;
}
%pythoncode %{
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, python 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)
def __get_array_interface__ (self):
"""Compose numpy array interface
Via the numpy array interface, OpenCV data structures can be directly passed to numpy
methods without copying / converting. This tremendously speeds up mixing code from
OpenCV and numpy.
See: http://numpy.scipy.org/array_interface.shtml
@author Mark Asbach <asbach@ient.rwth-aachen.de>
@date 2009-01-07
"""
if self.depth == IPL_DEPTH_8U:
typestr = '|u1'
bytes_per_pixel = 1
elif self.depth == IPL_DEPTH_8S:
typestr = '|i1'
bytes_per_pixel = 1
elif self.depth == IPL_DEPTH_16U:
typestr = '|u2'
bytes_per_pixel = 2
elif self.depth == IPL_DEPTH_16S:
typestr = '|i2'
bytes_per_pixel = 2
elif self.depth == IPL_DEPTH_32S:
typestr = '|i4'
bytes_per_pixel = 4
elif self.depth == IPL_DEPTH_32F:
typestr = '|f4'
bytes_per_pixel = 4
elif self.depth == IPL_DEPTH_64F:
typestr = '|f8'
bytes_per_pixel = 8
else:
raise TypeError("unknown resp. unhandled OpenCV image/matrix format")
if self.nChannels == 1:
# monochrome image, matrix with a single channel
return {'shape': (self.height, self.width),
'typestr': typestr,
'version': 3,
'data': (int (self.data.ptr), False),
'strides': (int (self.widthStep), int (bytes_per_pixel))}
else:
# color image, image with alpha, matrix with multiple channels
return {'shape': (self.height, self.width, self.nChannels),
'typestr': typestr,
'version': 3,
'data': (int (self.data.ptr), False),
'strides': (int (self.widthStep), int (self.nChannels * bytes_per_pixel), int (bytes_per_pixel))}
__array_interface__ = property (__get_array_interface__, doc = "numpy array interface description")
%}
} //extend CvMat
// slice access and assignment for IplImage
%extend _IplImage
{
char * __str__(){
static char str[8];
cvArrPrint( self );
str[0]=0;
return str;
}
// scalar assignment
void __setitem__(PyObject * object, double val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalarAll(val));
}
void __setitem__(PyObject * object, CvPoint val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalar(val.x, val.y));
}
void __setitem__(PyObject * object, CvPoint2D32f val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, cvScalar(val.x, val.y));
}
void __setitem__(PyObject * object, CvScalar val){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvSet(&tmp, val);
}
// array slice assignment
void __setitem__(PyObject * object, CvArr * arr){
CvMat tmp;
CvRect subrect = PySlice_to_CvRect( self, object );
cvGetSubRect(self, &tmp, subrect);
cvConvert(arr, &tmp);
}
// slice access
PyObject * __getitem__(PyObject * object){
CvMat mat;
IplImage * im;
CvRect subrect = PySlice_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 PyLong_FromUnsignedLong( CV_IMAGE_ELEM(self, uchar, subrect.y, subrect.x ) );
case CV_8S:
return PyLong_FromLong( CV_IMAGE_ELEM(self, char, subrect.y, subrect.x ) );
case CV_16U:
return PyLong_FromUnsignedLong( CV_IMAGE_ELEM(self, ushort, subrect.y, subrect.x ) );
case CV_16S:
return PyLong_FromLong( CV_IMAGE_ELEM(self, short, subrect.y, subrect.x ) );
case CV_32S:
return PyLong_FromLong( CV_IMAGE_ELEM(self, int, subrect.y, subrect.x ) );
case CV_32F:
return PyFloat_FromDouble( CV_IMAGE_ELEM(self, float, subrect.y, subrect.x) );
case CV_64F:
return PyFloat_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 );
}
}

105
interfaces/swig/python/cvseq.i
View File

@ -1,105 +0,0 @@
/*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-08-02 Roman Stanchak <rstancha@cse.wustl.edu>
%include "pycvseq.hpp"
%template (CvTuple_CvPoint_2) CvTuple<CvPoint,2>;
%template (CvTuple_float_2) CvTuple<float,2>;
%template (CvTuple_float_3) CvTuple<float,3>;
%template (CvSeq_CvPoint) CvTypedSeq<CvPoint>;
%template (CvSeq_CvPoint2D32f) CvTypedSeq<CvPoint2D32f>;
%template (CvSeq_CvRect) CvTypedSeq<CvRect>;
%template (CvSeq_CvSeq) CvTypedSeq<CvSeq *>;
%template (CvSeq_CvQuadEdge2D) CvTypedSeq<CvQuadEdge2D>;
%template (CvSeq_CvConnectedComp) CvTypedSeq<CvConnectedComp>;
%template (CvSeq_CvPoint_2) CvTypedSeq< CvTuple<CvPoint,2> >;
%template (CvSeq_float_2) CvTypedSeq< CvTuple<float,2> >;
%template (CvSeq_float_3) CvTypedSeq< CvTuple<float,3> >;
%extend CvSeq {
%pythoncode %{
def __iter__(self):
"""
generator function iterating elements in the sequence
"""
for i in range(self.total):
yield self[i]
def vrange(self):
"""
generator function iterating along v_next
"""
s = self
t = type(self)
while s:
yield s
s = t.cast(s.v_next)
def hrange(self):
"""
generator function iterating along h_next
"""
s = self
t = type(self)
while s:
yield s
s = t.cast(s.h_next)
%}
}
// accessor to turn edges into a typed sequence
%extend CvSubdiv2D {
CvTypedSeq<CvQuadEdge2D> * typed_edges;
CvTypedSeq<CvQuadEdge2D> * typed_edges_get(){
return (CvTypedSeq<CvQuadEdge2D> *) self->edges;
}
void typed_edges_set( CvTypedSeq<CvQuadEdge2D> * ){
}
%pythoncode %{
def __iter__(self):
s = CvSeq_QuadEdge2D.cast(self)
for i in range(s.total):
yield s[i]
%}
}

83
interfaces/swig/python/cvshadow.cpp
View File

@ -1,83 +0,0 @@
#include <cxcore.h>
#include <cv.h>
#include <stdio.h>
#include "cvshadow.h"
CvArr * cvCvtSeqToArray_Shadow( const CvSeq* seq, CvArr * elements, CvSlice slice){
CvMat stub, *mat=(CvMat *)elements;
if(!CV_IS_MAT(mat)){
mat = cvGetMat(elements, &stub);
}
cvCvtSeqToArray( seq, mat->data.ptr, slice );
return elements;
}
double cvArcLength_Shadow( const CvSeq * seq, CvSlice slice, int is_closed){
return cvArcLength( seq, slice, is_closed );
}
double cvArcLength_Shadow( const CvArr * arr, CvSlice slice, int is_closed){
return cvArcLength( arr, slice, is_closed );
}
void cvMoments_Shadow( const CvSeq * seq, CvMoments * moments, int binary ){
cvMoments( seq, moments, binary );
}
void cvMoments_Shadow( const CvArr * seq, CvMoments * moments, int binary ){
cvMoments( seq, moments, binary );
}
CvTypedSeq<CvRect> * cvHaarDetectObjects_Shadow( const CvArr* image, CvHaarClassifierCascade* cascade,
CvMemStorage* storage, double scale_factor, int min_neighbors, int flags,
CvSize min_size )
{
return (CvTypedSeq<CvRect> *) cvHaarDetectObjects( image, cascade, storage, scale_factor,
min_neighbors, flags, min_size);
}
CvTypedSeq<CvConnectedComp> * cvSegmentMotion_Shadow( const CvArr* mhi, CvArr* seg_mask, CvMemStorage* storage,
double timestamp, double seg_thresh ){
return (CvTypedSeq<CvConnectedComp> *) cvSegmentMotion( mhi, seg_mask, storage, timestamp, seg_thresh );
}
CvTypedSeq<CvPoint> * cvApproxPoly_Shadow( const void* src_seq, int header_size, CvMemStorage* storage,
int method, double parameter, int parameter2)
{
return (CvTypedSeq<CvPoint> *) cvApproxPoly( src_seq, header_size, storage, method, parameter, parameter2 );
}
// Always return a new Mat of indices
CvMat * cvConvexHull2_Shadow( const CvArr * points, int orientation, int return_points){
CvMat * hull=0;
CvMat * points_mat=(CvMat *) points;
CvSeq * points_seq=(CvSeq *) points;
int npoints, type;
if(CV_IS_MAT(points_mat)){
npoints = MAX(points_mat->rows, points_mat->cols);
type = return_points ? points_mat->type : CV_32S;
}
else if(CV_IS_SEQ(points_seq)){
npoints = points_seq->total;
type = return_points ? CV_SEQ_ELTYPE(points_seq) : 1;
}
else{
CV_Error(CV_StsBadArg, "points must be a CvSeq or CvMat");
}
hull=cvCreateMat(1,npoints,type);
cvConvexHull2(points, hull, orientation, return_points);
return hull;
}
std::vector<CvPoint> cvSnakeImage_Shadow( const CvMat * image, std::vector<CvPoint> points,
std::vector<float> alpha, std::vector<float> beta,
std::vector<float> gamma,
CvSize win, CvTermCriteria criteria, int calc_gradient ){
IplImage ipl_stub;
cvSnakeImage( cvGetImage(image, &ipl_stub), &(points[0]), points.size(),
&((alpha)[0]), &((beta)[0]), &((gamma)[0]),
(alpha.size()>1 && beta.size()>1 && gamma.size()>1 ? CV_ARRAY : CV_VALUE),
win, criteria, calc_gradient );
return points;
}

29
interfaces/swig/python/cvshadow.h
View File

@ -1,29 +0,0 @@
#ifndef CV_SHADOW_H
#define CV_SHADOW_H
#include <vector>
#include "cxtypes.h"
#include "cvtypes.h"
#include "pycvseq.hpp"
// modify cvCvtSeqToArray to take CvArr as input instead of raw data
CvArr * cvCvtSeqToArray_Shadow( const CvSeq* seq, CvArr * elements, CvSlice slice=CV_WHOLE_SEQ);
// Return a typed sequence instead of generic CvSeq
CvTypedSeq<CvRect> * cvHaarDetectObjects_Shadow( const CvArr* image, CvHaarClassifierCascade* cascade,
CvMemStorage* storage, double scale_factor=1.1, int min_neighbors=3, int flags=0,
CvSize min_size=cvSize(0,0) );
CvTypedSeq<CvConnectedComp> * cvSegmentMotion_Shadow( const CvArr* mhi, CvArr* seg_mask, CvMemStorage* storage,
double timestamp, double seg_thresh );
CvTypedSeq<CvPoint> * cvApproxPoly_Shadow( const void* src_seq, int header_size, CvMemStorage* storage,
int method, double parameter, int parameter2=0);
// Always return a new Mat of indices
CvMat * cvConvexHull2_Shadow( const CvArr * points, int orientation=CV_CLOCKWISE,
int return_points=0);
std::vector<CvPoint> cvSnakeImage_Shadow( const CvMat * image, std::vector<CvPoint> points,
std::vector<float> alpha, std::vector<float> beta, std::vector<float> gamma,
CvSize win, CvTermCriteria criteria, int calc_gradient=1 );
#endif

137
interfaces/swig/python/cvshadow.i
View File

@ -1,137 +0,0 @@
/*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*/
/* This file contains custom python shadow class code for certain troublesome functions */
%{
#include "cvshadow.h"
%}
// source %myshadow, %myrelease macros
%include "cvswigmacros.i"
%include "stl.i"
// %ignore, %rename must come before %include
%myshadow(cvCvtSeqToArray);
%myshadow(cvHaarDetectObjects);
%myshadow(cvSegmentMotion);
%myshadow(cvApproxPoly);
%myshadow(cvConvexHull2);
%newobject cvConvexHull2_Shadow; // shadowed functioned always returns new object
/* cvSnakeImage shadow uses a vector<CvPoint> and vector<float> */
%template(FloatVector) std::vector<float>;
%template(CvPointVector) std::vector<CvPoint>;
%myshadow(cvSnakeImage);
// must come after %ignore, %rename
%include "cvshadow.h"
/* return a typed CvSeq instead of generic for CvSubdiv2D edges -- see cvseq.i */
%rename (untyped_edges) CvSubdiv2D::edges;
%ignore CvSubdiv2D::edges;
%rename (edges) CvSubdiv2D::typed_edges;
/* Python doesn't know what to do with these */
%rename (asIplImage) operator IplImage*;
%rename (asCvMat) operator CvMat*;
%ignore operator const IplImage*;
%ignore operator const CvMat*;
/* Define sequence type for functions returning sequences */
%define %cast_seq( cvfunc, type )
%rename (cvfunc##Untyped) cvfunc;
%pythoncode %{
def cvfunc(*args):
seq = cvfunc##Untyped( *args )
return type.cast(seq)
%}
%enddef
%cast_seq( cvHoughCircles, CvSeq_float_3 );
%cast_seq( cvPyrSegmentation, CvSeq_CvConnectedComp );
%cast_seq( cvApproxChains, CvSeq_CvPoint);
%cast_seq( cvContourFromContourTree, CvSeq_CvPoint );
%cast_seq( cvConvexityDefects, CvSeq_CvConvexityDefect );
/* Special cases ... */
%rename(cvFindContoursUntyped) cvFindContours;
%pythoncode %{
def cvFindContours( *args ):
count, seq = cvFindContoursUntyped( *args )
return count, CvSeq_CvPoint.cast(seq)
%}
/* cvHoughLines2 returns a different type of sequence depending on its args */
%rename (cvHoughLinesUntyped) cvHoughLines2;
%pythoncode %{
def cvHoughLines2( *args ):
seq = cvHoughLinesUntyped( *args )
type = CV_SEQ_ELTYPE(seq)
if type == CV_32SC4:
return CvSeq_CvPoint_2.cast(seq)
return CvSeq_float_2.cast(seq)
%}
// cvPointSeqFromMat
// cvSeqPartition
// cvSeqSlice
// cvTreeToNodeSeq
// Fix cvRelease* function to play nice w/ Python
// TODO some of these objects lack the delete method -- why???
%myrelease(cv, cvReleaseImage, CvMat); // IplImage is CvMat in Python
%myrelease(cv, cvReleaseMat, CvMat);
%myrelease(cv, cvReleaseStructuringElement, IplConvKernel);
%myrelease(cv, cvReleaseKalman, CvKalman);
%myrelease(cv, cvReleaseHist, CvHistogram);
%myrelease(cv, cvReleaseHaarClassifierCascade, CvHaarClassifierCascade);
//%myrelease(cvReleasePOSITObject, CvPOSITObject);
%myrelease(cv, cvReleaseImageHeader, CvMat); // IplImage is CvMat
%myrelease(cv, cvReleaseMatND, CvMatND);
%myrelease(cv, cvReleaseSparseMat, CvSparseMat);
%myrelease(cv, cvReleaseMemStorage, CvMemStorage);
%myrelease(cv, cvReleaseGraphScanner, CvGraphScanner);
//%myrelease(cvReleaseFileStorage, CvFileStorage);
// TODO implement this
%ignore cvRelease;

75
interfaces/swig/python/cvswigmacros.i
View File

@ -1,75 +0,0 @@
/*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*/
/* This file contains swig macros that are used in several typemap files */
%define %myshadow(function)
%ignore function;
%rename (function) function##_Shadow;
%enddef
// Elsewhere in this wrapper, the cvRelease* functions are mapped to
// the destructors for the corresponding OpenCV object wrapper. This
// is done in order to let Python handle memory management. If the
// reference count of the Python object wrapping the OpenCV object
// goes to 0, the garbage collector will call the destructor, and
// therefore the cvRelease* function, before freeing the Python object.
// However, if the user explicitly calls the cvRelease* function, we
// must prevent the Python garbage collector from calling it again when
// the refcount reaches 0 -- otherwise a double-free error occurs.
//
// Thus, below, we redirect each cvRelease* function to the
// corresponding OpenCV object's destructor. This has the effect of:
// (1) Calling the corresponding cvRelease* function, and therefore
// immediately releasing the OpenCV object.
// (2) Telling SWIG to disown memory management for this OpenCV object.
//
// Thus, when the refcount for the Python object reaches 0, the Python
// object is garbage collected, but since it no longer owns the OpenCV
// object, this is not freed again.
%define %myrelease(module, Function, Type)
%ignore Function;
%rename (Function) Function##_Shadow;
%pythoncode %{
Function = _##module##.delete_##Type
%}
%enddef

113
interfaces/swig/python/error.cpp
View File

@ -1,113 +0,0 @@
/*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*/
// 2004-03-17, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// Python header.
// It may be required that this header is the first to be included
// (see Python documentation for details)
#include "Python.h"
#include "error.h"
#include <sstream>
#include <iostream>
// OpenCV headers
#include "cxcore.h"
#include "cxerror.h"
//=========================================================================
int SendErrorToPython
(
int status,
const char* func_name,
const char* err_msg,
const char* file_name,
int line,
void* /*userdata*/
)
throw(int)
{
std::stringstream message;
message
<< " openCV Error:"
<< "\n Status=" << cvErrorStr(status)
<< "\n function name=" << (func_name ? func_name : "unknown")
<< "\n error message=" << (err_msg ? err_msg : "unknown")
<< "\n file_name=" << (file_name ? file_name : "unknown")
<< "\n line=" << line
<< std::flush;
// Clear OpenCV's error status for the next call!
cvSetErrStatus( CV_StsOk );
// Set Python Error.
// ATTENTION: this only works if the function returning to
// Python returns 0 instead of a PyObject (see also "custom_typemaps.i"
PyErr_SetString(PyExc_RuntimeError, message.str().c_str());
throw 1;
return 0;
}
//=========================================================================
void* void_ptr_generator()
{
return 0;
}
//=========================================================================
void** void_ptrptr_generator()
{
return 0;
}
//=========================================================================
CvErrorCallback function_ptr_generator()
{
return &SendErrorToPython;
}

68
interfaces/swig/python/error.h
View File

@ -1,68 +0,0 @@
/*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*/
// 2004-03-17, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
#include "cxcore.h"
/**
* This function will set a Python error and throw an int.
* Exceptions are catched automatically by the SWIG code from "typemaps.i"
*/
int SendErrorToPython ( int status,
const char * func_name,
const char * err_msg,
const char * file_name,
int line,
void * /*userdata*/) throw(int);
/// Returns the adress of the static method "SendErrorToPython()"
CvErrorCallback function_ptr_generator();
/// Dummy to generate an empty void pointer
void * void_ptr_generator();
/// Dummy to generate an empty void double pointer
void ** void_ptrptr_generator();

296
interfaces/swig/python/highgui.i
View File

@ -1,296 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
%{
#include <cxtypes.h>
#include <cv.h>
#include <highgui.h>
#include "pyhelpers.h"
#include "pycvseq.hpp"
%}
// include python-specific files
%include "./nointpb.i"
%include "./pytypemaps.i"
%include "exception.i"
%include "cvswigmacros.i"
// handle camera and video writer destruction
%myrelease(highgui, cvReleaseCapture, CvCapture);
%myrelease(highgui, cvReleaseVideoWriter, CvVideoWriter);
/* the wrapping code to enable the use of Python-based mouse callbacks */
%header %{
/* This encapsulates the python callback and user_data for mouse callback */
struct PyCvMouseCBData {
PyObject * py_func;
PyObject * user_data;
};
/* This encapsulates the python callback and user_data for mouse callback */
/* C helper function which is responsible for calling
the Python real trackbar callback function */
static void icvPyOnMouse (int event, int x, int y,
int flags, PyCvMouseCBData * param) {
/* Must ensure this thread has a lock on the interpreter */
PyGILState_STATE state = PyGILState_Ensure();
PyObject *result;
/* the argument of the callback ready to be passed to Python code */
PyObject *arg1 = PyInt_FromLong (event);
PyObject *arg2 = PyInt_FromLong (x);
PyObject *arg3 = PyInt_FromLong (y);
PyObject *arg4 = PyInt_FromLong (flags);
PyObject *arg5 = param->user_data; // assume this is already a PyObject
/* build the tuple for calling the Python callback */
PyObject *arglist = Py_BuildValue ("(OOOOO)",
arg1, arg2, arg3, arg4, arg5);
/* call the Python callback */
result = PyEval_CallObject (param->py_func, arglist);
/* Errors in Python callback get swallowed, so report them here */
if(!result){
PyErr_Print();
cvError( CV_StsInternal, "icvPyOnMouse", "", __FILE__, __LINE__);
}
/* cleanup */
Py_XDECREF (result);
/* Release Interpreter lock */
PyGILState_Release(state);
}
%}
/**
* adapt cvSetMouseCallback to use python callback
*/
%rename (cvSetMouseCallbackOld) cvSetMouseCallback;
%rename (cvSetMouseCallback) cvSetMouseCallbackPy;
%inline %{
void cvSetMouseCallbackPy( const char* window_name, PyObject * on_mouse, PyObject * param=NULL ){
// TODO potential memory leak if mouse callback is redefined
PyCvMouseCBData * py_callback = new PyCvMouseCBData;
py_callback->py_func = on_mouse;
py_callback->user_data = param ? param : Py_None;
Py_XINCREF(py_callback->py_func);
Py_XINCREF(py_callback->user_data);
cvSetMouseCallback( window_name, (CvMouseCallback) icvPyOnMouse, (void *) py_callback );
}
%}
/**
* The following code enables trackbar callbacks from python. Unfortunately, there is no
* way to distinguish which trackbar the event originated from, so must hard code a
* fixed number of unique c callback functions using the macros below
*/
%wrapper %{
/* C helper function which is responsible for calling
the Python real trackbar callback function */
static void icvPyOnTrackbar( PyObject * py_cb_func, int pos) {
/* Must ensure this thread has a lock on the interpreter */
PyGILState_STATE state = PyGILState_Ensure();
PyObject *result;
/* the argument of the callback ready to be passed to Python code */
PyObject *arg1 = PyInt_FromLong (pos);
/* build the tuple for calling the Python callback */
PyObject *arglist = Py_BuildValue ("(O)", arg1);
/* call the Python callback */
result = PyEval_CallObject (py_cb_func, arglist);
/* Errors in Python callback get swallowed, so report them here */
if(!result){
PyErr_Print();
cvError( CV_StsInternal, "icvPyOnTrackbar", "", __FILE__, __LINE__);
}
/* cleanup */
Py_XDECREF (result);
/* Release Interpreter lock */
PyGILState_Release(state);
}
#define ICV_PY_MAX_CB 10
struct PyCvTrackbar {
CvTrackbarCallback cv_func;
PyObject * py_func;
PyObject * py_pos;
};
static int my_trackbar_cb_size=0;
extern PyCvTrackbar my_trackbar_cb_funcs[ICV_PY_MAX_CB];
%}
/* Callback table entry */
%define %ICV_PY_CB_TAB_ENTRY(idx)
{(CvTrackbarCallback) icvPyTrackbarCB##idx, NULL, NULL }
%enddef
/* Table of callbacks */
%define %ICV_PY_CB_TAB
%wrapper %{
PyCvTrackbar my_trackbar_cb_funcs[ICV_PY_MAX_CB] = {
%ICV_PY_CB_TAB_ENTRY(0),
%ICV_PY_CB_TAB_ENTRY(1),
%ICV_PY_CB_TAB_ENTRY(2),
%ICV_PY_CB_TAB_ENTRY(3),
%ICV_PY_CB_TAB_ENTRY(4),
%ICV_PY_CB_TAB_ENTRY(5),
%ICV_PY_CB_TAB_ENTRY(6),
%ICV_PY_CB_TAB_ENTRY(7),
%ICV_PY_CB_TAB_ENTRY(8),
%ICV_PY_CB_TAB_ENTRY(9)
};
%}
%enddef
/* Callback definition */
%define %ICV_PY_CB_IMPL(idx)
%wrapper %{
static void icvPyTrackbarCB##idx(int pos){
if(!my_trackbar_cb_funcs[idx].py_func) return;
icvPyOnTrackbar( my_trackbar_cb_funcs[idx].py_func, pos );
}
%}
%enddef
%ICV_PY_CB_IMPL(0);
%ICV_PY_CB_IMPL(1);
%ICV_PY_CB_IMPL(2);
%ICV_PY_CB_IMPL(3);
%ICV_PY_CB_IMPL(4);
%ICV_PY_CB_IMPL(5);
%ICV_PY_CB_IMPL(6);
%ICV_PY_CB_IMPL(7);
%ICV_PY_CB_IMPL(8);
%ICV_PY_CB_IMPL(9);
%ICV_PY_CB_TAB;
/**
* typemap to memorize the Python callback when doing cvCreateTrackbar ()
*/
%typemap(in) CvTrackbarCallback {
if(my_trackbar_cb_size == ICV_PY_MAX_CB){
SWIG_exception(SWIG_IndexError, "Exceeded maximum number of trackbars");
}
my_trackbar_cb_size++;
if (!PyCallable_Check($input)) {
PyErr_SetString(PyExc_TypeError, "parameter must be callable");
return 0;
}
Py_XINCREF((PyObject*) $input); /* Add a reference to new callback */
Py_XDECREF(my_trackbar_cb_funcs[my_trackbar_cb_size-1].py_func); /* Dispose of previous callback */
my_trackbar_cb_funcs[my_trackbar_cb_size-1].py_func = (PyObject *) $input;
/* prepare to call the C function who will register the callback */
$1 = my_trackbar_cb_funcs[ my_trackbar_cb_size-1 ].cv_func;
}
/**
* typemap so that cvWaitKey returns a character in all cases except -1
*/
%rename (cvWaitKeyC) cvWaitKey;
%rename (cvWaitKey) cvWaitKeyPy;
%inline %{
PyObject * cvWaitKeyPy(int delay=0){
// In order for the event processing thread to run a python callback
// it must acquire the global interpreter lock, but cvWaitKey blocks, so
// this thread can never release the lock. So release it here.
PyThreadState * thread_state = PyEval_SaveThread();
int res = cvWaitKey(delay);
PyEval_RestoreThread( thread_state );
char str[2]={(char)res,0};
if(res==-1){
return PyLong_FromLong(-1);
}
return PyString_FromString(str);
}
%}
/* HighGUI Python module initialization
* needed for callbacks to work in a threaded environment
*/
%init %{
PyEval_InitThreads();
%}
%include "../general/highgui.i"
%pythoncode
%{
__doc__ = """HighGUI provides minimalistic user interface parts and video input/output.
Dependent on the platform it was compiled on, this library provides methods
to draw a window for image display, capture video from a camera or framegrabber
or read/write video streams from/to the file system.
This wrapper was semi-automatically created from the C/C++ headers and therefore
contains no Python documentation. Because all identifiers are identical to their
C/C++ counterparts, you can consult the standard manuals that come with OpenCV.
"""
%}

457
interfaces/swig/python/highgui.py
View File

@ -1,457 +0,0 @@
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.
from sys import version_info
if version_info >= (2,6,0):
def swig_import_helper():
from os.path import dirname
import imp
fp = None
try:
fp, pathname, description = imp.find_module('_highgui', [dirname(__file__)])
except ImportError:
import _highgui
return _highgui
if fp is not None:
try:
_mod = imp.load_module('_highgui', fp, pathname, description)
finally:
fp.close()
return _mod
_highgui = swig_import_helper()
del swig_import_helper
else:
import _highgui
del version_info
try:
_swig_property = property
except NameError:
pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
if (name == "thisown"): return self.this.own(value)
if (name == "this"):
if type(value).__name__ == 'SwigPyObject':
self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name,None)
if method: return method(self,value)
if (not static) or hasattr(self,name):
self.__dict__[name] = value
else:
raise AttributeError("You cannot add attributes to %s" % self)
def _swig_setattr(self,class_type,name,value):
return _swig_setattr_nondynamic(self,class_type,name,value,0)
def _swig_getattr(self,class_type,name):
if (name == "thisown"): return self.this.own()
method = class_type.__swig_getmethods__.get(name,None)
if method: return method(self)
raise AttributeError(name)
def _swig_repr(self):
try: strthis = "proxy of " + self.this.__repr__()
except: strthis = ""
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
try:
_object = object
_newclass = 1
except AttributeError:
class _object : pass
_newclass = 0
class CvRNG_Wrapper(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CvRNG_Wrapper, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CvRNG_Wrapper, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _highgui.new_CvRNG_Wrapper(*args)
try: self.this.append(this)
except: self.this = this
def ptr(self): return _highgui.CvRNG_Wrapper_ptr(self)
def ref(self): return _highgui.CvRNG_Wrapper_ref(self)
def __eq__(self, *args): return _highgui.CvRNG_Wrapper___eq__(self, *args)
def __ne__(self, *args): return _highgui.CvRNG_Wrapper___ne__(self, *args)
__swig_destroy__ = _highgui.delete_CvRNG_Wrapper
__del__ = lambda self : None;
CvRNG_Wrapper_swigregister = _highgui.CvRNG_Wrapper_swigregister
CvRNG_Wrapper_swigregister(CvRNG_Wrapper)
class CvSubdiv2DEdge_Wrapper(_object):
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CvSubdiv2DEdge_Wrapper, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CvSubdiv2DEdge_Wrapper, name)
__repr__ = _swig_repr
def __init__(self, *args):
this = _highgui.new_CvSubdiv2DEdge_Wrapper(*args)
try: self.this.append(this)
except: self.this = this
def ptr(self): return _highgui.CvSubdiv2DEdge_Wrapper_ptr(self)
def ref(self): return _highgui.CvSubdiv2DEdge_Wrapper_ref(self)
def __eq__(self, *args): return _highgui.CvSubdiv2DEdge_Wrapper___eq__(self, *args)
def __ne__(self, *args): return _highgui.CvSubdiv2DEdge_Wrapper___ne__(self, *args)
__swig_destroy__ = _highgui.delete_CvSubdiv2DEdge_Wrapper
__del__ = lambda self : None;
CvSubdiv2DEdge_Wrapper_swigregister = _highgui.CvSubdiv2DEdge_Wrapper_swigregister
CvSubdiv2DEdge_Wrapper_swigregister(CvSubdiv2DEdge_Wrapper)
cvReleaseCapture = _highgui.delete_CvCapture
cvReleaseVideoWriter = _highgui.delete_CvVideoWriter
def cvRetrieveFrame(*args):
"""cvRetrieveFrame(CvCapture capture) -> CvMat"""
return _highgui.cvRetrieveFrame(*args)
def cvQueryFrame(*args):
"""cvQueryFrame(CvCapture capture) -> CvMat"""
return _highgui.cvQueryFrame(*args)
def cvInitSystem(*args):
"""cvInitSystem(int argc, char argv) -> int"""
return _highgui.cvInitSystem(*args)
def cvStartWindowThread():
"""cvStartWindowThread() -> int"""
return _highgui.cvStartWindowThread()
CV_WINDOW_AUTOSIZE = _highgui.CV_WINDOW_AUTOSIZE
def cvNamedWindow(*args):
"""cvNamedWindow(char name, int flags = 1) -> int"""
return _highgui.cvNamedWindow(*args)
def cvShowImage(*args):
"""cvShowImage(char name, CvArr image)"""
return _highgui.cvShowImage(*args)
def cvResizeWindow(*args):
"""cvResizeWindow(char name, int width, int height)"""
return _highgui.cvResizeWindow(*args)
def cvMoveWindow(*args):
"""cvMoveWindow(char name, int x, int y)"""
return _highgui.cvMoveWindow(*args)
def cvDestroyWindow(*args):
"""cvDestroyWindow(char name)"""
return _highgui.cvDestroyWindow(*args)
def cvDestroyAllWindows():
"""cvDestroyAllWindows()"""
return _highgui.cvDestroyAllWindows()
def cvGetWindowHandle(*args):
"""cvGetWindowHandle(char name) -> void"""
return _highgui.cvGetWindowHandle(*args)
def cvGetWindowName(*args):
"""cvGetWindowName(void window_handle) -> char"""
return _highgui.cvGetWindowName(*args)
def cvCreateTrackbar(*args):
"""
cvCreateTrackbar(char trackbar_name, char window_name, int value, int count,
CvTrackbarCallback on_change) -> int
"""
return _highgui.cvCreateTrackbar(*args)
def cvCreateTrackbar2(*args):
"""
cvCreateTrackbar2(char trackbar_name, char window_name, int value, int count,
CvTrackbarCallback2 on_change, void userdata = None) -> int
"""
return _highgui.cvCreateTrackbar2(*args)
def cvGetTrackbarPos(*args):
"""cvGetTrackbarPos(char trackbar_name, char window_name) -> int"""
return _highgui.cvGetTrackbarPos(*args)
def cvSetTrackbarPos(*args):
"""cvSetTrackbarPos(char trackbar_name, char window_name, int pos)"""
return _highgui.cvSetTrackbarPos(*args)
CV_EVENT_MOUSEMOVE = _highgui.CV_EVENT_MOUSEMOVE
CV_EVENT_LBUTTONDOWN = _highgui.CV_EVENT_LBUTTONDOWN
CV_EVENT_RBUTTONDOWN = _highgui.CV_EVENT_RBUTTONDOWN
CV_EVENT_MBUTTONDOWN = _highgui.CV_EVENT_MBUTTONDOWN
CV_EVENT_LBUTTONUP = _highgui.CV_EVENT_LBUTTONUP
CV_EVENT_RBUTTONUP = _highgui.CV_EVENT_RBUTTONUP
CV_EVENT_MBUTTONUP = _highgui.CV_EVENT_MBUTTONUP
CV_EVENT_LBUTTONDBLCLK = _highgui.CV_EVENT_LBUTTONDBLCLK
CV_EVENT_RBUTTONDBLCLK = _highgui.CV_EVENT_RBUTTONDBLCLK
CV_EVENT_MBUTTONDBLCLK = _highgui.CV_EVENT_MBUTTONDBLCLK
CV_EVENT_FLAG_LBUTTON = _highgui.CV_EVENT_FLAG_LBUTTON
CV_EVENT_FLAG_RBUTTON = _highgui.CV_EVENT_FLAG_RBUTTON
CV_EVENT_FLAG_MBUTTON = _highgui.CV_EVENT_FLAG_MBUTTON
CV_EVENT_FLAG_CTRLKEY = _highgui.CV_EVENT_FLAG_CTRLKEY
CV_EVENT_FLAG_SHIFTKEY = _highgui.CV_EVENT_FLAG_SHIFTKEY
CV_EVENT_FLAG_ALTKEY = _highgui.CV_EVENT_FLAG_ALTKEY
def cvSetMouseCallbackOld(*args):
"""cvSetMouseCallbackOld(char window_name, CvMouseCallback on_mouse, void param = None)"""
return _highgui.cvSetMouseCallbackOld(*args)
CV_LOAD_IMAGE_UNCHANGED = _highgui.CV_LOAD_IMAGE_UNCHANGED
CV_LOAD_IMAGE_GRAYSCALE = _highgui.CV_LOAD_IMAGE_GRAYSCALE
CV_LOAD_IMAGE_COLOR = _highgui.CV_LOAD_IMAGE_COLOR
CV_LOAD_IMAGE_ANYDEPTH = _highgui.CV_LOAD_IMAGE_ANYDEPTH
CV_LOAD_IMAGE_ANYCOLOR = _highgui.CV_LOAD_IMAGE_ANYCOLOR
def cvLoadImageM(*args):
"""cvLoadImageM(char filename, int iscolor = 1) -> CvMat"""
return _highgui.cvLoadImageM(*args)
CV_IMWRITE_JPEG_QUALITY = _highgui.CV_IMWRITE_JPEG_QUALITY
CV_IMWRITE_PNG_COMPRESSION = _highgui.CV_IMWRITE_PNG_COMPRESSION
CV_IMWRITE_PXM_BINARY = _highgui.CV_IMWRITE_PXM_BINARY
def cvSaveImage(*args):
"""cvSaveImage(char filename, CvArr image, int params = None) -> int"""
return _highgui.cvSaveImage(*args)
def cvDecodeImage(*args):
"""cvDecodeImage(CvMat buf, int iscolor = 1)"""
return _highgui.cvDecodeImage(*args)
def cvDecodeImageM(*args):
"""cvDecodeImageM(CvMat buf, int iscolor = 1) -> CvMat"""
return _highgui.cvDecodeImageM(*args)
def cvEncodeImage(*args):
"""cvEncodeImage(char ext, CvArr image, int params = None) -> CvMat"""
return _highgui.cvEncodeImage(*args)
CV_CVTIMG_FLIP = _highgui.CV_CVTIMG_FLIP
CV_CVTIMG_SWAP_RB = _highgui.CV_CVTIMG_SWAP_RB
def cvConvertImage(*args):
"""cvConvertImage(CvArr src, CvArr dst, int flags = 0)"""
return _highgui.cvConvertImage(*args)
def cvWaitKeyC(delay = 0):
"""cvWaitKeyC(int delay = 0) -> int"""
return _highgui.cvWaitKeyC(delay)
def cvCreateFileCapture(*args):
"""cvCreateFileCapture(char filename) -> CvCapture"""
return _highgui.cvCreateFileCapture(*args)
CV_CAP_ANY = _highgui.CV_CAP_ANY
CV_CAP_MIL = _highgui.CV_CAP_MIL
CV_CAP_VFW = _highgui.CV_CAP_VFW
CV_CAP_V4L = _highgui.CV_CAP_V4L
CV_CAP_V4L2 = _highgui.CV_CAP_V4L2
CV_CAP_FIREWARE = _highgui.CV_CAP_FIREWARE
CV_CAP_FIREWIRE = _highgui.CV_CAP_FIREWIRE
CV_CAP_IEEE1394 = _highgui.CV_CAP_IEEE1394
CV_CAP_DC1394 = _highgui.CV_CAP_DC1394
CV_CAP_CMU1394 = _highgui.CV_CAP_CMU1394
CV_CAP_STEREO = _highgui.CV_CAP_STEREO
CV_CAP_TYZX = _highgui.CV_CAP_TYZX
CV_TYZX_LEFT = _highgui.CV_TYZX_LEFT
CV_TYZX_RIGHT = _highgui.CV_TYZX_RIGHT
CV_TYZX_COLOR = _highgui.CV_TYZX_COLOR
CV_TYZX_Z = _highgui.CV_TYZX_Z
CV_CAP_QT = _highgui.CV_CAP_QT
CV_CAP_UNICAP = _highgui.CV_CAP_UNICAP
CV_CAP_DSHOW = _highgui.CV_CAP_DSHOW
def cvCreateCameraCapture(*args):
"""cvCreateCameraCapture(int index) -> CvCapture"""
return _highgui.cvCreateCameraCapture(*args)
def cvGrabFrame(*args):
"""cvGrabFrame(CvCapture capture) -> int"""
return _highgui.cvGrabFrame(*args)
def cvRetrieveFrame__Deprecated(*args):
"""cvRetrieveFrame__Deprecated(CvCapture capture, int streamIdx = 0)"""
return _highgui.cvRetrieveFrame__Deprecated(*args)
def cvQueryFrame__Deprecated(*args):
"""cvQueryFrame__Deprecated(CvCapture capture)"""
return _highgui.cvQueryFrame__Deprecated(*args)
CV_CAP_PROP_POS_MSEC = _highgui.CV_CAP_PROP_POS_MSEC
CV_CAP_PROP_POS_FRAMES = _highgui.CV_CAP_PROP_POS_FRAMES
CV_CAP_PROP_POS_AVI_RATIO = _highgui.CV_CAP_PROP_POS_AVI_RATIO
CV_CAP_PROP_FRAME_WIDTH = _highgui.CV_CAP_PROP_FRAME_WIDTH
CV_CAP_PROP_FRAME_HEIGHT = _highgui.CV_CAP_PROP_FRAME_HEIGHT
CV_CAP_PROP_FPS = _highgui.CV_CAP_PROP_FPS
CV_CAP_PROP_FOURCC = _highgui.CV_CAP_PROP_FOURCC
CV_CAP_PROP_FRAME_COUNT = _highgui.CV_CAP_PROP_FRAME_COUNT
CV_CAP_PROP_FORMAT = _highgui.CV_CAP_PROP_FORMAT
CV_CAP_PROP_MODE = _highgui.CV_CAP_PROP_MODE
CV_CAP_PROP_BRIGHTNESS = _highgui.CV_CAP_PROP_BRIGHTNESS
CV_CAP_PROP_CONTRAST = _highgui.CV_CAP_PROP_CONTRAST
CV_CAP_PROP_SATURATION = _highgui.CV_CAP_PROP_SATURATION
CV_CAP_PROP_HUE = _highgui.CV_CAP_PROP_HUE
CV_CAP_PROP_GAIN = _highgui.CV_CAP_PROP_GAIN
CV_CAP_PROP_EXPOSURE = _highgui.CV_CAP_PROP_EXPOSURE
CV_CAP_PROP_CONVERT_RGB = _highgui.CV_CAP_PROP_CONVERT_RGB
CV_CAP_PROP_WHITE_BALANCE = _highgui.CV_CAP_PROP_WHITE_BALANCE
CV_CAP_PROP_RECTIFICATION = _highgui.CV_CAP_PROP_RECTIFICATION
def cvGetCaptureProperty(*args):
"""cvGetCaptureProperty(CvCapture capture, int property_id) -> double"""
return _highgui.cvGetCaptureProperty(*args)
def cvSetCaptureProperty(*args):
"""cvSetCaptureProperty(CvCapture capture, int property_id, double value) -> int"""
return _highgui.cvSetCaptureProperty(*args)
def cvGetCaptureDomain(*args):
"""cvGetCaptureDomain(CvCapture capture) -> int"""
return _highgui.cvGetCaptureDomain(*args)
def CV_FOURCC(*args):
"""CV_FOURCC(char c1, char c2, char c3, char c4) -> int"""
return _highgui.CV_FOURCC(*args)
CV_FOURCC_PROMPT = _highgui.CV_FOURCC_PROMPT
def cvCreateVideoWriter(*args):
"""
cvCreateVideoWriter(char filename, int fourcc, double fps, CvSize frame_size,
int is_color = 1) -> CvVideoWriter
"""
return _highgui.cvCreateVideoWriter(*args)
def cvWriteFrame(*args):
"""cvWriteFrame(CvVideoWriter writer, image) -> int"""
return _highgui.cvWriteFrame(*args)
HG_AUTOSIZE = _highgui.HG_AUTOSIZE
class CvvImage(_object):
"""Proxy of C++ CvvImage class"""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CvvImage, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CvvImage, name)
__repr__ = _swig_repr
def __init__(self):
"""__init__(self) -> CvvImage"""
this = _highgui.new_CvvImage()
try: self.this.append(this)
except: self.this = this
__swig_destroy__ = _highgui.delete_CvvImage
__del__ = lambda self : None;
def Create(self, *args):
"""
Create(self, int width, int height, int bits_per_pixel, int image_origin = 0) -> bool
Create(self, int width, int height, int bits_per_pixel) -> bool
"""
return _highgui.CvvImage_Create(self, *args)
def Load(self, *args):
"""
Load(self, char filename, int desired_color = 1) -> bool
Load(self, char filename) -> bool
"""
return _highgui.CvvImage_Load(self, *args)
def LoadRect(self, *args):
"""LoadRect(self, char filename, int desired_color, CvRect r) -> bool"""
return _highgui.CvvImage_LoadRect(self, *args)
def Save(self, *args):
"""Save(self, char filename) -> bool"""
return _highgui.CvvImage_Save(self, *args)
def CopyOf(self, *args):
"""
CopyOf(self, CvvImage image, int desired_color = -1)
CopyOf(self, CvvImage image)
CopyOf(self, img, int desired_color = -1)
CopyOf(self, img)
"""
return _highgui.CvvImage_CopyOf(self, *args)
def GetImage(self):
"""GetImage(self)"""
return _highgui.CvvImage_GetImage(self)
def Destroy(self):
"""Destroy(self)"""
return _highgui.CvvImage_Destroy(self)
def Width(self):
"""Width(self) -> int"""
return _highgui.CvvImage_Width(self)
def Height(self):
"""Height(self) -> int"""
return _highgui.CvvImage_Height(self)
def Bpp(self):
"""Bpp(self) -> int"""
return _highgui.CvvImage_Bpp(self)
def Fill(self, *args):
"""Fill(self, int color)"""
return _highgui.CvvImage_Fill(self, *args)
def Show(self, *args):
"""Show(self, char window)"""
return _highgui.CvvImage_Show(self, *args)
CvvImage_swigregister = _highgui.CvvImage_swigregister
CvvImage_swigregister(CvvImage)
def cvSetMouseCallback(*args):
return _highgui.cvSetMouseCallback(*args)
cvSetMouseCallback = _highgui.cvSetMouseCallback
def cvWaitKey(delay = 0):
return _highgui.cvWaitKey(delay)
cvWaitKey = _highgui.cvWaitKey
def cvLoadImage(*args):
"""
cvLoadImage(char filename, int iscolor = 1) -> CvMat
cvLoadImage(char filename) -> CvMat
"""
return _highgui.cvLoadImage(*args)
class CvCapture(_object):
"""Proxy of C++ CvCapture class"""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CvCapture, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CvCapture, name)
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
__repr__ = _swig_repr
__swig_destroy__ = _highgui.delete_CvCapture
__del__ = lambda self : None;
CvCapture_swigregister = _highgui.CvCapture_swigregister
CvCapture_swigregister(CvCapture)
class CvVideoWriter(_object):
"""Proxy of C++ CvVideoWriter class"""
__swig_setmethods__ = {}
__setattr__ = lambda self, name, value: _swig_setattr(self, CvVideoWriter, name, value)
__swig_getmethods__ = {}
__getattr__ = lambda self, name: _swig_getattr(self, CvVideoWriter, name)
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
__repr__ = _swig_repr
__swig_destroy__ = _highgui.delete_CvVideoWriter
__del__ = lambda self : None;
CvVideoWriter_swigregister = _highgui.CvVideoWriter_swigregister
CvVideoWriter_swigregister(CvVideoWriter)
__doc__ = """HighGUI provides minimalistic user interface parts and video input/output.
Dependent on the platform it was compiled on, this library provides methods
to draw a window for image display, capture video from a camera or framegrabber
or read/write video streams from/to the file system.
This wrapper was semi-automatically created from the C/C++ headers and therefore
contains no Python documentation. Because all identifiers are identical to their
C/C++ counterparts, you can consult the standard manuals that come with OpenCV.
"""

152
interfaces/swig/python/imagedata.i
View File

@ -1,152 +0,0 @@
/*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*/
// 2004-03-16, Gabriel Schreiber <schreiber@ient.rwth-aachen.de>
// Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
// 2006-08-29 Roman Stanchak -- converted to use CvMat rather than IplImage
%{
/// Accessor to convert a Python string into the imageData.
void CvMat_imageData_set(CvMat * self, PyObject* object)
{
char* py_string = PyString_AsString(object);
int depth = CV_MAT_DEPTH(self->type);
int cn = CV_MAT_CN(self->type);
int step = self->step ? self->step : CV_ELEM_SIZE(self->type) * self->cols;
if (depth == CV_8U && cn==3){
// RGB case
// The data is reordered beause OpenCV uses BGR instead of RGB
for (long line = 0; line < self->rows; ++line)
for (long pixel = 0; pixel < self->cols; ++pixel)
{
// In OpenCV the beginning of the lines are aligned
// to 4 Bytes. So use step instead of cols.
long position = line*step + pixel*3;
long sourcepos = line*self->cols*3 + pixel*3;
self->data.ptr[position ] = py_string[sourcepos+2];
self->data.ptr[position+1] = py_string[sourcepos+1];
self->data.ptr[position+2] = py_string[sourcepos ];
}
}
else if (depth == CV_8U && cn==1)
{
// Grayscale 8bit case
for (long line = 0; line < self->rows; ++line)
{
// In OpenCV the beginning of the lines are aligned
// to 4 Bytes. So use step instead of cols.
memcpy
(
self->data.ptr + line*step,
py_string + line*self->cols,
step
);
}
}
else if ( depth == CV_32F )
{
// float (32bit) case
for (long line = 0; line < self->rows; ++line)
{
// here we don not have to care about alignment as the Floats are
// as long as the alignment
memcpy
(
self->data.ptr + line*step,
py_string + line*self->cols*sizeof(float),
step
);
}
}
else if ( depth == CV_64F )
{
// double (64bit) case
for (long line = 0; line < self->rows; ++line)
{
// here we don not have to care about alignment as the Floats are
// as long as the alignment
memcpy
(
self->data.ptr + line*step,
py_string + line*self->cols*sizeof(double),
step
);
}
}
else
{
// make some noise
SendErrorToPython (SWIG_TypeError,
"CvMat_imageData_set",
"cannot convert string data to this image format",
__FILE__, __LINE__, NULL);
}
}
/// Accessor to convert the imageData into a Python string.
PyObject* CvMat_imageData_get(CvMat * self)
{
if (!self->data.ptr)
{
PyErr_SetString(PyExc_TypeError, "Data pointer of CvMat is NULL");
return NULL;
}
int step = self->step ? self->step : CV_ELEM_SIZE(self->type) * self->cols;
return PyString_FromStringAndSize((const char *)self->data.ptr, self->rows*step);
}
%}
// add virtual member variable to CvMat
%extend CvMat {
PyObject * imageData;
};

269
interfaces/swig/python/matlab_syntax.py
View File

@ -1,269 +0,0 @@
#########################################################################################
#
# 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.
#
#########################################################################################
"""Matlab syntax for OpenCV
For those who have switched from Matlab, this module offers similar syntax to the basic
Matlab commands. I.e. you can invoke 'imread' to load images, 'imshow', etc.
"""
from cv import *
from highgui import cvShowImage,cvNamedWindow,cvLoadImage,cvWaitKey
#__all__ = ['imagesc', 'display', 'imread', 'imshow', 'saveimage', 'loadimage', 'pause',
# 'Image', 'Image8', 'Image8c3', 'Image32s', 'Image32f', 'Image64f']
def eye(*args):
mat = array(*args)
cvSetIdentity(mat);
return mat
def ones(*args):
mat = array(*args)
cvSet(mat, cvScalarAll(1.0))
return mat
def zeros(*args):
mat = array(*args)
cvSet(mat, cvScalarAll(0.0))
return mat
def array(*args):
m=1
n=1
c=1
classname='single'
nargs = len(args)
# nasty argument parsing
if nargs>0:
if isinstance(args[0],tuple) or isinstance(args[0],list) and len(args[0]) > 1:
m=args[0][0]
n=args[0][1]
if len(args[0])>2:
c=args[0][2]
if len(args)>1:
classname = args[1]
else:
m=args[0]
if nargs == 1:
n=args[0]
elif nargs > 1:
# is the last argument the classname?
if args[nargs-1].__class__ == str:
classname = args[nargs-1]
nargs-=1
if nargs > 1:
n = args[1]
if nargs > 2:
c = args[2]
if(classname=='double'):
depth=cv.CV_64F
elif(classname=='single'):
depth=cv.CV_32F
elif(classname=='int8'):
depth=cv.CV_8S
elif(classname=='uint8'):
depth=cv.CV_8U
elif(classname=='int16'):
depth=cv.CV_16S
elif(classname=='uint16'):
depth=cv.CV_16U
elif(classname=='int32' or classname=='uint32' or
classname=='int64' or classname=='uint64'):
depth=cv.CV_32S
else:
depth=cv.CV_32F
depth = CV_MAKETYPE(depth, c)
return cvCreateMat(m,n,depth)
def size(X,dim=-1):
# CvMat
if hasattr(X, "type"):
sz = (X.rows, X.cols, CV_MAT_CN(X.type))
# IplImage
elif hasattr(X, "nChannels"):
sz = (X.height, X.width, X.nChannels)
# CvMatNd
else:
sz = cvGetDims(X)
if dim is -1:
return sz
return sz[dim]
def reshape(X, m, n=1, c=-1):
'''
reshape will produce different results in matlab and python due to the
order of elements stored in the array (row-major vs. column major)
'''
if c==-1:
c = CV_MAT_CN(X)
return cvReshape(X, c, m)
def im2float(im):
mat = cvGetMat(im);
if CV_MAT_DEPTH(mat.type)==CV_32F:
return mat
im64f = array(size(im), 'float')
cvConvertScale(im, im64f, 1.0, 0.0)
return im64f
def im2double(im):
mat = cvGetMat(im);
if CV_MAT_DEPTH(mat.type)==CV_64F:
return mat
im64f = array(size(im), 'double')
cvConvertScale(im, im64f, 1.0, 0.0)
return im64f
def rgb2ntsc (rgb):
trans = [ [0.299, 0.596, 0.211], [0.587, -0.274, -0.523], [0.114, -0.322, 0.312] ];
return rgb * trans;
def rgb2gray(rgb):
ntscmap = rgb2ntsc (rgb);
graymap = ntscmap [:, 1] * ones (1, 3);
return graymap
class cvImageViewer:
"""
Wrapper class for some matlab/octave/scilab syntax image viewing functions
"""
currentWindowName = ""
currentWindow = -1
maxWindow = -1
def imagesc(self,im, clims=None):
"""
Display a normalized version of the image
"""
if(self.currentWindow==-1):
self.display()
# don't normalize multichannel image
#if(im.nChannels>1):
# if(im.depth!=cv.IPL_DEPTH_8U):
# im2 = cvCreateImage( cvSize(im.width, im.height), cv.IPL_DEPTH_8U, im.nChannels)
# cvScale(im, im2)
# im = im2
# cvShowImage(self.currentWindowName, im)
# return self.currentWindow
# normalize image
if clims:
[minv, maxv] = clims
else:
[minv,maxv] = cvMinMaxLoc(im)
if maxv != minv:
s = 255.0/(maxv-minv)
shift = 255*(-minv)/(maxv-minv)
else:
s = 1.0
shift = -maxv
im2 = array( size(im), 'uint8' )
cvConvertScale(im, im2, s, shift)
cvShowImage(self.currentWindowName, im2)
def image(self, im):
"""
Display image as is -- probably not what you'd expect for FP or integer images
"""
if(self.currentWindow==-1):
self.display()
cvShowImage(self.currentWindowName,im)
return self.currentWindow
def display(self, index=-1):
"""
open a new window
"""
if(index==-1):
self.maxWindow = self.maxWindow+1;
index= self.maxWindow;
if(index > self.maxWindow):
self.maxWindow = index;
self.currentWindow = index;
self.currentWindowName = "opencv-python window %d" % self.currentWindow
cvNamedWindow(self.currentWindowName,0)
return self.currentWindow
def drawnow():
cvWaitKey(10)
def pause(delay=-1):
if delay<0:
cvWaitKey(-1)
else:
cvWaitKey(delay*1000)
c = cvImageViewer()
imagesc = c.imagesc
display = c.display
image = c.image
imshow = c.image
def imread(fname):
return cvLoadImage(fname, -1)
loadimage = imread
imload = imread
def imsave(im, fname, format):
return cvSaveImage(fname, im)
saveimage = imsave
def gradient(F):
F = im2float(F)
Fx = array(size(F))
Fy = array(size(F))
# new images
cvSobel(F, Fx, 1, 0, CV_SCHARR)
cvSobel(F, Fy, 0, 1, CV_SCHARR)
return (Fx, Fy)

118
interfaces/swig/python/ml.i
View File

@ -1,118 +0,0 @@
/*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*/
// 2004-03-16, Mark Asbach <asbach@ient.rwth-aachen.de>
// Institute of Communications Engineering, RWTH Aachen University
%module(package="opencv") ml
%{
#include <ml.h>
#include <cxtypes.h>
#include <cv.h>
#include <highgui.h>
#include "pyhelpers.h"
#include "pycvseq.hpp"
%}
// include python-specific files
%include "./nointpb.i"
%include "./pytypemaps.i"
%include "exception.i"
%import "../general/cv.i"
%include "../general/memory.i"
%include "../general/typemaps.i"
%newobject cvCreateCNNConvolutionLayer;
%newobject cvCreateCNNSubSamplingLayer;
%newobject cvCreateCNNFullConnectLayer;
%newobject cvCreateCNNetwork;
%newobject cvTrainCNNClassifier;
%newobject cvCreateCrossValidationEstimateModel;
%pythoncode
%{
__doc__ = """Machine Learning
The Machine Learning library (ML) is a set of classes and functions for
statistical classification, regression and clustering of data.
Most of the classification and regression algorithms are implemented as classes.
As the algorithms have different sets of features (like ability to handle missing
measurements, or categorical input variables etc.), there is only little common
ground between the classes. This common ground is defined by the class CvStatModel
that all the other ML classes are derived from.
This wrapper was semi-automatically created from the C/C++ headers and therefore
contains no Python documentation. Because all identifiers are identical to their
C/C++ counterparts, you can consult the standard manuals that come with OpenCV.
"""
%}
%extend CvEM
{
PyObject * get_covs()
{
CvMat ** pointers = const_cast<CvMat **> (self->get_covs());
int n = self->get_nclusters();
PyObject * result = PyTuple_New(n);
for (int i=0; i<n; ++i)
{
PyObject * obj = SWIG_NewPointerObj(pointers[i], $descriptor(CvMat *), 0);
PyTuple_SetItem(result, i, obj);
//Py_DECREF(obj);
}
return result;
}
}
%ignore CvEM::get_covs;
%include "ml.h"

1472
interfaces/swig/python/ml.py
View File

File diff suppressed because it is too large Load Diff

34
interfaces/swig/python/nointpb.i
View File

@ -1,34 +0,0 @@
/* This file is to prevent problems with swig <= 1.3.25 which use
PyInt_AS_LONG and may cause some corruption on RedHat systems.
Include it in every .i file who generate a C/C++ file */
%runtime%{
/* define the PyAPI_FUNC macro if it doesn't exist, for example with Python
version below 2.3... But not really tested... */
#ifndef PyAPI_FUNC
# define PyAPI_FUNC(RTYPE) RTYPE
#endif
/* remove the PyInt_AS_LONG if defined, as this cause problems on RedHat */
#ifdef PyInt_AS_LONG
#undef PyInt_AS_LONG
#endif
/* wrapper to the better function PyInt_AsLong, removing problems
with RedHat (I hope) */
long PyInt_AS_LONG (PyObject *obj) {
return PyInt_AsLong (obj);
}
/* remove the PyFloat_AS_DOUBLE if defined, to prevent errors */
#ifdef PyFloat_AS_DOUBLE
#undef PyFloat_AS_DOUBLE
#endif
/* wrapper to the better function PyFloat_AS_DOUBLE, to prevent errors */
double PyFloat_AS_DOUBLE (PyObject *obj) {
return PyFloat_AsDouble (obj);
}
%}

104
interfaces/swig/python/pycvseq.hpp
View File

@ -1,104 +0,0 @@
/*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*/
#ifndef PY_CV_SEQ_H
#define PY_CV_SEQ_H
#include "cxcore.h"
#include "cvtypes.h"
/** class to make sequence iteration nicer */
template<class T>
class CvTypedSeqReader : public CvSeqReader {
int pos;
public:
CvTypedSeqReader( const CvSeq * seq ){
cvStartReadSeq( seq, this );
pos = 0;
}
T * current(){
return (T*) this->ptr;
}
void next(){
CV_NEXT_SEQ_ELEM( this->seq->elem_size, *this );
pos++;
}
bool valid(){
return pos<this->seq->total;
}
};
template<class T>
class CvTypedSeq : public CvSeq {
public:
static CvTypedSeq<T> * cast(CvSeq * seq){
return (CvTypedSeq<T> *) seq;
}
T * __getitem__ (int i){
return (T *) cvGetSeqElem(this, i);
}
void __setitem__ (int i, T * obj){
T * ptr = this->__getitem__(i);
memcpy(ptr, obj, sizeof(T));
}
void append(T * obj){
cvSeqPush( this, obj );
}
T * pop(){
T * obj = new T;
cvSeqPop( this, obj );
return obj;
}
};
template<class T, int size=2>
struct CvTuple {
T val[2];
void __setitem__(int i, T * obj){
val[i] = *obj;
}
const T & __getitem__(int i){
return val[i];
}
};
#endif //PY_CV_SEQ_H

606
interfaces/swig/python/pyhelpers.cpp
View File

@ -1,606 +0,0 @@
#include "pyhelpers.h"
#include <iostream>
#include <sstream>
int PySwigObject_Check(PyObject *op);
/* Py_ssize_t for old Pythons */
#if PY_VERSION_HEX < 0x02050000
typedef int Py_ssize_t;
#endif
PyObject * PyTuple_FromIntArray(int * arr, int len){
PyObject * obj = PyTuple_New(len);
for(int i=0; i<len; i++){
PyTuple_SetItem(obj, i, PyLong_FromLong( arr[i] ) );
}
return obj;
}
PyObject * SWIG_SetResult(PyObject * result, PyObject * obj){
if(result){
Py_DECREF(result);
}
result = PyTuple_New(1);
PyTuple_SetItem(result, 0, obj);
return result;
}
PyObject * SWIG_AppendResult(PyObject * result, PyObject ** to_add, int num){
if ((!result) || (result == Py_None)) {
/* no other results, so just add our values */
/* if only one object, return that */
if(num==1){
return to_add[0];
}
/* create a new tuple to put in our new pointer python objects */
result = PyTuple_New (num);
/* put in our new pointer python objects */
for(int i=0; i<num; i++){
PyTuple_SetItem (result, i, to_add[i]);
}
}
else {
/* we have other results, so add it to the end */
if (!PyTuple_Check (result)) {
/* previous result is not a tuple, so create one and put
previous result and current pointer in it */
/* first, save previous result */
PyObject *obj_save = result;
/* then, create the tuple */
result = PyTuple_New (1);
/* finaly, put the saved value in the tuple */
PyTuple_SetItem (result, 0, obj_save);
}
/* create a new tuple to put in our new pointer python object */
PyObject *my_obj = PyTuple_New (num);
/* put in our new pointer python object */
for( int i=0; i<num ; i++ ){
PyTuple_SetItem (my_obj, i, to_add[i]);
}
/* save the previous result */
PyObject *obj_save = result;
/* concat previous and our new result */
result = PySequence_Concat (obj_save, my_obj);
/* decrement the usage of no more used objects */
Py_DECREF (obj_save);
Py_DECREF (my_obj);
}
return result;
}
template <typename T>
void cv_arr_write(FILE * f, const char * fmt, T * data, size_t rows, size_t nch, size_t step){
size_t i,j,k;
char * cdata = (char *) data;
const char * chdelim1="", * chdelim2="";
// only output channel parens if > 1
if(nch>1){
chdelim1="(";
chdelim2=")";
}
fputs("[",f);
for(i=0; i<rows; i++){
fputs("[",f);
// first element
// out<<chdelim1;
fputs(chdelim1, f);
fprintf(f, fmt, ((T*)(cdata+i*step))[0]);
for(k=1; k<nch; k++){
fputs(", ", f);
fprintf(f, fmt, ((T*)(cdata+i*step))[k]);
}
fputs(chdelim2,f);
// remaining elements
for(j=nch*sizeof(T); j<step; j+=(nch*sizeof(T))){
fprintf(f, ",%s", chdelim1);
fprintf(f, fmt, ((T*)(cdata+i*step+j))[0]);
for(k=1; k<nch; k++){
fputs(", ", f);
fprintf(f, fmt, ((T*)(cdata+i*step+j))[k]);
}
fputs(chdelim2, f);
}
fputs( "]\n", f );
}
fputs( "]", f );
}
void cvArrPrint(CvArr * arr){
CvMat * mat;
CvMat stub;
mat = cvGetMat(arr, &stub);
int cn = CV_MAT_CN(mat->type);
int depth = CV_MAT_DEPTH(mat->type);
int step = MAX(mat->step, cn*mat->cols*CV_ELEM_SIZE(depth));
switch(depth){
case CV_8U:
cv_arr_write(stdout, "%u", (uchar *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_8S:
cv_arr_write(stdout, "%d", (char *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_16U:
cv_arr_write(stdout, "%u", (ushort *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_16S:
cv_arr_write(stdout, "%d", (short *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_32S:
cv_arr_write(stdout, "%d", (int *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_32F:
cv_arr_write(stdout, "%f", (float *)mat->data.ptr, mat->rows, cn, step);
break;
case CV_64F:
cv_arr_write(stdout, "%g", (double *)mat->data.ptr, mat->rows, cn, step);
break;
default:
CV_Error( CV_StsError, "Unknown element type");
break;
}
}
// deal with negative array indices
int PyLong_AsIndex( PyObject * idx_object, int len ){
int idx = PyLong_AsLong( idx_object );
if(idx<0) return len+idx;
return idx;
}
CvRect PySlice_to_CvRect(CvArr * src, PyObject * idx_object){
CvSize sz = cvGetSize(src);
//printf("Size %dx%d\n", sz.height, sz.width);
int lower[2], upper[2];
Py_ssize_t len, start, stop, step, slicelength;
if(PyInt_Check(idx_object) || PyLong_Check(idx_object)){
// if array is a row vector, assume index into columns
if(sz.height>1){
lower[0] = PyLong_AsIndex( idx_object, sz.height );
upper[0] = lower[0] + 1;
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[0] = 0;
upper[0] = sz.height;
lower[1] = PyLong_AsIndex( idx_object, sz.width );
upper[1] = lower[1]+1;
}
}
// 1. Slice
else if(PySlice_Check(idx_object)){
len = sz.height;
if(PySlice_GetIndicesEx( (PySliceObject*)idx_object, len, &start, &stop, &step, &slicelength )!=0){
printf("Error in PySlice_GetIndicesEx: returning NULL");
PyErr_SetString(PyExc_Exception, "Error");
return cvRect(0,0,0,0);
}
// if array is a row vector, assume index bounds are into columns
if(sz.height>1){
lower[0] = (int) start; // use c convention of start index = 0
upper[0] = (int) stop; // use c convention
lower[1] = 0;
upper[1] = sz.width;
}
else{
lower[1] = (int) start; // use c convention of start index = 0
upper[1] = (int) stop; // use c convention
lower[0] = 0;
upper[0] = sz.height;
}
}
// 2. Tuple
else if(PyTuple_Check(idx_object)){
//printf("PyTuple{\n");
if(PyObject_Length(idx_object)!=2){
//printf("Expected a sequence of length 2: returning NULL");
PyErr_SetString(PyExc_ValueError, "Expected a sequence with 2 elements");
return cvRect(0,0,0,0);
}
for(int i=0; i<2; i++){
PyObject *o = PyTuple_GetItem(idx_object, i);
// 2a. Slice -- same as above
if(PySlice_Check(o)){
//printf("PySlice\n");
len = (i==0 ? sz.height : sz.width);
if(PySlice_GetIndicesEx( (PySliceObject*)o, len, &start, &stop, &step, &slicelength )!=0){
PyErr_SetString(PyExc_Exception, "Error");
printf("Error in PySlice_GetIndicesEx: returning NULL");
return cvRect(0,0,0,0);
}
//printf("PySlice_GetIndecesEx(%d, %d, %d, %d, %d)\n", len, start, stop, step, slicelength);
lower[i] = start;
upper[i] = stop;
}
// 2b. Integer
else if(PyInt_Check(o) || PyLong_Check(o)){
//printf("PyInt\n");
lower[i] = PyLong_AsIndex(o, i==0 ? sz.height : sz.width);
upper[i] = lower[i]+1;
}
else {
PyErr_SetString(PyExc_TypeError, "Expected a sequence of slices or integers");
printf("Expected a slice or int as sequence item: returning NULL");
return cvRect(0,0,0,0);
}
}
}
else {
PyErr_SetString( PyExc_TypeError, "Expected a slice or sequence");
printf("Expected a slice or sequence: returning NULL");
return cvRect(0,0,0,0);
}
//lower[0] = MAX(0, lower[0]);
//lower[1] = MAX(0, lower[1]);
//upper[0] = MIN(sz.height, upper[0]);
//upper[1] = MIN(sz.width, upper[1]);
//printf("Slice=%d %d %d %d\n", lower[0], upper[0], lower[1], upper[1]);
return cvRect(lower[1],lower[0], upper[1]-lower[1], upper[0]-lower[0]);
}
int CheckSliceBounds(CvRect * rect, int w, int h){
//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 -1;
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);
PyErr_SetString(PyExc_IndexError, errstr);
//PyErr_SetString(PyExc_ValueError, errstr);
return 0;
}
return 1;
}
double PyObject_AsDouble(PyObject * obj){
if(PyNumber_Check(obj)){
if(PyFloat_Check(obj)){
return PyFloat_AsDouble(obj);
}
else if(PyInt_Check(obj) || PyLong_Check(obj)){
return (double) PyLong_AsLong(obj);
}
}
PyErr_SetString( PyExc_TypeError, "Could not convert python object to Double");
return -1;
}
long PyObject_AsLong(PyObject * obj){
if(PyNumber_Check(obj)){
if(PyFloat_Check(obj)){
return (long) PyFloat_AsDouble(obj);
}
else if(PyInt_Check(obj) || PyLong_Check(obj)){
return PyLong_AsLong(obj);
}
}
PyErr_SetString( PyExc_TypeError, "Could not convert python object to Long");
return -1;
}
CvArr * PyArray_to_CvArr (PyObject * obj)
{
// let's try to create a temporary CvMat header that points to the
// data owned by obj and reflects its memory layout
CvArr * cvarr = NULL;
void * raw_data = 0;
long rows;
long cols;
long channels;
long step;
long mat_type = 7;
long element_size = 1;
// infer layout from array interface
PyObject * interface = PyObject_GetAttrString (obj, "__array_interface__");
// the array interface should be a dict
if (PyMapping_Check (interface))
{
if (PyMapping_HasKeyString (interface, (char*)"version") &&
PyMapping_HasKeyString (interface, (char*)"shape") &&
PyMapping_HasKeyString (interface, (char*)"typestr") &&
PyMapping_HasKeyString (interface, (char*)"data"))
{
PyObject * version = PyMapping_GetItemString (interface, (char*)"version");
PyObject * shape = PyMapping_GetItemString (interface, (char*)"shape");
PyObject * typestr = PyMapping_GetItemString (interface, (char*)"typestr");
PyObject * data = PyMapping_GetItemString (interface, (char*)"data");
if (!PyInt_Check (version) || PyInt_AsLong (version) != 3)
PyErr_SetString(PyExc_TypeError, "OpenCV understands version 3 of the __array_interface__ only");
else
{
if (!PyTuple_Check (shape) || PyTuple_Size (shape) < 2 || PyTuple_Size (shape) > 3)
PyErr_SetString(PyExc_TypeError, "arrays must have a shape with 2 or 3 dimensions");
else
{
rows = PyInt_AsLong (PyTuple_GetItem (shape, 0));
cols = PyInt_AsLong (PyTuple_GetItem (shape, 1));
channels = PyTuple_Size (shape) < 3 ? 1 : PyInt_AsLong (PyTuple_GetItem (shape, 2));
if (rows < 1 || cols < 1 || channels < 1 || channels > 4)
PyErr_SetString(PyExc_TypeError, "rows and columns must be positive, channels from 1 to 4");
else
{
// fprintf (stderr, "rows: %ld, cols: %ld, channels %ld\n", rows, cols, channels); fflush (stderr);
if (! PyTuple_Check (data) || PyTuple_Size (data) != 2 ||
!(PyInt_Check (PyTuple_GetItem (data,0)) || PyLong_Check (PyTuple_GetItem (data,0))) ||
!(PyBool_Check (PyTuple_GetItem (data,1)) && !PyInt_AsLong (PyTuple_GetItem (data,1))))
PyErr_SetString (PyExc_TypeError, "arrays must have a pointer to writeable data");
else
{
raw_data = PyLong_AsVoidPtr (PyTuple_GetItem (data,0));
// fprintf(stderr, "raw_data: %p\n", raw_data); fflush (stderr);
char * format_str = NULL;
Py_ssize_t len = 0;
if (!PyString_Check (typestr) || PyString_AsStringAndSize (typestr, & format_str, &len) == -1 || len !=3)
PyErr_SetString(PyExc_TypeError, "there is something wrong with the format string");
else
{
// fprintf(stderr, "format: %c %c\n", format_str[1], format_str[2]); fflush (stderr);
if (format_str[1] == 'u' && format_str[2] == '1')
{
element_size = 1;
mat_type = CV_MAKETYPE(CV_8U, channels);
}
else if (format_str[1] == 'i' && format_str[2] == '1')
{
element_size = 1;
mat_type = CV_MAKETYPE(CV_8S, channels);
}
else if (format_str[1] == 'u' && format_str[2] == '2')
{
element_size = 2;
mat_type = CV_MAKETYPE(CV_16U, channels);
}
else if (format_str[1] == 'i' && format_str[2] == '2')
{
element_size = 2;
mat_type = CV_MAKETYPE(CV_16S, channels);
}
else if (format_str[1] == 'i' && format_str[2] == '4')
{
element_size = 4;
mat_type = CV_MAKETYPE(CV_32S, channels);
}
else if (format_str[1] == 'f' && format_str[2] == '4')
{
element_size = 4;
mat_type = CV_MAKETYPE(CV_32F, channels);
}
else if (format_str[1] == 'f' && format_str[2] == '8')
{
element_size = 8;
mat_type = CV_MAKETYPE(CV_64F, channels);
}
else
{
PyErr_SetString(PyExc_TypeError, "unknown or unhandled element format");
mat_type = CV_USRTYPE1;
}
// handle strides if given
// TODO: implement stride handling
step = cols * channels * element_size;
if (PyMapping_HasKeyString (interface, (char*)"strides"))
{
PyObject * strides = PyMapping_GetItemString (interface, (char*)"strides");
if (strides != Py_None)
{
fprintf(stderr, "we have strides ... not handled!\n"); fflush (stderr);
PyErr_SetString(PyExc_TypeError, "arrays with strides not handled yet");
mat_type = CV_USRTYPE1; // use this to denote, we've got an error
}
Py_DECREF (strides);
}
// create matrix header if everything is okay
if (mat_type != CV_USRTYPE1)
{
CvMat * temp_matrix = cvCreateMatHeader (rows, cols, mat_type);
cvSetData (temp_matrix, raw_data, step);
cvarr = temp_matrix;
// fprintf(stderr, "step_size: %ld, type: %ld\n", step, mat_type); fflush (stderr);
}
}
}
}
}
}
Py_DECREF (data);
Py_DECREF (typestr);
Py_DECREF (shape);
Py_DECREF (version);
}
}
Py_DECREF (interface);
return cvarr;
}
// Convert Python lists to CvMat *
CvArr * PySequence_to_CvArr (PyObject * obj)
{
int dims [CV_MAX_DIM] = { 1, 1, 1};
PyObject * container[CV_MAX_DIM+1] = {NULL, NULL, NULL, NULL};
int ndim = 0;
PyObject * item = Py_None;
// TODO: implement type detection - currently we create CV_64F only
// scan full array to
// - figure out dimensions
// - check consistency of dimensions
// - find appropriate data-type and signedness
// enum NEEDED_DATATYPE { NEEDS_CHAR, NEEDS_INTEGER, NEEDS_FLOAT, NEEDS_DOUBLE };
// NEEDED_DATATYPE needed_datatype = NEEDS_CHAR;
// bool needs_sign = false;
// scan first entries to find out dimensions
for (item = obj, ndim = 0; PySequence_Check (item) && ndim <= CV_MAX_DIM; ndim++)
{
dims [ndim] = PySequence_Size (item);
container [ndim] = PySequence_GetItem (item, 0);
item = container[ndim];
}
// in contrast to PyTuple_GetItem, PySequence_GetItame returns a NEW reference
if (container[0])
{
Py_DECREF (container[0]);
}
if (container[1])
{
Py_DECREF (container[1]);
}
if (container[2])
{
Py_DECREF (container[2]);
}
if (container[3])
{
Py_DECREF (container[3]);
}
// it only makes sense to support 2 and 3 dimensional data at this time
if (ndim < 2 || ndim > 3)
{
PyErr_SetString (PyExc_TypeError, "Nested sequences should have 2 or 3 dimensions");
return NULL;
}
// also, the number of channels should match what's typical for OpenCV
if (ndim == 3 && (dims[2] < 1 || dims[2] > 4))
{
PyErr_SetString (PyExc_TypeError, "Currently, the third dimension of CvMat only supports 1 to 4 channels");
return NULL;
}
// CvMat
CvMat * matrix = cvCreateMat (dims[0], dims[1], CV_MAKETYPE (CV_64F, dims[2]));
for (int y = 0; y < dims[0]; y++)
{
PyObject * rowobj = PySequence_GetItem (obj, y);
// double check size
if (PySequence_Check (rowobj) && PySequence_Size (rowobj) == dims[1])
{
for (int x = 0; x < dims[1]; x++)
{
PyObject * colobj = PySequence_GetItem (rowobj, x);
if (dims [2] > 1)
{
if (PySequence_Check (colobj) && PySequence_Size (colobj) == dims[2])
{
PyObject * tuple = PySequence_Tuple (colobj);
double a, b, c, d;
if (PyArg_ParseTuple (colobj, "d|d|d|d", &a, &b, &c, &d))
{
cvSet2D (matrix, y, x, cvScalar (a, b, c, d));
}
else
{
PyErr_SetString (PyExc_TypeError, "OpenCV only accepts numbers that can be converted to float");
cvReleaseMat (& matrix);
Py_DECREF (tuple);
Py_DECREF (colobj);
Py_DECREF (rowobj);
return NULL;
}
Py_DECREF (tuple);
}
else
{
PyErr_SetString (PyExc_TypeError, "All sub-sequences must have the same number of entries");
cvReleaseMat (& matrix);
Py_DECREF (colobj);
Py_DECREF (rowobj);
return NULL;
}
}
else
{
if (PyFloat_Check (colobj) || PyInt_Check (colobj))
{
cvmSet (matrix, y, x, PyFloat_AsDouble (colobj));
}
else
{
PyErr_SetString (PyExc_TypeError, "OpenCV only accepts numbers that can be converted to float");
cvReleaseMat (& matrix);
Py_DECREF (colobj);
Py_DECREF (rowobj);
return NULL;
}
}
Py_DECREF (colobj);
}
}
else
{
PyErr_SetString (PyExc_TypeError, "All sub-sequences must have the same number of entries");
cvReleaseMat (& matrix);
Py_DECREF (rowobj);
return NULL;
}
Py_DECREF (rowobj);
}
return matrix;
}

44
interfaces/swig/python/pyhelpers.h
View File

@ -1,44 +0,0 @@
#ifndef PYHELPERS_H
#define PYHELPERS_H
#include <Python.h>
#include <cxcore.h>
#include <cv.h>
/** convert python index object (tuple, integer, or slice) to CvRect for subsequent cvGetSubMat call */
CvRect PySlice_to_CvRect(CvArr * src, PyObject * idx_object);
/** 1 if rectangle is a subrectangle of [0,0,w,h], 0 otherwise */
int CheckSliceBounds(CvRect * rect, int w, int h );
/// convert object that supports the array protocol to CvMat *
CvArr * PyArray_to_CvArr (PyObject * obj);
/// convert nested sequences to CvMat *
CvArr * PySequence_to_CvArr (PyObject * obj);
/** prints array to stdout
* TODO: python __str__ and __repr__ return strings, so this should write to a string
*/
void cvArrPrint (CvArr * mat);
/** Convert an integer array to python tuple */
PyObject * PyTuple_FromIntArray(int * arr, int len);
/** If result is not NULL or PyNone, release object and replace it with obj */
PyObject * SWIG_SetResult(PyObject * result, PyObject * obj);
/** helper function to append one or more objects to the swig $result array */
PyObject * SWIG_AppendResult(PyObject * result, PyObject ** to_add, int num);
/** helper function to convert python scalar or sequence to int, float or double arrays */
double PyObject_AsDouble(PyObject * obj);
long PyObject_AsLong(PyObject * obj);
int PyObject_AsDoubleArray(PyObject * obj, double * array, int len);
int PyObject_AsLongArray( PyObject * obj, int * array, int len);
int PyObject_AsFloatArray(PyObject * obj, float * array, int len);
static inline int cvCvToIplDepth(int type) { return cvIplDepth(type); }
#endif //PYHELPERS_H

239
interfaces/swig/python/pyhelpers.i
View File

@ -1,239 +0,0 @@
/* These functions need the SWIG_* functions defined in the wrapper */
%{
#include "pyhelpers.h"
static CvArr * PyObject_to_CvArr(PyObject * obj, bool * freearg);
// convert a python sequence/array/list object into a c-array
#define PyObject_AsArrayImpl(func, ctype, ptype) \
int func(PyObject * obj, ctype * array, int len){ \
void * mat_vptr=NULL; \
void * im_vptr=NULL; \
if(PyNumber_Check(obj)){ \
memset( array, 0, sizeof(ctype)*len ); \
array[0] = PyObject_As##ptype( obj ); \
} \
else if(PyList_Check(obj) || PyTuple_Check(obj)){ \
int seqsize = PySequence_Size(obj); \
for(int i=0; i<len && i<seqsize; i++){ \
if(i<seqsize){ \
array[i] = PyObject_As##ptype( PySequence_GetItem(obj, i) ); \
} \
else{ \
array[i] = 0; \
} \
} \
} \
else if( SWIG_ConvertPtr(obj, &mat_vptr, SWIGTYPE_p_CvMat, 0)!=-1 || \
SWIG_ConvertPtr(obj, &im_vptr, SWIGTYPE_p__IplImage, 0)!=-1) \
{ \
CvMat * mat = (CvMat *) mat_vptr; \
CvMat stub; \
if(im_vptr) mat = cvGetMat(im_vptr, &stub); \
if( mat->rows!=1 && mat->cols!=1 ){ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: CvArr must be row or column vector" ); \
return -1; \
} \
if( mat->rows==1 && mat->cols==1 ){ \
CvScalar val; \
if( len!=CV_MAT_CN(mat->type) ){ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: CvArr channels != length" ); \
return -1; \
} \
val = cvGet1D(mat, 0); \
for(int i=0; i<len; i++){ \
array[i] = (ctype) val.val[i]; \
} \
} \
else{ \
mat = cvReshape(mat, &stub, -1, mat->rows*mat->cols); \
if( mat->rows != len ){ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: CvArr rows or cols must equal length" ); \
return -1; \
} \
for(int i=0; i<len; i++){ \
CvScalar val = cvGet1D(mat, i); \
array[i] = (ctype) val.val[0]; \
} \
} \
} \
else{ \
PyErr_SetString( PyExc_TypeError, \
"PyObject_As*Array: Expected a number, sequence or CvArr" ); \
return -1; \
} \
return 0; \
}
PyObject_AsArrayImpl( PyObject_AsFloatArray, float, Double );
PyObject_AsArrayImpl( PyObject_AsDoubleArray, double, Double );
PyObject_AsArrayImpl( PyObject_AsLongArray, int, Long );
static CvPoint PyObject_to_CvPoint(PyObject * obj){
CvPoint val;
CvPoint *ptr;
CvPoint2D32f * ptr2D32f;
CvScalar * scalar;
if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return *ptr;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return cvPointFrom32f( *ptr2D32f );
}
if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
return cvPointFrom32f(cvPoint2D32f( scalar->val[0], scalar->val[1] ));
}
if(PyObject_AsLongArray(obj, (int *) &val, 2) != -1){
return val;
}
PyErr_SetString( PyExc_TypeError, "could not convert to CvPoint");
return cvPoint(0,0);
}
static CvPoint2D32f PyObject_to_CvPoint2D32f(PyObject * obj){
CvPoint2D32f val;
CvPoint2D32f *ptr2D32f;
CvPoint *ptr;
CvScalar * scalar;
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return *ptr2D32f;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return cvPointTo32f(*ptr);
}
if( SWIG_ConvertPtr(obj, (void**)&scalar, SWIGTYPE_p_CvScalar, 0) != -1) {
return cvPoint2D32f( scalar->val[0], scalar->val[1] );
}
if(PyObject_AsFloatArray(obj, (float *) &val, 2) != -1){
return val;
}
PyErr_SetString(PyExc_TypeError, "could not convert to CvPoint2D32f");
return cvPoint2D32f(0,0);
}
/* Check if this object can be interpreted as a CvScalar */
static bool CvScalar_Check(PyObject * obj){
void * vptr;
CvScalar val;
return SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0 ) != -1 ||
SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D32f, 0 ) != -1 ||
SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint, 0 ) != -1 ||
PyObject_AsDoubleArray(obj, val.val, 4) !=-1;
}
static CvScalar PyObject_to_CvScalar(PyObject * obj){
CvScalar val;
CvScalar * ptr;
CvPoint2D32f *ptr2D32f;
CvPoint *pt_ptr;
void * vptr;
if( SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0 ) != -1)
{
ptr = (CvScalar *) vptr;
return *ptr;
}
if( SWIG_ConvertPtr(obj, (void**)&ptr2D32f, SWIGTYPE_p_CvPoint2D32f, 0) != -1) {
return cvScalar(ptr2D32f->x, ptr2D32f->y);
}
if( SWIG_ConvertPtr(obj, (void**)&pt_ptr, SWIGTYPE_p_CvPoint, 0) != -1) {
return cvScalar(pt_ptr->x, pt_ptr->y);
}
if(PyObject_AsDoubleArray(obj, val.val, 4)!=-1){
return val;
}
return cvScalar(-1,-1,-1,-1);
}
static int CvArr_Check( PyObject * obj )
{
void *ptr;
if( obj == Py_None ||
SWIG_IsOK( SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_void, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_CvMat, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_CvSeq, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_CvContour, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_CvSparseMat, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr(obj, &ptr, SWIGTYPE_p_CvMatND, 0) ) ||
PyObject_HasAttrString(obj, "__array_interface__") ||
PySequence_Check(obj) )
{
return 1;
}
PyErr_Clear();
return 0;
}
/* if python sequence type, convert to CvMat or CvMatND */
static CvArr * PyObject_to_CvArr (PyObject * obj, bool * freearg)
{
CvArr * cvarr = NULL;
*freearg = false;
if ( obj == Py_None )
{
// Interpret None as NULL pointer
return NULL;
}
else if( SWIG_IsOK( SWIG_ConvertPtr(obj, (void **)& cvarr, SWIGTYPE_p_void, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr (obj, (void** )& cvarr, SWIGTYPE_p_CvMat, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr (obj, (void **)& cvarr, SWIGTYPE_p_CvSeq, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr (obj, (void **)& cvarr, SWIGTYPE_p_CvContour, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr (obj, (void **)& cvarr, SWIGTYPE_p_CvSparseMat, 0) ) ||
SWIG_IsOK( SWIG_ConvertPtr (obj, (void **)& cvarr, SWIGTYPE_p_CvMatND, 0) ))
{
// we got a directly wrapped void * pointer, OpenCV array or sequence type
return cvarr;
}
else if (PyObject_HasAttrString (obj, "__array_interface__"))
{
// if we didn't get our own datatype, let's see if it supports the array protocol
// array protocol is great because we just have to create another header but can
// use the original data without copying
cvarr = PyArray_to_CvArr (obj);
*freearg = (cvarr != NULL);
}
else if (PySequence_Check (obj))
{
// our next bet is a tuple or list of tuples or lists this has to be copied over, however
cvarr = PySequence_to_CvArr (obj);
*freearg = (cvarr != NULL);
}
else if (PyLong_Check (obj) && PyLong_AsLong (obj) == 0)
{
// Interpret a '0' integer as a NULL pointer
* freearg = false;
return NULL;
}
else
{
// TODO, throw an error here
return NULL;
}
return cvarr;
}
static int PyObject_GetElemType(PyObject * obj){
void *vptr;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint, 0) != -1) return CV_32SC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize, 0) != -1) return CV_32SC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvRect, 0) != -1) return CV_32SC4;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvSize2D32f, 0) != -1) return CV_32FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D32f, 0) != -1) return CV_32FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D32f, 0) != -1) return CV_32FC3;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint2D64f, 0) != -1) return CV_64FC2;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvPoint3D64f, 0) != -1) return CV_64FC3;
if(SWIG_ConvertPtr(obj, &vptr, SWIGTYPE_p_CvScalar, 0) != -1) return CV_64FC4;
if(PyTuple_Check(obj) || PyList_Check(obj)) return CV_MAKE_TYPE(CV_32F, PySequence_Size( obj ));
if(PyLong_Check(obj)) return CV_32S;
return CV_32F;
}
%}

1478
interfaces/swig/python/pytypemaps.i
View File

File diff suppressed because it is too large Load Diff

120
interfaces/swig/python/setup-for-win.py
View File

@ -1,120 +0,0 @@
from distutils.core import setup, Extension import os
opencv_pwrap_dir = r'.'
opencv_base_dir = r'../../..'
def patch_for_win32(filename,outfile,patches,extra_defs):
print 'patching '+filename+'...'
src = open(filename,'rt')
dst = open(outfile, 'wt')
for l in src.xreadlines():
dl = l
for (from_str,to_str) in patches:
dl = dl.replace(from_str,to_str)
for i in extra_defs:
if l.find(i[0]) >= 0:
dst.write(i[1])
extra_defs.remove(i)
dst.write(dl)
src.close()
dst.close()
def is_older(a,b):
return os.path.getmtime(a)<os.path.getmtime(b)
if not os.path.exists('_cv_win32.cpp') or is_older('_cv_win32.cpp','_cv.cpp'):
patch_for_win32('_cv.cpp', '_cv_win32.cpp',
[('unsigned long long','uint64',),('long long','int64'),
("char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);",
"char *doc = (char*)(((PyCFunctionObject *)obj) -> m_ml -> ml_doc);"),
("char *c = methods[i].ml_doc;",
"char *c = (char*)methods[i].ml_doc;")],
[('PyAPI_FUNC','#undef PyAPI_FUNC\n'), ('cv.h',
"""
#include "cv.h"
const signed char icvDepthToType[]=
{
-1, -1, CV_8U, CV_8S, CV_16U, CV_16S, -1, -1,
CV_32F, CV_32S, -1, -1, -1, -1, -1, -1, CV_64F, -1
};
CvModuleInfo* CvModule::first = 0;
CvModuleInfo* CvModule::last = 0;
CvTypeInfo* CvType::first = 0;
CvTypeInfo* CvType::last = 0;
""")])
if not os.path.exists('_highgui_win32.cpp') or is_older('_highgui_win32.cpp','_highgui.cpp'):
patch_for_win32('_highgui.cpp', '_highgui_win32.cpp',
[('unsigned long long','uint64',),('long long','int64'),
("char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);",
"char *doc = (char*)(((PyCFunctionObject *)obj) -> m_ml -> ml_doc);"),
("char *c = methods[i].ml_doc;",
"char *c = (char*)methods[i].ml_doc;")],
[('PyAPI_FUNC','#undef PyAPI_FUNC\n')])
if not os.path.exists('_ml_win32.cpp') or is_older('_ml_win32.cpp','_ml.cpp'):
patch_for_win32('_ml.cpp', '_ml_win32.cpp',
[('unsigned long long','uint64',),('long long','int64'),
("char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);",
"char *doc = (char*)(((PyCFunctionObject *)obj) -> m_ml -> ml_doc);"),
("char *c = methods[i].ml_doc;",
"char *c = (char*)methods[i].ml_doc;")],
[('PyAPI_FUNC','#undef PyAPI_FUNC\n')])
setup(name='OpenCV Python Wrapper',
version='0.0',
packages = ['opencv'],
package_dir = {'opencv': opencv_pwrap_dir},
ext_modules=[Extension('opencv._cv',
[os.path.join (opencv_pwrap_dir, '_cv_win32.cpp'),
os.path.join (opencv_pwrap_dir, 'error.cpp'),
os.path.join (opencv_pwrap_dir, 'cvshadow.cpp'),
os.path.join (opencv_pwrap_dir, 'pyhelpers.cpp')],
include_dirs = [os.path.join (opencv_base_dir,
'cv', 'include'),
os.path.join (opencv_base_dir,
'cxcore', 'include'),
],
library_dirs = [os.path.join (opencv_base_dir,
'lib')],
libraries = ['cv', 'cxcore'],
),
Extension('opencv._ml',
[os.path.join (opencv_pwrap_dir, '_ml_win32.cpp'),
os.path.join (opencv_pwrap_dir, 'error.cpp'),
os.path.join (opencv_pwrap_dir, 'cvshadow.cpp'),
os.path.join (opencv_pwrap_dir, 'pyhelpers.cpp')],
include_dirs = [os.path.join (opencv_base_dir,
'cv', 'include'),
os.path.join (opencv_base_dir,
'cxcore', 'include'),
os.path.join (opencv_base_dir,
'ml', 'include'),
os.path.join (opencv_base_dir,
'otherlibs', 'highgui'),
],
library_dirs = [os.path.join (opencv_base_dir,
'lib')],
libraries = ['cv', 'cxcore', 'ml'],
),
Extension('opencv._highgui', [os.path.join (opencv_pwrap_dir, '_highgui_win32.cpp'),
os.path.join (opencv_pwrap_dir, 'error.cpp'),
os.path.join (opencv_pwrap_dir, 'cvshadow.cpp'),
os.path.join (opencv_pwrap_dir, 'pyhelpers.cpp')],
include_dirs = [os.path.join (opencv_base_dir,
'otherlibs', 'highgui'),
os.path.join (opencv_base_dir,
'cxcore', 'include'),
os.path.join (opencv_base_dir,
'cv', 'include')],
library_dirs = [os.path.join (opencv_base_dir,
'lib')],
libraries = ['highgui', 'cv', 'cxcore'],
)
]
)