Пример #1
0
def main(gt_fp: str):
    gt = OBBAnns(gt_fp)
    gt.load_annotations()

    root = split(gt_fp)[0]

    # First make perfect proposals
    bboxes = gt.ann_info[['bbox', 'cat_id', 'img_id']]
    proposals = {'proposals': bboxes.to_dict('records')}
    with open(join(root, 'proposals_perfect.json'), 'w') as prop_file:
        json.dump(proposals, prop_file)

    # Now randomly "forget" certain proposals
    selector = [
        True if random() > 0.2 else False for _ in range(len(gt.ann_info))
    ]

    bboxes = gt.ann_info[['bbox', 'cat_id',
                          'img_id']][selector].apply(fudge_bboxes,
                                                     1,
                                                     result_type='expand')

    proposals = {'proposals': bboxes.to_dict('records')}

    with open(join(root, 'proposals.json'), 'w') as prop_file:
        json.dump(proposals, prop_file)
Пример #2
0
    def load_annotations(self, ann_file):
        self.obb = OBBAnns(ann_file)
        self.obb.load_annotations()
        self.obb.set_annotation_set_filter(['deepscores'])
        # self.obb.set_class_blacklist(["staff"])
        self.cat_ids = list(self.obb.get_cats().keys())
        self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
        self.label2cat = {v: k for k, v in self.cat2label.items()}
        self.CLASSES = tuple(
            [v["name"] for (k, v) in self.obb.get_cats().items()])
        self.img_ids = [id['id'] for id in self.obb.img_info]

        return self.obb.img_info
Пример #3
0
  def __init__(self, image_set, year, devkit_path=None):
    imdb.__init__(self, 'DeepScoresV2' + year + '_' + image_set)
    self._year = year
    self._devkit_path = self._get_default_path() if devkit_path is None \
      else devkit_path

    self._image_set = image_set

    self._data_path = self._devkit_path + "/images"

    self.blacklist = ["staff", 'legerLine']


    self.o = OBBAnns(self._devkit_path+'/deepscores_'+image_set+'.json')
    self.o.load_annotations()
    print(self.o.annotation_sets)
    self.o.set_annotation_set_filter(['deepscores'])
    self.o.set_class_blacklist(self.blacklist)

    self._classes = [v["name"] for (k, v) in self.o.get_cats().items()]
    self._class_ids = [k for (k, v) in self.o.get_cats().items()]

    self._class_to_ind = dict(list(zip(self.classes, list(range(self.num_classes)))))
    self._class_ids_to_ind = dict(list(zip(self._class_ids, list(range(self.num_classes)))))
    self._ind_to_class_ids = {v: k for k, v in self._class_ids_to_ind.items()}

    self._image_index = self._load_image_set_index()

    # self.cat_ids = list(self.o.get_cats().keys())
    # self.cat2label = {
    #   cat_id: i
    #   for i, cat_id in enumerate(self.cat_ids)
    # }
    # self.label2cat = {v: k for k, v in self.cat2label.items()}
    # self.CLASSES = tuple([v["name"] for (k, v) in self.o.get_cats().items()])
    # self.img_ids = [id['id'] for id in self.o.img_info]


    self._image_ext = '.png'

    # Default to roidb handler
    self._roidb_handler = self.gt_roidb
    self._salt = str(uuid.uuid4())
    self._comp_id = 'comp4'

    # PASCAL specific config options
    self.config = {'cleanup': True,
                   'use_salt': True,
                   'use_diff': False,
                   'matlab_eval': False,
                   'rpn_file': None}
Пример #4
0
import shutil

import json
import numpy as np
from obb_anns import OBBAnns
from pathlib import Path

ann_in_1 = OBBAnns('data/deep_scores_dense/deepscores_test.json')
ann_in_2 = OBBAnns('../ili_subset/scores.json')
SUFFIX = '_scn'
ann_out_path = Path('..', 'ds_test_ili', 'deepscores_test.json')

ann_in_1.load_annotations()
ann_in_2.load_annotations()
target_ds_root = ann_out_path.parent

assert target_ds_root.exists(), f"Directory of the target dataset ({str(target_ds_root)}) must exist!"

# Make dirs
images_path = Path('images')
segmentation_path = Path('segmentation')
instance_path = Path('instance')
for subdir in [images_path, segmentation_path, instance_path]:
    (target_ds_root / subdir).mkdir(exist_ok=True)

print("Copying image files")
def copy_images(ann: OBBAnns, suffix: str = ''):
    ds_root = Path(ann.ann_file).parent
    for img_info in ann.img_info:
        img_path = Path(img_info['filename'])
        img_path_new = img_path.with_name(img_path.with_suffix('').name + suffix + img_path.suffix)
Пример #5
0
    parser.add_argument('PROPOSAL',
                        type=str,
                        nargs='?',
                        help='name of the proposals json')
    return parser.parse_args()


def extract_bbox_list():
    all_bboxes = []
    return all_bboxes


