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