Python 调用 C++ 传递numpy 数据详情
更新时间：2022年03月29日 09:26:24 作者：darkerJ
这篇文章主要介绍了Python 调用 C++ 传递numpy 数据详情，文章主要分为两部分，c++代码和python代码，代码分享详细，需要的小伙伴可以参考一下，希望对你有所帮助
1.C++ 代码
Demo.h
#pragma once void GeneratorGaussKernel(int ksize, float sigma, float* kernel); void LeftAndRightMirrorImageUInt8(unsigned char* in, unsigned char* out, int width, int height); void LeftAndRightMirrorImageFloat(float* in, float* out, int width, int height); void UpAndDownMirrorImageFloat(float* in, float* out, int width, int height); void UpAndDownMirrorImageUInt8(unsigned char* in, unsigned char* out, int width, int height); void ImageFilterFloat(float* in, float* out, int width, int height, float* filterKernel, int kw, int kh); void SaltAndPepperFloat(float* in, float* out, int width, int height, float minV, float maxV, float proportion); void SaltAndPepperUInt8(unsigned char* in, unsigned char* out, int width, int height, float minV, float maxV, float proportion); void ImageMinMax(float* in, int width, int height, int channels, float* minV, float* maxV); void ImageMinMax(unsigned char* in, int width, int height, int channels, unsigned char* minV, unsigned char* maxV); void ImageMulAAddBFloatFloat(float* in, float* out, int width, int height, int channels, float A, float B); void ImageMulAAddBUInt8UInt8(unsigned char* in, unsigned char* out, int width, int height, int channels, float A, float B); void ImageMulAAddBUInt8Float(unsigned char* in, float* out, int width, int height, int channels, float A, float B); void NormalizeUInt8Float(unsigned char* in, float* out, int width, int height, int channels, int type); void NormalizeFloatFloat(float* in, float* out, int width, int height, int channels, int type); void RGBAvgUInt8Float(unsigned char* in, float* out, int width, int height); void RGBAvgFloatFloat(float* in, float* out, int width, int height);
Demo.cpp
#include <Python.h>
#include <malloc.h>
#include <numpy/arrayobject.h>
#include <iostream>
#include <vector>
#include <xmmintrin.h>
#include <immintrin.h>
#include "omp.h"
class ImageCoord {
public:
ImageCoord() {
x = 0; y = 0;
}
ImageCoord(const ImageCoord& coord) {
x = coord.x;
y = coord.y;
}
ImageCoord(int x, int y) {
this->x = x;
this->y = y;
}
void operator= (ImageCoord& coord) {
x = coord.x;
y = coord.y;
}
int x, y;
};
class Random {
public:
Random() {
srand((unsigned int)time(NULL));
}
ImageCoord RandomImageCoord(int width, int height) {
ImageCoord ans;
ans.x = rand() % width;
ans.y = rand() % height;
return ans;
}
bool RandomBoolean() {
return rand() % 2 == 1;
}
};
static Random gRandom;
void GeneratorGaussKernel(int ksize, float sigma, float* kernel)
{
int bufferSize = ksize * ksize;
float sigmasigma2 = 2.0f * sigma * sigma;
float sigmasigma2Inv = 1.f / sigmasigma2;
float sigmasigma2PIInv = sigmasigma2Inv / 3.14159265358979f;
int radius = ksize / 2;
float sum = 0.f;
for (int i = -radius; i <= radius; ++i) {
for (int j = -radius; j <= radius; ++j) {
kernel[(i + radius) * ksize + (j + radius)] = sigmasigma2PIInv * expf(-(i * i + j * j) * sigmasigma2Inv);
}
}
for (int i = 0; i < bufferSize; ++i) {
sum += kernel[i];
}
sum = 1.f / sum;
for (int i = 0; i < bufferSize; ++i) {
kernel[i] = kernel[i] * sum;
}
}
void LeftAndRightMirrorImageUInt8(unsigned char* in, unsigned char* out, int width, int height)
{
for (int i = 0; i < height; ++i) {
int hoffset = i * width;
for (int j = 0; j < width; ++j) {
int woffset = (hoffset + j) * 3;
int woffset_ = (hoffset + width - 1 - j) * 3;
for (int n = 0; n < 3; ++n) {
out[woffset_ + n] = in[woffset + n];
}
}
}
}
void LeftAndRightMirrorImageFloat(float* in, float* out, int width, int height)
{
for (int i = 0; i < height; ++i) {
int hoffset = i * width;
for (int j = 0; j < width; ++j) {
int woffset = (hoffset + j) * 3;
int woffset_ = (hoffset + width - 1 - j) * 3;
for (int n = 0; n < 3; ++n) {
out[woffset_ + n] = in[woffset + n];
}
}
}
}
void UpAndDownMirrorImageFloat(float* in, float* out, int width, int height)
{
int lineOffset = width * 3;
int lineSize = lineOffset * sizeof(float);
float* outTmp = out + lineOffset * height - lineOffset;
float* inTmp = in;
for (int i = 0; i < height; ++i) {
memcpy_s(outTmp, lineSize, inTmp, lineSize);
outTmp -= lineOffset;
inTmp += lineOffset;
}
}
void UpAndDownMirrorImageUInt8(unsigned char* in, unsigned char* out, int width, int height)
{
int lineOffset = width * 3;
int lineSize = lineOffset * sizeof(unsigned char);
unsigned char* outTmp = out + lineOffset * height - lineOffset;
unsigned char* inTmp = in;
for (int i = 0; i < height; ++i) {
memcpy_s(outTmp, lineSize, inTmp, lineSize);
outTmp -= lineOffset;
inTmp += lineOffset;
}
}
#if 0
void Conv(float* in, float* out, int width, float* filter, int ksize) {
int lineSize = width * 3;
float* inTemp = in;
float* outTemp = out;
out[0] = 0.f; out[1] = 0.f; out[2] = 0.f;
for (int i = 0; i < ksize; ++i) {
for (int j = 0; j < ksize; ++j) {
int xoffset = j * 3;
out[0] += (*filter) * inTemp[xoffset + 0];
out[1] += (*filter) * inTemp[xoffset + 1];
out[2] += (*filter) * inTemp[xoffset + 2];
filter++;
}
inTemp = inTemp + lineSize;
}
}
void ImageFilterFloat(float* in, float* out, int width, int height, float* filterKernel, int kw, int kh)
{
size_t size = (size_t)width * (size_t)height * sizeof(float) * 3;
int startX = kw / 2;
int endX = width - kw / 2;
int startY = kh / 2;
int endY = height - kh / 2;
float* tempOut = out + (startY * width + startX) * 3;
memset(out, 0, size);
//memcpy_s(out, size, in, size);
omp_set_num_threads(32);
#pragma omp parallel for
for (int i = 0; i <= height - kh; ++i) {
int yoffset = i * width * 3;
for (int j = 0; j <= width - kw; ++j) {
int xoffset = yoffset + j * 3;
Conv((in + xoffset), (tempOut + xoffset), width, filterKernel, kw);
}
}
}
#elif 1
void Conv(float* in, float* out, int width, __m128* filter, int ksize) {
int lineSize = width * 3;
float* inTemp = in;
float* outTemp = out;
out[0] = 0.f; out[1] = 0.f; out[2] = 0.f;
__m128 sum = _mm_set_ps1(0.f);
for (int i = 0; i < ksize; ++i) {
for (int j = 0; j < ksize; ++j) {
int xoffset = j * 3;
__m128 img_value = _mm_set_ps(1.f, inTemp[xoffset + 2], inTemp[xoffset + 1], inTemp[xoffset + 0]);
sum = _mm_add_ps(_mm_mul_ps((*filter), img_value), sum);
filter++;
}
inTemp = inTemp + lineSize;
}
out[0] = sum.m128_f32[0];
out[1] = sum.m128_f32[1];
out[2] = sum.m128_f32[2];
}
void ImageFilterFloat(float* in, float* out, int width, int height, float* filterKernel, int kw, int kh)
{
size_t size = (size_t)width * (size_t)height * sizeof(float) * 3;
int startX = kw / 2;
int endX = width - kw / 2;
int startY = kh / 2;
int endY = height - kh / 2;
float* tempOut = out + (startY * width + startX) * 3;
memset(out, 0, size);
__m128* filterKernel_m128 = (__m128*)_mm_malloc(kw * kh * sizeof(__m128), sizeof(__m128));
for (int i = 0; i < kw * kh; ++i) {
filterKernel_m128[i] = _mm_set_ps1(filterKernel[i]);
}
omp_set_num_threads(32);
#pragma omp parallel for
for (int i = 0; i <= height - kh; ++i) {
int yoffset = i * width * 3;
for (int j = 0; j <= width - kw; ++j) {
int xoffset = yoffset + j * 3;
Conv((in + xoffset), (tempOut + xoffset), width, filterKernel_m128, kw);
}
}
if (filterKernel_m128) {
_mm_free(filterKernel_m128);
filterKernel_m128 = NULL;
}
}
#endif
void SaltAndPepperFloat(float* in, float* out, int width, int height, float minV, float maxV, float proportion)
{
int coordNumber = (int)(width * height * proportion);
if (in != out) {
memcpy_s(out, width * height * 3 * sizeof(float), in, width * height * 3 * sizeof(float));
}
for (int i = 0; i < coordNumber; ++i) {
ImageCoord coord = gRandom.RandomImageCoord(width, height);
bool saltOrPepper = gRandom.RandomBoolean();
float value = saltOrPepper ? minV : maxV;
int x = coord.x;
int y = coord.y;
int offset = (y * width + x) * 3;
for (int c = 0; c < 3; ++c) {
out[offset + c] = value;
}
}
}
void SaltAndPepperUInt8(unsigned char* in, unsigned char* out, int width, int height, float minV, float maxV, float proportion)
{
int coordNumber = (int)(width * height * proportion);
if (in != out) {
memcpy_s(out, width * height * 3 * sizeof(unsigned char), in, width * height * 3 * sizeof(unsigned char));
}
for (int i = 0; i < coordNumber; ++i) {
ImageCoord coord = gRandom.RandomImageCoord(width, height);
bool saltOrPepper = gRandom.RandomBoolean();
float value = saltOrPepper ? minV : maxV;
int x = coord.x;
int y = coord.y;
int offset = (y * width + x) * 3;
for (int c = 0; c < 3; ++c) {
out[offset + c] = (unsigned char)value;
}
}
}
void ImageMinMax(float* in, int width, int height, int channels, float* minV, float* maxV)
{
float minValue = 99999.f;
float maxValue = -minValue;
int number = width * height * channels;
for (int i = 0; i < number; ++i) {
float value = in[i];
if (value > maxValue) {
maxValue = value;
}
if (value < minValue) {
minValue = value;
}
}
*minV = (float)minValue;
*maxV = (float)maxValue;
}
void ImageMinMax(unsigned char* in, int width, int height, int channels, unsigned char* minV, unsigned char* maxV)
{
int minValue = 256;
int maxValue = -1;
int number = width * height * channels;
for (int i = 0; i < number; ++i) {
int value = in[i];
if (value > maxValue) {
maxValue = value;
}
if (value < minValue) {
minValue = value;
}
}
*minV = (unsigned char)minValue;
*maxV = (unsigned char)maxValue;
}
void ImageMulAAddBFloatFloat(float* in, float* out, int width, int height, int channels, float A, float B)
{
int size = width * height * channels;
for (int i = 0; i < size; ++i) {
out[i] = in[i] * A + B;
}
}
void ImageMulAAddBUInt8UInt8(unsigned char* in, unsigned char* out, int width, int height, int channels, float A, float B)
{
#define ALVACLAMP(x, minV, maxV) \
(x) < (minV) ? (minV) : ((x) > (maxV) ? (maxV) : (x))
int size = width * height * channels;
for (int i = 0; i < size; ++i) {
out[i] = (unsigned char)(ALVACLAMP(in[i] * A + B, 0, 255));
}
#undef ALVACLAMP
}
void ImageMulAAddBUInt8Float(unsigned char* in, float* out, int width, int height, int channels, float A, float B)
{
int size = width * height * channels;
for (int i = 0; i < size; ++i) {
out[i] = in[i] * A + B;
}
}
void NormalizeUInt8Float(unsigned char* in, float* out, int width, int height, int channels, int type)
{
unsigned char minV, maxV;
ImageMinMax(in, width, height, channels, &minV, &maxV);
int size = width * height * channels;
float inv = 1.f / (maxV - minV);
float offset = 0.f;
if (type == 1) {
inv *= 2.f;
offset = -1.f;
}
for (int i = 0; i < size; ++i) {
out[i] = (in[i] - minV) * inv + offset;
}
}
void NormalizeFloatFloat(float* in, float* out, int width, int height, int channels, int type)
{
float minV, maxV;
ImageMinMax(in, width, height, channels, &minV, &maxV);
int size = width * height * channels;
float inv = 1.f / (maxV - minV);
float offset = 0.f;
if (type == 1) {
inv *= 2.f;
offset = -1.f;
}
for (int i = 0; i < size; ++i) {
out[i] = (in[i] - minV) * inv + offset;
}
}
void RGBAvgUInt8Float(unsigned char* in, float* out, int width, int height)
{
int size = width * height;
for (int i = 0; i < size; ++i) {
float avg = (in[i * 3 + 0] + in[i * 3 + 1] + in[i * 3 + 2]) / 3.f;
out[i * 3 + 0] = avg;
out[i * 3 + 1] = avg;
out[i * 3 + 2] = avg;
}
}
void RGBAvgFloatFloat(float* in, float* out, int width, int height)
{
int size = width * height;
for (int i = 0; i < size; ++i) {
float avg = (in[i * 3 + 0] + in[i * 3 + 1] + in[i * 3 + 2]) / 3.f;
out[i * 3 + 0] = avg;
out[i * 3 + 1] = avg;
out[i * 3 + 2] = avg;
}
}
static PyObject* GeneratorGaussKernel(PyObject* self, PyObject* args) {
//int ksize, float sigma, float* kernel
PyObject* pyobj_filter = NULL;
int ksize;
float sigma;
int ret = PyArg_ParseTuple(args, "Oif", &pyobj_filter, &ksize, &sigma);
PyArrayObject* oarr = (PyArrayObject*)pyobj_filter;
float* data = (float*)(oarr->data);
GeneratorGaussKernel(ksize, sigma, data);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* LeftAndRightMirrorImageUInt8(PyObject* self, PyObject* args) {
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
int ret = PyArg_ParseTuple(args, "OOii", &pyobj_img, &pyobj_out_img, &width, &height);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
unsigned char* dataIn = (unsigned char*)(oarr->data);
unsigned char* dataOut = (unsigned char*)(oarr_out->data);
LeftAndRightMirrorImageUInt8(dataIn, dataOut, width, height);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
//std::cout << "";
}
static PyObject* LeftAndRightMirrorImageFloat(PyObject* self, PyObject* args) {
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
int ret = PyArg_ParseTuple(args, "OOii", &pyobj_img, &pyobj_out_img, &width, &height);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
float* dataIn = (float*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
LeftAndRightMirrorImageFloat(dataIn, dataOut, width, height);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* UpAndDownMirrorImageUInt8(PyObject* self, PyObject* args) {
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
int ret = PyArg_ParseTuple(args, "OOii", &pyobj_img, &pyobj_out_img, &width, &height);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
unsigned char* dataIn = (unsigned char*)(oarr->data);
unsigned char* dataOut = (unsigned char*)(oarr_out->data);
UpAndDownMirrorImageUInt8(dataIn, dataOut, width, height);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* UpAndDownMirrorImageFloat(PyObject* self, PyObject* args) {
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
int ret = PyArg_ParseTuple(args, "OOii", &pyobj_img, &pyobj_out_img, &width, &height);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
float* dataIn = (float*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
UpAndDownMirrorImageFloat(dataIn, dataOut, width, height);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* ImageFilterFloat(PyObject* self, PyObject* args) {
//float* in, float* out, int width, int height, float* filterKernel, int kw, int kh
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
PyObject* pyobj_filterKernel = NULL;
int width, height;
int kw, kh;
int ret = PyArg_ParseTuple(args, "OOiiOii", &pyobj_img, &pyobj_out_img, &width, &height, &pyobj_filterKernel, &kw, &kh);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
PyArrayObject* kernel = (PyArrayObject*)pyobj_filterKernel;
float* dataIn = (float*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
float* filter = (float*)(kernel->data);
ImageFilterFloat(dataIn, dataOut, width, height, filter, kw, kh);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* SaltAndPepperFloat(PyObject* self, PyObject* args) {
//float* in, float* out, int width, int height, float minV, float maxV, float proportion
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
float minV, maxV, proportion;
int ret = PyArg_ParseTuple(args, "OOiifff", &pyobj_img, &pyobj_out_img, &width, &height, &minV, &maxV, &proportion);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
float* dataIn = (float*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
SaltAndPepperFloat(dataIn, dataOut, width, height, minV, maxV, proportion);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* SaltAndPepperUInt8(PyObject* self, PyObject* args) {
//float* in, float* out, int width, int height, float minV, float maxV, float proportion
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
float minV, maxV, proportion;
int ret = PyArg_ParseTuple(args, "OOiifff", &pyobj_img, &pyobj_out_img, &width, &height, &minV, &maxV, &proportion);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
unsigned char* dataIn = (unsigned char*)(oarr->data);
unsigned char* dataOut = (unsigned char*)(oarr_out->data);
SaltAndPepperUInt8(dataIn, dataOut, width, height, minV, maxV, proportion);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* ImageMulAAddBFloatFloat(PyObject* self, PyObject* args) {
//float* in, float* out, int width, int height, int channels, float A, float B
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height, channels = 3;
float A, B;
int ret = PyArg_ParseTuple(args, "OOiiff", &pyobj_img, &pyobj_out_img, &width, &height, &A, &B);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
float* dataIn = (float*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
ImageMulAAddBFloatFloat(dataIn, dataOut, width, height, channels, A, B);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* ImageMulAAddBUInt8Float(PyObject* self, PyObject* args) {
//float* in, float* out, int width, int height, int channels, float A, float B
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height, channels = 3;
float A, B;
int ret = PyArg_ParseTuple(args, "OOiiff", &pyobj_img, &pyobj_out_img, &width, &height, &A, &B);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
unsigned char* dataIn = (unsigned char*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
ImageMulAAddBUInt8Float(dataIn, dataOut, width, height, channels, A, B);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* ImageMulAAddBUInt8UInt8(PyObject* self, PyObject* args) {
//float* in, float* out, int width, int height, int channels, float A, float B
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height, channels = 3;
float A, B;
int ret = PyArg_ParseTuple(args, "OOiiff", &pyobj_img, &pyobj_out_img, &width, &height, &A, &B);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
unsigned char* dataIn = (unsigned char*)(oarr->data);
unsigned char* dataOut = (unsigned char*)(oarr_out->data);
ImageMulAAddBUInt8UInt8(dataIn, dataOut, width, height, channels, A, B);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* NormalizeUInt8Float(PyObject* self, PyObject* args) {
// unsigned char* in, float* out, int width, int height, int channels, int type
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height, channels = 3;
int type;
int ret = PyArg_ParseTuple(args, "OOiii", &pyobj_img, &pyobj_out_img, &width, &height, &type);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
unsigned char* dataIn = (unsigned char*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
NormalizeUInt8Float(dataIn, dataOut, width, height, channels, type);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* NormalizeFloatFloat(PyObject* self, PyObject* args) {
// unsigned char* in, float* out, int width, int height, int channels, int type
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height, channels = 3;
int type;
int ret = PyArg_ParseTuple(args, "OOiii", &pyobj_img, &pyobj_out_img, &width, &height, &type);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
float* dataIn = (float*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
NormalizeFloatFloat(dataIn, dataOut, width, height, channels, type);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* RGBAvgUInt8Float(PyObject* self, PyObject* args) {
// unsigned char* in, float* out, int width, int height
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
int ret = PyArg_ParseTuple(args, "OOii", &pyobj_img, &pyobj_out_img, &width, &height);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
unsigned char* dataIn = (unsigned char*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
RGBAvgUInt8Float(dataIn, dataOut, width, height);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyObject* RGBAvgFloatFloat(PyObject* self, PyObject* args) {
// unsigned char* in, float* out, int width, int height
PyObject* pyobj_img = NULL;
PyObject* pyobj_out_img = NULL;
int width, height;
int ret = PyArg_ParseTuple(args, "OOii", &pyobj_img, &pyobj_out_img, &width, &height);
PyArrayObject* oarr = (PyArrayObject*)pyobj_img;
PyArrayObject* oarr_out = (PyArrayObject*)pyobj_out_img;
float* dataIn = (float*)(oarr->data);
float* dataOut = (float*)(oarr_out->data);
RGBAvgFloatFloat(dataIn, dataOut, width, height);
PyObject* result = PyUnicode_FromFormat("result:%s", "ok");
return result;
}
static PyMethodDef DemoMethods[] = {
{"LeftAndRightMirrorImageUInt8", (PyCFunction)LeftAndRightMirrorImageUInt8, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"LeftAndRightMirrorImageFloat", (PyCFunction)LeftAndRightMirrorImageFloat, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"UpAndDownMirrorImageUInt8", (PyCFunction)UpAndDownMirrorImageUInt8, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"UpAndDownMirrorImageFloat", (PyCFunction)UpAndDownMirrorImageFloat, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"ImageFilterFloat", (PyCFunction)ImageFilterFloat, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"SaltAndPepperFloat", (PyCFunction)SaltAndPepperFloat, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"SaltAndPepperUInt8", (PyCFunction)SaltAndPepperUInt8, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"ImageMulAAddBFloatFloat", (PyCFunction)ImageMulAAddBFloatFloat, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"ImageMulAAddBUInt8Float", (PyCFunction)ImageMulAAddBUInt8Float, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"ImageMulAAddBUInt8UInt8", (PyCFunction)ImageMulAAddBUInt8UInt8, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"NormalizeUInt8Float", (PyCFunction)NormalizeUInt8Float, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"NormalizeFloatFloat", (PyCFunction)NormalizeFloatFloat, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"RGBAvgUInt8Float", (PyCFunction)RGBAvgUInt8Float, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"RGBAvgFloatFloat", (PyCFunction)RGBAvgFloatFloat, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{"GeneratorGaussKernel", (PyCFunction)GeneratorGaussKernel, METH_VARARGS | METH_KEYWORDS, "I guess here is description." },
{NULL, NULL, 0, NULL}
};
static struct PyModuleDef demoModule = {
PyModuleDef_HEAD_INIT,
"mirror",
NULL,
-1,
DemoMethods
};
PyMODINIT_FUNC
PyInit_ImgProcessing(void) { // ImgProcessing 为生成的dll名称
return PyModule_Create(&demoModule);
}2.Python 代码
把C++ 编译出的ImgProcessing.dll 改为 ImgProcessing.pyd 并 拷贝到Python工程下
# -*- coding:utf-8 -*-
import cv2
import random
import numpy as np
import ImgProcessing as aug
class AugmentImagesBase:
def _gauss(self, x, y, sigma=1.):
Z = 2 * np.pi * sigma ** 2
kernel_value = 1 / Z * np.exp(-(x ** 2 + y ** 2) / 2 / sigma ** 2)
return kernel_value
def _gauss_kernel(self, kwidth, kheight, kchannel=1):
kernels = np.zeros((kheight, kwidth, kchannel, 1), np.float32)
mid = np.floor(kwidth / 2)
for kernel_idx in range(kchannel):
for i in range(kheight):
for j in range(kwidth):
kernels[i, j, kernel_idx, 0] = self._gauss(i - mid, j - mid)
if kchannel == 1:
kernels = np.reshape(kernels, (kheight, kwidth))
return kernels
def left_right_flip(self, img_in, img_out, width=336, height=192):
aug.AlvaLeftAndRightMirrorImageUInt8(img_in, img_out, width, height)
return img_out
def up_down_flip(self, img_in, img_out, width=336, height=192):
aug.AlvaUpAndDownMirrorImageUInt8(img_in, img_out, width, height)
return img_out
def filtering(self, img_in, img_out, width=336, height=192, kernel=None, kwidth=3, kheight=3):
aug.AlvaImageFilterFloat(img_in, img_out, width, height, kernel, kwidth, kheight)
return img_out
def pepper_salt(self, img_in, img_out, width=336, height=192, min_v=0, max_v=255, proportion=0.1):
rand_proportion = random.uniform(0., proportion)
aug.AlvaSaltAndPepperUInt8(img_in, img_out, width, height, min_v, max_v, rand_proportion)
return img_out
def contrast(self, img_in, img_out, width=336, height=192, a=0.6, b=0.4):
aug.AlvaImageMulAAddBUInt8UInt8(img_in, img_out, width, height, a, b)
return img_out
def average_rgb(self, img_in, img_out, width=336, height=192):
img_in = img_in.astype(np.float32)
img_out = img_out.astype(np.float32)
aug.AlvaRGBAvgFloatFloat(img_in, img_out, width, height)
img_out = img_out.astype(np.uint8)
return img_out
def normalize(self, img_in, img_out, width=336, height=192, type=1):
aug.AlvaNormalizeUInt8Float(img_in, img_out, width, height, type)
return img_out
def normal(self, img_in, img_out):
return img_in
def rota_180(self, img_in, img_out):
return cv2.rotate(img_in, cv2.ROTATE_180)
def rand_aug(self, img_in):
img_in = np.asarray(img_in, dtype=np.uint8)
img_out = np.ones_like(img_in).astype(np.uint8)
aug_func = {
"left_right_flip": self.left_right_flip,
'up_down_flip': self.up_down_flip,
'pepper_salt': self.pepper_salt,
'contrast': self.contrast,
'average_rgb': self.average_rgb,
"normal": self.normal,
"rota_180": self.rota_180,
}
img_out_curr = np.ones_like(img_in[0]).astype(np.uint8)
aug_names = []
for i in range(img_in.shape[0]):
aug_name = random.sample(list(aug_func.keys()), 1)[0]
img_out_curr = aug_func[aug_name](np.squeeze(img_in[i]), img_out_curr)
img_out[i] = img_out_curr
aug_names.append(aug_name)
return img_out, aug_names
def image_aug(img_path):
import cv2
import time
aug_tools = AugmentImagesBase()
kernel = aug_tools._gauss_kernel(5, 5)
img_in = cv2.imread(img_path).astype(np.float32)
img_out = np.ones_like(img_in).astype(np.float32)
time1 = time.time()
for i in range(1000):
# img_out, aug_names = aug_tools.average_rgb(img_in, img_out)
img_out = aug_tools.filtering(img_in, img_out, kernel=kernel, kwidth=5, kheight=5)
time2 = time.time()
print("end time:", time2 - time1)
# cv2.imshow(aug_names[0], img_out[0])
cv2.imshow("aug img", img_out.astype(np.uint8))
cv2.imshow('src img', img_in.astype(np.uint8))
cv2.waitKey(0)
if __name__ == "__main__":
img_path = r"G:\20210917\img\1.jpg"
image_aug(img_path)PyArg_ParseTuple 的使用见：PyArg_ParseTuple
到此这篇关于Python 调用 C++ 传递numpy 数据详情的文章就介绍到这了,更多相关Python调用 C++内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
PyQt5 QTreeWidget 树形结构递归遍历当前所有节点的实现
Qt中实现树形结构可以使用QTreeWidget类，也可以使用QTreeView类，本文主要介绍了PyQt5 QTreeWidget 树形结构递归遍历当前所有节点的实现，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2021-11-11
最近小编收到了好多小伙伴的吐槽称不会下载安装python,博主听到后非常的扎心,经过博主几天的熬夜加班,给大家出了一套python下载安装以及pycharm环境搭建的完整教程,一起来看看吧2024-02-02
这篇文章主要介绍了Python 中包/模块的 `import` 操作代码，非常不错，具有一定的参考借鉴价值 ,需要的朋友可以参考下2019-04-04
这篇文章主要为大家详细介绍了Python如何实现简单的弹球小游戏，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下2022-11-11
Python基于tkinter canvas实现图片裁剪功能
这篇文章主要介绍了Python基于tkinter canvas实现图片裁剪功能,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-11-11
googletrans是一个基于谷歌翻译API的Python库,支持多种语言的自动检测和翻译,提供了translate和detect方法,用于翻译文本和检测文本语言,通过简单的命令即可安装使用,适合需要实现多语言翻译功能的开发者2024-09-09
这篇文章主要介绍了python爬虫常见错误,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-02-02
在Python程序和Flask框架中使用SQLAlchemy的教程
SQLAlchemy为Python程序与SQL语句之间建立了映射,是Python操作数据库的利器,这里我们将来看在Python程序和Flask框架中使用SQLAlchemy的教程,需要的朋友可以参考下2016-06-06
今天小编就为大家分享一篇python 实现多维数组(array)排序，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧2020-02-02
Python原始字符串与Unicode字符串操作符用法实例分析
这篇文章主要介绍了Python原始字符串与Unicode字符串操作符用法,结合实例形式分析了Python针对原始字符与Unicode字符的操作符用法,需要的朋友可以参考下2017-07-07
最新评论