text: """
  Copyright 2017-2018 lvaleriu (https://github.com/lvaleriu/)
  
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at
  
      http://www.apache.org/licenses/LICENSE-2.0
  
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  """
  
  import csv
  import os.path
  
  import numpy as np
  from PIL import Image
  
  from .generator import Generator
  from ..utils.image import read_image_bgr, read_img_rgbd
  
  kitti_classes = {
      'Car': 0,
      'Van': 1,
      'Truck': 2,
      'Pedestrian': 3,
      'Person_sitting': 4,
      'Cyclist': 5,
      'Tram': 6,
      'Misc': 7,
      'DontCare': 7
  }
  
  
  class KittiGenerator(Generator):
      """ Generate data for a KITTI dataset.
  
      See http://www.cvlibs.net/datasets/kitti/ for more information.
      """
  
      def __init__(
          self,
          base_dir,
          subset='train',
          disp = True,
          **kwargs
      ):
          """ Initialize a KITTI data generator.
  
          Args
              base_dir: Directory w.r.t. where the files are to be searched (defaults to the directory containing the csv_data_file).
              subset: The subset to generate data for (defaults to 'train').
          """
          self.base_dir = base_dir
          self.disp = disp
  
          label_dir = os.path.join(self.base_dir, subset, 'labels')
          image_dir = os.path.join(self.base_dir, subset, 'images')
          if disp:
              disp_dir = os.path.join(self.base_dir, subset, 'disparity')
  
          """
          1    type         Describes the type of object: 'Car', 'Van', 'Truck',
                               'Pedestrian', 'Person_sitting', 'Cyclist', 'Tram',
                               'Misc' or 'DontCare'
          1    truncated    Float from 0 (non-truncated) to 1 (truncated), where
                           truncated refers to the object leaving image boundaries
          1    occluded     Integer (0,1,2,3) indicating occlusion state:
                           0 = fully visible, 1 = partly occluded
                           2 = largely occluded, 3 = unknown
          1    alpha        Observation angle of object, ranging [-pi..pi]
          4    bbox         2D bounding box of object in the image (0-based index):
                           contains left, top, right, bottom pixel coordinates
          3    dimensions   3D object dimensions: height, width, length (in meters)
          3    location     3D object location x,y,z in camera coordinates (in meters)
          1    rotation_y   Rotation ry around Y-axis in camera coordinates [-pi..pi]
          """
  
          self.labels = {}
          self.classes = kitti_classes
          for name, label in self.classes.items():
              self.labels[label] = name
  
          self.image_data = dict()
          self.images = []
          if disp:
              self.disps = []
  
          for i, fn in enumerate(os.listdir(label_dir)):
              label_fp = os.path.join(label_dir, fn)
              image_fp = os.path.join(image_dir, fn.replace('.txt', '.png'))
              self.images.append(image_fp)
              if disp:
                  disp_fp = os.path.join(disp_dir, fn.replace('.txt', '.png'))
                  self.disps.append(disp_fp)
  
              fieldnames = ['type', 'truncated', 'occluded', 'alpha', 'left', 'top', 'right', 'bottom', 'dh', 'dw', 'dl',
                            'lx', 'ly', 'lz', 'ry']
              with open(label_fp, 'r') as csv_file:
                  reader = csv.DictReader(csv_file, delimiter=' ', fieldnames=fieldnames)
                  boxes = []
                  for line, row in enumerate(reader):
                      label = row['type']
                      cls_id = kitti_classes[label]
  
                      annotation = {'cls_id': cls_id, 'x1': row['left'], 'x2': row['right'], 'y2': row['bottom'], 'y1': row['top']}
                      boxes.append(annotation)
  
                  self.image_data[i] = boxes
  
          super(KittiGenerator, self).__init__(**kwargs)
  
      def size(self):
          """ Size of the dataset.
          """
          return len(self.images)
  
      def num_classes(self):
          """ Number of classes in the dataset.
          """
          return max(self.classes.values()) + 1
  
      def has_label(self, label):
          """ Return True if label is a known label.
          """
          return label in self.labels
  
      def has_name(self, name):
          """ Returns True if name is a known class.
          """
          return name in self.classes
  
      def name_to_label(self, name):
          """ Map name to label.
          """
          raise NotImplementedError()
  
      def label_to_name(self, label):
          """ Map label to name.
          """
          return self.labels[label]
  
      def image_aspect_ratio(self, image_index):
          """ Compute the aspect ratio for an image with image_index.
          """
          # PIL is fast for metadata
          image = Image.open(self.images[image_index])
          return float(image.width) / float(image.height)
  
      def load_image(self, image_index):
          """ Load an image at the image_index.
          """
          if self.disp:
              return read_img_rgbd(self.images[image_index], self.disps[image_index])
              
          return read_image_bgr(self.images[image_index])
  
      def load_annotations(self, image_index):
          """ Load annotations for an image_index.
          """
          image_data = self.image_data[image_index]
          annotations = {'labels': np.empty((len(image_data),)), 'bboxes': np.empty((len(image_data), 4))}
  
          for idx, ann in enumerate(image_data):
              annotations['bboxes'][idx, 0] = float(ann['x1'])
              annotations['bboxes'][idx, 1] = float(ann['y1'])
              annotations['bboxes'][idx, 2] = float(ann['x2'])
              annotations['bboxes'][idx, 3] = float(ann['y2'])
              annotations['labels'][idx] = int(ann['cls_id'])
  
          return annotations
  