def test_hsv2bgr():
cv_hsv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HSV)
cv_hsv = caer.to_tensor(cv_hsv, cspace='hsv')
bgr = caer.hsv2bgr(cv_hsv)
assert len(bgr.shape) == 3
assert isinstance(bgr, caer.Tensor)
assert bgr.is_bgr()
def test_hsv2hls():
cv_hsv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HSV)
cv_hsv = caer.to_tensor(cv_hsv, cspace='hsv')
hls = caer.hsv2hls(cv_hsv)
assert len(hls.shape) == 3
assert isinstance(hls, caer.Tensor)
assert hls.is_hls()
def test_yuv2hls():
cv_yuv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2YUV)
cv_yuv = caer.to_tensor(cv_yuv, cspace="yuv")
hls = caer.yuv2hls(cv_yuv)
assert len(hls.shape) == 3
assert isinstance(hls, caer.Tensor)
assert hls.is_hls()
def test_yuv2luv():
cv_yuv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2YUV)
cv_yuv = caer.to_tensor(cv_yuv, cspace="yuv")
luv = caer.yuv2luv(cv_yuv)
assert len(luv.shape) == 3
assert isinstance(luv, caer.Tensor)
assert luv.is_luv()
def test_yuv2rgb():
cv_yuv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2YUV)
cv_yuv = caer.to_tensor(cv_yuv, cspace="yuv")
rgb = caer.yuv2rgb(cv_yuv)
assert len(rgb.shape) == 3
assert isinstance(rgb, caer.Tensor)
assert rgb.is_rgb()
def test_yuv2bgr():
cv_yuv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2YUV)
cv_yuv = caer.to_tensor(cv_yuv, cspace="yuv")
bgr = caer.yuv2bgr(cv_yuv)
assert len(bgr.shape) == 3
assert isinstance(bgr, caer.Tensor)
assert bgr.is_bgr()
def test_hls2lab():
cv_hls = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HLS)
cv_hls = caer.to_tensor(cv_hls, cspace="hls")
lab = caer.hls2lab(cv_hls)
assert len(lab.shape) == 3
assert isinstance(lab, caer.Tensor)
assert lab.is_lab()
def test_hls2hsv():
cv_hls = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HLS)
cv_hls = caer.to_tensor(cv_hls, cspace="hls")
hsv = caer.hls2hsv(cv_hls)
assert len(hsv.shape) == 3
assert isinstance(hsv, caer.Tensor)
assert hsv.is_hsv()
def test_hls2bgr():
cv_hls = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HLS)
cv_hls = caer.to_tensor(cv_hls, cspace="hls")
bgr = caer.hls2bgr(cv_hls)
assert len(bgr.shape) == 3
assert isinstance(bgr, caer.Tensor)
assert bgr.is_bgr()
def test_hsv2lab():
cv_hsv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HSV)
cv_hsv = caer.to_tensor(cv_hsv, cspace='hsv')
lab = caer.hsv2lab(cv_hsv)
assert len(lab.shape) == 3
assert isinstance(lab, caer.Tensor)
assert lab.is_lab()
def test_lab2rgb():
cv_lab = cv.cvtColor(cv_bgr, cv.COLOR_BGR2LAB)
cv_lab = caer.to_tensor(cv_lab, cspace='lab')
rgb = caer.lab2rgb(cv_lab)
assert len(rgb.shape) == 3
assert isinstance(rgb, caer.Tensor)
assert rgb.is_rgb()
def test_yuv2hsv():
cv_yuv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2YUV)
cv_yuv = caer.to_tensor(cv_yuv, cspace='yuv')
hsv = caer.yuv2hsv(cv_yuv)
assert len(hsv.shape) == 3
assert isinstance(hsv, caer.Tensor)
assert hsv.is_hsv()
def test_lab2hsv():
cv_lab = cv.cvtColor(cv_bgr, cv.COLOR_BGR2LAB)
cv_lab = caer.to_tensor(cv_lab, cspace='lab')
hsv = caer.lab2hsv(cv_lab)
assert len(hsv.shape) == 3
assert isinstance(hsv, caer.Tensor)
assert hsv.is_hsv()
def test_lab2bgr():
cv_lab = cv.cvtColor(cv_bgr, cv.COLOR_BGR2LAB)
cv_lab = caer.to_tensor(cv_lab, cspace='lab')
bgr = caer.lab2bgr(cv_lab)
assert len(bgr.shape) == 3
assert isinstance(bgr, caer.Tensor)
assert bgr.is_bgr()
def test_yuv2lab():
cv_yuv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2YUV)
cv_yuv = caer.to_tensor(cv_yuv, cspace='yuv')
lab = caer.yuv2lab(cv_yuv)
assert len(lab.shape) == 3
assert isinstance(lab, caer.Tensor)
assert lab.is_lab()
def test_rgb2gray():
cv_rgb = cv.cvtColor(cv_bgr, cv.COLOR_BGR2RGB)
cv_rgb = caer.to_tensor(cv_rgb, cspace='rgb')
gray = caer.rgb2gray(cv_rgb)
assert len(gray.shape) == 2 or (len(gray.shape) == 3
and gray.shape[-1] == 1)
assert isinstance(gray, caer.Tensor)
assert gray.is_gray()
def test_lab2hls():
cv_lab = cv.cvtColor(cv_bgr, cv.COLOR_BGR2LAB)
cv_lab = caer.to_tensor(cv_lab, cspace="lab")
hls = caer.lab2hls(cv_lab)
assert len(hls.shape) == 3
assert isinstance(hls, caer.Tensor)
assert hls.is_hls()
def test_gray2rgb():
cv_gray = cv.imread(tens_path)
cv_gray = cv.cvtColor(cv_gray, cv.COLOR_BGR2GRAY)
cv_gray = caer.to_tensor(cv_gray, cspace="gray")
rgb = caer.gray2rgb(cv_gray)
assert len(rgb.shape) == 3
assert isinstance(rgb, caer.Tensor)
assert rgb.is_rgb()
def test_luv2gray():
cv_luv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2LUV)
cv_luv = caer.to_tensor(cv_luv, cspace='luv')
gray = caer.luv2gray(cv_luv)
assert len(gray.shape) == 2 or (len(gray.shape) == 3
and gray.shape[-1] == 1)
assert isinstance(gray, caer.Tensor)
assert gray.is_gray()
def show_resized_image():
global currentImage
global resizedImgBtn
global flipHImgBtn
global flipVImgBtn
global flipHVImgBtn
global rotateImgBtn
tempSize = selectedSize.get()
if 'x' in tempSize:
size = tempSize.replace(' ', '').split('x')
try:
if resizedImgBtn['bg'] == 'lightgrey':
resizedImgBtn['bg'] = 'lightblue'
if flipHImgBtn['bg'] == 'lightblue':
flipHImgBtn['bg'] = 'lightgrey'
elif flipVImgBtn['bg'] == 'lightblue':
flipVImgBtn['bg'] = 'lightgrey'
elif flipHVImgBtn['bg'] == 'lightblue':
flipHVImgBtn['bg'] = 'lightgrey'
else:
rotateImgBtn['bg'] = 'lightgrey'
if not transformedImage is None:
currentImage = caer.to_tensor(transformedImage, cspace='rgb')
reset_ghsps()
# Resize the image without preserving aspect ratio
currentImage = caer.to_tensor(caer.resize(
currentImage,
target_size=(int(size[0]), int(size[1])),
preserve_aspect_ratio=False),
cspace='rgb')
if rotationApplied:
show_rotated_image(True)
else:
image_show(currentImage)
except Exception as e:
print(str(e))
def test_gray2hsv():
cv_gray = cv.imread(tens_path)
cv_gray = cv.cvtColor(cv_gray, cv.COLOR_BGR2GRAY)
cv_gray = caer.to_tensor(cv_gray, cspace="gray")
hsv = caer.gray2hsv(cv_gray)
assert len(hsv.shape) == 3
assert isinstance(hsv, caer.Tensor)
assert hsv.is_hsv()
def test_hls2gray():
cv_hls = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HLS)
cv_hls = caer.to_tensor(cv_hls, cspace='hls')
gray = caer.hls2gray(cv_hls)
assert len(gray.shape) == 2 or (len(gray.shape) == 3
and gray.shape[-1] == 1)
assert isinstance(gray, caer.Tensor)
assert gray.is_gray()
def test_lab2gray():
cv_lab = cv.cvtColor(cv_bgr, cv.COLOR_BGR2LAB)
cv_lab = caer.to_tensor(cv_lab, cspace="lab")
gray = caer.lab2gray(cv_lab)
assert len(gray.shape) == 2 or (len(gray.shape) == 3
and gray.shape[-1] == 1)
assert isinstance(gray, caer.Tensor)
assert gray.is_gray()
def test_hsv2gray():
cv_hsv = cv.cvtColor(cv_bgr, cv.COLOR_BGR2HSV)
cv_hsv = caer.to_tensor(cv_hsv, cspace="hsv")
gray = caer.hsv2gray(cv_hsv)
assert len(gray.shape) == 2 or (len(gray.shape) == 3
and gray.shape[-1] == 1)
assert isinstance(gray, caer.Tensor)
assert gray.is_gray()
def test_gray2lab():
cv_gray = cv.imread(tens_path)
cv_gray = cv.cvtColor(cv_gray, cv.COLOR_BGR2GRAY)
cv_gray = caer.to_tensor(cv_gray, cspace='gray')
lab = caer.gray2lab(cv_gray)
assert len(lab.shape) == 3
assert isinstance(lab, caer.Tensor)
assert lab.is_lab()
def test_gray2hls():
cv_gray = cv.imread(tens_path)
cv_gray = cv.cvtColor(cv_gray, cv.COLOR_BGR2GRAY)
cv_gray = caer.to_tensor(cv_gray, cspace='gray')
hls = caer.gray2hls(cv_gray)
assert len(hls.shape) == 3
assert isinstance(hls, caer.Tensor)
assert hls.is_hls()
def test_gray2bgr():
cv_gray = cv.imread(tens_path)
cv_gray = cv.cvtColor(cv_gray, cv.COLOR_BGR2GRAY)
cv_gray = caer.to_tensor(cv_gray, cspace='gray')
bgr = caer.gray2bgr(cv_gray)
assert len(bgr.shape) == 3
assert isinstance(bgr, caer.Tensor)
assert bgr.is_bgr()
def play_file_video():
global close_video_window
global sourceSelection
global take_a_screenshot
global checkVarLoop
if not video_file is None:
capture1 = None
close_video_window = False
popup_menu_source['state'] = 'disabled'
popup_menu_scale['state'] = 'disabled'
closeBtn['state'] = 'normal'
screenshotBtn['state'] = 'normal'
chbLoop['state'] = 'normal'
try:
capture1 = caer.core.cv.VideoCapture(video_file)
while True:
isTrue, frame = capture1.read()
if isTrue:
if scaleSelection.get() != '1.00':
width = int(frame.shape[1] *
float(scaleSelection.get()))
height = int(frame.shape[0] *
float(scaleSelection.get()))
dimensions = (width, height)
frame = caer.core.cv.resize(
frame,
dimensions,
interpolation=caer.core.cv.INTER_AREA)
caer.core.cv.imshow(video_file, frame)
else:
caer.core.cv.imshow(video_file, frame)
if take_a_screenshot:
caer.imsave(
'./Screenshot_' + str(screenshot_count) + '.png',
caer.to_tensor(frame, cspace="bgr"))
take_a_screenshot = False
else:
if checkVarLoop.get() == 1:
capture1.release()
capture1 = caer.core.cv.VideoCapture(video_file)
else:
break
if caer.core.cv.waitKey(20) & 0xFF == ord(
'd') or app_closing or close_video_window:
break
except Exception as e:
print(str(e))
if not app_closing:
popup_menu_source['state'] = 'normal'
popup_menu_scale['state'] = 'normal'
closeBtn['state'] = 'disabled'
screenshotBtn['state'] = 'disabled'
checkVarLoop.set(0)
chbLoop['state'] = 'disabled'
sourceSelection.set('None')
capture1.release()
caer.core.cv.destroyAllWindows()
# \_____\/_/ \_ \______ |_| \_\
# Licensed under the MIT License <http://opensource.org/licenses/MIT>
# SPDX-License-Identifier: MIT
# Copyright (c) 2020-2021 The Caer Authors <http://github.com/jasmcaus>
import caer
import cv2 as cv
import os
here = os.path.dirname(os.path.dirname(__file__))
tens_path = os.path.join(here, 'data', 'green_fish.jpg')
# BGR
cv_bgr = cv.imread(tens_path)
cv_rgb = cv.cvtColor(cv_bgr, cv.COLOR_BGR2RGB)
cv_rgb = caer.to_tensor(cv_rgb, cspace='rgb')
def test_rgb2bgr():
cv_rgb = cv.cvtColor(cv_bgr, cv.COLOR_BGR2RGB)
cv_rgb = caer.to_tensor(cv_rgb, cspace='rgb')
bgr = caer.rgb2bgr(cv_rgb)
assert len(bgr.shape) == 3
assert isinstance(bgr, caer.Tensor)
assert bgr.is_bgr()
def test_rgb2gray():
cv_rgb = cv.cvtColor(cv_bgr, cv.COLOR_BGR2RGB)
cv_rgb = caer.to_tensor(cv_rgb, cspace='rgb')
def adjust_ghsps(*args):
global transformedImage
if not currentImage is None:
# reset the error label's text
if lblError['text'] == 'Error':
lblError['text'] = ''
transformedImage = caer.to_tensor(currentImage, cspace="rgb")
# apply all transformations to currently displayed image
if image_resized:
transformedImage = caer.resize(transformedImage,
target_size=(int(image_size[0]),
int(image_size[1])),
preserve_aspect_ratio=False)
if hue.get() != 0.0:
transformedImage = caer.transforms.adjust_hue(
transformedImage, hue.get())
if saturation.get() != 1.0:
transformedImage = caer.transforms.adjust_saturation(
transformedImage, saturation.get())
if imgGamma.get() != 1.05:
transformedImage = caer.transforms.adjust_gamma(
transformedImage, imgGamma.get())
if sharpen.get() != 8.9:
transformedImage = caer.core.cv.filter2D(transformedImage, -1,
sharpenKernel)
gb = gaussian_blur.get()
if gb > 1:
transformedImage = caer.core.cv.GaussianBlur(
transformedImage, (gb + 1, gb + 1),
caer.core.cv.BORDER_DEFAULT)
if posterize.get() < 6:
transformedImage = caer.transforms.posterize(
transformedImage, posterize.get())
if solarize.get() < 255:
transformedImage = caer.transforms.solarize(
transformedImage, solarize.get())
if sobel_threshold.get() > 0:
transformedImage = caer.core.cv.cvtColor(
transformedImage, caer.core.cv.COLOR_RGB2GRAY)
sobelKernel = sobel_threshold.get() if sobel_threshold.get(
) % 2 != 0 else sobel_threshold.get() + 1 # values 1, 3 and 5
dx = dy = sobel_threshold.get() - 2 if sobel_threshold.get(
) > 2 else sobel_threshold.get()
sobelx = caer.core.cv.Sobel(transformedImage,
caer.core.cv.IMREAD_GRAYSCALE,
dx,
0,
ksize=sobelKernel)
sobely = caer.core.cv.Sobel(transformedImage,
caer.core.cv.IMREAD_GRAYSCALE,
0,
dy,
ksize=sobelKernel)
transformedImage = caer.core.cv.bitwise_or(sobelx, sobely)
transformedImage = caer.core.cv.cvtColor(
transformedImage, caer.core.cv.COLOR_GRAY2RGB)
if show_edges.get() == 1:
transformedImage = caer.core.cv.cvtColor(
transformedImage, caer.core.cv.COLOR_RGB2GRAY)
transformedImage = caer.core.cv.Canny(transformedImage,
low_threshold.get(),
low_threshold.get() * 2)
transformedImage = caer.core.cv.cvtColor(
transformedImage, caer.core.cv.COLOR_GRAY2RGB)
if show_emboss.get() == 1:
transformedImage = caer.core.cv.filter2D(
transformedImage, -1, embossKernel) + emboss.get()
if flip_H:
transformedImage = caer.transforms.hflip(transformedImage)
if flip_V:
transformedImage = caer.transforms.vflip(transformedImage)
if rotationApplied:
show_rotated_image(True)
else:
image_show(transformedImage)
