def get_label_colortable(n_labels, shape):
if cv2 is None:
raise RuntimeError('get_label_colortable requires OpenCV (cv2)')
rows, cols = shape
if rows * cols < n_labels:
raise ValueError
cmap = label_colormap(n_labels)
table = np.zeros((rows * cols, 50, 50, 3), dtype=np.uint8)
for lbl_id, color in enumerate(cmap):
color_uint8 = (color * 255).astype(np.uint8)
table[lbl_id, :, :] = color_uint8
text = '{:<2}'.format(lbl_id)
cv2.putText(table[lbl_id], text, (5, 35),
cv2.cv.CV_FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 3)
table = table.reshape(rows, cols, 50, 50, 3)
table = table.transpose(0, 2, 1, 3, 4)
table = table.reshape(rows * 50, cols * 50, 3)
return table
# -----------------------------------------------------------------------------
# Evaluation
# -----------------------------------------------------------------------------
python类color()的实例源码
def overlay_heatmap(image, heatmap, cmap='jet', vmin=0, vmax=1, img_ratio=0.4):
""" create a visualization of the image with overlaid heatmap """
img_gray = image
if len(image.shape) == 3:
img_gray = skimage.color.rgb2gray(image)
elif len(image.shape) != 2:
raise Exception('Image should be grayscale or rgb')
heatmap_norm = (heatmap - vmin) / (vmax - vmin)
cmap = mpl.cm.get_cmap(cmap)
heatmap_vis = cmap(heatmap_norm)
img_gray_3plane = np.repeat(img_gray.reshape(np.append(img_gray.shape, 1)), 3, axis=2)
heatmap_overlay = (1.0 - img_ratio) * heatmap_vis[:,:,0:3] + img_ratio * img_gray_3plane
mask = np.isnan(heatmap)
heatmap_overlay[mask] = img_gray_3plane[mask]
return heatmap_overlay
def draw_circle(x, y, r, img, color_r, color_g, color_b):
"""Draws a Pacman to img
Args:
x, int, x location in img
y, int, y location in img
r, int, radius of circle
img, np.array, 3D color image matrix
color_r, int, red channel of color
color_g, int, green channel of color
color_b, int, blue channel of color
"""
y_start = int(max(0, y - r))
y_stop = int(min(y + r, img.shape[0] - 1))
for y_i in range(y_start, y_stop):
x_start = int(x - math.sqrt(r**2 - (y - y_i)**2))
x_stop = int(x + math.sqrt(r**2 - (y - y_i)**2))
for x_i in range(x_start, x_stop):
img[x_i, y_i, 0] = color_r
img[x_i, y_i, 1] = color_g
img[x_i, y_i, 2] = color_b
def draw_rect(x, y, w, h, img, color_r, color_g, color_b):
"""Draws a rectangle to img
Args:
x, int, x location in img
y, int, y location in img
w, int, width
h, int, height
img, np.array, 3D color image matrix
color_r, int, red channel of color
color_g, int, green channel of color
color_b, int, blue channel of color
"""
y_start = int(max(0, y))
y_stop = int(min(y + h, img.shape[0] - 1))
x_start = int(max(0, x))
x_stop = int(min(x + w, img.shape[1] - 1))
for y_i in range(y_start, y_stop):
for x_i in range(x_start, x_stop):
img[y_i, x_i, 0] = color_r
img[y_i, x_i, 1] = color_g
img[y_i, x_i, 2] = color_b
def mandelbrot_color(matrix, output_file_name):
"""Generates a color version of the Mandelbrot Set
Writes its output file to output_file_name
Args:
matrix: np.array, 2D array representing the mandelbrot set
output_file_name: string, filename to write image to
"""
# I wasn't quite sure on how to do the coloring, so I just interpolated
# between two colors:
color1 = np.array([[.2], [.2], [.8]])
color2 = np.array([[1], [.2], [.5]])
color_img = np.zeros((matrix.shape[0], matrix.shape[1], 3))
color_img[:, :, 0] = color1[0] + matrix[:, :] * (color2[0] - color1[0])
color_img[:, :, 1] = color1[1] + matrix[:, :] * (color2[1] - color1[1])
color_img[:, :, 2] = color1[2] + matrix[:, :] * (color2[2] - color1[2])
print("\nWriting image to:", output_file_name)
skimage.io.imsave(output_file_name, color_img)
def draw_arrow(x0, y0, x1, y1, input_img, color):
input_img = draw_line(x0, y0, x1, y1, input_img, color)
dx = x1 - x0
dy = y1 - y0
#endpoint for one edge of arrow
x2 = x0 + 0.75 * dx + 0.25 * (3 ** -0.5) * dy
y2 = y0 + 0.75 * dy - 0.25 * (3 ** -0.5) * dx
x3 = x0 + 0.75 * dx - 0.25 * (3 ** -0.5) * dy
y3 = y0 + 0.75 * dy + 0.25 * (3 ** -0.5) * dx
input_img = draw_line(x2, y2, x1, y1, input_img, color)
input_img = draw_line(x3, y3, x1, y1, input_img, color)
return input_img
#transform(TypeSpecialize(checks=False))
def write_img(out_img, out_filename, do_clip=True):
"""Writes out_img to out_filename
"""
if use_4channel and len(out_img.shape) == 3 and out_img.shape[2] == 4:
out_img = out_img[:,:,:3]
assert out_img is not None, 'expected out_img to not be None'
out_img = numpy.clip(out_img, 0, 1) if do_clip else out_img
if is_pypy:
out_img = numpy.asarray(out_img*255, 'uint8')
if len(out_img.shape) == 2:
mode = 'L'
elif len(out_img.shape) == 3:
if out_img.shape[2] == 3:
mode = 'RGB'
elif out_img.shape[2] == 4:
mode = 'RGBA'
else:
raise ValueError('unknown color image mode')
else:
raise ValueError('unknown number of dimensions for image')
I = Image.frombytes(mode, (out_img.shape[1], out_img.shape[0]), out_img.tobytes())
I.save(out_filename)
else:
try:
skimage.io.imsave(out_filename, out_img)
except:
print('Caught exception while saving to {}: image shape is {}, min: {}, max: {}'.format(out_filename, out_img.shape, out_img.min(), out_img.max()))
raise
def alpha_blend(img, background=255):
"""
Take an image, assume the last channel is a alpha channel and remove it
by using the appropriate background.
:param img: The image to alpha blend into given background.
:param background: The background color to use when alpha blending.
A scalar is expected, which is used for all
the channels.
"""
alpha = img[..., -1] / 255.0
channels = img[..., :-1]
new_img = numpy.zeros_like(channels)
for ichan in range(channels.shape[-1]):
new_img[..., ichan] = numpy.clip(
(1 - alpha) * background + alpha * channels[..., ichan],
a_min=0, a_max=255)
return new_img
def rgb2gray(img):
print img.shape
img = skimage.color.rgb2gray(img)
return img
def rgb2gray(img):
print img.shape
img = skimage.color.rgb2gray(img)
return img
def grouped_bar(features, bar_labels=None, group_labels=None, ax=None, colors=None):
'''
features.shape like np.array([n_bars, n_groups])
>>> bars = np.random.rand(5,3)
>>> grouped_bar(bars)
>>> group_labels = ['group%d' % i for i in range(bars.shape[1])]
>>> bar_labels = ['bar%d' % i for i in range(bars.shape[0])]
>>> grouped_bar(bars, group_labels=group_labels, bar_labels=bar_labels)
'''
n_bars, n_groups = features.shape[0:2]
if ax is None:
fig, ax = plt.subplots()
fig.set_size_inches(9,6)
else:
fig = ax.get_figure()
if colors is None:
colors = mpl.cm.spectral(np.linspace(0, 1, n_bars))
index = np.arange(n_groups)
bar_width = 1.0/(n_bars) * 0.75
for j,group in enumerate(features):
label = bar_labels[j] if bar_labels is not None else None
ax.bar(index + j*bar_width - bar_width*n_bars/2.0,
group, bar_width, color=colors[j], label=label, alpha=0.4)
ax.margins(0.05,0.0) # so the bar graph is nicely padded
if bar_labels is not None:
ax.legend(loc='upper left', bbox_to_anchor=(1.0,1.02), fontsize=14)
if group_labels is not None:
ax.set_xticks(index + (n_bars/2.)*bar_width - bar_width*n_bars/2.0)
ax.set_xticklabels(group_labels, rotation=0.0)
for item in (ax.get_xticklabels() + ax.get_yticklabels()):
item.set_fontsize(14)
def draw_pacman_right(x, y, r, img, ma, color_r, color_g, color_b):
"""Draws a Pacman to img
Args:
x, int, x location in img (center of pacman)
y, int, y location in img (center of pacman)
r, int, radius of pacman
img, np.array, 3D color image matrix
ma, float, angle mouth is open at ("mouth angle")
color_r, float, red channel of color
color_g, float, green channel of color
color_b, float, blue channel of color
"""
y_start = int(max(0, y - r))
y_stop = int(min(y + r, img.shape[0] - 1))
for y_i in range(y_start, y_stop):
x_start = int(x - math.sqrt(r**2 - (y - y_i)**2))
x_stop = int(x + math.sqrt(r**2 - (y - y_i)**2))
# top half of mouth:
if y_i > y - float(r) * math.sin(ma) and y_i <= y:
r_mouth = float(y - y_i) / math.sin(ma)
x_stop = int(x + r_mouth * math.cos(ma))
# bottom half of mouth:
elif y_i < y + float(r) * math.sin(ma) and y_i > y:
r_mouth = float(y_i - y) / math.sin(ma)
x_stop = int(x + r_mouth * math.cos(ma))
for x_i in range(x_start, x_stop):
img[x_i, y_i, 0] = color_r
img[x_i, y_i, 1] = color_g
img[x_i, y_i, 2] = color_b
# draw the eye:
draw_circle(x, y - int(r / 2), int(r / 10.), img, 0, 0, 0)
def draw_pacman_right(x, y, r, img, ma, color_r, color_g, color_b):
"""Draws a Pacman to img
Args:
x, int, x location in img (center of pacman)
y, int, y location in img (center of pacman)
r, int, radius of pacman
img, np.array, 3D color image matrix
ma, float, angle mouth is open at ("mouth angle")
color_r, float, red channel of color
color_g, float, green channel of color
color_b, float, blue channel of color
"""
color = (color_r, color_g, color_b)
y_start = int(max(0, y - r))
y_stop = int(min(y + r, img.shape[0] - 1))
for y_i in range(y_start, y_stop):
x_start = int(x - math.sqrt(r**2 - (y - y_i)**2))
x_stop = int(x + math.sqrt(r**2 - (y - y_i)**2))
# top half of mouth:
if y_i > y - float(r) * math.sin(ma) and y_i <= y:
r_mouth = float(y - y_i) / math.sin(ma)
x_stop = int(x + r_mouth * math.cos(ma))
# bottom half of mouth:
elif y_i < y + float(r) * math.sin(ma) and y_i > y:
r_mouth = float(y_i - y) / math.sin(ma)
x_stop = int(x + r_mouth * math.cos(ma))
for x_i in range(x_start, x_stop):
img[x_i, y_i] = color
# draw the eye:
draw_circle(x, y - int(r / 2), int(r / 10.), img, 0, 0, 0)
#transform(TypeSpecialize(checks=False))
def draw_rect(x, y, w, h, img, color_r, color_g, color_b):
"""Draws a rectangle to img
Args:
x, int, x location in img
y, int, y location in img
w, int, width
h, int, height
img, np.array, 3D color image matrix
color_r, int, red channel of color
color_g, int, green channel of color
color_b, int, blue channel of color
"""
color = (color_r, color_g, color_b)
y_start = int(max(0, y))
y_stop = int(min(y + h, img.shape[0] - 1))
x_start = int(max(0, x))
x_stop = int(min(x + w, img.shape[1] - 1))
for y_i in range(y_start, y_stop):
for x_i in range(x_start, x_stop):
img[y_i, x_i, 0] = color_r
img[y_i, x_i, 1] = color_g
img[y_i, x_i, 2] = color_b
#transform(TypeSpecialize(checks=False))
def draw_arrow(x0, y0, x1, y1, input_img, color):
#x0 = start_point[0]
#y0 = start_point[1]
#x1 = x0 + velocity[0]
#y1 = y0 + velocity[1]
input_img = draw_line(x0, y0, x1, y1, input_img, color)
dx = x1 - x0
dy = y1 - y0
#endpoint for one edge of arrow
x2 = x0 + 0.75 * dx + 0.25 * (3 ** -0.5) * dy
y2 = y0 + 0.75 * dy - 0.25 * (3 ** -0.5) * dx
x3 = x0 + 0.75 * dx - 0.25 * (3 ** -0.5) * dy
y3 = y0 + 0.75 * dy + 0.25 * (3 ** -0.5) * dx
input_img = draw_line(x2, y2, x1, y1, input_img, color)
input_img = draw_line(x3, y3, x1, y1, input_img, color)
return input_img
#transform(TypeSpecialize(checks=False))
def find_color_value(dist, r):
#dist is a 2D vector with magnitude smaller than 1, r is its manitude
#representing a position inside the color wheel
angle = np.arctan2(dist[0], dist[1])
color = np.array([0.0, 0.0, 0.0])
if angle >= 0 and angle <= 2.0 * np.pi / 3.0:
scale = angle * 3.0 / (2.0 * np.pi)
color[0] = 1.0 - scale
color[1] = scale
if angle > 2.0 * np.pi / 3.0:
scale = (angle - 2.0 * np.pi / 3.0) * 3.0 / (2.0 * np.pi)
color[1] = 1.0 - scale
color[2] = scale
if angle < -2.0 * np.pi / 3.0:
real_angle = angle + 2.0 * np.pi
scale = (real_angle - 2.0 * np.pi / 3.0) * 3.0 / (2.0 * np.pi)
color[1] = 1.0 - scale
color[2] = scale
if angle < 0 and angle >= -2.0 * np.pi / 3.0:
real_angle = angle + 2.0 * np.pi
scale = (real_angle - 4.0 * np.pi / 3.0) * 3.0 / (2.0 * np.pi)
color[2] = 1.0 - scale
color[0] = scale
color *= r ** 0.25
return color
#transform(TypeSpecialize(checks=False))
def read_img(in_filename, grayscale=False, extra_info={}):
"""Returns the image saved at in_filename as a numpy array.
If grayscale is True, converts from 3D RGB image to 2D grayscale image.
"""
if is_pypy:
ans = Image.open(in_filename)
height = ans.height
width = ans.width
channels = len(ans.getbands())
if ans.mode == 'I':
numpy_mode = 'uint32'
maxval = 65535.0
elif ans.mode in ['L', 'RGB', 'RGBA']:
numpy_mode = 'uint8'
maxval = 255.0
else:
raise ValueError('unknown mode')
ans = numpy.fromstring(ans.tobytes(), numpy_mode).reshape((height, width, channels))
ans = ans/maxval
if grayscale and (len(ans.shape) == 3 and ans.shape[2] == 3):
ans = ans[:,:,0]*0.2125 + ans[:,:,1]*0.7154 + ans[:,:,2]*0.0721
if len(ans.shape) == 3 and ans.shape[2] == 1:
ans = ans[:,:,0]
return ans
else:
ans = skimage.io.imread(in_filename)
if ans.dtype == numpy.int32: # Work around scikit-image bug #1680
ans = numpy.asarray(ans, numpy.uint16)
ans = skimage.img_as_float(ans)
if grayscale:
ans = skimage.color.rgb2gray(ans)
# print('here', use_4channel, len(ans.shape) == 3, ans.shape[2] == 3)
if use_4channel and len(ans.shape) == 3 and ans.shape[2] == 3:
ans = numpy.dstack((ans,) + (numpy.ones((ans.shape[0], ans.shape[1], 1)),))
extra_info['originally_3channel'] = True
return ans
def lblshow(label_img, labels_str=None, f=None, ax=None, cmap=None, *args, **kwargs):
''' display a labeled image with associated legend
Parameters
----------
label_img : labeled image [nrows, ncols] = numpy.array.shape
labels_str : a complete list of labels
f : (optional) a figure handle
cmap : the color of each label (optional). like a list of colors, e.g.,
['Red','Green',...] or a matplotlib.colors.ListedColormap)
'''
if labels_str is None:
labels_str = [str(i) for i in np.unique(label_img)]
if ax is None:
if f is None:
f,ax = plt.subplots(1,1)
f.set_size_inches(9,6)
else:
ax = f.gca()
elif f is None:
f = ax.get_figure()
nlabels = len(labels_str)
if type(cmap) is mpl.colors.ListedColormap:
pass
elif hasattr(cmap, '__iter__'):
if not kwargs.has_key('norm'):
bounds = range(0,len(cmap)+1)
kwargs['norm'] = mpl.colors.BoundaryNorm(bounds, len(cmap)) # HACKY
cmap = mpl.colors.ListedColormap(cmap)
elif cmap is None:
colors = mpl.cm.spectral(np.linspace(0, 1, nlabels))
cmap = mpl.colors.ListedColormap(colors)
else:
assert False, 'invalid color map'
im = ax.imshow(label_img, cmap=cmap, *args, **kwargs); ax.axis('off')
# create an axes on the right side of ax. The width of cax will be 5%
# of ax and the padding between cax and ax will be fixed at 0.05 inch.
divider = make_axes_locatable(ax)
cax = divider.append_axes("right", size="5%", pad=0.05)
cbar = plt.colorbar(im, cax=cax)
cbar.ax.get_yaxis().set_ticks([])
for j, lab in enumerate(labels_str):
cbar.ax.text(1.3, float(2 * j + 1) / (nlabels*2), lab, ha='left', va='center')
return f
def draw_ghost(x, y, r, img, color_r, color_g, color_b, tf, blink):
"""Draws a ghost to img
Args:
x, int, x location in img
y, int, y location in img
r, int, radius of the ghosts's head
img, np.array, 3D color image matrix
color_r, int, red channel of color
color_g, int, green channel of color
color_b, int, blue channel of color
tf, float, how much of ghost is not tentacles
blink, boolean, whether or not the ghost should be blinking
"""
y_start = int(max(0, y - r))
y_stop = int(min(y + r, img.shape[1] - 1))
for y_i in range(y_start, y_stop):
x_start = int(x - math.sqrt(r**2 - (y - y_i)**2))
x_stop = int(x + math.sqrt(r**2 - (y - y_i)**2))
# bottom half of ghost:
if y_i > y:
x_start = int(max(0, x - r))
x_stop = int(min(x + r, img.shape[0] - 1))
# print(x_start, x_stop, y_start, y_stop)
for x_i in range(x_start, x_stop):
if y_i <= y + tf * r:
img[x_i, y_i, 0] = color_r
img[x_i, y_i, 1] = color_g
img[x_i, y_i, 2] = color_b
else:
if x_i < x - r * 5/7. or (x_i > x - r * 3/7. and x_i < x - r * 1/7.) or (x_i > x + r * 1/7. and x_i < x + r * 3/7.) or (x_i > x + r * 5/7.):
img[x_i, y_i, 0] = color_r
img[x_i, y_i, 1] = color_g
img[x_i, y_i, 2] = color_b
# draw the eye:
if not blink:
draw_circle(x - int(r / 4), y - int(r / 2), int(r / 5.), img, 1, 1, 1)
draw_circle(x + int(r / 4), y - int(r / 2), int(r / 5.), img, 1, 1, 1)
draw_circle(x - int(r / 8.), y - int(r / 2), int(r / 9.), img, 0, 0, 1)
draw_circle(x + int(r * 3 / 8.), y - int(r / 2), int(r / 9.), img, 0, 0, 1)
else:
draw_rect(y - int(r / 2), x - int(r / 4), r / 8., r / 4., img, 0, 0, 0)
draw_rect(y - int(r / 2), x + int(r / 4), r / 8., r / 4., img, 0, 0, 0)
def optical_flow_ssd(input_img1, input_img2):
h = input_img1.shape[0]
w = input_img1.shape[1]
output_img = np.zeros(input_img1.shape, 'float32')
output_img[:, :, :] = input_img2[:, :, :]
u = np.zeros([h, w], 'float32')
v = np.zeros([h, w], 'float32')
window_size = 21
offset = int((window_size - 1) / 2.0)
summed_ssd = np.zeros([input_img1.shape[0], input_img1.shape[1], window_size ** 2], 'float32')
for r in range(window_size):
for c in range(window_size):
offset_y = r - offset
offset_x = c - offset
ind = window_size * r + c
summed_ssd[:, :, ind] = calc_summed_ssd(input_img1, input_img2, offset_y, offset_x)
max_of = 0.0
for r in range(offset, h - offset):
for c in range(offset, w - offset):
ssd = summed_ssd[r + offset, c + offset, :] + summed_ssd[r - offset - 1, c - offset - 1, :] - summed_ssd[r + offset, c - offset - 1, :] - summed_ssd[r - offset - 1, c + offset, :]
ind = np.argmin(ssd)
offset_c = ind % window_size
offset_r = (ind - offset_c) // window_size
offset_y = offset_r - offset
offset_x = offset_c - offset
u[r, c] = offset_x
v[r, c] = offset_y
if (u[r, c] ** 2 + v[r, c] ** 2) ** 0.5 > max_of:
max_of = (u[r, c] ** 2 + v[r, c] ** 2) ** 0.5
for r in range(offset, h - offset, 10):
for c in range(offset, w - offset, 10):
scale = ((u[r, c] ** 2 + v[r, c] ** 2) ** 0.5) / max_of
dist = np.array([u[r, c], v[r, c]], 'float32') / max_of
color = find_color_value(dist, scale)
output_img = draw_arrow(float(r), float(c), float(r - u[r, c]), float(c - v[r, c]), output_img, color = color)
output_img = output_img[20 : h - 20, 20 : w - 20, :]
return output_img
#transform(TypeSpecialize(checks=False))
def fetch(self, key=''):
if key == 'filename_raster':
# A raster filename holds the file in a raster graphic format
return self.fetch('filename')
elif key == 'filename_zxing':
return pathlib2.Path(self.fetch('filename_raster')).as_uri()
elif key == 'ndarray':
Image.MAX_IMAGE_PIXELS = self.config('max_decompressed_size')
try:
image_array = skimage.io.imread(self.fetch('filename_raster'))
if image_array.shape == (2,):
# Assume this is related to
# https://github.com/scikit-image/scikit-image/issues/2154
return image_array[0]
return image_array
except Image.DecompressionBombWarning:
logging.warn('The file "{0}" contains a lot of pixels and '
'can take a lot of memory when decompressed. '
'To allow larger images, modify the '
'"max_decompressed_size" config.'
.format(self.fetch('filename')))
# Use empty array as the file cannot be read.
return numpy.ndarray(0)
elif key == 'ndarray_grey':
with warnings.catch_warnings():
warnings.simplefilter("ignore")
return skimage.img_as_ubyte(
skimage.color.rgb2grey(self.fetch('ndarray')))
elif key == 'ndarray_hsv':
with warnings.catch_warnings():
warnings.simplefilter("ignore")
return skimage.img_as_ubyte(
skimage.color.rgb2hsv(self.fetch('ndarray_noalpha')))
elif key == 'ndarray_noalpha':
if self.is_type('alpha'):
return self.alpha_blend(self.fetch('ndarray'))
return self.fetch('ndarray')
elif key == 'pillow':
pillow_img = Image.open(self.fetch('filename_raster'))
self.closables.append(pillow_img)
return pillow_img
return super(ImageFile, self).fetch(key)
def analyze_color_calibration_target(self):
"""
Find whether there is a color calibration strip on top of the image.
"""
grey_array = self.fetch('ndarray_grey')
image_array = self.fetch('ndarray')
if grey_array is None:
return {}
# For the images we're testing, the IT8 bar takes about 20% of the
# image and also in the 20% we need the mid area
bary = int(0.2 * grey_array.shape[0])
def bar_intensity(x):
sampley = max(int(0.1 * x.shape[0]), 2)
return numpy.mean(
x[(x.shape[0] - sampley) // 2:(x.shape[0] + sampley) // 2,
:, ...],
axis=0)
topbar = bar_intensity(grey_array[:bary, :, ...])
botbar = bar_intensity(grey_array[-bary:, :, ...])
def _merge_near(arr):
out = []
last_elem = arr[0]
out.append(last_elem)
for elem in arr[1:]:
if elem != last_elem:
out.append(elem)
last_elem = elem
return numpy.asarray(out)
# Bottom bars seem to have smaller intensity because of the background
# Hence, we set a smaller threshold for peaks in bottom bars.
bot_spikes = _merge_near((numpy.diff(botbar)) > -2.5).sum()
top_spikes = _merge_near((numpy.diff(topbar)) < 3).sum()
top_grey_mse, bot_grey_mse = 0, 0
if image_array.ndim == 3:
for chan in range(image_array.shape[2]):
top_grey_mse += (
(image_array[bary:, :, chan] -
grey_array[bary:]) ** 2).mean()
bot_grey_mse += (
(image_array[-bary, :, chan] -
grey_array[-bary]) ** 2).mean()
top_grey_mse /= 3.0
bot_grey_mse /= 3.0
data = {}
if 15 < top_spikes < 25:
data['Color:IT8TopBar'] = top_spikes
data['Color:IT8TopBarGreyMSE'] = top_grey_mse
if 15 < bot_spikes < 25:
data['Color:IT8BottomBar'] = bot_spikes
data['Color:IT8BottomBarGreyMSE'] = bot_grey_mse
return data
