Wrapping einer OpenCV-Implementierung eines Fehler-Level-Analyse-Algorithmus mit Cithon

Question

Ich habe einen Fehler-Level-Analyse-Algorithmus mit C++ (opencv Version 2.4) implementiert und ich möchte einen Python-Wrapper dafür mit Cython erstellen. Ich habe einen Teil der Dokumentation von Cython für C++ gelesen, aber es hat mir nicht geholfen und außerdem habe ich keine zusätzlichen Informationen gefunden, um den Wrapper online zu implementieren. Es wäre wirklich toll, wenn mir jemand helfen und mir helfen könnte, dieses Problem zu lösen.

Dies ist mein Code für die ich einen pyhton Wrapper bauen wollen:

#include <opencv2/highgui/highgui.hpp> 
#include <iostream> 
#include <vector> 

// Control 
int scale = 15, 
quality = 75; 

// Image containers 
cv::Mat input_image, 
compressed_image; 

void processImage(int, void*) 
{ 

// Setting up parameters and JPEG compression 
std::vector<int> parameters; 
parameters.push_back(CV_IMWRITE_JPEG_QUALITY); 
parameters.push_back(quality); 
cv::imwrite("lena.jpeg", input_image, parameters); 

// Reading temp image from the disk 
compressed_image = cv::imread("lena.jpeg"); 

if (compressed_image.empty()) 
{ 
    std::cout << "> Error loading temp image" << std::endl; 
    exit(EXIT_FAILURE); 
} 

cv::Mat output_image = cv::Mat::zeros(input_image.size(), CV_8UC3); 

// Compare values through matrices 
for (int row = 0; row < input_image.rows; ++row) 
{ 
const uchar* ptr_input = input_image.ptr<uchar>(row); 
const uchar* ptr_compressed = compressed_image.ptr<uchar>(row); 
uchar* ptr_out = output_image.ptr<uchar>(row); 

    for (int column = 0; column < input_image.cols; column++) 
    { 
     // Calc abs diff for each color channel multiplying by a scale factor 
     ptr_out[0] = abs(ptr_input[0] - ptr_compressed[0]) * scale; 
     ptr_out[1] = abs(ptr_input[1] - ptr_compressed[1]) * scale; 
     ptr_out[2] = abs(ptr_input[2] - ptr_compressed[2]) * scale; 

     ptr_input += 3; 
     ptr_compressed += 3; 
     ptr_out += 3; 
    } 
} 

// Shows processed image 
cv::imshow("Error Level Analysis", output_image); 
} 

int main (int argc, char* argv[]) 
{ 
// Verifica se o número de parâmetros necessário foi informado 
if (argc < 2) 
{ 
std::cout << "> You need to provide an image as parameter" << std::endl; 
return EXIT_FAILURE; 
} 

// Read the image 
input_image = cv::imread(argv[1]); 

// Check image load 
if (input_image.empty()) 
{ 
    std::cout << "> Error loading input image" << std::endl; 
    return EXIT_FAILURE; 
} 

// Set up window and trackbar 
cv::namedWindow("Error Level Analysis", CV_WINDOW_AUTOSIZE); 
cv::imshow("Error Level Analysis", input_image); 
cv::createTrackbar("Scale", "Error Level Analysis", &scale, 100, processImage); 
cv::createTrackbar("Quality", "Error Level Analysis", &quality, 100, processImage); 

// Press 'q' to quit 
while (char(cv::waitKey(0)) != 'q') {}; 

return EXIT_SUCCESS; 
} 

https://github.com/shreyneil/image_test/blob/master/ela.cpp

Beiträge sind willkommen. Danke.

Answer 1

Es ist nicht wirklich klar, was Sie damit erreichen wollen, aber es ist ziemlich einfach, die Funktionen von Cython aufrufbar zu machen. Beginnen Sie mit kleinen Änderungen an main - es muss umbenannt werden, damit es nicht mehr als Hauptfunktion für ein Programm fungiert, und da Sie nur das zweite Befehlszeilenargument als Dateinamen verwenden, sollten Sie es wie folgt ändern:

void some_function(char* filename) { 
    // Read the image 
    input_image = cv::imread(filename); 
    // everything else the same 
} 

Dann erstellen Sie Ihre Cython-Wrapper cy_wrap.pyx. Es gibt zwei Teile davon. Zuerst müssen Sie Cython über Ihre beiden C++ - Funktionen (cdef extern from) informieren. Zweitens benötigen Sie einen kleinen Wrapper-Funktion zu schreiben, die diese aus Python anrufen:

cdef extern from "ela.hpp": 
    # you'll need to create ela.hpp with declarations for your two functions 
    void processImage(int, void*) 
    void some_function(char* filename) 

# and Python wrappers 
def processImagePy(): 
    # since the parameters are ignored in C++ we can pass anything 
    processImage(0,NULL) 

def some_functionPy(filename): 
    # automatic conversion from string to char* 
    some_function(filename) 

Mit diesem Modul Sie werden in der Lage sein processImagePy und some_functionPy zu nennen.

Um es zu einem Python-Modul zu kompilieren, müssen Sie eine setup.py-Datei schreiben. Ich schlage vor, Sie folgen the template given in the Cython documentation (die Sie gelesen haben, oder?). Ihre Quelldateien sind cy_wrap.pyx und ela.cpp. Wahrscheinlich möchten Sie mit der OpenCV-Bibliothek verlinken. Sie müssen specify language="c++"