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);
}
