void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // Check number of arguments if (nrhs != 1) mexErrMsgTxt("Unexpected number of input arguments."); if (nlhs != 1) mexErrMsgTxt("Unexpected number of output arguments."); // Check argument types are valid if (mxGetClassID(prhs[0]) != mxDOUBLE_CLASS || mxIsComplex(prhs[0])) mexErrMsgTxt("Input must be a real double matrix"); int nparams = mxGetM(prhs[0]); if (nparams != 3 && nparams != 6 && nparams != 7) mexErrMsgTxt("Input must have 3, 6 or 7 rows"); // Construct the output array int ndims = mxGetNumberOfDimensions(prhs[0]); if (ndims > 19) mexErrMsgTxt("Input has an unsupported number of dimensions"); size_t out_dims[20]; out_dims[0] = 3; out_dims[1] = 3 + (nparams != 3); const mwSize *dims = mxGetDimensions(prhs[0]); int nmatrices = 1; for (int a = 1; a < ndims; ++a) { out_dims[a+1] = dims[a]; nmatrices *= dims[a]; } plhs[0] = mxCreateUninitNumericArray(ndims+1, out_dims, mxDOUBLE_CLASS, mxREAL); double *out = (double *)mxGetData(plhs[0]); // Get the data pointers and strides double *r = (double *)mxGetData(prhs[0]); double *t = NULL; int t_stride = 0; if (nparams > 3) { t = r + 3; t_stride = nparams; } double s_ = 0; double *s = &s_; int s_stride = 0; if (nparams == 7) { s = r + 6; s_stride = 7; } int out_stride = 3 * (3 + (nparams != 3)); // Call the expm function int a; #pragma omp parallel for if (nmatrices > 1000) num_threads(omp_get_num_procs()) default(shared) private(a) for (a = 0; a < nmatrices; ++a) expm_srt_3d(&out[out_stride*a], &r[nparams*a], &t[t_stride*a], s[s_stride*a]); return; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // Check number of arguments if (nrhs < 3 || nrhs > 5) mexErrMsgTxt("Unexpected number of input arguments."); if (nlhs < 1 || nlhs > 2) mexErrMsgTxt("Unexpected number of output arguments."); // Check argument types are valid mxClassID in_class = mxGetClassID(prhs[1]); if (mxGetClassID(prhs[2]) != in_class) mexErrMsgTxt("X and Y must be arrays of the same type"); for (int i = 0; i < nrhs; ++i) { if (mxIsComplex(prhs[i])) mexErrMsgTxt("Inputs cannot be complex."); } // Get and check array dimensions int num_points = static_cast<int>(mxGetNumberOfElements(prhs[1])); if (num_points != static_cast<int>(mxGetNumberOfElements(prhs[2]))) mexErrMsgTxt("X and Y must have the same dimensions"); int ndims = static_cast<int>(mxGetNumberOfDimensions(prhs[0])); std::vector<size_t> out_dims(ndims+2); out_dims[0] = 2; out_dims[1] = mxGetM(prhs[1]); out_dims[2] = mxGetN(prhs[1]); const mwSize *dims = mxGetDimensions(prhs[0]); out_dims[3] = 1; int nchannels = 1; for (int i = 2; i < ndims; ++i) { out_dims[i+1] = dims[i]; nchannels *= static_cast<int>(dims[i]); } // Get the out of bounds value (oobv) and set the output class to the same class as the oobv. double oobv; mxClassID out_class; if (nrhs > 4) { // Get the value for oobv if (mxGetNumberOfElements(prhs[4]) != 1) mexErrMsgTxt("oobv must be a scalar."); oobv = mxGetScalar(prhs[4]); out_class = mxGetClassID(prhs[4]); } else { // Use the default value for oobv oobv = mxGetNaN(); out_class = in_class; } // Create the output arrays plhs[0] = mxCreateUninitNumericArray(ndims, &out_dims[1], out_class, mxREAL); void *B = mxGetData(plhs[0]); void *G = NULL; if (nlhs > 1) { plhs[1] = mxCreateUninitNumericArray(ndims+1, &out_dims[0], out_class, mxREAL); G = mxGetData(plhs[1]); } // Get the interpolation method char buffer[10] = {'l'}; int k = 0; if (nrhs > 3) { // Read in the method string if (mxGetString(prhs[3], buffer, sizeof(buffer))) mexErrMsgTxt("Unrecognised interpolation method"); // Remove '*' from the start k += (buffer[k] == '*'); // Remove 'bi' from the start k += 2 * ((buffer[k] == 'b') & (buffer[k+1] == 'i')); } // Get pointer to the input image const void *A = mxGetData(prhs[0]); // Call the first wrapper function according to the input image type const int width = static_cast<int>(dims[1]); const int height = static_cast<int>(dims[0]); switch (mxGetClassID(prhs[0])) { case mxDOUBLE_CLASS: wrapper_func(B, G, (const double *)A, prhs, num_points, width, height, nchannels, oobv, buffer[k], out_class, in_class); break; case mxSINGLE_CLASS: wrapper_func(B, G, (const float *)A, prhs, num_points, width, height, nchannels, oobv, buffer[k], out_class, in_class); break; case mxINT8_CLASS: wrapper_func(B, G, (const int8_t *)A, prhs, num_points, width, height, nchannels, oobv, buffer[k], out_class, in_class); break; case mxUINT8_CLASS: wrapper_func(B, G, (const uint8_t *)A, prhs, num_points, width, height, nchannels, oobv, buffer[k], out_class, in_class); break; case mxINT16_CLASS: wrapper_func(B, G, (const int16_t *)A, prhs, num_points, width, height, nchannels, oobv, buffer[k], out_class, in_class); break; case mxUINT16_CLASS: wrapper_func(B, G, (const uint16_t *)A, prhs, num_points, width, height, nchannels, oobv, buffer[k], out_class, in_class); break; case mxLOGICAL_CLASS: wrapper_func(B, G, (const mxLogical *)A, prhs, num_points, width, height, nchannels, oobv, buffer[k], out_class, in_class); break; default: mexErrMsgTxt("A is of an unsupported type"); break; } return; }
bool* shared_lib_func(unsigned char* raw, V3DLONG total_bytes, V3DLONG unit_bytes, V3DLONG x, V3DLONG y, V3DLONG z, V3DLONG t,int paran, double* para,std::string fileDir){ std::cerr << "Matlab Part Start." << std::endl; // Initialize the MATLAB Compiler Runtime global state /*if (!mclInitializeApplication(NULL, 0)) { std::cerr << "Could not initialize the application properly." << mclGetLastErrorMessage() << 'Z' << std::endl; //return -1; }*/ // Initialize the Vigenere library if (!libvaa_port_testInitialize()) { std::cerr << "Could not initialize the library properly." << mclGetLastErrorMessage() << 'Z' <<std::endl; //return -1; } std::cout << "Intialization Finished" << std::endl; mxArray *mx_output = NULL; size_t raw_dim[1] = {x*y*z*t}; size_t dim[1] = { 1 }; size_t dim_para[1]; dim_para[0] = paran; mxArray *mx_raw, *mx_unit_bytes, *mx_x, *mx_y, *mx_z, *mx_t, *mx_para,*mx_fileDir; int pause; unsigned char *dynamic_raw = (unsigned char *)mxCalloc(total_bytes, sizeof(UINT8_T)); for (V3DLONG i = 0; i < total_bytes; i++){ dynamic_raw[i] = raw[i]; } mx_raw = mxCreateUninitNumericArray(1, raw_dim, get_mxClass(unit_bytes),mxREAL); mxSetData(mx_raw, dynamic_raw); V3DLONG *dynamic_unit_bytes = (V3DLONG *)mxCalloc(1, sizeof(V3DLONG)); dynamic_unit_bytes[0] = unit_bytes; mx_unit_bytes = mxCreateUninitNumericArray(1, dim, get_mxClass(8), mxREAL); mxSetData(mx_unit_bytes, dynamic_unit_bytes); V3DLONG *dynamic_x = (V3DLONG *)mxCalloc(1, sizeof(V3DLONG)); dynamic_x[0] = x; mx_x = mxCreateUninitNumericArray(1, dim, get_mxClass(8), mxREAL); mxSetData(mx_x, dynamic_x); V3DLONG *dynamic_y = (V3DLONG *)mxCalloc(1, sizeof(V3DLONG)); dynamic_y[0] = y; mx_y = mxCreateUninitNumericArray(1, dim, get_mxClass(8), mxREAL); mxSetData(mx_y, dynamic_y); V3DLONG *dynamic_z = (V3DLONG *)mxCalloc(1, sizeof(V3DLONG)); dynamic_z[0] = z; mx_z = mxCreateUninitNumericArray(1, dim, get_mxClass(8), mxREAL); mxSetData(mx_z, dynamic_z); V3DLONG *dynamic_t = (V3DLONG *)mxCalloc(1, sizeof(V3DLONG)); dynamic_t[0] = t; mx_t = mxCreateUninitNumericArray(1, dim, get_mxClass(8), mxREAL); mxSetData(mx_t, dynamic_t); double *dynamic_para = (double *)mxCalloc(paran, sizeof(double)); for (int i = 0; i < paran; i++){ dynamic_para[i] = para[i]; } mx_para = mxCreateUninitNumericArray(1, dim_para, mxDOUBLE_CLASS, mxREAL); mxSetData(mx_para, dynamic_para); mx_fileDir = mxCreateString(fileDir.c_str()); std::cout << "Assignment Finished\n"; mlfVaa3d_trace3D(1, &mx_output, mx_raw, mx_unit_bytes, mx_x, mx_y, mx_z, mx_t, mx_para,mx_fileDir); //y = (double*)mxGetPr(y_ptr); //std::cout << "answer:" << *y << '\n'; // Shut down the library and the application global state. bool* output = mxGetLogicals(mx_output); mxDestroyArray(mx_raw); std::cout << "free mx raw\n"; //mxDestroyArray(mx_output); //std::cout << "free mx output"; mxDestroyArray(mx_unit_bytes); std::cout << "free mx unit\n"; mxDestroyArray(mx_x); std::cout << "free mx x\n"; mxDestroyArray(mx_y); std::cout << "free mx y\n"; mxDestroyArray(mx_z); std::cout << "free mx z\n"; mxDestroyArray(mx_t); std::cout << "free mx t\n"; mxDestroyArray(mx_para); std::cout << "free mx para\n"; libvaa_port_testTerminate(); //mclTerminateApplication(); std::cout << "Matlab Part Finished." << std::endl; return output; }