# --------------------------------------------------------
# Fast R-CNN
# Copyright (c) 2015 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by <NAME> and <NAME>
# --------------------------------------------------------
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import os
from datasets.imdb import imdb
import datasets.ds_utils as ds_utils
import xml.etree.ElementTree as ET
import numpy as np
import scipy.sparse
import scipy.io as sio
import pickle
import subprocess
import uuid
from .mydataset_eval import mydataset_eval
from model.config import cfg
import matplotlib.pyplot as plt
import cv2
class mydataset(imdb):
  def __init__(self, image_set, dataset):

    name = dataset + '_' + image_set
    imdb.__init__(self, name)
    self._image_set = image_set


    self._root_path = '/media/rgh/rgh-data/Dataset/'+dataset#.capitalize()
    self._data_path = os.path.join(self._root_path, 'image', image_set)
    self._parsing_label_path = os.path.join(self._root_path, 'label', image_set)
    # self._classes = ('__background__',  # always index 0
    #                  'face', 'hair', 'U-clothes', 'L-arm','R-arm',
    #                  'pants', 'L-leg', 'R-leg', 'dress','L-shoe',
    #                  'R-shoe')
    self._classes = ('__background__', 'Hat', 'Hair', 'Glove', 'Sunglasses', 'Upper-clothes', 'Dress', 'Coat', 'Socks',
                   'Pants', 'Jumpsuits', 'Scarf', 'Skirt', 'Face', 'Left-arm', 'Right-arm', 'Left-leg', 'Right-leg',
                   'Left-shoe', 'Right-shoe')
    self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
    self._image_ext = '.jpg'
    self._parsing_label_ext = '.png'
    self._image_index = self._load_image_set_index()
    # Default to roidb handler
    self._roidb_handler = self.gt_roidb
    self.config = {'cleanup': False,
                   'use_diff': True,
                   'matlab_eval': False,
                   'rpn_file': None,
                   'min_size': 2}
    assert os.path.exists(self._root_path), \
      'dataset path does not exist: {}'.format(self._root_path)
    assert os.path.exists(self._data_path), \
      'Path does not exist: {}'.format(self._data_path)
  def parsing_label_path_at(self, i):
    return self.parsing_label_path_from_index(self._image_index[i])

  def parsing_label_path_from_index(self, index):
    parsing_label_path = os.path.join(self._parsing_label_path,
                              index + self._parsing_label_ext)
    assert os.path.exists(parsing_label_path), \
      'Path does not exist: {}'.format(parsing_label_path)
    return parsing_label_path
  def image_path_at(self, i):
    """
    Return the absolute path to image i in the image sequence.
    """
    return self.image_path_from_index(self._image_index[i])

  def image_path_from_index(self, index):
    """
    Construct an image path from the image's "index" identifier.
    """
    image_path = os.path.join(self._data_path,
                              index + self._image_ext)
    assert os.path.exists(image_path), \
      'Path does not exist: {}'.format(image_path)
    return image_path

  def _load_image_set_index(self):
    """
    Load the indexes listed in this dataset's image set file.
    """
    image_set_file = os.path.join(self._root_path,
                                  self._image_set + '.txt')

    assert os.path.exists(image_set_file), \
      'Path does not exist: {}'.format(image_set_file)
    with open(image_set_file) as f:
      image_index = [x.strip() for x in f.readlines()]
    return image_index


  def gt_roidb(self):
    """
    Return the database of ground-truth regions of interest.

    This function loads/saves from/to a cache file to speed up future calls.
    """
    cache_file = os.path.join(self.cache_path, self.name + '_gt_roidb.pkl')
    # if os.path.exists(cache_file):
    #   with open(cache_file, 'rb') as fid:
    #     try:
    #       roidb = pickle.load(fid)
    #     except:
    #       roidb = pickle.load(fid, encoding='bytes')
    #   print('{} gt roidb loaded from {}'.format(self.name, cache_file))
    #   return roidb

    # gt_roidb = [self._load_annotation(index)
    #             for index in self.image_index]
    gt_roidb = []
    error_index = []
    for index in self.image_index:
      roi = self._load_annotation(index)
      if roi is not None:
        gt_roidb.append(roi)
      else:
        error_index.append(index)
    for index in error_index:
      self.image_index.remove(index)
    print('error images number: ', len(error_index))
    print(error_index)
    with open(cache_file, 'wb') as fid:
      pickle.dump(gt_roidb, fid, pickle.HIGHEST_PROTOCOL)
    print('wrote gt roidb to {}'.format(cache_file))

    return gt_roidb

  def rpn_roidb(self):
    if int(self._year) == 2007 or self._image_set != 'test':
      gt_roidb = self.gt_roidb()
      rpn_roidb = self._load_rpn_roidb(gt_roidb)
      roidb = imdb.merge_roidbs(gt_roidb, rpn_roidb)
    else:
      roidb = self._load_rpn_roidb(None)

    return roidb

  def _load_rpn_roidb(self, gt_roidb):
    filename = self.config['rpn_file']
    print('loading {}'.format(filename))
    assert os.path.exists(filename), \
      'rpn data not found at: {}'.format(filename)
    with open(filename, 'rb') as f:
      box_list = pickle.load(f)
    return self.create_roidb_from_box_list(box_list, gt_roidb)

  def _load_annotation(self, img_index):
    """
    Load image and bounding boxes info from txt file.
    """
    bbox_txt = open(os.path.join(self._root_path, 'bbox', self._image_set, img_index+'.txt'),'r')
    bboxs = []
    num_objs = 0
    for index, line in enumerate(bbox_txt):
      line = line.strip()
      if line != '':
        num_objs += 1
        #print(line.split(' '))
        x1, y1, x2, y2 = line.split(' ')
        # Make pixel indexes 0-based
        x1 = float(x1)# - 1 #if float(x1) > 1 else float(x1)
        y1 = float(y1)# - 1 #if float(y1) > 1 else float(y1)
        x2 = float(x2)# - 1
        y2 = float(y2)# - 1
        # 0 bk
        bboxs.append([index+1, [x1, y1, x2, y2],(x2 - x1 + 1) * (y2 - y1 + 1)])
    boxes = np.zeros((num_objs, 4), dtype=np.uint16)
    gt_classes = np.zeros((num_objs), dtype=np.int32)
    overlaps = np.zeros((num_objs, self.num_classes), dtype=np.float32)
    seg_areas = np.zeros((num_objs), dtype=np.float32)
    for index, bbox in enumerate(bboxs):
      boxes[index, :] = bbox[1]
      gt_classes[index] = bbox[0]
      overlaps[index, bbox[0]] = 1.0
      seg_areas[index] = bbox[2]
    overlaps = scipy.sparse.csr_matrix(overlaps)
    if cfg.SUB_CATEGORY:
      sub_category_txt = open(os.path.join(self._root_path, 'sub_category_3', self._image_set, img_index + '.txt'), 'r')
      subs = []
      num_subs = 0
      for index, line in enumerate(sub_category_txt):
        line = line.strip()
        if line != '':
          num_subs += 1
          main, sub = line.split(' ')
          main = int(main)
          sub = int(sub)
          subs.append((main-1)*3+sub)
      # print(img_index, ' ', num_objs,' ', num_subs)
      if num_objs !=num_subs:
        return None
      sub_categorys = np.zeros((num_subs), dtype=np.int32)
      for index, sub in enumerate(subs):
        sub_categorys[index] = sub
      return {'boxes': boxes,
              'gt_classes': gt_classes,
              'sub_categorys': sub_categorys,
              'gt_overlaps': overlaps,
              'flipped': False,
              'seg_areas': seg_areas,
              'do_parsing': cfg.DO_PARSING}
    return {'boxes': boxes,
            'gt_classes': gt_classes,
            'gt_overlaps': overlaps,
            'flipped': False,
            'seg_areas': seg_areas,
            'do_parsing': cfg.DO_PARSING}


  def _get_results_file_template(self):
    # VOCdevkit/results/VOC2007/Main/<comp_id>_det_test_aeroplane.txt
    filename = self._image_set + '_{:s}.txt'
    path = os.path.join(
      self._root_path,'detection_result', filename)
    return path

  def _write_results_file(self, all_boxes):
    for cls_ind, cls in enumerate(self.classes):
      if cls == '__background__':
        continue
      print('Writing {} results file'.format(cls))
      filename = self._get_results_file_template().format(cls)
      with open(filename, 'wt') as f:
        for im_ind, index in enumerate(self.image_index):
          dets = all_boxes[cls_ind][im_ind]
          if dets == []:
            continue
          # the VOCdevkit expects 1-based indices
          for k in range(dets.shape[0]):
            f.write('{:s} {:.3f} {:.1f} {:.1f} {:.1f} {:.1f}\n'.
                    format(index, dets[k, -1],
                           dets[k, 0] + 1, dets[k, 1] + 1,
                           dets[k, 2] + 1, dets[k, 3] + 1))

  def _do_python_eval(self, output_dir='output'):
    annopath = os.path.join(self._root_path, 'bbox',self._image_set, '{:s}.txt')
    imagesetfile = os.path.join(self._root_path, self._image_set + '.txt')
    cachedir = os.path.join(self._root_path, 'annotations_cache')
    aps = []
    recs = []  ### ADDED
    precs = []  ### ADDED
    nposes = []  ### ADDED
    tps = []  ### ADDED
    fps = []  ### ADDED
    # The PASCAL VOC metric changed in 2010
    #use_07_metric = True if int(self._year) < 2010 else False
    #print('VOC07 metric? ' + ('Yes' if use_07_metric else 'No'))
    use_07_metric = False
    if not os.path.isdir(output_dir):
      os.mkdir(output_dir)
    for i, cls in enumerate(self._classes):
      if cls == '__background__':
        continue
      filename = self._get_results_file_template().format(cls)
      # add npos, tp, fp
      rec, prec, ap, npos, tp, fp = mydataset_eval(
        filename, annopath, imagesetfile, cls, cachedir, ovthresh=cfg.TEST.IOU_THRESH,
        use_07_metric=use_07_metric, use_diff=self.config['use_diff'])
      # plt.plot(rec, prec, lw=2, label=cls)
      # plt.xlabel('Recall')
      # plt.ylabel('Precision')
      # plt.grid(True)
      # plt.ylim([0.0, 1.05])
      # plt.xlim([0.0, 1.0])
      # plt.title('Precision-Recall')
      # plt.legend(loc="upper right")
      # plt.show()
      tps += [tp[-1]]  ### ADDED
      fps += [fp[-1]]  ### ADDED
      nposes += [npos]  ### ADDED
      aps += [ap]
      recs += [rec[-1]]
      precs += [prec[-1]]
      #print(('AP for {} = {:.4f}'.format(cls, ap)))
      print(('{} AP: {:.4f}, Rec: {:.4f}, Prec: {:.4f}'.format(cls, ap, rec[-1], prec[-1])))
      with open(os.path.join(output_dir, cls + '_pr.pkl'), 'wb') as f:
        pickle.dump({'rec': rec, 'prec': prec, 'ap': ap}, f)
    overall_recs = np.sum(tps) / float(np.sum(nposes))  ### ADDED
    overall_precs = np.sum(tps) / np.maximum(np.sum(tps) + np.sum(fps), np.finfo(np.float64).eps)  ### ADDED
    print('Mean AP = {:.4f}'.format(np.mean(aps)))
    print('Overall Recall = {:.4f}'.format(overall_recs))  ### ADDED
    print('Overall Precision = {:.4f}'.format(overall_precs))  ### ADDED
    print('Overall F1 = {:.4f}'.format((2 * overall_recs * overall_precs) / (overall_recs + overall_precs)))  ### ADDED
    print('~~~~~~~~')
    print('AP Results:')
    for ap in aps:
      print(('{:.3f}'.format(ap)))
    print(('{:.3f}'.format(np.mean(aps))))
    print('~~~~~~~~')
    print('Recall Results:')
    for rec in recs:
      print(('{:.3f}'.format(rec)))
    print(('{:.3f}'.format(np.mean(overall_recs))))
    # print('~~~~~~~~')
    # print('Prec Results:')
    # for prec in precs:
    #   print(('{:.3f}'.format(prec)))
    # print(('{:.3f}'.format(np.mean(overall_precs))))
    # print('~~~~~~~~')
    # print('')
    print('--------------------------------------------------------------')
    print('Results computed with the **unofficial** Python eval code.')
    print('Results should be very close to the official MATLAB eval code.')
    print('Recompute with `./tools/reval.py --matlab ...` for your paper.')
    print('-- Thanks, The Management')
    print('--------------------------------------------------------------')


  def evaluate_detections(self, all_boxes, output_dir):
    self._write_results_file(all_boxes)
    self._do_python_eval(output_dir)
    if self.config['matlab_eval']:
      self._do_matlab_eval(output_dir)
    if self.config['cleanup']:
      for cls in self._classes:
        if cls == '__background__':
          continue
        filename = self._get_results_file_template().format(cls)
        os.remove(filename)


if __name__ == '__main__':
  from mydataset.mydataset import mydataset

  d = mydataset('lip')
  res = d.roidb
  from IPython import embed;

  embed()
