void eecs467_default_display_finished (vx_application_t *app, vx_display_t *disp) { eecs467_default_implementation_t *impl = app->impl; pthread_mutex_lock (&impl->mutex); vx_layer_t *layer = NULL; zhash_remove (impl->layers, &disp, NULL, &layer); vx_layer_destroy (layer); pthread_mutex_unlock (&impl->mutex); }
static void display_finished(vx_application_t * app, vx_display_t * disp) { state_t * state = app->impl; pthread_mutex_lock(&state->mutex); vx_layer_t * layer = NULL; // store a reference to the world and layer that we associate with each vx_display_t zhash_remove(state->layers, &disp, NULL, &layer); vx_layer_destroy(layer); pthread_mutex_unlock(&state->mutex); }
static void display_finished(vx_application_t * app, vx_display_t * disp) { state_t * state = app->impl; pthread_mutex_lock(&state->mutex); vx_layer_t * layer = NULL; // store a reference to the world and layer that we associate with each vx_display_t zhash_remove(state->layers, &disp, NULL, &layer); vx_layer_destroy(layer); // Exit after the last remote connection is closed if (zhash_size(state->layers) == 0) { state->running = 0; } pthread_mutex_unlock(&state->mutex); }
// Pass in a codes describing which resources are no longer in use. Decrement user counts, // and return a list of all resources whos counts have reached zero, which therefore // should be deleted from the display using a OP_DEALLOC_RESOURCES opcode void vx_resc_manager_buffer_resources(vx_resc_manager_t * mgr, const uint8_t * data, int datalen) { if (0) print_manager(mgr); vx_code_input_stream_t * cins = vx_code_input_stream_create(data, datalen); int code = cins->read_uint32(cins); assert(code == OP_BUFFER_RESOURCES); int worldID = cins->read_uint32(cins); char * name = strdup(cins->read_str(cins)); //freed when cur_resources is eventually removed from the buffer map int count = cins->read_uint32(cins); zhash_t * cur_resources = zhash_create(sizeof(uint64_t), sizeof(vx_resc_t*), zhash_uint64_hash, zhash_uint64_equals); vx_resc_t * vr = NULL; for (int i = 0; i < count; i++) { uint64_t id = cins->read_uint64(cins); zhash_put(cur_resources, &id, &vr, NULL, NULL); } assert(cins->pos == cins->len); // we've emptied the stream vx_code_input_stream_destroy(cins); // 1 Update our records zhash_t * worldBuffers = NULL; zhash_get(mgr->allLiveSets, &worldID, &worldBuffers); if (worldBuffers == NULL) { worldBuffers = zhash_create(sizeof(char*), sizeof(zhash_t*), zhash_str_hash, zhash_str_equals); zhash_put(mgr->allLiveSets, &worldID, &worldBuffers, NULL, NULL); } zhash_t * old_resources = NULL; char * old_name = NULL; zhash_put(worldBuffers, &name, &cur_resources, &old_name, &old_resources); free(old_name); // 2 Figure out which resources have become unused: if(old_resources != NULL) { removeAll(old_resources, cur_resources); zarray_t * dealloc = zarray_create(sizeof(uint64_t)); // now 'old_resources' contains only the resources that are no longer referenced // iterate through each one, and see if there is a buffer somewhere that references it zhash_iterator_t prev_itr; zhash_iterator_init(old_resources, &prev_itr); uint64_t id = -1; vx_resc_t * vr = NULL; while(zhash_iterator_next(&prev_itr, &id, &vr)) { // Check all worlds zhash_iterator_t world_itr;// gives us all worlds zhash_iterator_init(mgr->allLiveSets, &world_itr); uint32_t wIDl = -1; zhash_t * buffer_map = NULL; while(zhash_iterator_next(&world_itr, &wIDl, &buffer_map)) { zhash_iterator_t buffer_itr; // gives us all buffers zhash_iterator_init(buffer_map, &buffer_itr); char * bName = NULL; zhash_t * resc_map = NULL; while(zhash_iterator_next(&buffer_itr, &bName, &resc_map)) { if (zhash_contains(resc_map, &id)) { goto continue_outer_loop; } } } // If none of the worlds have this resource, we need to flag removal zarray_add(dealloc, &id); continue_outer_loop: ; } // 3 Issue dealloc commands if (zarray_size(dealloc) > 0) { vx_code_output_stream_t * couts = vx_code_output_stream_create(512); couts->write_uint32(couts, OP_DEALLOC_RESOURCES); couts->write_uint32(couts, zarray_size(dealloc)); for (int i = 0; i < zarray_size(dealloc); i++) { uint64_t id = 0; zarray_get(dealloc, i, &id); couts->write_uint64(couts, id); } mgr->disp->send_codes(mgr->disp, couts->data, couts->pos); vx_code_output_stream_destroy(couts); // Also remove the resources we deallocated from remoteResc for (int i = 0; i < zarray_size(dealloc); i++) { uint64_t id = 0; zarray_get(dealloc, i, &id); assert(zhash_contains(mgr->remoteResc, &id)); zhash_remove(mgr->remoteResc, &id, NULL, NULL); } } zarray_destroy(dealloc); zhash_destroy(old_resources); } if (0) { print_manager(mgr); printf("\n\n"); } }
void hsv_find_balls_blob_detector(image_u32_t* im, frame_t frame, metrics_t met, zarray_t* blobs_out) { assert(frame.xy0.x < frame.xy1.x && frame.xy0.y < frame.xy1.y); assert(frame.xy0.x >= 0 && frame.xy0.y >= 0 && frame.xy1.x < im->width && frame.xy1.y < im->height); assert(frame.ex0.x < frame.ex1.x && frame.ex0.y < frame.ex1.y); assert(frame.ex0.x >= 0 && frame.ex0.y >= 0 && frame.ex1.x < im->width && frame.ex1.y < im->height); // Int to node zhash_t* node_map = zhash_create(sizeof(uint32_t), sizeof(node_t*), zhash_uint32_hash, zhash_uint32_equals); for(int i = frame.xy0.y; i < frame.xy1.y; i++) { for(int j = frame.xy0.x; j < frame.xy1.x; j++) { if((i < frame.ex0.y || i > frame.ex1.y) || (j < frame.ex0.x || j > frame.ex1.x)) { uint32_t idx_im = i * im->stride + j; // Indframe.ex relative to image // Pixel color data uint32_t abgr = im->buf[idx_im]; hsv_t hsv = {0,0,0}; rgb_to_hsv(abgr, &hsv); hsv_t error = {fabs(hsv.hue - met.hsv.hue), fabs(hsv.sat - met.hsv.sat), fabs(hsv.val - met.hsv.val)}; // 'Acceptable' if((error.hue < met.error.hue) && (error.sat < met.error.sat) && (error.val < met.error.val)) { // Create new node, set itself up as a parent node_t* n = calloc(1, sizeof(node_t)); n->id = idx_im; n->parent_id = idx_im; n->parent_node = n; n->num_children = 0; node_t* tmp_node; uint32_t tmp_idx; // Add node to node map if(zhash_put(node_map, &idx_im, &n, &tmp_idx, &tmp_node)==1) { assert(0); } //Check if apart of another blob, or starting a new blob // if apart of another, point to the parent, if a new blob, point to self //Check neighbours if(!met.lines) { // only check this if don't want lines for tape detection if(j > frame.xy0.x) { tmp_idx = idx_im - 1; // is Left neighbour similar color if(zhash_get(node_map, &tmp_idx, &tmp_node) == 1) { node_t* neighbour = tmp_node; connect(n, neighbour); } } } if(i > frame.xy0.y) { tmp_idx = idx_im - im->stride; // is Bottom neighbor similar color if(tmp_idx > 0 && zhash_get(node_map, &tmp_idx, &tmp_node) == 1) { node_t* neighbour = tmp_node; connect(neighbour,n); } } } } } } //count number of children for each parent, go through node_map // if a node is not a parent, add 1 to it's parent->num_children and delete from hash // if is a parent do nothing zarray_t* vals = zhash_values(node_map); for(int i = 0; i < zarray_size(vals); i++) { node_t* node; zarray_get(vals, i, &node); resolve_r(node); if(node->parent_id != node->id) { node->parent_node->num_children++; // key should exist, if it doesn't find out why assert(zhash_remove(node_map, &node->id, NULL, NULL)); } } // search parent only hash and add to blobs out conditionally vals = zhash_values(node_map); for(int i = 0; i < zarray_size(vals); i++) { node_t* node; zarray_get(vals, i, &node); if(node->num_children > met.min_size) { loc_t pos; pos.x = node->parent_id%im->stride; pos.y = node->parent_id/im->stride; zarray_add(blobs_out, &pos); // printf("parent %d\n", node->id); } } zarray_destroy(vals); zhash_vmap_values(node_map, free); zhash_destroy(node_map); }