Các lệnh OpenCV cơ bản trong python

import cv2
import numpy as np

//khai báo thư viện cv2
// khai báo thư viện numpy nhưng thay numpy bằng np (gon)
//thư viện numpy để tạo ảnh
---------------------------------------------------------------------Nhập ,xuất ảnh – Chuyển đổi không gian màu BGR/GRAY/HSV----------------------------------------------------------------img = cv2.imread("meo.jpg")
//nhập ảnh
img = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
//chuyển đổi không gian màu BGR -> GRAY
img = img[200:400,200:400]
//hiển thị vùng tương ứng
cv2.imshow("Image",img)
cv2.waitKey()

//xuất ảnh
//chờ cho đến khi ấn nút bất kì

------------------------------------------------------------------------------------Tạo ảnh-Vẽ các đối tượng lên ảnh------------------------------------------------------------------------------------------img = np.empty((600,800,3)) //W:600 L:800 3 kênh màu BGR
//empty sẽ lấy đến địa chỉ bất kì thường là màu đen
img = np.empty((600,800,3)) //giá trị 3 kênh màu tương ứng là 0--> màu đen
img[:,:,(0,1)]=255
img[:,:,2)]=255
for i in range(0,400,10):

//định một khỏang với giá trị màu tương ứng

//lệnh for để vẽ nhiều line

cv2.line(img,(300,400),(10,10),(0,0,0),3)
//vẽ đường line với (x1,y1);(x2,y2);(B,G,R);(thickness)

cv2.putText(img,str(i),(10,10),cv2.FONT_HERSHEY_COMPLEX_SMALL,1,(0,255,0)) //viết chữ với [bienanh],str(bien so)/"mau",vitri,font,size,màu,...
cv2.circle(img,(200,200),50,(255,0,0),3)
//vẽ hình trịn với [bienanh],tam,bankinh,mau,thickness
cv2.ellipse(img,(300,300),(100,50),45,0,180,(0,0,0),3)
//vẽ hình ellipse với [bienanh],tam,chieu dai truc,do nghieng,goc dau,goc cuoi,mau,thickness
pts = np.array(((10,10),(10,100),(100,100),(100,10)),np.int32)
//tạo mảng các đỉnh với mỗi điểm lưu ở vùng có bộ nhớ 32bit
pts = [pts.reshape((-1,1,2))]
//chuyển từ mảng hai chiều sang 3 chiều với -1 tự hiểu là số điểm trong mảng
cv2.polylines(img,pts,True,(255,255,255),3)
//vẽ đa giác với [bienanh],tập hợp dinh,kin/k kin,mau,thickness

-----------------------------------------------------------------------Tạo thanh trượt-Trackbar - Thay đổi màu sắc-----------------------------------------------------------------------------------import cv2
import numpy as np
blue = 0
green = 0
red = 0
def blue_function(pos):
global blue
blue=pos
def green_function(pos):
global green
green=pos

//khai báo ba biến tương ứng ba kênh màu B-G-R

//khai báo hàm
//khai báo biến blue là biến toàn cục
//truyền giá trị của pos vào blue

def red_function(pos):
global red
red=pos
cv2.namedWindow("Image")
//tạo cửa sổ mới
cv2.createTrackbar("Blue: ","Image",0,255,blue_function) //tạo thanh trượt-Trackbar với [tenthanhtruot],[tencuaso],giá trị bắt đầu, giá trị lớn nhất, gọi hàm tương ứng
cv2.createTrackbar("Green: ","Image",0,255,green_function)
cv2.createTrackbar("Red: ","Image",0,255,red_function)
while(True):
img = np.empty((600,800,3),np.uint8)
img[:,:,0] = blue
img[:,:,1] = green
img[:,:,2] = red
cv2.imshow("Image",img)
if cv2.waitKey(10) == ord('q'):
break
cv2.destroyAllWindows()

//hàm while
//mỗi điểm ảnh có kiểu dữ liệu unsign int8
//gắn kênh màu cho biến blue tương ứng

//trong khi cho 10ms nếu phím q được nhấn
//tắt tất cả các cửa sổ hiện hành

---------------------------------------------------------------------Phân ngưỡng ảnh-Threshold – Các loại phân ngưỡng------------------------------------------------------------------------------import cv2
def get_value(pos):
get_value.value=pos

//khai báo hàm

get_value.value = 0

//khai báo biến cục bộ

cv2.namedWindow("Control")
//tạo cửa sổ mới
cv2.createTrackbar("Value","Control",0,255,get_value)

