void RTreeClassifier::train(std::vector<BaseKeypoint> const& base_set, Rng &rng, int num_trees, int depth, int views, size_t reduced_num_dim, int num_quant_bits) { PatchGenerator make_patch(NULL, rng); train(base_set, rng, make_patch, num_trees, depth, views, reduced_num_dim, num_quant_bits); }
int main (int argc, char *argv[]) { if (argc != 3) abort (); setlocale (LC_ALL, "C"); int exit_code = 1; const char *db_file = argv[1]; const char *nameslist_file = argv[2]; uninm_names_db db = uninm_names_db_open (db_file); if (db != NULL) { char nameslist[2000000]; memset (nameslist, 0, sizeof nameslist); FILE *f = fopen (nameslist_file, "rb"); (void) fread (nameslist, 1, sizeof nameslist, f); fclose (f); int failure_count = 0; // Test the codepoints up to 0x10FFFF. for (int codepoint = 0; codepoint <= 0x10FFFF; codepoint++) { char *patch = make_patch (db, codepoint); if (patch != NULL) { if (strstr (nameslist, patch) == NULL) { (void) printf ("Failure: codepoint = %X\n", codepoint); failure_count++; } free (patch); } } if (failure_count == 0) exit_code = 0; uninm_names_db_close (db); } return exit_code; }
void push_changes(lua_State *l, const char *base_path, const char *full_path) { struct dirent **dir_list = NULL; struct dirent *dir = NULL; int results; int i; int rv; char *path; if (strncmp(base_path, full_path, strlen(base_path)) != 0) die("wtf? %s != %s len %li", base_path, full_path, strlen(base_path)); gettimeofday(&now, NULL); path = strdup(full_path + strlen(base_path) + 1); /* Skip trailing slash in full_path */ log_debug("relative path is %s", path); scandir_baton_t baton; baton.ig = root_ignores; baton.base_path = base_path; baton.level = 0; results = ds_scandir(full_path, &dir_list, &changed_filter, &baton); if (results == -1) { log_debug("Error scanning directory %s: %s", full_path, strerror(errno)); return; } else if (results == 0) { log_debug("No results found in directory %s", full_path); return; } char *file_path; char *file_path_rel; for (i = 0; i < results; i++) { dir = dir_list[i]; ds_asprintf(&file_path, "%s%s", full_path, dir->d_name); ds_asprintf(&file_path_rel, "%s%s", path, dir->d_name); if (is_ignored(file_path)) { /* we triggered this event */ unignore_change(file_path); goto cleanup; } if (is_directory(full_path, dir)) { /* TODO: figure out if we need to recurse */ goto cleanup; } buf_t *buf = get_buf(file_path_rel); if (buf == NULL) { log_err("buf not found for path %s", file_path_rel); goto cleanup; } const char *f2 = file_path; mmapped_file_t *mf; struct stat file_stats; off_t f2_size; rv = lstat(f2, &file_stats); if (rv) { die("Error lstat()ing file %s.", f2); } f2_size = file_stats.st_size; if (f2_size == 0) { log_debug("%s is empty"); goto cleanup; } mf = mmap_file(f2, f2_size, 0, 0); if (is_binary(mf->buf, mf->len)) { log_debug("%s is binary. skipping", file_path); goto diff_cleanup; } char *new_text = strndup(mf->buf, mf->len); char *patch_text = make_patch(l, buf->buf, new_text); free(new_text); if (strlen(patch_text) == 0) { log_debug("no change. not sending patch"); goto diff_cleanup; } char *md5_after = md5(mf->buf, mf->len); send_json( "{s:s s:i s:s s:s s:s s:s}", "name", "patch", "id", buf->id, "patch", patch_text, "path", buf->path, "md5_before", buf->md5, "md5_after", md5_after ); free(md5_after); free(patch_text); buf->buf = realloc(buf->buf, mf->len + 1); buf->len = mf->len; memcpy(buf->buf, mf->buf, buf->len); diff_cleanup:; munmap_file(mf); free(mf); cleanup:; free(file_path); free(file_path_rel); free(dir); } free(dir_list); free(path); }
/// Draw the entire boundary network, mapping disorientations vtkPolyData* Dataset::boundary_network() { int i,j,k = 0; int num_quads = 0, new_quads = 0, buffer_count = 1; int num_vertices = 0; AdjGrain* adj_grain; Quad *quads; XYZ p; Point *d = data; // Allocate buffer for quads (faces) // We will expand this as required quads = (Quad*) malloc(sizeof(Quad)*QUAD_BUFFER); if (quads == NULL) { return 0; } // Cycle through each //-------------------------------------------------- for(i=0;i<nv;i++){ d++; if (d->grain>=0) { // Calcuate the x,y,z coordinates from the voxel index //-------------------------------------------------- p.x = (i/dx) % tx; p.y = (i/dy) % ty; p.z = (i/dz) % tz; // Check if we need to increase the size of the quad buffer //-------------------------------------------------- if(num_quads+24 > buffer_count*QUAD_BUFFER) { quads = (Quad*) realloc(quads, sizeof(Quad)*(++buffer_count)*QUAD_BUFFER); if (quads == NULL) { return 0; } } // Check adjacent voxels in the positive x,y,z directions // and add a quad if they're not in the same grain //-------------------------------------------------- if(p.x<tx-1 && (d+dx)->grain>=0 && (d+dx)->grain != d->grain){ make_patch(p,X,+1,quads+num_quads, steps,(d+dx)->grain,d->grain); num_quads++; } if(p.y<ty-1 && (d+dy)->grain>=0 && (d+dy)->grain != d->grain){ make_patch(p,Y,+1,quads+num_quads, steps,(d+dy)->grain,d->grain); num_quads++; } if(p.z<tz-1 && (d+dz)->grain>=0 && (d+dz)->grain != d->grain){ make_patch(p,Z,+1,quads+num_quads, steps,(d+dz)->grain,d->grain); num_quads++; } } } printf("Number of quads: %i\n",num_quads); // Create a symmetric matrix of disorientations between all (adjacent) grains // for fast access - we'll be doing lots of these lookups. //-------------------------------------------------- float *dis = NULL; dis = (float*) malloc(num_grains*num_grains*sizeof(float)); if (dis == NULL) { return 0; } // initialise the disorientations to invalid value for debugging // this can be safely removed in implementation for(i=0;i<num_grains;i++){ for(j=0;j<num_grains;j++){ dis[j+i*num_grains] = 100; }} for(i=0;i<num_grains;i++){ for(j=0;j<grains[i].num_adj_grains;j++){ adj_grain = grains[i].adj_grains+j; dis[i+num_grains*adj_grain->grain] = adj_grain->disorientation; dis[adj_grain->grain+num_grains*i] = adj_grain->disorientation; } } //-------------------------------------------------- // Set up the VTK objects //-------------------------------------------------- vtkPoints* pts=vtkPoints::New(); pts->SetNumberOfPoints(num_quads*4); vtkCellArray* gquads = vtkCellArray::New(); int size = gquads->EstimateSize(num_quads,4); gquads->Allocate(10, 5); // ptr is direct pointer to underlying gquads representation, // see VTK documentation for details int *ptr = (int*) gquads->WritePointer(num_quads,size); // colors is VTK array storing the disorientation value for each face vtkFloatArray* colours = vtkFloatArray::New(); colours->SetName("disorientations"); colours->SetNumberOfComponents(1); colours->SetNumberOfTuples(num_quads); // Fill the VTK objects //-------------------------------------------------- for(i=0;i<num_quads;i++){ colours->InsertValue( i, dis[quads[i].grain1+quads[i].grain2*num_grains] ); *(ptr++) = 4; for(j=0;j<4;j++){ *(ptr++) = k; pts->SetPoint(k, (double)quads[i].p[j].x, (double)quads[i].p[j].y, (double)quads[i].p[j].z); k++; } } vtkPolyData* surface = vtkPolyData::New(); surface->SetPoints(pts); surface->SetPolys(gquads); surface->GetCellData()->SetScalars(colours); // Clean up //-------------------------------------------------- free(quads); pts->Delete(); gquads->Delete(); free(dis); return surface; }