***Trình bày thuật toán FS-ME  DCT khối này sẽ biến đổi dữ liệu dưới dạng biên độ thành

 DCT khối này sẽ biến đổi dữ liệu dưới dạng biên độ thành dữ liệu dưới dạng tần số để loại bỏ
 Chia khung tham chiếu thành các block nhỏ 16x16.Thuật toán tìm kiếm trái-> phải, trên
xuống,..để tìm giá trị MAD nhỏ nhất . Thuật toán này tìm kiếm sai khác giữa 2 khung hình liên
tiếp để ước lượng chuyển động
 Tạo block B1,B2 ở frame k và k+1 sao cho block đặt ở trung tâm 2 frame. Ta lấy thêm 8bit ở
xung quang block B1 thành 1 block nhỏ hơn frame k, sau đó t bắt đầu đi block B1 từ trái qua
phải từ trên xuống dưới từ block vừa tìm được để so sánh với block B2 bằng sử dụng MAD
MAD = ∑ ∑ |𝐶 − 𝑃
 Block tìm được với sai khác nhỏ nhất có độ chính xác cao nhất (SAD min)tuy nhiên độ phức
tạp của nó là n^4 nên tìm sẽ lâu
 Từ block hiện tại và block tìm được ta có thể xác định được vecto chuyển động của các MB
giữa hay khung hình liên tiếp
*Thuật toán three step search ME không cần dịch s2 từng điểm ảnh trên windown như fullsearch. Ta
chỉ cần lấy 9điểm bao quanh block trung tâm , tìm best matching trong 9 điểm .Rồi ta lại khoanh vùng
9điểm xung quanh block tìm được .sau khi lặp lại ba lần nên vùng ta gọi là three step thay vì phải so
sánh hết các điểm ảnh ta chỉ cần so sánh 9x3 lần thay cho 32x32 lần
Dù nhanh hơn rất nhiều nhưng three step có sai số lớn hơn mà ta bắt buộc phải đánh đổi so với lại full
search.
Các thuật toán tìm kiếm bổ sung : half-pixel accuracy ME (số không nguyên),từ các nguyên từ nội suy
từ các pixel có trước(độ chính xác là nửa pixel); Quarter-pixel accuracy ME
***So sánh ưu nhược điểm của phép biến đổi dct so với phép biến đổi fft
-Giống :đều là biến đổi từ miền pixel sang miền tần số ,phân tích được năng lượng ảnh trên miền tần số
rõ ràng hơn
-khác:
sự dư thừa dữ liệu tạo ra hệ số tương quan cho phép nén ảnh hiệu quả hơn
 Lượng tử hóa: Mỗi hệ số sẽ được lượng tử hóa sử dụng giá trị tương ứng từ bảng lượng tử để
biểu diễn số lần nhỏ hơn các giá trị cho phép của hệ số DCT cuối cùng là biến đổi ma trận thu
được thành chuỗi số một chiều
 Mã hóa entropy: gồm 2 thủ tục mã hóa là mã hóa huffman và mã hóa số học sử dụng các bảng
