paddlex 2.1.0__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

paddlex/tools/anchor_clustering/yolo_cluster.py

@@ -1,178 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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 copy
-import os
-import numpy as np
-from tqdm import tqdm
-from scipy.cluster.vq import kmeans
-from paddlex.utils import logging
-
-__all__ = ['YOLOAnchorCluster']
-
-
-class BaseAnchorCluster(object):
-    def __init__(self, num_anchors, cache, cache_path):
-        """
-        Base Anchor Cluster
-        Args:
-            num_anchors (int): number of clusters
-            cache (bool): whether using cache
-            cache_path (str): cache directory path
-        """
-        super(BaseAnchorCluster, self).__init__()
-        self.num_anchors = num_anchors
-        self.cache_path = cache_path
-        self.cache = cache
-
-    def print_result(self, centers):
-        raise NotImplementedError('%s.print_result is not available' %
-                                  self.__class__.__name__)
-
-    def get_whs(self):
-        whs_cache_path = os.path.join(self.cache_path, 'whs.npy')
-        shapes_cache_path = os.path.join(self.cache_path, 'shapes.npy')
-        if self.cache and os.path.exists(whs_cache_path) and os.path.exists(
-                shapes_cache_path):
-            self.whs = np.load(whs_cache_path)
-            self.shapes = np.load(shapes_cache_path)
-            return self.whs, self.shapes
-        whs = np.zeros((0, 2))
-        shapes = np.zeros((0, 2))
-        samples = copy.deepcopy(self.dataset.file_list)
-        for sample in tqdm(samples):
-            im_h, im_w = sample['image_shape']
-            bbox = sample['gt_bbox']
-            wh = bbox[:, 2:4] - bbox[:, 0:2]
-            wh = wh / np.array([[im_w, im_h]])
-            shape = np.ones_like(wh) * np.array([[im_w, im_h]])
-            whs = np.vstack((whs, wh))
-            shapes = np.vstack((shapes, shape))
-
-        if self.cache:
-            os.makedirs(self.cache_path, exist_ok=True)
-            np.save(whs_cache_path, whs)
-            np.save(shapes_cache_path, shapes)
-
-        self.whs = whs
-        self.shapes = shapes
-        return self.whs, self.shapes
-
-    def calc_anchors(self):
-        raise NotImplementedError('%s.calc_anchors is not available' %
-                                  self.__class__.__name__)
-
-    def __call__(self):
-        self.get_whs()
-        centers = self.calc_anchors()
-        return centers
-
-
-class YOLOAnchorCluster(BaseAnchorCluster):
-    def __init__(self,
-                 num_anchors,
-                 dataset,
-                 image_size,
-                 cache=True,
-                 cache_path=None,
-                 iters=300,
-                 gen_iters=1000,
-                 thresh=0.25):
-        """
-        YOLOv5 Anchor Cluster
-
-        Reference:
-            https://github.com/ultralytics/yolov5/blob/master/utils/autoanchor.py
-
-        Args:
-            num_anchors (int): number of clusters
-            dataset (DataSet): DataSet instance, VOC or COCO
-            image_size (list or int): [h, w], being an int means image height and image width are the same.
-            cache (bool): whether using cache。 Defaults to True.
-            cache_path (str or None, optional): cache directory path. If None, use `data_dir` of dataset. Defaults to None.
-            iters (int, optional): iters of kmeans algorithm. Defaults to 300.
-            gen_iters (int, optional): iters of genetic algorithm. Defaults to 1000.
-            thresh (float, optional): anchor scale threshold. Defaults to 0.25.
-        """
-        self.dataset = dataset
-        if cache_path is None:
-            cache_path = self.dataset.data_dir
-        if isinstance(image_size, int):
-            image_size = [image_size] * 2
-        self.image_size = image_size
-        self.iters = iters
-        self.gen_iters = gen_iters
-        self.thresh = thresh
-        super(YOLOAnchorCluster, self).__init__(num_anchors, cache, cache_path)
-
-    def print_result(self, centers):
-        whs = self.whs
-        x, best = self.metric(whs, centers)
-        bpr, aat = (best > self.thresh).mean(), (
-            x > self.thresh).mean() * self.num_anchors
-        logging.info(
-            'thresh=%.2f: %.4f best possible recall, %.2f anchors past thr' %
-            (self.thresh, bpr, aat))
-        logging.info(
-            'n=%g, img_size=%s, metric_all=%.3f/%.3f-mean/best, past_thresh=%.3f-mean: '
-            % (self.num_anchors, self.image_size, x.mean(), best.mean(),
-               x[x > self.thresh].mean()))
-        logging.info('%d anchor cluster result: [w, h]' % self.num_anchors)
-        for w, h in centers:
-            logging.info('[%d, %d]' % (w, h))
-
-    def metric(self, whs, centers):
-        r = whs[:, None] / centers[None]
-        x = np.minimum(r, 1. / r).min(2)
-        return x, x.max(1)
-
-    def fitness(self, whs, centers):
-        _, best = self.metric(whs, centers)
-        return (best * (best > self.thresh)).mean()
-
-    def calc_anchors(self):
-        self.whs = self.whs * self.shapes / self.shapes.max(
-            1, keepdims=True) * np.array([self.image_size[::-1]])
-        wh0 = self.whs
-        i = (wh0 < 3.0).any(1).sum()
-        if i:
-            logging.warning('Extremely small objects found. %d of %d '
-                            'labels are < 3 pixels in width or height' %
-                            (i, len(wh0)))
-
-        wh = wh0[(wh0 >= 2.0).any(1)]
-        logging.info('Running kmeans for %g anchors on %g points...' %
-                     (self.num_anchors, len(wh)))
-        s = wh.std(0)
-        centers, dist = kmeans(wh / s, self.num_anchors, iter=self.iters)
-        centers *= s
-
-        f, sh, mp, s = self.fitness(wh, centers), centers.shape, 0.9, 0.1
-        pbar = tqdm(
-            range(self.gen_iters),
-            desc='Evolving anchors with Genetic Algorithm')
-        for _ in pbar:
-            v = np.ones(sh)
-            while (v == 1).all():
-                v = ((np.random.random(sh) < mp) * np.random.random() *
-                     np.random.randn(*sh) * s + 1).clip(0.3, 3.0)
-            new_centers = (centers.copy() * v).clip(min=2.0)
-            new_f = self.fitness(wh, new_centers)
-            if new_f > f:
-                f, centers = new_f, new_centers.copy()
-                pbar.desc = 'Evolving anchors with Genetic Algorithm: fitness = %.4f' % f
-
-        centers = np.round(centers[np.argsort(centers.prod(1))]).astype(
-            int).tolist()
-        return centers

