Method FindBestPattern

cmp_compressonatorlib/bc6h/bc6h_encode.cpp:886–1012

}

float BC6HBlockEncoder::FindBestPattern(AMD_BC6H_Format& BC6H_data, bool TwoRegionShapes, int shape_pattern)
{
    // Index bit size for the patterns been used.
    // All two zone shapes have 3 bits per color, max index value < 8
    // All one zone shapes gave 4 bits per color, max index value < 16
    int   Index_BitSize = TwoRegionShapes ? 8 : 16;
    int   max_subsets   = TwoRegionShapes ? 2 : 1;
    float direction[NCHANNELS];
    float step;

    BC6H_data.region        = (unsigned short)max_subsets;
    BC6H_data.index         = 0;
    BC6H_data.d_shape_index = (unsigned short)shape_pattern;
    memset(BC6H_data.partition, 0, sizeof(BC6H_data.partition));
    memset(BC6H_data.shape_indices, 0, sizeof(BC6H_data.shape_indices));

    // Get the pattern to encode with
    Partition(shape_pattern,         // Shape pattern we want to get
              BC6H_data.din,         // Input data
              BC6H_data.partition,   // Returns the patterned shape data
              BC6H_data.entryCount,  // counts the number of pixel used in each subset region num of 0's amd 1's
              max_subsets,           // Table Shapes to use eithe one regions 1 or two regions 2
              3);                    // rgb no alpha always = 3

    float error[MAX_SUBSETS] = {0.0, FLT_MAX, FLT_MAX};
    int   BestOutB           = 0;
    float BestError;         //the lowest error from vector direction quantization
    float BestError_endpts;  //the lowest error from endpoints extracted from the vector direction quantization

    float outB[2][2][MAX_SUBSET_SIZE][MAX_DIMENSION_BIG];
    int   shape_indicesB[2][MAX_SUBSETS][MAX_SUBSET_SIZE];

    for (int subset = 0; subset < max_subsets; subset++)
    {
        error[0] += optQuantAnD_d(BC6H_data.partition[subset],   // input data
                                  BC6H_data.entryCount[subset],  // number of input points above (not clear about 1, better to avoid)
                                  Index_BitSize,                 // number of clusters on the ramp, 8  or 16
                                  shape_indicesB[0][subset],     // output index, if not all points of the ramp used, 0 may not be assigned
                                  outB[0][subset],               // resulting quantization
                                  direction,                     // direction vector of the ramp (check normalization)
                                  &step,                         // step size (check normalization)
                                  3,                             // number of channels (always 3 = RGB for BC6H)
                                  m_quality                      // Quality set number of retry to get good end points
                                                                 // Max retries = MAX_TRY = 4000 when Quality is 1.0
                                                                 // Min = 0 and default with quality 0.05 is 200 times
        );
    }

    BestError = error[0];
    BestOutB  = 0;

    // The following code is almost complete - runs very slow and not sure if % of improvement is justified..
#ifdef USE_SHAKERHD
    // Valid only for 2 region shapes
    if ((max_subsets > 1) && (m_quality > 0.80))
    {
        int tempIndices[MAX_SUBSET_SIZE];
        // int     temp_epo_code[2][2][MAX_DIMENSION_BIG];