Hugging Face's logo

Spaces:
userIdc2024
/
Bulk-Image-API
Sleeping

App Files Community
Bulk-Image-API
File size: 6,462 Bytes 
6c01eb2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
import random
import piexif
from PIL import Image
from io import BytesIO

def generate_metadata(model):
    # Define different values based on iPhone model
    exposure_times = {
        "iPhone 11": "1/60",
        "iPhone 11 Pro": "1/70",
        "iPhone 12": "1/100",
        "iPhone 12 Pro": "1/110",
        "iPhone 13": "1/120",
        "iPhone 13 Pro": "1/130",
        "iPhone 13 Pro Max": "1/140",
        "iPhone 14": "1/200",
        "iPhone 14 Pro": "1/220",
        "iPhone 14 Pro Max": "1/240",
        "iPhone 15": "1/300",
        "iPhone 15 Plus": "1/320",
        "iPhone 15 Pro": "1/400",
        "iPhone 15 Pro Max": "1/500",
        "iPhone 16": "1/600",
        "iPhone 16 Pro": "1/700",
        "iPhone 16 Pro Max": "1/1000"
    }
    f_numbers = {
        "iPhone 11": "f/1.8",
        "iPhone 11 Pro": "f/1.8",
        "iPhone 12": "f/1.6",
        "iPhone 12 Pro": "f/1.6",
        "iPhone 13": "f/1.5",
        "iPhone 13 Pro": "f/1.5",
        "iPhone 13 Pro Max": "f/1.5",
        "iPhone 14": "f/1.4",
        "iPhone 14 Pro": "f/1.4",
        "iPhone 14 Pro Max": "f/1.4",
        "iPhone 15": "f/1.4",
        "iPhone 15 Plus": "f/1.4",
        "iPhone 15 Pro": "f/1.4",
        "iPhone 15 Pro Max": "f/1.3",
        "iPhone 16": "f/1.3",
        "iPhone 16 Pro": "f/1.3",
        "iPhone 16 Pro Max": "f/1.3"
    }
    focal_lengths = {
        "iPhone 11": "3.99 mm",
        "iPhone 11 Pro": "4.0 mm",
        "iPhone 12": "4.2 mm",
        "iPhone 12 Pro": "4.3 mm",
        "iPhone 13": "5.0 mm",
        "iPhone 13 Pro": "5.1 mm",
        "iPhone 13 Pro Max": "5.2 mm",
        "iPhone 14": "6.0 mm",
        "iPhone 14 Pro": "6.1 mm",
        "iPhone 14 Pro Max": "6.2 mm",
        "iPhone 15": "6.0 mm",
        "iPhone 15 Plus": "6.1 mm",
        "iPhone 15 Pro": "6.1 mm",
        "iPhone 15 Pro Max": "6.2 mm",
        "iPhone 16": "6.5 mm",
        "iPhone 16 Pro": "6.6 mm",
        "iPhone 16 Pro Max": "6.7 mm"
    }

    metadata = {
        "Make": "Apple",
        "Model": model,
        "Software": "iOS {}".format(random.choice([14, 15, 16, 17, 18, 19])),
        "Orientation": random.choice(["Horizontal (normal)", "Rotate 90 CW", "Rotate 180", "Rotate 90 CCW"]),
        "DateTime": "{}:{}:{} {:02}:{:02}:{:02}".format(random.randint(2022, 2024), random.randint(1, 12), random.randint(1, 28), random.randint(0, 23), random.randint(0, 59), random.randint(0, 59)),
        "ExposureTime": exposure_times[model],
        "FNumber": f_numbers[model],
        "ISOSpeedRatings": random.choice([100, 200, 400, 800, 1600]),
        "FocalLength": focal_lengths[model],
        "Flash": random.choice(["Flash fired", "Flash did not fire, compulsory mode", "Flash fired, auto mode"]),
        "WhiteBalance": random.choice(["Auto", "Manual"]),
        "MeteringMode": random.choice(["Pattern", "CenterWeightedAverage", "Spot"]),
        "SceneCaptureType": random.choice(["Standard", "Landscape", "Portrait", "NightScene"]),
        "GPSLatitude": "{:.4f} N".format(random.uniform(0.0, 90.0)),
        "GPSLongitude": "{:.4f} W".format(random.uniform(0.0, 180.0)),
        "Altitude": "{:.1f} m".format(random.uniform(0, 100)),
        "LensMake": "Apple",
        "LensModel": "{} back triple camera {} f/1.5".format(model, focal_lengths[model]),
        "ColorSpace": random.choice(["sRGB", "Adobe RGB"]),
        "PixelXDimension": random.choice([3024, 4032, 2160]),
        "PixelYDimension": random.choice([3024, 4032, 2160]),
        "ExposureBiasValue": random.choice(["0 EV", "+1 EV", "-1 EV"]),
        "BrightnessValue": "{:.1f}".format(random.uniform(-5, 10)),
        "ExposureMode": random.choice(["Auto Exposure", "Manual Exposure"])
    }
    return metadata

