Class QuantizationModule

utils/compress_utils.py:35–132

class QuantizationModule:
    def __init__(self, base_accuracy, level_kp_num=(30, 10, 3, 0), level_dacc=(0, 0.02, 0.04, 0.06),
                 ground_salience_level=2, feature_region=3, segments=8, sharp_num=4, less_sharp_num=8, flat_num=6,
                 uniform=True):
        self.uniform = uniform
        if uniform:
            self.acc = base_accuracy
        else:
            ####################################################################################
            # level_kp_num and level_dacc are enabled when non-uniform quantization.           #
            # level_kp_num: minimum number of key point in this salience level.                #
            # level_dacc: delta accuracy for this salience level. acc = base_acc + delta_acc.  #
            ####################################################################################
            self.level_kp_num = np.array(level_kp_num)
            self.acc = np.array([base_accuracy] * len(self.level_kp_num)) + np.array(level_dacc)
            self.ground_level = ground_salience_level
            self.feature_region = feature_region
            self.segments = segments
            self.sharp_num = sharp_num
            self.less_sharp_num = less_sharp_num
            self.flat_num = flat_num

    def quantize_residual(self, residual, seg_idx, point_cloud=None, range_image=None):
        if self.uniform:
            residual_quantized = quantization_utils_cpp.uniform_quantize(seg_idx, residual, self.acc)
            # # python version
            # residual_collect = []
            # cluster_num = np.max(seg_idx) + 1
            # for m in range(cluster_num):
            #     if m == 1:
            #         # zero points.
            #         continue
            #     residual_collect.extend(residual[..., 0][np.where(seg_idx == m)])
            # residual_quantized = np.rint(np.array(residual_collect) / self.acc).astype(np.int16)
            salience_level = None
            key_point_map = None
        else:
            feature_map, key_point_map = extract_features_without_ground(range_image, seg_idx,
                                                                         self.feature_region, self.segments,
                                                                         self.sharp_num, self.less_sharp_num,
                                                                         self.flat_num)
            # range_image, seg_idx, feature_region=3, segments=8, sharp_num=4, less_sharp_num=8, flat_num=6
            (residual_quantized, salience_level) = quantization_utils_cpp.nonuniform_quantize(seg_idx,
                                                                                              residual, key_point_map,
                                                                                              self.level_kp_num,
                                                                                              self.acc,
                                                                                              self.ground_level)
            # # python version
            # cluster_num = np.max(seg_idx) + 1
            # salience_level = np.ones(cluster_num, dtype=np.int32) * 3
            #
            # for cluster_id in range(cluster_num):
            #     if cluster_id == 0 or cluster_id == 1:
            #         continue
            #     cluster_idx = np.where(seg_idx == cluster_id)
            #     key_point_num = np.where(key_point_map[cluster_idx] > 0)[0].shape[0]
            #     cluster_points = point_cloud[cluster_idx]
            #     if cluster_points.shape[0] < 30: