File size: 5,792 Bytes
be79b2f
 
9b19c92
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
fbb0539
9b19c92
 
 
 
fbb0539
9b19c92
 
7aebbbb
 
be79b2f
9b19c92
 
 
 
fbb0539
 
 
9b19c92
12f3d8c
be79b2f
9b19c92
12f3d8c
be79b2f
9b19c92
12f3d8c
be79b2f
9b19c92
12f3d8c
be79b2f
12f3d8c
9b19c92
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
from pathlib import Path

import datasets
import numpy as np
import pandas as pd
import PIL.Image
import PIL.ImageOps

_CITATION = """\
@InProceedings{huggingface:dataset,
title = {printed-2d-masks-with-holes-for-eyes-attacks},
author = {TrainingDataPro},
year = {2023}
}
"""

_DESCRIPTION = """\
The dataset consists of selfies of people and videos of them wearing a printed
2d mask with their face. The dataset solves tasks in the field of anti-spoofing
and it is useful for buisness and safety systems.
The dataset includes: **attacks** - videos of people wearing printed portraits
of themselves with cut-out eyes.
"""
_NAME = 'printed-2d-masks-with-holes-for-eyes-attacks'

_HOMEPAGE = f"https://huggingface.co/datasets/TrainingDataPro/{_NAME}"

_LICENSE = "cc-by-nc-nd-4.0"

_DATA = f"https://huggingface.co/datasets/TrainingDataPro/{_NAME}/resolve/main/data/"


def exif_transpose(img):
    if not img:
        return img

    exif_orientation_tag = 274

    # Check for EXIF data (only present on some files)
    if hasattr(img, "_getexif") and isinstance(
            img._getexif(), dict) and exif_orientation_tag in img._getexif():
        exif_data = img._getexif()
        orientation = exif_data[exif_orientation_tag]

        # Handle EXIF Orientation
        if orientation == 1:
            # Normal image - nothing to do!
            pass
        elif orientation == 2:
            # Mirrored left to right
            img = img.transpose(PIL.Image.FLIP_LEFT_RIGHT)
        elif orientation == 3:
            # Rotated 180 degrees
            img = img.rotate(180)
        elif orientation == 4:
            # Mirrored top to bottom
            img = img.rotate(180).transpose(PIL.Image.FLIP_LEFT_RIGHT)
        elif orientation == 5:
            # Mirrored along top-left diagonal
            img = img.rotate(-90,
                             expand=True).transpose(PIL.Image.FLIP_LEFT_RIGHT)
        elif orientation == 6:
            # Rotated 90 degrees
            img = img.rotate(-90, expand=True)
        elif orientation == 7:
            # Mirrored along top-right diagonal
            img = img.rotate(90,
                             expand=True).transpose(PIL.Image.FLIP_LEFT_RIGHT)
        elif orientation == 8:
            # Rotated 270 degrees
            img = img.rotate(90, expand=True)

    return img


def load_image_file(file, mode='RGB'):
    # Load the image with PIL
    img = PIL.Image.open(file)

    if hasattr(PIL.ImageOps, 'exif_transpose'):
        # Very recent versions of PIL can do exit transpose internally
        img = PIL.ImageOps.exif_transpose(img)
    else:
        # Otherwise, do the exif transpose ourselves
        img = exif_transpose(img)

    img = img.convert(mode)

    return np.array(img)


class Printed2dMasksWithHolesForEyesAttacks(datasets.GeneratorBasedBuilder):

    def _info(self):
        return datasets.DatasetInfo(description=_DESCRIPTION,
                                    features=datasets.Features({
                                        'photo': datasets.Image(),
                                        'attack': datasets.Value('string'),
                                        'phone': datasets.Value('string'),
                                        'gender': datasets.Value('string'),
                                        'age': datasets.Value('int8'),
                                        'country': datasets.Value('string')
                                    }),
                                    supervised_keys=None,
                                    homepage=_HOMEPAGE,
                                    citation=_CITATION,
                                    license=_LICENSE)

    def _split_generators(self, dl_manager):
        images = dl_manager.download_and_extract(f"{_DATA}photo.zip")
        attacks = dl_manager.download(f"{_DATA}attack.tar.gz")
        annotations = dl_manager.download(f"{_DATA}{_NAME}.csv")
        images = dl_manager.iter_files(images)
        attacks = dl_manager.iter_archive(attacks)
        return [
            datasets.SplitGenerator(name=datasets.Split.TRAIN,
                                    gen_kwargs={
                                        "images": images,
                                        'attacks': attacks,
                                        'annotations': annotations
                                    }),
        ]

    def _generate_examples(self, images, attacks, annotations):
        annotations_df = pd.read_csv(annotations, sep=';')

        for idx, (image_path, (attack_path, attack)) in enumerate(
                zip(sorted(images), sorted(attacks, key=lambda x: x[0]))):
            image_name = Path(image_path).name
            yield idx, {
                "photo":
                    load_image_file(image_path),
                "attack":
                    attack_path,
                # annotations_df.loc[annotations_df['photo'].str.lower() ==
                #                    image_name.lower()]['attack'].values[0],
                'phone':
                    annotations_df.loc[annotations_df['photo'].str.lower() ==
                                       image_name.lower()]['phone'].values[0],
                'gender':
                    annotations_df.loc[annotations_df['photo'].str.lower() ==
                                       image_name.lower()]['gender'].values[0],
                'age':
                    annotations_df.loc[annotations_df['photo'].str.lower() ==
                                       image_name.lower()]['age'].values[0],
                'country':
                    annotations_df.loc[annotations_df['photo'].str.lower() ==
                                       image_name.lower()]
                    ['country'].values[0],
            }