mã hóa tương ứng:
+ Mã hóa huffman :sử dụng cho việc nén dữ liệu có tổn thất , kết quả thu được dung
lượng(số bít)sau khi mã hóa nhỏ nhất
+ Mã hóa số học:Thực hiện mã hóa toàn bộ thông điệp trong một số duy nhất n thuộc
[0,0;1,0]
Bài 2 : Huffman Sắp xếp xác suất theo hàng dọc -> tìm ra mã hóa vectorX(viết ngược từ phải qua trái)
-độ dài : tổng các số bít biểu diễn từng thành phần của X
-Độ dài trung bình của các từ mã = Tổng của (tần số suất hiện nhân với số bít thể hiện tương ứng sau)
Bài 3 : frame = cv2.imread("peppers.png",0) – chuyển đổi gray
DC : all giá trị = (A+B+C+D+I+J+K+L+4)/8
***TCP/IP:mô hình 4 lớp
Application(Application,presentation,session) Hỗ trợ ứng dụng cho các giao thức tầng Host to
Host(tầng vận chuyển), Cung cấp giao diện người sử dụng Các giao thức gồm: DNS, NFS ,BOOTP ,
DHCP,FTP,..
– transport(transport) Thực hiện kết nối giữa 2 máy trên mạng theo 2 giao thức TCP,UDP
– network(networ) Có nhiệm vụ tìm đường đi cho gói tin từ điểm truyền có thể đến nhiều điểm khác
nhau. + IP (Internet Protocol): giao thức vận chuyển + RIP (Route Information Protocol): tìm đường +
ICMP : ping kiểm tra kết nối tín hiệu mạng + ARP (Address Resolution Protocol): phân giải địa chỉvậtlý

 Dct Sử dụng biểu diễn cosin,sin để biến đổi ,xác định miền tần số của ảnh
 FFT dựa trên phép biến đổi fourier được biểu diễn bởi các thành phần chứa lũy thừa , số phức
 Biển đổi dct tạo ra các hệ số tương quan độc lập với nhau trong quá trình nén ảnh, tăng hiệu
quả và không ảnh hưởng đến quá trình nén
 FFT khắc phục , giảm số lượng phép nhân có trong DFT , cải thiện một số tính toán trong quá
trình biến đổi
 DCT Cho phép loại bỏ các thông tin dư thừa đối với thị giác con người để nén ảnh có tỉ lệ cao
=> dct có hiệu quả tốt hơn trong xử lí ảnh để nén
– network interface (data link, physical) : Tầng này nắm giữ những định dạng dữ liệu và truyễn dữ liệu
đến cable + Cung cấp các phương tiện kết nối vật lý: cable,bộ chuyển đổi(Transceiver),Card mạng(NIC)
+Giao thức kết nối,giao thức truy nhập đường truyền(CMSA/CD,Token Ring,Token Bus, ATM,
Ethernet, …). + Cung cấp các dịch vụ cho tầng Internet,phân dữ liệu thành các khung
*** trình bày đoạn chương trình thực hiện ME nêu trên
for row in Range (search window W)
for col in Range (search window H)

***trình bày chức năng và nguyên tắc hoạt động các khâu trong jpeg diff = block(row,col) – block(current)

 Phân khối :ảnh đầu vào sẽ được phân chia thành các block là các ma trận điểm ảnh 8x8 pixel MAD = np (np.abs(diff))/float(H*W) /tính MAD của từng block
nhằm tính toán DCT cho từng vùng dư thừa dữ liệu khác nhau -> giảm độ phức tạp của thuật If MAD < temp searchBlock = block(row,col) /MAD bé nhất là block cần tìm
toán
***Giải thích nguyên tắc nén video trong hình:

- Sơ đồ sử dụng intra và inter để loại bỏ dư thừa, lọc dư thừa ở bước đầu tiên. tmp_out[row,col] = tmp[row,col-col%size]

+ Đối với frame loại I, nó sẽ được dùng intra để loại bỏ dư thừa về mặt không gian. Vì 2 điểm ảnh gần output = tmp_out[1:height+1,1:width+1]
nhay trong khung hình có tương đồng lớn, nên intra sẽ tiến hành so sánh với đầu ra là phần dư của frame
return output
đang xét – frame dự đoán(có 9 mode dự đoán)
def mode2(frame, mode ="DC"):
+ Đối với frame loại P, nó sẽ dùng inter để loại bỏ dư thừa về mặt thời gian. Nghĩa là nó sẽ khai thác
sự sai khác về mặt thời gian giữa 2 khung hình, tìm ra block trong reference frame giống với block hiện tmp_out = np.zeros_like(tmp)
tại(trong…)nhất,từ đó cho đầu ra là vector chuyển động giữa 2 block for row in np.arange(1,stop=height-size+2,step=size):
- Sau đó đầu ra của bước trên sẽ được biến đổi DCT,rồi lượng tử hoá và cuối cùng là mã hoá for col in np.arange(1,stop=width-size+2,step=size):
entropy coding cho ra 1 chuỗi bit, hoàn thành việc nén.
x = np.full((4,4), (sum(tmp[row-1,col:col+size])+sum(tmp[row:row+4,col-1]))/8)
*** Ý nghĩa khối DCT và lượng tử hoá
tmp_out[row:row+size,col:col+size] = x
+DCT : chuyển giá trị pixel sang miền tần số vì trên miền thời gian và miền tần số không có quy luật.
output = tmp_out[1:height+1,1:width+1]
Năng lượng sẽ tập trung ở vùng có tần số thấp(góc trái trên trong ma trận) =) cắt bỏ các vùng tần số cao
đi, bỏ được càng nhiều là khả năng nén càng tốt return output

