1## Multi Parallelogram Prediction Decoder
2
3### MeshPredictionSchemeConstrainedMultiParallelogramDecoder_ComputeOriginalValues()
4
5~~~~~
6void MeshPredictionSchemeConstrainedMultiParallelogramDecoder_ComputeOriginalValues(
7      num_values) {
8  signed_values = seq_int_att_dec_symbols_to_signed_ints[curr_att_dec][curr_att];
9  num_components = GetNumComponents();
10  for (i = 0; i < kMaxNumParallelograms; ++i) {
11    pred_vals[i].resize(num_components, 0);
12  }
13  out_values = signed_values;
14  PredictionSchemeTransform_ComputeOriginalValue(
15      pred_vals[0], &signed_values[0], &out_values[0]);
16  is_crease_edge_pos.assign(kMaxNumParallelograms, 0);
17  corner_map_size = num_values;
18  for (p = 1; p < corner_map_size; ++p) {
19    start_corner_id = encoded_attribute_value_index_to_corner_map[curr_att_dec][p];
20    corner_id = start_corner_id;
21    num_parallelograms = 0;
22    first_pass = true;
23    while (corner_id >= 0) {
24      if (ComputeParallelogramPrediction(p, corner_id, &out_values[0],
25          num_components, &(pred_vals[num_parallelograms][0]))) {
26        ++num_parallelograms;
27        if (num_parallelograms == kMaxNumParallelograms)
28          break;
29      }
30      if (first_pass) {
31        corner_id = SwingLeft(curr_att_dec, corner_id);
32      } else {
33        corner_id = SwingRight(curr_att_dec, corner_id);
34      }
35      if (corner_id == start_corner_id) {
36        break;
37      }
38      if (corner_id < 0 && first_pass) {
39        first_pass = false;
40        corner_id = SwingRight(curr_att_dec, start_corner_id);
41      }
42    }
43    is_crease_edge_ = pred_cons_multi_is_cease_edge[curr_att_dec][curr_att];
44    num_used_parallelograms = 0;
45    if (num_parallelograms > 0) {
46      for (i = 0; i < num_components; ++i) {
47        multi_pred_vals[i] = 0;
48      }
49      for (i = 0; i < num_parallelograms; ++i) {
50        context = num_parallelograms - 1;
51        is_crease = is_crease_edge_[context][is_crease_edge_pos[context]++];
52        if (!is_crease) {
53          ++num_used_parallelograms;
54          for (j = 0; j < num_components; ++j) {
55            multi_pred_vals[j] += pred_vals[i][j];
56          }
57        }
58      }
59    }
60    dst_offset = p * num_components;
61    if (num_used_parallelograms == 0) {
62      src_offset = (p - 1) * num_components;
63      PredictionSchemeTransform_ComputeOriginalValue(&out_values[src_offset],
64          &signed_values[dst_offset], &out_values[dst_offset]);
65    } else {
66      for (c = 0; c < num_components; ++c) {
67        multi_pred_vals[c] /= num_used_parallelograms;
68      }
69      PredictionSchemeTransform_ComputeOriginalValue(multi_pred_vals,
70          &signed_values[dst_offset], &out_values[dst_offset]);
71    }
72  }
73  seq_int_att_dec_original_values[curr_att_dec][curr_att] = out_values;
74}
75
76~~~~~
77{:.draco-syntax}
78