def img_fill(im_in, n): # n = binary image threshold
th, im_th = cv2.threshold(im_in, n, 255, cv2.THRESH_BINARY);
# Copy the thresholded image.
im_floodfill = im_th.copy()
# Mask used to flood filling.
# Notice the size needs to be 2 pixels than the image.
h, w = im_th.shape[:2]
mask = np.zeros((h + 2, w + 2), np.uint8)
# Floodfill from point (0, 0)
cv2.floodFill(im_floodfill, mask, (0, 0), 255);
# Invert floodfilled image
im_floodfill_inv = cv2.bitwise_not(im_floodfill)
# Combine the two images to get the foreground.
fill_image = im_th | im_floodfill_inv
return fill_image
python类bitwise_not()的实例源码
def color_picker(rect):
global img,img_gray2,hsv
roi=img[rect[0][1]:rect[1][1],rect[0][0]:rect[1][0]]
b,g,r,_=np.uint8(cv2.mean(roi))
color=cv2.cvtColor(np.uint8([[[b,g,r]]]),cv2.COLOR_BGR2HSV)
h= color[0][0][0]
# define range of blue color in HSV
lower = np.array([h-10,50,50])
upper = np.array([h+10,255,255])
# Threshold the HSV image to get only blue colors
mask = cv2.inRange(hsv, lower, upper)
# Bitwise-AND mask and original image
res = cv2.bitwise_and(img,img, mask= mask)
res2=cv2.bitwise_and(img_gray2,img_gray2, mask= cv2.bitwise_not(mask))
return res+res2
def select_largest_obj(self, img_bin, lab_val=255, fill_holes=False,
smooth_boundary=False, kernel_size=15):
'''Select the largest object from a binary image and optionally
fill holes inside it and smooth its boundary.
Args:
img_bin (2D array): 2D numpy array of binary image.
lab_val ([int]): integer value used for the label of the largest
object. Default is 255.
fill_holes ([boolean]): whether fill the holes inside the largest
object or not. Default is false.
smooth_boundary ([boolean]): whether smooth the boundary of the
largest object using morphological opening or not. Default
is false.
kernel_size ([int]): the size of the kernel used for morphological
operation. Default is 15.
Returns:
a binary image as a mask for the largest object.
'''
n_labels, img_labeled, lab_stats, _ = \
cv2.connectedComponentsWithStats(img_bin, connectivity=8,
ltype=cv2.CV_32S)
largest_obj_lab = np.argmax(lab_stats[1:, 4]) + 1
largest_mask = np.zeros(img_bin.shape, dtype=np.uint8)
largest_mask[img_labeled == largest_obj_lab] = lab_val
# import pdb; pdb.set_trace()
if fill_holes:
bkg_locs = np.where(img_labeled == 0)
bkg_seed = (bkg_locs[0][0], bkg_locs[1][0])
img_floodfill = largest_mask.copy()
h_, w_ = largest_mask.shape
mask_ = np.zeros((h_ + 2, w_ + 2), dtype=np.uint8)
cv2.floodFill(img_floodfill, mask_, seedPoint=bkg_seed,
newVal=lab_val)
holes_mask = cv2.bitwise_not(img_floodfill) # mask of the holes.
largest_mask = largest_mask + holes_mask
if smooth_boundary:
kernel_ = np.ones((kernel_size, kernel_size), dtype=np.uint8)
largest_mask = cv2.morphologyEx(largest_mask, cv2.MORPH_OPEN,
kernel_)
return largest_mask
def img_fill(im_in,n): # n = binary image threshold
th, im_th = cv2.threshold(im_in, n, 255, cv2.THRESH_BINARY);
# Copy the thresholded image.
im_floodfill = im_th.copy()
# Mask used to flood filling.
# Notice the size needs to be 2 pixels than the image.
h, w = im_th.shape[:2]
mask = np.zeros((h+2, w+2), np.uint8)
# Floodfill from point (0, 0)
cv2.floodFill(im_floodfill, mask, (0,0), 255);
# Invert floodfilled image
im_floodfill_inv = cv2.bitwise_not(im_floodfill)
# Combine the two images to get the foreground.
fill_image = im_th | im_floodfill_inv
return fill_image
def __init__(self, srcimg):
super(DataArgumentation, self).__init__(
)
self.src = cv2.bitwise_not(srcimg) # opencv mat 1ch ??????????
# ????
self.transition_levels = [0, 3, 5, 6, 8, 10, 12]
# ???
self.rotation_theta = [0, 0.1, 0.2, 0.3, 0.4,
0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]
def foreground(self, image, smooth=False, grayscale=False):
"""
Extract foreground from background
:param image:
:param smooth:
:param grayscale:
:return:
"""
if smooth and grayscale:
image = self.toGrayscale(image)
image = self.smooth(image)
elif smooth:
image = self.smooth(image)
elif grayscale:
image = self.toGrayscale(image)
fgmask = self.fgbg.apply(image)
ret, mask = cv2.threshold(fgmask, 200, 255, cv2.THRESH_BINARY_INV)
mask_inv = cv2.bitwise_not(mask)
return mask_inv
def overlay_img(self):
"""Overlay the transparent, transformed image of the arc onto our CV image"""
#overlay the arc on the image
rows, cols, channels = self.transformed.shape
roi = self.cv_image[0:rows, 0:cols]
#change arc_image to grayscale
arc2gray = cv2.cvtColor(self.transformed, cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(arc2gray, 10, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)
#black out area of arc in ROI
img1_bg = cv2.bitwise_and(roi, roi, mask=mask_inv)
img2_fg = cv2.bitwise_and(self.transformed, self.transformed, mask=mask)
#put arc on ROI and modify the main image
dst = cv2.add(img1_bg, img2_fg)
self.cv_image[0:rows, 0:cols] = dst
def composite(img1, img2, mask0):
if mask0.shape[2] == 3:
mask2 = cv2.cvtColor(mask0, cv2.COLOR_BGR2GRAY)
else:
mask2 = mask0[:]
mask1 = np.ones((img1.shape[0], img1.shape[1], 3), np.uint8)
mask1[..., 0] = mask2
mask1[..., 1] = mask2
mask1[..., 2] = mask2
white = np.ones((img1.shape[0], img1.shape[1], 3), np.uint8)
white[:] = (0, 0, 0)
invmask = np.zeros((img1.shape[0], img1.shape[1], 3), np.uint8)
invmask = cv2.absdiff(white, mask1)
invmask = cv2.bitwise_not(invmask)
output = np.zeros((img1.shape[0], img1.shape[1], 3), np.uint8)
cv2.subtract(img2, invmask, dst=output)
return output
def main():
# parse command line options
if len(sys.argv) != 2:
print 'Usage: python input_name output_name'
exit(1)
filePath = sys.argv[1]
print "<----- processing %s ----->" % filePath
#???????????????????????????????
img = cv2.imread(filePath, 0)
img = cv2.resize(img, (1200, 900))
# ??????
# imgArr = np.array(img)
# imgMean = np.mean(img)
# imgcopy = imgArr - imgMean
# imgcopy = imgcopy * 2 + imgMean * 3
# imgcopy = imgcopy / 255
canny = cv2.Canny(img, 60, 300)
inverted = cv2.bitwise_not(canny)
cv2.imshow('Canny', inverted)
test1 = Image.fromarray(canny)
test2 = Image.fromarray(inverted)
result = pytesseract.image_to_string(test1, lang="eng", config="-c tessedit_char_whitelist=0123456789X")
print result
print "-------"
result = pytesseract.image_to_string(test2, lang="eng")
print result
k = cv2.waitKey(0)
def fill(th, im_th):
# Copy the thresholded image.
im_floodfill = im_th.copy()
# Mask used to flood filling.
# Notice the size needs to be 2 pixels than the image.
h, w = im_th.shape[:2]
mask = np.zeros((h+2, w+2), np.uint8)
# Floodfill from point (0, 0)
cv2.floodFill(im_floodfill, mask, (0,0), 255);
# Invert floodfilled image
im_floodfill_inv = cv2.bitwise_not(im_floodfill);
# Combine the two images to get the foreground.
im_out = im_th | im_floodfill_inv
return im_out;
def find_lines(img, acc_threshold=0.25, should_erode=True):
if len(img.shape) == 3 and img.shape[2] == 3: # if it's color
img = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
img = cv2.GaussianBlur(img, (11, 11), 0)
img = cv2.adaptiveThreshold(
img,
255,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY,
5,
2)
img = cv2.bitwise_not(img)
# thresh = 127
# edges = cv2.threshold(img, thresh, 255, cv2.THRESH_BINARY)[1]
# edges = cv2.Canny(blur, 500, 500, apertureSize=3)
if should_erode:
element = cv2.getStructuringElement(cv2.MORPH_RECT, (4, 4))
img = cv2.erode(img, element)
theta = np.pi/2000
angle_threshold = 2
horizontal = cv2.HoughLines(
img,
1,
theta,
int(acc_threshold * img.shape[1]),
min_theta=np.radians(90 - angle_threshold),
max_theta=np.radians(90 + angle_threshold))
vertical = cv2.HoughLines(
img,
1,
theta,
int(acc_threshold * img.shape[0]),
min_theta=np.radians(-angle_threshold),
max_theta=np.radians(angle_threshold),
)
horizontal = list(horizontal) if horizontal is not None else []
vertical = list(vertical) if vertical is not None else []
horizontal = [line[0] for line in horizontal]
vertical = [line[0] for line in vertical]
horizontal = np.asarray(horizontal)
vertical = np.asarray(vertical)
return horizontal, vertical
def repaint_skin(filename):
import cv2
shutil.copy(filename, filename + '.bak')
frame = cv2.imread(filename)
HSV = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
l = np.array([0, 50, 80], dtype = "uint8")
u = np.array([23, 255, 255], dtype = "uint8")
skin_area = cv2.inRange(HSV, l, u)
not_skin_area = cv2.bitwise_not(frame, frame, mask = skin_area)
cv2.imwrite(filename, not_skin_area)
def animpingpong(self):
obj=self.Object
res=None
for t in obj.OutList:
print t.Label
img=t.ViewObject.Proxy.img.copy()
if res==None:
res=img.copy()
else:
#rr=cv2.subtract(res,img)
#rr=cv2.add(res,img)
aw=0.0+float(obj.aWeight)/100
bw=0.0+float(obj.bWeight)/100
print aw
print bw
if obj.aInverse:
# b umsetzen
ret, mask = cv2.threshold(img, 50, 255, cv2.THRESH_BINARY)
img=cv2.bitwise_not(mask)
rr=cv2.addWeighted(res,aw,img,bw,0)
res=rr
#b,g,r = cv2.split(res)
cv2.imshow(obj.Label,res)
#cv2.imshow(obj.Label +" b",b)
#cv2.imshow(obj.Label + " g",g)
#cv2.imshow(obj.Label + " r",r)
res=img
if not obj.matplotlib:
cv2.imshow(obj.Label,img)
else:
from matplotlib import pyplot as plt
# plt.subplot(121),
plt.imshow(img,cmap = 'gray')
plt.title(obj.Label), plt.xticks([]), plt.yticks([])
plt.show()
self.img=img
def maskLogoOverImage(self):
# Load two images
img1 = cv2.imread('messi5.jpg')
img2 = cv2.imread('opencv_logo.png')
# I want to put logo on top-left corner, So I create a ROI
rows,cols,channels = img2.shape
roi = img1[0:rows, 0:cols ]
# Now create a mask of logo and create its inverse mask also
img2gray = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(img2gray, 10, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)
# Now black-out the area of logo in ROI
img1_bg = cv2.bitwise_and(roi,roi,mask = mask_inv)
# Take only region of logo from logo image.
img2_fg = cv2.bitwise_and(img2,img2,mask = mask)
# Put logo in ROI and modify the main image
dst = cv2.add(img1_bg,img2_fg)
img1[0:rows, 0:cols ] = dst
cv2.imshow('res',img1)
cv2.waitKey(0)
cv2.destroyAllWindows()
#####################################################################################################################
# Prototypes & Convenient CLI/GUI Dispatcher to rebuild mental picture of where we are/repeat on new platforms.
#####################################################################################################################
def grab_cut_mask(img_col, mask, debug=False):
assert isinstance(img_col, numpy.ndarray), 'image must be a numpy array'
assert isinstance(mask, numpy.ndarray), 'mask must be a numpy array'
assert img_col.ndim == 3, 'skin detection can only work on color images'
assert mask.ndim == 2, 'mask must be 2D'
kernel = numpy.ones((50, 50), numpy.float32) / (50 * 50)
dst = cv2.filter2D(mask, -1, kernel)
dst[dst != 0] = 255
free = numpy.array(cv2.bitwise_not(dst), dtype=numpy.uint8)
if debug:
scripts.display('not skin', free)
scripts.display('grabcut input', mask)
grab_mask = numpy.zeros(mask.shape, dtype=numpy.uint8)
grab_mask[:, :] = 2
grab_mask[mask == 255] = 1
grab_mask[free == 255] = 0
if numpy.unique(grab_mask).tolist() == [0, 1]:
logger.debug('conducting grabcut')
bgdModel = numpy.zeros((1, 65), numpy.float64)
fgdModel = numpy.zeros((1, 65), numpy.float64)
if img_col.size != 0:
mask, bgdModel, fgdModel = cv2.grabCut(img_col, grab_mask, None, bgdModel, fgdModel, 5,
cv2.GC_INIT_WITH_MASK)
mask = numpy.where((mask == 2) | (mask == 0), 0, 1).astype(numpy.uint8)
else:
logger.warning('img_col is empty')
return mask
def convert_to_linedrawing(self, luminous_image_data):
kernel = numpy.ones((3, 3), numpy.uint8)
linedrawing = cv2.Canny(luminous_image_data, 5, 125)
linedrawing = cv2.bitwise_not(linedrawing)
linedrawing = cv2.erode(linedrawing, kernel, iterations=1)
linedrawing = cv2.dilate(linedrawing, kernel, iterations=1)
return linedrawing
def convert_to_linedrawing(self, luminous_image_data):
neiborhood24 = numpy.array([[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]],
numpy.uint8)
dilated = cv2.dilate(luminous_image_data, neiborhood24, iterations=1)
diff = cv2.absdiff(dilated, luminous_image_data)
linedrawing = cv2.bitwise_not(diff)
return linedrawing
def extract_bv(image):
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
contrast_enhanced_green_fundus = clahe.apply(image)
# applying alternate sequential filtering (3 times closing opening)
r1 = cv2.morphologyEx(contrast_enhanced_green_fundus, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
R1 = cv2.morphologyEx(r1, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
r2 = cv2.morphologyEx(R1, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
R2 = cv2.morphologyEx(r2, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
r3 = cv2.morphologyEx(R2, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
R3 = cv2.morphologyEx(r3, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
f4 = cv2.subtract(R3,contrast_enhanced_green_fundus)
f5 = clahe.apply(f4)
# removing very small contours through area parameter noise removal
ret,f6 = cv2.threshold(f5,15,255,cv2.THRESH_BINARY)
mask = np.ones(f5.shape[:2], dtype="uint8") * 255
im2, contours, hierarchy = cv2.findContours(f6.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
if cv2.contourArea(cnt) <= 200:
cv2.drawContours(mask, [cnt], -1, 0, -1)
im = cv2.bitwise_and(f5, f5, mask=mask)
ret,fin = cv2.threshold(im,15,255,cv2.THRESH_BINARY_INV)
newfin = cv2.erode(fin, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
# removing blobs of microaneurysm & unwanted bigger chunks taking in consideration they are not straight lines like blood
# vessels and also in an interval of area
fundus_eroded = cv2.bitwise_not(newfin)
xmask = np.ones(image.shape[:2], dtype="uint8") * 255
x1, xcontours, xhierarchy = cv2.findContours(fundus_eroded.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in xcontours:
shape = "unidentified"
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.04 * peri, False)
if len(approx) > 4 and cv2.contourArea(cnt) <= 3000 and cv2.contourArea(cnt) >= 100:
shape = "circle"
else:
shape = "veins"
if(shape=="circle"):
cv2.drawContours(xmask, [cnt], -1, 0, -1)
finimage = cv2.bitwise_and(fundus_eroded,fundus_eroded,mask=xmask)
blood_vessels = cv2.bitwise_not(finimage)
dilated = cv2.erode(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(7,7)), iterations=1)
#dilated1 = cv2.dilate(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
blood_vessels_1 = cv2.bitwise_not(dilated)
return blood_vessels_1
def extract_bv(image):
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
contrast_enhanced_green_fundus = clahe.apply(image)
# applying alternate sequential filtering (3 times closing opening)
r1 = cv2.morphologyEx(contrast_enhanced_green_fundus, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
R1 = cv2.morphologyEx(r1, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5)), iterations = 1)
r2 = cv2.morphologyEx(R1, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
R2 = cv2.morphologyEx(r2, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(11,11)), iterations = 1)
r3 = cv2.morphologyEx(R2, cv2.MORPH_OPEN, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
R3 = cv2.morphologyEx(r3, cv2.MORPH_CLOSE, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(23,23)), iterations = 1)
f4 = cv2.subtract(R3,contrast_enhanced_green_fundus)
f5 = clahe.apply(f4)
# removing very small contours through area parameter noise removal
ret,f6 = cv2.threshold(f5,15,255,cv2.THRESH_BINARY)
mask = np.ones(f5.shape[:2], dtype="uint8") * 255
im2, contours, hierarchy = cv2.findContours(f6.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in contours:
if cv2.contourArea(cnt) <= 200:
cv2.drawContours(mask, [cnt], -1, 0, -1)
im = cv2.bitwise_and(f5, f5, mask=mask)
ret,fin = cv2.threshold(im,15,255,cv2.THRESH_BINARY_INV)
newfin = cv2.erode(fin, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
# removing blobs of microaneurysm & unwanted bigger chunks taking in consideration they are not straight lines like blood
# vessels and also in an interval of area
fundus_eroded = cv2.bitwise_not(newfin)
xmask = np.ones(image.shape[:2], dtype="uint8") * 255
x1, xcontours, xhierarchy = cv2.findContours(fundus_eroded.copy(),cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
for cnt in xcontours:
shape = "unidentified"
peri = cv2.arcLength(cnt, True)
approx = cv2.approxPolyDP(cnt, 0.04 * peri, False)
if len(approx) > 4 and cv2.contourArea(cnt) <= 3000 and cv2.contourArea(cnt) >= 100:
shape = "circle"
else:
shape = "veins"
if(shape=="circle"):
cv2.drawContours(xmask, [cnt], -1, 0, -1)
finimage = cv2.bitwise_and(fundus_eroded,fundus_eroded,mask=xmask)
blood_vessels = cv2.bitwise_not(finimage)
dilated = cv2.erode(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(7,7)), iterations=1)
#dilated1 = cv2.dilate(blood_vessels, cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(3,3)), iterations=1)
blood_vessels_1 = cv2.bitwise_not(dilated)
return blood_vessels_1
def _filter_image(self, image):
_, thresh = cv2.threshold(image, 200, 255, cv2.THRESH_BINARY)
opened = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, (5, 5), iterations=3)
return cv2.bitwise_not(opened)
def find_contours(img):
img1 = cv2.bitwise_not(img)
imgray = cv2.cvtColor(img1 ,cv2.COLOR_BGR2GRAY)
ret, thresh = cv2.threshold(imgray,127,255,0)
contours, hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
img_cont = img1.copy()
cv2.drawContours(img_cont, contours, -1, (255,255,255), -1)
return img_cont
def __add_figure_to_frame(self, frame, figure_location):
"""This function is used to add a file from hard disk to the figure
Algorithm source: http://docs.opencv.org/trunk/d0/d86/tutorial_py_image_arithmetics.html
"""
# Get size of frame
height, width, channels = frame.shape
# Only add icon when the frame is big enough
if height >= 100 and width >= 100:
# Load heart icon
icon_heart = cv2.imread(figure_location)
# Convert to RGB
icon_heart = cv2.cvtColor(icon_heart, cv2.COLOR_BGR2RGB)
# Create ROI
rows, cols, channels = icon_heart.shape
roi = frame[:rows, :cols, :]
# Convert heart to greyscale
icon_heart_gray = cv2.cvtColor(icon_heart, cv2.COLOR_RGB2GRAY)
# Create mask and inverse mask with binary threshold
ret, mask = cv2.threshold(icon_heart_gray, 10, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)
# Background: Original frame with inverse mask
frame_bg = cv2.bitwise_and(roi, roi, mask=mask_inv)
# Foreground: Heart with normal mask
icon_heart_fg = cv2.bitwise_and(icon_heart, icon_heart, mask=mask)
# Add heart icon to frame
icon_heart_final = cv2.add(frame_bg, icon_heart_fg)
frame[:rows, :cols, :] = icon_heart_final
return frame
# Setter and getter following
def outlining(img):
#kernel size
kernel_size=3
#-------------------------------------------------
#bilateral filter, sharpen, thresh image
biblur=cv2.bilateralFilter(img,20,175,175)
sharp=cv2.addWeighted(img,1.55,biblur,-0.5,0)
ret1,thresh1 = cv2.threshold(sharp,127,255,cv2.THRESH_OTSU)
#negative and closed image
inv=cv2.bitwise_not(thresh1)
kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (kernel_size, kernel_size))
closed = cv2.morphologyEx(inv, cv2.MORPH_CLOSE, kernel)
return closed
categorical_crossentropy_example.py 文件源码
项目：keras-semantic-segmentation-example
作者: mrgloom
项目源码
文件源码
阅读 30
收藏 0
点赞 0
评论 0
def gen_random_image():
img = np.zeros((IMAGE_H, IMAGE_W, INPUT_CHANNELS), dtype=np.uint8)
mask = np.zeros((IMAGE_H, IMAGE_W, NUMBER_OF_CLASSES), dtype=np.uint8)
mask_obj1 = np.zeros((IMAGE_H, IMAGE_W, 1), dtype=np.uint8)
colors = np.random.permutation(256)
# Background
img[:, :, 0] = colors[0]
img[:, :, 1] = colors[1]
img[:, :, 2] = colors[2]
# Object class 1
obj1_color0 = colors[3]
obj1_color1 = colors[4]
obj1_color2 = colors[5]
while(True):
center_x = rn.randint(0, IMAGE_W)
center_y = rn.randint(0, IMAGE_H)
r_x = rn.randint(10, 50)
r_y = rn.randint(10, 50)
if(center_x+r_x < IMAGE_W and center_x-r_x > 0 and center_y+r_y < IMAGE_H and center_y-r_y > 0):
cv2.ellipse(img, (int(center_x), int(center_y)), (int(r_x), int(r_y)), int(0), int(0), int(360), (int(obj1_color0), int(obj1_color1), int(obj1_color2)), int(-1))
cv2.ellipse(mask_obj1, (int(center_x), int(center_y)), (int(r_x), int(r_y)), int(0), int(0), int(360), int(255), int(-1))
break
mask[:,:,0] = np.squeeze(mask_obj1)
mask[:,:,1] = np.squeeze(cv2.bitwise_not(mask_obj1))
# White noise
density = rn.uniform(0, 0.1)
for i in range(IMAGE_H):
for j in range(IMAGE_W):
if rn.random() < density:
img[i, j, 0] = rn.randint(0, 255)
img[i, j, 1] = rn.randint(0, 255)
img[i, j, 2] = rn.randint(0, 255)
return img, mask
def find_samples_bounding_rect(path):
min_w = 0
min_h = 0
print ('finding bounding box:')
bar = progressbar.ProgressBar(maxval=num_classes*num_samples,
widgets=[
' [', progressbar.Timer(), '] ',
progressbar.Bar(),
' (', progressbar.ETA(), ') ',
])
bar.start()
counter = 0
for i in range(1, num_classes + 1):
for j in range(1, num_samples + 1):
filename = '{0}/Sample{1:03d}/img{1:03d}-{2:03d}.png'.format(path, i, j)
# opencv read -> Gray Image -> Bounding Rect
im = cv2.imread(filename)
imgray = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
imgray = cv2.bitwise_not(imgray)
_, contours, _ = cv2.findContours(imgray, cv2.RETR_LIST,cv2.CHAIN_APPROX_SIMPLE)
_, _, w, h = cv2.boundingRect(contours[len(contours) - 1])
# find maximum resolution
min_w = max(min_w, w)
min_h = max(min_h, h)
# update progress bar
counter = counter + 1
bar.update(counter)
bar.finish()
return min_w, min_h
def find_digits(binary_img):
inv = cv2.bitwise_not(binary_img)
contours, hierarchy = cv2.findContours(inv,
cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1)
digits = []
for cnt in contours:
area = cv2.contourArea(cnt)
if area > 500:
[x, y, w, h] = cv2.boundingRect(cnt)
margin = 20
x -= margin
y -= margin
w += margin*2
h += margin*2
figure = binary_img[y: y + h, x: x + w]
if figure.size > 0:
digits.append({
'image': figure,
'x': x,
'y': y,
'w': w,
'h': h,
})
return digits
def resize_digits(digits):
digits = map(itemgetter('image'), sorted(digits, key=itemgetter('x')))
blur_kernel = np.ones((4, 4), np.float32)/(4*4)
erode_kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
return [
cv2.resize(
cv2.bitwise_not(
cv2.filter2D(
cv2.erode(digit, erode_kernel, iterations=1),
-1, blur_kernel)
),
(20, 20))
for digit in digits]
def overlayimg(back, fore, x, y, w, h):
# Load two images
img1 = np.array(back)
img2 = np.array(fore)
# create new dimensions
r = float((h)) / img2.shape[1]
dim = ((w), int(img2.shape[1] * r))
# Now create a mask of box and create its inverse mask also
img2gray = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(img2gray, 10, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)
# resize box and masks
resized_img2 = cv2.resize(img2, dim, interpolation=cv2.INTER_AREA)
resized_mask = cv2.resize(mask, dim, interpolation=cv2.INTER_AREA)
resized_mask_inv = cv2.resize(mask_inv, dim, interpolation=cv2.INTER_AREA)
# I want to put box in co-ordinates, So I create a ROI
rows, cols, channels = resized_img2.shape
roi = img1[y:y+rows, x:x+cols]
# Now black-out the area of box in ROI
img1_bg = cv2.bitwise_and(roi, roi, mask=resized_mask_inv)
# Take only region of box from box image.
img2_fg = cv2.bitwise_and(resized_img2, resized_img2, mask=resized_mask)
# Put box in ROI and modify the main image
dst = cv2.add(img1_bg, img2_fg)
img1[y:y+rows, x:x+cols] = dst
return img1
def bit_not(self, frame):
self._ndarray = cv2.bitwise_not(self.ndarray, frame.ndarray)
self._contours = None
# XOR this frame with another frame
def generate_bg(root_dir):
cv2.namedWindow("frame")
cv2.namedWindow("foregrond mask")
cv2.namedWindow("groundtruth")
cv2.namedWindow("background model")
for __, dirnames_l0, __ in walklevel(root_dir, level = 0):
for dirname_l0 in dirnames_l0:
if not os.path.exists(root_dir + "/" + dirname_l0 + "/done") or os.path.isfile(root_dir + "/" + dirname_l0 + "/done"):
print ("start dealing with " + dirname_l0)
if not os.path.exists(root_dir + "/" + dirname_l0 + "/bg") or os.path.isfile(root_dir + "/" + dirname_l0 + "/bg"):
os.makedirs(root_dir + "/" + dirname_l0 + "/bg")
num = 1
bgs = libbgs.SuBSENSE()
F = open(root_dir + "/" + dirname_l0 + "/temporalROI.txt", 'r')
line = F.read().split(' ')
begin = int(line[0]); end = int(line[1])
ROI_mask = cv2.imread(root_dir + "/" + dirname_l0 + "/ROI.bmp")
while True:
frame_filename = root_dir + "/" + dirname_l0 + "/input/" + num2filename(num, "in") + ".jpg"
gt_filename = root_dir + "/" + dirname_l0 + "/groundtruth/" + num2filename(num, "gt") + ".png"
if not os.path.isfile(frame_filename):
num = num + 1
continue
frame = cv2.imread(frame_filename)
gt = cv2.imread(gt_filename)
check = (frame[:,:,0] == frame[:,:,1])
if check.all():
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
fg = cv2.bitwise_and(bgs.apply(frame), ROI_mask[:,:,0])
bg_model = bgs.getBackgroundModel()
addition = 83*np.ones(fg.shape, dtype=np.uint8)
fg_mask = cv2.add(fg, addition, mask=cv2.bitwise_not(ROI_mask[:,:,0]))
fg_mask = cv2.add(fg_mask, fg)
cv2.rectangle(frame, (10, 2), (100,20), (255,255,255), -1)
cv2.putText(frame, str(num), (15, 15), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0,0,0))
cv2.imshow("frame", frame)
cv2.imshow("foregrond mask", fg_mask)
cv2.imshow("groundtruth", gt)
cv2.imshow("background model", bg_model)
if (num >= begin) & (num <= end):
bg_filename = root_dir + "/" + dirname_l0 + "/bg/" + num2filename(num, "bg") + ".jpg"
cv2.imwrite(bg_filename, bg_model)
num = num + 1
if num > end:
print ("finish with " + dirname_l0)
break
cv2.waitKey(20)
os.makedirs(root_dir + "/" + dirname_l0 + "/done")