+Lượng tử hoá : kết quả thu được từ quá trình DCT sẽ chia cho các hệ số lượng tử để thu được kết quả def mode3(frame, mode = "down left"):
nhỏ hơn và được làm tròn xuống số nguyên. Mục đích là để giảm số lượng bit cần lưu trữ, cho nên tmp_out = np.zeros_like(tmp)
lượng tử hoá là quá trình xử lý mất thông tin
for row in range(1,height+1):
def mode0(frame, mode = "vertical"): //////////////////////////////////////////////////////////////////////////////////intra
for col in range(1, width+1):
tmp_out = np.zeros_like(tmp)
if(row%4==0):
for row in range(1, height+1):
tmp_out[row,col] = tmp[row-4,col+4]
for col in range(1, width+1):
else:
if(row%size==0):
tmp_out[row,col] = tmp[row-row%4,col+row%4]
tmp_out[row,col] = tmp[row-size,col]
output = tmp_out[1:height+1,1:width+1]
else:
return output
tmp_out[row,col] = tmp[row-row%size,col]
def mode4(frame, mode = "down right"):
output = tmp_out[1:height+1,1:width+1]
tmp_out = np.zeros_like(tmp)
return output
for row in range(1,height+1):
def mode1(frame, mode = "horizontal"):
for col in range(1,width+1):
tmp_out = np.zeros_like(tmp)
if(row%4==1 or col%4==1):
for col in range(1, width+1):
tmp_out[row,col]=tmp[row-1,col-1]
for row in range(1, height+1):
else:
if(col%size==0):
tmp_out[row,col]=tmp_out[row-1,col-1]
tmp_out[row,col] = tmp[row,col-size]
output = tmp_out[1:height+1,1:width+1]
else:
return output
def mode5(frame, mode = "vertical right"): return output

tmp_out = np.zeros_like(tmp) def mode8(fram, mode = "horizontal up"):

for row in np.arange(1,stop=height+1-size+1,step=size): tmp_out = np.zeros_like(tmp)

for col in range(1,width+1): for col in np.arange(1,stop=width+1-size+1,step=size):

if(col % size == 1): for row in range(1,height+1):

tmp_out[row:row+2,col] = np.full((2),tmp[row-1,col-1]) tmp_out[row,col:col+2] = np.full((2),tmp[row,col-1])

tmp_out[row+2:row+size,col] = np.full((2),tmp[row+1,col-1]) tmp_out[row,col+2:col+size] = np.full((2),tmp[row+1,col-1])

else: output = tmp_out[1:height+1,1:width+1]

tmp_out[row:row+2,col] = np.full((2),tmp[row-1,col-1]) return output

tmp_out[row+2:row+size,col] = np.full((2),tmp_out[row+1,col-1]) def dct(input_matrix): /////////////////////////////////////////////////////////////////////////////////////dct

output = tmp_out[1:height+1,1:width+1] return cv2.dct(input_matrix)

return output img_gray = cv2.imread('C:/image/apple.jpg', 0)

def mode6(frame, mode ="horizontal down"): img_float = img_gray.astype('float')

tmp_out = np.zeros_like(tmp) img_dct = cv2.dct(img_float)

for col in np.arange(1,stop=width+1-size+1,step=size): #img_dct_log = np.log(abs(img_dct))

for row in range(1,height+1): #print(img_dct_log)