def dms_coordinates(value):
    """Convert decimal degrees to EXIF GPS (DMS format)."""
    degrees = int(value)
    minutes_float = (value - degrees) * 60
    minutes = int(minutes_float)
    seconds = round((minutes_float - minutes) * 60 * 10000)
    return [(degrees, 1), (minutes, 1), (seconds, 10000)]

def meta_data_helper_function(image_bytes,model=None):
    """
    Takes raw image bytes, adds realistic EXIF metadata, and returns new bytes.
    """
    if model is None:
        model = random.choice([
            "iPhone 11", "iPhone 11 Pro", "iPhone 12", "iPhone 12 Pro",
            "iPhone 13", "iPhone 13 Pro", "iPhone 13 Pro Max", "iPhone 14",
            "iPhone 14 Pro", "iPhone 14 Pro Max", "iPhone 15", "iPhone 15 Plus",
            "iPhone 15 Pro", "iPhone 15 Pro Max", "iPhone 16", "iPhone 16 Pro",
            "iPhone 16 Pro Max"
        ])

    # Load image from bytes
    img = Image.open(BytesIO(image_bytes))
    img = img.convert("RGB")  # Ensure compatibility

    # Generate metadata
    metadata = generate_metadata(model)

    # Build EXIF data
    exif_dict = {"0th": {}, "Exif": {}, "GPS": {}}

    exif_dict["0th"][piexif.ImageIFD.Make] = metadata["Make"]
    exif_dict["0th"][piexif.ImageIFD.Model] = metadata["Model"]
    exif_dict["0th"][piexif.ImageIFD.Software] = metadata["Software"]
    exif_dict["0th"][piexif.ImageIFD.DateTime] = metadata["DateTime"]

    # Exposure time (rational)
    num, den = map(int, metadata["ExposureTime"].split("/"))
    exif_dict["Exif"][piexif.ExifIFD.ExposureTime] = (num, den)

    # FNumber
    f_number = float(metadata["FNumber"].replace("f/", ""))
    exif_dict["Exif"][piexif.ExifIFD.FNumber] = (int(f_number * 10), 10)

    # ISO
    exif_dict["Exif"][piexif.ExifIFD.ISOSpeedRatings] = metadata["ISOSpeedRatings"]

    # Focal Length
    focal_length = float(metadata["FocalLength"].split()[0])
    exif_dict["Exif"][piexif.ExifIFD.FocalLength] = (int(focal_length * 10), 10)

    # GPS
    lat = float(metadata["GPSLatitude"].split()[0])
    lon = float(metadata["GPSLongitude"].split()[0])

    exif_dict["GPS"][piexif.GPSIFD.GPSLatitudeRef] = b'N' if lat >= 0 else b'S'
    exif_dict["GPS"][piexif.GPSIFD.GPSLatitude] = dms_coordinates(abs(lat))

    exif_dict["GPS"][piexif.GPSIFD.GPSLongitudeRef] = b'E' if lon >= 0 else b'W'
    exif_dict["GPS"][piexif.GPSIFD.GPSLongitude] = dms_coordinates(abs(lon))

    altitude_value = float(metadata["Altitude"].replace(" m", ""))
    exif_dict["GPS"][piexif.GPSIFD.GPSAltitude] = (int(altitude_value), 1)


    # Dump to bytes
    exif_bytes = piexif.dump(exif_dict)

    # Save to in-memory buffer
    output_io = BytesIO()
    img.save(output_io, format="JPEG", exif=exif_bytes)
    return output_io.getvalue()