def draw_mask(frame):
plt.imshow(frame, cmap='gray', vmin=0, vmax=200)
mask_left = RoiPoly(color='r')
plt.imshow(frame, cmap='gray', vmin=0, vmax=200)
mask_right = RoiPoly(color='b')
mask = numpy.logical_or(mask_left.get_mask(frame),
mask_right.get_mask(frame))
return mask
def label():
if len(sys.argv)>=2:
color = sys.argv[1]
else:
print('color?')
color = input()
ni = ''
data = np.array([0,0,0])
while(not ni == 'q'):
print("input image number:")
ni = input()
if ni =='q':
break
else:
fig = plt.figure()
img = cv2.imread('trainset/'+ni+'.png')
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB),interpolation='nearest')
roi = RoiPoly(color='r',fig=fig)
mask = roi.get_mask(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
data = np.vstack((data,handle(img,mask))) # Stack data sample
data = np.array(list(filter(lambda x: (x>=1).any(),data)))
print(str(data.shape))
print("label next press ENTER, finish label press Q then ENTER")
ni = input()
np.save(color+'.npy',data)
def label_barrels(img):
'''
Generates a mask for the barrel
'''
fig = set_fig(img, 'label barrels')
# Let user draw first ROI to mark red barrell
roi_barrel = RoiPoly(color='r', fig=fig)
mask_barrel = roi_barrel.get_mask(img[:, :, 0])
print(mask_barrel.shape)
# plt.imshow(mask_barrel)
# truncated = len(img[:, :, 0].flatten())
# x_indices = np.concatenate((img[:, :, 0].flatten().reshape(truncated,1), img[:, :, 1].flatten().reshape(truncated,1)), axis=1)
# x_new = np.concatenate((x_indices, img[:, :, 2].flatten().reshape(truncated,1)), axis=1)
# x_barrel = x_new[mask_barrel.flatten()]
# x_notbarrel = x_new[np.invert(mask_barrel).flatten()]
print(sum(mask_barrel.flatten()))
# print(sum(np.invert(mask_barrel).flatten()))
return mask_barrel
def custom_mask(img):
"""
Image segmentation function to create a custom polygon mask, and evalute radius and position of the masked object.
Need to use %matplotlib qt in jupyter notebook
Args:
img(array): Grayscale image as a Numpy array
Returns:
dict: Dictionary with keys: mask, radius, centroid (x/y)
"""
height = img.shape[0]
width = img.shape[1]
# click polygon mask interactive
plt.ion()
plt.imshow(img, extent=[0, width, height, 0])
plt.text(0.5, 1.05,'Click Polygon Mask with left click, finish with right click', fontsize=12,
horizontalalignment='center',
verticalalignment='center',c='darkred', transform= plt.gca().transAxes)# transform = ax.transAxes)
my_roi = RoiPoly(color='r')
# Extract mask and segementation details
mask = np.flipud(my_roi.get_mask(img)) # flip mask due to imshow
# determine radius of spheroid
radius = np.sqrt(np.sum(mask) / np.pi)
# determine center of mass
cy, cx = scipy_meas.center_of_mass(mask)
# hide pop-up windows
plt.ioff()
# return dictionary containing spheroid information
return {'mask': mask, 'radius': radius, 'centroid': (cx, cy)}
def manually_roi_select(lista_img, mask_list, n_mask):
fig = plt.figure()
plt.imshow(lista_img[int(n_mask)-1], interpolation='nearest', cmap=plt.cm.gray)
plt.colorbar()
plt.title("left click: line segment right click or double click: close region")
roi1 = RoiPoly(color='r', fig=fig)
mask = roi1.get_mask(mask_list[int(n_mask)-1])
mask_list[int(n_mask)-1] = mask
return roi1, mask
def annotate(img):
'''
Create a polygon for binary masking
Call the funciton after plt.imshow(your_image)
'''
my_roi = RoiPoly(color='r')
mask = my_roi.get_mask(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY))
return mask
def draw_roi(frames, region):
plt.imshow(frames[5000], cmap='gray', vmin=0, vmax=255)
plt.title("Draw " + region + " ROI")
roi = RoiPoly(color='r')
mask = roi.get_mask(frames[0])
gradient_signal = np.abs(np.gradient(np.mean(frames[:, mask], axis=1)))
threshold = np.mean(gradient_signal) + np.std(gradient_signal)
return gradient_signal, threshold
def manual_crop(s, normalize, n_slice):
fig = plt.figure(figsize=(15, 8))
plt.imshow(s,
interpolation="nearest",
cmap=plt.cm.gray,
norm=normalize)
plt.colorbar()
plt.title(f"Slice: {n_slice}")
plt.show(block=False)
roi1 = RoiPoly(color='r', fig=fig)
plt.close(fig)
mask = roi1.get_mask(s)
return s * mask
def roicrop(img):
# Show the image
fig = plt.figure()
plt.imshow(img, interpolation='nearest', cmap="Greys")
plt.title("left click: line segment right click: next figure")
plt.show(block=False)
# Let user draw first ROI
roi = RoiPoly(color='r', fig=fig)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
mask = roi.get_mask(gray)
return roi, mask
def label(dpath, mpath):
x = Image.open(dpath)
im = np.array(x)
im = im[:, :, 0]
plt.imshow(im)
my_roi = RoiPoly(color='r')
mask = my_roi.get_mask(im)
f_img = Image.fromarray(mask)
#Output path of mask
# Save mask to the path
f_img.save(mpath + dpath.split('/')[-1].split('.')[0] + ".jpg")
def label_image(img_path, img_id):
# Create image
img = Image.open('trainset/{}.jpg'.format(img_id))
# Show the image
fig = plt.figure()
plt.imshow(img)
# Let user draw first ROI
roi = RoiPoly(color='r', fig=fig)
mask = roi.get_mask(np.array(img)[:, :, 0])
plt.imshow(mask)
plt.show()
print(mask)
np.save('dataset/masks/{}.npy'.format(img_id), mask)
img.save('dataset/imgs/{}.png'.format(img_id))
def draw_roi(self):
"""
This function is meant to "test drive" the roipoly interface since it is new to the developer
Args:
----
self:pointer to current instance of the class
"""
image_file = random.choice(self.train_files)
image = plt.imread(self.root_location + image_file)
plt.figure(1)
plt.imshow(image)
my_roi = RoiPoly(color='r')
mask = my_roi.get_mask(image[:, :, 2]) * 1
plt.figure(2)
plt.imshow(mask, cmap="gray")
plt.show()
def main():
dir_train = "./2019Proj1_train/"
dir_labeled_train = "./labeled_train/"
if not os.path.exists(dir_labeled_train):
os.makedirs(dir_labeled_train)
filelist = os.listdir(dir_train)
num_file = len(filelist)
startIdx = 0
endIdx = num_file - 1
if len(sys.argv) > 1 and sys.argv[1].isdigit():
startIdx = int(sys.argv[1])
if len(sys.argv) > 2 and sys.argv[2].isdigit():
endIdx = int(sys.argv[2])
print(endIdx)
for i in range(max(0, startIdx), min(num_file - 1, endIdx) + 1):
filename = filelist[i]
name, extension = os.path.splitext(filename)
image = Image.open(dir_train + filename)
plt.title("Labeling: " + str(i) + ". " + name)
plt.imshow(image)
roi = RoiPoly(color='r')
# show result
plt.title("Result: " + str(i) + ". " + name)
plt.imshow(image)
roi.display_roi()
plt.show()
# get mask
imgSize = np.shape(image)
mask = roi.get_mask(np.zeros(imgSize[0:2], dtype=bool))
# show mask
# plt.title("Mask: " + str(i) + ". " + name)
# plt.imshow(mask)
# plt.show()
np.save(os.path.join(dir_labeled_train, name + '.npy'), mask)
print("Finish labeling: " + dir_labeled_train + name + '.npy')
plt.close()
def set_white_info(self, white_reflectance):
self.white_reflectance = white_reflectance
root = tk.Tk()
root.withdraw()
white_reference_path = filedialog.askopenfilename(
initialdir=self.cam_folder,
title="Select white reference image for '{}' camera".format(
self.cam_name))
root.destroy()
self.white_reference_path = white_reference_path
loop = True
while loop:
is_full_white_img = input(
"Does the white reference panel fills up the image? ('yes' / 'no')\n"
)
if is_full_white_img == 'yes':
loop = False
is_full_white_img = True
elif is_full_white_img == 'no':
loop = False
is_full_white_img = False
else:
print("Please type either 'yes' or 'no'.")
self.is_full_white_img = is_full_white_img
white_exp_t = self.read_exp_t_ms(white_reference_path)
self.white_exp_t = white_exp_t
white_array = ufunc.read_img2array(white_reference_path)
self.white_array = white_array
if not is_full_white_img:
bands = white_array.shape[2]
band = int(bands / 2)
fig = plt.figure()
plt.imshow(white_array[:, :, band], cmap=plt.get_cmap("Greys_r"))
plt.show(block=False)
roi = RoiPoly(color='r', fig=fig)
mask = roi.get_mask(white_array[:, :, band])
white_mean_values = np.mean(white_array[mask], axis=0)
self.white_mean_values = white_mean_values
def labeling(m=3):
'''Iterate over all training images and label m rois in each image'''
mask_list = []
for i in range(n):
i += 1
img_name = str(i)+'.png'
img = plt.imread(os.path.join('trainset',img_name))
masks = []
for j in range(m):
plt.imshow(img)
r = RoiPoly(color='r')
mask = r.get_mask(img[:,:,0]) # create mask of roi
masks.append(mask)
#combine masks
mask_result = masks[0] | masks[1]
mask_result = mask_result | masks[2]
mask_list.append(mask_result)
pickle_out = open('mask_list',"wb")
pickle.dump(mask_list, pickle_out)
pickle_out.close()
return mask_list
# fig = plt.figure()
# plt.imshow(I1, interpolation='nearest')
# plt.title('Image %i, draw fourth ROI' %i)
# plt.show(block=False)
# # Let user draw fourth ROI
# roi4 = RoiPoly(color='b', fig=fig)
#
# # Show the image with both ROIs
# plt.imshow(I1, interpolation='nearest')
# [x.display_roi() for x in [roi1, roi2, roi3, roi4]]
roi1.display_roi()
plt.title('All ROIs')
plt.show()
mask1 = roi1.get_mask(gray)
# mask2 = roi2.get_mask(gray)
# mask3 = roi3.get_mask(gray)
# mask4 = roi4.get_mask(gray)
# Show ROI masks
plt.imshow(mask1, interpolation='nearest', cmap='Greys')
plt.title('ROI mask')
plt.show()
# plt.imshow(mask1 + mask2 + mask3 + mask4, \
# interpolation='nearest', cmap="Greys")
# plt.title('ROI masks of the ROIs')
# plt.show()
r1, c1 = np.where(mask1 == True)
# r2,c2 = np.where(mask2 == True)
fig = plt.figure()
plt.imshow(img)
# plt.colorbar()
plt.title(
"left click: line segment right click or double click: close region"
)
plt.show(block=False)
roi2 = RoiPoly(color='b', fig=fig)
fig = plt.figure()
plt.imshow(img)
# plt.colorbar()
plt.title(
"left click: line segment right click or double click: close region"
)
plt.show(block=False)
roi3 = RoiPoly(color='b', fig=fig)
totalmasked = roi1.get_mask(img[:, :, 0]) + roi2.get_mask(
img[:, :, 0]) + roi3.get_mask(img[:, :, 0])
fig = plt.figure()
plt.imshow(totalmasked, cmap=plt.cm.gray)
plt.show()
savefilename, extension = filename.split('.')
np.save(savingdirectory + savefilename, totalmasked)
# Let user draw first ROI
roi1 = RoiPoly(color='r', fig=fig)
# Show the image with the first ROI
fig = plt.figure()
plt.imshow(img, interpolation='nearest', cmap="Greys")
plt.colorbar()
roi1.display_roi()
plt.title('draw second ROI')
plt.show(block=False)
# Let user draw second ROI
roi2 = RoiPoly(color='b', fig=fig)
# Show the image with both ROIs and their mean values
plt.imshow(img, interpolation='nearest', cmap="Greys")
plt.colorbar()
for roi in [roi1, roi2]:
roi.display_roi()
roi.display_mean(img)
plt.title('The two ROIs')
plt.show()
# Show ROI masks
plt.imshow(roi1.get_mask(img) + roi2.get_mask(img),
interpolation='nearest',
cmap="Greys")
plt.title('ROI masks of the two ROIs')
plt.show()
# Show the image
fig = plt.figure()
plt.imshow(I1, interpolation='nearest')
plt.title('Image %i, draw fourth ROI' %i)
plt.show(block=False)
# # Show the image with both ROIs
# plt.imshow(I1, interpolation='nearest')
# [x.display_roi() for x in [roi1, roi2, roi3]]
# roi1.display_roi()
# plt.title('All ROIs')
# plt.show()
mask1 = roi1.get_mask(gray)
mask2 = roi2.get_mask(gray)
mask3 = roi3.get_mask(gray)
# Show ROI masks
plt.imshow(mask1 + mask2 + mask3, \
interpolation='nearest', cmap="Greys")
plt.title('ROI masks of the ROIs')
plt.show()
r1,c1 = np.where(mask1 == True)
r2,c2 = np.where(mask2 == True)
r3,c3 = np.where(mask3 == True)
# 3 color classes for black, light gray-whiteish, dark gray-blackish
K1 = np.append(K1, I1[r1,c1,:], axis=0)
plt.show(block=False)
roi1 = RoiPoly(color='r', fig=fig)
# Show the image with the first ROI
fig = plt.figure(dpi=100)
plt.imshow(gray, interpolation='nearest', cmap="Greys")
plt.colorbar()
roi1.display_roi()
plt.title('draw second ROI')
plt.show(block=False)
# # Let user draw second ROI
roi2 = RoiPoly(color='b', fig=fig)
# Show the image with both ROIs and their mean values
plt.imshow(gray, interpolation='nearest', cmap="Greys")
plt.colorbar()
for roi in [roi1, roi2]:
roi.display_roi()
roi.display_mean(gray)
plt.title('The two ROIs')
plt.show()
# Show ROI masks
fig = plt.figure(dpi=100)
plt.imshow(roi1.get_mask(gray) + roi2.get_mask(gray),
interpolation='nearest',
cmap="Greys")
plt.savefig("img/mask.png")
plt.title('ROI masks of the two ROIs')
plt.show()
import numpy as np
from roipoly import RoiPoly
from matplotlib import pyplot as plt
import cv2
n = 42 #first 42 as input training set
train_nb = np.empty([1, 3])
for i in range(1, n + 1):
image = cv2.imread(
r'C:\Users\user\Desktop\courses\ECE 276A\ECE276A_HW1\trainset' +
'\%d' % (i) + '.png')
img = image[:, :, [2, 1, 0]]
plt.imshow(img)
my_roi = RoiPoly(color='r')
plt.show()
img_GRAY = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
mask = my_roi.get_mask(img_GRAY)
# train_b and train_nb are used separately as positive and negative samples.
# train_nb = np.concatenate((train_nb, img[mask]), axis=0)
train_b = np.concatenate((train_b, img[mask]), axis=0)
for img_name in path:
img = cv2.imread('trainset_test\\' + img_name)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_yuv = cv2.cvtColor(img, cv2.COLOR_RGB2YCR_CB)
img_hsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)
# show the image
plt.imshow(img)
roi = RoiPoly(color='r')
# Define ROI of not_barrel_blue barrel
roi_mask = roi.get_mask(img)
#plt.imshow(roi_mask)
#plt.show()
save_index = np.where(roi_mask == True)
# pick pixels according to ROI
channel1 = img[:, :, 0][save_index]
channel2 = img[:, :, 1][save_index]
channel3 = img[:, :, 2][save_index]
channel1_yuv = img_yuv[:, :, 0][save_index]
channel2_yuv = img_yuv[:, :, 1][save_index]
channel3_yuv = img_yuv[:, :, 2][save_index]
plt.show(block=False)
# Let user draw first ROI
roi1 = RoiPoly(color='g', fig=fig)
# Show the image with the first ROI
fig = plt.figure()
plt.imshow(img, interpolation='nearest')
plt.colorbar()
roi1.display_roi()
plt.title('draw first ROI')
plt.show(block=False)
# Show ROI masks
img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
mask1 = roi1.get_mask(img_gray)
plt.imshow(mask1, interpolation='nearest', cmap="Greys")
plt.title('ROI masks')
plt.show()
np.save(mask_folder + image_name[:-4] + '.npy', mask1)
barrel_rgb = img[mask1]
background_rgb = img[~mask1]
mean_rgb = barrel_rgb.mean(0) #mean rgb of barrel
mean_background = background_rgb.mean(0) #mean rgb of background
num_pixels = barrel_rgb.size #no. of barrel pixels
distance = image_name.split('.')[0].split('_')[0] #distance of barrel
row = round(np.mean(
np.nonzero(mask1)[0])) #average row indice of non-zero values in mask
col = round(np.mean(np.nonzero(
# read the first training image
folder = 'data/training'
filename = '%04i.jpg' % (i, )
img = cv2.imread(os.path.join(folder, filename))
img = cv2.cvtColor(
img, cv2.COLOR_BGR2RGB
) # images are in BGR format, need to convert to RGB
# display the image and use roipoly for labeling
fig, ax = plt.subplots()
ax.imshow(img)
my_roi = RoiPoly(fig=fig, ax=ax, color='r')
# get the image mask
mask = my_roi.get_mask(img)
# display the labeled region and the image mask
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.suptitle('%d pixels selected\n' % img[mask, :].shape[0])
ax1.imshow(img)
ax1.add_line(
plt.Line2D(my_roi.x + [my_roi.x[0]],
my_roi.y + [my_roi.y[0]],
color=my_roi.color))
ax2.imshow(mask)
plt.show(block=True)
# save roipoly labled data
# plt.show()
fig = plt.figure()
plt.imshow(img, interpolation='nearest', cmap="Greys")
plt.colorbar()
roi1.display_roi()
roi2.display_roi()
plt.title('draw third ROI')
plt.show(block=False)
roi3 = RoiPoly(color='b', fig=fig)
# Show the image with both ROIs and their mean values
# plt.imshow(img, interpolation='nearest', cmap="Greys")
# plt.colorbar()
# for roi in [roi1, roi2, roi3]:
# roi.display_roi()
# roi.display_mean(gray)
# plt.title('The two ROIs')
# plt.show()
# Show ROI masks
roi_red = roi1.get_mask(gray) + roi2.get_mask(gray)
# plt.imshow(roi_red,
# interpolation='nearest', cmap="Greys")
# plt.title('ROI masks of the two ROIs')
# plt.show()
roi_background = roi3.get_mask(gray)
if (roi_red.any()):
np.save("./fg_mask/" + img_name, roi_red)
if (roi_background.any()):
np.save("./bg_mask/" + img_name, roi_background)
# print(type(roi1.get_mask(img)))
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
import numpy as np
from matplotlib import pyplot as plt
from roipoly import RoiPoly
import matplotlib.image as mpimg
for index in range(1, 26):
# load image
img = mpimg.imread("C:/users/jiageng/Desktop/ECE276A_HW1/trainset/%s.png" %
index)
fig = plt.figure()
plt.imshow(img)
plt.show(block=False)
# draw the roi from the image
roi = RoiPoly(color='b', fig=fig)
mask_roi = roi.get_mask(img[:, :, 1])
plt.imshow(mask_roi, interpolation='nearest', cmap="Greys")
plt.show()
#store masks
np.save("C:/users/jiageng/Desktop/ECE276A_HW1/masks/%s.npy" % index,
mask_roi)
print(index)
plt.show(block=False)
# Let user draw first ROI
roi1 = RoiPoly(color='r', fig=fig)
# Show the image with the first ROI
fig = plt.figure()
plt.imshow(img, interpolation='nearest', cmap="Greys")
plt.colorbar()
roi1.display_roi()
plt.title('draw second ROI')
plt.show(block=False)
# Let user draw second ROI
roi2 = RoiPoly(color='b', fig=fig)
# Show the image with both ROIs and their mean values
plt.imshow(img, interpolation='nearest', cmap="Greys")
plt.colorbar()
for roi in [roi1, roi2]:
roi.display_roi()
roi.display_mean(img)
plt.title('The two ROIs')
plt.show()
# Show ROI masks
plt.imshow(roi1.get_mask(img) + roi2.get_mask(img),
interpolation='nearest', cmap="Greys")
plt.title('ROI masks of the two ROIs')
plt.show()
#terminal portion - jupyter notebook crashes, so this cell must be done in separate python script and then np arrays extracted back to notebook later
import cv2
import matplotlib
matplotlib.use('TkAgg')
from roipoly import RoiPoly
from matplotlib import pyplot as plt
import numpy as np
image = cv2.imread('/Users/alanacrognale/Downloads/ECE5242Proj1-train/14.png'
) #change directory file - do this for all training images
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
plt.imshow(image)
my_roi = RoiPoly(color='r')
plt.show()
mask = my_roi.get_mask(image[:, :, 0])
np.save('/Users/alanacrognale/Desktop/mask_14',
mask) #change directory file - do this for all training images
# In[2]:
#import training set labels
import numpy as np
import cv2
import matplotlib
matplotlib.use('TkAgg')
from roipoly import RoiPoly
from matplotlib import pyplot as plt
mask = np.load('/Users/alanacrognale/Desktop/mask_14.npy'
) #change directory file - do this for all training images
if __name__ == '__main__':
results = multiprocessing.Queue()
# configure below for your experiment
detectorName = 'MPCCD-8N0-3-002-6'
integrateOver = 10
t0offset = -10
fig = plt.figure()
tenFrames, curTag = returnTenFrames(detectorName,
integrateOver=integrateOver)
plt.imshow(tenFrames)
my_roi = RoiPoly(color='r', fig=fig)
plt.imshow(tenFrames)
my_roi.display_roi()
mask = my_roi.get_mask(tenFrames)
#binning parameters
roiBins = 40
startBin = -2.0
endbin = 3.0
binCounterBin = np.zeros(roiBins)
binTheData = binROI(results, detectorName, curTag, startBin, endbin, mask,
roiBins, t0offset)
binTheData.start()
binROIs = np.zeros(roiBins)
bin_nomDel = np.zeros(roiBins)
i0det = 0
beamStatus = 0
detArraysROIs = 0
img = cv2.imread(image)
# get the RGB image in order to show the original image.
RGB_image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
HSV_image = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
# show RGB image
plt.imshow(RGB_image)
#plt.imshow(HSV_image)
#plt.show()
my_roi = RoiPoly(color='r')
# create an area which has the same dimension as the original image
area = np.zeros((HSV_image.shape[0], HSV_image.shape[1]))
mask = my_roi.get_mask(area)
plt.imshow(mask)
#plt.show()
mask = np.array(mask, dtype=np.uint8)
#print(mask.shape)
area_of_interest = cv2.bitwise_and(HSV_image, HSV_image, mask=mask)
#plt.imshow(area_of_interest)
#plt.show()
#print(area_of_interest.shape)
#print pixel locations of interested area where the image is not black.
locations = np.where(area_of_interest != [0, 0, 0])
#plt.imshow(locations)
from roipoly import RoiPoly
import pandas as pd
# create array to store 3 channels labelled area
red_sign = np.load("red.npy")
red_sign = red_sign.tolist()
# red_sign =[[], [], []]
file = os.listdir('/Users/wzh13/PycharmProjects/ece2767a1/trainsetred')
for i in file:
or_image = cv2.imread('./trainsetred/' + i)
gray_image = cv2.cvtColor(or_image, cv2.COLOR_BGR2GRAY) # 2 gray space
rgb_image = cv2.cvtColor(or_image, cv2.COLOR_BGR2RGB) # 2 rgb space
ycrcb_image = cv2.cvtColor(or_image, cv2.COLOR_BGR2YCrCb)
pl.imshow(rgb_image)
my_roi = RoiPoly(color='r')
mask = my_roi.get_mask(rgb_image[:, :, 0])
pl.imshow(mask)
pl.show()
sign_position = np.where(mask)
# print(ycrcb_image.shape)
y, cr, cb = cv2.split(rgb_image)
red_sign[0].extend(y[sign_position].tolist())
red_sign[1].extend(cr[sign_position].tolist())
red_sign[2].extend(cb[sign_position].tolist())
np.save("red.npy", red_sign)
print(np.shape(red_sign))
