Python C++扩展

biduw

　　Python C++扩展
　　前段时间看了一篇文章，http://blog.jobbole.com/78859/， 颇有感触，于是就结合自己工作中的知识作了一个简单的Python移动侦测：移动侦测的算法使用C++实现，封装成Python可以调用的格式，具体流程如图1。

　　图1
　　首先看一下C++的工程配置，如图2
     
　　图2
　　C++部分代码：
　　#include "stdafx.h"
#include "Python.h"
#include "C:\Python27\Lib\site-packages\numpy\core\include\numpy\arrayobject.h"
#include "motiondetector.h"
　　static int MD_GRID_W      = 32;
static int MD_GRID_H      = 32;
static int MD_NOISE_LEVEL = 150;
static int MD_SENSITIVITY = 150;
　　class VideoDetector
{
public:
~VideoDetector()
{
  if (m_motionDetector != NULL)
  {
   delete m_motionDetector;
   m_motionDetector = NULL;
   printf("~VideoDetector\r\n");
  }
}
VideoDetector(int width, int height):m_width(width), m_height(height)
{
        m_motionDetector = new simple_md::MotionDetector();
  if (m_motionDetector != NULL)
  {
      m_motionDetector->init(MD_GRID_W, MD_GRID_H, m_width, height);
   m_motionDetector->set_noise_level(MD_NOISE_LEVEL);
   m_motionDetector->set_sensitivity(MD_SENSITIVITY);
　　// Setup default zone
   std::vector<simple_md::Zone> zones;
   simple_md::Zone z;
   z.sensitivity = 100;
　　for (int i = 0; i < MD_GRID_W * MD_GRID_H; ++i)
   {
    z.mask.push_back(100);
   }
　　zones.push_back(z);
   m_motionDetector->set_zones(zones);
   m_motionDetector->set_md_enbale();
         printf("VideoDetector\r\n");
  }
}
　　int process_frame(uint8_t *frame)
{
  
  if (m_motionDetector != NULL && frame != NULL)
  {
　　m_motionDetector->feed_frame(frame, m_width, m_height, m_width - 1, GetTickCount(), NULL, 0, NULL, 0, NULL, 0);
   return m_motionDetector->get_state();
  }
  return 0;
}
　　int test(void)
{
  return m_width * m_height;
}
private:
VideoDetector();
simple_md::MotionDetector *m_motionDetector;
int m_width;
int m_height;
};
　　static void PyDelVideoDetector(void *ptr)
{
    printf("VideoDetector_UnInit\n");
VideoDetector *tmp = static_cast<VideoDetector *>(ptr);
delete tmp;
return;
}
　　PyObject *VideoDetector_Init(PyObject *self, PyObject *args)
{
printf("VideoDetector_Init\n");
int arg1 = 0;
int arg2 = 0;
int ret = PyArg_ParseTuple(args, "ii", &arg1, &arg2);
if (ret == 0)
{
  printf("VideoDetector_Init fail\n");
  return NULL;
}
VideoDetector *vd = new VideoDetector(arg1, arg2);
return PyCObject_FromVoidPtr(vd, PyDelVideoDetector);
}
　　#define f(x0) (*((uint8_t*)PyArray_DATA(py_pix) + (x0) * PyArray_STRIDES(py_pix)[0]))
#define shape(i) (py_pix->dimensions[(i)])
　　PyObject *VideoDetector_Process(PyObject *self, PyObject *args)
{
printf("VideoDetector_Process\n");
PyObject *py_obj = 0;
PyArrayObject *py_pix = 0;
npy_int64 idx = 0;
int ret = PyArg_ParseTuple(args, "OO", &py_obj, &py_pix);
if (ret == 0)
{
     printf("VideoDetector_Process fail\n");
  return NULL;
}
　　uint8_t *frame = (uint8_t *)malloc(sizeof(uint8_t) * shape(0));
if (frame == NULL)
{
  return NULL;
}
　　for (idx = 0; idx < shape(0); idx++)
{
  *(frame + idx) = (uint8_t)f(idx);
}
    printf("-------process_frame start-------\n");
void * tmp = PyCObject_AsVoidPtr(py_obj);
VideoDetector *vd = static_cast<VideoDetector *>(tmp);
int result = vd->process_frame(frame);
free(frame);
frame = NULL;
printf("-------process_frame end(%d)-------\n", result);
return Py_BuildValue("i", result);
}
　　PyObject *VideoDetector_Test(PyObject *self, PyObject *args)
{
printf("VideoDetector_Test\n");
PyObject *pynum = 0;
int ret = PyArg_ParseTuple(args, "O", &pynum);
if (ret == 0)
{
     printf("VideoDetector_Test fail\n");
  return NULL;
}
void * tmp = PyCObject_AsVoidPtr(pynum);
VideoDetector *vd = static_cast<VideoDetector *>(tmp);
int result = vd->test();
return Py_BuildValue("i", result);
}
　　static PyMethodDef VideoDetector_methods[] = {
{"VideoDetector", VideoDetector_Init    , METH_VARARGS},
{"test"    ,      VideoDetector_Test    , METH_VARARGS},
{"process"    ,   VideoDetector_Process , METH_VARARGS},
{NULL, NULL, 0}
};
　　PyMODINIT_FUNC initVideoDetector(void)
{
Py_InitModule("VideoDetector", VideoDetector_methods);
}
　　videodetector.py代码：
　　from VideoDetector import *
　　class videodetector(object):
def __init__(self, arg1, arg2):
  self._base = VideoDetector(arg1, arg2)
def test(self):
  return test(self._base)
def process(self, frame):
  return process(self._base, frame)
　　
　　camera.py代码：
　　import cv2
import time
import datetime
import numpy as np
from videodetector import *
　　frame_num = 0
　　def motion_detect(obj, frame):
global frame_num
if frame_num % 5 == 0:
  print frame_num
  pixels = []
  for ch in frame.tostring():
   pixels.append(ord(ch))
　　#rgb2yuv = np.array([[0.299, 0.587, 0.114],
        #                    [-0.14713, -0.28886, 0.436],
        #                    [0.615, -0.51499, -0.10001]])
  #rgb = np.array(pixels).reshape(len(pixels) / 3, 3)
  #yuv = np.dot(rgb, rgb2yuv.T)
  #y = np.array(yuv[ :, 0]).reshape(len(yuv), 1)
  #print yuv.shape
  #print y.shape
  #print obj.process(y)
  
  rgb = np.array(pixels).reshape(len(pixels) / 3, 3)
  r = rgb[ : , 0];
  g = rgb[ : , 1];
  b = rgb[ : , 2];
  raw = r + g + b;
  #print datetime.datetime.now().second
  #print datetime.datetime.now().microsecond
  print raw.shape;
  print obj.process(raw)
frame_num += 1
　　
camera = cv2.VideoCapture(0)
fps = camera.get(cv2.cv.CV_CAP_PROP_FPS)
(width, height) = (int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)), int(camera.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)))
print width
print height
obj = videodetector(width, height)
#print obj.test()
　　print("program begin")
while True:
(grabbed, frame) = camera.read()
if not grabbed:
  continue
cv2.imshow("Frame", frame)
motion_detect(obj, frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
  break
print("program end")
camera.release()
cv2.destroyAllWindows()
print("program release")
　　
　　效果如图3：

　　图3