if __name__ == '__main__':
    args = parse_args()

    a = OBBAnns(join(args.ROOT, args.ANNS))
    a.load_annotations()
    a.set_annotation_set_filter(['deepscores'])

    np_annotations = np.stack(a.ann_info['a_bbox'])
    height = np_annotations[:, 3] - np_annotations[:, 1]
    width = np_annotations[:, 2] - np_annotations[:, 0]
    aspect_ratio = height / width
    area = a.ann_info['area']

    d = {
        'height': height,
        'width': width,
        'aspect_ratio': aspect_ratio,
        'area': area
    }
Пример #6
0
    parser = ArgumentParser(description='runs the obb_anns.py file')
    parser.add_argument('ROOT',
                        type=str,
                        help='path to the root of the dataset directory')
    return parser.parse_args()


if __name__ == '__main__':
    args = parse_args()
    root_dir = Path(args.ROOT)
    file_names_in_annotations = []
    num_ann_files = len(list(root_dir.glob("*.json")))

    for i, dataset_ann_fp in enumerate(root_dir.glob("*.json")):
        print(f'Checking file {i + 1} of {num_ann_files}...')
        a = OBBAnns(join(args.ROOT, dataset_ann_fp))
        a.load_annotations()
        a.set_annotation_set_filter(['deepscores'])

        for img in tqdm(a.img_info, unit='imgs'):
            file_names_in_annotations.append(img['filename'])
            try:
                b = a.get_anns(img_id=img['id'])
            except:
                print(f'{img["id"]} caused an exception')

    file_names_in_annotations = set(file_names_in_annotations)

    images_dir = root_dir / 'images_png'

    print("Checking if every image has its annotation in the dataset...")
Пример #7
0
from PIL.PngImagePlugin import PngImageFile
from obb_anns import OBBAnns
from pathlib import Path

# source_images = Path('..', 'ili_subset', 'images')
# source_images = Path('..', 'scanned_deepscore_images_png')
source_images = Path('..', 'scanned_deepscore_images_clean')
# source_index = Path('..', 'clean_scans')
# source_index = Path('..', 'scanned_deepscore_images_png')
source_index = Path('..', 'scanned_deepscore_images_clean')
# target_ds = Path('..', 'ili_subset')
target_ds = Path('..', 'deepscores_scanned')
target_ds_file = target_ds / 'deepscores.json'

orig_ann_root = Path('data', 'deep_scores_dense')
orig_ann_train = OBBAnns(str(orig_ann_root / 'deepscores_train.json'))
orig_ann_train.load_annotations()
orig_ann_test = OBBAnns(str(orig_ann_root / 'deepscores_test.json'))
orig_ann_test.load_annotations()


def construct_reverse_lookup(ann: OBBAnns) -> dict:
    reverse_lookup = {}
    for entry in ann.img_info:
        reverse_lookup[entry['filename']] = entry
    return reverse_lookup