//tạo thanh trượt

while True:
img = cv2.imread("meomeo.png")
cv2.imshow("Control",img)
ret, img = cv2.threshold(img,get_value.value,255,cv2.THRESH_TRUNC)
//phân ngưỡng với [bienanh], giá trị cài đặt lại từ thanh trượt,max,mode phân ngưỡng
print(ret)
//phân ngưỡng trả về hai giá trị 0-gia tri so, 1-gia tri anh
cv2.imshow("Image",img)
if cv2.waitKey(10) == ord('q'):
break
cv2.destroyAllWindows()

---------------------------------------------------------------------------------------Phát VIDEO dùng tốc độ quay - Play VIDEO----------------------------------------------------------------------------------import cv2
import time

// khai báo thư viện thời gian

cap = cv2.VideoCapture("KUKA.mpg")
fps = cap.get(cv2.CAP_PROP_FPS)
wait_time = 1000/fps
print(fps)
while True:
pre_time = time.time()
ret,img = cap.read()
img = cv2.medianBlur(img,19)
cv2.imshow("Video",img)
xl_time = (time.time() - pre_time)*1000
print(xl_time)

//lưu video vào biến cap
//đọc giá trị số khung hình trên giây
//tình thời gian chờ giữa hai khung hình ms

//đọc thời gian hiện tại
//đọc video
//làm mờ video
//xuất video
//tính thời gian xử lí các dòng lệnh

if xl_time > wait_time:
delay_time = 1
else:
delay_time = wait_time - xl_time
if cv2.waitKey(int (delay_time)) == ord('q'):
break
cv2.destroyAllWindows()

//delay thời gian tương ứng với tốc độ khung hình

---------------------------------------------------------------------------------------------Bám theo vật thể - Tracking object--------------------------------------------------------------------------BGR
import cv2
import time
import numpy as np
def Min_Blue(pos):
Min_Blue.value = pos
Min_Blue.value = 0
def Min_Green(pos):
Min_Green.value = pos
Min_Green.value = 0
def Min_Red(pos):
Min_Red.value = pos
Min_Red.value = 0
def Max_Blue(pos):
Max_Blue.value = pos
Max_Blue.value = 255
def Max_Green(pos):
Max_Green.value = pos
Max_Green.value = 255
def Max_Red(pos):
Max_Red.value = pos
Max_Red.value = 255

//khai báo hàm min max ba kênh màu BGR


cv2.namedWindow("Control")
cv2.createTrackbar("Min blue","Control",0,255,Min_Blue)

cv2.createTrackbar("Min green","Control",0,255,Min_Green)
cv2.createTrackbar("Min red","Control",0,255,Min_Green)

//tạo 6 thanh trượt

cv2.createTrackbar("Max blue","Control",255,255,Max_Blue,)
cv2.createTrackbar("Max green","Control",255,255,Max_Green)
cv2.createTrackbar("Max red","Control",255,255,Max_Red)

cap = cv2.VideoCapture("KUKA.mpg")
fps = cap.get(cv2.CAP_PROP_FPS)
wait_time = 1000/fps
print(fps)
play = True
while True:
pre_time = time.time()
if play:
ret,img = cap.read()
if ret == False:
break
cv2.imshow("Control",img)
lower = np.array([Min_Blue.value,Min_Green.value,Min_Red.value])
upper = np.array([Max_Blue.value,Max_Green.value,Max_Red.value])
mask_sub = cv2.inRange(img,lower,upper)
mask = cv2.merge((mask_sub,mask_sub,mask_sub))
res = cv2.bitwise_and(img,mask)

//tải video
//fps

//nếu play = true thì đọc video
//nếu hết video thì tắt

//tạo mảng giới hạn dưới của ba kênh màu BGR
// tạo mảng giới hạn trên của ba kênh màu BGR
//tạo mặt nạ phụ: nằm trong giới hạn thì trắng, ngồi thì đen
//tạo mặt nạ chính: phối ba kênh màu lại
//so sánh với hình mẫu để hiện màu

cv2.imshow("Mask",mask)
cv2.imshow("Res", res)
xl_time = (time.time() - pre_time)*1000
if xl_time > wait_time:
delay_time = 1
else:
delay_time = wait_time - xl_time
key = cv2.waitKey(int (delay_time))
if key == ord('q'):
break
if key == ord(' '):
play = not play
cv2.destroyAllWindows()