paddlex/tools/convert.py

@@ -1,52 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-from .dataset_conversion import *
-
-easydata2imagenet = EasyData2ImageNet().convert
-jingling2imagenet = JingLing2ImageNet().convert
-jingling2seg = JingLing2Seg().convert
-labelme2seg = LabelMe2Seg().convert
-easydata2seg = EasyData2Seg().convert
-labelme2voc = LabelMe2VOC().convert
-easydata2voc = EasyData2VOC().convert
-labelme2coco = LabelMe2COCO().convert
-easydata2coco = EasyData2COCO().convert
-jingling2coco = JingLing2COCO().convert
-
-
-def dataset_conversion(source, to, pics, anns, save_dir):
-    if source.lower() == 'easydata' and to.lower() == 'imagenet':
-        easydata2imagenet(pics, anns, save_dir)
-    elif source.lower() == 'jingling' and to.lower() == 'imagenet':
-        jingling2imagenet(pics, anns, save_dir)
-    elif source.lower() == 'jingling' and to.lower() == 'seg':
-        jingling2seg(pics, anns, save_dir)
-    elif source.lower() == 'labelme' and to.lower() == 'seg':
-        labelme2seg(pics, anns, save_dir)
-    elif source.lower() == 'easydata' and to.lower() == 'seg':
-        easydata2seg(pics, anns, save_dir)
-    elif source.lower() == 'labelme' and to.lower() == 'pascalvoc':
-        labelme2voc(pics, anns, save_dir)
-    elif source.lower() == 'easydata' and to.lower() == 'pascalvoc':
-        easydata2voc(pics, anns, save_dir)
-    elif source.lower() == 'labelme' and to.lower() == 'mscoco':
-        labelme2coco(pics, anns, save_dir)
-    elif source.lower() == 'easydata' and to.lower() == 'mscoco':
-        easydata2coco(pics, anns, save_dir)
-    elif source.lower() == 'jingling' and to.lower() == 'mscoco':
-        jingling2coco(pics, anns, save_dir)
-    else:
-        raise Exception("Converting from {} to {} is not supported.".format(
-            source, to))

