def image_transformation(file):
# open image and apply filter
img = cv2.imdecode(numpy.frombuffer(file, numpy.uint8),
cv2.IMREAD_UNCHANGED)
img = cv2.resize(img, None, fx=1.2, fy=1.2, interpolation=cv2.INTER_CUBIC)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
kernel = numpy.ones((1, 1), numpy.uint8)
img = cv2.dilate(img, kernel, iterations=1)
img = cv2.erode(img, kernel, iterations=1)
img = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
# get coordinates
coords = numpy.column_stack(numpy.where(img > 0))
angle = cv2.minAreaRect(coords)[-1]
# the `cv2.minAreaRect` function returns values in the
# range [-90, 0); as the rectangle rotates clockwise the
# returned angle trends to 0 -- in this special case we
# need to add 90 degrees to the angle
if angle < -45:
angle = -(90 + angle)
# otherwise, just take the inverse of the angle to make
# it positive
else:
angle = -angle
(h, w) = img.shape[:2]
center = (w // 2, h // 2)
m = cv2.getRotationMatrix2D(center, angle, 1.0)
rotated = cv2.warpAffine(img,
m, (w, h),
flags=cv2.INTER_CUBIC,
borderMode=cv2.BORDER_REPLICATE)
img = rotated
ret, thresh_binary = cv2.threshold(img, 127, 255, cv2.THRESH_BINARY)
value_thresh_binary = cv2.Laplacian(thresh_binary, cv2.CV_64F).var()
blur = cv2.GaussianBlur(img, (5, 5), 0)
# blur = gaussian_blur(img, 5)
# img = otsu(blur)
ret3, thresh_otsu = cv2.threshold(blur, 0, 255,
cv2.THRESH_BINARY + cv2.THRESH_OTSU)
value_otsu = cv2.Laplacian(thresh_otsu, cv2.CV_64F).var()
if value_thresh_binary > value_otsu:
print(value_thresh_binary)
img = thresh_binary
else:
print(value_otsu)
img = thresh_otsu
return img
def edgeDetectionZeroCrossingSimple(I: np.ndarray) -> (np.ndarray, np.ndarray):
src_gray = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
lap = cv2.Laplacian(src_gray, cv2.CV_16S, ksize=7)
# TO DO :
# Look for patterns like {+, 0, -} or {+, -} (zerocrossing) not sure what to do
return lap
def laplaceDetection(self):
try:
img = cv2.imread(self.filename)
laplacian = cv2.Laplacian(img, cv2.CV_64F)
cv2.imwrite('img/dist/laplace.jpg', laplacian,
[cv2.IMWRITE_JPEG_QUALITY, 100])
cv2.waitKey()
except:
pass
def laplacian(m, n, thres, l, sigma, mean, p, img, hist_range):
lap = cv2.Laplacian(img, cv2.CV_64F)
lap = np.int64(lap)
sum1 = 0
for i in range(1, m - 1):
for j in range(1, n - 1):
sum1 = sum1 + lap[i][j]**2
return sum1
def CovertLaplacian(self):
img = cv2.imread(
os.path.join(root, '..', 'static', 'photos',
session['img_name_org_edge']))
laplacian = cv2.Laplacian(img, cv2.CV_64F)
filename = str(randint(1000000000,
9999999999)) + session['img_name_org_edge']
cv2.imwrite(os.path.join(root, '..', 'static', 'photos', filename),
laplacian)
session['img_name_covert_edge'] = filename
session['covert_title_edge'] = "Detection By Laplacian"
def laplace(img: np.ndarray) -> np.ndarray:
"""
laplace filter
Args:
img: image as numpy array
Returns:
img
"""
return cv2.Laplacian(img, cv2.CV_64F)
def zeroCross():
image = imageInit
image = grayScale()
LoG = cv2.Laplacian(image, cv2.CV_16S)
minLoG = cv2.morphologyEx(LoG, cv2.MORPH_ERODE, np.ones((2, 2)))
maxLoG = cv2.morphologyEx(LoG, cv2.MORPH_DILATE, np.ones((2, 2)))
edged = (np.logical_or(np.logical_and(minLoG < 0, LoG > 0),
np.logical_and(maxLoG > 0, LoG < 0)) *
255).astype('uint8')
show_img(ImageTk.PhotoImage(Img.fromarray(edged)))
def edgeDetectionZeroCrossingLOG(I: np.ndarray) -> (np.ndarray, np.ndarray):
# smooth with gaussian
I = blurImage2(I, 9)
# turn to GrayScale and activate laplace filter
src_gray = cv2.cvtColor(I, cv2.COLOR_BGR2GRAY)
lap = cv2.Laplacian(src_gray, cv2.CV_16S, ksize=7)
# show the img
# activate abs only if you want to show the picture
# make sure you find the edge points before using abs
lap = cv2.convertScaleAbs(lap)
return lap
def __apply(self, grayed, index, p):
coordinates = self._coordinates(p)
rect = self.bounds[index]
roi_gray = grayed[rect[1]:(rect[1] + rect[3]),
rect[0]:(rect[0] + rect[2])]
laplacian = open_cv.Laplacian(roi_gray, open_cv.CV_64F)
coordinates[:, 0] = coordinates[:, 0] - rect[0]
coordinates[:, 1] = coordinates[:, 1] - rect[1]
status = np.mean(np.abs(
laplacian * self.mask[index])) < MotionDetector.LAPLACIAN
return status
def variance_of_laplacian(image):
"""Assessment of bluriness of an image. Bigger value - lower bluriness.
Idea taken from https://www.pyimagesearch.com/2015/09/07/blur-detection-with-opencv/
and modified. I found it emperically that (max-min)**2/var is working better than simple variance
as an assessment of bluriness.
Args:
image
Returns:
assessment of bluriness
"""
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
conv2d = cv2.Laplacian(gray_image, cv2.CV_64F)
return int((conv2d.max() - conv2d.min())**2 / (2 * conv2d.var()))
def grad(img):
laplacian = cv2.Laplacian(img, cv2.CV_64F)
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=3)
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=3)
plt.subplot(2, 2, 1), plt.imshow(img, cmap='gray')
plt.title('orignal'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 2), plt.imshow(laplacian, cmap='gray')
plt.title('Laplacian'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 3), plt.imshow(sobelx, cmap='gray')
plt.title('sobel X'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 4), plt.imshow(sobely, cmap='gray')
plt.title('sobel Y'), plt.xticks([]), plt.yticks([])
plt.show()
def edge_detection():
img = cv2.imread('2.jpg', cv2.IMREAD_GRAYSCALE)
lap = cv2.Laplacian(img, cv2.CV_64F, ksize=3)
lap = np.uint8(np.absolute(lap))
sobelX = cv2.Sobel(img, cv2.CV_64F, 1, 0)
sobelY = cv2.Sobel(img, cv2.CV_64F, 0, 1)
sobelX = np.uint8(np.absolute(sobelX))
sobelY = np.uint8(np.absolute(sobelY))
sobelCombined = cv2.bitwise_or(sobelX, sobelY)
titles = ['image', 'Laplacian', 'sobelX', 'sobelY', 'sobelCombined']
images = [img, lap, sobelX, sobelY, sobelCombined]
for i in range(5):
plt.subplot(2, 3, i + 1), plt.imshow(images[i], 'gray')
plt.title(titles[i])
plt.xticks([]), plt.yticks([])
plt.show()
def grad():
img = cv2.imread(selImg.select_img(6), cv2.IMREAD_GRAYSCALE)
#img = cv2.imread(select_img('2'), cv2.IMREAD_GRAYSCALE)
laplacian = cv2.Laplacian(img, cv2.CV_64F)
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize = 3)
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize = 3)
plt.subplot(2, 2, 1), plt.imshow(img, cmap = 'gray')
plt.title('orignal'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 2), plt.imshow(laplacian, cmap = 'gray')
plt.title('Laplacian'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 3), plt.imshow(sobelx, cmap = 'gray')
plt.title('sobel X'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 4), plt.imshow(sobely, cmap = 'gray')
plt.title('sobel Y'), plt.xticks([]), plt.yticks([])
plt.show()
def fourierDesciptor(self, res):
"""计算傅里叶描述子
:param res: 输入图片
:return: 图像，描述子点
"""
# Laplacian算子进行八邻域检测
gray = cv2.cvtColor(res, cv2.COLOR_BGR2GRAY)
dst = cv2.Laplacian(gray, cv2.CV_16S, ksize=3)
Laplacian = cv2.convertScaleAbs(dst)
contour = self.find_contours(Laplacian) # 提取轮廓点坐标
contour_array = contour[0][:, 0, :] # 注意这里只保留区域面积最大的轮廓点坐标
contours_complex = np.empty(contour_array.shape[:-1], dtype=complex)
contours_complex.real = contour_array[:, 0] # 横坐标作为实数部分
contours_complex.imag = contour_array[:, 1] # 纵坐标作为虚数部分
fourier_result = np.fft.fft(contours_complex) # 进行傅里叶变换
#fourier_result = np.fft.fftshift(fourier_result)
descirptor_in_use = self.truncate_descriptor(
fourier_result) # 截短傅里叶描述子
img1 = res.copy()
self.reconstruct(res, descirptor_in_use) # 绘图显示描述子点
self.draw_circle(img1, descirptor_in_use) # 相关关定位框架
return res, descirptor_in_use
def main():
drone = tellopy.Tello()
os.makedirs('raw_data', exist_ok=True) #生データの保存するディレクトリの作成
os.makedirs('take_picture', exist_ok=True) #撮影時のディレクトリ
os.makedirs('process_picture', exist_ok=True) #撮影時の加工画像を入れるディレクトリ
SCREEN_WIDTH = 640
SCREEN_HEIGHT = 480
pygame.joystick.init()
try:
joy = pygame.joystick.Joystick(0) # create a joystick instance
joy.init() # init instance
print('Joystickの名称: ' + joy.get_name())
print('ボタン数 : ' + str(joy.get_numbuttons()))
pygame.init()
screen = pygame.display.set_mode(
(SCREEN_WIDTH, SCREEN_HEIGHT)) # 画面を作る
pygame.display.set_caption('Joystick') # タイトル
pygame.display.flip() # 画面を反映
except pygame.error:
print('Joystickが見つかりませんでした。')
try:
drone.connect()
drone.wait_for_connection(20.0)
retry = 3
container = None
while container is None and 0 < retry:
retry -= 1
try:
container = av.open(drone.get_video_stream())
except av.AVError as ave:
print(ave)
print('retry...')
fly_sw = False #takeoffとlandの切り替え
scale = 4 #適時変更
# skip first 300 frames
frame_skip = 300
raw_count = 0 #rawfile_no
picture_count = 0 #picturefile_no
while True:
for frame in container.decode(video=0):
if 0 < frame_skip:
frame_skip = frame_skip - 1
continue
start_time = time.time()
image = cv2.cvtColor(numpy.array(frame.to_image()),
cv2.COLOR_RGB2BGR)
cv2.imshow('Original', image)
cv2.waitKey(1)
if frame.time_base < 1.0 / 60:
time_base = 1.0 / 60
else:
time_base = frame.time_base
frame_skip = int((time.time() - start_time) / time_base)
dir_write('raw_data', 'frame_{:04d}.png'.format(raw_count),
image)
raw_count += 1
for e in pygame.event.get(): # イベントチェック
if e.type == QUIT: # 終了が押された？
drone.quit()
return
if e.type == KEYDOWN and e.key == K_ESCAPE: # ESCが押された？
drone.quit()
return
# Joystick関連のイベントチェック
if e.type == pygame.locals.JOYAXISMOTION:
x1, y1 = joy.get_axis(0), joy.get_axis(
1) #左スティックのx,yに値の格納
x2, y2 = joy.get_axis(4), joy.get_axis(
3) #右スティックのx,yに値の格納
#print('x and y : ' + str(x) +' , '+ str(y))
drone.left_x = -x1
drone.left_y = -y1
drone.right_x = x2 / scale
drone.right_y = -y2 / scale
elif e.type == pygame.locals.JOYBALLMOTION:
print('ball motion')
elif e.type == pygame.locals.JOYHATMOTION:
print('hat motion')
elif e.type == pygame.locals.JOYBUTTONDOWN:
print(str(e.button) + '番目のボタンが押された')
if int(e.button) == 7 and fly_sw == False: #start
drone.takeoff()
fly_sw = True
elif int(e.button) == 7 and fly_sw == True: #start
drone.land()
drone.quit()
cv2.destroyAllWindows()
filepath = os.path.join('raw_data')
files = os.listdir(filepath)
raw_count = 0
for file in files:
index = re.search('.png', file)
if index:
raw_count += 1
print(raw_count)
#ビデオとして結合
fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v')
video = cv2.VideoWriter('replay.mp4', fourcc, 20.0,
(640, 480))
for i in range(0, raw_count):
filepath = os.path.join(
'raw_data', 'frame_{:04d}.png'.format(i))
img = cv2.imread(filepath)
img = cv2.resize(img, (640, 480))
video.write(img)
video.release()
for i in range(0, picture_count):
filepath = os.path.join(
'take_picture',
'picture_{:04d}.png'.format(i))
img = cv2.imread(filepath)
print(cv2.Laplacian(
img, cv2.CV_64F).var()) #ラプラシアン微分
pixel = pic.pixelArt(img)
dir_write('process_picture',
'dot_{:04d}.png'.format(i), pixel)
water = pic.waterColor(img)
dir_write('process_picture',
'water_{:04d}.png'.format(i), water)
oil = pic.oilPaint(img)
dir_write('process_picture',
'oil_{:04d}.png'.format(i), oil)
fly_sw = False
if int(e.button) == 3: #Y
dir_write(
'take_picture',
'picture_{:04d}.png'.format(picture_count),
image)
picture_count += 1
elif e.type == pygame.locals.JOYBUTTONUP:
print(str(e.button) + '番目のボタンが離された')
except Exception as ex:
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback.print_exception(exc_type, exc_value, exc_traceback)
print(ex)
finally:
drone.quit()
cv2.destroyAllWindows()
def accumulate_contours(self, labels, scale=4): # noqa: C901
label_list = {}
for label_obj in labels:
files = eval(label_obj['files'])[0]
path = label_obj['path']
dcm = pydicom.dcmread(os.path.join(path, files),
stop_before_pixels=True)
label = label_obj['data']
lv_label = remove_small_3d(label, 2)
series_uid = label_obj['series']
study_uid = label_obj['study']
print(f"load dcm:{os.path.join(path, files)}")
label_list[series_uid] = {
"SeriesDescription": label_obj['description'],
"ImageOrientationPatient": dcm.ImageOrientationPatient,
"ImagePositionPatient": dcm.ImagePositionPatient,
"PixelSpacing": dcm.PixelSpacing,
"label": lv_label
}
if "SpacingBetweenSlices" in dcm:
SpacingDistance = dcm.SpacingBetweenSlices
print(
f"desc:{dcm.SeriesDescription}, position:{dcm.ImagePositionPatient}, orientation:{dcm.ImageOrientationPatient}, study uid:{study_uid}, series uid:{series_uid}"
)
contours_list = []
for i in range(lv_label.shape[-1]):
label_edge = lv_label[:, :, i]
if len(np.unique(label_edge)) > 1:
label_edge = (label_edge * 255).astype(np.uint8)
# cv2.imwrite(f"/dresden/users/qc58/work/ATMI/output/2/demo/{item}-{i}-orig.jpg", label_edge)
label_edge = cv2.Laplacian(label_edge, cv2.CV_8U)
# cv2.imwrite(f"/dresden/users/qc58/work/ATMI/output/2/demo/{item}-{i}-edge.jpg", label_edge)
# label_edge = cv2.Canny(label_edge, 30, 200)
contours, hierarchy = cv2.findContours(
label_edge, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
sorted(contours, key=len)
if scale > 1:
contours = [c_i / scale for c_i in contours]
if len(contours) > 0:
if contours[-1].shape[0] > 30:
append_list = [{
"data": contours[-1],
"desc": dcm.SeriesDescription
}]
if "SAX" in dcm.SeriesDescription and len(
contours
) > 1 and contours[-2].shape[0] > 30:
# print(f"SAX, and include the contour.")
if len(contours) > 2:
append_list.append({
"data":
contours[-3],
"desc":
"INNER_" + dcm.SeriesDescription
})
# append_list.append(contours[-2])
contours_list.append(append_list)
else:
contours_list.append([])
label_list[series_uid]['contours'] = contours_list
for serie in label_list:
label_list[serie]['SliceDistance'] = SpacingDistance
return label_list
from cv2 import cv2 as cv
import numpy as np
img = cv.imread('Photos/cat.jpg')
cv.imshow('Cat', img)
gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
cv.imshow('Gray', gray)
# Laplacian
lap = cv.Laplacian(gray, cv.CV_64F)
lap = np.uint8(np.absolute(lap))
cv.imshow('Laplacian', lap)
# Sobel
sobelx = cv.Sobel(gray, cv.CV_64F, 1, 0)
sobely = cv.Sobel(gray, cv.CV_64F, 0, 1)
combined_sobel = cv.bitwise_or(sobelx, sobely)
cv.imshow('Sobel X', sobelx)
cv.imshow('Sobel Y', sobely)
cv.imshow('Combined Sobel', combined_sobel)
canny = cv.Canny(gray, 150, 175)
cv.imshow('Canny', canny)
cv.waitKey(0)
from cv2 import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('star.jpg', 0)
# cv2.CV_64F 输出图像的深度(数据类型)
# , 可以使用 - 1, 与原图像保持一致 np.uint8
laplacian = cv2.Laplacian(img, cv2.CV_64F)
# 参数 1,0 为只在 x 方向求一阶导数,最大可以求 2 阶导数。
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0, ksize=5)
# 参数 0,1 为只在 y 方向求一阶导数,最大可以求 2 阶导数。
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1, ksize=5)
plt.subplot(2, 2, 1), plt.imshow(img, cmap='gray')
plt.title('Original'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 2), plt.imshow(laplacian, cmap='gray')
plt.title('Laplacian'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 3), plt.imshow(sobelx, cmap='gray')
plt.title('Sobel X'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 4), plt.imshow(sobely, cmap='gray')
plt.title('Sobel Y'), plt.xticks([]), plt.yticks([])
plt.show()
Sobel operators is a joint Gausssian smoothing plus differentiation operation, so it is more resistant to noise. You can specify the direction of derivatives to be taken, vertical or horizontal (by the arguments, yorder and xorder respectively). You can also specify the size of kernel by the argument ksize. If ksize = -1, a 3x3 Scharr filter is used which gives better results than 3x3 Sobel filter. Please see the docs for kernels used.
2. Laplacian Derivatives
It calculates the Laplacian of the image given by the relation, \Delta src = \frac{\partial ^2{src}}{\partial x^2} + \frac{\partial ^2{src}}{\partial y^2} where each derivative is found using Sobel derivatives.
'''
# Below code shows all operators in a single diagram. All kernels are of 5x5 size. Depth of output image is passed -1 to get the result in np.uint8 type.
from cv2 import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('resource/sudo.png', 0)
whatdatatype = cv2.CV_8U
laplacian = cv2.Laplacian(img, whatdatatype)
sobelx = cv2.Sobel(img, cv2.CV_8U, 1, 0, ksize=5)
sobely = cv2.Sobel(img, whatdatatype, 0, 1, ksize=5)
plt.subplot(2, 2, 1), plt.imshow(img, cmap='gray')
plt.title('Original'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 2), plt.imshow(laplacian, cmap='gray')
plt.title('Laplacian'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 3), plt.imshow(sobelx, cmap='gray')
plt.title('Sobel X'), plt.xticks([]), plt.yticks([])
plt.subplot(2, 2, 4), plt.imshow(sobely, cmap='gray')
plt.title('Sobel Y'), plt.xticks([]), plt.yticks([])
plt.show()
from cv2 import cv2 as cv
img = cv.imread("predio.JPG", 0)
sobelx = cv.Sobel(img, cv.CV_8U, 1, 0, ksize=7)
sobely = cv.Sobel(img, cv.CV_8U, 0, 1, ksize=7)
laplacian = cv.Laplacian(img, cv.CV_8U)
cv.imshow("sobelx", sobelx)
cv.imshow("sobely", sobely)
cv.imshow("laplacian", laplacian)
cv.waitKey(0)
cv.destroyAllWindows()
def laplace_sharp(image_in):
depth = cv2.CV_16S
kernel_size = (3, 3) # 模板大小
scale = 1 # 扩散系数
image_out = cv2.Laplacian(image_in, depth, kernel_size, scale=scale)
return image_out
# Extract Sobel Edges
sobel_x = cv2.Sobel(image, cv2.CV_64F, 0, 1, ksize=5)
sobel_y = cv2.Sobel(image, cv2.CV_64F, 1, 0, ksize=5)
cv2.imshow("Original", image)
cv2.waitKey()
cv2.imshow("Sobel X", sobel_x)
cv2.waitKey()
cv2.imshow("Sobel Y", sobel_y)
cv2.waitKey()
sobel_OR = cv2.bitwise_or(sobel_x, sobel_y)
cv2.imshow("sobel_OR", sobel_OR)
cv2.waitKey()
laplacian = cv2.Laplacian(image, cv2.CV_64F)
cv2.imshow("Laplacian", laplacian)
cv2.waitKey()
# Then, we need to provide two values: threshold1 and threshold2. any gradient value larger than threshold2
# is considered to be an edge. Any value below threshold1 is considered not to be an edge.
# Values in between threshold1 and threshold2 are either classified as edges or non-edges based on how their
# intensities are "connected". In this case, any gradient values below 60 are considered non-edges
# whereas any values above 120 are considered edges.
# Canny Edge Detection uses gradient values as thresholds
# The first threshold gradient
canny = cv2.Canny(image, 20, 170)
cv2.imshow("Canny", canny)
cv2.waitKey()
# Sobel(src, dst, ddepth, dx, dy)
# src − An object of the class Mat representing the source (input) image.
# dst − An object of the class Mat representing the destination (output) image.
# ddepth − An integer variable representing the depth of the image.
# NOTE: When depth= (-1) or (CV_64F) , the destination image will have the same depth as the source.
# dx − An integer variable representing the x-derivative. (0 or 1). 1 when we want gradient in x-direction
# dy − An integer variable representing the y-derivative. (0 or 1). 1 when we want gradient in y-direction
from cv2 import cv2
import numpy as np
import matplotlib.pyplot as plt
img = cv2.imread('ronaldo.jpg', 0)
lap_img = cv2.Laplacian(img, cv2.CV_64F, ksize=3)
# NOTE: As when converting to grayscale the slope becomes negative and of floating type so first we take the
# absolute value to remove the signs and then convert the type from floating to uint8 which is required.
lap_img = np.uint8(np.absolute(lap_img))
sobelx = cv2.Sobel(img, cv2.CV_64F, 1, 0) # from left to right
sobely = cv2.Sobel(img, cv2.CV_64F, 0, 1) # from top to bottom
sobelx = np.uint8(np.absolute(sobelx))
sobely = np.uint8(np.absolute(sobely))
title = ['Original Image', 'Laplacian Image', 'Sobelx Image', 'Sobely Image']
images = [img, lap_img, sobelx, sobely]
for i in range(len(images)):
plt.subplot(2, 2, i + 1)
def laplace_gradient(image):
dst = cv.Laplacian(image, cv.CV_32F)
lpls = cv.convertScaleAbs(dst)
cv.imshow("laplace", lpls)
N = 8
inputPath = os.path.abspath('../dataset/video/vid'+str(N)+'.mov')
outputPath = os.path.abspath('output/vidSet'+str(N))
height = 500
#%%
cap = cv2.VideoCapture(inputPath)
w, h = cap.get(3), cap.get(4)
numFrame = (int(cap.get(7)))
variance = np.zeros(numFrame)
for n in range(numFrame):
ret,frame = cap.read()
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
variance[n] = cv2.Laplacian(frame, cv2.CV_64F).var()
# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()
#%%
minDist = 5
window = 15
modulo = numFrame % window
K = int((numFrame-modulo)/window)
frameList = np.zeros(K+1)
#plt.plot(variance)
#plt.show()
for i in range(K+1):
import numpy as np
from adaptive_histo_equilization import adapt_hist_equilization
from cv2 import cv2
img = cv2.imread("test_001.jpg")
#To get the input 1 from Simple color balance
image_1 = simplest_cb(img, 50)
#CLAHE
lab1 = cv2.cvtColor(image_1, cv2.COLOR_BGR2LAB)
lab_temp = lab1.copy()
lab2 = adapt_hist_equilization(lab_temp)
image_2 = cv2.cvtColor(lab2, cv2.COLOR_LAB2BGR)
#For input 1
R1 = np.double(lab1[:, :, 0]) / 255
# calculate laplacian contrast weight
WL1 = cv2.Laplacian(R1, cv2.CV_64F)
h = np.array([1, 4, 6, 4, 1]) / 16
filt = (h.T).dot(h)
WC1 = cv2.filter2D(R1, cv2.CV_64F, filt)
for i in np.where(WC1 > (math.pi / 2.75)):
# Formula to calculate laplacian contrast weight
WC1[i] = math.pi / 2.75
WC1 = (R1 - WC1) * (R1 - WC1)
# calculate the saliency weight for input 1
WS1 = saliencyDetection(image_1)
sigma = 0.25
aver = 0.5
# calculate the exposedness weight for input 1
##Formula for the exposdness weight from book 'Progress in Patter recognition,
#Image Analysis,Computer Vision and Application'
WE1 = np.exp(-(R1 - aver)**2 / (2 * np.square(sigma)))
def estimate_blur(image: np.array, threshold: int = 100):
if image.ndim == 3:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
blur_map = cv2.Laplacian(image, cv2.CV_64F)
score = np.var(blur_map)
return blur_map, score, bool(score < threshold)
# img = cv2.imread('Putin.png', cv2.IMREAD_REDUCED_GRAYSCALE_4)
# img = cv2.imread('forest.png', cv2.IMREAD_REDUCED_COLOR_4)
# img = cv2.imread('chameleon.png', cv2.IMREAD_REDUCED_COLOR_2)
img = cv2.imread('open-logo.png', cv2.IMREAD_GRAYSCALE)
"""
Чем порядок производной больше, тем границы на изображении более размыты, появляется шум на изображении;
Порядок производной должен быть СТРОГО меньше размера ядра Собеля(ksize). По умолчанию ksize = 3;
Оператор Собеля 'ksize' вычисляет градиент яркости изображения в каждой точке,
участки с большой величиной градиента (в основном, грани) будут видны как белые линии;
Параметр ddepth - глубина выходного изображения. Возьмем 'cv2.CV_8U', что означает создание 8bit unsigned numpy array
"""
sobel_x = cv2.Sobel(src=img, ddepth=cv2.CV_8U, dx=1, dy=0, ksize=3)
sobel_y = cv2.Sobel(img, cv2.CV_8U, 0, 1)
sobel_xy = cv2.Sobel(img, cv2.CV_8U, 1, 1)
'''Оператор Лапласа идеально подходит для изображений с четкими границами'''
laplacian = cv2.Laplacian(img, cv2.CV_8U, cv2.BORDER_DEFAULT)
'''
Перед использованием детектора границ Кенни рекомендуется выполнить размытие;
Отклонение от ядра по осям X,Y -> (x,y), где x,y целые нечетные числа
'''
blur = cv2.GaussianBlur(img, (1, 1), cv2.BORDER_DEFAULT)
'''
threshold1 - порог минимума, threshold2 - порог максимума;
apertureSize - размер для оператора Собеля. apertureSize = 3 по дефолту;
L2gradient если True, то вычисляется точно, если False, то вычисляется упрощенно
'''
canny = cv2.Canny(image=blur,
threshold1=200,
threshold2=225,
apertureSize=3,
L2gradient=True)
from cv2 import cv2
import numpy as np
img = cv2.imread("./sources/contour.png")
w, h = img.shape[:2]
print(w)
print(h)
kernel = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]], np.uint8)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
deneme = cv2.Laplacian(gray, cv2.CV_8U, (3, 3))
cv2.imshow("orginal", img)
cv2.imshow("deneme", deneme)
cv2.waitKey(0)
cv2.destroyAllWindows
def la_place():
dst = cv2.Laplacian(img, cv2.CV_16S, ksize=3)
return cv2.convertScaleAbs(dst)
