region_container* get_polygon(const mxArray * input) {
region_container* p = NULL;
double *r = (double*)mxGetPr(input);
int l = mxGetN(input);
if (l % 2 == 0 && l > 6) {
p = region_create_polygon(l / 2);
for (int i = 0; i < p->data.polygon.count; i++) {
p->data.polygon.x[i] = r[i*2];
p->data.polygon.y[i] = r[i*2+1];
}
} else if (l == 4) {
region_container* t = NULL;
t = region_create_rectangle(r[0], r[1], r[2], r[3]);
p = region_convert(t, POLYGON);
region_release(&t);
}
return p;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
region_container* p = NULL;
if( nrhs < 3 ) mexErrMsgTxt("One vector and two integer arguments required.");
if( nlhs != 1 ) mexErrMsgTxt("Exactly one output argument required.");
if (!MEX_TEST_VECTOR(0) || !MEX_TEST_DOUBLE(0)) mexErrMsgTxt("First argument must be a vector of type double");
region_clear_flags(REGION_LEGACY_RASTERIZATION);
if (nrhs > 3) {
char* codestr = get_string(prhs[3]);
if (strcmpi(codestr, "legacy") == 0)
region_set_flags(REGION_LEGACY_RASTERIZATION);
free(codestr);
}
int width = getSingleInteger(prhs[1]);
int height = getSingleInteger(prhs[2]);
p = get_polygon(prhs[0]);
float* tmp = p->data.polygon.x; p->data.polygon.x = p->data.polygon.y; p->data.polygon.y = tmp;
plhs[0] = mxCreateLogicalMatrix(height, width);
char *result = (char*) mxGetData(plhs[0]);
region_mask(p, result, width, height);
if (p) region_release(&p);
}
t_status interface_region_release(o_syscall* message)
{
t_status error;
error = region_release(message->u.request.u.region_release.arg1,
message->u.request.u.region_release.arg2);
message->u.reply.error = error;
return (STATUS_OK);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
region_type format;
region_container* p;
region_container* c;
if( nrhs != 2 ) mexErrMsgTxt("Two vector arguments (region and format) required.");
if( nlhs != 1 ) mexErrMsgTxt("Exactly one output argument required.");
if (mxGetClassID(prhs[0]) != mxDOUBLE_CLASS)
mexErrMsgTxt("First input argument must be of type double");
if ( mxGetNumberOfDimensions(prhs[0]) > 2 || mxGetM(prhs[0]) > 1 ) mexErrMsgTxt("First input argument must be a vector");
char* codestr = get_string(prhs[1]);
if (!get_region_code(codestr, format)) {
free(codestr);
mexErrMsgTxt("Not a valid format");
}
free(codestr);
p = array_to_region(prhs[0]);
if (!p)
mexErrMsgTxt("Not a valid region vector");
c = region_convert(p, format);
if (!c) {
if (p) region_release(&p);
mexErrMsgTxt("Unable to convert region");
}
plhs[0] = region_to_array(c);
if (c) region_release(&c);
if (p) region_release(&p);
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {
if( nrhs != 2 ) mexErrMsgTxt("Exactly one string input argument and one cell array argument required.");
if( nlhs != 0 ) mexErrMsgTxt("No output arguments required.");
char* path = getString(prhs[0]);
std::vector<Region*> regions;
if (!mxIsCell(prhs[1]))
mexErrMsgTxt("Second argument must be a cell array");
int length = MAX(mxGetM(prhs[1]), mxGetN(prhs[1]));
if ( MIN(mxGetM(prhs[1]), mxGetN(prhs[1])) != 1 )
mexErrMsgTxt("Cell array must be a vector");
for (int i = 0; i < length; i++) {
mxArray* val = mxGetCell (prhs[1], i);
double *d = (double*) mxGetPr(val);
Region* region = NULL;
int l = MAX(mxGetM(val), mxGetN(val));
if (MIN(mxGetM(val), mxGetN(val)) == 1) {
if (l == 1) {
region = region_create_special(d[0]);
} else if (l == 4) {
region = region_create_rectangle(d[0], d[1], d[2], d[3]);
} else if (l > 5 && l % 2 == 0) {
region = region_create_polygon(l / 2);
for (int j = 0; j < l / 2; j++) {
region->data.polygon.x[j] = d[j * 2];
region->data.polygon.y[j] = d[j * 2 + 1];
}
}
}
if (region) {
regions.push_back(region);
} else {
char message[128];
sprintf(message, "Not a valid region at position %d, skipping", i+1);
mexWarnMsgTxt(message);
}
}
std::ofstream ofs;
ofs.open (path, std::ofstream::out | std::ofstream::app);
if (ofs.is_open()) {
for (int i = 0; i < regions.size(); i++) {
Region* region = regions[i];
char * tmp = region_string(region);
if (tmp) {
ofs << tmp << "\n";
free(tmp);
}
region_release(®ion);
}
} else {
free(path);
mexErrMsgTxt("Unable to open file for writing.");
}
ofs.close();
free(path);
}