paddlex/tools/dataset_conversion/__init__.py

@@ -1,24 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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.
-
-from .x2imagenet import EasyData2ImageNet, JingLing2ImageNet
-from .x2seg import JingLing2Seg, LabelMe2Seg, EasyData2Seg
-from .x2voc import LabelMe2VOC, EasyData2VOC
-from .x2coco import LabelMe2COCO, EasyData2COCO, JingLing2COCO
-
-__all__ = [
-    'EasyData2ImageNet', 'JingLing2ImageNet', 'JingLing2Seg', 'LabelMe2Seg',
-    'EasyData2Seg', 'LabelMe2VOC', 'EasyData2VOC', 'LabelMe2COCO',
-    'EasyData2COCO', 'JingLing2COCO'
-]

paddlex/tools/dataset_conversion/x2coco.py

@@ -1,379 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
-#
-# 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 cv2
-import json
-import os
-import os.path as osp
-import shutil
-import numpy as np
-import PIL.ImageDraw
-from paddlex.utils import path_normalization, MyEncoder, is_pic, get_encoding
-
-
-class X2COCO(object):
-    def __init__(self):
-        self.images_list = []
-        self.categories_list = []
-        self.annotations_list = []
-
-    def generate_categories_field(self, label, labels_list):
-        category = {}
-        category["supercategory"] = "component"
-        category["id"] = len(labels_list) + 1
-        category["name"] = label
-        return category
-
-    def generate_rectangle_anns_field(self, points, label, image_id, object_id,
-                                      label_to_num):
-        annotation = {}
-        seg_points = np.asarray(points).copy()
-        seg_points[1, :] = np.asarray(points)[2, :]
-        seg_points[2, :] = np.asarray(points)[1, :]
-        annotation["segmentation"] = [list(seg_points.flatten())]
-        annotation["iscrowd"] = 0
-        annotation["image_id"] = image_id + 1
-        annotation["bbox"] = list(
-            map(float, [
-                points[0][0], points[0][1], points[1][0] - points[0][0],
-                points[1][1] - points[0][1]
-            ]))
-        annotation["area"] = annotation["bbox"][2] * annotation["bbox"][3]
-        annotation["category_id"] = label_to_num[label]
-        annotation["id"] = object_id + 1
-        return annotation
-
-    def convert(self, image_dir, json_dir, dataset_save_dir):
-        """转换。
-        Args:
-            image_dir (str): 图像文件存放的路径。
-            json_dir (str): 与每张图像对应的json文件的存放路径。
-            dataset_save_dir (str): 转换后数据集存放路径。
-        """
-        assert osp.exists(image_dir), "he image folder does not exist!"
-        assert osp.exists(json_dir), "The json folder does not exist!"
-        if not osp.exists(dataset_save_dir):
-            os.makedirs(dataset_save_dir)
-        # Convert the image files.
-        new_image_dir = osp.join(dataset_save_dir, "JPEGImages")
-        if osp.exists(new_image_dir):
-            raise Exception(
-                "The directory {} is already exist, please remove the directory first".
-                format(new_image_dir))
-        os.makedirs(new_image_dir)
-        for img_name in os.listdir(image_dir):
-            if is_pic(img_name):
-                shutil.copyfile(
-                    osp.join(image_dir, img_name),
-                    osp.join(new_image_dir, img_name))
-        # Convert the json files.
-        self.parse_json(new_image_dir, json_dir)
-        coco_data = {}
-        coco_data["images"] = self.images_list
-        coco_data["categories"] = self.categories_list
-        coco_data["annotations"] = self.annotations_list
-        json_path = osp.join(dataset_save_dir, "annotations.json")
-        f = open(json_path, "w")
-        json.dump(coco_data, f, indent=4, cls=MyEncoder)
-        f.close()
-
-
-class LabelMe2COCO(X2COCO):
-    """将使用LabelMe标注的数据集转换为COCO数据集。
-    """
-
-    def __init__(self):
-        super(LabelMe2COCO, self).__init__()
-
-    def generate_images_field(self, json_info, image_file, image_id):
-        image = {}
-        image["height"] = json_info["imageHeight"]
-        image["width"] = json_info["imageWidth"]
-        image["id"] = image_id + 1
-        json_img_path = path_normalization(json_info["imagePath"])
-        json_info["imagePath"] = osp.join(
-            osp.split(json_img_path)[0], image_file)
-        image["file_name"] = osp.split(json_info["imagePath"])[-1]
-        return image
-
-    def generate_polygon_anns_field(self, height, width, points, label,
-                                    image_id, object_id, label_to_num):
-        annotation = {}
-        annotation["segmentation"] = [list(np.asarray(points).flatten())]
-        annotation["iscrowd"] = 0
-        annotation["image_id"] = image_id + 1
-        annotation["bbox"] = list(
-            map(float, self.get_bbox(height, width, points)))
-        annotation["area"] = annotation["bbox"][2] * annotation["bbox"][3]
-        annotation["category_id"] = label_to_num[label]
-        annotation["id"] = object_id + 1
-        return annotation
-
-    def get_bbox(self, height, width, points):
-        polygons = points
-        mask = np.zeros([height, width], dtype=np.uint8)
-        mask = PIL.Image.fromarray(mask)
-        xy = list(map(tuple, polygons))
-        PIL.ImageDraw.Draw(mask).polygon(xy=xy, outline=1, fill=1)
-        mask = np.array(mask, dtype=bool)
-        index = np.argwhere(mask == 1)
-        rows = index[:, 0]
-        clos = index[:, 1]
-        left_top_r = np.min(rows)
-        left_top_c = np.min(clos)
-        right_bottom_r = np.max(rows)
-        right_bottom_c = np.max(clos)
-        return [
-            left_top_c, left_top_r, right_bottom_c - left_top_c,
-            right_bottom_r - left_top_r
-        ]
-
-    def parse_json(self, img_dir, json_dir):
-        image_id = -1
-        object_id = -1
-        labels_list = []
-        label_to_num = {}
-        for img_file in os.listdir(img_dir):
-            img_name_part = osp.splitext(img_file)[0]
-            json_file = osp.join(json_dir, img_name_part + ".json")
-            if not osp.exists(json_file):
-                os.remove(osp.join(img_dir, img_file))
-                continue
-            image_id = image_id + 1
-            with open(json_file, mode='r', \
-                      encoding=get_encoding(json_file)) as j:
-                json_info = json.load(j)
-                img_info = self.generate_images_field(json_info, img_file,
-                                                      image_id)
-                self.images_list.append(img_info)
-                for shapes in json_info["shapes"]:
-                    object_id = object_id + 1
-                    label = shapes["label"]
-                    if label not in labels_list:
-                        self.categories_list.append( \
-                            self.generate_categories_field(label, labels_list))
-                        labels_list.append(label)
-                        label_to_num[label] = len(labels_list)
-                    points = shapes["points"]
-                    p_type = shapes["shape_type"]
-                    if p_type == "polygon":
-                        self.annotations_list.append(
-                            self.generate_polygon_anns_field(
-                                json_info["imageHeight"], json_info[
-                                    "imageWidth"], points, label, image_id,
-                                object_id, label_to_num))
-                    if p_type == "rectangle":
-                        points.append([points[0][0], points[1][1]])
-                        points.append([points[1][0], points[0][1]])
-                        self.annotations_list.append(
-                            self.generate_rectangle_anns_field(
-                                points, label, image_id, object_id,
-                                label_to_num))
-
-
-class EasyData2COCO(X2COCO):
-    """将使用EasyData标注的检测或分割数据集转换为COCO数据集。
-    """
-
-    def __init__(self):
-        super(EasyData2COCO, self).__init__()
-
-    def generate_images_field(self, img_path, image_id):
-        image = {}
-        img = cv2.imread(img_path)
-        image["height"] = img.shape[0]
-        image["width"] = img.shape[1]
-        image["id"] = image_id + 1
-        img_path = path_normalization(img_path)
-        image["file_name"] = osp.split(img_path)[-1]
-        return image
-
-    def generate_polygon_anns_field(self, points, segmentation, label,
-                                    image_id, object_id, label_to_num):
-        annotation = {}
-        annotation["segmentation"] = segmentation
-        annotation["iscrowd"] = 1 if len(segmentation) > 1 else 0
-        annotation["image_id"] = image_id + 1
-        annotation["bbox"] = list(
-            map(float, [
-                points[0][0], points[0][1], points[1][0] - points[0][0],
-                points[1][1] - points[0][1]
-            ]))
-        annotation["area"] = annotation["bbox"][2] * annotation["bbox"][3]
-        annotation["category_id"] = label_to_num[label]
-        annotation["id"] = object_id + 1
-        return annotation
-
-    def parse_json(self, img_dir, json_dir):
-        from pycocotools.mask import decode
-        image_id = -1
-        object_id = -1
-        labels_list = []
-        label_to_num = {}
-        for img_file in os.listdir(img_dir):
-            img_name_part = osp.splitext(img_file)[0]
-            json_file = osp.join(json_dir, img_name_part + ".json")
-            if not osp.exists(json_file):
-                os.remove(osp.join(img_dir, img_file))
-                continue
-            image_id = image_id + 1
-            with open(json_file, mode='r', \
-                      encoding=get_encoding(json_file)) as j:
-                json_info = json.load(j)
-                img_info = self.generate_images_field(
-                    osp.join(img_dir, img_file), image_id)
-                self.images_list.append(img_info)
-                for shapes in json_info["labels"]:
-                    object_id = object_id + 1
-                    label = shapes["name"]
-                    if label not in labels_list:
-                        self.categories_list.append( \
-                            self.generate_categories_field(label, labels_list))
-                        labels_list.append(label)
-                        label_to_num[label] = len(labels_list)
-                    points = [[shapes["x1"], shapes["y1"]],
-                              [shapes["x2"], shapes["y2"]]]
-                    if "mask" not in shapes:
-                        points.append([points[0][0], points[1][1]])
-                        points.append([points[1][0], points[0][1]])
-                        self.annotations_list.append(
-                            self.generate_rectangle_anns_field(
-                                points, label, image_id, object_id,
-                                label_to_num))
-                    else:
-                        mask_dict = {}
-                        mask_dict[
-                            'size'] = [img_info["height"], img_info["width"]]
-                        mask_dict['counts'] = shapes['mask'].encode()
-                        mask = decode(mask_dict)
-                        contours, hierarchy = cv2.findContours(
-                            (mask).astype(np.uint8), cv2.RETR_TREE,
-                            cv2.CHAIN_APPROX_SIMPLE)
-                        segmentation = []
-                        for contour in contours:
-                            contour_list = contour.flatten().tolist()
-                            if len(contour_list) > 4:
-                                segmentation.append(contour_list)
-                        self.annotations_list.append(
-                            self.generate_polygon_anns_field(
-                                points, segmentation, label, image_id,
-                                object_id, label_to_num))
-
-
-class JingLing2COCO(X2COCO):
-    """将使用EasyData标注的检测或分割数据集转换为COCO数据集。
-    """
-
-    def __init__(self):
-        super(JingLing2COCO, self).__init__()
-
-    def generate_images_field(self, json_info, image_id):
-        image = {}
-        image["height"] = json_info["size"]["height"]
-        image["width"] = json_info["size"]["width"]
-        image["id"] = image_id + 1
-        json_info["path"] = path_normalization(json_info["path"])
-        image["file_name"] = osp.split(json_info["path"])[-1]
-        return image
-
-    def generate_polygon_anns_field(self, height, width, points, label,
-                                    image_id, object_id, label_to_num):
-        annotation = {}
-        annotation["segmentation"] = [list(np.asarray(points).flatten())]
-        annotation["iscrowd"] = 0
-        annotation["image_id"] = image_id + 1
-        annotation["bbox"] = list(
-            map(float, self.get_bbox(height, width, points)))
-        annotation["area"] = annotation["bbox"][2] * annotation["bbox"][3]
-        annotation["category_id"] = label_to_num[label]
-        annotation["id"] = object_id + 1
-        return annotation
-
-    def get_bbox(self, height, width, points):
-        polygons = points
-        mask = np.zeros([height, width], dtype=np.uint8)
-        mask = PIL.Image.fromarray(mask)
-        xy = list(map(tuple, polygons))
-        PIL.ImageDraw.Draw(mask).polygon(xy=xy, outline=1, fill=1)
-        mask = np.array(mask, dtype=bool)
-        index = np.argwhere(mask == 1)
-        rows = index[:, 0]
-        clos = index[:, 1]
-        left_top_r = np.min(rows)
-        left_top_c = np.min(clos)
-        right_bottom_r = np.max(rows)
-        right_bottom_c = np.max(clos)
-        return [
-            left_top_c, left_top_r, right_bottom_c - left_top_c,
-            right_bottom_r - left_top_r
-        ]
-
-    def parse_json(self, img_dir, json_dir):
-        image_id = -1
-        object_id = -1
-        labels_list = []
-        label_to_num = {}
-        for img_file in os.listdir(img_dir):
-            img_name_part = osp.splitext(img_file)[0]
-            json_file = osp.join(json_dir, img_name_part + ".json")
-            if not osp.exists(json_file):
-                os.remove(osp.join(img_dir, img_file))
-                continue
-            image_id = image_id + 1
-            with open(json_file, mode='r', \
-                      encoding=get_encoding(json_file)) as j:
-                json_info = json.load(j)
-                img_info = self.generate_images_field(json_info, image_id)
-                self.images_list.append(img_info)
-                anns_type = "bndbox"
-                for i, obj in enumerate(json_info["outputs"]["object"]):
-                    if i == 0:
-                        if "polygon" in obj:
-                            anns_type = "polygon"
-                    else:
-                        if anns_type not in obj:
-                            continue
-                    object_id = object_id + 1
-                    label = obj["name"]
-                    if label not in labels_list:
-                        self.categories_list.append( \
-                            self.generate_categories_field(label, labels_list))
-                        labels_list.append(label)
-                        label_to_num[label] = len(labels_list)
-                    if anns_type == "polygon":
-                        points = []
-                        for j in range(int(len(obj["polygon"]) / 2.0)):
-                            points.append([
-                                obj["polygon"]["x" + str(j + 1)],
-                                obj["polygon"]["y" + str(j + 1)]
-                            ])
-                        self.annotations_list.append(
-                            self.generate_polygon_anns_field(
-                                json_info["size"]["height"], json_info["size"][
-                                    "width"], points, label, image_id,
-                                object_id, label_to_num))
-                    if anns_type == "bndbox":
-                        points = []
-                        points.append(
-                            [obj["bndbox"]["xmin"], obj["bndbox"]["ymin"]])
-                        points.append(
-                            [obj["bndbox"]["xmax"], obj["bndbox"]["ymax"]])
-                        points.append(
-                            [obj["bndbox"]["xmin"], obj["bndbox"]["ymax"]])
-                        points.append(
-                            [obj["bndbox"]["xmax"], obj["bndbox"]["ymin"]])
-                        self.annotations_list.append(
-                            self.generate_rectangle_anns_field(
-                                points, label, image_id, object_id,
-                                label_to_num))