DLLEXPORT int start_int_background_task(WolframLibraryData libData,
mint Argc, MArgument *Args, MArgument Res)
{
mint asyncObjID;
WolframIOLibrary_Functions ioLibrary = libData->ioLibraryFunctions;
IntBackgroundArgs threadArg = (IntBackgroundArgs)malloc(sizeof(struct IntBackgroundArgs_st));
if(Argc != 2)
return LIBRARY_FUNCTION_ERROR;
threadArg->ioLibrary = ioLibrary;
threadArg->pausemillis = MArgument_getInteger(Args[0]);
threadArg->eventdata = MArgument_getInteger(Args[1]);
asyncObjID = ioLibrary->createAsynchronousTaskWithThread(IntBackgroundTask, threadArg);
MArgument_setInteger(Res, asyncObjID);
return LIBRARY_NO_ERROR;
}
/* Gets the I0,I1 th integer element of T0 returning that value */
DLLEXPORT int demo_TII_I(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0;
mint I0, I1, res;
mint dims[2];
int err = LIBRARY_NO_ERROR;
T0 = MArgument_getMTensor(Args[0]);
I0 = MArgument_getInteger(Args[1]);
I1 = MArgument_getInteger(Args[2]);
dims[0] = I0;
dims[1] = I1;
err = libData->MTensor_getInteger(T0, dims, &res);
MArgument_setInteger(Res, res);
return err;
}
/* Gets the subpart of the input tensor starting at the I0,I1 th position */
DLLEXPORT int demo_TII_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0, T1 = 0;
mint I0, I1;
mint pos[2];
int err = LIBRARY_NO_ERROR;
T0 = MArgument_getMTensor(Args[0]);
I0 = MArgument_getInteger(Args[1]);
I1 = MArgument_getInteger(Args[2]);
pos[0] = I0;
pos[1] = I1;
err = libData->MTensor_getMTensor(T0, pos, 2, &T1);
MArgument_setMTensor(Res, T1);
return err;
}
DLLEXPORT int encodeString(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res)
{
mint i = 0, shift;
if (string)
libData->UTF8String_disown(string);
string = MArgument_getUTF8String(Args[0]);
shift = MArgument_getInteger(Args[1]);
/* Find shift mod 127 so we only
deal with positive numbers below */
shift = shift % 127;
if (shift < 0)
shift += 127;
shift -= 1;
while (string[i]) {
mint c = (mint) string[i];
/* Error for non ASCII string */
if (c & 128) return LIBRARY_FUNCTION_ERROR;
c = ((c + shift) % 127) + 1;
string[i++] = (char) c;
}
MArgument_setUTF8String(Res, string);
return 0;
}
/**
* http://en.wikipedia.org/wiki/Mandelbrot_set
* @param _Real x
* @param _Real y
* @param _Integer maximum iterations
* @return _Integer iterations until escape, 0 if it never escapes
*/
DLLEXPORT int mandelbrot(WolframLibraryData libData, mint Argc,
MArgument *Args, MArgument Res)
{
mreal re = MArgument_getReal(Args[0]);
mreal im = MArgument_getReal(Args[1]);
mint max_iters = MArgument_getInteger(Args[2]);
mreal Z_im = 0.;
mreal Z_re = 0.;
mreal Z_im2 = 0.;
mreal Z_re2 = 0.;
mint iter = 0;
for (; (iter < max_iters) && (Z_re2 + Z_im2 < 4); iter++) {
Z_im = 2. * Z_im * Z_re + im;
Z_re = Z_re2 - Z_im2 + re;
Z_im2 = Z_im * Z_im;
Z_re2 = Z_re * Z_re;
}
if (iter == max_iters)
iter = 0;
MArgument_setInteger(Res, iter);
return LIBRARY_NO_ERROR;
}
DLLEXPORT int incrementInteger(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {
mint I0;
mint I1;
I0 = MArgument_getInteger(Args[0]);
I1 = I0 + 1;
MArgument_setInteger(Res, I1);
return LIBRARY_NO_ERROR;
}
/* Sets the I0,I1 th real element of T0 with value, returning that position */
DLLEXPORT int demo_TIIR_R(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0;
mint I0, I1;
mreal value, res;
mint dims[2];
int err = LIBRARY_NO_ERROR;
T0 = MArgument_getMTensor(Args[0]);
I0 = MArgument_getInteger(Args[1]);
I1 = MArgument_getInteger(Args[2]);
value = MArgument_getReal(Args[3]);
dims[0] = I0;
dims[1] = I1;
err = libData->MTensor_setReal(T0, dims, value);
if (err) return err;
err = libData->MTensor_getReal(T0, dims, &res);
MArgument_setReal(Res, res);
return err;
}
/* Gets the I0th element of T0, returning that value */
DLLEXPORT int demo_T_I(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0;
mint I0, res;
int err = LIBRARY_NO_ERROR;
T0 = MArgument_getMTensor(Args[0]);
I0 = MArgument_getInteger(Args[1]);
err = libData->MTensor_getInteger(T0, &I0, &res);
MArgument_setInteger(Res, res);
return err;
}
/* Gets the I0 th Real number from the rank 1 tensor T0 */
DLLEXPORT int demo_TI_R( WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0;
mint I0;
mreal R0;
int err = LIBRARY_NO_ERROR;
T0 = MArgument_getMTensor(Args[0]);
I0 = MArgument_getInteger(Args[1]);
err = libData->MTensor_getReal(T0, &I0, &R0);
if (err) return err;
MArgument_setReal(Res, R0);
return LIBRARY_NO_ERROR;
}
/* Sets the I0 th element in T0 to its value in T1 */
DLLEXPORT int demo_TTI_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0, T1;
mint I0;
int err = LIBRARY_NO_ERROR;
T0 = MArgument_getMTensor(Args[0]);
T1 = MArgument_getMTensor(Args[1]);
I0 = MArgument_getInteger(Args[2]);
err = libData->MTensor_setMTensor(T0, T1, &I0, 1);
MArgument_setMTensor(Res, T0);
return err;
}
DLLEXPORT int start_secondary_int_background_task(WolframLibraryData libData,
mint Argc, MArgument *Args, MArgument Res)
{
mint asyncObjID;
WolframIOLibrary_Functions ioLibrary = libData->ioLibraryFunctions;
if(Argc != 1)
return LIBRARY_FUNCTION_ERROR;
s_secondaryAsyncObjEventData = MArgument_getInteger(Args[1]);
asyncObjID = ioLibrary->createAsynchronousTaskWithoutThread();
s_secondaryAsyncObjID = asyncObjID;
MArgument_setInteger(Res, asyncObjID);
return LIBRARY_NO_ERROR;
}
EXTERN_C DLLEXPORT int InitSinkWriter(WolframLibraryData libData, mint Argc, MArgument * Args, MArgument Res) {
// Get the arguments from MArgument
char *videofile = MArgument_getUTF8String(Args[0]);
// convert UTF8 filename to wide chars
int size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, NULL, 0);
WCHAR* videofileW = new WCHAR[size];
size = MultiByteToWideChar(CP_ACP, 0, videofile, -1, videofileW, size);
// extract the sink parameters
mint encoder = MArgument_getInteger(Args[1]);
mint width = MArgument_getInteger(Args[2]);
mint height = MArgument_getInteger(Args[3]);
mreal framerate = MArgument_getReal(Args[4]);
mint kbps = MArgument_getInteger(Args[5]);
hr = VW.setParams(encoder, width, height, framerate, kbps);
if (FAILED(hr))
{
libData->Message("setsinkparamsfail");
return LIBRARY_FUNCTION_ERROR;
}
// Initialise the sink writer
hr = VW.initSinkWriter(videofileW);
// finished with the filename now
delete videofileW;
if (FAILED(hr))
{
libData->Message("initsinkfail");
return LIBRARY_FUNCTION_ERROR;
}
return LIBRARY_NO_ERROR;
}
/* Returns Sum[i*R0, {i, I0}] */
DLLEXPORT int Function01( WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
mreal R0;
mint I0;
mint i;
mreal R1;
I0 = MArgument_getInteger(Args[0]);
R0 = MArgument_getReal(Args[1]);
R1 = 0;
for ( i = 0; i < I0; i++) {
R1 = R1 + i*R0;
}
MArgument_setReal(Res, R1);
return LIBRARY_NO_ERROR;
}
/**
* Constructs a new rank 1 tensor of length I0, and sets the
* ith element of the vector to 2*i
**/
DLLEXPORT int demo_I_T(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument Res) {
MTensor T0;
mint i, I0, dims[1];
int err = LIBRARY_NO_ERROR;
I0 = MArgument_getInteger(Args[0]);
dims[0] = I0;
err = libData->MTensor_new(MType_Integer, 1, dims, &T0);
for ( i = 1; i <= I0 && !err; i++) {
err = libData->MTensor_setInteger( T0, &i, i*2);
}
MArgument_setMTensor(Res, T0);
return err;
}
DLLEXPORT int opencv_dilate(WolframLibraryData libData, mint Argc, MArgument *Args, MArgument res)
{
mint dims[3], w, h, i, j;
IplImage* src = 0;
IplImage* dst = 0;
raw_t_bit* src_data_bit = 0;
raw_t_bit* dst_data_bit = 0;
raw_t_ubit8* src_data_byte = 0;
raw_t_ubit8* dst_data_byte = 0;
raw_t_ubit16* src_data_bit16 = 0;
raw_t_ubit16* dst_data_bit16 = 0;
raw_t_real32* src_data_real32 = 0;
raw_t_real32* dst_data_real32 = 0;
IplConvKernel* element = 0;
MImage image_in, image_out = 0;
int radius;
int err = 0;
int type = 0;
WolframImageLibrary_Functions imgFuns = libData->imageLibraryFunctions;
if (Argc < 2) {
return LIBRARY_FUNCTION_ERROR;
}
image_in = MArgument_getMImage(Args[0]);
if(imgFuns->MImage_getRank(image_in) == 3) return LIBRARY_FUNCTION_ERROR;
if(imgFuns->MImage_getChannels(image_in) != 1) return LIBRARY_FUNCTION_ERROR;
radius = MArgument_getInteger(Args[1]);
if(radius < 1) return LIBRARY_FUNCTION_ERROR;
err = imgFuns->MImage_clone(image_in, &image_out);
if (err) return LIBRARY_FUNCTION_ERROR;
type = imgFuns->MImage_getDataType(image_in);
h = imgFuns->MImage_getRowCount(image_in);
w = imgFuns->MImage_getColumnCount(image_in);
element = cvCreateStructuringElementEx(2*radius+1,2*radius+1, radius, radius, CV_SHAPE_RECT, 0);
switch(type) {
case MImage_Type_Bit:
{
raw_t_bit* data_in = imgFuns->MImage_getBitData(image_in);
raw_t_bit* data_out = imgFuns->MImage_getBitData(image_out);
if (!data_in || !data_out) {
err = LIBRARY_FUNCTION_ERROR;
goto cleanup;
}
src = cvCreateImage( cvSize(w, h), IPL_DEPTH_1U, 1);
dst = cvCreateImage( cvSize(w, h), IPL_DEPTH_1U, 1);
src_data_bit = src->imageData;
dst_data_bit = dst->imageData;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
(src_data_bit + i*src->widthStep)[j] = data_in[i*w+j];
}
}
cvDilate(src, dst, element, 1);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
data_out[i*w+j] = (dst_data_bit + i*dst->widthStep)[j];
}
}
break;
}
case MImage_Type_Bit8:
{
raw_t_ubit8* data_in = imgFuns->MImage_getByteData(image_in);
raw_t_ubit8* data_out = imgFuns->MImage_getByteData(image_out);
if (!data_in || !data_out) {
err = LIBRARY_FUNCTION_ERROR;
goto cleanup;
}
src = cvCreateImage( cvSize(w, h), IPL_DEPTH_8U, 1);
dst = cvCreateImage( cvSize(w, h), IPL_DEPTH_8U, 1);
src_data_byte = src->imageData;
dst_data_byte = dst->imageData;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
(src_data_byte + i*src->widthStep)[j] = data_in[i*w+j];
}
}
cvDilate(src, dst, element, 1);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
data_out[i*w+j] = (dst_data_byte + i*dst->widthStep)[j];
}
}
break;
}
case MImage_Type_Bit16:
{
raw_t_ubit16* data_in = imgFuns->MImage_getBit16Data(image_in);
raw_t_ubit16* data_out = imgFuns->MImage_getBit16Data(image_out);
if (!data_in || !data_out) {
err = LIBRARY_FUNCTION_ERROR;
goto cleanup;
}
src = cvCreateImage( cvSize(w, h), IPL_DEPTH_16U, 1);
dst = cvCreateImage( cvSize(w, h), IPL_DEPTH_16U, 1);
src_data_bit16 = src->imageData;
dst_data_bit16 = dst->imageData;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
(src_data_bit16 + i*src->widthStep)[j] = data_in[i*w+j];
}
}
cvDilate(src, dst, element, 1);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
data_out[i*w+j] = (dst_data_bit16 + i*dst->widthStep)[j];
}
}
break;
}
case MImage_Type_Real32:
{
raw_t_real32* data_in = imgFuns->MImage_getReal32Data(image_in);
raw_t_real32* data_out = imgFuns->MImage_getReal32Data(image_out);
if (!data_in || !data_out) {
err = LIBRARY_FUNCTION_ERROR;
goto cleanup;
}
src = cvCreateImage( cvSize(w, h), IPL_DEPTH_32F, 1);
dst = cvCreateImage( cvSize(w, h), IPL_DEPTH_32F, 1);
src_data_real32 = src->imageData;
dst_data_real32 = dst->imageData;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
(src_data_real32 + i*src->widthStep)[j] = data_in[i*w+j];
}
}
cvDilate(src, dst, element, 1);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
data_out[i*w+j] = (dst_data_real32 + i*dst->widthStep)[j];
}
}
break;
}
case MImage_Type_Real:
{
raw_t_real64* data_in = imgFuns->MImage_getRealData(image_in);
raw_t_real64* data_out = imgFuns->MImage_getRealData(image_out);
if (!data_in || !data_out) {
err = LIBRARY_FUNCTION_ERROR;
goto cleanup;
}
src = cvCreateImage( cvSize(w, h), IPL_DEPTH_32F, 1);
dst = cvCreateImage( cvSize(w, h), IPL_DEPTH_32F, 1);
src_data_real32 = src->imageData;
dst_data_real32 = dst->imageData;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
(src_data_real32 + i*src->widthStep)[j] = (raw_t_real32)data_in[i*w+j];
}
}
cvDilate(src, dst, element, 1);
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
data_out[i*w+j] = (dst_data_real32 + i*dst->widthStep)[j];
}
}
break;
}
default:
return LIBRARY_FUNCTION_ERROR;
}
cleanup:
if(src) cvReleaseImage( &src );
if(dst) cvReleaseImage( &dst );
if(element) cvReleaseStructuringElement(&element);
if(err == 0) {
MArgument_setMImage(res, image_out);
}
else {
if(image_out) imgFuns->MImage_free(image_out);
}
return err;
}
