LabVIEW
Creating a .dll in Visual Studio 2015 to pass an image through some OPENCV filters in Labview?
@idmb wrote:
#include "math.h" #include <opencv2/opencv.hpp> #include <opencv2/core/core.hpp> #include <opencv2/highgui/highgui.hpp> #include <iostream> using namespace std; using namespace cv; extern "C" __declspec(dllexport) double * __cdecl Reimage(int *myarray, int array_length_row, int array_length_col); __declspec(dllexport) double * __cdecl Reimage(int *myarray, int array_length_row, int array_length_col) { vector<double> xy; xy.push_back(250); xy.push_back(155); return xy.data(); }so I would expect to get back a 1d array with values 250 and 155 in the 0 and 1 spots respectively?
You have two problems with this:
1) You can't return an array as function return value to LabVIEW. LabVIEW has no way to know how large the array is and therefore couldn't possibly convert it into a LabVIEW array (which is distinctively different than a C array data pointer).
2) You create the standard template variable xy on the stack. You do not create a reference to it but the entire variable is on the stack. The automatic memory management of standard template variables makes sure that the variable is deallocated as soon as it goes out of program scope, which in this case is at the moment the return statement is executed. This means you are returning a pointer to a memory area that is not valid anymore as soon as the function returns to the caller. But avoiding the auto cleanup by either using variable references with explicit allocation of the variable through new, would only seemingly solve the problem. You would get the array properly back into LabVIEW but you would leak memory with every call of this function.
So even if you go around the limitation of LabVIEW to not allow to return C data array pointers as function value by treating it as a pointer sized variable and trying to index the pointer manually on your LabVIEW diagram, you are indexing a pointer that is not valid anymore and most likely used for other things already. The standard C++ template library has a tendency to inline the storage of its variable up to a certain amount so it is possible that the pointer you return is actually directly pointing into the stack rather than some dynamically allocated memory, and that stack is of course overwritten and reused umptien times at the point where your LabVIEW code tries to reference it. If you would create a bigger array (or initialize the array to be of some bigger size, the standard C++ template would likely use a dynamically allocated pointer inside the variable but at the moment the return statement is executed the variable will be cleaned up and free that pointer too. The contents in its memory may survive long enough to be able to get read by your LabVIEW code, but you are still accessing invalid memory that way and sooner or later you would run into big trouble anyways.
Interfacing LabVIEW to C code is not easy, interfacing it to C++ and especially standard template code can be a very serious challenge, since the memory management of both assume very different paradigmas, that you have to properly translate between the two in you C++ code.
To make this work, the simplest way would be to change the function to return a LabVIEW array handle, then inside the function allocate such a handle through a LabVIEW memory manager function such as NumericArrayResize(), copy the contents from the standard template vector into it (and update the length in the handle) and then return from the code.
Another approach would be to return the array in an array pointer argument. This only works easily if you know beforehand how large the array will be and can allocated the array on the LabVIEW diagram and pass the C data pointer as argument to the function. Then you copy the content of the vector into the array pointer before returning to the caller and having the vector auto destroyed by the C++ compiler.
In terms of OpenCV you can optimize this to avoid an extra memory copy of the image data but you have to know beforehand how big the returned picture will get. Then you can allocate a properly sized array data on the diagram, pass its pointer to the C function, which uses it to wrap an OpenCV image datatype around it, then you can pass the OpenCV image variable to just about any OpenCV function that requires this and clean up the wrapped image datatype before returning and the data is already in the LabVIEW array on return from the C function.
That is the most efficient way to deal with OpenCV images in LabVIEW. But as said, it requires you to know beforehand what the size of the image will be so you can allocate the array properly in LabVIEW before calling the function. If you can't know the size beforehand, the only way to deal with this is to do the OpenCV stuff in your C function, then determine the needed size, allocate a LabVIEW array handle through the proper LabVIEW memory manager functions and then copy the OpenCV image content into the LabVIEW array handle and return that handle to LabVIEW.