// gán hành động chờ cho Key

//nhấn nút cách thì play = Fals


------------------------------------------------------------------------------------------Khử nhiễu - Ăn mòn, giãn nở-erode,dilate------------------------------------------------------------------------------mask_sub = cv2.inRange(img,lower,upper)
kernel = np.ones((4,4))

mask_sub = cv2.erode(mask_sub,kernel)
kernel = np.ones((7,7))
mask_sub = cv2.dilate(mask_sub,kernel)

//tạo ma trận 1 kích thước 4x4
//khử nhiễu: qt ảnh ma trận nào có kích thước bé hơn 4x4 thì xóa
// phịng to: qt ảnh ma trận nào có kích thước bé hơn 7x7 thi phóng to ra

------------------------------------------------------------------------------------------------Định vị vật thể - Vẽ đường bao---------------------------------------------------------------------------------HSV
import cv2
import time
import numpy as np

def Min_H(pos):
Min_H.value = pos
Min_H.value = 33
def Min_S(pos):
Min_S.value = pos
Min_S.value = 50
def Min_V(pos):
Min_V.value = pos
Min_V.value = 62
def Max_H(pos):
Max_H.value = pos
Max_H.value = 102
def Max_S(pos):
Max_S.value = pos
Max_S.value = 255
def Max_V(pos):
Max_V.value = pos

Max_V.value = 248
cv2.namedWindow("Control")
cv2.createTrackbar("Min H", "Control", 33, 255, Min_H)
cv2.createTrackbar("Min S", "Control", 50, 255, Min_S)
cv2.createTrackbar("Min V", "Control", 62, 255, Min_V)
cv2.createTrackbar("Max H", "Control", 102, 255, Max_H)


cv2.createTrackbar("Max S", "Control", 255, 255, Max_S)
cv2.createTrackbar("Max V", "Control", 248, 255, Max_V)
cap = cv2.VideoCapture("tracking.mp4")
fps = cap.get(cv2.CAP_PROP_FPS)
wait_time = 1000 / fps

#nhập video
#đọc fps của video

print(fps)
play = True
delta_time = 0
while True:
pre_time = time.time()
if play:
ret, img = cap.read()
if img is None:
img = temp_img
else:
temp_img = img
img_clone = img.copy()

#nếu hết video thì dừng ở khung hình cuối

#copy một bản khác

cv2.imshow("Control", cv2.putText(img_clone.copy(),"%.2f (ms)" %delta_time,(10,30),cv2.FONT_HERSHEY_SIMPLEX,1,(0,0,255),3))
img_hsv = cv2.cvtColor(img_clone, cv2.COLOR_BGR2HSV)
#chuyển đổi hệ màu BGR -> HSV
lower = np.array([Min_H.value, Min_S.value, Min_V.value])
upper = np.array([Max_H.value, Max_S.value, Max_V.value])
mask = cv2.inRange(img_hsv, lower, upper)
kernel = np.ones((5, 5))
mask = cv2.erode(mask, kernel)
mask = cv2.dilate(mask, kernel, iterations=2)

#khử nhiễu và giãn hình
#iterations=2 : so lan lap

contours,hierarchy = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
if len(contours) > 0:
tmp_c = contours [0]
res = cv2.drawContours(img_clone,contours,-1,(255,0,0),2)
M = cv2.moments(tmp_c)
x = int(M['m10'] / (M['m00'] +1))
y = int (M['m01'] / (M['m00'] +1))
cv2.putText(res,"Tr.Banh",(x,y),cv2.FONT_HERSHEY_COMPLEX,1,(0,0,255),2)
else:
res = img_clone

cv2.imshow("Result", res)

#in ra xuli_time

#xác định đường biên

#nếu có đường biên
#vẽ đường biên
#thông số đường biên
#tọa độ đường biên
#xuất chữ
#nếu khơng phát hiện đường biên thì vẫn xuất hình bình thường


delta_time = (time.time() - pre_time) * 1000
if delta_time > wait_time:
delay_time = 1
else:
delay_time = wait_time - delta_time
key = cv2.waitKey(int(delay_time))
if key == ord('q'):
break
if key == ord(' '):
play = not play
cv2.destroyAllWindows()

-----------------------------------------------------------------------------------------------Qũy đạo vật thể - Vẽ đường bao tương đương-----------------------------------------------------------------------arr_point = np.array((),np.int32)

#tạo mảnh trong

(cx,cy),cr = cv2.minEnclosingCircle(tmp_c)
#vẽ đường tròn bao tương đương