reverse_lookup_train = construct_reverse_lookup(orig_ann_train)
reverse_lookup_test = construct_reverse_lookup(orig_ann_test)
Пример #8
0
def main(image_set, single_scale=False):
    # (1)
    if image_set == 'train':
        #dir_txt = os.path.join(dir_dataset, 'labelTxt', image_set)
        out_dir_json = os.path.join(dir_dataset, 'annotations', image_set)
        os.makedirs(out_dir_json, exist_ok=True)
        #txt2json(dir_txt, out_dir_json)

        o = OBBAnns(dir_dataset + 'deepscores_train.json')
        o.load_annotations()
        #print(o)
        cats = o.get_cats()
        img_idxs = [i for i in range(len(o.img_info))]
        imgs, anns = o.get_img_ann_pair(idxs=img_idxs,
                                        ann_set_filter="deepscores")
        filenames = []

        for img in anns:
            objs = []
            img_np = np.array(img)
            for object_instance in img_np:
                obj = dict()
                coord = np.array(object_instance[1],
                                 dtype=np.float32).reshape([4, 2])
                bbox = cv.boxPoints(cv.minAreaRect(coord)).astype(
                    np.int).tolist()
                obj['name'] = cats[object_instance[2][0]]['name']
                obj['bbox'] = bbox
                objs.append(obj)
            if objs:
                filename = o.get_imgs(ids=[int(img_np[0][4])])[0]['filename']
                filenames.append(os.path.splitext(filename)[0])
                json_filename = os.path.splitext(filename)[0] + '.json'
                json.dump(objs,
                          open(os.path.join(out_dir_json, json_filename),
                               'wt'),
                          indent=2)

        # Split images and json annotations in train and val files
        out_dir_train = os.path.join(dir_dataset, 'images2', 'train')
        out_dir_val = os.path.join(dir_dataset, 'images2', 'val')
        out_dir_val_json = os.path.join(dir_dataset, 'annotations', 'val')
        out_dir_test = os.path.join(dir_dataset, 'images2', 'test')
        os.makedirs(out_dir_train, exist_ok=True)
        os.makedirs(out_dir_val, exist_ok=True)
        os.makedirs(out_dir_test, exist_ok=True)
        os.makedirs(out_dir_val_json, exist_ok=True)

        filenames_train, filenames_val = train_test_split(filenames,
                                                          test_size=272,
                                                          random_state=8)

        for filename in os.listdir(os.path.join(dir_dataset, 'images')):
            if os.path.splitext(filename)[0] in filenames_train:
                shutil.move(os.path.join(dir_dataset, 'images', filename),
                            os.path.join(out_dir_train, filename))
            elif os.path.splitext(filename)[0] in filenames_val:
                shutil.move(os.path.join(dir_dataset, 'images', filename),
                            os.path.join(out_dir_val, filename))
                shutil.move(
                    os.path.join(out_dir_json,
                                 os.path.splitext(filename)[0] + '.json'),
                    os.path.join(out_dir_val_json,
                                 os.path.splitext(filename)[0] + '.json'))
            else:
                shutil.move(os.path.join(dir_dataset, 'images', filename),
                            os.path.join(out_dir_test, filename))

        os.rmdir(os.path.join(dir_dataset, 'images'))
        os.rename(os.path.join(dir_dataset, 'images2'),
                  os.path.join(dir_dataset, 'images'))

    # (2)
    pairs = []
    for filename in os.listdir(os.path.join(dir_dataset, 'images', image_set)):
        anno = os.path.join(dir_dataset, 'annotations', image_set,
                            filename.replace('png', 'json'))
        img = os.path.join(dir_dataset, 'images', image_set, filename)
        if not os.path.exists(anno):
            anno = None
        pairs.append([img, anno])

    overlap = 0.25
    sizes = [768] if single_scale else [512, 768, 1024, 1536]
    save_empty = image_set == 'test'
    image_set = f"{image_set}-{sizes[0]}" if single_scale else image_set

    out_dir_images = os.path.join(dir_dataset, 'images', f'{image_set}-crop')
    out_dir_annos = os.path.join(dir_dataset, 'annotations',
                                 f'{image_set}-crop')

    cropper = Cropper(sizes, overlap)
    cropper.crop_batch(pairs, out_dir_images, out_dir_annos, save_empty)

    # (3)
    pairs = []
    for filename in os.listdir(out_dir_images):
        img = os.path.join('images', f'{image_set}-crop', filename)
        anno = None if image_set == 'test' else os.path.join(
            'annotations', f'{image_set}-crop', filename.replace(
                'jpg', 'json'))
        pairs.append([img, anno])
    out_dir = os.path.join(dir_dataset, 'image-sets')
    os.makedirs(out_dir, exist_ok=True)
    json.dump(pairs,
              open(os.path.join(out_dir, f'{image_set}.json'), 'wt'),
              indent=2)
Пример #9
0
from mmdet.apis import init_detector, inference_detector
import mmcv
import os
import cv2
from mmdet.core import rotated_box_to_poly_np
from mmcv.visualization import imshow_det_bboxes
import numpy as np
from obb_anns import OBBAnns

annotations_file = "data/deep_scores_dense/deepscores_test.json"
obb = OBBAnns(annotations_file)
obb.load_annotations()
obb.set_annotation_set_filter(['deepscores'])
CLASSES = tuple([v["name"] for (k, v) in obb.get_cats().items()])

config_file = 'DeepScoresV2_s2anet/fullrez_crop/s2anet_r50_fpn_1x_deepscoresv2_tugg_lowrez.py'
checkpoint_file = 'DeepScoresV2_s2anet/fullrez_crop/epoch_500.pth'

model_name = "s2anet_fullrez_crop"
images_folder = "/home/tugg/Documents/RealScores/Realworld_Test"

resize = 1.0

model = init_detector(config_file, checkpoint_file, device='cuda:0')

images = os.listdir(images_folder)
os.makedirs(os.path.join(images_folder, model_name), exist_ok=True)

for img in images:
    if os.path.isdir(os.path.join(images_folder, img)):
        continue
Пример #10
0
    else:
        label = self.cat_info[cat_id]['name']

        if print_label:
            pos = print_text_label(pos, label, '#ffffff', '#303030')
        if print_onset and 'onset' in parsed_comments.keys():
            pos = print_text_label(pos, parsed_comments['onset'], '#ffffff',
                                   '#091e94')
        if print_staff_pos and 'rel_position' in parsed_comments.keys():
            print_text_label(pos, parsed_comments['rel_position'], '#ffffff',
                             '#0a7313')

    return draw


ann = OBBAnns('../scanned_ds/ili_scores.json')
ann.load_annotations()
data_root = '../scanned_ds'
out_dir = 'out_ili'
annotation_set = 'deepscores'
annotation_set = ann.annotation_sets.index(annotation_set)
ann.chosen_ann_set = ann.chosen_ann_set[annotation_set]
for img_info in ann.img_info:
    img_id = img_info['id']
    ann.visualize(img_id=img_id, data_root=data_root, out_dir=out_dir)
    # img_info, ann_info = ann.get_img_ann_pair(ids=[img_id])
    # img_info, ann_info = img_info[0], ann_info[0]
    #
    # # Get the data_root from the ann_file path if it doesn't exist
    # if data_root is None:
    #     data_root = osp.split(ann.ann_file)[0]