int trim_group (group_t* group, unsigned int max_blocks) { block_node_t* tmp_block = *group; block_node_t* prev; unsigned int diff = group_length(group) - max_blocks;; int i; if (group_length(group) <= max_blocks) { return 0; } // go to the end of the group while (tmp_block != NULL) { prev = tmp_block; tmp_block = tmp_block->next; } // delete obsolete blocks while (diff > 0) { tmp_block = prev; prev = get_previous_block (*group, tmp_block); for (i=0; i<tmp_block->block.block_size; ++i) { free (tmp_block->block.data[i]); } free (tmp_block->block.data); free (tmp_block); tmp_block = NULL; prev->next = NULL; --diff; } return 0; }
int value_length(const value& val, int wrap_length) { switch (val.type()) { case value_type::number_type: { return stringize_number(val.number_value()).size(); } case value_type::string_type: { return 2 + escape_string(val.string_value()).size(); } case value_type::bool_type: { return val.bool_value() ? 4 : 5; } case value_type::group_type: { return group_length(val.group_value()); } case value_type::vector_type: { return vector_length(val.vector_value()); } default: { return 0; } } }
void write_group(scanner& sc, writer& wr, bool braces, const group& gr) { bool wrap = !braces || group_length(gr) > wr.wrap_length; if (braces) { wr.append("{ "); wr.indent(); if (wrap) { wr.newline(); } sc.expect('{'); } std::vector<std::string> keys; for (const auto& key : gr) { keys.push_back(key); } while (sc.peek_token().type != token_type::eof_token && !(braces && sc.peek_token().is_char('}'))) { std::string key = sc.expect_identifier(); sc.expect('='); auto key_it = std::find(std::begin(keys), std::end(keys), key); if (key_it != keys.end()) { wr.append(key); wr.append(" = "); write_value(sc, wr, gr.get<value>(*key_it)); keys.erase(key_it); bool terminate = sc.peek_token().is_char('}') && keys.empty(); if (!terminate) { if (wrap) { wr.newline(); } else { wr.append(", "); } } else if (!wrap) { wr.append(" "); } } else { read_value(sc); } sc.expect(',', true); if (braces && sc.peek_token().is_char('}')) { break; } } unsigned int i = 0; for (const auto& key : keys) { wr.append(key); wr.append(" = "); scanner dummy_scanner = make_scanner("0"); write_value(dummy_scanner, wr, gr.get<value>(key)); if (i < keys.size() - 1) { if (wrap) { wr.newline(); } else { wr.append(", "); } } else if (!wrap) { wr.append(" "); } i++; } if (braces) { wr.unindent(); if (wrap) { wr.newline(); } sc.expect('}'); wr.append("}"); } }
int print_list (list_t const list, char* const path, char* const prefix) { FILE* fd = 0; group_node_t* tmp = list; block_node_t* tmp_block; char groupname[40]; int count = 0; while (tmp != NULL) { //obtain output filename if (get_output_filename (groupname, path, prefix, "txt", ++count) != 0) { generate_error ("Unable to process output filename for group..."); return 1; } fd = fopen (groupname, "w"); if (fd == NULL) { generate_error ("Unable to open file for printing group..."); return 1; } tmp_block = tmp->group; fprintf (fd, "[INFO] ... nr of blocks in group: %d\n", group_length(&tmp_block)); if (strstr(path, "est") != NULL) { fprintf (fd, "[INFO] ... group weight: %f\n", tmp->weight); } fprintf (fd, "\n"); fprintf (fd, "[INFO] ... reference block...\n"); while (tmp_block != NULL) { print_block (fd, tmp_block->block); fprintf (fd, "[INFO] ... block position: (%d/%d)\n", tmp_block->block.x, tmp_block->block.y); fprintf (fd, "[INFO] ... distance to reference block: %f\n", tmp_block->distance); tmp_block = tmp_block->next; } tmp = tmp->next; fclose (fd); } return 0; }
int shrinkage (char* const kind, list_t* list, int const sigma, double const th_3d, int const channel) { FILE* fd = 0; char outfile[40]; char path[30]; char ch; group_node_t* tmp = *list; block_node_t* group; unsigned int z; int count = 0; // obtain letter for channel ch = (channel==0) ? 'y' : (channel==1) ? 'u' : (channel==2) ? 'v' : 0; // determine path for file-writing sprintf (path, "dns/%s/%c/grp/", kind, ch); while (tmp != NULL) { group = tmp->group; z = group_length (&group); unsigned int len = group->block.block_size; double arr[z][len][len]; //obtain output filename if (get_output_filename (outfile, path, "group", "txt", ++count) != 0) { generate_error ("Unable to process output filename for group..."); return 1; } fd = fopen (outfile, "a"); if (fd == NULL) { generate_error ("Unable to open file for printing group..."); return 1; } // build a 3D-array from the actual group group2array (&group, len, z, arr); // append extracted group to log-file array2file (fd, len, z, arr, "extracted group"); // perform 3D transformation if necessary if (!strcmp(kind, "ht") || !strcmp(kind, "wnr")) { // perform 3D-DCT dct_3d (len, z, arr); // append transformed group to log-file array2file (fd, len, z, arr, "group after 3D-DCT transformation"); } // perform actual shrinkage operation if (!strcmp(kind, "avg")) { average_3d (len, z, arr); } else if (!strcmp(kind, "ht")) { hard_threshold_3d (len, z, arr, th_3d, sigma); } else if (!strcmp(kind, "wnr")) { wiener_3d (len, z, arr, sigma); } else if (!strcmp(kind, "none")) { // do nothing } else { generate_error ("Invalid kind of shrinkage..."); return 1; } // append thresholded group to log-file array2file (fd, len, z, arr, "group after 3D-shrinkage-operation"); // transform back if (!strcmp(kind, "ht") || !strcmp(kind, "wnr")) { // perform 3D-IDCT idct_3d (len, z, arr); // append inverse-transformed group to log-file array2file (fd, len, z, arr, "group after 3D-IDCT transformation"); } // write array data back to a list node array2group (&group, len, z, arr); // calculate the weights for the blocks of the actual group tmp->weight = get_weight (kind, len, z, arr); tmp = tmp->next; fclose (fd); } // probably need more variables in interface return 0; }