#!/usr/bin/env python
'''
Estimate the disk usage per area of a VoxCovStack.
'''

from __future__ import division
import argparse
import numpy as np
import os

import base.proto
from mapping.distributed_mapping.proto.aligner_pb2 import VoxCovStack

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--voxcov', type=str, help='Path to VoxCovStack proto')
    args = parser.parse_args()

    map_size = os.stat(args.voxcov).st_size / 1024.0
    print('Map size: {:.2f} kB'.format(map_size))
    
    stack = VoxCovStack()
    base.proto.ReadProto(args.voxcov, stack)
    
    for layer in stack.layers:
        resolution = layer.resolution

        min_x = 1e16
        min_y = 1e16

        max_x = -1e16
        max_y = -1e16

        coverage = set()
        for semantic_layer in layer.semantic_layers:
            
            for mean in semantic_layer.means:
                min_x = min(mean.x, min_x)
                min_y = min(mean.y, min_y)

                max_x = max(mean.x, max_x)
                max_y = max(mean.y, max_y)

                coverage.add((int(mean.x / resolution),
                              int(mean.y / resolution)))

        voxel_area = len(coverage) * resolution**2

        width = max_x - min_x
        height = max_y - min_y
        bounding_area = width * height

        print(50*'=')
        print('Resolution: {:.2f} m'.format(resolution))
        print('Occupied voxel columns: {:d}'.format(len(coverage)))
        print('Occupied Voxel Area: {:.2f} m^2'.format(voxel_area))
        print('Bounding Area: {:.2f} m^2'.format(bounding_area))
        print('Size per occupied voxel column: {:.2f} kB/m^2'.format(map_size / voxel_area))
        print('Size per area: {:.2f} kB/m^2'.format(map_size / bounding_area))
        print('Width: {:.2f} m'.format(max_x - min_x))
        print('Height: {:.2f} m'.format(max_y - min_y))