Nuestros investigadores estrellas han agotado sus depósitos de café, por su búsqueda noche y día por la solución, hasta que Paúl encontró la solución en GitLab por lo tanto ahora la compartimos contigo.
Solución:
Anteriormente escribí una respuesta aquí explicando cómo hacer una interpolación lineal por partes en un histograma de imagen para hacer cumplir proporciones particulares de luces / medios tonos / sombras.
Los mismos principios básicos subyacen a la coincidencia de histogramas entre dos imágenes. Básicamente, usted calcula los histogramas acumulativos para sus imágenes fuente y de plantilla, luego interpola linealmente para encontrar los valores de píxeles únicos en la imagen de plantilla que más se acercan a los cuantiles de los valores de píxeles únicos en la imagen de origen:
import numpy as np
def hist_match(source, template):
"""
Adjust the pixel values of a grayscale image such that its histogram
matches that of a target image
Arguments:
-----------
source: np.ndarray
Image to transform; the histogram is computed over the flattened
array
template: np.ndarray
Template image; can have different dimensions to source
Returns:
-----------
matched: np.ndarray
The transformed output image
"""
oldshape = source.shape
source = source.ravel()
template = template.ravel()
# get the set of unique pixel values and their corresponding indices and
# counts
s_values, bin_idx, s_counts = np.unique(source, return_inverse=True,
return_counts=True)
t_values, t_counts = np.unique(template, return_counts=True)
# take the cumsum of the counts and normalize by the number of pixels to
# get the empirical cumulative distribution functions for the source and
# template images (maps pixel value --> quantile)
s_quantiles = np.cumsum(s_counts).astype(np.float64)
s_quantiles /= s_quantiles[-1]
t_quantiles = np.cumsum(t_counts).astype(np.float64)
t_quantiles /= t_quantiles[-1]
# interpolate linearly to find the pixel values in the template image
# that correspond most closely to the quantiles in the source image
interp_t_values = np.interp(s_quantiles, t_quantiles, t_values)
return interp_t_values[bin_idx].reshape(oldshape)
Por ejemplo:
from matplotlib import pyplot as plt
from scipy.misc import lena, ascent
source = lena()
template = ascent()
matched = hist_match(source, template)
def ecdf(x):
"""convenience function for computing the empirical CDF"""
vals, counts = np.unique(x, return_counts=True)
ecdf = np.cumsum(counts).astype(np.float64)
ecdf /= ecdf[-1]
return vals, ecdf
x1, y1 = ecdf(source.ravel())
x2, y2 = ecdf(template.ravel())
x3, y3 = ecdf(matched.ravel())
fig = plt.figure()
gs = plt.GridSpec(2, 3)
ax1 = fig.add_subplot(gs[0, 0])
ax2 = fig.add_subplot(gs[0, 1], sharex=ax1, sharey=ax1)
ax3 = fig.add_subplot(gs[0, 2], sharex=ax1, sharey=ax1)
ax4 = fig.add_subplot(gs[1, :])
for aa in (ax1, ax2, ax3):
aa.set_axis_off()
ax1.imshow(source, cmap=plt.cm.gray)
ax1.set_title('Source')
ax2.imshow(template, cmap=plt.cm.gray)
ax2.set_title('template')
ax3.imshow(matched, cmap=plt.cm.gray)
ax3.set_title('Matched')
ax4.plot(x1, y1 * 100, '-r', lw=3, label='Source')
ax4.plot(x2, y2 * 100, '-k', lw=3, label='Template')
ax4.plot(x3, y3 * 100, '--r', lw=3, label='Matched')
ax4.set_xlim(x1[0], x1[-1])
ax4.set_xlabel('Pixel value')
ax4.set_ylabel('Cumulative %')
ax4.legend(loc=5)
Para un par de imágenes RGB, puede aplicar esta función por separado a cada canal. Dependiendo del efecto que esté tratando de lograr, es posible que primero desee transformar las imágenes en un espacio de color diferente. Por ejemplo, podría transformarse en un espacio HSV y luego hacer coincidir solo en el canal V si desea igualar la luminosidad, pero no el tono o la saturación.
Aquí hay otra implementación basada en esto y scikit-image exposure
‘s cumulative_distribution
función que usa np.interp
similar a la implementación de ali_m. Se asume que la imagen de entrada y plantilla es en escala de grises y con valores de píxeles como números enteros en [0,255].
from skimage.exposure import cumulative_distribution
import matplotlib.pylab as plt
import numpy as np
def cdf(im):
'''
computes the CDF of an image im as 2D numpy ndarray
'''
c, b = cumulative_distribution(im)
# pad the beginning and ending pixels and their CDF values
c = np.insert(c, 0, [0]*b[0])
c = np.append(c, [1]*(255-b[-1]))
return c
def hist_matching(c, c_t, im):
'''
c: CDF of input image computed with the function cdf()
c_t: CDF of template image computed with the function cdf()
im: input image as 2D numpy ndarray
returns the modified pixel values
'''
pixels = np.arange(256)
# find closest pixel-matches corresponding to the CDF of the input image, given the value of the CDF H of
# the template image at the corresponding pixels, s.t. c_t = H(pixels) <=> pixels = H-1(c_t)
new_pixels = np.interp(c, c_t, pixels)
im = (np.reshape(new_pixels[im.ravel()], im.shape)).astype(np.uint8)
return im
La salida se muestra a continuación:
Me gustaría agregar una pequeña adición a la solución escrita anteriormente. Si alguien planea hacer esto como una función global (como para imágenes en escala de grises), sería una buena idea convertir el archivo final coincidente. array en su formato correspondiente (numpy.uint8). Esto podría ayudar en futuras conversiones de imágenes sin crear conflictos.
def hist_norm(source, template):
olddtype = source.dtype
oldshape = source.shape
source = source.ravel()
template = template.ravel()
s_values, bin_idx, s_counts = np.unique(source, return_inverse=True,
return_counts=True)
t_values, t_counts = np.unique(template, return_counts=True)
s_quantiles = np.cumsum(s_counts).astype(np.float64)
s_quantiles /= s_quantiles[-1]
t_quantiles = np.cumsum(t_counts).astype(np.float64)
t_quantiles /= t_quantiles[-1]
interp_t_values = np.interp(s_quantiles, t_quantiles, t_values)
interp_t_values = interp_t_values.astype(olddtype)
return interp_t_values[bin_idx].reshape(oldshape)
valoraciones y comentarios
Recuerda dar recomendación a esta noticia si te ayudó.