mirror of https://github.com/opencv/opencv.git
Merge pull request #809 from taka-no-me:drop_python1
Andrey Kamaev
12 years ago
committed by
OpenCV Buildbot
commit
4223a59497
112 changed files with 1304 additions and 13882 deletions
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,384 @@ |
||||
/*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.
|
||||
//
|
||||
//
|
||||
// License Agreement
|
||||
// For Open Source Computer Vision Library
|
||||
//
|
||||
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
|
||||
// Copyright (C) 2009-2011, Willow Garage Inc., 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 the copyright holders 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 __OPENCV_CONTRIB_COMPAT_HPP__ |
||||
#define __OPENCV_CONTRIB_COMPAT_HPP__ |
||||
|
||||
#include "opencv2/core/core_c.h" |
||||
|
||||
#ifdef __cplusplus |
||||
|
||||
/****************************************************************************************\
|
||||
* Adaptive Skin Detector * |
||||
\****************************************************************************************/ |
||||
|
||||
class CV_EXPORTS CvAdaptiveSkinDetector |
||||
{ |
||||
private: |
||||
enum { |
||||
GSD_HUE_LT = 3, |
||||
GSD_HUE_UT = 33, |
||||
GSD_INTENSITY_LT = 15, |
||||
GSD_INTENSITY_UT = 250 |
||||
}; |
||||
|
||||
class CV_EXPORTS Histogram |
||||
{ |
||||
private: |
||||
enum { |
||||
HistogramSize = (GSD_HUE_UT - GSD_HUE_LT + 1) |
||||
}; |
||||
|
||||
protected: |
||||
int findCoverageIndex(double surfaceToCover, int defaultValue = 0); |
||||
|
||||
public: |
||||
CvHistogram *fHistogram; |
||||
Histogram(); |
||||
virtual ~Histogram(); |
||||
|
||||
void findCurveThresholds(int &x1, int &x2, double percent = 0.05); |
||||
void mergeWith(Histogram *source, double weight); |
||||
}; |
||||
|
||||
int nStartCounter, nFrameCount, nSkinHueLowerBound, nSkinHueUpperBound, nMorphingMethod, nSamplingDivider; |
||||
double fHistogramMergeFactor, fHuePercentCovered; |
||||
Histogram histogramHueMotion, skinHueHistogram; |
||||
IplImage *imgHueFrame, *imgSaturationFrame, *imgLastGrayFrame, *imgMotionFrame, *imgFilteredFrame; |
||||
IplImage *imgShrinked, *imgTemp, *imgGrayFrame, *imgHSVFrame; |
||||
|
||||
protected: |
||||
void initData(IplImage *src, int widthDivider, int heightDivider); |
||||
void adaptiveFilter(); |
||||
|
||||
public: |
||||
|
||||
enum { |
||||
MORPHING_METHOD_NONE = 0, |
||||
MORPHING_METHOD_ERODE = 1, |
||||
MORPHING_METHOD_ERODE_ERODE = 2, |
||||
MORPHING_METHOD_ERODE_DILATE = 3 |
||||
}; |
||||
|
||||
CvAdaptiveSkinDetector(int samplingDivider = 1, int morphingMethod = MORPHING_METHOD_NONE); |
||||
virtual ~CvAdaptiveSkinDetector(); |
||||
|
||||
virtual void process(IplImage *inputBGRImage, IplImage *outputHueMask); |
||||
}; |
||||
|
||||
|
||||
/****************************************************************************************\
|
||||
* Fuzzy MeanShift Tracker * |
||||
\****************************************************************************************/ |
||||
|
||||
class CV_EXPORTS CvFuzzyPoint { |
||||
public: |
||||
double x, y, value; |
||||
|
||||
CvFuzzyPoint(double _x, double _y); |
||||
}; |
||||
|
||||
class CV_EXPORTS CvFuzzyCurve { |
||||
private: |
||||
std::vector<CvFuzzyPoint> points; |
||||
double value, centre; |
||||
|
||||
bool between(double x, double x1, double x2); |
||||
|
||||
public: |
||||
CvFuzzyCurve(); |
||||
~CvFuzzyCurve(); |
||||
|
||||
void setCentre(double _centre); |
||||
double getCentre(); |
||||
void clear(); |
||||
void addPoint(double x, double y); |
||||
double calcValue(double param); |
||||
double getValue(); |
||||
void setValue(double _value); |
||||
}; |
||||
|
||||
class CV_EXPORTS CvFuzzyFunction { |
||||
public: |
||||
std::vector<CvFuzzyCurve> curves; |
||||
|
||||
CvFuzzyFunction(); |
||||
~CvFuzzyFunction(); |
||||
void addCurve(CvFuzzyCurve *curve, double value = 0); |
||||
void resetValues(); |
||||
double calcValue(); |
||||
CvFuzzyCurve *newCurve(); |
||||
}; |
||||
|
||||
class CV_EXPORTS CvFuzzyRule { |
||||
private: |
||||
CvFuzzyCurve *fuzzyInput1, *fuzzyInput2; |
||||
CvFuzzyCurve *fuzzyOutput; |
||||
public: |
||||
CvFuzzyRule(); |
||||
~CvFuzzyRule(); |
||||
void setRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1); |
||||
double calcValue(double param1, double param2); |
||||
CvFuzzyCurve *getOutputCurve(); |
||||
}; |
||||
|
||||
class CV_EXPORTS CvFuzzyController { |
||||
private: |
||||
std::vector<CvFuzzyRule*> rules; |
||||
public: |
||||
CvFuzzyController(); |
||||
~CvFuzzyController(); |
||||
void addRule(CvFuzzyCurve *c1, CvFuzzyCurve *c2, CvFuzzyCurve *o1); |
||||
double calcOutput(double param1, double param2); |
||||
}; |
||||
|
||||
class CV_EXPORTS CvFuzzyMeanShiftTracker |
||||
{ |
||||
private: |
||||
class FuzzyResizer |
||||
{ |
||||
private: |
||||
CvFuzzyFunction iInput, iOutput; |
||||
CvFuzzyController fuzzyController; |
||||
public: |
||||
FuzzyResizer(); |
||||
int calcOutput(double edgeDensity, double density); |
||||
}; |
||||
|
||||
class SearchWindow |
||||
{ |
||||
public: |
||||
FuzzyResizer *fuzzyResizer; |
||||
int x, y; |
||||
int width, height, maxWidth, maxHeight, ellipseHeight, ellipseWidth; |
||||
int ldx, ldy, ldw, ldh, numShifts, numIters; |
||||
int xGc, yGc; |
||||
long m00, m01, m10, m11, m02, m20; |
||||
double ellipseAngle; |
||||
double density; |
||||
unsigned int depthLow, depthHigh; |
||||
int verticalEdgeLeft, verticalEdgeRight, horizontalEdgeTop, horizontalEdgeBottom; |
||||
|
||||
SearchWindow(); |
||||
~SearchWindow(); |
||||
void setSize(int _x, int _y, int _width, int _height); |
||||
void initDepthValues(IplImage *maskImage, IplImage *depthMap); |
||||
bool shift(); |
||||
void extractInfo(IplImage *maskImage, IplImage *depthMap, bool initDepth); |
||||
void getResizeAttribsEdgeDensityLinear(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh); |
||||
void getResizeAttribsInnerDensity(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh); |
||||
void getResizeAttribsEdgeDensityFuzzy(int &resizeDx, int &resizeDy, int &resizeDw, int &resizeDh); |
||||
bool meanShift(IplImage *maskImage, IplImage *depthMap, int maxIteration, bool initDepth); |
||||
}; |
||||
|
||||
public: |
||||
enum TrackingState |
||||
{ |
||||
tsNone = 0, |
||||
tsSearching = 1, |
||||
tsTracking = 2, |
||||
tsSetWindow = 3, |
||||
tsDisabled = 10 |
||||
}; |
||||
|
||||
enum ResizeMethod { |
||||
rmEdgeDensityLinear = 0, |
||||
rmEdgeDensityFuzzy = 1, |
||||
rmInnerDensity = 2 |
||||
}; |
||||
|
||||
enum { |
||||
MinKernelMass = 1000 |
||||
}; |
||||
|
||||
SearchWindow kernel; |
||||
int searchMode; |
||||
|
||||
private: |
||||
enum
|
||||
{ |
||||
MaxMeanShiftIteration = 5, |
||||
MaxSetSizeIteration = 5 |
||||
}; |
||||
|
||||
void findOptimumSearchWindow(SearchWindow &searchWindow, IplImage *maskImage, IplImage *depthMap, int maxIteration, int resizeMethod, bool initDepth); |
||||
|
||||
public: |
||||
CvFuzzyMeanShiftTracker(); |
||||
~CvFuzzyMeanShiftTracker(); |
||||
|
||||
void track(IplImage *maskImage, IplImage *depthMap, int resizeMethod, bool resetSearch, int minKernelMass = MinKernelMass); |
||||
}; |
||||
|
||||
|
||||
namespace cv |
||||
{ |
||||
|
||||
typedef bool (*BundleAdjustCallback)(int iteration, double norm_error, void* user_data); |
||||
|
||||
class CV_EXPORTS LevMarqSparse { |
||||
public: |
||||
LevMarqSparse(); |
||||
LevMarqSparse(int npoints, // number of points
|
||||
int ncameras, // number of cameras
|
||||
int nPointParams, // number of params per one point (3 in case of 3D points)
|
||||
int nCameraParams, // number of parameters per one camera
|
||||
int nErrParams, // number of parameters in measurement vector
|
||||
// for 1 point at one camera (2 in case of 2D projections)
|
||||
Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras
|
||||
// 1 - point is visible for the camera, 0 - invisible
|
||||
Mat& P0, // starting vector of parameters, first cameras then points
|
||||
Mat& X, // measurements, in order of visibility. non visible cases are skipped
|
||||
TermCriteria criteria, // termination criteria
|
||||
|
||||
// callback for estimation of Jacobian matrices
|
||||
void (*fjac)(int i, int j, Mat& point_params, |
||||
Mat& cam_params, Mat& A, Mat& B, void* data), |
||||
// callback for estimation of backprojection errors
|
||||
void (*func)(int i, int j, Mat& point_params, |
||||
Mat& cam_params, Mat& estim, void* data), |
||||
void* data, // user-specific data passed to the callbacks
|
||||
BundleAdjustCallback cb, void* user_data |
||||
); |
||||
|
||||
virtual ~LevMarqSparse(); |
||||
|
||||
virtual void run( int npoints, // number of points
|
||||
int ncameras, // number of cameras
|
||||
int nPointParams, // number of params per one point (3 in case of 3D points)
|
||||
int nCameraParams, // number of parameters per one camera
|
||||
int nErrParams, // number of parameters in measurement vector
|
||||
// for 1 point at one camera (2 in case of 2D projections)
|
||||
Mat& visibility, // visibility matrix. rows correspond to points, columns correspond to cameras
|
||||
// 1 - point is visible for the camera, 0 - invisible
|
||||
Mat& P0, // starting vector of parameters, first cameras then points
|
||||
Mat& X, // measurements, in order of visibility. non visible cases are skipped
|
||||
TermCriteria criteria, // termination criteria
|
||||
|
||||
// callback for estimation of Jacobian matrices
|
||||
void (CV_CDECL * fjac)(int i, int j, Mat& point_params, |
||||
Mat& cam_params, Mat& A, Mat& B, void* data), |
||||
// callback for estimation of backprojection errors
|
||||
void (CV_CDECL * func)(int i, int j, Mat& point_params, |
||||
Mat& cam_params, Mat& estim, void* data), |
||||
void* data // user-specific data passed to the callbacks
|
||||
); |
||||
|
||||
virtual void clear(); |
||||
|
||||
// useful function to do simple bundle adjustment tasks
|
||||
static void bundleAdjust(std::vector<Point3d>& points, // positions of points in global coordinate system (input and output)
|
||||
const std::vector<std::vector<Point2d> >& imagePoints, // projections of 3d points for every camera
|
||||
const std::vector<std::vector<int> >& visibility, // visibility of 3d points for every camera
|
||||
std::vector<Mat>& cameraMatrix, // intrinsic matrices of all cameras (input and output)
|
||||
std::vector<Mat>& R, // rotation matrices of all cameras (input and output)
|
||||
std::vector<Mat>& T, // translation vector of all cameras (input and output)
|
||||
std::vector<Mat>& distCoeffs, // distortion coefficients of all cameras (input and output)
|
||||
const TermCriteria& criteria= |
||||
TermCriteria(TermCriteria::COUNT+TermCriteria::EPS, 30, DBL_EPSILON), |
||||
BundleAdjustCallback cb = 0, void* user_data = 0); |
||||
|
||||
public: |
||||
virtual void optimize(CvMat &_vis); //main function that runs minimization
|
||||
|
||||
//iteratively asks for measurement for visible camera-point pairs
|
||||
void ask_for_proj(CvMat &_vis,bool once=false); |
||||
//iteratively asks for Jacobians for every camera_point pair
|
||||
void ask_for_projac(CvMat &_vis); |
||||
|
||||
CvMat* err; //error X-hX
|
||||
double prevErrNorm, errNorm; |
||||
double lambda; |
||||
CvTermCriteria criteria; |
||||
int iters; |
||||
|
||||
CvMat** U; //size of array is equal to number of cameras
|
||||
CvMat** V; //size of array is equal to number of points
|
||||
CvMat** inv_V_star; //inverse of V*
|
||||
|
||||
CvMat** A; |
||||
CvMat** B; |
||||
CvMat** W; |
||||
|
||||
CvMat* X; //measurement
|
||||
CvMat* hX; //current measurement extimation given new parameter vector
|
||||
|
||||
CvMat* prevP; //current already accepted parameter.
|
||||
CvMat* P; // parameters used to evaluate function with new params
|
||||
// this parameters may be rejected
|
||||
|
||||
CvMat* deltaP; //computed increase of parameters (result of normal system solution )
|
||||
|
||||
CvMat** ea; // sum_i AijT * e_ij , used as right part of normal equation
|
||||
// length of array is j = number of cameras
|
||||
CvMat** eb; // sum_j BijT * e_ij , used as right part of normal equation
|
||||
// length of array is i = number of points
|
||||
|
||||
CvMat** Yj; //length of array is i = num_points
|
||||
|
||||
CvMat* S; //big matrix of block Sjk , each block has size num_cam_params x num_cam_params
|
||||
|
||||
CvMat* JtJ_diag; //diagonal of JtJ, used to backup diagonal elements before augmentation
|
||||
|
||||
CvMat* Vis_index; // matrix which element is index of measurement for point i and camera j
|
||||
|
||||
int num_cams; |
||||
int num_points; |
||||
int num_err_param; |
||||
int num_cam_param; |
||||
int num_point_param; |
||||
|
||||
//target function and jacobian pointers, which needs to be initialized
|
||||
void (*fjac)(int i, int j, Mat& point_params, Mat& cam_params, Mat& A, Mat& B, void* data); |
||||
void (*func)(int i, int j, Mat& point_params, Mat& cam_params, Mat& estim, void* data); |
||||
|
||||
void* data; |
||||
|
||||
BundleAdjustCallback cb; |
||||
void* user_data; |
||||
}; |
||||
|
||||
} // cv
|
||||
|
||||
#endif /* __cplusplus */ |
||||
|
||||
#endif /* __OPENCV_CONTRIB_COMPAT_HPP__ */ |
||||
File diff suppressed because it is too large
Load Diff
@ -1 +0,0 @@ |
||||
from cv2.cv import * |
||||
File diff suppressed because it is too large
Load Diff
@ -1,360 +0,0 @@ |
||||
#define CV_BLUR_NO_SCALE 0 |
||||
#define CV_BLUR 1 |
||||
#define CV_GAUSSIAN 2 |
||||
#define CV_MEDIAN 3 |
||||
#define CV_BILATERAL 4 |
||||
#define CV_INPAINT_NS 0 |
||||
#define CV_INPAINT_TELEA 1 |
||||
#define CV_SCHARR -1 |
||||
#define CV_MAX_SOBEL_KSIZE 7 |
||||
#define CV_BGR2BGRA 0 |
||||
#define CV_RGB2RGBA CV_BGR2BGRA |
||||
#define CV_BGRA2BGR 1 |
||||
#define CV_RGBA2RGB CV_BGRA2BGR |
||||
#define CV_BGR2RGBA 2 |
||||
#define CV_RGB2BGRA CV_BGR2RGBA |
||||
#define CV_RGBA2BGR 3 |
||||
#define CV_BGRA2RGB CV_RGBA2BGR |
||||
#define CV_BGR2RGB 4 |
||||
#define CV_RGB2BGR CV_BGR2RGB |
||||
#define CV_BGRA2RGBA 5 |
||||
#define CV_RGBA2BGRA CV_BGRA2RGBA |
||||
#define CV_BGR2GRAY 6 |
||||
#define CV_RGB2GRAY 7 |
||||
#define CV_GRAY2BGR 8 |
||||
#define CV_GRAY2RGB CV_GRAY2BGR |
||||
#define CV_GRAY2BGRA 9 |
||||
#define CV_GRAY2RGBA CV_GRAY2BGRA |
||||
#define CV_BGRA2GRAY 10 |
||||
#define CV_RGBA2GRAY 11 |
||||
#define CV_BGR2BGR565 12 |
||||
#define CV_RGB2BGR565 13 |
||||
#define CV_BGR5652BGR 14 |
||||
#define CV_BGR5652RGB 15 |
||||
#define CV_BGRA2BGR565 16 |
||||
#define CV_RGBA2BGR565 17 |
||||
#define CV_BGR5652BGRA 18 |
||||
#define CV_BGR5652RGBA 19 |
||||
#define CV_GRAY2BGR565 20 |
||||
#define CV_BGR5652GRAY 21 |
||||
#define CV_BGR2BGR555 22 |
||||
#define CV_RGB2BGR555 23 |
||||
#define CV_BGR5552BGR 24 |
||||
#define CV_BGR5552RGB 25 |
||||
#define CV_BGRA2BGR555 26 |
||||
#define CV_RGBA2BGR555 27 |
||||
#define CV_BGR5552BGRA 28 |
||||
#define CV_BGR5552RGBA 29 |
||||
#define CV_GRAY2BGR555 30 |
||||
#define CV_BGR5552GRAY 31 |
||||
#define CV_BGR2XYZ 32 |
||||
#define CV_RGB2XYZ 33 |
||||
#define CV_XYZ2BGR 34 |
||||
#define CV_XYZ2RGB 35 |
||||
#define CV_BGR2YCrCb 36 |
||||
#define CV_RGB2YCrCb 37 |
||||
#define CV_YCrCb2BGR 38 |
||||
#define CV_YCrCb2RGB 39 |
||||
#define CV_BGR2HSV 40 |
||||
#define CV_RGB2HSV 41 |
||||
#define CV_BGR2Lab 44 |
||||
#define CV_RGB2Lab 45 |
||||
#define CV_BayerBG2BGR 46 |
||||
#define CV_BayerGB2BGR 47 |
||||
#define CV_BayerRG2BGR 48 |
||||
#define CV_BayerGR2BGR 49 |
||||
#define CV_BayerBG2RGB CV_BayerRG2BGR |
||||
#define CV_BayerGB2RGB CV_BayerGR2BGR |
||||
#define CV_BayerRG2RGB CV_BayerBG2BGR |
||||
#define CV_BayerGR2RGB CV_BayerGB2BGR |
||||
#define CV_BayerBG2BGR_VNG 62 |
||||
#define CV_BayerGB2BGR_VNG 63 |
||||
#define CV_BayerRG2BGR_VNG 64 |
||||
#define CV_BayerGR2BGR_VNG 65 |
||||
#define CV_BGR2Luv 50 |
||||
#define CV_RGB2Luv 51 |
||||
#define CV_BGR2HLS 52 |
||||
#define CV_RGB2HLS 53 |
||||
#define CV_HSV2BGR 54 |
||||
#define CV_HSV2RGB 55 |
||||
#define CV_Lab2BGR 56 |
||||
#define CV_Lab2RGB 57 |
||||
#define CV_Luv2BGR 58 |
||||
#define CV_Luv2RGB 59 |
||||
#define CV_HLS2BGR 60 |
||||
#define CV_HLS2RGB 61 |
||||
#define CV_COLORCVT_MAX 100 |
||||
#define CV_INTER_NN 0 |
||||
#define CV_INTER_LINEAR 1 |
||||
#define CV_INTER_CUBIC 2 |
||||
#define CV_INTER_AREA 3 |
||||
#define CV_WARP_FILL_OUTLIERS 8 |
||||
#define CV_WARP_INVERSE_MAP 16 |
||||
#define CV_SHAPE_RECT 0 |
||||
#define CV_SHAPE_CROSS 1 |
||||
#define CV_SHAPE_ELLIPSE 2 |
||||
#define CV_SHAPE_CUSTOM 100 |
||||
#define CV_MOP_OPEN 2 |
||||
#define CV_MOP_CLOSE 3 |
||||
#define CV_MOP_GRADIENT 4 |
||||
#define CV_MOP_TOPHAT 5 |
||||
#define CV_MOP_BLACKHAT 6 |
||||
#define CV_TM_SQDIFF 0 |
||||
#define CV_TM_SQDIFF_NORMED 1 |
||||
#define CV_TM_CCORR 2 |
||||
#define CV_TM_CCORR_NORMED 3 |
||||
#define CV_TM_CCOEFF 4 |
||||
#define CV_TM_CCOEFF_NORMED 5 |
||||
#define CV_LKFLOW_PYR_A_READY 1 |
||||
#define CV_LKFLOW_PYR_B_READY 2 |
||||
#define CV_LKFLOW_INITIAL_GUESSES 4 |
||||
#define CV_LKFLOW_GET_MIN_EIGENVALS 8 |
||||
#define CV_POLY_APPROX_DP 0 |
||||
#define CV_CONTOURS_MATCH_I1 1 |
||||
#define CV_CONTOURS_MATCH_I2 2 |
||||
#define CV_CONTOURS_MATCH_I3 3 |
||||
#define CV_CLOCKWISE 1 |
||||
#define CV_COUNTER_CLOCKWISE 2 |
||||
#define CV_COMP_CORREL 0 |
||||
#define CV_COMP_CHISQR 1 |
||||
#define CV_COMP_INTERSECT 2 |
||||
#define CV_COMP_BHATTACHARYYA 3 |
||||
#define CV_DIST_MASK_3 3 |
||||
#define CV_DIST_MASK_5 5 |
||||
#define CV_DIST_MASK_PRECISE 0 |
||||
#define CV_THRESH_BINARY 0 /* value = value > threshold ? max_value : 0 */ |
||||
#define CV_THRESH_BINARY_INV 1 /* value = value > threshold ? 0 : max_value */ |
||||
#define CV_THRESH_TRUNC 2 /* value = value > threshold ? threshold : value */ |
||||
#define CV_THRESH_TOZERO 3 /* value = value > threshold ? value : 0 */ |
||||
#define CV_THRESH_TOZERO_INV 4 /* value = value > threshold ? 0 : value */ |
||||
#define CV_THRESH_MASK 7 |
||||
#define CV_THRESH_OTSU 8 /* use Otsu algorithm to choose the optimal threshold value; |
||||
#define CV_ADAPTIVE_THRESH_MEAN_C 0 |
||||
#define CV_ADAPTIVE_THRESH_GAUSSIAN_C 1 |
||||
#define CV_FLOODFILL_FIXED_RANGE (1 << 16) |
||||
#define CV_FLOODFILL_MASK_ONLY (1 << 17) |
||||
#define CV_CANNY_L2_GRADIENT (1 << 31) |
||||
#define CV_HOUGH_STANDARD 0 |
||||
#define CV_HOUGH_PROBABILISTIC 1 |
||||
#define CV_HOUGH_MULTI_SCALE 2 |
||||
#define CV_HOUGH_GRADIENT 3 |
||||
#define CV_HAAR_DO_CANNY_PRUNING 1 |
||||
#define CV_HAAR_SCALE_IMAGE 2 |
||||
#define CV_HAAR_FIND_BIGGEST_OBJECT 4 |
||||
#define CV_HAAR_DO_ROUGH_SEARCH 8 |
||||
#define CV_LMEDS 4 |
||||
#define CV_RANSAC 8 |
||||
#define CV_CALIB_CB_ADAPTIVE_THRESH 1 |
||||
#define CV_CALIB_CB_NORMALIZE_IMAGE 2 |
||||
#define CV_CALIB_CB_FILTER_QUADS 4 |
||||
#define CV_CALIB_USE_INTRINSIC_GUESS 1 |
||||
#define CV_CALIB_FIX_ASPECT_RATIO 2 |
||||
#define CV_CALIB_FIX_PRINCIPAL_POINT 4 |
||||
#define CV_CALIB_ZERO_TANGENT_DIST 8 |
||||
#define CV_CALIB_FIX_FOCAL_LENGTH 16 |
||||
#define CV_CALIB_FIX_K1 32 |
||||
#define CV_CALIB_FIX_K2 64 |
||||
#define CV_CALIB_FIX_K3 128 |
||||
#define CV_CALIB_FIX_INTRINSIC 256 |
||||
#define CV_CALIB_SAME_FOCAL_LENGTH 512 |
||||
#define CV_CALIB_ZERO_DISPARITY 1024 |
||||
#define CV_FM_7POINT 1 |
||||
#define CV_FM_8POINT 2 |
||||
#define CV_FM_LMEDS_ONLY CV_LMEDS |
||||
#define CV_FM_RANSAC_ONLY CV_RANSAC |
||||
#define CV_FM_LMEDS CV_LMEDS |
||||
#define CV_FM_RANSAC CV_RANSAC |
||||
#define CV_STEREO_BM_NORMALIZED_RESPONSE 0 |
||||
#define CV_STEREO_BM_BASIC 0 |
||||
#define CV_STEREO_BM_FISH_EYE 1 |
||||
#define CV_STEREO_BM_NARROW 2 |
||||
#define CV_STEREO_GC_OCCLUDED SHRT_MAX |
||||
#define CV_AUTOSTEP 0x7fffffff |
||||
#define CV_MAX_ARR 10 |
||||
#define CV_NO_DEPTH_CHECK 1 |
||||
#define CV_NO_CN_CHECK 2 |
||||
#define CV_NO_SIZE_CHECK 4 |
||||
#define CV_CMP_EQ 0 |
||||
#define CV_CMP_GT 1 |
||||
#define CV_CMP_GE 2 |
||||
#define CV_CMP_LT 3 |
||||
#define CV_CMP_LE 4 |
||||
#define CV_CMP_NE 5 |
||||
#define CV_CHECK_RANGE 1 |
||||
#define CV_CHECK_QUIET 2 |
||||
#define CV_RAND_UNI 0 |
||||
#define CV_RAND_NORMAL 1 |
||||
#define CV_SORT_EVERY_ROW 0 |
||||
#define CV_SORT_EVERY_COLUMN 1 |
||||
#define CV_SORT_ASCENDING 0 |
||||
#define CV_SORT_DESCENDING 16 |
||||
#define CV_GEMM_A_T 1 |
||||
#define CV_GEMM_B_T 2 |
||||
#define CV_GEMM_C_T 4 |
||||
#define CV_SVD_MODIFY_A 1 |
||||
#define CV_SVD_U_T 2 |
||||
#define CV_SVD_V_T 4 |
||||
#define CV_LU 0 |
||||
#define CV_SVD 1 |
||||
#define CV_SVD_SYM 2 |
||||
#define CV_CHOLESKY 3 |
||||
#define CV_QR 4 |
||||
#define CV_NORMAL 16 |
||||
#define CV_COVAR_SCRAMBLED 0 |
||||
#define CV_COVAR_NORMAL 1 |
||||
#define CV_COVAR_USE_AVG 2 |
||||
#define CV_COVAR_SCALE 4 |
||||
#define CV_COVAR_ROWS 8 |
||||
#define CV_COVAR_COLS 16 |
||||
#define CV_PCA_DATA_AS_ROW 0 |
||||
#define CV_PCA_DATA_AS_COL 1 |
||||
#define CV_PCA_USE_AVG 2 |
||||
#define CV_C 1 |
||||
#define CV_L1 2 |
||||
#define CV_L2 4 |
||||
#define CV_NORM_MASK 7 |
||||
#define CV_RELATIVE 8 |
||||
#define CV_DIFF 16 |
||||
#define CV_MINMAX 32 |
||||
#define CV_DIFF_C (CV_DIFF | CV_C) |
||||
#define CV_DIFF_L1 (CV_DIFF | CV_L1) |
||||
#define CV_DIFF_L2 (CV_DIFF | CV_L2) |
||||
#define CV_RELATIVE_C (CV_RELATIVE | CV_C) |
||||
#define CV_RELATIVE_L1 (CV_RELATIVE | CV_L1) |
||||
#define CV_RELATIVE_L2 (CV_RELATIVE | CV_L2) |
||||
#define CV_REDUCE_SUM 0 |
||||
#define CV_REDUCE_AVG 1 |
||||
#define CV_REDUCE_MAX 2 |
||||
#define CV_REDUCE_MIN 3 |
||||
#define CV_DXT_FORWARD 0 |
||||
#define CV_DXT_INVERSE 1 |
||||
#define CV_DXT_SCALE 2 /* divide result by size of array */ |
||||
#define CV_DXT_INV_SCALE (CV_DXT_INVERSE + CV_DXT_SCALE) |
||||
#define CV_DXT_INVERSE_SCALE CV_DXT_INV_SCALE |
||||
#define CV_DXT_ROWS 4 /* transform each row individually */ |
||||
#define CV_DXT_MUL_CONJ 8 /* conjugate the second argument of cvMulSpectrums */ |
||||
#define CV_FRONT 1 |
||||
#define CV_BACK 0 |
||||
#define CV_GRAPH_VERTEX 1 |
||||
#define CV_GRAPH_TREE_EDGE 2 |
||||
#define CV_GRAPH_BACK_EDGE 4 |
||||
#define CV_GRAPH_FORWARD_EDGE 8 |
||||
#define CV_GRAPH_CROSS_EDGE 16 |
||||
#define CV_GRAPH_ANY_EDGE 30 |
||||
#define CV_GRAPH_NEW_TREE 32 |
||||
#define CV_GRAPH_BACKTRACKING 64 |
||||
#define CV_GRAPH_OVER -1 |
||||
#define CV_GRAPH_ALL_ITEMS -1 |
||||
#define CV_GRAPH_ITEM_VISITED_FLAG (1 << 30) |
||||
#define CV_GRAPH_SEARCH_TREE_NODE_FLAG (1 << 29) |
||||
#define CV_GRAPH_FORWARD_EDGE_FLAG (1 << 28) |
||||
#define CV_FILLED -1 |
||||
#define CV_AA 16 |
||||
#define CV_FONT_HERSHEY_SIMPLEX 0 |
||||
#define CV_FONT_HERSHEY_PLAIN 1 |
||||
#define CV_FONT_HERSHEY_DUPLEX 2 |
||||
#define CV_FONT_HERSHEY_COMPLEX 3 |
||||
#define CV_FONT_HERSHEY_TRIPLEX 4 |
||||
#define CV_FONT_HERSHEY_COMPLEX_SMALL 5 |
||||
#define CV_FONT_HERSHEY_SCRIPT_SIMPLEX 6 |
||||
#define CV_FONT_HERSHEY_SCRIPT_COMPLEX 7 |
||||
#define CV_FONT_ITALIC 16 |
||||
#define CV_FONT_VECTOR0 CV_FONT_HERSHEY_SIMPLEX |
||||
#define CV_KMEANS_USE_INITIAL_LABELS 1 |
||||
#define CV_ErrModeLeaf 0 /* Print error and exit program */ |
||||
#define CV_ErrModeParent 1 /* Print error and continue */ |
||||
#define CV_ErrModeSilent 2 /* Don't print and continue */ |
||||
#define CV_RETR_EXTERNAL 0 |
||||
#define CV_RETR_LIST 1 |
||||
#define CV_RETR_CCOMP 2 |
||||
#define CV_RETR_TREE 3 |
||||
#define CV_CHAIN_CODE 0 |
||||
#define CV_CHAIN_APPROX_NONE 1 |
||||
#define CV_CHAIN_APPROX_SIMPLE 2 |
||||
#define CV_CHAIN_APPROX_TC89_L1 3 |
||||
#define CV_CHAIN_APPROX_TC89_KCOS 4 |
||||
#define CV_LINK_RUNS 5 |
||||
#define CV_SUBDIV2D_VIRTUAL_POINT_FLAG (1 << 30) |
||||
#define CV_DIST_USER -1 /* User defined distance */ |
||||
#define CV_DIST_L1 1 /* distance = |x1-x2| + |y1-y2| */ |
||||
#define CV_DIST_L2 2 /* the simple euclidean distance */ |
||||
#define CV_DIST_C 3 /* distance = max(|x1-x2|,|y1-y2|) */ |
||||
#define CV_DIST_L12 4 /* L1-L2 metric: distance = 2(sqrt(1+x*x/2) - 1)) */ |
||||
#define CV_DIST_FAIR 5 /* distance = c^2(|x|/c-log(1+|x|/c)), c = 1.3998 */ |
||||
#define CV_DIST_WELSCH 6 /* distance = c^2/2(1-exp(-(x/c)^2)), c = 2.9846 */ |
||||
#define CV_DIST_HUBER 7 /* distance = |x|<c ? x^2/2 : c(|x|-c/2), c=1.345 */ |
||||
#define CV_HAAR_MAGIC_VAL 0x42500000 |
||||
#define CV_HAAR_FEATURE_MAX 3 |
||||
#define CV_TERMCRIT_ITER 1 |
||||
#define CV_TERMCRIT_NUMBER CV_TERMCRIT_ITER |
||||
#define CV_TERMCRIT_EPS 2 |
||||
#define CV_EVENT_MOUSEMOVE 0 |
||||
#define CV_EVENT_LBUTTONDOWN 1 |
||||
#define CV_EVENT_RBUTTONDOWN 2 |
||||
#define CV_EVENT_MBUTTONDOWN 3 |
||||
#define CV_EVENT_LBUTTONUP 4 |
||||
#define CV_EVENT_RBUTTONUP 5 |
||||
#define CV_EVENT_MBUTTONUP 6 |
||||
#define CV_EVENT_LBUTTONDBLCLK 7 |
||||
#define CV_EVENT_RBUTTONDBLCLK 8 |
||||
#define CV_EVENT_MBUTTONDBLCLK 9 |
||||
#define CV_EVENT_FLAG_LBUTTON 1 |
||||
#define CV_EVENT_FLAG_RBUTTON 2 |
||||
#define CV_EVENT_FLAG_MBUTTON 4 |
||||
#define CV_EVENT_FLAG_CTRLKEY 8 |
||||
#define CV_EVENT_FLAG_SHIFTKEY 16 |
||||
#define CV_EVENT_FLAG_ALTKEY 32 |
||||
#define CV_MAX_DIM 32 |
||||
#define CV_CAP_PROP_POS_MSEC 0 |
||||
#define CV_CAP_PROP_POS_FRAMES 1 |
||||
#define CV_CAP_PROP_POS_AVI_RATIO 2 |
||||
#define CV_CAP_PROP_FRAME_WIDTH 3 |
||||
#define CV_CAP_PROP_FRAME_HEIGHT 4 |
||||
#define CV_CAP_PROP_FPS 5 |
||||
#define CV_CAP_PROP_FOURCC 6 |
||||
#define CV_CAP_PROP_FRAME_COUNT 7 |
||||
#define CV_CAP_PROP_FORMAT 8 |
||||
#define CV_CAP_PROP_MODE 9 |
||||
#define CV_CAP_PROP_BRIGHTNESS 10 |
||||
#define CV_CAP_PROP_CONTRAST 11 |
||||
#define CV_CAP_PROP_SATURATION 12 |
||||
#define CV_CAP_PROP_HUE 13 |
||||
#define CV_CAP_PROP_GAIN 14 |
||||
#define CV_CAP_PROP_EXPOSURE 15 |
||||
#define CV_CAP_PROP_CONVERT_RGB 16 |
||||
#define CV_CAP_PROP_RECTIFICATION 18 |
||||
#define CV_CAP_OPENNI 900 |
||||
#define CV_CAP_OPENNI_DEPTH_GENERATOR 2147483648 |
||||
#define CV_CAP_OPENNI_IMAGE_GENERATOR 1073741824 |
||||
#define CV_CAP_OPENNI_DEPTH_MAP 0 |
||||
#define CV_CAP_OPENNI_POINT_CLOUD_MAP 1 |
||||
#define CV_CAP_OPENNI_DISPARITY_MAP 2 |
||||
#define CV_CAP_OPENNI_DISPARITY_MAP_32F 3 |
||||
#define CV_CAP_OPENNI_VALID_DEPTH_MASK 4 |
||||
#define CV_CAP_OPENNI_BGR_IMAGE 5 |
||||
#define CV_CAP_OPENNI_GRAY_IMAGE 6 |
||||
#define CV_CAP_PROP_OPENNI_OUTPUT_MODE 100 |
||||
#define CV_CAP_OPENNI_VGA_30HZ 0 |
||||
#define CV_CAP_OPENNI_SXGA_15HZ 1 |
||||
#define CV_CAP_PROP_OPENNI_REGISTRATION 104 |
||||
#define CV_CAP_PROP_OPENNI_FRAME_MAX_DEPTH 101 |
||||
#define CV_CAP_PROP_OPENNI_BASELINE 102 |
||||
#define CV_CAP_PROP_OPENNI_FOCAL_LENGTH 103 |
||||
#define CV_CAP_OPENNI_IMAGE_GENERATOR_OUTPUT_MODE 1073741924 |
||||
#define CV_CAP_OPENNI_DEPTH_GENERATOR_BASELINE 2147483750 |
||||
#define CV_CAP_OPENNI_DEPTH_GENERATOR_FOCAL_LENGTH 2147483751 |
||||
#define CV_CAP_OPENNI_DEPTH_GENERATOR_REGISTRATION 2147483752 |
||||
#define CV_CN_SHIFT 3 |
||||
#define CV_IMWRITE_JPEG_QUALITY 1 |
||||
#define CV_IMWRITE_PNG_COMPRESSION 16 |
||||
#define CV_IMWRITE_PXM_BINARY 32 |
||||
#define IPL_ORIGIN_TL 0 |
||||
#define IPL_ORIGIN_BL 1 |
||||
#define CV_GAUSSIAN_5x5 |
||||
#define CV_CN_MAX |
||||
#define CV_WINDOW_AUTOSIZE 1 |
||||
#define CV_WINDOW_NORMAL 0 |
||||
#define CV_WINDOW_FULLSCREEN 1 |
||||
#define HG_AUTOSIZE CV_WINDOW_AUTOSIZE |
||||
#define CV_CVTIMG_FLIP 1 |
||||
#define CV_CVTIMG_SWAP_RB 2 |
||||
@ -1,631 +0,0 @@ |
||||
#!/usr/bin/env python |
||||
|
||||
import sys |
||||
from string import Template |
||||
|
||||
class argument: |
||||
def __init__(self, fields): |
||||
self.ty = fields[0] |
||||
self.nm = fields[1] |
||||
self.flags = "" |
||||
self.init = None |
||||
|
||||
if len(fields) > 2: |
||||
if fields[2][0] == '/': |
||||
self.flags = fields[2][1:].split(",") |
||||
else: |
||||
self.init = fields[2] |
||||
|
||||
api = [] |
||||
for l in open("%s/api" % sys.argv[1]): |
||||
if l[0] == '#': |
||||
continue |
||||
l = l.rstrip() |
||||
if (not l.startswith(' ')) and ('/' in l): |
||||
(l, flags) = l.split('/') |
||||
else: |
||||
flags = "" |
||||
f = l.split() |
||||
if len(f) != 0: |
||||
if l[0] != ' ': |
||||
if len(f) > 1: |
||||
ty = f[1] |
||||
else: |
||||
ty = None |
||||
api.append((f[0], [], ty, flags)) |
||||
else: |
||||
api[-1][1].append(argument(f)) |
||||
|
||||
# Validation: check that any optional arguments are last |
||||
had_error = False |
||||
for (f, args, ty, flags) in api: |
||||
has_init = [(a.init != None) for a in args if not 'O' in a.flags] |
||||
if True in has_init and not all(has_init[has_init.index(True):]): |
||||
print 'Error in definition for "%s", optional arguments must be last' % f |
||||
had_error = True |
||||
|
||||
if had_error: |
||||
sys.exit(1) |
||||
|
||||
def cname(n): |
||||
if n.startswith("CV"): |
||||
return '_' + n |
||||
elif n[0].isdigit(): |
||||
return '_' + n |
||||
else: |
||||
return n |
||||
|
||||
# RHS is how the aggregate gets expanded in the C call |
||||
aggregate = { |
||||
'pts_npts_contours' : '!.pts,!.npts,!.contours', |
||||
'cvarr_count' : '!.cvarr,!.count', |
||||
'cvarr_plane_count' : '!.cvarr,!.count', |
||||
'floats' : '!.f', |
||||
'ints' : '!.i', |
||||
'ints0' : '!.i', |
||||
'CvPoints' : '!.p,!.count', |
||||
'CvPoint2D32fs' : '!.p,!.count', |
||||
'CvPoint3D32fs' : '!.p,!.count', |
||||
'cvarrseq' : '!.seq', |
||||
'CvArrs' : '!.ims', |
||||
'IplImages' : '!.ims', |
||||
'intpair' : '!.pairs,!.count', |
||||
'cvpoint2d32f_count' : '!.points,&!.count' |
||||
} |
||||
conversion_types = [ |
||||
'char', |
||||
'CvArr', |
||||
'CvArrSeq', |
||||
'CvBox2D', # '((ff)(ff)f)', |
||||
'CvBox2D*', |
||||
'CvCapture*', |
||||
'CvStereoBMState*', |
||||
'CvStereoGCState*', |
||||
'CvKalman*', |
||||
'CvVideoWriter*', |
||||
'CvContourTree*', |
||||
'CvFont', |
||||
'CvFont*', |
||||
'CvHaarClassifierCascade*', |
||||
'CvHistogram', |
||||
'CvMat', |
||||
'CvMatND', |
||||
'CvMemStorage', |
||||
'CvMoments', |
||||
'CvMoments*', |
||||
'CvNextEdgeType', |
||||
'CvPoint', |
||||
'CvPoint*', |
||||
'CvPoint2D32f', # '(ff)', |
||||
'CvPoint2D32f*', |
||||
'CvPoint3D32f*', |
||||
'CvPoint2D64f', |
||||
'CvPOSITObject*', |
||||
'CvRect', |
||||
'CvRect*', |
||||
'CvRNG*', |
||||
'CvScalar', |
||||
'CvSeq', |
||||
'CvSeqOfCvConvexityDefect', |
||||
'CvSize', |
||||
'CvSlice', |
||||
'CvStarDetectorParams', |
||||
'CvSubdiv2D*', |
||||
'CvSubdiv2DEdge', |
||||
'CvTermCriteria', |
||||
'generic', |
||||
'IplConvKernel*', |
||||
'IplImage', |
||||
'PyObject*', |
||||
'PyCallableObject*' |
||||
] |
||||
|
||||
def safename(s): |
||||
return s.replace('*', 'PTR').replace('[', '_').replace(']', '_') |
||||
|
||||
def has_optional(al): |
||||
""" return true if any argument is optional """ |
||||
return any([a.init for a in al]) |
||||
|
||||
def gen(name, args, ty, flags): |
||||
yield "" |
||||
if has_optional(args): |
||||
yield "static PyObject *pycv%s(PyObject *self, PyObject *args, PyObject *kw)" % cname(name) |
||||
else: |
||||
yield "static PyObject *pycv%s(PyObject *self, PyObject *args)" % cname(name) |
||||
if 'doconly' in flags: |
||||
yield ";" |
||||
else: |
||||
yield "{" |
||||
|
||||
destinations = [] |
||||
for a in args: |
||||
remap = { |
||||
'CvArr' : 'CvArr*', |
||||
'CvMat' : 'CvMat*', |
||||
'CvMatND' : 'CvMatND*', |
||||
'IplImage' : 'IplImage*', |
||||
'CvMemStorage' : 'CvMemStorage*', |
||||
'CvHistogram':'CvHistogram*', |
||||
'CvSeq':'CvSeq*', |
||||
'CvHaarClassifierCascade' : 'CvHaarClassifierCascade*' |
||||
} |
||||
ctype = remap.get(a.ty, a.ty) |
||||
if a.init: |
||||
init = " = %s" % a.init |
||||
else: |
||||
init = '' |
||||
yield " %s %s%s;" % (ctype, a.nm, init) |
||||
if 'O' in a.flags: |
||||
continue |
||||
if a.ty in (conversion_types + aggregate.keys()): |
||||
yield ' PyObject *pyobj_%s = NULL;' % (a.nm) |
||||
destinations.append('&pyobj_%s' % (a.nm)) |
||||
elif a.ty in [ 'CvPoint2D32f' ]: |
||||
destinations.append('&%s.x, &%s.y' % (a.nm, a.nm)) |
||||
elif a.ty in [ 'CvTermCriteria' ]: |
||||
destinations.append('&%s.type, &%s.max_iter, &%s.epsilon' % ((a.nm,)*3)) |
||||
elif a.ty in [ 'CvSURFParams' ]: |
||||
destinations.append('&%s.extended, &%s.hessianThreshold, &%s.nOctaves, &%s.nOctaveLayers' % ((a.nm,)*4)) |
||||
elif a.nm in [ 'CvBox2D' ]: |
||||
s = ", ".join([('&' + a.nm +'.' + fld) for fld in [ 'center.x', 'center.y', 'size.width', 'size.height', 'angle' ] ]) |
||||
destinations.append(s) |
||||
else: |
||||
destinations.append('&%s' % a.nm) |
||||
fmap = { |
||||
'CvSURFParams' : '(idii)', |
||||
'double' : 'd', |
||||
'float' : 'f', |
||||
'int' : 'i', |
||||
'int64' : 'L', |
||||
'char*' : 's', |
||||
} |
||||
for k in (conversion_types + aggregate.keys()): |
||||
fmap[k] = 'O' |
||||
in_args = [ a for a in args if not 'O' in a.flags ] |
||||
fmt0 = "".join([ fmap[a.ty] for a in in_args if not a.init]) |
||||
fmt1 = "".join([ fmap[a.ty] for a in in_args if a.init]) |
||||
|
||||
yield '' |
||||
if len(fmt0 + fmt1) > 0: |
||||
if len(fmt1) > 0: |
||||
yield ' const char *keywords[] = { %s };' % (", ".join([ '"%s"' % arg.nm for arg in args if not 'O' in arg.flags ] + ['NULL'])) |
||||
yield ' if (!PyArg_ParseTupleAndKeywords(args, kw, "%s|%s", %s))' % (fmt0, fmt1, ", ".join(['(char**)keywords'] + destinations)) |
||||
if '(' in (fmt0 + fmt1): |
||||
print "Tuple with kwargs is not allowed, function", name |
||||
sys.exit(1) |
||||
else: |
||||
yield ' if (!PyArg_ParseTuple(args, "%s", %s))' % (fmt0, ", ".join(destinations)) |
||||
yield ' return NULL;' |
||||
|
||||
# Do the conversions: |
||||
for a in args: |
||||
joinwith = [f[2:] for f in a.flags if f.startswith("J:")] |
||||
if len(joinwith) > 0: |
||||
yield 'preShareData(%s, &%s);' % (joinwith[0], a.nm) |
||||
if 'O' in a.flags: |
||||
continue |
||||
if a.ty in (conversion_types + aggregate.keys()): |
||||
if a.init: |
||||
pred = '(pyobj_%s != NULL) && ' % a.nm |
||||
else: |
||||
pred = '' |
||||
yield ' if (%s!convert_to_%s(pyobj_%s, &%s, "%s")) return NULL;' % (pred, safename(a.ty), a.nm, a.nm, a.nm) |
||||
|
||||
yield '#ifdef CVPY_VALIDATE_%s' % name |
||||
yield 'CVPY_VALIDATE_%s();' % name |
||||
yield '#endif' |
||||
|
||||
def invokename(a): |
||||
if 'K' in a.flags: |
||||
prefix = "(const CvArr **)" |
||||
elif 'O' in a.flags and not 'A' in a.flags: |
||||
prefix = "&" |
||||
else: |
||||
prefix = "" |
||||
if a.ty in aggregate: |
||||
return prefix + aggregate[a.ty].replace('!', a.nm) |
||||
else: |
||||
return prefix + a.nm |
||||
|
||||
def funcname(s): |
||||
# The name by which the function is called, in C |
||||
if s.startswith("CV"): |
||||
return s |
||||
else: |
||||
return "cv" + s |
||||
tocall = '%s(%s)' % (funcname(name), ", ".join(invokename(a) for a in args)) |
||||
if 'stub' in flags: |
||||
yield ' return stub%s(%s);' % (name, ", ".join(invokename(a) for a in args)) |
||||
elif ty == None: |
||||
yield ' ERRWRAP(%s);' % tocall |
||||
yield ' Py_RETURN_NONE;' |
||||
else: |
||||
Rtypes = [ |
||||
'int', |
||||
'int64', |
||||
'double', |
||||
'CvCapture*', |
||||
'CvVideoWriter*', |
||||
'CvPOSITObject*', |
||||
'CvScalar', |
||||
'CvSize', |
||||
'CvRect', |
||||
'CvSeq*', |
||||
'CvBox2D', |
||||
'CvSeqOfCvAvgComp*', |
||||
'CvSeqOfCvConvexityDefect*', |
||||
'CvSeqOfCvStarKeypoint*', |
||||
'CvSeqOfCvSURFPoint*', |
||||
'CvSeqOfCvSURFDescriptor*', |
||||
'CvContourTree*', |
||||
'IplConvKernel*', |
||||
'IplImage*', |
||||
'CvMat*', |
||||
'constCvMat*', |
||||
'ROCvMat*', |
||||
'CvMatND*', |
||||
'CvPoint2D32f_4', |
||||
'CvRNG', |
||||
'CvSubdiv2D*', |
||||
'CvSubdiv2DPoint*', |
||||
'CvSubdiv2DEdge', |
||||
'ROIplImage*', |
||||
'CvStereoBMState*', |
||||
'CvStereoGCState*', |
||||
'CvKalman*', |
||||
'float', |
||||
'generic', |
||||
'unsigned' ] |
||||
|
||||
if ty in Rtypes: |
||||
yield ' %s r;' % (ty) |
||||
yield ' ERRWRAP(r = %s);' % (tocall) |
||||
yield ' return FROM_%s(r);' % safename(ty) |
||||
else: |
||||
all_returns = ty.split(",") |
||||
return_value_from_call = len(set(Rtypes) & set(all_returns)) != 0 |
||||
if return_value_from_call: |
||||
yield ' %s r;' % list(set(Rtypes) & set(all_returns))[0] |
||||
yield ' ERRWRAP(r = %s);' % (tocall) |
||||
else: |
||||
yield ' ERRWRAP(%s);' % (tocall) |
||||
typed = dict([ (a.nm,a.ty) for a in args]) |
||||
for i in range(len(all_returns)): |
||||
if all_returns[i] in Rtypes: |
||||
typed['r'] = all_returns[i] |
||||
all_returns[i] = "r" |
||||
if len(all_returns) == 1: |
||||
af = dict([ (a.nm,a.flags) for a in args]) |
||||
joinwith = [f[2:] for f in af.get(all_returns[0], []) if f.startswith("J:")] |
||||
if len(joinwith) > 0: |
||||
yield ' return shareData(pyobj_%s, %s, %s);' % (joinwith[0], joinwith[0], all_returns[0]) |
||||
else: |
||||
yield ' return FROM_%s(%s);' % (safename(typed[all_returns[0]]), all_returns[0]) |
||||
else: |
||||
yield ' return Py_BuildValue("%s", %s);' % ("N" * len(all_returns), ", ".join(["FROM_%s(%s)" % (safename(typed[n]), n) for n in all_returns])) |
||||
|
||||
yield '}' |
||||
|
||||
gen_c = [ open("generated%d.i" % i, "w") for i in range(5) ] |
||||
|
||||
print "Generated %d functions" % len(api) |
||||
for nm,args,ty,flags in sorted(api): |
||||
|
||||
# Figure out docstring into ds_* |
||||
ds_args = [] |
||||
mandatory = [a.nm for a in args if not ('O' in a.flags) and not a.init] |
||||
optional = [a.nm for a in args if not ('O' in a.flags) and a.init] |
||||
ds_args = ", ".join(mandatory) |
||||
def o2s(o): |
||||
if o == []: |
||||
return "" |
||||
else: |
||||
return ' [, %s%s]' % (o[0], o2s(o[1:])) |
||||
ds_args += o2s(optional) |
||||
|
||||
ds = "%s(%s) -> %s" % (nm, ds_args, str(ty)) |
||||
#print ds |
||||
|
||||
if has_optional(args): |
||||
entry = '{"%%s", (PyCFunction)pycv%s, METH_KEYWORDS, "%s"},' % (cname(nm), ds) |
||||
else: |
||||
entry = '{"%%s", pycv%s, METH_VARARGS, "%s"},' % (cname(nm), ds) |
||||
print >>gen_c[1], entry % (nm) |
||||
if nm.startswith('CV_'): |
||||
print >>gen_c[1], entry % (nm[3:]) |
||||
for l in gen(nm,args,ty,flags): |
||||
print >>gen_c[0], l |
||||
|
||||
for l in open("%s/defs" % sys.argv[1]): |
||||
print >>gen_c[2], "PUBLISH(%s);" % l.split()[1] |
||||
|
||||
######################################################################## |
||||
# Generated objects. |
||||
######################################################################## |
||||
|
||||
# gen_c[3] is the code, gen_c[4] initializers |
||||
|
||||
gensimple = Template(""" |
||||
/* |
||||
${cvtype} is the OpenCV C struct |
||||
${ourname}_t is the Python object |
||||
*/ |
||||
|
||||
struct ${ourname}_t { |
||||
PyObject_HEAD |
||||
${cvtype} v; |
||||
}; |
||||
|
||||
static PyObject *${ourname}_repr(PyObject *self) |
||||
{ |
||||
${ourname}_t *p = (${ourname}_t*)self; |
||||
char str[1000]; |
||||
sprintf(str, "<${ourname} %p>", p); |
||||
return PyString_FromString(str); |
||||
} |
||||
|
||||
${getset_funcs} |
||||
|
||||
static PyGetSetDef ${ourname}_getseters[] = { |
||||
|
||||
${getset_inits} |
||||
{NULL} /* Sentinel */ |
||||
}; |
||||
|
||||
static PyTypeObject ${ourname}_Type = { |
||||
PyObject_HEAD_INIT(&PyType_Type) |
||||
0, /*size*/ |
||||
MODULESTR".${ourname}", /*name*/ |
||||
sizeof(${ourname}_t), /*basicsize*/ |
||||
}; |
||||
|
||||
static void ${ourname}_specials(void) |
||||
{ |
||||
${ourname}_Type.tp_repr = ${ourname}_repr; |
||||
${ourname}_Type.tp_getset = ${ourname}_getseters; |
||||
} |
||||
|
||||
static PyObject *FROM_${cvtype}(${cvtype} r) |
||||
{ |
||||
${ourname}_t *m = PyObject_NEW(${ourname}_t, &${ourname}_Type); |
||||
m->v = r; |
||||
return (PyObject*)m; |
||||
} |
||||
|
||||
static int convert_to_${cvtype}PTR(PyObject *o, ${cvtype}** dst, const char *name = "no_name") |
||||
{ |
||||
${allownull} |
||||
if (PyType_IsSubtype(o->ob_type, &${ourname}_Type)) { |
||||
*dst = &(((${ourname}_t*)o)->v); |
||||
return 1; |
||||
} else { |
||||
(*dst) = (${cvtype}*)NULL; |
||||
return failmsg("Expected ${cvtype} for argument '%s'", name); |
||||
} |
||||
} |
||||
|
||||
""") |
||||
|
||||
genptr = Template(""" |
||||
/* |
||||
${cvtype} is the OpenCV C struct |
||||
${ourname}_t is the Python object |
||||
*/ |
||||
|
||||
struct ${ourname}_t { |
||||
PyObject_HEAD |
||||
${cvtype} *v; |
||||
}; |
||||
|
||||
static void ${ourname}_dealloc(PyObject *self) |
||||
{ |
||||
${ourname}_t *p = (${ourname}_t*)self; |
||||
cvRelease${ourname}(&p->v); |
||||
PyObject_Del(self); |
||||
} |
||||
|
||||
static PyObject *${ourname}_repr(PyObject *self) |
||||
{ |
||||
${ourname}_t *p = (${ourname}_t*)self; |
||||
char str[1000]; |
||||
sprintf(str, "<${ourname} %p>", p); |
||||
return PyString_FromString(str); |
||||
} |
||||
|
||||
${getset_funcs} |
||||
|
||||
static PyGetSetDef ${ourname}_getseters[] = { |
||||
|
||||
${getset_inits} |
||||
{NULL} /* Sentinel */ |
||||
}; |
||||
|
||||
static PyTypeObject ${ourname}_Type = { |
||||
PyObject_HEAD_INIT(&PyType_Type) |
||||
0, /*size*/ |
||||
MODULESTR".${ourname}", /*name*/ |
||||
sizeof(${ourname}_t), /*basicsize*/ |
||||
}; |
||||
|
||||
static void ${ourname}_specials(void) |
||||
{ |
||||
${ourname}_Type.tp_dealloc = ${ourname}_dealloc; |
||||
${ourname}_Type.tp_repr = ${ourname}_repr; |
||||
${ourname}_Type.tp_getset = ${ourname}_getseters; |
||||
} |
||||
|
||||
static PyObject *FROM_${cvtype}PTR(${cvtype} *r) |
||||
{ |
||||
${ourname}_t *m = PyObject_NEW(${ourname}_t, &${ourname}_Type); |
||||
m->v = r; |
||||
return (PyObject*)m; |
||||
} |
||||
|
||||
static int convert_to_${cvtype}PTR(PyObject *o, ${cvtype}** dst, const char *name = "no_name") |
||||
{ |
||||
${allownull} |
||||
if (PyType_IsSubtype(o->ob_type, &${ourname}_Type)) { |
||||
*dst = ((${ourname}_t*)o)->v; |
||||
return 1; |
||||
} else { |
||||
(*dst) = (${cvtype}*)NULL; |
||||
return failmsg("Expected ${cvtype} for argument '%s'", name); |
||||
} |
||||
} |
||||
|
||||
""") |
||||
|
||||
getset_func_template = Template(""" |
||||
static PyObject *${ourname}_get_${member}(${ourname}_t *p, void *closure) |
||||
{ |
||||
return ${rconverter}(p->v${accessor}${member}); |
||||
} |
||||
|
||||
static int ${ourname}_set_${member}(${ourname}_t *p, PyObject *value, void *closure) |
||||
{ |
||||
if (value == NULL) { |
||||
PyErr_SetString(PyExc_TypeError, "Cannot delete the ${member} attribute"); |
||||
return -1; |
||||
} |
||||
|
||||
if (! ${checker}(value)) { |
||||
PyErr_SetString(PyExc_TypeError, "The ${member} attribute value must be a ${typename}"); |
||||
return -1; |
||||
} |
||||
|
||||
p->v${accessor}${member} = ${converter}(value); |
||||
return 0; |
||||
} |
||||
|
||||
""") |
||||
|
||||
getset_init_template = Template(""" |
||||
{(char*)"${member}", (getter)${ourname}_get_${member}, (setter)${ourname}_set_${member}, (char*)"${member}", NULL}, |
||||
""") |
||||
|
||||
objects = [ |
||||
( 'IplConvKernel', ['allownull'], { |
||||
"nCols" : 'i', |
||||
"nRows" : 'i', |
||||
"anchorX" : 'i', |
||||
"anchorY" : 'i', |
||||
}), |
||||
( 'CvCapture', [], {}), |
||||
( 'CvHaarClassifierCascade', [], {}), |
||||
( 'CvPOSITObject', [], {}), |
||||
( 'CvVideoWriter', [], {}), |
||||
( 'CvStereoBMState', [], { |
||||
"preFilterType" : 'i', |
||||
"preFilterSize" : 'i', |
||||
"preFilterCap" : 'i', |
||||
"SADWindowSize" : 'i', |
||||
"minDisparity" : 'i', |
||||
"numberOfDisparities" : 'i', |
||||
"textureThreshold" : 'i', |
||||
"uniquenessRatio" : 'i', |
||||
"speckleWindowSize" : 'i', |
||||
"speckleRange" : 'i', |
||||
}), |
||||
( 'CvStereoGCState', [], { |
||||
"Ithreshold" : 'i', |
||||
"interactionRadius" : 'i', |
||||
"K" : 'f', |
||||
"lambda" : 'f', |
||||
"lambda1" : 'f', |
||||
"lambda2" : 'f', |
||||
"occlusionCost" : 'i', |
||||
"minDisparity" : 'i', |
||||
"numberOfDisparities" : 'i', |
||||
"maxIters" : 'i', |
||||
}), |
||||
( 'CvKalman', [], { |
||||
"MP" : 'i', |
||||
"DP" : 'i', |
||||
"CP" : 'i', |
||||
"state_pre" : 'mr', |
||||
"state_post" : 'mr', |
||||
"transition_matrix" : 'mr', |
||||
"control_matrix" : 'mr', |
||||
"measurement_matrix" : 'mr', |
||||
"control_matrix" : 'mr', |
||||
"process_noise_cov" : 'mr', |
||||
"measurement_noise_cov" : 'mr', |
||||
"error_cov_pre" : 'mr', |
||||
"gain" : 'mr', |
||||
"error_cov_post" : 'mr', |
||||
}), |
||||
( 'CvMoments', ['copy'], { |
||||
"m00" : 'f', |
||||
"m10" : 'f', |
||||
"m01" : 'f', |
||||
"m20" : 'f', |
||||
"m11" : 'f', |
||||
"m02" : 'f', |
||||
"m30" : 'f', |
||||
"m21" : 'f', |
||||
"m12" : 'f', |
||||
"m03" : 'f', |
||||
"mu20" : 'f', |
||||
"mu11" : 'f', |
||||
"mu02" : 'f', |
||||
"mu30" : 'f', |
||||
"mu21" : 'f', |
||||
"mu12" : 'f', |
||||
"mu03" : 'f', |
||||
"inv_sqrt_m00" : 'f', |
||||
}), |
||||
] |
||||
|
||||
checkers = { |
||||
'i' : 'PyNumber_Check', |
||||
'f' : 'PyNumber_Check', |
||||
'm' : 'is_cvmat', |
||||
'mr' : 'is_cvmat' |
||||
} |
||||
# Python -> C |
||||
converters = { |
||||
'i' : 'PyInt_AsLong', |
||||
'f' : 'PyFloat_AsDouble', |
||||
'm' : 'PyCvMat_AsCvMat', |
||||
'mr' : 'PyCvMat_AsCvMat' |
||||
} |
||||
# C -> Python |
||||
rconverters = { |
||||
'i' : 'PyInt_FromLong', |
||||
'f' : 'PyFloat_FromDouble', |
||||
'm' : 'FROM_CvMat', |
||||
'mr' : 'FROM_ROCvMatPTR' |
||||
} |
||||
# Human-readable type names |
||||
typenames = { |
||||
'i' : 'integer', |
||||
'f' : 'float', |
||||
'm' : 'list of CvMat', |
||||
'mr' : 'list of CvMat', |
||||
} |
||||
|
||||
for (t, flags, members) in objects: |
||||
map = {'cvtype' : t, |
||||
'ourname' : t.replace('Cv', '')} |
||||
# gsf is all the generated code for the member accessors |
||||
if 'copy' in flags: |
||||
a = '.' |
||||
else: |
||||
a = '->' |
||||
gsf = "".join([getset_func_template.substitute(map, accessor = a, member = m, checker = checkers[t], converter = converters[t], rconverter = rconverters[t], typename = typenames[t]) for (m, t) in members.items()]) |
||||
# gsi is the generated code for the initializer for each accessor |
||||
gsi = "".join([getset_init_template.substitute(map, member = m) for (m, t) in members.items()]) |
||||
# s is the template that pulls everything together |
||||
if 'allownull' in flags: |
||||
nullcode = """if (o == Py_None) { *dst = (%s*)NULL; return 1; }""" % map['cvtype'] |
||||
else: |
||||
nullcode = "" |
||||
if 'copy' in flags: |
||||
print >>gen_c[3], gensimple.substitute(map, getset_funcs = gsf, getset_inits = gsi, allownull = nullcode) |
||||
else: |
||||
print >>gen_c[3], genptr.substitute(map, getset_funcs = gsf, getset_inits = gsi, allownull = nullcode) |
||||
print >>gen_c[4], "MKTYPE(%s);" % map['ourname'] |
||||
|
||||
for f in gen_c: |
||||
f.close() |
||||
File diff suppressed because it is too large
Load Diff
@ -1,133 +0,0 @@ |
||||
#!/usr/bin/env python |
||||
|
||||
import unittest |
||||
import random |
||||
import time |
||||
import math |
||||
import sys |
||||
import array |
||||
import urllib |
||||
import tarfile |
||||
import hashlib |
||||
import os |
||||
import getopt |
||||
import operator |
||||
import functools |
||||
import numpy as np |
||||
import cv2 |
||||
import cv2.cv as cv |
||||
|
||||
class NewOpenCVTests(unittest.TestCase): |
||||
|
||||
def get_sample(self, filename, iscolor = cv.CV_LOAD_IMAGE_COLOR): |
||||
if not filename in self.image_cache: |
||||
filedata = urllib.urlopen("https://raw.github.com/Itseez/opencv/master/" + filename).read() |
||||
self.image_cache[filename] = cv2.imdecode(np.fromstring(filedata, dtype=np.uint8), iscolor) |
||||
return self.image_cache[filename] |
||||
|
||||
def setUp(self): |
||||
self.image_cache = {} |
||||
|
||||
def hashimg(self, im): |
||||
""" Compute a hash for an image, useful for image comparisons """ |
||||
return hashlib.md5(im.tostring()).digest() |
||||
|
||||
if sys.version_info[:2] == (2, 6): |
||||
def assertLess(self, a, b, msg=None): |
||||
if not a < b: |
||||
self.fail('%s not less than %s' % (repr(a), repr(b))) |
||||
|
||||
def assertLessEqual(self, a, b, msg=None): |
||||
if not a <= b: |
||||
self.fail('%s not less than or equal to %s' % (repr(a), repr(b))) |
||||
|
||||
def assertGreater(self, a, b, msg=None): |
||||
if not a > b: |
||||
self.fail('%s not greater than %s' % (repr(a), repr(b))) |
||||
|
||||
# Tests to run first; check the handful of basic operations that the later tests rely on |
||||
|
||||
class Hackathon244Tests(NewOpenCVTests): |
||||
|
||||
def test_int_array(self): |
||||
a = np.array([-1, 2, -3, 4, -5]) |
||||
absa0 = np.abs(a) |
||||
self.assert_(cv2.norm(a, cv2.NORM_L1) == 15) |
||||
absa1 = cv2.absdiff(a, 0) |
||||
self.assertEqual(cv2.norm(absa1, absa0, cv2.NORM_INF), 0) |
||||
|
||||
def test_imencode(self): |
||||
a = np.zeros((480, 640), dtype=np.uint8) |
||||
flag, ajpg = cv2.imencode("img_q90.jpg", a, [cv2.IMWRITE_JPEG_QUALITY, 90]) |
||||
self.assertEqual(flag, True) |
||||
self.assertEqual(ajpg.dtype, np.uint8) |
||||
self.assertGreater(ajpg.shape[0], 1) |
||||
self.assertEqual(ajpg.shape[1], 1) |
||||
|
||||
def test_projectPoints(self): |
||||
objpt = np.float64([[1,2,3]]) |
||||
imgpt0, jac0 = cv2.projectPoints(objpt, np.zeros(3), np.zeros(3), np.eye(3), np.float64([])) |
||||
imgpt1, jac1 = cv2.projectPoints(objpt, np.zeros(3), np.zeros(3), np.eye(3), None) |
||||
self.assertEqual(imgpt0.shape, (objpt.shape[0], 1, 2)) |
||||
self.assertEqual(imgpt1.shape, imgpt0.shape) |
||||
self.assertEqual(jac0.shape, jac1.shape) |
||||
self.assertEqual(jac0.shape[0], 2*objpt.shape[0]) |
||||
|
||||
def test_estimateAffine3D(self): |
||||
pattern_size = (11, 8) |
||||
pattern_points = np.zeros((np.prod(pattern_size), 3), np.float32) |
||||
pattern_points[:,:2] = np.indices(pattern_size).T.reshape(-1, 2) |
||||
pattern_points *= 10 |
||||
(retval, out, inliers) = cv2.estimateAffine3D(pattern_points, pattern_points) |
||||
self.assertEqual(retval, 1) |
||||
if cv2.norm(out[2,:]) < 1e-3: |
||||
out[2,2]=1 |
||||
self.assertLess(cv2.norm(out, np.float64([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]])), 1e-3) |
||||
self.assertEqual(cv2.countNonZero(inliers), pattern_size[0]*pattern_size[1]) |
||||
|
||||
def test_fast(self): |
||||
fd = cv2.FastFeatureDetector(30, True) |
||||
img = self.get_sample("samples/cpp/right02.jpg", 0) |
||||
img = cv2.medianBlur(img, 3) |
||||
imgc = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) |
||||
keypoints = fd.detect(img) |
||||
self.assert_(600 <= len(keypoints) <= 700) |
||||
for kpt in keypoints: |
||||
self.assertNotEqual(kpt.response, 0) |
||||
|
||||
def check_close_angles(self, a, b, angle_delta): |
||||
self.assert_(abs(a - b) <= angle_delta or |
||||
abs(360 - abs(a - b)) <= angle_delta) |
||||
|
||||
def check_close_pairs(self, a, b, delta): |
||||
self.assertLessEqual(abs(a[0] - b[0]), delta) |
||||
self.assertLessEqual(abs(a[1] - b[1]), delta) |
||||
|
||||
def check_close_boxes(self, a, b, delta, angle_delta): |
||||
self.check_close_pairs(a[0], b[0], delta) |
||||
self.check_close_pairs(a[1], b[1], delta) |
||||
self.check_close_angles(a[2], b[2], angle_delta) |
||||
|
||||
def test_geometry(self): |
||||
npt = 100 |
||||
np.random.seed(244) |
||||
a = np.random.randn(npt,2).astype('float32')*50 + 150 |
||||
|
||||
img = np.zeros((300, 300, 3), dtype='uint8') |
||||
be = cv2.fitEllipse(a) |
||||
br = cv2.minAreaRect(a) |
||||
mc, mr = cv2.minEnclosingCircle(a) |
||||
|
||||
be0 = ((150.2511749267578, 150.77322387695312), (158.024658203125, 197.57696533203125), 37.57804489135742) |
||||
br0 = ((161.2974090576172, 154.41793823242188), (199.2301483154297, 207.7177734375), -9.164555549621582) |
||||
mc0, mr0 = (160.41790771484375, 144.55152893066406), 136.713500977 |
||||
|
||||
self.check_close_boxes(be, be0, 5, 15) |
||||
self.check_close_boxes(br, br0, 5, 15) |
||||
self.check_close_pairs(mc, mc0, 5) |
||||
self.assertLessEqual(abs(mr - mr0), 5) |
||||
|
||||
if __name__ == '__main__': |
||||
print "testing", cv2.__version__ |
||||
random.seed(0) |
||||
unittest.main() |
||||
@ -1,15 +0,0 @@ |
||||
#!/usr/bin/python |
||||
|
||||
import cv2.cv as cv |
||||
import time |
||||
|
||||
cv.NamedWindow("camera", 1) |
||||
|
||||
capture = cv.CaptureFromCAM(0) |
||||
|
||||
while True: |
||||
img = cv.QueryFrame(capture) |
||||
cv.ShowImage("camera", img) |
||||
if cv.WaitKey(10) == 27: |
||||
break |
||||
cv.DestroyAllWindows() |
||||
@ -1,116 +0,0 @@ |
||||
#!/usr/bin/env python |
||||
|
||||
import cv2.cv as cv |
||||
|
||||
def is_rect_nonzero(r): |
||||
(_,_,w,h) = r |
||||
return (w > 0) and (h > 0) |
||||
|
||||
class CamShiftDemo: |
||||
|
||||
def __init__(self): |
||||
self.capture = cv.CaptureFromCAM(0) |
||||
cv.NamedWindow( "CamShiftDemo", 1 ) |
||||
cv.NamedWindow( "Histogram", 1 ) |
||||
cv.SetMouseCallback( "CamShiftDemo", self.on_mouse) |
||||
|
||||
self.drag_start = None # Set to (x,y) when mouse starts drag |
||||
self.track_window = None # Set to rect when the mouse drag finishes |
||||
|
||||
print( "Keys:\n" |
||||
" ESC - quit the program\n" |
||||
" b - switch to/from backprojection view\n" |
||||
"To initialize tracking, drag across the object with the mouse\n" ) |
||||
|
||||
def hue_histogram_as_image(self, hist): |
||||
""" Returns a nice representation of a hue histogram """ |
||||
|
||||
histimg_hsv = cv.CreateImage( (320,200), 8, 3) |
||||
|
||||
mybins = cv.CloneMatND(hist.bins) |
||||
cv.Log(mybins, mybins) |
||||
(_, hi, _, _) = cv.MinMaxLoc(mybins) |
||||
cv.ConvertScale(mybins, mybins, 255. / hi) |
||||
|
||||
w,h = cv.GetSize(histimg_hsv) |
||||
hdims = cv.GetDims(mybins)[0] |
||||
for x in range(w): |
||||
xh = (180 * x) / (w - 1) # hue sweeps from 0-180 across the image |
||||
val = int(mybins[int(hdims * x / w)] * h / 255) |
||||
cv.Rectangle( histimg_hsv, (x, 0), (x, h-val), (xh,255,64), -1) |
||||
cv.Rectangle( histimg_hsv, (x, h-val), (x, h), (xh,255,255), -1) |
||||
|
||||
histimg = cv.CreateImage( (320,200), 8, 3) |
||||
cv.CvtColor(histimg_hsv, histimg, cv.CV_HSV2BGR) |
||||
return histimg |
||||
|
||||
def on_mouse(self, event, x, y, flags, param): |
||||
if event == cv.CV_EVENT_LBUTTONDOWN: |
||||
self.drag_start = (x, y) |
||||
if event == cv.CV_EVENT_LBUTTONUP: |
||||
self.drag_start = None |
||||
self.track_window = self.selection |
||||
if self.drag_start: |
||||
xmin = min(x, self.drag_start[0]) |
||||
ymin = min(y, self.drag_start[1]) |
||||
xmax = max(x, self.drag_start[0]) |
||||
ymax = max(y, self.drag_start[1]) |
||||
self.selection = (xmin, ymin, xmax - xmin, ymax - ymin) |
||||
|
||||
def run(self): |
||||
hist = cv.CreateHist([180], cv.CV_HIST_ARRAY, [(0,180)], 1 ) |
||||
backproject_mode = False |
||||
while True: |
||||
frame = cv.QueryFrame( self.capture ) |
||||
|
||||
# Convert to HSV and keep the hue |
||||
hsv = cv.CreateImage(cv.GetSize(frame), 8, 3) |
||||
cv.CvtColor(frame, hsv, cv.CV_BGR2HSV) |
||||
self.hue = cv.CreateImage(cv.GetSize(frame), 8, 1) |
||||
cv.Split(hsv, self.hue, None, None, None) |
||||
|
||||
# Compute back projection |
||||
backproject = cv.CreateImage(cv.GetSize(frame), 8, 1) |
||||
|
||||
# Run the cam-shift |
||||
cv.CalcArrBackProject( [self.hue], backproject, hist ) |
||||
if self.track_window and is_rect_nonzero(self.track_window): |
||||
crit = ( cv.CV_TERMCRIT_EPS | cv.CV_TERMCRIT_ITER, 10, 1) |
||||
(iters, (area, value, rect), track_box) = cv.CamShift(backproject, self.track_window, crit) |
||||
self.track_window = rect |
||||
|
||||
# If mouse is pressed, highlight the current selected rectangle |
||||
# and recompute the histogram |
||||
|
||||
if self.drag_start and is_rect_nonzero(self.selection): |
||||
sub = cv.GetSubRect(frame, self.selection) |
||||
save = cv.CloneMat(sub) |
||||
cv.ConvertScale(frame, frame, 0.5) |
||||
cv.Copy(save, sub) |
||||
x,y,w,h = self.selection |
||||
cv.Rectangle(frame, (x,y), (x+w,y+h), (255,255,255)) |
||||
|
||||
sel = cv.GetSubRect(self.hue, self.selection ) |
||||
cv.CalcArrHist( [sel], hist, 0) |
||||
(_, max_val, _, _) = cv.GetMinMaxHistValue( hist) |
||||
if max_val != 0: |
||||
cv.ConvertScale(hist.bins, hist.bins, 255. / max_val) |
||||
elif self.track_window and is_rect_nonzero(self.track_window): |
||||
cv.EllipseBox( frame, track_box, cv.CV_RGB(255,0,0), 3, cv.CV_AA, 0 ) |
||||
|
||||
if not backproject_mode: |
||||
cv.ShowImage( "CamShiftDemo", frame ) |
||||
else: |
||||
cv.ShowImage( "CamShiftDemo", backproject) |
||||
cv.ShowImage( "Histogram", self.hue_histogram_as_image(hist)) |
||||
|
||||
c = cv.WaitKey(7) % 0x100 |
||||
if c == 27: |
||||
break |
||||
elif c == ord("b"): |
||||
backproject_mode = not backproject_mode |
||||
|
||||
if __name__=="__main__": |
||||
demo = CamShiftDemo() |
||||
demo.run() |
||||
cv.DestroyAllWindows() |
||||
@ -1,34 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import cv2.cv as cv |
||||
import sys |
||||
import urllib2 |
||||
|
||||
if __name__ == "__main__": |
||||
cv.NamedWindow("win") |
||||
if len(sys.argv) > 1: |
||||
filename = sys.argv[1] |
||||
im = cv.LoadImage(filename, cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
im3 = cv.LoadImage(filename, cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
try: # try opening local copy of image |
||||
fileName = '../cpp/left01.jpg' |
||||
im = cv.LoadImageM(fileName, False) |
||||
im3 = cv.LoadImageM(fileName, True) |
||||
except: # if local copy cannot be opened, try downloading it |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/cpp/left01.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
im = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
im3 = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
chessboard_dim = ( 9, 6 ) |
||||
|
||||
found_all, corners = cv.FindChessboardCorners( im, chessboard_dim ) |
||||
print found_all, len(corners) |
||||
|
||||
cv.DrawChessboardCorners( im3, chessboard_dim, corners, found_all ) |
||||
|
||||
cv.ShowImage("win", im3); |
||||
cv.WaitKey() |
||||
cv.DestroyAllWindows() |
||||
@ -1,136 +0,0 @@ |
||||
#! /usr/bin/env python |
||||
|
||||
print "OpenCV Python version of contours" |
||||
|
||||
# import the necessary things for OpenCV |
||||
import cv2.cv as cv |
||||
|
||||
# some default constants |
||||
_SIZE = 500 |
||||
_DEFAULT_LEVEL = 3 |
||||
|
||||
# definition of some colors |
||||
_red = (0, 0, 255, 0); |
||||
_green = (0, 255, 0, 0); |
||||
_white = cv.RealScalar (255) |
||||
_black = cv.RealScalar (0) |
||||
|
||||
# the callback on the trackbar, to set the level of contours we want |
||||
# to display |
||||
def on_trackbar (position): |
||||
|
||||
# create the image for putting in it the founded contours |
||||
contours_image = cv.CreateImage ( (_SIZE, _SIZE), 8, 3) |
||||
|
||||
# compute the real level of display, given the current position |
||||
levels = position - 3 |
||||
|
||||
# initialisation |
||||
_contours = contours |
||||
|
||||
if levels <= 0: |
||||
# zero or negative value |
||||
# => get to the nearest face to make it look more funny |
||||
_contours = contours.h_next().h_next().h_next() |
||||
|
||||
# first, clear the image where we will draw contours |
||||
cv.SetZero (contours_image) |
||||
|
||||
# draw contours in red and green |
||||
cv.DrawContours (contours_image, _contours, |
||||
_red, _green, |
||||
levels, 3, cv.CV_AA, |
||||
(0, 0)) |
||||
|
||||
# finally, show the image |
||||
cv.ShowImage ("contours", contours_image) |
||||
|
||||
if __name__ == '__main__': |
||||
|
||||
# create the image where we want to display results |
||||
image = cv.CreateImage ( (_SIZE, _SIZE), 8, 1) |
||||
|
||||
# start with an empty image |
||||
cv.SetZero (image) |
||||
|
||||
# draw the original picture |
||||
for i in range (6): |
||||
dx = (i % 2) * 250 - 30 |
||||
dy = (i / 2) * 150 |
||||
|
||||
cv.Ellipse (image, |
||||
(dx + 150, dy + 100), |
||||
(100, 70), |
||||
0, 0, 360, _white, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 115, dy + 70), |
||||
(30, 20), |
||||
0, 0, 360, _black, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 185, dy + 70), |
||||
(30, 20), |
||||
0, 0, 360, _black, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 115, dy + 70), |
||||
(15, 15), |
||||
0, 0, 360, _white, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 185, dy + 70), |
||||
(15, 15), |
||||
0, 0, 360, _white, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 115, dy + 70), |
||||
(5, 5), |
||||
0, 0, 360, _black, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 185, dy + 70), |
||||
(5, 5), |
||||
0, 0, 360, _black, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 150, dy + 100), |
||||
(10, 5), |
||||
0, 0, 360, _black, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 150, dy + 150), |
||||
(40, 10), |
||||
0, 0, 360, _black, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 27, dy + 100), |
||||
(20, 35), |
||||
0, 0, 360, _white, -1, 8, 0) |
||||
cv.Ellipse (image, |
||||
(dx + 273, dy + 100), |
||||
(20, 35), |
||||
0, 0, 360, _white, -1, 8, 0) |
||||
|
||||
# create window and display the original picture in it |
||||
cv.NamedWindow ("image", 1) |
||||
cv.ShowImage ("image", image) |
||||
|
||||
# create the storage area |
||||
storage = cv.CreateMemStorage (0) |
||||
|
||||
# find the contours |
||||
contours = cv.FindContours(image, |
||||
storage, |
||||
cv.CV_RETR_TREE, |
||||
cv.CV_CHAIN_APPROX_SIMPLE, |
||||
(0,0)) |
||||
|
||||
# comment this out if you do not want approximation |
||||
contours = cv.ApproxPoly (contours, |
||||
storage, |
||||
cv.CV_POLY_APPROX_DP, 3, 1) |
||||
|
||||
# create the window for the contours |
||||
cv.NamedWindow ("contours", 1) |
||||
|
||||
# create the trackbar, to enable the change of the displayed level |
||||
cv.CreateTrackbar ("levels+3", "contours", 3, 7, on_trackbar) |
||||
|
||||
# call one time the callback, so we will have the 1st display done |
||||
on_trackbar (_DEFAULT_LEVEL) |
||||
|
||||
# wait a key pressed to end |
||||
cv.WaitKey (0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,65 +0,0 @@ |
||||
#! /usr/bin/env python |
||||
|
||||
print "OpenCV Python version of convexhull" |
||||
|
||||
# import the necessary things for OpenCV |
||||
import cv2.cv as cv |
||||
|
||||
# to generate random values |
||||
import random |
||||
|
||||
# how many points we want at max |
||||
_MAX_POINTS = 100 |
||||
|
||||
if __name__ == '__main__': |
||||
|
||||
# main object to get random values from |
||||
my_random = random.Random () |
||||
|
||||
# create the image where we want to display results |
||||
image = cv.CreateImage ( (500, 500), 8, 3) |
||||
|
||||
# create the window to put the image in |
||||
cv.NamedWindow ('hull', cv.CV_WINDOW_AUTOSIZE) |
||||
|
||||
while True: |
||||
# do forever |
||||
|
||||
# get a random number of points |
||||
count = my_random.randrange (0, _MAX_POINTS) + 1 |
||||
|
||||
# initialisations |
||||
points = [] |
||||
|
||||
for i in range (count): |
||||
# generate a random point |
||||
points.append ( ( |
||||
my_random.randrange (0, image.width / 2) + image.width / 4, |
||||
my_random.randrange (0, image.width / 2) + image.width / 4 |
||||
)) |
||||
|
||||
# compute the convex hull |
||||
storage = cv.CreateMemStorage(0) |
||||
hull = cv.ConvexHull2 (points, storage, cv.CV_CLOCKWISE, 1) |
||||
|
||||
# start with an empty image |
||||
cv.SetZero (image) |
||||
|
||||
# draw all the points as circles in red |
||||
for i in range (count): |
||||
cv.Circle (image, points [i], 2, |
||||
(0, 0, 255, 0), |
||||
cv.CV_FILLED, cv.CV_AA, 0) |
||||
|
||||
# Draw the convex hull as a closed polyline in green |
||||
cv.PolyLine(image, [hull], 1, cv.RGB(0,255,0), 1, cv.CV_AA) |
||||
|
||||
# display the final image |
||||
cv.ShowImage ('hull', image) |
||||
|
||||
# handle events, and wait a key pressed |
||||
k = cv.WaitKey (0) % 0x100 |
||||
if k == 27: |
||||
# user has press the ESC key, so exit |
||||
break |
||||
cv.DestroyAllWindows() |
||||
@ -1,169 +0,0 @@ |
||||
#!/usr/bin/python |
||||
|
||||
""" |
||||
Find Squares in image by finding countours and filtering |
||||
""" |
||||
#Results slightly different from C version on same images, but is |
||||
#otherwise ok |
||||
|
||||
import math |
||||
import cv2.cv as cv |
||||
|
||||
def angle(pt1, pt2, pt0): |
||||
"calculate angle contained by 3 points(x, y)" |
||||
dx1 = pt1[0] - pt0[0] |
||||
dy1 = pt1[1] - pt0[1] |
||||
dx2 = pt2[0] - pt0[0] |
||||
dy2 = pt2[1] - pt0[1] |
||||
|
||||
nom = dx1*dx2 + dy1*dy2 |
||||
denom = math.sqrt( (dx1*dx1 + dy1*dy1) * (dx2*dx2 + dy2*dy2) + 1e-10 ) |
||||
ang = nom / denom |
||||
return ang |
||||
|
||||
def is_square(contour): |
||||
""" |
||||
Squareness checker |
||||
|
||||
Square contours should: |
||||
-have 4 vertices after approximation, |
||||
-have relatively large area (to filter out noisy contours) |
||||
-be convex. |
||||
-have angles between sides close to 90deg (cos(ang) ~0 ) |
||||
Note: absolute value of an area is used because area may be |
||||
positive or negative - in accordance with the contour orientation |
||||
""" |
||||
|
||||
area = math.fabs( cv.ContourArea(contour) ) |
||||
isconvex = cv.CheckContourConvexity(contour) |
||||
s = 0 |
||||
if len(contour) == 4 and area > 1000 and isconvex: |
||||
for i in range(1, 4): |
||||
# find minimum angle between joint edges (maximum of cosine) |
||||
pt1 = contour[i] |
||||
pt2 = contour[i-1] |
||||
pt0 = contour[i-2] |
||||
|
||||
t = math.fabs(angle(pt0, pt1, pt2)) |
||||
if s <= t:s = t |
||||
|
||||
# if cosines of all angles are small (all angles are ~90 degree) |
||||
# then its a square |
||||
if s < 0.3:return True |
||||
|
||||
return False |
||||
|
||||
def find_squares_from_binary( gray ): |
||||
""" |
||||
use contour search to find squares in binary image |
||||
returns list of numpy arrays containing 4 points |
||||
""" |
||||
squares = [] |
||||
storage = cv.CreateMemStorage(0) |
||||
contours = cv.FindContours(gray, storage, cv.CV_RETR_TREE, cv.CV_CHAIN_APPROX_SIMPLE, (0,0)) |
||||
storage = cv.CreateMemStorage(0) |
||||
while contours: |
||||
#approximate contour with accuracy proportional to the contour perimeter |
||||
arclength = cv.ArcLength(contours) |
||||
polygon = cv.ApproxPoly( contours, storage, cv.CV_POLY_APPROX_DP, arclength * 0.02, 0) |
||||
if is_square(polygon): |
||||
squares.append(polygon[0:4]) |
||||
contours = contours.h_next() |
||||
|
||||
return squares |
||||
|
||||
def find_squares4(color_img): |
||||
""" |
||||
Finds multiple squares in image |
||||
|
||||
Steps: |
||||
-Use Canny edge to highlight contours, and dilation to connect |
||||
the edge segments. |
||||
-Threshold the result to binary edge tokens |
||||
-Use cv.FindContours: returns a cv.CvSequence of cv.CvContours |
||||
-Filter each candidate: use Approx poly, keep only contours with 4 vertices, |
||||
enough area, and ~90deg angles. |
||||
|
||||
Return all squares contours in one flat list of arrays, 4 x,y points each. |
||||
""" |
||||
#select even sizes only |
||||
width, height = (color_img.width & -2, color_img.height & -2 ) |
||||
timg = cv.CloneImage( color_img ) # make a copy of input image |
||||
gray = cv.CreateImage( (width,height), 8, 1 ) |
||||
|
||||
# select the maximum ROI in the image |
||||
cv.SetImageROI( timg, (0, 0, width, height) ) |
||||
|
||||
# down-scale and upscale the image to filter out the noise |
||||
pyr = cv.CreateImage( (width/2, height/2), 8, 3 ) |
||||
cv.PyrDown( timg, pyr, 7 ) |
||||
cv.PyrUp( pyr, timg, 7 ) |
||||
|
||||
tgray = cv.CreateImage( (width,height), 8, 1 ) |
||||
squares = [] |
||||
|
||||
# Find squares in every color plane of the image |
||||
# Two methods, we use both: |
||||
# 1. Canny to catch squares with gradient shading. Use upper threshold |
||||
# from slider, set the lower to 0 (which forces edges merging). Then |
||||
# dilate canny output to remove potential holes between edge segments. |
||||
# 2. Binary thresholding at multiple levels |
||||
N = 11 |
||||
for c in [0, 1, 2]: |
||||
#extract the c-th color plane |
||||
cv.SetImageCOI( timg, c+1 ); |
||||
cv.Copy( timg, tgray, None ); |
||||
cv.Canny( tgray, gray, 0, 50, 5 ) |
||||
cv.Dilate( gray, gray) |
||||
squares = squares + find_squares_from_binary( gray ) |
||||
|
||||
# Look for more squares at several threshold levels |
||||
for l in range(1, N): |
||||
cv.Threshold( tgray, gray, (l+1)*255/N, 255, cv.CV_THRESH_BINARY ) |
||||
squares = squares + find_squares_from_binary( gray ) |
||||
|
||||
return squares |
||||
|
||||
|
||||
RED = (0,0,255) |
||||
GREEN = (0,255,0) |
||||
def draw_squares( color_img, squares ): |
||||
""" |
||||
Squares is py list containing 4-pt numpy arrays. Step through the list |
||||
and draw a polygon for each 4-group |
||||
""" |
||||
color, othercolor = RED, GREEN |
||||
for square in squares: |
||||
cv.PolyLine(color_img, [square], True, color, 3, cv.CV_AA, 0) |
||||
color, othercolor = othercolor, color |
||||
|
||||
cv.ShowImage(WNDNAME, color_img) |
||||
|
||||
|
||||
WNDNAME = "Squares Demo" |
||||
def main(): |
||||
"""Open test color images, create display window, start the search""" |
||||
cv.NamedWindow(WNDNAME, 1) |
||||
for name in [ "../c/pic%d.png" % i for i in [1, 2, 3, 4, 5, 6] ]: |
||||
img0 = cv.LoadImage(name, 1) |
||||
try: |
||||
img0 |
||||
except ValueError: |
||||
print "Couldn't load %s\n" % name |
||||
continue |
||||
|
||||
# slider deleted from C version, same here and use fixed Canny param=50 |
||||
img = cv.CloneImage(img0) |
||||
|
||||
cv.ShowImage(WNDNAME, img) |
||||
|
||||
# force the image processing |
||||
draw_squares( img, find_squares4( img ) ) |
||||
|
||||
# wait for key. |
||||
if cv.WaitKey(-1) % 0x100 == 27: |
||||
break |
||||
|
||||
if __name__ == "__main__": |
||||
main() |
||||
cv.DestroyAllWindows() |
||||
@ -1,20 +0,0 @@ |
||||
#!/usr/bin/python |
||||
|
||||
import cv2.cv as cv |
||||
import urllib2 |
||||
from sys import argv |
||||
|
||||
def load_sample(name=None): |
||||
if len(argv) > 1: |
||||
img0 = cv.LoadImage(argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
elif name is not None: |
||||
try: |
||||
img0 = cv.LoadImage(name, cv.CV_LOAD_IMAGE_COLOR) |
||||
except IOError: |
||||
urlbase = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/' |
||||
file = name.split('/')[-1] |
||||
filedata = urllib2.urlopen(urlbase+file).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
img0 = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
return img0 |
||||
@ -1,139 +0,0 @@ |
||||
#!/usr/bin/python |
||||
""" |
||||
the script demostrates iterative construction of |
||||
delaunay triangulation and voronoi tesselation |
||||
|
||||
Original Author (C version): ? |
||||
Converted to Python by: Roman Stanchak |
||||
""" |
||||
import cv2.cv as cv |
||||
import random |
||||
|
||||
def draw_subdiv_point( img, fp, color ): |
||||
cv.Circle( img, (cv.Round(fp[0]), cv.Round(fp[1])), 3, color, cv.CV_FILLED, 8, 0 ); |
||||
|
||||
def draw_subdiv_edge( img, edge, color ): |
||||
org_pt = cv.Subdiv2DEdgeOrg(edge); |
||||
dst_pt = cv.Subdiv2DEdgeDst(edge); |
||||
|
||||
if org_pt and dst_pt : |
||||
|
||||
org = org_pt.pt; |
||||
dst = dst_pt.pt; |
||||
|
||||
iorg = ( cv.Round( org[0] ), cv.Round( org[1] )); |
||||
idst = ( cv.Round( dst[0] ), cv.Round( dst[1] )); |
||||
|
||||
cv.Line( img, iorg, idst, color, 1, cv.CV_AA, 0 ); |
||||
|
||||
|
||||
def draw_subdiv( img, subdiv, delaunay_color, voronoi_color ): |
||||
|
||||
for edge in subdiv.edges: |
||||
edge_rot = cv.Subdiv2DRotateEdge( edge, 1 ) |
||||
|
||||
draw_subdiv_edge( img, edge_rot, voronoi_color ); |
||||
draw_subdiv_edge( img, edge, delaunay_color ); |
||||
|
||||
|
||||
def locate_point( subdiv, fp, img, active_color ): |
||||
|
||||
(res, e0) = cv.Subdiv2DLocate( subdiv, fp ); |
||||
|
||||
if res in [ cv.CV_PTLOC_INSIDE, cv.CV_PTLOC_ON_EDGE ]: |
||||
e = e0 |
||||
while True: |
||||
draw_subdiv_edge( img, e, active_color ); |
||||
e = cv.Subdiv2DGetEdge(e, cv.CV_NEXT_AROUND_LEFT); |
||||
if e == e0: |
||||
break |
||||
|
||||
draw_subdiv_point( img, fp, active_color ); |
||||
|
||||
|
||||
def draw_subdiv_facet( img, edge ): |
||||
|
||||
t = edge; |
||||
count = 0; |
||||
|
||||
# count number of edges in facet |
||||
while count == 0 or t != edge: |
||||
count+=1 |
||||
t = cv.Subdiv2DGetEdge( t, cv.CV_NEXT_AROUND_LEFT ); |
||||
|
||||
buf = [] |
||||
|
||||
# gather points |
||||
t = edge; |
||||
for i in range(count): |
||||
assert t>4 |
||||
pt = cv.Subdiv2DEdgeOrg( t ); |
||||
if not pt: |
||||
break; |
||||
buf.append( ( cv.Round(pt.pt[0]), cv.Round(pt.pt[1]) ) ); |
||||
t = cv.Subdiv2DGetEdge( t, cv.CV_NEXT_AROUND_LEFT ); |
||||
|
||||
if( len(buf)==count ): |
||||
pt = cv.Subdiv2DEdgeDst( cv.Subdiv2DRotateEdge( edge, 1 )); |
||||
cv.FillConvexPoly( img, buf, cv.RGB(random.randrange(256),random.randrange(256),random.randrange(256)), cv.CV_AA, 0 ); |
||||
cv.PolyLine( img, [buf], 1, cv.RGB(0,0,0), 1, cv.CV_AA, 0); |
||||
draw_subdiv_point( img, pt.pt, cv.RGB(0,0,0)); |
||||
|
||||
def paint_voronoi( subdiv, img ): |
||||
|
||||
cv.CalcSubdivVoronoi2D( subdiv ); |
||||
|
||||
for edge in subdiv.edges: |
||||
|
||||
# left |
||||
draw_subdiv_facet( img, cv.Subdiv2DRotateEdge( edge, 1 )); |
||||
|
||||
# right |
||||
draw_subdiv_facet( img, cv.Subdiv2DRotateEdge( edge, 3 )); |
||||
|
||||
if __name__ == '__main__': |
||||
win = "source"; |
||||
rect = ( 0, 0, 600, 600 ); |
||||
|
||||
active_facet_color = cv.RGB( 255, 0, 0 ); |
||||
delaunay_color = cv.RGB( 0,0,0); |
||||
voronoi_color = cv.RGB(0, 180, 0); |
||||
bkgnd_color = cv.RGB(255,255,255); |
||||
|
||||
img = cv.CreateImage( (rect[2],rect[3]), 8, 3 ); |
||||
cv.Set( img, bkgnd_color ); |
||||
|
||||
cv.NamedWindow( win, 1 ); |
||||
|
||||
storage = cv.CreateMemStorage(0); |
||||
subdiv = cv.CreateSubdivDelaunay2D( rect, storage ); |
||||
|
||||
print "Delaunay triangulation will be build now interactively." |
||||
print "To stop the process, press any key\n"; |
||||
|
||||
for i in range(200): |
||||
fp = ( random.random()*(rect[2]-10)+5, random.random()*(rect[3]-10)+5 ) |
||||
|
||||
locate_point( subdiv, fp, img, active_facet_color ); |
||||
cv.ShowImage( win, img ); |
||||
|
||||
if( cv.WaitKey( 100 ) >= 0 ): |
||||
break; |
||||
|
||||
cv.SubdivDelaunay2DInsert( subdiv, fp ); |
||||
cv.CalcSubdivVoronoi2D( subdiv ); |
||||
cv.Set( img, bkgnd_color ); |
||||
draw_subdiv( img, subdiv, delaunay_color, voronoi_color ); |
||||
cv.ShowImage( win, img ); |
||||
|
||||
if( cv.WaitKey( 100 ) >= 0 ): |
||||
break; |
||||
|
||||
|
||||
cv.Set( img, bkgnd_color ); |
||||
paint_voronoi( subdiv, img ); |
||||
cv.ShowImage( win, img ); |
||||
|
||||
cv.WaitKey(0); |
||||
|
||||
cv.DestroyWindow( win ); |
||||
@ -1,80 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import cv2.cv as cv |
||||
import sys |
||||
import urllib2 |
||||
|
||||
hist_size = 64 |
||||
range_0 = [0, 256] |
||||
ranges = [ range_0 ] |
||||
|
||||
class DemHist: |
||||
|
||||
def __init__(self, src_image): |
||||
self.src_image = src_image |
||||
self.dst_image = cv.CloneMat(src_image) |
||||
self.hist_image = cv.CreateImage((320, 200), 8, 1) |
||||
self.hist = cv.CreateHist([hist_size], cv.CV_HIST_ARRAY, ranges, 1) |
||||
|
||||
self.brightness = 0 |
||||
self.contrast = 0 |
||||
|
||||
cv.NamedWindow("image", 0) |
||||
cv.NamedWindow("histogram", 0) |
||||
cv.CreateTrackbar("brightness", "image", 100, 200, self.update_brightness) |
||||
cv.CreateTrackbar("contrast", "image", 100, 200, self.update_contrast) |
||||
|
||||
self.update_brightcont() |
||||
|
||||
def update_brightness(self, val): |
||||
self.brightness = val - 100 |
||||
self.update_brightcont() |
||||
|
||||
def update_contrast(self, val): |
||||
self.contrast = val - 100 |
||||
self.update_brightcont() |
||||
|
||||
def update_brightcont(self): |
||||
# The algorithm is by Werner D. Streidt |
||||
# (http://visca.com/ffactory/archives/5-99/msg00021.html) |
||||
|
||||
if self.contrast > 0: |
||||
delta = 127. * self.contrast / 100 |
||||
a = 255. / (255. - delta * 2) |
||||
b = a * (self.brightness - delta) |
||||
else: |
||||
delta = -128. * self.contrast / 100 |
||||
a = (256. - delta * 2) / 255. |
||||
b = a * self.brightness + delta |
||||
|
||||
cv.ConvertScale(self.src_image, self.dst_image, a, b) |
||||
cv.ShowImage("image", self.dst_image) |
||||
|
||||
cv.CalcArrHist([self.dst_image], self.hist) |
||||
(min_value, max_value, _, _) = cv.GetMinMaxHistValue(self.hist) |
||||
cv.Scale(self.hist.bins, self.hist.bins, float(self.hist_image.height) / max_value, 0) |
||||
|
||||
cv.Set(self.hist_image, cv.ScalarAll(255)) |
||||
bin_w = round(float(self.hist_image.width) / hist_size) |
||||
|
||||
for i in range(hist_size): |
||||
cv.Rectangle(self.hist_image, (int(i * bin_w), self.hist_image.height), |
||||
(int((i + 1) * bin_w), self.hist_image.height - cv.Round(self.hist.bins[i])), |
||||
cv.ScalarAll(0), -1, 8, 0) |
||||
|
||||
cv.ShowImage("histogram", self.hist_image) |
||||
|
||||
if __name__ == "__main__": |
||||
# Load the source image. |
||||
if len(sys.argv) > 1: |
||||
src_image = cv.GetMat(cv.LoadImage(sys.argv[1], 0)) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/baboon.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
src_image = cv.DecodeImageM(imagefiledata, 0) |
||||
|
||||
dh = DemHist(src_image) |
||||
|
||||
cv.WaitKey(0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,114 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import cv2.cv as cv |
||||
import sys |
||||
import urllib2 |
||||
|
||||
# Rearrange the quadrants of Fourier image so that the origin is at |
||||
# the image center |
||||
# src & dst arrays of equal size & type |
||||
def cvShiftDFT(src_arr, dst_arr ): |
||||
|
||||
size = cv.GetSize(src_arr) |
||||
dst_size = cv.GetSize(dst_arr) |
||||
|
||||
if dst_size != size: |
||||
cv.Error( cv.CV_StsUnmatchedSizes, "cv.ShiftDFT", "Source and Destination arrays must have equal sizes", __FILE__, __LINE__ ) |
||||
|
||||
if(src_arr is dst_arr): |
||||
tmp = cv.CreateMat(size[1]/2, size[0]/2, cv.GetElemType(src_arr)) |
||||
|
||||
cx = size[0] / 2 |
||||
cy = size[1] / 2 # image center |
||||
|
||||
q1 = cv.GetSubRect( src_arr, (0,0,cx, cy) ) |
||||
q2 = cv.GetSubRect( src_arr, (cx,0,cx,cy) ) |
||||
q3 = cv.GetSubRect( src_arr, (cx,cy,cx,cy) ) |
||||
q4 = cv.GetSubRect( src_arr, (0,cy,cx,cy) ) |
||||
d1 = cv.GetSubRect( src_arr, (0,0,cx,cy) ) |
||||
d2 = cv.GetSubRect( src_arr, (cx,0,cx,cy) ) |
||||
d3 = cv.GetSubRect( src_arr, (cx,cy,cx,cy) ) |
||||
d4 = cv.GetSubRect( src_arr, (0,cy,cx,cy) ) |
||||
|
||||
if(src_arr is not dst_arr): |
||||
if( not cv.CV_ARE_TYPES_EQ( q1, d1 )): |
||||
cv.Error( cv.CV_StsUnmatchedFormats, "cv.ShiftDFT", "Source and Destination arrays must have the same format", __FILE__, __LINE__ ) |
||||
|
||||
cv.Copy(q3, d1) |
||||
cv.Copy(q4, d2) |
||||
cv.Copy(q1, d3) |
||||
cv.Copy(q2, d4) |
||||
|
||||
else: |
||||
cv.Copy(q3, tmp) |
||||
cv.Copy(q1, q3) |
||||
cv.Copy(tmp, q1) |
||||
cv.Copy(q4, tmp) |
||||
cv.Copy(q2, q4) |
||||
cv.Copy(tmp, q2) |
||||
|
||||
if __name__ == "__main__": |
||||
|
||||
if len(sys.argv) > 1: |
||||
im = cv.LoadImage( sys.argv[1], cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/baboon.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
im = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
|
||||
realInput = cv.CreateImage( cv.GetSize(im), cv.IPL_DEPTH_64F, 1) |
||||
imaginaryInput = cv.CreateImage( cv.GetSize(im), cv.IPL_DEPTH_64F, 1) |
||||
complexInput = cv.CreateImage( cv.GetSize(im), cv.IPL_DEPTH_64F, 2) |
||||
|
||||
cv.Scale(im, realInput, 1.0, 0.0) |
||||
cv.Zero(imaginaryInput) |
||||
cv.Merge(realInput, imaginaryInput, None, None, complexInput) |
||||
|
||||
dft_M = cv.GetOptimalDFTSize( im.height - 1 ) |
||||
dft_N = cv.GetOptimalDFTSize( im.width - 1 ) |
||||
|
||||
dft_A = cv.CreateMat( dft_M, dft_N, cv.CV_64FC2 ) |
||||
image_Re = cv.CreateImage( (dft_N, dft_M), cv.IPL_DEPTH_64F, 1) |
||||
image_Im = cv.CreateImage( (dft_N, dft_M), cv.IPL_DEPTH_64F, 1) |
||||
|
||||
# copy A to dft_A and pad dft_A with zeros |
||||
tmp = cv.GetSubRect( dft_A, (0,0, im.width, im.height)) |
||||
cv.Copy( complexInput, tmp, None ) |
||||
if(dft_A.width > im.width): |
||||
tmp = cv.GetSubRect( dft_A, (im.width,0, dft_N - im.width, im.height)) |
||||
cv.Zero( tmp ) |
||||
|
||||
# no need to pad bottom part of dft_A with zeros because of |
||||
# use nonzero_rows parameter in cv.FT() call below |
||||
|
||||
cv.DFT( dft_A, dft_A, cv.CV_DXT_FORWARD, complexInput.height ) |
||||
|
||||
cv.NamedWindow("win", 0) |
||||
cv.NamedWindow("magnitude", 0) |
||||
cv.ShowImage("win", im) |
||||
|
||||
# Split Fourier in real and imaginary parts |
||||
cv.Split( dft_A, image_Re, image_Im, None, None ) |
||||
|
||||
# Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) |
||||
cv.Pow( image_Re, image_Re, 2.0) |
||||
cv.Pow( image_Im, image_Im, 2.0) |
||||
cv.Add( image_Re, image_Im, image_Re, None) |
||||
cv.Pow( image_Re, image_Re, 0.5 ) |
||||
|
||||
# Compute log(1 + Mag) |
||||
cv.AddS( image_Re, cv.ScalarAll(1.0), image_Re, None ) # 1 + Mag |
||||
cv.Log( image_Re, image_Re ) # log(1 + Mag) |
||||
|
||||
|
||||
# Rearrange the quadrants of Fourier image so that the origin is at |
||||
# the image center |
||||
cvShiftDFT( image_Re, image_Re ) |
||||
|
||||
min, max, pt1, pt2 = cv.MinMaxLoc(image_Re) |
||||
cv.Scale(image_Re, image_Re, 1.0/(max-min), 1.0*(-min)/(max-min)) |
||||
cv.ShowImage("magnitude", image_Re) |
||||
|
||||
cv.WaitKey(0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,72 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import sys |
||||
import cv2.cv as cv |
||||
import urllib2 |
||||
|
||||
wndname = "Distance transform" |
||||
tbarname = "Threshold" |
||||
|
||||
# The output images |
||||
dist = 0 |
||||
dist8u1 = 0 |
||||
dist8u2 = 0 |
||||
dist8u = 0 |
||||
dist32s = 0 |
||||
|
||||
gray = 0 |
||||
edge = 0 |
||||
|
||||
# define a trackbar callback |
||||
def on_trackbar(edge_thresh): |
||||
|
||||
cv.Threshold(gray, edge, float(edge_thresh), float(edge_thresh), cv.CV_THRESH_BINARY) |
||||
#Distance transform |
||||
cv.DistTransform(edge, dist, cv.CV_DIST_L2, cv.CV_DIST_MASK_5) |
||||
|
||||
cv.ConvertScale(dist, dist, 5000.0, 0) |
||||
cv.Pow(dist, dist, 0.5) |
||||
|
||||
cv.ConvertScale(dist, dist32s, 1.0, 0.5) |
||||
cv.AndS(dist32s, cv.ScalarAll(255), dist32s, None) |
||||
cv.ConvertScale(dist32s, dist8u1, 1, 0) |
||||
cv.ConvertScale(dist32s, dist32s, -1, 0) |
||||
cv.AddS(dist32s, cv.ScalarAll(255), dist32s, None) |
||||
cv.ConvertScale(dist32s, dist8u2, 1, 0) |
||||
cv.Merge(dist8u1, dist8u2, dist8u2, None, dist8u) |
||||
cv.ShowImage(wndname, dist8u) |
||||
|
||||
|
||||
if __name__ == "__main__": |
||||
edge_thresh = 100 |
||||
|
||||
if len(sys.argv) > 1: |
||||
gray = cv.LoadImage(sys.argv[1], cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/stuff.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
gray = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
|
||||
# Create the output image |
||||
dist = cv.CreateImage((gray.width, gray.height), cv.IPL_DEPTH_32F, 1) |
||||
dist8u1 = cv.CloneImage(gray) |
||||
dist8u2 = cv.CloneImage(gray) |
||||
dist8u = cv.CreateImage((gray.width, gray.height), cv.IPL_DEPTH_8U, 3) |
||||
dist32s = cv.CreateImage((gray.width, gray.height), cv.IPL_DEPTH_32S, 1) |
||||
|
||||
# Convert to grayscale |
||||
edge = cv.CloneImage(gray) |
||||
|
||||
# Create a window |
||||
cv.NamedWindow(wndname, 1) |
||||
|
||||
# create a toolbar |
||||
cv.CreateTrackbar(tbarname, wndname, edge_thresh, 255, on_trackbar) |
||||
|
||||
# Show the image |
||||
on_trackbar(edge_thresh) |
||||
|
||||
# Wait for a key stroke; the same function arranges events processing |
||||
cv.WaitKey(0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,184 +0,0 @@ |
||||
#!/usr/bin/python |
||||
|
||||
import cv2.cv as cv |
||||
import time |
||||
from pydmtx import DataMatrix |
||||
import numpy |
||||
import sys |
||||
import math |
||||
|
||||
''' |
||||
Find 2 D barcode based on up to 3 channel datamatrix |
||||
''' |
||||
|
||||
def absnorm8(im, im8): |
||||
""" im may be any single-channel image type. Return an 8-bit version, absolute value, normalized so that max is 255 """ |
||||
(minVal, maxVal, _, _) = cv.MinMaxLoc(im) |
||||
cv.ConvertScaleAbs(im, im8, 255 / max(abs(minVal), abs(maxVal)), 0) |
||||
return im8 |
||||
|
||||
font = cv.InitFont(cv.CV_FONT_HERSHEY_SIMPLEX, 1.0, 1.0, thickness = 2, lineType = cv.CV_AA) |
||||
if 0: |
||||
started = time.time() |
||||
print dm_write.decode(bg.width, bg.height, buffer(bg.tostring()), max_count = 1, min_edge = 12, max_edge = 13, shape = DataMatrix.DmtxSymbol10x10) # , timeout = 10) |
||||
print "took", time.time() - started |
||||
|
||||
class DmtxFinder: |
||||
def __init__(self): |
||||
self.cache = {} |
||||
self.dm = DataMatrix() |
||||
|
||||
def Cached(self, name, rows, cols, type): |
||||
key = (name, rows, cols) |
||||
if not key in self.cache: |
||||
self.cache[key] = cv.CreateMat(rows, cols, type) |
||||
return self.cache[key] |
||||
|
||||
def find0(self, img): |
||||
started = time.time() |
||||
self.dm.decode(img.width, |
||||
img.height, |
||||
buffer(img.tostring()), |
||||
max_count = 4, |
||||
#min_edge = 6, |
||||
#max_edge = 19 # Units of 2 pixels |
||||
) |
||||
print "brute", time.time() - started |
||||
found = {} |
||||
for i in range(self.dm.count()): |
||||
stats = dm_read.stats(i + 1) |
||||
print stats |
||||
found[stats[0]] = stats[1] |
||||
return found |
||||
|
||||
def find(self, img): |
||||
started = time.time() |
||||
gray = self.Cached('gray', img.height, img.width, cv.CV_8UC1) |
||||
cv.CvtColor(img, gray, cv.CV_BGR2GRAY) |
||||
|
||||
sobel = self.Cached('sobel', img.height, img.width, cv.CV_16SC1) |
||||
sobely = self.Cached('sobely', img.height, img.width, cv.CV_16SC1) |
||||
|
||||
cv.Sobel(gray, sobel, 1, 0) |
||||
cv.Sobel(gray, sobely, 0, 1) |
||||
cv.Add(sobel, sobely, sobel) |
||||
|
||||
sobel8 = self.Cached('sobel8', sobel.height, sobel.width, cv.CV_8UC1) |
||||
absnorm8(sobel, sobel8) |
||||
cv.Threshold(sobel8, sobel8, 128.0, 255.0, cv.CV_THRESH_BINARY) |
||||
|
||||
sobel_integral = self.Cached('sobel_integral', img.height + 1, img.width + 1, cv.CV_32SC1) |
||||
cv.Integral(sobel8, sobel_integral) |
||||
|
||||
d = 16 |
||||
_x1y1 = cv.GetSubRect(sobel_integral, (0, 0, sobel_integral.cols - d, sobel_integral.rows - d)) |
||||
_x1y2 = cv.GetSubRect(sobel_integral, (0, d, sobel_integral.cols - d, sobel_integral.rows - d)) |
||||
_x2y1 = cv.GetSubRect(sobel_integral, (d, 0, sobel_integral.cols - d, sobel_integral.rows - d)) |
||||
_x2y2 = cv.GetSubRect(sobel_integral, (d, d, sobel_integral.cols - d, sobel_integral.rows - d)) |
||||
|
||||
summation = cv.CloneMat(_x2y2) |
||||
cv.Sub(summation, _x1y2, summation) |
||||
cv.Sub(summation, _x2y1, summation) |
||||
cv.Add(summation, _x1y1, summation) |
||||
sum8 = self.Cached('sum8', summation.height, summation.width, cv.CV_8UC1) |
||||
absnorm8(summation, sum8) |
||||
cv.Threshold(sum8, sum8, 32.0, 255.0, cv.CV_THRESH_BINARY) |
||||
|
||||
cv.ShowImage("sum8", sum8) |
||||
seq = cv.FindContours(sum8, cv.CreateMemStorage(), cv.CV_RETR_EXTERNAL) |
||||
subimg = cv.GetSubRect(img, (d / 2, d / 2, sum8.cols, sum8.rows)) |
||||
t_cull = time.time() - started |
||||
|
||||
seqs = [] |
||||
while seq: |
||||
seqs.append(seq) |
||||
seq = seq.h_next() |
||||
|
||||
started = time.time() |
||||
found = {} |
||||
print 'seqs', len(seqs) |
||||
for seq in seqs: |
||||
area = cv.ContourArea(seq) |
||||
if area > 1000: |
||||
rect = cv.BoundingRect(seq) |
||||
edge = int((14 / 14.) * math.sqrt(area) / 2 + 0.5) |
||||
candidate = cv.GetSubRect(subimg, rect) |
||||
sym = self.dm.decode(candidate.width, |
||||
candidate.height, |
||||
buffer(candidate.tostring()), |
||||
max_count = 1, |
||||
#min_edge = 6, |
||||
#max_edge = int(edge) # Units of 2 pixels |
||||
) |
||||
if sym: |
||||
onscreen = [(d / 2 + rect[0] + x, d / 2 + rect[1] + y) for (x, y) in self.dm.stats(1)[1]] |
||||
found[sym] = onscreen |
||||
else: |
||||
print "FAILED" |
||||
t_brute = time.time() - started |
||||
print "cull took", t_cull, "brute", t_brute |
||||
return found |
||||
|
||||
bg = cv.CreateMat(1024, 1024, cv.CV_8UC3) |
||||
cv.Set(bg, cv.RGB(0, 0, 0)) |
||||
df = DmtxFinder() |
||||
|
||||
cv.NamedWindow("camera", 1) |
||||
|
||||
def mkdmtx(msg): |
||||
dm_write = DataMatrix() |
||||
dm_write.encode(msg) |
||||
pi = dm_write.image # .resize((14, 14)) |
||||
cv_im = cv.CreateImageHeader(pi.size, cv.IPL_DEPTH_8U, 3) |
||||
cv.SetData(cv_im, pi.tostring()) |
||||
return cv_im |
||||
|
||||
# test = [('WIL', (100,100))]: # , ('LOW', (250,100)), ('GAR', (300, 300)), ('AGE', (500, 300))]: |
||||
|
||||
test = [] |
||||
y = 10 |
||||
for j in range(7): |
||||
r = 28 + j * 4 |
||||
mr = r * math.sqrt(2) |
||||
y += mr * 1.8 |
||||
test += [(str(deg) + "abcdefgh"[j], (50 + deg * 11, y), math.pi * deg / 180, r) for deg in range(0, 90, 10)] |
||||
|
||||
for (msg, (x, y), angle, r) in test: |
||||
map = cv.CreateMat(2, 3, cv.CV_32FC1) |
||||
corners = [(x + r * math.cos(angle + th), y + r * math.sin(angle + th)) for th in [0, math.pi / 2, math.pi, 3 * math.pi / 4]] |
||||
src = mkdmtx(msg) |
||||
(sx, sy) = cv.GetSize(src) |
||||
cv.GetAffineTransform([(0,0), (sx, 0), (sx, sy)], corners[:3], map) |
||||
temp = cv.CreateMat(bg.rows, bg.cols, cv.CV_8UC3) |
||||
cv.Set(temp, cv.RGB(0, 0, 0)) |
||||
cv.WarpAffine(src, temp, map) |
||||
cv.Or(temp, bg, bg) |
||||
|
||||
|
||||
cv.ShowImage("comp", bg) |
||||
scribble = cv.CloneMat(bg) |
||||
|
||||
if 0: |
||||
for i in range(10): |
||||
df.find(bg) |
||||
|
||||
for (sym, coords) in df.find(bg).items(): |
||||
print sym |
||||
cv.PolyLine(scribble, [coords], 1, cv.CV_RGB(255, 0,0), 1, lineType = cv.CV_AA) |
||||
Xs = [x for (x, y) in coords] |
||||
Ys = [y for (x, y) in coords] |
||||
where = ((min(Xs) + max(Xs)) / 2, max(Ys) - 50) |
||||
cv.PutText(scribble, sym, where, font, cv.RGB(0,255, 0)) |
||||
|
||||
cv.ShowImage("results", scribble) |
||||
cv.WaitKey() |
||||
cv.DestroyAllWindows() |
||||
|
||||
sys.exit(0) |
||||
|
||||
capture = cv.CaptureFromCAM(0) |
||||
while True: |
||||
img = cv.QueryFrame(capture) |
||||
cv.ShowImage("capture", img) |
||||
print df.find(img) |
||||
cv.WaitKey(6) |
||||
@ -1,162 +0,0 @@ |
||||
#! /usr/bin/env python |
||||
from random import Random |
||||
import colorsys |
||||
|
||||
print "OpenCV Python version of drawing" |
||||
|
||||
import cv2.cv as cv |
||||
|
||||
def random_color(random): |
||||
""" |
||||
Return a random color |
||||
""" |
||||
icolor = random.randint(0, 0xFFFFFF) |
||||
return cv.Scalar(icolor & 0xff, (icolor >> 8) & 0xff, (icolor >> 16) & 0xff) |
||||
|
||||
if __name__ == '__main__': |
||||
|
||||
# some "constants" |
||||
width = 1000 |
||||
height = 700 |
||||
window_name = "Drawing Demo" |
||||
number = 100 |
||||
delay = 5 |
||||
line_type = cv.CV_AA # change it to 8 to see non-antialiased graphics |
||||
|
||||
# create the source image |
||||
image = cv.CreateImage( (width, height), 8, 3) |
||||
|
||||
# create window and display the original picture in it |
||||
cv.NamedWindow(window_name, 1) |
||||
cv.SetZero(image) |
||||
cv.ShowImage(window_name, image) |
||||
|
||||
# create the random number |
||||
random = Random() |
||||
|
||||
# draw some lines |
||||
for i in range(number): |
||||
pt1 = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
pt2 = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
cv.Line(image, pt1, pt2, |
||||
random_color(random), |
||||
random.randrange(0, 10), |
||||
line_type, 0) |
||||
|
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# draw some rectangles |
||||
for i in range(number): |
||||
pt1 = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
pt2 = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
cv.Rectangle(image, pt1, pt2, |
||||
random_color(random), |
||||
random.randrange(-1, 9), |
||||
line_type, 0) |
||||
|
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# draw some ellipes |
||||
for i in range(number): |
||||
pt1 = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
sz = (random.randrange(0, 200), |
||||
random.randrange(0, 200)) |
||||
angle = random.randrange(0, 1000) * 0.180 |
||||
cv.Ellipse(image, pt1, sz, angle, angle - 100, angle + 200, |
||||
random_color(random), |
||||
random.randrange(-1, 9), |
||||
line_type, 0) |
||||
|
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# init the list of polylines |
||||
nb_polylines = 2 |
||||
polylines_size = 3 |
||||
pt = [0,] * nb_polylines |
||||
for a in range(nb_polylines): |
||||
pt [a] = [0,] * polylines_size |
||||
|
||||
# draw some polylines |
||||
for i in range(number): |
||||
for a in range(nb_polylines): |
||||
for b in range(polylines_size): |
||||
pt [a][b] = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
cv.PolyLine(image, pt, 1, |
||||
random_color(random), |
||||
random.randrange(1, 9), |
||||
line_type, 0) |
||||
|
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# draw some filled polylines |
||||
for i in range(number): |
||||
for a in range(nb_polylines): |
||||
for b in range(polylines_size): |
||||
pt [a][b] = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
cv.FillPoly(image, pt, |
||||
random_color(random), |
||||
line_type, 0) |
||||
|
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# draw some circles |
||||
for i in range(number): |
||||
pt1 = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
cv.Circle(image, pt1, random.randrange(0, 300), |
||||
random_color(random), |
||||
random.randrange(-1, 9), |
||||
line_type, 0) |
||||
|
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# draw some text |
||||
for i in range(number): |
||||
pt1 = (random.randrange(-width, 2 * width), |
||||
random.randrange(-height, 2 * height)) |
||||
font = cv.InitFont(random.randrange(0, 8), |
||||
random.randrange(0, 100) * 0.05 + 0.01, |
||||
random.randrange(0, 100) * 0.05 + 0.01, |
||||
random.randrange(0, 5) * 0.1, |
||||
random.randrange(0, 10), |
||||
line_type) |
||||
|
||||
cv.PutText(image, "Testing text rendering!", |
||||
pt1, font, |
||||
random_color(random)) |
||||
|
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# prepare a text, and get it's properties |
||||
font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, |
||||
3, 3, 0.0, 5, line_type) |
||||
text_size, ymin = cv.GetTextSize("OpenCV forever!", font) |
||||
pt1 = ((width - text_size[0]) / 2, (height + text_size[1]) / 2) |
||||
image2 = cv.CloneImage(image) |
||||
|
||||
# now, draw some OpenCV pub ;-) |
||||
for i in range(0, 512, 2): |
||||
cv.SubS(image2, cv.ScalarAll(i), image) |
||||
(r, g, b) = colorsys.hsv_to_rgb((i % 100) / 100., 1, 1) |
||||
cv.PutText(image, "OpenCV forever!", |
||||
pt1, font, cv.RGB(255 * r, 255 * g, 255 * b)) |
||||
cv.ShowImage(window_name, image) |
||||
cv.WaitKey(delay) |
||||
|
||||
# wait some key to end |
||||
cv.WaitKey(0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,60 +0,0 @@ |
||||
#! /usr/bin/env python |
||||
|
||||
print "OpenCV Python version of edge" |
||||
|
||||
import sys |
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
|
||||
# some definitions |
||||
win_name = "Edge" |
||||
trackbar_name = "Threshold" |
||||
|
||||
# the callback on the trackbar |
||||
def on_trackbar(position): |
||||
|
||||
cv.Smooth(gray, edge, cv.CV_BLUR, 3, 3, 0) |
||||
cv.Not(gray, edge) |
||||
|
||||
# run the edge dector on gray scale |
||||
cv.Canny(gray, edge, position, position * 3, 3) |
||||
|
||||
# reset |
||||
cv.SetZero(col_edge) |
||||
|
||||
# copy edge points |
||||
cv.Copy(im, col_edge, edge) |
||||
|
||||
# show the im |
||||
cv.ShowImage(win_name, col_edge) |
||||
|
||||
if __name__ == '__main__': |
||||
if len(sys.argv) > 1: |
||||
im = cv.LoadImage( sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/fruits.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
im = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
# create the output im |
||||
col_edge = cv.CreateImage((im.width, im.height), 8, 3) |
||||
|
||||
# convert to grayscale |
||||
gray = cv.CreateImage((im.width, im.height), 8, 1) |
||||
edge = cv.CreateImage((im.width, im.height), 8, 1) |
||||
cv.CvtColor(im, gray, cv.CV_BGR2GRAY) |
||||
|
||||
# create the window |
||||
cv.NamedWindow(win_name, cv.CV_WINDOW_AUTOSIZE) |
||||
|
||||
# create the trackbar |
||||
cv.CreateTrackbar(trackbar_name, win_name, 1, 100, on_trackbar) |
||||
|
||||
# show the im |
||||
on_trackbar(0) |
||||
|
||||
# wait a key pressed to end |
||||
cv.WaitKey(0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,101 +0,0 @@ |
||||
#!/usr/bin/python |
||||
""" |
||||
This program is demonstration for face and object detection using haar-like features. |
||||
The program finds faces in a camera image or video stream and displays a red box around them. |
||||
|
||||
Original C implementation by: ? |
||||
Python implementation by: Roman Stanchak, James Bowman |
||||
""" |
||||
import sys |
||||
import cv2.cv as cv |
||||
from optparse import OptionParser |
||||
|
||||
# Parameters for haar detection |
||||
# From the API: |
||||
# The default parameters (scale_factor=2, min_neighbors=3, flags=0) are tuned |
||||
# for accurate yet slow object detection. For a faster operation on real video |
||||
# images the settings are: |
||||
# scale_factor=1.2, min_neighbors=2, flags=CV_HAAR_DO_CANNY_PRUNING, |
||||
# min_size=<minimum possible face size |
||||
|
||||
min_size = (20, 20) |
||||
image_scale = 2 |
||||
haar_scale = 1.2 |
||||
min_neighbors = 2 |
||||
haar_flags = 0 |
||||
|
||||
def detect_and_draw(img, cascade): |
||||
# allocate temporary images |
||||
gray = cv.CreateImage((img.width,img.height), 8, 1) |
||||
small_img = cv.CreateImage((cv.Round(img.width / image_scale), |
||||
cv.Round (img.height / image_scale)), 8, 1) |
||||
|
||||
# convert color input image to grayscale |
||||
cv.CvtColor(img, gray, cv.CV_BGR2GRAY) |
||||
|
||||
# scale input image for faster processing |
||||
cv.Resize(gray, small_img, cv.CV_INTER_LINEAR) |
||||
|
||||
cv.EqualizeHist(small_img, small_img) |
||||
|
||||
if(cascade): |
||||
t = cv.GetTickCount() |
||||
faces = cv.HaarDetectObjects(small_img, cascade, cv.CreateMemStorage(0), |
||||
haar_scale, min_neighbors, haar_flags, min_size) |
||||
t = cv.GetTickCount() - t |
||||
print "detection time = %gms" % (t/(cv.GetTickFrequency()*1000.)) |
||||
if faces: |
||||
for ((x, y, w, h), n) in faces: |
||||
# the input to cv.HaarDetectObjects was resized, so scale the |
||||
# bounding box of each face and convert it to two CvPoints |
||||
pt1 = (int(x * image_scale), int(y * image_scale)) |
||||
pt2 = (int((x + w) * image_scale), int((y + h) * image_scale)) |
||||
cv.Rectangle(img, pt1, pt2, cv.RGB(255, 0, 0), 3, 8, 0) |
||||
|
||||
cv.ShowImage("result", img) |
||||
|
||||
if __name__ == '__main__': |
||||
|
||||
parser = OptionParser(usage = "usage: %prog [options] [filename|camera_index]") |
||||
parser.add_option("-c", "--cascade", action="store", dest="cascade", type="str", help="Haar cascade file, default %default", default = "../data/haarcascades/haarcascade_frontalface_alt.xml") |
||||
(options, args) = parser.parse_args() |
||||
|
||||
cascade = cv.Load(options.cascade) |
||||
|
||||
if len(args) != 1: |
||||
parser.print_help() |
||||
sys.exit(1) |
||||
|
||||
input_name = args[0] |
||||
if input_name.isdigit(): |
||||
capture = cv.CreateCameraCapture(int(input_name)) |
||||
else: |
||||
capture = None |
||||
|
||||
cv.NamedWindow("result", 1) |
||||
|
||||
if capture: |
||||
frame_copy = None |
||||
while True: |
||||
frame = cv.QueryFrame(capture) |
||||
if not frame: |
||||
cv.WaitKey(0) |
||||
break |
||||
if not frame_copy: |
||||
frame_copy = cv.CreateImage((frame.width,frame.height), |
||||
cv.IPL_DEPTH_8U, frame.nChannels) |
||||
if frame.origin == cv.IPL_ORIGIN_TL: |
||||
cv.Copy(frame, frame_copy) |
||||
else: |
||||
cv.Flip(frame, frame_copy, 0) |
||||
|
||||
detect_and_draw(frame_copy, cascade) |
||||
|
||||
if cv.WaitKey(10) >= 0: |
||||
break |
||||
else: |
||||
image = cv.LoadImage(input_name, 1) |
||||
detect_and_draw(image, cascade) |
||||
cv.WaitKey(0) |
||||
|
||||
cv.DestroyWindow("result") |
||||
@ -1,56 +0,0 @@ |
||||
#!/usr/bin/env python |
||||
|
||||
from cv import * |
||||
|
||||
class FBackDemo: |
||||
def __init__(self): |
||||
self.capture = CaptureFromCAM(0) |
||||
self.mv_step = 16 |
||||
self.mv_scale = 1.5 |
||||
self.mv_color = (0, 255, 0) |
||||
self.cflow = None |
||||
self.flow = None |
||||
|
||||
NamedWindow( "Optical Flow", 1 ) |
||||
|
||||
print( "Press ESC - quit the program\n" ) |
||||
|
||||
def draw_flow(self, flow, prevgray): |
||||
""" Returns a nice representation of a hue histogram """ |
||||
|
||||
CvtColor(prevgray, self.cflow, CV_GRAY2BGR) |
||||
for y in range(0, flow.height, self.mv_step): |
||||
for x in range(0, flow.width, self.mv_step): |
||||
fx, fy = flow[y, x] |
||||
Line(self.cflow, (x,y), (x+fx,y+fy), self.mv_color) |
||||
Circle(self.cflow, (x,y), 2, self.mv_color, -1) |
||||
ShowImage("Optical Flow", self.cflow) |
||||
|
||||
def run(self): |
||||
first_frame = True |
||||
|
||||
while True: |
||||
frame = QueryFrame( self.capture ) |
||||
|
||||
if first_frame: |
||||
gray = CreateImage(GetSize(frame), 8, 1) |
||||
prev_gray = CreateImage(GetSize(frame), 8, 1) |
||||
flow = CreateImage(GetSize(frame), 32, 2) |
||||
self.cflow = CreateImage(GetSize(frame), 8, 3) |
||||
|
||||
CvtColor(frame, gray, CV_BGR2GRAY) |
||||
if not first_frame: |
||||
CalcOpticalFlowFarneback(prev_gray, gray, flow, |
||||
pyr_scale=0.5, levels=3, winsize=15, |
||||
iterations=3, poly_n=5, poly_sigma=1.2, flags=0) |
||||
self.draw_flow(flow, prev_gray) |
||||
c = WaitKey(7) |
||||
if c in [27, ord('q'), ord('Q')]: |
||||
break |
||||
prev_gray, gray = gray, prev_gray |
||||
first_frame = False |
||||
|
||||
if __name__=="__main__": |
||||
demo = FBackDemo() |
||||
demo.run() |
||||
cv.DestroyAllWindows() |
||||
@ -1,160 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import sys |
||||
import random |
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
|
||||
im=None; |
||||
mask=None; |
||||
color_img=None; |
||||
gray_img0 = None; |
||||
gray_img = None; |
||||
ffill_case = 1; |
||||
lo_diff = 20 |
||||
up_diff = 20; |
||||
connectivity = 4; |
||||
is_color = 1; |
||||
is_mask = 0; |
||||
new_mask_val = 255; |
||||
|
||||
def update_lo( pos ): |
||||
lo_diff = pos |
||||
def update_up( pos ): |
||||
up_diff = pos |
||||
|
||||
def on_mouse( event, x, y, flags, param ): |
||||
|
||||
if( not color_img ): |
||||
return; |
||||
|
||||
if event == cv.CV_EVENT_LBUTTONDOWN: |
||||
my_mask = None |
||||
seed = (x,y); |
||||
if ffill_case==0: |
||||
lo = up = 0 |
||||
flags = connectivity + (new_mask_val << 8) |
||||
else: |
||||
lo = lo_diff; |
||||
up = up_diff; |
||||
flags = connectivity + (new_mask_val << 8) + cv.CV_FLOODFILL_FIXED_RANGE |
||||
b = random.randint(0,255) |
||||
g = random.randint(0,255) |
||||
r = random.randint(0,255) |
||||
|
||||
if( is_mask ): |
||||
my_mask = mask |
||||
cv.Threshold( mask, mask, 1, 128, cv.CV_THRESH_BINARY ); |
||||
|
||||
if( is_color ): |
||||
|
||||
color = cv.CV_RGB( r, g, b ); |
||||
comp = cv.FloodFill( color_img, seed, color, cv.CV_RGB( lo, lo, lo ), |
||||
cv.CV_RGB( up, up, up ), flags, my_mask ); |
||||
cv.ShowImage( "image", color_img ); |
||||
|
||||
else: |
||||
|
||||
brightness = cv.RealScalar((r*2 + g*7 + b + 5)/10); |
||||
comp = cv.FloodFill( gray_img, seed, brightness, cv.RealScalar(lo), |
||||
cv.RealScalar(up), flags, my_mask ); |
||||
cv.ShowImage( "image", gray_img ); |
||||
|
||||
|
||||
print "%g pixels were repainted" % comp[0] |
||||
|
||||
if( is_mask ): |
||||
cv.ShowImage( "mask", mask ); |
||||
|
||||
|
||||
|
||||
|
||||
if __name__ == "__main__": |
||||
|
||||
if len(sys.argv) > 1: |
||||
im = cv.LoadImage( sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/fruits.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
im = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
print "Hot keys:" |
||||
print "\tESC - quit the program" |
||||
print "\tc - switch color/grayscale mode" |
||||
print "\tm - switch mask mode" |
||||
print "\tr - restore the original image" |
||||
print "\ts - use null-range floodfill" |
||||
print "\tf - use gradient floodfill with fixed(absolute) range" |
||||
print "\tg - use gradient floodfill with floating(relative) range" |
||||
print "\t4 - use 4-connectivity mode" |
||||
print "\t8 - use 8-connectivity mode" |
||||
|
||||
color_img = cv.CloneImage( im ); |
||||
gray_img0 = cv.CreateImage( (color_img.width, color_img.height), 8, 1 ); |
||||
cv.CvtColor( color_img, gray_img0, cv.CV_BGR2GRAY ); |
||||
gray_img = cv.CloneImage( gray_img0 ); |
||||
mask = cv.CreateImage( (color_img.width + 2, color_img.height + 2), 8, 1 ); |
||||
|
||||
cv.NamedWindow( "image", 1 ); |
||||
cv.CreateTrackbar( "lo_diff", "image", lo_diff, 255, update_lo); |
||||
cv.CreateTrackbar( "up_diff", "image", up_diff, 255, update_up); |
||||
|
||||
cv.SetMouseCallback( "image", on_mouse ); |
||||
|
||||
while True: |
||||
if( is_color ): |
||||
cv.ShowImage( "image", color_img ); |
||||
else: |
||||
cv.ShowImage( "image", gray_img ); |
||||
|
||||
c = cv.WaitKey(0) % 0x100 |
||||
if c == 27: |
||||
print("Exiting ..."); |
||||
sys.exit(0) |
||||
elif c == ord('c'): |
||||
if( is_color ): |
||||
|
||||
print("Grayscale mode is set"); |
||||
cv.CvtColor( color_img, gray_img, cv.CV_BGR2GRAY ); |
||||
is_color = 0; |
||||
|
||||
else: |
||||
|
||||
print("Color mode is set"); |
||||
cv.Copy( im, color_img, None ); |
||||
cv.Zero( mask ); |
||||
is_color = 1; |
||||
|
||||
elif c == ord('m'): |
||||
if( is_mask ): |
||||
cv.DestroyWindow( "mask" ); |
||||
is_mask = 0; |
||||
|
||||
else: |
||||
cv.NamedWindow( "mask", 0 ); |
||||
cv.Zero( mask ); |
||||
cv.ShowImage( "mask", mask ); |
||||
is_mask = 1; |
||||
|
||||
elif c == ord('r'): |
||||
print("Original image is restored"); |
||||
cv.Copy( im, color_img, None ); |
||||
cv.Copy( gray_img0, gray_img, None ); |
||||
cv.Zero( mask ); |
||||
elif c == ord('s'): |
||||
print("Simple floodfill mode is set"); |
||||
ffill_case = 0; |
||||
elif c == ord('f'): |
||||
print("Fixed Range floodfill mode is set"); |
||||
ffill_case = 1; |
||||
elif c == ord('g'): |
||||
print("Gradient (floating range) floodfill mode is set"); |
||||
ffill_case = 2; |
||||
elif c == ord('4'): |
||||
print("4-connectivity mode is set"); |
||||
connectivity = 4; |
||||
elif c == ord('8'): |
||||
print("8-connectivity mode is set"); |
||||
connectivity = 8; |
||||
cv.DestroyAllWindows() |
||||
@ -1,104 +0,0 @@ |
||||
#!/usr/bin/python |
||||
""" |
||||
This program is a demonstration of ellipse fitting. |
||||
|
||||
Trackbar controls threshold parameter. |
||||
|
||||
Gray lines are contours. Colored lines are fit ellipses. |
||||
|
||||
Original C implementation by: Denis Burenkov. |
||||
Python implementation by: Roman Stanchak, James Bowman |
||||
""" |
||||
|
||||
import sys |
||||
import urllib2 |
||||
import random |
||||
import cv2.cv as cv |
||||
|
||||
def contour_iterator(contour): |
||||
while contour: |
||||
yield contour |
||||
contour = contour.h_next() |
||||
|
||||
class FitEllipse: |
||||
|
||||
def __init__(self, source_image, slider_pos): |
||||
self.source_image = source_image |
||||
cv.CreateTrackbar("Threshold", "Result", slider_pos, 255, self.process_image) |
||||
self.process_image(slider_pos) |
||||
|
||||
def process_image(self, slider_pos): |
||||
""" |
||||
This function finds contours, draws them and their approximation by ellipses. |
||||
""" |
||||
stor = cv.CreateMemStorage() |
||||
|
||||
# Create the destination images |
||||
image02 = cv.CloneImage(self.source_image) |
||||
cv.Zero(image02) |
||||
image04 = cv.CreateImage(cv.GetSize(self.source_image), cv.IPL_DEPTH_8U, 3) |
||||
cv.Zero(image04) |
||||
|
||||
# Threshold the source image. This needful for cv.FindContours(). |
||||
cv.Threshold(self.source_image, image02, slider_pos, 255, cv.CV_THRESH_BINARY) |
||||
|
||||
# Find all contours. |
||||
cont = cv.FindContours(image02, |
||||
stor, |
||||
cv.CV_RETR_LIST, |
||||
cv.CV_CHAIN_APPROX_NONE, |
||||
(0, 0)) |
||||
|
||||
for c in contour_iterator(cont): |
||||
# Number of points must be more than or equal to 6 for cv.FitEllipse2 |
||||
if len(c) >= 6: |
||||
# Copy the contour into an array of (x,y)s |
||||
PointArray2D32f = cv.CreateMat(1, len(c), cv.CV_32FC2) |
||||
for (i, (x, y)) in enumerate(c): |
||||
PointArray2D32f[0, i] = (x, y) |
||||
|
||||
# Draw the current contour in gray |
||||
gray = cv.CV_RGB(100, 100, 100) |
||||
cv.DrawContours(image04, c, gray, gray,0,1,8,(0,0)) |
||||
|
||||
# Fits ellipse to current contour. |
||||
(center, size, angle) = cv.FitEllipse2(PointArray2D32f) |
||||
|
||||
# Convert ellipse data from float to integer representation. |
||||
center = (cv.Round(center[0]), cv.Round(center[1])) |
||||
size = (cv.Round(size[0] * 0.5), cv.Round(size[1] * 0.5)) |
||||
|
||||
# Draw ellipse in random color |
||||
color = cv.CV_RGB(random.randrange(256),random.randrange(256),random.randrange(256)) |
||||
cv.Ellipse(image04, center, size, |
||||
angle, 0, 360, |
||||
color, 2, cv.CV_AA, 0) |
||||
|
||||
# Show image. HighGUI use. |
||||
cv.ShowImage( "Result", image04 ) |
||||
|
||||
|
||||
if __name__ == '__main__': |
||||
if len(sys.argv) > 1: |
||||
source_image = cv.LoadImage(sys.argv[1], cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/stuff.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
source_image = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
|
||||
# Create windows. |
||||
cv.NamedWindow("Source", 1) |
||||
cv.NamedWindow("Result", 1) |
||||
|
||||
# Show the image. |
||||
cv.ShowImage("Source", source_image) |
||||
|
||||
fe = FitEllipse(source_image, 70) |
||||
|
||||
print "Press any key to exit" |
||||
cv.WaitKey(0) |
||||
|
||||
cv.DestroyWindow("Source") |
||||
cv.DestroyWindow("Result") |
||||
@ -1,58 +0,0 @@ |
||||
#!/usr/bin/python |
||||
# This is a standalone program. Pass an image name as a first parameter of the program. |
||||
|
||||
import sys |
||||
from math import sin, cos, sqrt, pi |
||||
import cv2.cv as cv |
||||
import urllib2 |
||||
|
||||
# toggle between CV_HOUGH_STANDARD and CV_HOUGH_PROBILISTIC |
||||
USE_STANDARD = True |
||||
|
||||
if __name__ == "__main__": |
||||
if len(sys.argv) > 1: |
||||
filename = sys.argv[1] |
||||
src = cv.LoadImage(filename, cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/doc/pics/building.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
src = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_GRAYSCALE) |
||||
|
||||
|
||||
cv.NamedWindow("Source", 1) |
||||
cv.NamedWindow("Hough", 1) |
||||
|
||||
while True: |
||||
dst = cv.CreateImage(cv.GetSize(src), 8, 1) |
||||
color_dst = cv.CreateImage(cv.GetSize(src), 8, 3) |
||||
storage = cv.CreateMemStorage(0) |
||||
lines = 0 |
||||
cv.Canny(src, dst, 50, 200, 3) |
||||
cv.CvtColor(dst, color_dst, cv.CV_GRAY2BGR) |
||||
|
||||
if USE_STANDARD: |
||||
lines = cv.HoughLines2(dst, storage, cv.CV_HOUGH_STANDARD, 1, pi / 180, 100, 0, 0) |
||||
for (rho, theta) in lines[:100]: |
||||
a = cos(theta) |
||||
b = sin(theta) |
||||
x0 = a * rho |
||||
y0 = b * rho |
||||
pt1 = (cv.Round(x0 + 1000*(-b)), cv.Round(y0 + 1000*(a))) |
||||
pt2 = (cv.Round(x0 - 1000*(-b)), cv.Round(y0 - 1000*(a))) |
||||
cv.Line(color_dst, pt1, pt2, cv.RGB(255, 0, 0), 3, 8) |
||||
else: |
||||
lines = cv.HoughLines2(dst, storage, cv.CV_HOUGH_PROBABILISTIC, 1, pi / 180, 50, 50, 10) |
||||
for line in lines: |
||||
cv.Line(color_dst, line[0], line[1], cv.CV_RGB(255, 0, 0), 3, 8) |
||||
|
||||
cv.ShowImage("Source", src) |
||||
cv.ShowImage("Hough", color_dst) |
||||
|
||||
k = cv.WaitKey(0) % 0x100 |
||||
if k == ord(' '): |
||||
USE_STANDARD = not USE_STANDARD |
||||
if k == 27: |
||||
break |
||||
cv.DestroyAllWindows() |
||||
@ -1,69 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import urllib2 |
||||
import sys |
||||
import cv2.cv as cv |
||||
|
||||
class Sketcher: |
||||
def __init__(self, windowname, dests): |
||||
self.prev_pt = None |
||||
self.windowname = windowname |
||||
self.dests = dests |
||||
cv.SetMouseCallback(self.windowname, self.on_mouse) |
||||
|
||||
def on_mouse(self, event, x, y, flags, param): |
||||
pt = (x, y) |
||||
if event == cv.CV_EVENT_LBUTTONUP or not (flags & cv.CV_EVENT_FLAG_LBUTTON): |
||||
self.prev_pt = None |
||||
elif event == cv.CV_EVENT_LBUTTONDOWN: |
||||
self.prev_pt = pt |
||||
elif event == cv.CV_EVENT_MOUSEMOVE and (flags & cv.CV_EVENT_FLAG_LBUTTON) : |
||||
if self.prev_pt: |
||||
for dst in self.dests: |
||||
cv.Line(dst, self.prev_pt, pt, cv.ScalarAll(255), 5, 8, 0) |
||||
self.prev_pt = pt |
||||
cv.ShowImage(self.windowname, img) |
||||
|
||||
if __name__=="__main__": |
||||
if len(sys.argv) > 1: |
||||
img0 = cv.LoadImage( sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/fruits.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
img0 = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
print "Hot keys:" |
||||
print "\tESC - quit the program" |
||||
print "\tr - restore the original image" |
||||
print "\ti or ENTER - run inpainting algorithm" |
||||
print "\t\t(before running it, paint something on the image)" |
||||
|
||||
cv.NamedWindow("image", 1) |
||||
cv.NamedWindow("inpainted image", 1) |
||||
|
||||
img = cv.CloneImage(img0) |
||||
inpainted = cv.CloneImage(img0) |
||||
inpaint_mask = cv.CreateImage(cv.GetSize(img), 8, 1) |
||||
|
||||
cv.Zero(inpaint_mask) |
||||
cv.Zero(inpainted) |
||||
cv.ShowImage("image", img) |
||||
cv.ShowImage("inpainted image", inpainted) |
||||
|
||||
sk = Sketcher("image", [img, inpaint_mask]) |
||||
while True: |
||||
c = cv.WaitKey(0) % 0x100 |
||||
|
||||
if c == 27 or c == ord('q'): |
||||
break |
||||
|
||||
if c == ord('r'): |
||||
cv.Zero(inpaint_mask) |
||||
cv.Copy(img0, img) |
||||
cv.ShowImage("image", img) |
||||
|
||||
if c == ord('i') or c == ord('\n'): |
||||
cv.Inpaint(img, inpaint_mask, inpainted, 3, cv.CV_INPAINT_TELEA) |
||||
cv.ShowImage("inpainted image", inpainted) |
||||
cv.DestroyAllWindows() |
||||
@ -1,98 +0,0 @@ |
||||
#!/usr/bin/python |
||||
""" |
||||
Tracking of rotating point. |
||||
Rotation speed is constant. |
||||
Both state and measurements vectors are 1D (a point angle), |
||||
Measurement is the real point angle + gaussian noise. |
||||
The real and the estimated points are connected with yellow line segment, |
||||
the real and the measured points are connected with red line segment. |
||||
(if Kalman filter works correctly, |
||||
the yellow segment should be shorter than the red one). |
||||
Pressing any key (except ESC) will reset the tracking with a different speed. |
||||
Pressing ESC will stop the program. |
||||
""" |
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
from math import cos, sin, sqrt |
||||
import sys |
||||
|
||||
if __name__ == "__main__": |
||||
A = [ [1, 1], [0, 1] ] |
||||
|
||||
img = cv.CreateImage((500, 500), 8, 3) |
||||
kalman = cv.CreateKalman(2, 1, 0) |
||||
state = cv.CreateMat(2, 1, cv.CV_32FC1) # (phi, delta_phi) |
||||
process_noise = cv.CreateMat(2, 1, cv.CV_32FC1) |
||||
measurement = cv.CreateMat(1, 1, cv.CV_32FC1) |
||||
rng = cv.RNG(-1) |
||||
code = -1L |
||||
|
||||
cv.Zero(measurement) |
||||
cv.NamedWindow("Kalman", 1) |
||||
|
||||
while True: |
||||
cv.RandArr(rng, state, cv.CV_RAND_NORMAL, cv.RealScalar(0), cv.RealScalar(0.1)) |
||||
|
||||
kalman.transition_matrix[0,0] = 1 |
||||
kalman.transition_matrix[0,1] = 1 |
||||
kalman.transition_matrix[1,0] = 0 |
||||
kalman.transition_matrix[1,1] = 1 |
||||
|
||||
cv.SetIdentity(kalman.measurement_matrix, cv.RealScalar(1)) |
||||
cv.SetIdentity(kalman.process_noise_cov, cv.RealScalar(1e-5)) |
||||
cv.SetIdentity(kalman.measurement_noise_cov, cv.RealScalar(1e-1)) |
||||
cv.SetIdentity(kalman.error_cov_post, cv.RealScalar(1)) |
||||
cv.RandArr(rng, kalman.state_post, cv.CV_RAND_NORMAL, cv.RealScalar(0), cv.RealScalar(0.1)) |
||||
|
||||
|
||||
while True: |
||||
def calc_point(angle): |
||||
return (cv.Round(img.width/2 + img.width/3*cos(angle)), |
||||
cv.Round(img.height/2 - img.width/3*sin(angle))) |
||||
|
||||
state_angle = state[0,0] |
||||
state_pt = calc_point(state_angle) |
||||
|
||||
prediction = cv.KalmanPredict(kalman) |
||||
predict_angle = prediction[0, 0] |
||||
predict_pt = calc_point(predict_angle) |
||||
|
||||
cv.RandArr(rng, measurement, cv.CV_RAND_NORMAL, cv.RealScalar(0), |
||||
cv.RealScalar(sqrt(kalman.measurement_noise_cov[0, 0]))) |
||||
|
||||
# generate measurement |
||||
cv.MatMulAdd(kalman.measurement_matrix, state, measurement, measurement) |
||||
|
||||
measurement_angle = measurement[0, 0] |
||||
measurement_pt = calc_point(measurement_angle) |
||||
|
||||
# plot points |
||||
def draw_cross(center, color, d): |
||||
cv.Line(img, (center[0] - d, center[1] - d), |
||||
(center[0] + d, center[1] + d), color, 1, cv.CV_AA, 0) |
||||
cv.Line(img, (center[0] + d, center[1] - d), |
||||
(center[0] - d, center[1] + d), color, 1, cv.CV_AA, 0) |
||||
|
||||
cv.Zero(img) |
||||
draw_cross(state_pt, cv.CV_RGB(255, 255, 255), 3) |
||||
draw_cross(measurement_pt, cv.CV_RGB(255, 0,0), 3) |
||||
draw_cross(predict_pt, cv.CV_RGB(0, 255, 0), 3) |
||||
cv.Line(img, state_pt, measurement_pt, cv.CV_RGB(255, 0,0), 3, cv. CV_AA, 0) |
||||
cv.Line(img, state_pt, predict_pt, cv.CV_RGB(255, 255, 0), 3, cv. CV_AA, 0) |
||||
|
||||
cv.KalmanCorrect(kalman, measurement) |
||||
|
||||
cv.RandArr(rng, process_noise, cv.CV_RAND_NORMAL, cv.RealScalar(0), |
||||
cv.RealScalar(sqrt(kalman.process_noise_cov[0, 0]))) |
||||
cv.MatMulAdd(kalman.transition_matrix, state, process_noise, state) |
||||
|
||||
cv.ShowImage("Kalman", img) |
||||
|
||||
code = cv.WaitKey(100) % 0x100 |
||||
if code != -1: |
||||
break |
||||
|
||||
if code in [27, ord('q'), ord('Q')]: |
||||
break |
||||
|
||||
cv.DestroyWindow("Kalman") |
||||
@ -1,60 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
from random import randint |
||||
MAX_CLUSTERS = 5 |
||||
|
||||
if __name__ == "__main__": |
||||
|
||||
color_tab = [ |
||||
cv.CV_RGB(255, 0,0), |
||||
cv.CV_RGB(0, 255, 0), |
||||
cv.CV_RGB(100, 100, 255), |
||||
cv.CV_RGB(255, 0,255), |
||||
cv.CV_RGB(255, 255, 0)] |
||||
img = cv.CreateImage((500, 500), 8, 3) |
||||
rng = cv.RNG(-1) |
||||
|
||||
cv.NamedWindow("clusters", 1) |
||||
|
||||
while True: |
||||
cluster_count = randint(2, MAX_CLUSTERS) |
||||
sample_count = randint(1, 1000) |
||||
points = cv.CreateMat(sample_count, 1, cv.CV_32FC2) |
||||
clusters = cv.CreateMat(sample_count, 1, cv.CV_32SC1) |
||||
|
||||
# generate random sample from multigaussian distribution |
||||
for k in range(cluster_count): |
||||
center = (cv.RandInt(rng)%img.width, cv.RandInt(rng)%img.height) |
||||
first = k*sample_count/cluster_count |
||||
last = sample_count |
||||
if k != cluster_count: |
||||
last = (k+1)*sample_count/cluster_count |
||||
|
||||
point_chunk = cv.GetRows(points, first, last) |
||||
|
||||
cv.RandArr(rng, point_chunk, cv.CV_RAND_NORMAL, |
||||
cv.Scalar(center[0], center[1], 0, 0), |
||||
cv.Scalar(img.width*0.1, img.height*0.1, 0, 0)) |
||||
|
||||
|
||||
# shuffle samples |
||||
cv.RandShuffle(points, rng) |
||||
|
||||
cv.KMeans2(points, cluster_count, clusters, |
||||
(cv.CV_TERMCRIT_EPS + cv.CV_TERMCRIT_ITER, 10, 1.0)) |
||||
|
||||
cv.Zero(img) |
||||
|
||||
for i in range(sample_count): |
||||
cluster_idx = int(clusters[i, 0]) |
||||
pt = (cv.Round(points[i, 0][0]), cv.Round(points[i, 0][1])) |
||||
cv.Circle(img, pt, 2, color_tab[cluster_idx], cv.CV_FILLED, cv.CV_AA, 0) |
||||
|
||||
cv.ShowImage("clusters", img) |
||||
|
||||
key = cv.WaitKey(0) % 0x100 |
||||
if key in [27, ord('q'), ord('Q')]: |
||||
break |
||||
|
||||
cv.DestroyWindow("clusters") |
||||
@ -1,45 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
import sys |
||||
|
||||
if __name__ == "__main__": |
||||
laplace = None |
||||
colorlaplace = None |
||||
planes = [ None, None, None ] |
||||
capture = None |
||||
|
||||
if len(sys.argv) == 1: |
||||
capture = cv.CreateCameraCapture(0) |
||||
elif len(sys.argv) == 2 and sys.argv[1].isdigit(): |
||||
capture = cv.CreateCameraCapture(int(sys.argv[1])) |
||||
elif len(sys.argv) == 2: |
||||
capture = cv.CreateFileCapture(sys.argv[1]) |
||||
|
||||
if not capture: |
||||
print "Could not initialize capturing..." |
||||
sys.exit(-1) |
||||
|
||||
cv.NamedWindow("Laplacian", 1) |
||||
|
||||
while True: |
||||
frame = cv.QueryFrame(capture) |
||||
if frame: |
||||
if not laplace: |
||||
planes = [cv.CreateImage((frame.width, frame.height), 8, 1) for i in range(3)] |
||||
laplace = cv.CreateImage((frame.width, frame.height), cv.IPL_DEPTH_16S, 1) |
||||
colorlaplace = cv.CreateImage((frame.width, frame.height), 8, 3) |
||||
|
||||
cv.Split(frame, planes[0], planes[1], planes[2], None) |
||||
for plane in planes: |
||||
cv.Laplace(plane, laplace, 3) |
||||
cv.ConvertScaleAbs(laplace, plane, 1, 0) |
||||
|
||||
cv.Merge(planes[0], planes[1], planes[2], None, colorlaplace) |
||||
|
||||
cv.ShowImage("Laplacian", colorlaplace) |
||||
|
||||
if cv.WaitKey(10) != -1: |
||||
break |
||||
|
||||
cv.DestroyWindow("Laplacian") |
||||
@ -1,192 +0,0 @@ |
||||
#! /usr/bin/env python |
||||
|
||||
print "OpenCV Python version of lkdemo" |
||||
|
||||
import sys |
||||
|
||||
# import the necessary things for OpenCV |
||||
import cv2.cv as cv |
||||
|
||||
############################################################################# |
||||
# some "constants" |
||||
|
||||
win_size = 10 |
||||
MAX_COUNT = 500 |
||||
|
||||
############################################################################# |
||||
# some "global" variables |
||||
|
||||
image = None |
||||
pt = None |
||||
add_remove_pt = False |
||||
flags = 0 |
||||
night_mode = False |
||||
need_to_init = False |
||||
|
||||
############################################################################# |
||||
# the mouse callback |
||||
|
||||
# the callback on the trackbar |
||||
def on_mouse (event, x, y, flags, param): |
||||
|
||||
# we will use the global pt and add_remove_pt |
||||
global pt |
||||
global add_remove_pt |
||||
|
||||
if image is None: |
||||
# not initialized, so skip |
||||
return |
||||
|
||||
if image.origin != 0: |
||||
# different origin |
||||
y = image.height - y |
||||
|
||||
if event == cv.CV_EVENT_LBUTTONDOWN: |
||||
# user has click, so memorize it |
||||
pt = (x, y) |
||||
add_remove_pt = True |
||||
|
||||
############################################################################# |
||||
# so, here is the main part of the program |
||||
|
||||
if __name__ == '__main__': |
||||
|
||||
frames = sys.argv[1:] |
||||
if frames == []: |
||||
print "usage lkdemo.py <image files>" |
||||
sys.exit(1) |
||||
|
||||
# display a small howto use it |
||||
print "Hot keys: \n" \ |
||||
"\tESC - quit the program\n" \ |
||||
"\tr - auto-initialize tracking\n" \ |
||||
"\tc - delete all the points\n" \ |
||||
"\tn - switch the \"night\" mode on/off\n" \ |
||||
"\tSPACE - next frame\n" \ |
||||
"To add/remove a feature point click it\n" |
||||
|
||||
# first, create the necessary windows |
||||
cv.NamedWindow ('LkDemo', cv.CV_WINDOW_AUTOSIZE) |
||||
|
||||
# register the mouse callback |
||||
cv.SetMouseCallback ('LkDemo', on_mouse, None) |
||||
|
||||
fc = 0 |
||||
while 1: |
||||
# do forever |
||||
|
||||
frame = cv.LoadImage(frames[fc]) |
||||
|
||||
if image is None: |
||||
# create the images we need |
||||
image = cv.CreateImage (cv.GetSize (frame), 8, 3) |
||||
image.origin = frame.origin |
||||
grey = cv.CreateImage (cv.GetSize (frame), 8, 1) |
||||
prev_grey = cv.CreateImage (cv.GetSize (frame), 8, 1) |
||||
pyramid = cv.CreateImage (cv.GetSize (frame), 8, 1) |
||||
prev_pyramid = cv.CreateImage (cv.GetSize (frame), 8, 1) |
||||
features = [] |
||||
|
||||
# copy the frame, so we can draw on it |
||||
cv.Copy (frame, image) |
||||
|
||||
# create a grey version of the image |
||||
cv.CvtColor (image, grey, cv.CV_BGR2GRAY) |
||||
|
||||
if night_mode: |
||||
# night mode: only display the points |
||||
cv.SetZero (image) |
||||
|
||||
if need_to_init: |
||||
# we want to search all the good points |
||||
|
||||
# create the wanted images |
||||
eig = cv.CreateImage (cv.GetSize (grey), 32, 1) |
||||
temp = cv.CreateImage (cv.GetSize (grey), 32, 1) |
||||
|
||||
# the default parameters |
||||
quality = 0.01 |
||||
min_distance = 10 |
||||
|
||||
# search the good points |
||||
features = cv.GoodFeaturesToTrack ( |
||||
grey, eig, temp, |
||||
MAX_COUNT, |
||||
quality, min_distance, None, 3, 0, 0.04) |
||||
|
||||
# refine the corner locations |
||||
features = cv.FindCornerSubPix ( |
||||
grey, |
||||
features, |
||||
(win_size, win_size), (-1, -1), |
||||
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, 20, 0.03)) |
||||
|
||||
elif features != []: |
||||
# we have points, so display them |
||||
|
||||
# calculate the optical flow |
||||
features, status, track_error = cv.CalcOpticalFlowPyrLK ( |
||||
prev_grey, grey, prev_pyramid, pyramid, |
||||
features, |
||||
(win_size, win_size), 3, |
||||
(cv.CV_TERMCRIT_ITER|cv.CV_TERMCRIT_EPS, 20, 0.03), |
||||
flags) |
||||
|
||||
# set back the points we keep |
||||
features = [ p for (st,p) in zip(status, features) if st] |
||||
|
||||
if add_remove_pt: |
||||
# we have a point to add, so see if it is close to |
||||
# another one. If yes, don't use it |
||||
def ptptdist(p0, p1): |
||||
dx = p0[0] - p1[0] |
||||
dy = p0[1] - p1[1] |
||||
return dx**2 + dy**2 |
||||
if min([ ptptdist(pt, p) for p in features ]) < 25: |
||||
# too close |
||||
add_remove_pt = 0 |
||||
|
||||
# draw the points as green circles |
||||
for the_point in features: |
||||
cv.Circle (image, (int(the_point[0]), int(the_point[1])), 3, (0, 255, 0, 0), -1, 8, 0) |
||||
|
||||
if add_remove_pt: |
||||
# we want to add a point |
||||
# refine this corner location and append it to 'features' |
||||
|
||||
features += cv.FindCornerSubPix ( |
||||
grey, |
||||
[pt], |
||||
(win_size, win_size), (-1, -1), |
||||
(cv.CV_TERMCRIT_ITER | cv.CV_TERMCRIT_EPS, |
||||
20, 0.03)) |
||||
# we are no longer in "add_remove_pt" mode |
||||
add_remove_pt = False |
||||
|
||||
# swapping |
||||
prev_grey, grey = grey, prev_grey |
||||
prev_pyramid, pyramid = pyramid, prev_pyramid |
||||
need_to_init = False |
||||
|
||||
# we can now display the image |
||||
cv.ShowImage ('LkDemo', image) |
||||
|
||||
# handle events |
||||
c = cv.WaitKey(10) % 0x100 |
||||
|
||||
if c == 27: |
||||
# user has press the ESC key, so exit |
||||
break |
||||
|
||||
# processing depending on the character |
||||
if 32 <= c and c < 128: |
||||
cc = chr(c).lower() |
||||
if cc == 'r': |
||||
need_to_init = True |
||||
elif cc == 'c': |
||||
features = [] |
||||
elif cc == 'n': |
||||
night_mode = not night_mode |
||||
elif cc == ' ': |
||||
fc = (fc + 1) % len(frames) |
||||
cv.DestroyAllWindows() |
||||
@ -1,45 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import sys |
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
|
||||
src=None |
||||
dst=None |
||||
src2=None |
||||
|
||||
def on_mouse(event, x, y, flags, param): |
||||
|
||||
if not src: |
||||
return |
||||
|
||||
if event==cv.CV_EVENT_LBUTTONDOWN: |
||||
cv.LogPolar(src, dst, (x, y), 40, cv.CV_INTER_LINEAR + cv.CV_WARP_FILL_OUTLIERS) |
||||
cv.LogPolar(dst, src2, (x, y), 40, cv.CV_INTER_LINEAR + cv.CV_WARP_FILL_OUTLIERS + cv.CV_WARP_INVERSE_MAP) |
||||
cv.ShowImage("log-polar", dst) |
||||
cv.ShowImage("inverse log-polar", src2) |
||||
|
||||
if __name__ == "__main__": |
||||
|
||||
if len(sys.argv) > 1: |
||||
src = cv.LoadImage( sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/fruits.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
src = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
cv.NamedWindow("original", 1) |
||||
cv.NamedWindow("log-polar", 1) |
||||
cv.NamedWindow("inverse log-polar", 1) |
||||
|
||||
|
||||
dst = cv.CreateImage((256, 256), 8, 3) |
||||
src2 = cv.CreateImage(cv.GetSize(src), 8, 3) |
||||
|
||||
cv.SetMouseCallback("original", on_mouse) |
||||
on_mouse(cv.CV_EVENT_LBUTTONDOWN, src.width/2, src.height/2, None, None) |
||||
|
||||
cv.ShowImage("original", src) |
||||
cv.WaitKey() |
||||
cv.DestroyAllWindows() |
||||
@ -1,62 +0,0 @@ |
||||
#!/usr/bin/python |
||||
|
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
from random import randint |
||||
|
||||
def roundxy(pt): |
||||
return (cv.Round(pt[0]), cv.Round(pt[1])) |
||||
|
||||
def draw_common(points): |
||||
success, center, radius = cv.MinEnclosingCircle(points) |
||||
if success: |
||||
cv.Circle(img, roundxy(center), cv.Round(radius), cv.CV_RGB(255, 255, 0), 1, cv. CV_AA, 0) |
||||
|
||||
box = cv.MinAreaRect2(points) |
||||
box_vtx = [roundxy(p) for p in cv.BoxPoints(box)] |
||||
cv.PolyLine(img, [box_vtx], 1, cv.CV_RGB(0, 255, 255), 1, cv. CV_AA) |
||||
|
||||
def minarea_array(img, count): |
||||
pointMat = cv.CreateMat(count, 1, cv.CV_32SC2) |
||||
for i in range(count): |
||||
pointMat[i, 0] = (randint(img.width/4, img.width*3/4), |
||||
randint(img.height/4, img.height*3/4)) |
||||
|
||||
cv.Zero(img) |
||||
|
||||
for i in range(count): |
||||
cv.Circle(img, roundxy(pointMat[i, 0]), 2, cv.CV_RGB(255, 0, 0), cv.CV_FILLED, cv. CV_AA, 0) |
||||
|
||||
draw_common(pointMat) |
||||
|
||||
def minarea_seq(img, count, storage): |
||||
points = [(randint(img.width/4, img.width*3/4), randint(img.height/4, img.height*3/4)) for i in range(count)] |
||||
cv.Zero(img) |
||||
|
||||
for p in points: |
||||
cv.Circle(img, roundxy(p), 2, cv.CV_RGB(255, 0, 0), cv.CV_FILLED, cv. CV_AA, 0) |
||||
|
||||
draw_common(points) |
||||
|
||||
if __name__ == "__main__": |
||||
img = cv.CreateImage((500, 500), 8, 3) |
||||
storage = cv.CreateMemStorage() |
||||
|
||||
cv.NamedWindow("rect & circle", 1) |
||||
|
||||
use_seq = True |
||||
|
||||
while True: |
||||
count = randint(1, 100) |
||||
if use_seq: |
||||
minarea_seq(img, count, storage) |
||||
else: |
||||
minarea_array(img, count) |
||||
|
||||
cv.ShowImage("rect & circle", img) |
||||
key = cv.WaitKey() % 0x100 |
||||
if key in [27, ord('q'), ord('Q')]: |
||||
break |
||||
|
||||
use_seq = not use_seq |
||||
cv.DestroyAllWindows() |
||||
@ -1,13 +0,0 @@ |
||||
#! /usr/bin/env python |
||||
|
||||
import cv2.cv as cv |
||||
|
||||
cap = cv.CreateFileCapture("../c/tree.avi") |
||||
img = cv.QueryFrame(cap) |
||||
print "Got frame of dimensions (", img.width, " x ", img.height, ")" |
||||
|
||||
cv.NamedWindow("win", cv.CV_WINDOW_AUTOSIZE) |
||||
cv.ShowImage("win", img) |
||||
cv.MoveWindow("win", 200, 200) |
||||
cv.WaitKey(0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,52 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import sys |
||||
import urllib2 |
||||
import cv2.cv as cv |
||||
|
||||
src = 0 |
||||
image = 0 |
||||
dest = 0 |
||||
element_shape = cv.CV_SHAPE_RECT |
||||
|
||||
def Opening(pos): |
||||
element = cv.CreateStructuringElementEx(pos*2+1, pos*2+1, pos, pos, element_shape) |
||||
cv.Erode(src, image, element, 1) |
||||
cv.Dilate(image, dest, element, 1) |
||||
cv.ShowImage("Opening & Closing", dest) |
||||
def Closing(pos): |
||||
element = cv.CreateStructuringElementEx(pos*2+1, pos*2+1, pos, pos, element_shape) |
||||
cv.Dilate(src, image, element, 1) |
||||
cv.Erode(image, dest, element, 1) |
||||
cv.ShowImage("Opening & Closing", dest) |
||||
def Erosion(pos): |
||||
element = cv.CreateStructuringElementEx(pos*2+1, pos*2+1, pos, pos, element_shape) |
||||
cv.Erode(src, dest, element, 1) |
||||
cv.ShowImage("Erosion & Dilation", dest) |
||||
def Dilation(pos): |
||||
element = cv.CreateStructuringElementEx(pos*2+1, pos*2+1, pos, pos, element_shape) |
||||
cv.Dilate(src, dest, element, 1) |
||||
cv.ShowImage("Erosion & Dilation", dest) |
||||
|
||||
if __name__ == "__main__": |
||||
if len(sys.argv) > 1: |
||||
src = cv.LoadImage(sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/fruits.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
src = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
image = cv.CloneImage(src) |
||||
dest = cv.CloneImage(src) |
||||
cv.NamedWindow("Opening & Closing", 1) |
||||
cv.NamedWindow("Erosion & Dilation", 1) |
||||
cv.ShowImage("Opening & Closing", src) |
||||
cv.ShowImage("Erosion & Dilation", src) |
||||
cv.CreateTrackbar("Open", "Opening & Closing", 0, 10, Opening) |
||||
cv.CreateTrackbar("Close", "Opening & Closing", 0, 10, Closing) |
||||
cv.CreateTrackbar("Dilate", "Erosion & Dilation", 0, 10, Dilation) |
||||
cv.CreateTrackbar("Erode", "Erosion & Dilation", 0, 10, Erosion) |
||||
cv.WaitKey(0) |
||||
cv.DestroyWindow("Opening & Closing") |
||||
cv.DestroyWindow("Erosion & Dilation") |
||||
@ -1,110 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import urllib2 |
||||
import sys |
||||
import time |
||||
from math import cos, sin |
||||
import cv2.cv as cv |
||||
|
||||
CLOCKS_PER_SEC = 1.0 |
||||
MHI_DURATION = 1 |
||||
MAX_TIME_DELTA = 0.5 |
||||
MIN_TIME_DELTA = 0.05 |
||||
N = 4 |
||||
buf = range(10) |
||||
last = 0 |
||||
mhi = None # MHI |
||||
orient = None # orientation |
||||
mask = None # valid orientation mask |
||||
segmask = None # motion segmentation map |
||||
storage = None # temporary storage |
||||
|
||||
def update_mhi(img, dst, diff_threshold): |
||||
global last |
||||
global mhi |
||||
global storage |
||||
global mask |
||||
global orient |
||||
global segmask |
||||
timestamp = time.clock() / CLOCKS_PER_SEC # get current time in seconds |
||||
size = cv.GetSize(img) # get current frame size |
||||
idx1 = last |
||||
if not mhi or cv.GetSize(mhi) != size: |
||||
for i in range(N): |
||||
buf[i] = cv.CreateImage(size, cv.IPL_DEPTH_8U, 1) |
||||
cv.Zero(buf[i]) |
||||
mhi = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1) |
||||
cv.Zero(mhi) # clear MHI at the beginning |
||||
orient = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1) |
||||
segmask = cv.CreateImage(size,cv. IPL_DEPTH_32F, 1) |
||||
mask = cv.CreateImage(size,cv. IPL_DEPTH_8U, 1) |
||||
|
||||
cv.CvtColor(img, buf[last], cv.CV_BGR2GRAY) # convert frame to grayscale |
||||
idx2 = (last + 1) % N # index of (last - (N-1))th frame |
||||
last = idx2 |
||||
silh = buf[idx2] |
||||
cv.AbsDiff(buf[idx1], buf[idx2], silh) # get difference between frames |
||||
cv.Threshold(silh, silh, diff_threshold, 1, cv.CV_THRESH_BINARY) # and threshold it |
||||
cv.UpdateMotionHistory(silh, mhi, timestamp, MHI_DURATION) # update MHI |
||||
cv.CvtScale(mhi, mask, 255./MHI_DURATION, |
||||
(MHI_DURATION - timestamp)*255./MHI_DURATION) |
||||
cv.Zero(dst) |
||||
cv.Merge(mask, None, None, None, dst) |
||||
cv.CalcMotionGradient(mhi, mask, orient, MAX_TIME_DELTA, MIN_TIME_DELTA, 3) |
||||
if not storage: |
||||
storage = cv.CreateMemStorage(0) |
||||
seq = cv.SegmentMotion(mhi, segmask, storage, timestamp, MAX_TIME_DELTA) |
||||
for (area, value, comp_rect) in seq: |
||||
if comp_rect[2] + comp_rect[3] > 100: # reject very small components |
||||
color = cv.CV_RGB(255, 0,0) |
||||
silh_roi = cv.GetSubRect(silh, comp_rect) |
||||
mhi_roi = cv.GetSubRect(mhi, comp_rect) |
||||
orient_roi = cv.GetSubRect(orient, comp_rect) |
||||
mask_roi = cv.GetSubRect(mask, comp_rect) |
||||
angle = 360 - cv.CalcGlobalOrientation(orient_roi, mask_roi, mhi_roi, timestamp, MHI_DURATION) |
||||
|
||||
count = cv.Norm(silh_roi, None, cv.CV_L1, None) # calculate number of points within silhouette ROI |
||||
if count < (comp_rect[2] * comp_rect[3] * 0.05): |
||||
continue |
||||
|
||||
magnitude = 30. |
||||
center = ((comp_rect[0] + comp_rect[2] / 2), (comp_rect[1] + comp_rect[3] / 2)) |
||||
cv.Circle(dst, center, cv.Round(magnitude*1.2), color, 3, cv.CV_AA, 0) |
||||
cv.Line(dst, |
||||
center, |
||||
(cv.Round(center[0] + magnitude * cos(angle * cv.CV_PI / 180)), |
||||
cv.Round(center[1] - magnitude * sin(angle * cv.CV_PI / 180))), |
||||
color, |
||||
3, |
||||
cv.CV_AA, |
||||
0) |
||||
|
||||
if __name__ == "__main__": |
||||
motion = 0 |
||||
capture = 0 |
||||
|
||||
if len(sys.argv)==1: |
||||
capture = cv.CreateCameraCapture(0) |
||||
elif len(sys.argv)==2 and sys.argv[1].isdigit(): |
||||
capture = cv.CreateCameraCapture(int(sys.argv[1])) |
||||
elif len(sys.argv)==2: |
||||
capture = cv.CreateFileCapture(sys.argv[1]) |
||||
|
||||
if not capture: |
||||
print "Could not initialize capturing..." |
||||
sys.exit(-1) |
||||
|
||||
cv.NamedWindow("Motion", 1) |
||||
while True: |
||||
image = cv.QueryFrame(capture) |
||||
if(image): |
||||
if(not motion): |
||||
motion = cv.CreateImage((image.width, image.height), 8, 3) |
||||
cv.Zero(motion) |
||||
#motion.origin = image.origin |
||||
update_mhi(image, motion, 30) |
||||
cv.ShowImage("Motion", motion) |
||||
if(cv.WaitKey(10) != -1): |
||||
break |
||||
else: |
||||
break |
||||
cv.DestroyWindow("Motion") |
||||
@ -1,66 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import urllib2 |
||||
import sys |
||||
import cv2.cv as cv |
||||
import numpy |
||||
|
||||
# SRGB-linear conversions using NumPy - see http://en.wikipedia.org/wiki/SRGB |
||||
|
||||
def srgb2lin(x): |
||||
a = 0.055 |
||||
return numpy.where(x <= 0.04045, |
||||
x * (1.0 / 12.92), |
||||
numpy.power((x + a) * (1.0 / (1 + a)), 2.4)) |
||||
|
||||
def lin2srgb(x): |
||||
a = 0.055 |
||||
return numpy.where(x <= 0.0031308, |
||||
x * 12.92, |
||||
(1 + a) * numpy.power(x, 1 / 2.4) - a) |
||||
|
||||
if __name__ == "__main__": |
||||
if len(sys.argv) > 1: |
||||
img0 = cv.LoadImageM( sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/lena.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
img0 = cv.DecodeImageM(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
cv.NamedWindow("original", 1) |
||||
cv.ShowImage("original", img0) |
||||
|
||||
# Image was originally bytes in range 0-255. Turn it into an array of floats in range 0.0 - 1.0 |
||||
n = numpy.asarray(img0) / 255.0 |
||||
|
||||
# Use NumPy to do some transformations on the image |
||||
|
||||
# Negate the image by subtracting it from 1.0 |
||||
cv.NamedWindow("negative") |
||||
cv.ShowImage("negative", cv.fromarray(1.0 - n)) |
||||
|
||||
# Assume the image was sRGB, and compute the linear version. |
||||
cv.NamedWindow("linear") |
||||
cv.ShowImage("linear", cv.fromarray(srgb2lin(n))) |
||||
|
||||
# Look at a subwindow |
||||
cv.NamedWindow("subwindow") |
||||
cv.ShowImage("subwindow", cv.fromarray(n[200:300,200:400])) |
||||
|
||||
# Compute the grayscale image |
||||
cv.NamedWindow("monochrome") |
||||
ln = srgb2lin(n) |
||||
red = ln[:,:,0] |
||||
grn = ln[:,:,1] |
||||
blu = ln[:,:,2] |
||||
linear_mono = 0.3 * red + 0.59 * grn + 0.11 * blu |
||||
cv.ShowImage("monochrome", cv.fromarray(lin2srgb(linear_mono))) |
||||
|
||||
# Apply a blur to the NumPy array using OpenCV |
||||
cv.NamedWindow("gaussian") |
||||
cv.Smooth(n, n, cv.CV_GAUSSIAN, 15, 15) |
||||
cv.ShowImage("gaussian", cv.fromarray(n)) |
||||
|
||||
cv.WaitKey(0) |
||||
cv.DestroyAllWindows() |
||||
@ -1,48 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import urllib2 |
||||
import sys |
||||
import cv2.cv as cv |
||||
import numpy |
||||
|
||||
if __name__ == "__main__": |
||||
cv.NamedWindow("camera", 1) |
||||
|
||||
capture = cv.CaptureFromCAM(0) |
||||
|
||||
paste = cv.CreateMat(960, 1280, cv.CV_8UC3) |
||||
topleft = numpy.asarray(cv.GetSubRect(paste, (0, 0, 640, 480))) |
||||
topright = numpy.asarray(cv.GetSubRect(paste, (640, 0, 640, 480))) |
||||
bottomleft = numpy.asarray(cv.GetSubRect(paste, (0, 480, 640, 480))) |
||||
bottomright = numpy.asarray(cv.GetSubRect(paste, (640, 480, 640, 480))) |
||||
|
||||
while True: |
||||
img = cv.GetMat(cv.QueryFrame(capture)) |
||||
|
||||
n = (numpy.asarray(img)).astype(numpy.uint8) |
||||
|
||||
red = n[:,:,0] |
||||
grn = n[:,:,1] |
||||
blu = n[:,:,2] |
||||
|
||||
topleft[:,:,0] = 255 - grn |
||||
topleft[:,:,1] = red |
||||
topleft[:,:,2] = blu |
||||
|
||||
topright[:,:,0] = blu |
||||
topright[:,:,1] = 255 - red |
||||
topright[:,:,2] = grn |
||||
|
||||
bottomright[:,:,0] = red |
||||
bottomright[:,:,1] = grn |
||||
bottomright[:,:,2] = 255 - blu |
||||
|
||||
fgrn = grn.astype(numpy.float32) |
||||
fred = red.astype(numpy.float32) |
||||
bottomleft[:,:,0] = blu |
||||
bottomleft[:,:,1] = (abs(fgrn - fred)).astype(numpy.uint8) |
||||
bottomleft[:,:,2] = red |
||||
|
||||
cv.ShowImage("camera", paste) |
||||
if cv.WaitKey(6) == 27: |
||||
break |
||||
cv.DestroyAllWindows() |
||||
@ -1,56 +0,0 @@ |
||||
#!/usr/bin/python |
||||
|
||||
import sys |
||||
from cv import * |
||||
|
||||
def inside(r, q): |
||||
(rx, ry), (rw, rh) = r |
||||
(qx, qy), (qw, qh) = q |
||||
return rx > qx and ry > qy and rx + rw < qx + qw and ry + rh < qy + qh |
||||
|
||||
try: |
||||
img = LoadImage(sys.argv[1]) |
||||
except: |
||||
try: |
||||
f = open(sys.argv[1], "rt") |
||||
except: |
||||
print "cannot read " + sys.argv[1] |
||||
sys.exit(-1) |
||||
imglist = list(f.readlines()) |
||||
else: |
||||
imglist = [sys.argv[1]] |
||||
|
||||
NamedWindow("people detection demo", 1) |
||||
storage = CreateMemStorage(0) |
||||
|
||||
for name in imglist: |
||||
n = name.strip() |
||||
print n |
||||
try: |
||||
img = LoadImage(n) |
||||
except: |
||||
continue |
||||
|
||||
#ClearMemStorage(storage) |
||||
found = list(HOGDetectMultiScale(img, storage, win_stride=(8,8), |
||||
padding=(32,32), scale=1.05, group_threshold=2)) |
||||
found_filtered = [] |
||||
for r in found: |
||||
insidef = False |
||||
for q in found: |
||||
if inside(r, q): |
||||
insidef = True |
||||
break |
||||
if not insidef: |
||||
found_filtered.append(r) |
||||
for r in found_filtered: |
||||
(rx, ry), (rw, rh) = r |
||||
tl = (rx + int(rw*0.1), ry + int(rh*0.07)) |
||||
br = (rx + int(rw*0.9), ry + int(rh*0.87)) |
||||
Rectangle(img, tl, br, (0, 255, 0), 3) |
||||
|
||||
ShowImage("people detection demo", img) |
||||
c = WaitKey(0) |
||||
if c == ord('q'): |
||||
break |
||||
cv.DestroyAllWindows() |
||||
@ -1,41 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import cv2.cv as cv |
||||
|
||||
class PyrSegmentation: |
||||
def __init__(self, img0): |
||||
self.thresh1 = 255 |
||||
self.thresh2 = 30 |
||||
self.level =4 |
||||
self.storage = cv.CreateMemStorage() |
||||
cv.NamedWindow("Source", 0) |
||||
cv.ShowImage("Source", img0) |
||||
cv.NamedWindow("Segmentation", 0) |
||||
cv.CreateTrackbar("Thresh1", "Segmentation", self.thresh1, 255, self.set_thresh1) |
||||
cv.CreateTrackbar("Thresh2", "Segmentation", self.thresh2, 255, self.set_thresh2) |
||||
self.image0 = cv.CloneImage(img0) |
||||
self.image1 = cv.CloneImage(img0) |
||||
cv.ShowImage("Segmentation", self.image1) |
||||
|
||||
def set_thresh1(self, val): |
||||
self.thresh1 = val |
||||
self.on_segment() |
||||
|
||||
def set_thresh2(self, val): |
||||
self.thresh2 = val |
||||
self.on_segment() |
||||
|
||||
def on_segment(self): |
||||
comp = cv.PyrSegmentation(self.image0, self.image1, self.storage, \ |
||||
self.level, self.thresh1+1, self.thresh2+1) |
||||
cv.ShowImage("Segmentation", self.image1) |
||||
|
||||
def run(self): |
||||
self.on_segment() |
||||
cv.WaitKey(0) |
||||
|
||||
if __name__ == "__main__": |
||||
img0 = cv.LoadImage("../c/fruits.jpg", 1) |
||||
|
||||
# segmentation of the color image |
||||
PyrSegmentation(img0).run() |
||||
cv.DestroyAllWindows() |
||||
@ -1,153 +0,0 @@ |
||||
#!/usr/bin/python |
||||
# |
||||
# The full "Square Detector" program. |
||||
# It loads several images subsequentally and tries to find squares in |
||||
# each image |
||||
# |
||||
|
||||
import urllib2 |
||||
from math import sqrt |
||||
import cv2.cv as cv |
||||
|
||||
thresh = 50 |
||||
img = None |
||||
img0 = None |
||||
storage = None |
||||
wndname = "Square Detection Demo" |
||||
|
||||
def angle(pt1, pt2, pt0): |
||||
dx1 = pt1.x - pt0.x |
||||
dy1 = pt1.y - pt0.y |
||||
dx2 = pt2.x - pt0.x |
||||
dy2 = pt2.y - pt0.y |
||||
return (dx1*dx2 + dy1*dy2)/sqrt((dx1*dx1 + dy1*dy1)*(dx2*dx2 + dy2*dy2) + 1e-10) |
||||
|
||||
def findSquares4(img, storage): |
||||
N = 11 |
||||
sz = (img.width & -2, img.height & -2) |
||||
timg = cv.CloneImage(img); # make a copy of input image |
||||
gray = cv.CreateImage(sz, 8, 1) |
||||
pyr = cv.CreateImage((sz.width/2, sz.height/2), 8, 3) |
||||
# create empty sequence that will contain points - |
||||
# 4 points per square (the square's vertices) |
||||
squares = cv.CreateSeq(0, sizeof_CvSeq, sizeof_CvPoint, storage) |
||||
squares = CvSeq_CvPoint.cast(squares) |
||||
|
||||
# select the maximum ROI in the image |
||||
# with the width and height divisible by 2 |
||||
subimage = cv.GetSubRect(timg, cv.Rect(0, 0, sz.width, sz.height)) |
||||
|
||||
# down-scale and upscale the image to filter out the noise |
||||
cv.PyrDown(subimage, pyr, 7) |
||||
cv.PyrUp(pyr, subimage, 7) |
||||
tgray = cv.CreateImage(sz, 8, 1) |
||||
# find squares in every color plane of the image |
||||
for c in range(3): |
||||
# extract the c-th color plane |
||||
channels = [None, None, None] |
||||
channels[c] = tgray |
||||
cv.Split(subimage, channels[0], channels[1], channels[2], None) |
||||
for l in range(N): |
||||
# hack: use Canny instead of zero threshold level. |
||||
# Canny helps to catch squares with gradient shading |
||||
if(l == 0): |
||||
# apply Canny. Take the upper threshold from slider |
||||
# and set the lower to 0 (which forces edges merging) |
||||
cv.Canny(tgray, gray, 0, thresh, 5) |
||||
# dilate canny output to remove potential |
||||
# holes between edge segments |
||||
cv.Dilate(gray, gray, None, 1) |
||||
else: |
||||
# apply threshold if l!=0: |
||||
# tgray(x, y) = gray(x, y) < (l+1)*255/N ? 255 : 0 |
||||
cv.Threshold(tgray, gray, (l+1)*255/N, 255, cv.CV_THRESH_BINARY) |
||||
|
||||
# find contours and store them all as a list |
||||
count, contours = cv.FindContours(gray, storage, sizeof_CvContour, |
||||
cv.CV_RETR_LIST, cv. CV_CHAIN_APPROX_SIMPLE, (0, 0)) |
||||
|
||||
if not contours: |
||||
continue |
||||
|
||||
# test each contour |
||||
for contour in contours.hrange(): |
||||
# approximate contour with accuracy proportional |
||||
# to the contour perimeter |
||||
result = cv.ApproxPoly(contour, sizeof_CvContour, storage, |
||||
cv.CV_POLY_APPROX_DP, cv.ContourPerimeter(contours)*0.02, 0) |
||||
# square contours should have 4 vertices after approximation |
||||
# relatively large area (to filter out noisy contours) |
||||
# and be convex. |
||||
# Note: absolute value of an area is used because |
||||
# area may be positive or negative - in accordance with the |
||||
# contour orientation |
||||
if(result.total == 4 and |
||||
abs(cv.ContourArea(result)) > 1000 and |
||||
cv.CheckContourConvexity(result)): |
||||
s = 0 |
||||
for i in range(5): |
||||
# find minimum angle between joint |
||||
# edges (maximum of cosine) |
||||
if(i >= 2): |
||||
t = abs(angle(result[i], result[i-2], result[i-1])) |
||||
if s<t: |
||||
s=t |
||||
# if cosines of all angles are small |
||||
# (all angles are ~90 degree) then write quandrange |
||||
# vertices to resultant sequence |
||||
if(s < 0.3): |
||||
for i in range(4): |
||||
squares.append(result[i]) |
||||
|
||||
return squares |
||||
|
||||
# the function draws all the squares in the image |
||||
def drawSquares(img, squares): |
||||
cpy = cv.CloneImage(img) |
||||
# read 4 sequence elements at a time (all vertices of a square) |
||||
i=0 |
||||
while i<squares.total: |
||||
pt = [] |
||||
# read 4 vertices |
||||
pt.append(squares[i]) |
||||
pt.append(squares[i+1]) |
||||
pt.append(squares[i+2]) |
||||
pt.append(squares[i+3]) |
||||
|
||||
# draw the square as a closed polyline |
||||
cv.PolyLine(cpy, [pt], 1, cv.CV_RGB(0, 255, 0), 3, cv. CV_AA, 0) |
||||
i+=4 |
||||
|
||||
# show the resultant image |
||||
cv.ShowImage(wndname, cpy) |
||||
|
||||
def on_trackbar(a): |
||||
if(img): |
||||
drawSquares(img, findSquares4(img, storage)) |
||||
|
||||
names = ["../c/pic1.png", "../c/pic2.png", "../c/pic3.png", |
||||
"../c/pic4.png", "../c/pic5.png", "../c/pic6.png" ] |
||||
|
||||
if __name__ == "__main__": |
||||
# create memory storage that will contain all the dynamic data |
||||
storage = cv.CreateMemStorage(0) |
||||
for name in names: |
||||
img0 = cv.LoadImage(name, 1) |
||||
if not img0: |
||||
print "Couldn't load %s" % name |
||||
continue |
||||
img = cv.CloneImage(img0) |
||||
# create window and a trackbar (slider) with parent "image" and set callback |
||||
# (the slider regulates upper threshold, passed to Canny edge detector) |
||||
cv.NamedWindow(wndname, 1) |
||||
cv.CreateTrackbar("canny thresh", wndname, thresh, 1000, on_trackbar) |
||||
# force the image processing |
||||
on_trackbar(0) |
||||
# wait for key. |
||||
# Also the function cv.WaitKey takes care of event processing |
||||
c = cv.WaitKey(0) % 0x100 |
||||
# clear memory storage - reset free space position |
||||
cv.ClearMemStorage(storage) |
||||
if(c == '\x1b'): |
||||
break |
||||
cv.DestroyWindow(wndname) |
||||
@ -1,109 +0,0 @@ |
||||
#!/usr/bin/python |
||||
import urllib2 |
||||
import sys |
||||
import cv2.cv as cv |
||||
|
||||
class Sketcher: |
||||
def __init__(self, windowname, dests): |
||||
self.prev_pt = None |
||||
self.windowname = windowname |
||||
self.dests = dests |
||||
cv.SetMouseCallback(self.windowname, self.on_mouse) |
||||
|
||||
def on_mouse(self, event, x, y, flags, param): |
||||
pt = (x, y) |
||||
if event == cv.CV_EVENT_LBUTTONUP or not (flags & cv.CV_EVENT_FLAG_LBUTTON): |
||||
self.prev_pt = None |
||||
elif event == cv.CV_EVENT_LBUTTONDOWN: |
||||
self.prev_pt = pt |
||||
elif event == cv.CV_EVENT_MOUSEMOVE and (flags & cv.CV_EVENT_FLAG_LBUTTON) : |
||||
if self.prev_pt: |
||||
for dst in self.dests: |
||||
cv.Line(dst, self.prev_pt, pt, cv.ScalarAll(255), 5, 8, 0) |
||||
self.prev_pt = pt |
||||
cv.ShowImage(self.windowname, img) |
||||
|
||||
if __name__ == "__main__": |
||||
if len(sys.argv) > 1: |
||||
img0 = cv.LoadImage( sys.argv[1], cv.CV_LOAD_IMAGE_COLOR) |
||||
else: |
||||
url = 'http://code.opencv.org/projects/opencv/repository/revisions/master/raw/samples/c/fruits.jpg' |
||||
filedata = urllib2.urlopen(url).read() |
||||
imagefiledata = cv.CreateMatHeader(1, len(filedata), cv.CV_8UC1) |
||||
cv.SetData(imagefiledata, filedata, len(filedata)) |
||||
img0 = cv.DecodeImage(imagefiledata, cv.CV_LOAD_IMAGE_COLOR) |
||||
|
||||
rng = cv.RNG(-1) |
||||
|
||||
print "Hot keys:" |
||||
print "\tESC - quit the program" |
||||
print "\tr - restore the original image" |
||||
print "\tw - run watershed algorithm" |
||||
print "\t (before that, roughly outline several markers on the image)" |
||||
|
||||
cv.NamedWindow("image", 1) |
||||
cv.NamedWindow("watershed transform", 1) |
||||
|
||||
img = cv.CloneImage(img0) |
||||
img_gray = cv.CloneImage(img0) |
||||
wshed = cv.CloneImage(img0) |
||||
marker_mask = cv.CreateImage(cv.GetSize(img), 8, 1) |
||||
markers = cv.CreateImage(cv.GetSize(img), cv.IPL_DEPTH_32S, 1) |
||||
|
||||
cv.CvtColor(img, marker_mask, cv.CV_BGR2GRAY) |
||||
cv.CvtColor(marker_mask, img_gray, cv.CV_GRAY2BGR) |
||||
|
||||
cv.Zero(marker_mask) |
||||
cv.Zero(wshed) |
||||
|
||||
cv.ShowImage("image", img) |
||||
cv.ShowImage("watershed transform", wshed) |
||||
|
||||
sk = Sketcher("image", [img, marker_mask]) |
||||
|
||||
while True: |
||||
c = cv.WaitKey(0) % 0x100 |
||||
if c == 27 or c == ord('q'): |
||||
break |
||||
if c == ord('r'): |
||||
cv.Zero(marker_mask) |
||||
cv.Copy(img0, img) |
||||
cv.ShowImage("image", img) |
||||
if c == ord('w'): |
||||
storage = cv.CreateMemStorage(0) |
||||
#cv.SaveImage("wshed_mask.png", marker_mask) |
||||
#marker_mask = cv.LoadImage("wshed_mask.png", 0) |
||||
contours = cv.FindContours(marker_mask, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE) |
||||
def contour_iterator(contour): |
||||
while contour: |
||||
yield contour |
||||
contour = contour.h_next() |
||||
|
||||
cv.Zero(markers) |
||||
comp_count = 0 |
||||
for c in contour_iterator(contours): |
||||
cv.DrawContours(markers, |
||||
c, |
||||
cv.ScalarAll(comp_count + 1), |
||||
cv.ScalarAll(comp_count + 1), |
||||
-1, |
||||
-1, |
||||
8) |
||||
comp_count += 1 |
||||
|
||||
cv.Watershed(img0, markers) |
||||
|
||||
cv.Set(wshed, cv.ScalarAll(255)) |
||||
|
||||
# paint the watershed image |
||||
color_tab = [(cv.RandInt(rng) % 180 + 50, cv.RandInt(rng) % 180 + 50, cv.RandInt(rng) % 180 + 50) for i in range(comp_count)] |
||||
for j in range(markers.height): |
||||
for i in range(markers.width): |
||||
idx = markers[j, i] |
||||
if idx != -1: |
||||
wshed[j, i] = color_tab[int(idx - 1)] |
||||
|
||||
cv.AddWeighted(wshed, 0.5, img_gray, 0.5, 0, wshed) |
||||
cv.ShowImage("watershed transform", wshed) |
||||
cv.DestroyAllWindows() |
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue