File size: 6,698 Bytes
52758c1 | 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 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | """
Authors(s):
Abdelrahman Abdelhamed (a.abdelhamed@samsung.com)
Copyright (c) 2022 Samsung Electronics Co., Ltd.
Licensed under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) License, (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at https://creativecommons.org/licenses/by-nc/4.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.
For conditions of distribution and use, see the accompanying LICENSE.md file.
Utility functions for handling DNG opcode lists.
"""
import struct
import numpy as np
from pipeline.exif_utils import get_tag_values_from_ifds
class Opcode:
def __init__(self, id_, dng_spec_ver, option_bits, size_bytes, data):
self.id = id_
self.dng_spec_ver = dng_spec_ver
self.size_bytes = size_bytes
self.option_bits = option_bits
self.data = data
def parse_opcode_lists(ifds):
# OpcodeList1, 51008, 0xC740
# Applied to raw image as read directly form file
# OpcodeList2, 51009, 0xC741
# Applied to raw image after being mapped to linear reference values
# That is, after linearization, black level subtraction, normalization, and clipping
# OpcodeList3, 51022, 0xC74E
# Applied to raw image after being demosaiced
opcode_list_tag_nums = [51008, 51009, 51022]
opcode_lists = {}
for i, tag_num in enumerate(opcode_list_tag_nums):
opcode_list_ = get_tag_values_from_ifds(tag_num, ifds)
if opcode_list_ is not None:
opcode_list_ = bytearray(opcode_list_)
opcodes = parse_opcodes(opcode_list_)
opcode_lists.update({tag_num: opcodes})
else:
pass
return opcode_lists
def parse_opcodes(opcode_list):
"""
Parse a byte array representing an opcode list.
:param opcode_list: An opcode list as a byte array.
:return: Opcode lists as a dictionary.
"""
# opcode lists are always stored in big endian
endian_sign = ">"
# opcode IDs
# 9: GainMap
# 1: Rectilinear Warp
# clip to
# [0, 2^32 - 1] for OpcodeList1
# [0, 2^16 - 1] for OpcodeList2
# [0, 1] for OpcodeList3
i = 0
num_opcodes = struct.unpack(endian_sign + "I", opcode_list[i:i + 4])[0]
i += 4
opcodes = {}
for j in range(num_opcodes):
opcode_id_ = struct.unpack(endian_sign + "I", opcode_list[i:i + 4])[0]
i += 4
dng_spec_ver = [struct.unpack(endian_sign + "B", opcode_list[i + k:i + k + 1])[0] for k in range(4)]
i += 4
option_bits = struct.unpack(endian_sign + "I", opcode_list[i:i + 4])[0]
i += 4
# option bits
if option_bits & 1 == 1: # optional/unknown
pass
elif option_bits & 2 == 2: # can be skipped for "preview quality", needed for "full quality"
pass
else:
pass
opcode_size_bytes = struct.unpack(endian_sign + "I", opcode_list[i:i + 4])[0]
i += 4
opcode_data = opcode_list[i:i + 4 * opcode_size_bytes]
i += 4 * opcode_size_bytes
# GainMap (lens shading correction map)
if opcode_id_ == 9:
opcode_gain_map_data = parse_opcode_gain_map(opcode_data)
opcode_data = opcode_gain_map_data
# WarpRectilinear
elif opcode_id_ == 1:
opcode_rect_warp_data = parse_opcode_rect_warp(opcode_data)
opcode_data = opcode_rect_warp_data
# set opcode object
opcode = Opcode(id_=opcode_id_, dng_spec_ver=dng_spec_ver, option_bits=option_bits,
size_bytes=opcode_size_bytes,
data=opcode_data)
opcodes.update({opcode_id_: opcode})
return opcodes
def parse_opcode_rect_warp(opcode_data):
endian_sign = ">" # big
opcode_dict = {}
'''
opcode_dict = {
'N': 3,
'coefficient_set': [
{
'k_r0': 1,
'k_r1': 0,
'k_r2': 0,
'k_r3': 0,
'k_t0': 0,
'k_t1': 0,
},
...
],
'cx': 0.5,
'cy': 0.5
}
'''
i = 0
num_planes = struct.unpack(endian_sign + "L", opcode_data[i:i + 4])[0]
i += 4
opcode_dict['N'] = num_planes
opcode_dict['coefficient_set'] = []
for j in range(num_planes):
keys = ['k_r0', 'k_r1', 'k_r2', 'k_r3', 'k_t0', 'k_t1']
coefficient_set = {}
for key in keys:
coefficient_set[key] = struct.unpack(endian_sign + "d", opcode_data[i:i + 8])[0]
i += 8
opcode_dict['coefficient_set'].append(coefficient_set)
opcode_dict['cx'] = struct.unpack(endian_sign + "d", opcode_data[i:i + 8])[0]
i += 8
opcode_dict['cy'] = struct.unpack(endian_sign + "d", opcode_data[i:i + 8])[0]
return opcode_dict
def parse_opcode_gain_map(opcode_data):
endian_sign = ">" # big
opcode_dict = {}
keys = ['top', 'left', 'bottom', 'right', 'plane', 'planes', 'row_pitch', 'col_pitch', 'map_points_v',
'map_points_h', 'map_spacing_v', 'map_spacing_h', 'map_origin_v', 'map_origin_h', 'map_planes', 'map_gain']
dtypes = ['L'] * 10 + ['d'] * 4 + ['L'] + ['f']
dtype_sizes = [4] * 10 + [8] * 4 + [4] * 2 # data type size in bytes
counts = [1] * 15 + [0] # 0 count means variable count, depending on map_points_v and map_points_h
# values = []
i = 0
for k in range(len(keys)):
if counts[k] == 0: # map_gain
counts[k] = opcode_dict['map_points_v'] * opcode_dict['map_points_h']
if counts[k] == 1:
vals = struct.unpack(endian_sign + dtypes[k], opcode_data[i:i + dtype_sizes[k]])[0]
i += dtype_sizes[k]
else:
vals = []
for j in range(counts[k]):
vals.append(struct.unpack(endian_sign + dtypes[k], opcode_data[i:i + dtype_sizes[k]])[0])
i += dtype_sizes[k]
opcode_dict[keys[k]] = vals
opcode_dict['map_gain_2d'] = np.reshape(opcode_dict['map_gain'],
(opcode_dict['map_points_v'], opcode_dict['map_points_h']))
return opcode_dict
|