res = cv2.circle(img_clone,(int (cx),int (cy)),int(cr/1.5),(255,0,0),2)
#vẽ đường tròn tương ứng với R phù hợp
arr_point = np.append(arr_point,(int(cx),int(cy)))
#thêm tọa độ x,y hiện tại vào mảng
if len(arr_point) > 150:
#nếu mảng có trên 150 phần tử thì xóa phần tử (x,y) từ đầu
arr_point = np.delete(arr_point,(0,1))
arr_point = np.reshape(arr_point,(-1,1,2))
cv2.polylines(res,[arr_point],False,(0,255,0),2)

#2ch -> 3ch
#vẽ quỹ đạo bằng cách nối các điểm trong mảng

---------------------------------------------------------------------------------------------------- Chọn vật thể - Xử lí chuột----------------------------------------------------------------------------------------import cv2
import time
def Mouse_event(event, x, y, f, img):
if event == cv2.EVENT_LBUTTONDOWN:
Mouse_event.x0 = x
Mouse_event.y0 = y
Mouse_event.draw = True
if event == cv2.EVENT_LBUTTONUP:
Mouse_event.x1 = x
Mouse_event.y1 = y

#nếu chuột được nhấn
#tọa độ đầu
#bắt đầu vẽ
#nếu chuột được nhả
#tọa độ cuối

Mouse_event.draw = False
miny = min(Mouse_event.y0,Mouse_event.y1)
maxy = max(Mouse_event.y0, Mouse_event.y1)
minx = min(Mouse_event.x0, Mouse_event.x1)
maxx = max(Mouse_event.x0, Mouse_event.x1)
Mouse_event.img = img[miny:maxy,minx:maxx]
if event == cv2.EVENT_MOUSEMOVE:
Mouse_event.x = x
Mouse_event.y = y

Mouse_event.img = None
Mouse_event.x0 =0
Mouse_event.y0 =0
Mouse_event.x1 =0
Mouse_event.y1 =0
Mouse_event.x =0
Mouse_event.y =0
Mouse_event.draw = False
cap = cv2.VideoCapture(0)

#kết thúc vẽ

#cắt hình tương ứng với vùng chọn
#nếu di chuyển chuột
#tọa độ lúc di chuyển

#khởi tạo các biến cục bộ

#ghi cam laptop vao Capture0

while True:
pre_time = time.time()
ret,img = cap.read()
img_lone = img.copy()
if Mouse_event.draw:
img_lone = cv2.rectangle(img_lone,(Mouse_event.x0,Mouse_event.y0),(Mouse_event.x,Mouse_event.y),(0,0,255),2)
if Mouse_event.img is not None:
#nếu có vùng được chọn thì xuất ra cửa sổ Sample
cv2.imshow("Sample", Mouse_event.img)
cv2.imshow("Video", img_lone)
cv2.setMouseCallback("Video",Mouse_event,img)
#đọc sự kiện từ chuột với hàm Mouse_event

#vẽ hình vng

if cv2.waitKey(int (1)) == ord('q'):
break
cv2.destroyAllWindows()

---------------------------------------------------------------------------------------------------- Bám theo vật thể chỉ định tùy ý----------------------------------------------------------------------------------if Mouse_event.img is not None:
tpt = cv2.matchTemplate(img_clone,Mouse_event.img,cv2.TM_CCOEFF_NORMED)
min_val, max_val,min_loc,max_loc = cv2.minMaxLoc(tpt)
if max_val > .6:

#so sánh vùng chọn với ảnh, càng giống càng sáng
#trả về các giá trị: giống ít nhất, giống nhiều nhất, tọa độ giống ít nhất, tọa độ giống nhiều nhất

#nếu giống >60% thì:

cv2.putText(img_clone, "%.2f" % max_val, max_loc, cv2.FONT_HERSHEY_SIMPLEX, 2, (0, 255, 0), 2)
#in giá trị giống nhiều nhất
h, w, d = Mouse_event.img.shape
#lấy kích thước vùng chọn
cv2.rectangle(img_clone, max_loc, (max_loc[0] + w, max_loc[1] + h), (255, 0, 0), 2)
#vẽ vùng chọn chạy theo tọa độ giống nhất
cv2.imshow("Sample", Mouse_event.img)
cv2.imshow("Compare",tpt)
cv2.imshow("Video", img_clone)
cv2.setMouseCallback("Video",Mouse_event,img)