static void xcreate (mxArray *mnode, int i, VlHIKMNode *node) { int node_K = vl_ikm_get_K (node->filter) ; int M = vl_ikm_get_ndims (node->filter) ; vl_ikm_acc const *centers = vl_ikm_get_centers (node->filter) ; mxArray *mcenters ; mcenters = mxCreateNumericMatrix (M, node_K, mxINT32_CLASS, mxREAL); memcpy (mxGetPr(mcenters), centers, sizeof(vl_ikm_acc) * M * node_K) ; mxSetField (mnode, i, "centers", mcenters) ; if (node->children) { mxArray * msub ; const char * field_names[] = {"centers", "sub" } ; mwSize dims [2] ; int k ; dims[0] = 1 ; dims[1] = node_K ; msub = mxCreateStructArray (2, dims, 2, field_names) ; for (k = 0 ; k < node_K ; ++k) { xcreate (msub, k, node -> children [k]) ; } mxSetField (mnode, i, "sub", msub) ; } }
static VlHIKMNode * xcreate (VlHIKMTree *tree, mxArray const *mnode, int i) { mxArray const *mcenters, *msub ; VlHIKMNode *node ; vl_size M, node_K ; vl_uindex k ; /* sanity checks */ mcenters = mxGetField(mnode, i, "centers") ; msub = mxGetField(mnode, i, "sub") ; if (!mcenters || mxGetClassID (mcenters) != mxINT32_CLASS || !vlmxIsMatrix (mcenters, -1, -1) ) { mexErrMsgTxt("NODE.CENTERS must be a INT32 matrix.") ; } M = mxGetM (mcenters) ; node_K = mxGetN (mcenters) ; if (node_K > (vl_size)tree->K) { mexErrMsgTxt("A node has more clusters than TREE.K.") ; } if (tree->M < 0) { tree->M = M ; } else if (M != (vl_size)tree->M) { mexErrMsgTxt("A node CENTERS field has inconsistent dimensionality.") ; } node = mxMalloc (sizeof(VlHIKMNode)) ; node->filter = vl_ikm_new (tree->method) ; node->children = 0 ; vl_ikm_init (node->filter, mxGetData(mcenters), M, node_K) ; /* has any childer? */ if (msub) { /* sanity checks */ if (mxGetClassID (msub) != mxSTRUCT_CLASS) { mexErrMsgTxt("NODE.SUB must be a MATLAB structure array.") ; } if (mxGetNumberOfElements (msub) != node_K) { mexErrMsgTxt("NODE.SUB size must correspond to NODE.CENTERS.") ; } node-> children = mxMalloc (sizeof(VlHIKMNode *) * node_K) ; for(k = 0 ; k < node_K ; ++ k) { node-> children [k] = xcreate (tree, msub, k) ; } } return node ; }
static VlHIKMTree* python_to_hikm(VlHIKMTree_python & inTree, int method_type) { VlHIKMTree *tree = new VlHIKMTree; tree-> depth = inTree.depth; tree-> K = inTree.K; tree-> M = -1; /* to be initialized later */ tree-> method = method_type; tree-> root = xcreate(tree, inTree); return tree; }
mxArray * hikm_to_matlab (VlHIKMTree * tree) { int K = vl_hikm_get_K (tree) ; int depth = vl_hikm_get_depth (tree) ; mwSize dims [2] = {1, 1} ; mxArray *mtree ; const char *field_names[] = {"K", "depth", "centers", "sub"} ; /* Create the main struct array */ mtree = mxCreateStructArray (2, dims, NFIELDS(field_names), field_names) ; mxSetField (mtree, 0, "K", mxCreateDoubleScalar (K)) ; mxSetField (mtree, 0, "depth", mxCreateDoubleScalar (depth)) ; if (tree->root) xcreate (mtree, 0, tree->root) ; return mtree; }
static VlHIKMNode * xcreate(VlHIKMTree *tree, VlHIKMTree_python & inTree) { VlHIKMNode *node; int M, node_K, k; PyArrayObject * centers = (PyArrayObject *) inTree.centers; M = centers->dimensions[0]; node_K = centers->dimensions[1]; if (node_K > tree->K) { printf("%d / %d\n", node_K, tree->K); printf("A node has more clusters than TREE.K.\n"); } if (tree->M < 0) { tree->M = M; } else if (M != tree->M) { printf("%d / %d\n", M, tree->M); printf("A node CENTERS field has inconsistent dimensionality.\n"); } node = new VlHIKMNode; node->filter = vl_ikm_new(tree->method); node->children = 0; vl_ikm_init(node->filter, (vl_ikm_acc*) centers->data, M, node_K); /* has any childer? */ if (inTree.sub.size() > 0) { /* sanity checks */ if (inTree.sub.size() != node_K) { printf("%d, %d\n", (int)inTree.sub.size(), node_K); printf("NODE.SUB size must correspond to NODE.CENTERS.\n"); } node-> children = new VlHIKMNode*[node_K]; for (k = 0; k < node_K; ++k) { PyArrayObject * centers = (PyArrayObject *) inTree.sub[k].centers; node-> children[k] = xcreate(tree, inTree.sub[k]); } } return node; }
void nohup_main(void) { xsignal(SIGHUP, SIG_IGN); if (isatty(1)) { close(1); if (-1 == open("nohup.out", O_CREAT|O_APPEND|O_WRONLY, S_IRUSR|S_IWUSR )) { char *temp = getenv("HOME"); temp = xmprintf("%s/%s", temp ? temp : "", "nohup.out"); xcreate(temp, O_CREAT|O_APPEND|O_WRONLY, 0600); free(temp); } } if (isatty(0)) { close(0); xopen_stdio("/dev/null", O_RDONLY); } xexec(toys.optargs); }
/* Create a locked file. */ int createlock( const char *path, int flags, uid_t uid, gid_t gid, mode_t mode, u_int locks) { int fd, saved_errno; if (mklock(locks, path) != 0) return (-1); if ((fd = xcreate(path, flags, uid, gid, mode)) == -1) goto error; if (lockfd(locks, fd) != 0) goto error; return (fd); error: saved_errno = errno; close(fd); rmlock(locks, path); errno = saved_errno; return (-1); }
/* Make lock file. */ int mklock(u_int locks, const char *path) { char lock[MAXPATHLEN]; int fd; if (!(locks & LOCK_DOTLOCK)) return (0); if (ppath(lock, sizeof lock, "%s.lock", path) != 0) return (-1); fd = xcreate(lock, O_WRONLY, -1, -1, S_IRUSR|S_IWUSR); if (fd == -1) { if (errno == EEXIST) errno = EAGAIN; return (-1); } close(fd); cleanup_register(lock); return (0); }
static VlHIKMTree* matlab_to_hikm (mxArray const *mtree, int method_type) { VlHIKMTree *tree ; mxArray *mK, *mdepth ; int K = 0, depth = 0; VL_USE_MATLAB_ENV ; if (mxGetClassID (mtree) != mxSTRUCT_CLASS) { mexErrMsgTxt("TREE must be a MATLAB structure.") ; } mK = mxGetField(mtree, 0, "K") ; mdepth = mxGetField(mtree, 0, "depth") ; if (!mK || !uIsRealScalar (mK) || (K = (int) *mxGetPr (mK)) < 1) { mexErrMsgTxt("TREE.K must be a DOUBLE not smaller than one.") ; } if (!mdepth || !uIsRealScalar (mdepth) || (depth = (int) *mxGetPr (mdepth)) < 1) { mexErrMsgTxt("TREE.DEPTH must be a DOUBLE not smaller than one.") ; } tree = mxMalloc (sizeof(VlHIKMTree)) ; tree-> depth = depth ; tree-> K = K ; tree-> M = -1 ; /* to be initialized later */ tree-> method= method_type ; tree-> root = xcreate (tree, mtree, 0) ; return tree ; }