if(row % size == 1): img_idct1 = cv2.idct(img_dct)

tmp_out[row,col:col+2] = np.full((2),tmp[row-1,col-1]) #print(img_idct)

tmp_out[row,col+2:col+size] = np.full((2),tmp[row-1,col+1]) inf = 50

else: recor_temp = img_dct[0:inf, 0:inf]

tmp_out[row,col:col+2] = np.full((2),tmp[row-1,col-1]) recor_temp2 = np.zeros(img_gray.shape)

tmp_out[row,col+2:col+size] = np.full((2),tmp_out[row-1,col+1]) recor_temp2[0:inf, 0:inf] = recor_temp

output = tmp_out[1:height+1,1:width+1] img_idct2 = cv2.idct(recor_temp2)

return output img_idct3 = np.zeros(img_gray.shape)

def mode7(frame, mode = "vertical left"): print(recor_temp2.shape)

tmp_out = np.zeros_like(tmp) keep_info = 2

for row in np.arange(1,stop=height+1-size+1,step=size): (h, w) = img_gray.shape

for col in range(1,width+1): for i in range(0, h, 8):

tmp_out[row:row+2,col] = np.full((2),tmp[row-1,col+1]) for j in range(0, w, 8):

tmp_out[row+2:row+size,col] = np.full((2), tmp[row-1,col+2]) newblock = np.zeros((8, 8))

output = tmp_out[1:height+1,1:width+1] newblock[0:min(8, h-i), 0:min(8, w-j)] = img_gray[i:min(i + 8, h), j:min(j + 8, w)]

newblock_dct = cv2.dct(newblock) p9 = (cx+step, cy+step)

for k in range(0, 8): points = [p1,p2,p3,p4,p5,p6,p7,p8,p9]

for l in range(0, 8): for i in range(len(points)):

if k >= keep_info or l >= keep_info: px, py = points[i] # center point

newblock_dct[k, l] = 0 rx, ry = px-self.block_w//2, py-self.block_h//2 # topleft point

newblock_idct = cv2.idct(newblock_dct) refer_block, rx, ry = self.get_refer_block(rx, ry)

img_idct3[i:min(i + 8, h), j:min(j + 8, w)] = newblock_idct[0:min(8, h-i), 0:min(8, w-j)] MAD = self.get_MAD(curr_block, refer_block)

#print(img_idct2) if MAD < minMAD:

cv2.imwrite('C:/image/apple_gray.jpg', img_gray) cv2.imwrite('C:/image/apple_dct.jpg', img_dct) minMAD = MAD

class ThreeStepSearch(BaseSearch): match_block = refer_block

def find_match_block(self): match_point = (rx, ry)

curr_block = self.curr_frame[ cx, cy = points[i]

self.y : self.y + self.block_h, step = step//2

self.x : self.x + self.block_w, residual_block = curr_block - match_block

] return match_point, residual_block

step = 4 class FullSearch(BaseSearch): ///////////////////////////////////////////////////////////////////////////////FS

minMAD = sys.float_info.max def find_match_block(self):

match_point = None curr_block = self.curr_frame[

match_block = None self.y : self.y + self.block_h,

# Center point will be updated each loop self.x : self.x + self.block_w,

cx = self.x + self.block_w // 2 ]

cy = self.y + self.block_h // 2 searching_range = range(-self.p, self.p+1)

while step > 0: minMAD = sys.float_info.max

p1 = (cx-step, cy-step) match_point = None

p2 = (cx-step, cy) match_block = None

p3 = (cx-step, cy+step) for m in searching_range:

p4 = (cx, cy-step) for n in searching_range:

p5 = (cx, cy) rx, ry = self.x+n, self.y+m

p6 = (cx, cy+step) refer_block, rx, ry = self.get_refer_block(rx, ry)

p7 = (cx+step, cy-step) MAD = self.get_MAD(curr_block, refer_block)

p8 = (cx+step, cy) if MAD<minMAD:

 minMAD=MAD

match_point = (rx, ry)

match_block = refer_block

residual_block = curr_block - match_block

return match_point, residual_block