Spaces:
Runtime error
Runtime error
File size: 3,486 Bytes
f2dbf59 |
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 |
import numpy as np
_ShadowEnd = 160
_HighlightStart = 200
def _gammaCurve(gamma, x):
""" Returns from 0.0 to 1.0"""
return pow((x / 255.0), (1.0 / gamma))
def _calcDevelopment(shadow_level, high_level, x):
"""
This function returns a development like this:
(return)
^
|
0.5 | o - o <-- mids level, always 0.5
| - -
| - -
| - o <-- high_level eg. 0.25
| -
| o <-- shadow_level eg. 0.15
|
0 -+-----------------|-------|------------|-----> x (input)
0 160 200 255
"""
if x < _ShadowEnd:
power = 0.5 - (_ShadowEnd - x) * (0.5 - shadow_level) / _ShadowEnd
elif x < _HighlightStart:
power = 0.5
else:
power = 0.5 - (x - _HighlightStart) * (0.5 - high_level) / (255 - _HighlightStart)
return power
class Map:
def __init__(self, map):
self.map = map
@staticmethod
def calculate(src_gamma, noise_power, shadow_level, high_level) -> 'Map':
map = np.zeros([256, 256], dtype=np.uint8)
# We need to level off top end and low end to leave room for the noise to breathe
crop_top = noise_power * high_level / 12
crop_low = noise_power * shadow_level / 20
pic_scale = 1 - (crop_top + crop_low)
pic_offs = 255 * crop_low
for src_value in range(0, 256):
# Gamma compensate picture source value itself
pic_value = _gammaCurve(src_gamma, src_value) * 255.0
# In the shadows we want noise gamma to be 0.5, in the highs, 2.0:
gamma = pic_value * (1.5 / 256) + 0.5
gamma_offset = _gammaCurve(gamma, 128)
# Power is determined by the development
power = _calcDevelopment(shadow_level, high_level, pic_value)
for noise_value in range(0, 256):
gamma_compensated = _gammaCurve(gamma, noise_value) - gamma_offset
value = pic_value * pic_scale + pic_offs + 255.0 * power * noise_power * gamma_compensated
if value < 0:
value = 0
elif value < 255.0:
value = int(value)
else:
value = 255
map[src_value, noise_value] = value
return Map(map)
def lookup(self, pic_value, noise_value):
return self.map[pic_value, noise_value]
def saveToFile(self, filename):
from PIL import Image
img = Image.fromarray(self.map)
img.save(filename)
if __name__ == "__main__":
import matplotlib.pyplot as plt
import numpy as np
def plotfunc(x_min, x_max, step, func):
x_all = np.arange(x_min, x_max, step)
y = []
for x in x_all:
y.append(func(x))
plt.figure()
plt.plot(x_all, y)
plt.grid()
def development1(x):
return _calcDevelopment(0.2, 0.3, x)
def gamma05(x):
return _gammaCurve(0.5, x)
def gamma1(x):
return _gammaCurve(1, x)
def gamma2(x):
return _gammaCurve(2, x)
plotfunc(0.0, 255.0, 1.0, development1)
plotfunc(0.0, 255.0, 1.0, gamma05)
plotfunc(0.0, 255.0, 1.0, gamma1)
plotfunc(0.0, 255.0, 1.0, gamma2)
plt.show() |