برچسب: Image-manipulation

عملیات مورفولوژی

در openCV, دستکاری تصویر, مورفولوژی, یادداشت‌های کلاسی2018-03-10 محیا مهدیان

Mathematical Morphology

دو عملیات اصلی در Mathematical Morphology وجود دارد :

Dilation ( انشعاب )
Erosion ( فرسایش – تحلیل )

همچنین یک سری عملیات ترکیبی نیز وجود دارد :

Opening and Closing
Thinning and Tickening
و ..

Dilation

عمل Dilation تصویر باینری را بسط میدهد (Expand) ، و همینطور علاوه بر گسترش دادن تصویر ، حفره های موجود در آن را از بین می برد و لبه های خراب را ترمیم می کند.

Erosion

عکس عملیات Dilation می باشد .
که تصویر باینری را تحلیل میدهد ، و در واقع تصویر را کوچک میکند و قسمت های اضافی را حذف می کند . ( Shrink )

برای انجام این عملیات به المان هایی از جمله شکلی به عنوان فیلتر نیاز داریم که دارای ناحیه ای است که به آن Origin می گوییم ‌.

نمونه هایی از این فیلتر ها :

انجام عملیات Dilation

ورودی این عملیات تصویر باینری B و فیلتر S هستند.

انجام این عملیات از طریق حرکت فیلتر‌ S روی تصویر باینری و قرار دادن origin روی هر پیکسل میباشد . با قرار گرفتن origin در یک پیکسل از تصویر باینری و ضرب تک تک المان های فیلتر در پیکسل های نظیرشان و در نهایت با عمل OR ، پیکسل متناظر با origin ساخته می شود .

مثال متن باینری

برای مثال براثر عمل Dilation روی متن باینری مقابل :

با استفاده از فیلتر

تصویر حاصل بر اثر پر کردن حفره ها و نقاط خالی نوشته ، به این شکل در خواهد آمد :

مثال : بر اثر فرایند Dilation نتیجه عملیات به چه شکل خواهد بود ؟

انجام عملیات Erosion :

ورودی این عملیات تصویر باینری B و فیلتر S هستند.

انجام این عملیات از طریق حرکت فیلتر‌ S روی تصویر باینری و قرار دادن origin روی هر پیکسل میباشد . با قرار گرفتن origin در یک پیکسل از تصویر باینری و ضرب تک تک المان های فیلتر در پیکسل های نظیرشان و در نهایت با عمل AND ، پیکسل متناظر با origin ساخته می شود .

لازم به ذکر است سایز های مختلف فیلتر باعث ایجاد نتایج مختلفی در تصویر حاصل می شوند ، برای مثال اگر شکلی مطابق تصویر زیر داشته باشیم ، بر اثر استفاده از دیسک هایی با مقادیر شعاعی مختلف نتایج متفاوتی خواهیم داشت :

عملیات های Opening و Closing

این دو عملیات از مهم ترین فرایندها روی تصاویر باینری هستند.

Opening : عملیات حاصل از یک Erosion و سپس Dilation .

نمونه هایی از عملیات Opening

مثال ۱ :

مثال ۲ :

اگر با استفاده از فیلترِ دیسک ۱۱ پیکسلی عملیات opening را روی تصویر اولیه داشته باشیم ، در تصویر وسط روی عکس اولیه Threshold زده شده و سپس با انجام عملیات Opening میبینیم تصویر سمت راست نتیجه می شود که بدون کوچک شدن سایز تصویر نویز ها حذف شده اند ( ابتدا Erosion برای حذف نویز ها و سپس Dilation برای برگرداندن تصویر به سایز اولیه ) .

Closing : عملیات حاصل از یک Dilation و سپس Closing .

نمونه هایی از عملیات Closing

مثال ۱ :

مثال ۲ :

همینطور در تصویر بالا میبینیم در تصویر وسطی روی عکس اولیه Threshold زده شده و سپس در تصویر نهایی (سمت راست) نتیجه ی عملیات Closing را میبینیم که بدون بزرگ شدن سایز تصویر حفره ها پر شدند ( ابتدا Dilation برای پر کردن حفره ها و سپس Erosion برای برگرداندن تصویر به سایز اولیه ) .

نمونه هایی از عملیات Opening – Closing

همانطور که میبینیم با عملیات opening بدون کوچک شدن تصویر نویز ها حذف شده ، و سپس روی تصویر حاصل عملیات closing صورت گرفته و بدون بزرگ شدن تصویر حفره ها پر شده اند.

بررسی Opening-Closing و عملیات های Dilationو Erosion در OpenCv

برای انجام فرایند های Erosion و Dilation و Opening و Closing در OpenCv میتوانیم به این شکل عمل کنیم :

import cv2
import numpy as np

image = cv2.imread('images/opencv_inv.png', 0)

cv2.imshow('Original', image)
cv2.waitKey(0)

# Let's define our kernel size
kernel = np.ones((5,5), np.uint8)

# Now we erode
erosion = cv2.erode(image, kernel, iterations = 1)
cv2.imshow('Erosion', erosion)
cv2.waitKey(0)

# 
dilation = cv2.dilate(image, kernel, iterations = 1)
cv2.imshow('Dilation', dilation)
cv2.waitKey(0)

# Opening - Good for removing noise
opening = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel)
cv2.imshow('Opening', opening)
cv2.waitKey(0)

# Closing - Good for removing noise
closing = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)
cv2.imshow('Closing', closing)
cv2.waitKey(0)


cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/opencv_inv.png', 0)

cv2.imshow('Original', image)

cv2.waitKey(0)

# Let's define our kernel size

kernel = np.ones((5,5), np.uint8)

# Now we erode

erosion = cv2.erode(image, kernel, iterations = 1)

cv2.imshow('Erosion', erosion)

cv2.waitKey(0)

dilation = cv2.dilate(image, kernel, iterations = 1)

cv2.imshow('Dilation', dilation)

cv2.waitKey(0)

# Opening - Good for removing noise

opening = cv2.morphologyEx(image, cv2.MORPH_OPEN, kernel)

cv2.imshow('Opening', opening)

cv2.waitKey(0)

# Closing - Good for removing noise

closing = cv2.morphologyEx(image, cv2.MORPH_CLOSE, kernel)

cv2.imshow('Closing', closing)

cv2.waitKey(0)

cv2.destroyAllWindows()

با انجام این عملیات ها بر روی عکس مقابل :

نتایج بدین شکل خواهند بود :

Erosion :

Dilation :

Opening :

Closing :

تصاویر دودویی و حد آستانه

در openCV, دستکاری تصویر, یادداشت‌های کلاسی2018-03-09 زهرا محمدی

به طور کلی ، عکس ها به سه دسته تقسیم می شوند :

باینری یا دودویی(Binary)
مقیاس خاکستری (Gray scale)
رنگی (Color)

تحلیل تصاویر باینری

زمانی که یک تصویر را آنالیز می کنیم یک سری 0 و 1 به دست می آید.
0، پس زمینه را نشان می دهد.
1، پیش زمینه را نشان می دهد.

کاربرد های تحلیل تصاویر باینری :

بررسی قسمت ها
در صنعت و تولید
پردازش اسناد متنی

(عکس سمت راست خوب باینری نشده است( مناسب نبودن مقدار حد آستانه))

کارهایی که می توانیم با باینری کردن تصاویر انجام دهیم :

جدا کردن یک شی از پس زمینه
متراکم کردن پیکسل های یک شی
محاسبه و استخراج ویژگی های یک شی

مثال – تصویر سلول گلبول قرمز

کاربرد: برای مثال برای تسریع در شمارش گلبول‌های قرمز در تصاویر پزشکی می‌توان از پردازش تصویر استفاده کرد.

مشکل: اما اگر بخواهند تعداد گلبول های قرمز را بشمارند با باینری کردن تصویر یکی از مشکلاتی که ممکن است پیش بیاید این است که چند گلبول به یکدیگر چسبیده باشند و یا یک حفره وجود داشته باشد و نویزهایی درون تصویر وجود داشته باشد.

برای دودویی کردن تصویر و حل مشکلی که در مثال شمارش گلبول‌های قرمز بیان شد و سایر کاربردهای مفید در ایجاد و تحلیل تصاویر دودوبی برخی از عملکردها روی تصاویر معرفی شده است که در ادامه به صورت مختصر تشریح میگردد.

عملکرد های مفید

آستانه گذاری یک تصویر در مقیاس خاکستری ( gray scale )
تعیین کردن حد آستانه مناسب
تحلیل اجزای متصل به هم
مورفولوژی دودویی ریاضی
انواع استخراج ویژگی، ثابت ( محیطی، مرکزی، مداری، …)

آستانه گذاری

تعریف مختصر:

برای تبدیل یک تصویر gray scale یا مقیاس خاکستری به تصویر دودویی باید یک حد آستانه (Threshold) تعیین کنیم و تمام پیکسل‌های دارای مقدار کمتر از حد آستانه را 0 و تمام پیکسل‌های دارای مقدار بیشتر از حد آستانه را 1 (یا 255) کرد.

آستانه گذاری در OpenCV:

همان طور که بیان شد برای تبدیل تصویر gray scale به تصویر دودویی از آستانه گذاری استفاده میکنیم.

در OpenCV نیز این عملیات پیاده سازی شده و اگر مقدار پیکسلی بیشتر از مقدار threshold ( حد آستانه ) باشد، یک مقدار به آن تعلق می گیرد ( ممکن است آن مقدار سفید باشد. )
درغیر آن صورت مقدار دیگری به آن تعلق می گیرد ( ممکن است آن مقدار سیاه باشد. )

تابعی که در OpenCV برای آستانه گذاری استفاده می شود، cv2.threshold می باشد

پارامتر اول آن تصویر منبع ( image ) می باشد که باید یک تصویر در مقیاس خاکستری ( gray-scale ) باشد.
پارامتر دوم، مقدار حد آستانه ( threshold ) می باشد، که برای دسته بندی مقادیر پیکسل ها استفاده می شود.
پارامتر سوم، بیشترین مقدار ( Max value ) می باشد، که مقداری را نشان می دهد که اگر پیکسلی از مقدار حد آستانه ( threshold value ) بیشتر ( در مواردی ممکن است کمتر ) باشد، Max value به آن مقدار تعلق میگیرد.
پارامتر چهارم مربوط به نوع است. OpenCV حالت های مختلفی برای آستانه گذاری تعیین کرده است :

cv2.THRESH_BINARY

cv2.THRESH_BINARY_INV

cv2.THRESH_TRUNC

cv2.THRESH_TOZERO

cv2.THRESH_TOZERO_INV

cv2.threshold(image,threshold value, max value, threshold type)

1	cv2.threshold(image,threshold value, max value, threshold type)

مثال آستانه گذاری

آستانه گذاری به روش Ostu

در آستانه گذاری سراسری ( global thresholding )، یک مقدار دلخواه برای مقدار حد آستانه ( threshold ) استفاده می شود.
سوالی که پیش می آید این است که مقدار انتخاب شده مناسب است یا خیر؟!
پاسخ : متد آزمایش و خطا
اما با فرض یک تصویر biomodel، ( به بیان ساده تر، تصویر biomodel تصویری است که histogram دو قله ( یا حداکثر ) دارد. )
برای این تصویر ما می توانیم تقریبا حد وسط قله ها را برای مقدار حد آستانه در نظر بگیریم. یعنی کاری که در روش ostu انجام می شود. به صورت خودکار مقدار حد آستانه از تصویر histogram برای تصویر biomodel محاسبه می شود.

مثال: پس زمینه مشکی است و گیلاس سالم روشن است و قسمت های ضرب دیده تیره متوسط است.

نمودار هیستوگرام (Histogram) دو قسمت از گیلاس را نشان می دهد. ( پس زمینه ی مشکی حذف شده است. )

در پردازش تصویر، (balanced histogram thresholding (BHT یک متد بسیار ساده است (مثل روش ostu ) و متد lterative selection thresholding یک histogram بر مبنای متد آستانه گذاری ( thresholding ) می باشد.
این رویکرد تصویر را به دو کلاس اصلی تقسیم می کند :

پس زمینه ( Background )
پیش زمینه ( Foreground )

BHT سعی دارد سطح آستانه ( threshold ) را بهینه کند و histogram را به دو کلاس تقسیم می کند.
این متد histogram را می سنجد که بررسی می کند کدام بخش سنگین تر است و وزن را از بخش سنگین تر حذف کند تا روشن تر شود.

آستانه گذاری تطبیقی

در موارد قبلی، ما از مقدار های سراسری ( global ) به عنوان مقدار حد آستانه ( threshold value ) استفاده کردیم. اما در همه ی شرایط ممکن نیست این مقدار مناسب باشد؛ مثلا در مکانی که عکس شرایط روشنایی متفاوتی دارد، در این موارد ما به آستانه گذاری تطبیقی ( Adaptive theesholding ) رجوع می کنیم که الگوریتم، مقدار حد آستانه را برای نواحی کوچک تصویر محاسبه می کند. بنابراین ما به حد آستانه های متفاوتی برای نواحی مختلف همان تصویر می رسیم.
نتیجه: آستانه گذاری تطبیقی ( adaptive thresholding )، نتایج بهتری برای تصاویر با روشنایی متفاوت به نمایش می گذارد.

متد تطبیقی

cv2.ADAPTIVE_THRESH_MEAN_C مقدار حد آستانه ( threshold )، میانگین مقادیر نواحی همسایه می باشد.
cv2.ADAPTIVE_THRESH_GAUSSIAN_C مقدار حد آستانه ( threshold )، جمع وزنی مقادیر نواحی همسایه می باشد.

آستانه گذاری در پایتون و OpenCV

آستانه گذاری در پایتون و numpy

در ابتدا با numpy تصویر را باینری می‌کنیم.

import cv2
import numpy as np

# Load our image as greyscale 
image = cv2.imread('./images/gradient.jpg')

new_image = np.copy(image)
new_image[new_image <  127] = 0
new_image[new_image >= 127] = 255

cv2.imshow('Original', image)
cv2.imshow('After Threshhold, Binary Image', new_image)
cv2.waitKey(0) 
    
cv2.destroyAllWindows()

import cv2

import numpy as np

# Load our image as greyscale

image = cv2.imread('./images/gradient.jpg')

new_image = np.copy(image)

new_image[new_image < 127] = 0

new_image[new_image >= 127] = 255

cv2.imshow('Original', image)

cv2.imshow('After Threshhold, Binary Image', new_image)

cv2.waitKey(0)

cv2.destroyAllWindows()

در این کد با بارگذاری کردن تصویر gray scale، به رنگ های کمتر از حد آستانه ( 127 ) را صفر تعلق می گیرد ( سفید ) و به رنگ های بیشتر از حد آستانه ( 127 ) 255 تعلق می گیرد.( سیاه )

نکته :
دلیل اینکه از np.copy استفاده می کنیم این است که اگر به این صورت باشد : ( Newimage = image )
در واقع به یک مکان از حافظه دو اشاره گر اشاره می کند که در این صورت عکس اصلی ( اولیه) خراب می شود.

آستانه گذاری در OpenCV

برای اینکار می‌توانیم از تابع threshold در opencv نیز استفاده کنیم

import cv2
import numpy as np

# Load our image as greyscale 
image = cv2.imread('images/gradient.jpg',0)
cv2.imshow('Original', image)

# Values below 127 goes to 0 (black, everything above goes to 255 (white)
ret,thresh1 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
cv2.imshow('1 Threshold Binary', thresh1)
cv2.waitKey(0) 

cv2.destroyAllWindows()

import cv2

import numpy as np

# Load our image as greyscale

image = cv2.imread('images/gradient.jpg',0)

cv2.imshow('Original', image)

# Values below 127 goes to 0 (black, everything above goes to 255 (white)

ret,thresh1 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

cv2.imshow('1 Threshold Binary', thresh1)

cv2.waitKey(0)

cv2.destroyAllWindows()

پس از بارگذاری عکس، این بار به کمک تابع threshold که در آن حد آستانه 127 تعیین شده است، به مقادیر کمتر از این مقدار 0 تعلق می گیرد و به مقادیر بیشتر از این مقدار 1 تعلق می گیرد و نوع آن به صورت باینری (سیاه و سفید) تعیین شده است. ( در اینجا ret نشان دهنده ی حد آستانه است. )

پارامترهای مختلف تابع threshold

import cv2
import numpy as np

# Load our image as greyscale 
image = cv2.imread('images/gradient.jpg',0)
cv2.imshow('Original', image)

# Values below 127 goes to 0 (black, everything above goes to 255 (white)
ret,thresh1 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
cv2.imshow('1 Threshold Binary', thresh1)

# Values below 127 go to 255 and values above 127 go to 0 (reverse of above)
ret,thresh2 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY_INV)
cv2.imshow('2 Threshold Binary Inverse', thresh2)

# Values above 127 are truncated (held) at 127 (the 255 argument is unused)
ret,thresh3 = cv2.threshold(image, 127, 255, cv2.THRESH_TRUNC)
cv2.imshow('3 THRESH TRUNC', thresh3)

# Values below 127 go to 0, above 127 are unchanged  
ret,thresh4 = cv2.threshold(image, 127, 255, cv2.THRESH_TOZERO)
cv2.imshow('4 THRESH TOZERO', thresh4)

# Resever of above, below 127 is unchanged, above 127 goes to 0
ret,thresh5 = cv2.threshold(image, 127, 255, cv2.THRESH_TOZERO_INV)
cv2.imshow('5 THRESH TOZERO INV', thresh5)
cv2.waitKey(0) 
    
cv2.destroyAllWindows()

import cv2

import numpy as np

# Load our image as greyscale

image = cv2.imread('images/gradient.jpg',0)

cv2.imshow('Original', image)

# Values below 127 goes to 0 (black, everything above goes to 255 (white)

ret,thresh1 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

cv2.imshow('1 Threshold Binary', thresh1)

# Values below 127 go to 255 and values above 127 go to 0 (reverse of above)

ret,thresh2 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY_INV)

cv2.imshow('2 Threshold Binary Inverse', thresh2)

# Values above 127 are truncated (held) at 127 (the 255 argument is unused)

ret,thresh3 = cv2.threshold(image, 127, 255, cv2.THRESH_TRUNC)

cv2.imshow('3 THRESH TRUNC', thresh3)

# Values below 127 go to 0, above 127 are unchanged

ret,thresh4 = cv2.threshold(image, 127, 255, cv2.THRESH_TOZERO)

cv2.imshow('4 THRESH TOZERO', thresh4)

# Resever of above, below 127 is unchanged, above 127 goes to 0

ret,thresh5 = cv2.threshold(image, 127, 255, cv2.THRESH_TOZERO_INV)

cv2.imshow('5 THRESH TOZERO INV', thresh5)

cv2.waitKey(0)

cv2.destroyAllWindows()

در این کد پارامتر چهارم (threshold types) بررسی شده است.

: cv2.THRESH_BINARY

به مقادیر کمتر از حد آستانه ( 127 )، 0 تعلق می گیرد ( سفید ) و به مقادیر بیشتر از حد آستانه، 255 تعلق می گیرد ( سیاه ).

: cv2.THRESH_BINARY_INV

به رنگ های کمتر از حد آستانه ( 127 )، 255 تعلق می گیرد ( سیاه ) و به رنگ های بیشتر از حد آستانه، 0 تعلق می گیرد ( سفید ).(برعکس مورد قبل)

: cv2.THRESH_TRUNC

مقادیر بیشتر از حد آستانه بریده می شوند. ( 255 بدون استفاده می ماند. )

: cv2.THRESH_TOZERO

مقادیر بیشتر از حد آستانه تغییر نمی کنند. و به مقادیر کمتر از حد آستانه، 0 تعلق می گیرد.

: cv2.THRESH_TOZERO_INV

مقادیر کمتر از حد آستانه تغییر نمی کنند.و به مقادیر بیشتر از حد آستانه، 0 تعلق می گیرد.

یک مثال عملی از دودویی کردن تصویر در OpenCV

import cv2
import numpy as np

# Load our new image
image = cv2.imread('images/Origin_of_Species.jpg', 0)

cv2.imshow('Original', image)
cv2.waitKey(0) 

# Values below 127 goes to 0 (black, everything above goes to 255 (white)
ret,thresh1 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)
cv2.imshow('Threshold Binary', thresh1)
cv2.waitKey(0) 



# Using adaptiveThreshold
thresh = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
                               cv2.THRESH_BINARY, 3, 5) 
cv2.imshow("Adaptive Mean Thresholding", thresh) 
cv2.waitKey(0) 

# Using adaptiveThreshold + GaussianBlur
blur = cv2.GaussianBlur(image,(5,5),0)
thresh = cv2.adaptiveThreshold(blur, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
                               cv2.THRESH_BINARY, 3, 5) 
cv2.imshow("Adaptive Mean Thresholding with GaussianBlur", thresh) 
cv2.waitKey(0) 


ret2,th2 = cv2.threshold(image,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
cv2.imshow("Otsu's Thresholding", th2) 
cv2.waitKey(0) 

# Otsu's thresholding after Gaussian filtering
blur = cv2.GaussianBlur(image,(5,5),0)
ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
cv2.imshow("Guassian Otsu's Thresholding", th3) 
)cv2.waitKey)

cv2.destroyAllWindows()

import cv2

import numpy as np

# Load our new image

image = cv2.imread('images/Origin_of_Species.jpg', 0)

cv2.imshow('Original', image)

cv2.waitKey(0)

# Values below 127 goes to 0 (black, everything above goes to 255 (white)

ret,thresh1 = cv2.threshold(image, 127, 255, cv2.THRESH_BINARY)

cv2.imshow('Threshold Binary', thresh1)

cv2.waitKey(0)

# Using adaptiveThreshold

thresh = cv2.adaptiveThreshold(image, 255, cv2.ADAPTIVE_THRESH_MEAN_C,

cv2.THRESH_BINARY, 3, 5)

cv2.imshow("Adaptive Mean Thresholding", thresh)

cv2.waitKey(0)

# Using adaptiveThreshold + GaussianBlur

blur = cv2.GaussianBlur(image,(5,5),0)

thresh = cv2.adaptiveThreshold(blur, 255, cv2.ADAPTIVE_THRESH_MEAN_C,

cv2.THRESH_BINARY, 3, 5)

cv2.imshow("Adaptive Mean Thresholding with GaussianBlur", thresh)

cv2.waitKey(0)

ret2,th2 = cv2.threshold(image,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

cv2.imshow("Otsu's Thresholding", th2)

cv2.waitKey(0)

# Otsu's thresholding after Gaussian filtering

blur = cv2.GaussianBlur(image,(5,5),0)

ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

cv2.imshow("Guassian Otsu's Thresholding", th3)

)cv2.waitKey)

cv2.destroyAllWindows()

در ابتدا به کمک فیلتر ها نویزها را برطرف می کنیم زیرا thresholding ها local هستند باعث ایجاد نویز در تصویر می شوند.در آخر از ostu استفاده می کنیم چون ostu حد آستانه را مشخص می کند تصویر بهتری در خروجی نشان می دهد. ( ممکن است در روش های قبل threshold حد آستانه را درست تعیین نکرده باشیم. )

خروجی ها به صورت زیر است :

نتیجه گیری : ostu تصویر بهتری در خروجی نشان می دهد.

threshold Binary

: Adaptive thresholding

: Gaussian ostu thresholding

: ostu thresholding

: Adaptive thresholding with Gaussian

دستکاری تصاویر (۶) – فیتلرها در Open CV و حذف نویز تصاویر

در openCV, دستکاری تصویر, یادداشت‌های کلاسی2018-03-09 محمد حسن ستاریان

در قسمت قبلی با کرنل‌ها و نحوه کارکرد آن‌ها و استفاده از آنها برای ایجاد فیلتر روی تصاویر آشنا شدیم؛ حال با اعمال فیلتر روی تصاویر با استفاده از کتابخانه Open CV و توابع مربوطه آشنا می‌شویم.

اعمال فیلتر‌های دو بعدی رو تصویر

با استفاده از Open CV اعمال فیلتر‌های دو بعدی توسط کرنل بر روی تصاویر توسط تابع زیر انجام می‌شود:

cv2.filter2D(src, ddepth, kernel[, ...]) → dst

1	cv2.filter2D(src, ddepth, kernel[, ...]) → dst

این تابع یک تصویر را به عنوان اولین و یک ماتریس کرنل را به عنوان سومین ورودی خود گرفته و تصویر حاصل از اعمال کرنل بر روی تصویر داده شده را به عنوان خروجی برمی‌گرداند.

فیلتر محوی (Blur Filter)

همانطور که در پست قبل دیدیم برای محو کردن تصویر می‌توانیم یک کرنل Moving Average را بر روی تصویر اعمال کنیم. این کرنل یک ماتریس با مجموع جملات ۱ است و هرچه کرنل بزرگ‌تر باشد میزان تاری تصویر بیشتر خواهد شد.

import cv2
import numpy as np

image = cv2.imread('images/input.jpg')
cv2.imshow('Original Image', image)
cv2.waitKey(0)

# Creating our 3 x 3 kernel
kernel_3x3 = np.ones((3, 3), np.float32) / 9

# We use the cv2.fitler2D to conovlve the kernal with an image 
blurred = cv2.filter2D(image, -1, kernel_3x3)
cv2.imshow('3x3 Kernel Blurring', blurred)
cv2.waitKey(0)

# Creating our 7 x 7 kernel
kernel_7x7 = np.ones((7, 7), np.float32) / 49

blurred2 = cv2.filter2D(image, -1, kernel_7x7)
cv2.imshow('7x7 Kernel Blurring', blurred2)
cv2.waitKey(0)

cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/input.jpg')

cv2.imshow('Original Image', image)

cv2.waitKey(0)

# Creating our 3 x 3 kernel

kernel_3x3 = np.ones((3, 3), np.float32) / 9

# We use the cv2.fitler2D to conovlve the kernal with an image

blurred = cv2.filter2D(image, -1, kernel_3x3)

cv2.imshow('3x3 Kernel Blurring', blurred)

cv2.waitKey(0)

# Creating our 7 x 7 kernel

kernel_7x7 = np.ones((7, 7), np.float32) / 49

blurred2 = cv2.filter2D(image, -1, kernel_7x7)

cv2.imshow('7x7 Kernel Blurring', blurred2)

cv2.waitKey(0)

cv2.destroyAllWindows()

کرنلی که در دفعه قسمت اول برای تاری استفاده شده است یک ماتریس ۳*۳ با عناصر ۱ است که از آنجا که مجموع عناصر ماتریس باید ۱ باشد تقسیم بر ۹ شده است. همچنین برای قسمت دوم از ماتریس بزرگتر ۵*۵ استفاده شده و تقسیم بر ۲۵ شده است.

برای اعمال فیلتر Blur می‌تواند از تابع اختصاصی زیر نیز استفاده کرد:

cv2.blur(src, ksize[, ...]) → dst

Exapmle: Blur = cv2.blur(image, (3,3))

cv2.blur(src, ksize[, ...]) → dst

Exapmle: Blur = cv2.blur(image, (3,3))

این تابع یک تصویر را به همراه سایز ماتریس کرنل مورد نظر گرفته و تصویر محو شده را با عنوان خروجی برمی‌گرداند.

دیگر فیلتر‌های Blur

در Open CV علاوه بر کرنل Box (کرنل Moving Average مورد استفاده تا الان) برای محو کردن تصویر لکرنل‌های گوسین (Gaussian)، مدین (Median) و دوجانبه (Bilateral) نیز پشتیبانی می‌شوند.

import cv2
import numpy as np

image = cv2.imread('images/input.jpg')
cv2.imshow('original', image)
cv2.waitKey(0)

# Averaging done by convolving the image with a normalized box filter. 
# This takes the pixels under the box and replaces the central element
# Box size needs to odd and positive 
blur = cv2.blur(image, (3,3))
cv2.imshow('Averaging', blur)
cv2.waitKey(0)

# Instead of box filter, gaussian kernel
Gaussian = cv2.GaussianBlur(image, (7,7), 0)
cv2.imshow('Gaussian Blurring', Gaussian)
cv2.waitKey(0)

# Takes median of all the pixels under kernel area and central 
# element is replaced with this median value
median = cv2.medianBlur(image, 5)
cv2.imshow('Median Blurring', median)
cv2.waitKey(0)

# Bilateral is very effective in noise removal while keeping edges sharp
bilateral = cv2.bilateralFilter(image, 9, 75, 75)
cv2.imshow('Bilateral Blurring', bilateral)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/input.jpg')

cv2.imshow('original', image)

cv2.waitKey(0)

# Averaging done by convolving the image with a normalized box filter.

# This takes the pixels under the box and replaces the central element

# Box size needs to odd and positive

blur = cv2.blur(image, (3,3))

cv2.imshow('Averaging', blur)

cv2.waitKey(0)

# Instead of box filter, gaussian kernel

Gaussian = cv2.GaussianBlur(image, (7,7), 0)

cv2.imshow('Gaussian Blurring', Gaussian)

cv2.waitKey(0)

# Takes median of all the pixels under kernel area and central

# element is replaced with this median value

median = cv2.medianBlur(image, 5)

cv2.imshow('Median Blurring', median)

cv2.waitKey(0)

# Bilateral is very effective in noise removal while keeping edges sharp

bilateral = cv2.bilateralFilter(image, 9, 75, 75)

cv2.imshow('Bilateral Blurring', bilateral)

cv2.waitKey(0)

cv2.destroyAllWindows()

فیلتر Gaussian Blur

این فیلتر محو کردن را به گونه‌ای انجام می‌دهد که پیکسل‌های نزدیکتر سهم بیشتری در نتیجه عملیات کراس‌کرولیشن و در نتیجه تصویر تار شده نهایی داشته باشند.

فیلتر Median Blur

این فیلتر متوسط مقدار پیکسل‌هایی که درون کرنل قرار می‌گیرند را به عنوان مقدار نهایی پیکسل قرار می‌دهد.

فیلتر Bilateral Blur

این فیلتر سعی می‌کند درحالی که تصویر را محو می‌کند لبه‌های تصویر را تیز و دست نخورده نگاه دارد. به دلیل همین ویژگی این فیلتر در حذف نویز کاربرد زیادی دارد.

حذف نویز تصویر

برای حذف نویز تصویر می‌توان از تابع زیر که از روش میانگین گیری استفاده می‌کند کمک گرفت:

fastNlMeansDenoisingColored(InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21 )

1	fastNlMeansDenoisingColored(InputArray src, OutputArray dst, float h=3, float hColor=3, int templateWindowSize=7, int searchWindowSize=21 )

پارامتر‌های تابع عبارت‌اند از:

src : عکس مورد نظر برای حذف نویز
dst : متغیری برای ذخیره کردن عکس خروجی – با دادن none به این پارامتر، خروجی تابع عکس خروجی خواهد بود.
h : این پارامتر قدرت فیلتر را برای میزان شدت نور تنظیم می‌کند. هرچه مقدار این پارامتر بزرگتر باشد علاوع بر حذف نویز ممکن است از جزئیات تصویر نیز بکاهد و هرچه کوچکتر باشد جزئیات تصویر را نمی‌کاهد اما ممکن است نویزها را به درستی کاهش ندهد (بازه ۵ تا ۱۰ برای این پارامتر مناسب است).
hcolor : همانند h برای مولفه‌های رنگی
templateWindowSize : سایز گیره محاسبه کننده وزن‌ها (باید عددی فرد باشد).
searchWindowSize : سایز کرنل محاسبه کننده میانگین وزن‌دار برای هر پیکسل (باید عددی فرد باشد).

import numpy as np
import cv2

image = cv2.imread('images/taj-rgb-noise.jpg')

# Parameters, after None are - the filter strength 'h' (5-10 is a good range)
# Next is hForColorComponents, set as same value as h again
# 
dst = cv2.fastNlMeansDenoisingColored(image, None, 6, 6, 7, 21)

cv2.imshow('Fast Means Denoising', dst)
cv2.imshow('original image', image)
cv2.waitKey(0)

cv2.destroyAllWindows()

import numpy as np

import cv2

image = cv2.imread('images/taj-rgb-noise.jpg')

# Parameters, after None are - the filter strength 'h' (5-10 is a good range)

# Next is hForColorComponents, set as same value as h again

dst = cv2.fastNlMeansDenoisingColored(image, None, 6, 6, 7, 21)

cv2.imshow('Fast Means Denoising', dst)

cv2.imshow('original image', image)

cv2.waitKey(0)

cv2.destroyAllWindows()

بر اساس نوع تصویر چهار تابع محتلف برای کاهش نویز توسط روش میانگین گیری وجود دارد

()cv2.fastNlMeansDenoising : یا یک تصویر Grayscale کار می‌کند.
()cv2.fastNlMeansDenoisingColored : با یک تصویر رنگی کار می‌کند.
()cv2.fastNlMeansDenoisingMulti : با رشته‌ای از عکس‌های Grayscale که با فاصله زمانی کم گرفته شده‌اند کار می‌کند.
()cv2.fastNlMeansDenoisingColoredMulti : مانند قبلی برای عکس‌های رنگی.

دستکاری تصاویر (۵) – فیلترها و کرنل‌ها

در openCV, دستکاری تصویر, یادداشت‌های کلاسی2018-03-09 محمد حسن ستاریان

در قسمت قبل با عملیات‌های ریاضی ماتریس‌ها آشنا شدیم. در این قسمت می‌خواهیم به نحوه اعمال فیلتر‌های مختلف روی تصاویر با استفاده از عملیات‌های ریاضی روی ماتریس تصاویر بپردازیم.

برای شروع به چند تعریف نیاز داریم:

تصویر

همانطور که می‌دانید تصویر یک ماتریس است که در هر خانه مقادیر رنگ آن خانه (با توجه به سیستم رنگی مورد استفاده) قرارگرفته اند.

کانولوشن (Convolution)

کانولوشن درواقع یک عملگر ریاضی است که بر روی دو تابع اعمال شده و تابع سومی را به صورت انتگرال حاصلضرب دو تابع که یکی از آنها برعکس شده و روی یکدیگر می‌لغزند تعریف می‌کند.

کراس‌کرولیشن (Cross-correlation)

کراس‌کرولیشن میزان شباهت و ارتباط دو دسته اطلاعات را می‌سنجد. این عملگر همانند عملیات کانولوشن بوده با این تفاوت که در این عملیات تابع عبوری برعکس نمی‌شود.

در پردازش تصاویر، توابع ما درواقع ماتریس‌های تصاویر هستند. به ماتریس عبوری (اعمال شده) به تصویر کرنل می‌گوییم. همچنین در پردازش تصاویر (در عموم کتابخانه‌‌های مطرح و همینطور Open CV) از عملیات کراس‌کرولیشین استفاده می‌شود.

کرنل

کرنل، ماتریس عموما کوچکی است که روی تصویر اعمال می‌شود. از کاربردهای آن می‌توان در پردازش تصویر برای اعمال فیلتر‌های مختلف برروی عکس و در یادگیری ماشین برای ویژگی‌یابی اشاره کرد.

حال که با تعاریف اولیه مورد نیاز آشنا شدیم به نحوه استفاده و نتیجه آن روی تصاویر می‌پردازیم:

اعمال کرنل روی تصویر

در اعمال کرنل روی تصویر نیاز داریم تا با عبور کرنل بر روی تصویر و انجام عملیات کراس‌کرولیشن نتیجه عملیات در خانه‌ای از خانه‌‌های کرنل (که روی تصویر قرار‌گرفته اند) نگاشته شود. برای این‌کار عموما خانه وسط ماتریس کرنل را در نظر می‌گیرند؛ درنتیجه عموم کرنل‌های مورد استفاده ماتریس‌هایی فرد-فرد هستند.

برای عبور کرنل بر روی تصویر می‌توان دو رویه داشت:

کانولوشن بدون حاشیه‌گذاری (Valid Padding Convolution)
عبور کرنل به صورتی که خانه اول ماتریس کرنل (خانه [۰.۰]) بر روی خانه اول ماتریس تصویر بیافتد و کرنل از تصویر خارج نشود.
این روش باعث از دست رفتن قسمت‌هایی از حاشیه تصویر می‌شود.

نحوه عبور یک ماتریس کرنل بر روی یک ماتریس تصویر و انجام عملیات کراس‌کرولیشن — نحوه عبور کرنل روی ماتریس تصویر و انجام عملیات کراس‌کرولیشن در حالت Valid Padding

کانولوشن با حاشیه‌گذاری (Same Padding Convolution)
عبور کرنل به صورتی که خانه مرکز کرنل (خانه‌ای که برای نوشتن مقادیر عملیات در هر مرحله انتخاب شده) بر روی خانه اول ماتریس تصویر بیافتد.
در این حالت کرنل می‌تواند از تصویر خارج شود که مقادیر خارج از تصویر عموما صفر در نظر گرفته می‌شوند.

نحوه عبور کرنل روی ماتریس تصویر و انجام عملیات کراس‌کرولیشن در حالت Same Padding

توجه کنید که در تصویر بالا حرکت کرنل بیشتر از یک پیکسل است؛ برای همین تصویر خروجی از ورودی کوچکتر شده است.

به جز دو روش فوق برای جلوگیری از کوچک شدن تصویر می‌توان از روش‌های تکرار حاشیه تصویر (Edge Value Replication) و یا گسترش آینه‌وار (Mirror Extension) نیز استفاده کرد:

از راست به چپ: گسترش آینه‌وار، تکرار حاشیه تصویر و حاشیه‌گذاری

استفاده از کرنل‌ها

چند مثال از کرنل‌ها با فرض اینکه خانه وسط هر کرنل برای نوشتن مقادیر استفاده شود و همچنین خانه وسط بر روی هر پیکسل قرارگیرد و کرنل در هر مرحله یک پیکسل جابه‌جا شود :

کرنل تطابق

با توجه به کرنل با جابه‌جا شدن روی تصویر تغییری روی تصویر اعمال نمی‌کند چرا که با قرارگیری روی هر پیکسل تنها مقدار همان پیکسل بدون تغییر روی خودش نوشته می‌شود.

کرنل انتقال به چپ

با توجه به کرنل با جابه‌جا شدن روی تصویرو قرار گیری روی هر پیکسل مقدار پیکسل سمت راستش را جایگزین آن می‌کند. درنتیجه تصویر ۱ پیکسل به سمت چپ میرود.

حال که با نحوه اعمال کرنل‌ها و نتیجه حاصل از آن آشنا شدیم، به بررسی استفاده از کرنل‌ها برای ایجاد فیلتر روی تصاویر می‌پردازیم:

استفاده از کرنل‌ها برای ایجاد فیلتر روی تصاویر

فیلتر محوی (Blur Filter)

با عبور یک کرنل Moving Average (کرنل تصویر پایین) که کرنلی با مجموع مقادیر ۱ است و مقدار هر خانه را با میانگین مقدار خانه‌های همسایه‌اش جایگذین می‌کند، می‌توان تصویر را محو کرد.

این کرنل تغییرات ناگهانی در رنگ تصویر را ملایم‌تر می‌کند. به تصویر زیر که عبور کرنل بالا بر روی یک ماتریس است دقت کنید:

همچنین با افزایش سایز کرنل می‌توان میزان تاری تصویر را افزایش داد:

فیلتر تیزی (Sharpen Filter)

کرنل زیر را در نظر بگیرید:

می‌توان این کرنل را به صورت زیر باز کرد:

ماتریس سمت راست همان کرنل مربوط به فیلتر محوی (Blur) است که تصویر را بدون جزئیات تولید می‌کند؛ با تفریق این ماتریس از خود تصویر (ماتریس وسط) جزئیات تصویر اصلی حاصل می‌شود؛ حال با اضافه کردن این ماتریس به خود تصویر می‌توان جزئیات تصویر را به آن افزود و تصویری با جزئیات نمایان‌تر شده تولید کرد.

نتیجه حاصل از جدا کردن جزئیات و اضافه کردن آن به عکس را می‌توان به ترتیب در سطر‌های تصویر زیر مشاهده کرد:

درنتیجه فیلتر تیزی (Sharpen Filter) به صورت زیر است:

دستکاری تصاویر (۴) – عملیات ریاضی و ترکیب تصاویر رنگی در OpenCv

در openCV, دستکاری تصویر, یادداشت‌های کلاسی2018-03-09 محیا مهدیان

یادآوری چگونگی سر ریز شدن متغیر ها

با توجه به اینکه برای تصاویر در OpenCV از نوع داده‌ای unit8 یعنی عدد صحیح بدون علامت ۸ بیتی استفاده میکنیم . پس این نوع ۳ به توان ۸ یعنی ۲۵۶ مقدار مختلف میتواند داشته باشد و مقادیر خارج از ۰ تا ۲۵۵ امکان پذیر نبود و در صورتی که عددی بزرگتر قرار نسبت داده شود متغیر سر ریز می‌شد.

به قطعه کد زیر توجه کنید.

import numpy as np
import cv2
a = np.ones([2], dtype = "uint8")

b = a * 100
print(a)
print(b)
print(b + 155)
print(b + 160)

import numpy as np

import cv2

a = np.ones([2], dtype = "uint8")

b = a * 100

print(a)

print(b)

print(b + 155)

print(b + 160)

در کد بالا ماتریس دو عنصری a که عناصر آن همه ۱ هستند ، بعد از اینکه عناصرش ۱۰۰ برابر میشوند و به علاوه ۲۵۵می شنود ماتریس [۲۵۵ ۲۵۵] ساخته میشود ولی بعد از افزایش به اندازه ی ۱۶۰ واحد در هر عنصر از ماتریس b ماتریس [۴ ۴] ساخته میشود چون سرریز صورت گرفته ( مقدار بیش از ۲۵۵) و دوباره مقدار مربوطه از ۰ شروع شده است .

خروجی کد فوق :

[1 1]
 [100 100]
 [255 255] 
[4 4]

[1 1]

[100 100]

[255 255]

[4 4]

طبیعتا این موضوع برای جمع دو ماتریس هم اندازه نیز صادق است:

import numpy as np

m1 = np.array([[150, 155], [156, 157]], dtype = "uint8") 
m2 = np.ones([2,2], dtype = "uint8") * 100
print(m1 + m2)

import numpy as np

m1 = np.array([[150, 155], [156, 157]], dtype = "uint8")

m2 = np.ones([2,2], dtype = "uint8") * 100

print(m1 + m2)

در کد بالا m1 و m2 دو ماتریس به ترتیب به مقادیر :

[[150 155]
 [156 157]]
[[100 100]
 [100 100]]

[[150 155]

[156 157]]

[[100 100]

[100 100]]

هستند.که بعد از عملیات جمع این دو ماتریس دو درایه ی سطر دوم به دلیل سرریز مقادیر ۰ و ۱ را میگیرند.

خروجی کد:

[[250 255]
[  0   1]]

1 2	[[250 255] [ 0 1]]

برای حل این مشکل ( خراب نشدن عناصر بر اثر overflow ) راه حل هایی از جمله راه حل زیر وجود دارد :

import numpy as np

m1 = np.array([[150, 155], [156, 157]], dtype = "uint8") 

value_to_add = 100
max_threshold = 255 - 100

m1[m1 >= max_threshold] = 255
m1[m1 < max_threshold] += value_to_add

print(m1)

import numpy as np

m1 = np.array([[150, 155], [156, 157]], dtype = "uint8")

value_to_add = 100

max_threshold = 255 - 100

m1[m1 >= max_threshold] = 255

m1[m1 < max_threshold] += value_to_add

print(m1)

در کد مشاهده شده ماتریس m1 را داریم که می خواهیم مقدار را به تمام درایه های آن بیفزاییم . براثر این عملیات مقادیری از ماتریس اصلی که بیشتر از ۱۵۰ یا مساوی ۱۵۰ هستند وقتی با ۱۰۰ جمع شوند سر ریز میشوند . برای جلوگیری از این موضوع میتوانیم درایه هایی که مقدارشان بیشتر یا مساوی ۱۵۰ هستند برابر با بیشترین مقدار ممکن یعنی ۲۵۵ قرار داده و عملیات جمع را برای بقیه ی درایه ها انجام دهیم .

خروجی کد:

[[250 255]
 [255 255]]

1 2	[[250 255] [255 255]]

حل مشکل با OpenCV :

اگر از توابع cv2.add و cv2.subtract استفاده کنیم این مشکل را مشاهده نخواهیم کرد و مقادیر کمتر از ۰ همان ۰ و مقادیر بیش از ۲۵۵ همان ۲۵۵ باقی خواهد ماند.

به کد مقابل توجه کنید :

import cv2
import numpy as np

image = cv2.imread('images/input.jpg')

M = np.ones(image.shape, dtype = "uint8") * 100

cv2.imshow("Original", image)
cv2.waitKey(0)

added = cv2.add(image, M)
cv2.imshow("Added", added)

subtracted = cv2.subtract(image, M)
cv2.imshow("Subtracted", subtracted)

cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/input.jpg')

M = np.ones(image.shape, dtype = "uint8") * 100

cv2.imshow("Original", image)

cv2.waitKey(0)

added = cv2.add(image, M)

cv2.imshow("Added", added)

subtracted = cv2.subtract(image, M)

cv2.imshow("Subtracted", subtracted)

cv2.waitKey(0)

cv2.destroyAllWindows()

در این قطعه کد تصویری را خواندیم و سپس ماتریسی با اندازه ی تصویر خوانده شده ساختیم که تمام عناصرش ۱۰۰ هستند ، سپس این ماتریس را با تصویرمان جمع کردیم و چون ازتابع add در opencv استفاده کردیم خرابی در تصویر نهایی مشاهده نشد ، و به طور مشابه عمل subtract را انجام دادیم .

تصویر Orginal :

orginal

تصویر Add شده :

تصویر Subtract شده :

مثال عملی ترکیب تصاویر رنگی :

import cv2
import numpy as np

img1 = cv2.imread('./images/ml.jpg')
img2 = cv2.imread('./images/opencv.jpg')

cv2.imshow("ml", img1)
cv2.imshow("opencv", img2)

cv2.waitKey(0)

output_image = cv2.add(img1,img2)
cv2.imshow("out", output_image)


print(img1.shape)
print(img2.shape)
print(output_image.shape)

cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2

import numpy as np

img1 = cv2.imread('./images/ml.jpg')

img2 = cv2.imread('./images/opencv.jpg')

cv2.imshow("ml", img1)

cv2.imshow("opencv", img2)

cv2.waitKey(0)

output_image = cv2.add(img1,img2)

cv2.imshow("out", output_image)

print(img1.shape)

print(img2.shape)

print(output_image.shape)

cv2.waitKey(0)

cv2.destroyAllWindows()

در این مثال عملی مشاهده میشود که بعد از خواندن دو تصویر رنگی با نام های img1 و img2 ، این دو تصویر را با استفاده از تابع add جمع کردیم و در تصویر نهایی از دست رفتگی بعضی پیکسل ها را داریم ( همانطور که در زیر مشاهده میکنید مثلا تصویر img2 برخی قسمت هایش از دست رفته است).

img1 : img2 :

result :

حل این مشکل با ترکیب دو تصویر با جمع وزن‌دار :

برای حل این مشکل میتوانیم با نسبت های مختلف ، مثلا ۰.۵ و ۰.۵ یا ۰.۳ و ۰.۷ و یا…. نسبت هایی که مشابها جمعشان ۱ گردد تصاویر را جمع کنیم .

تابع مورد نظر به شکل زیر می باشد :

addWeighted(src1, alpha, src2, beta, gamma)

که آلفا و بتا در فرمول دوم مشاهده میشود.

g(x)=(1−α)f0(x)+αf1(x)
dst=α⋅img1+β⋅img2+γ

با این عمل میتوانیم تاثیر هر تصویر را بعد از عملیات جمع در تصویر نهایی دستکاری کنیم :

import cv2
import numpy as np

img1 = cv2.imread('./images/ml.jpg')
img2 = cv2.imread('./images/opencv.jpg')
dst = cv2.addWeighted(img1,0.7,img2,0.3,0)
cv2.imshow('dst',dst)

cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2

import numpy as np

img1 = cv2.imread('./images/ml.jpg')

img2 = cv2.imread('./images/opencv.jpg')

dst = cv2.addWeighted(img1,0.7,img2,0.3,0)

cv2.imshow('dst',dst)

cv2.waitKey(0)

cv2.destroyAllWindows()

img1 : img2 :

result :

عملیات بیتی (Bitwise Operations) و نقاب‌گذاری تصویر (Masking) :

ابتدا به رسم یک مربع و نیم دایره برای پیاده سازی عملیات بیتی روی اشکال میپردازیم.

import cv2
import numpy as np

square = np.zeros((300, 300), np.uint8)
cv2.rectangle(square, (50, 50), (250, 250), 255, -1)
cv2.imshow("Square", square)
cv2.waitKey(0)


ellipse = np.zeros((300, 300), np.uint8)
cv2.ellipse(ellipse, (150, 150), (150, 150), 30, 0, 180, 255, -1)
cv2.imshow("Ellipse", ellipse)
cv2.waitKey(0)

cv2.destroyAllWindows()

import cv2

import numpy as np

square = np.zeros((300, 300), np.uint8)

cv2.rectangle(square, (50, 50), (250, 250), 255, -1)

cv2.imshow("Square", square)

cv2.waitKey(0)

ellipse = np.zeros((300, 300), np.uint8)

cv2.ellipse(ellipse, (150, 150), (150, 150), 30, 0, 180, 255, -1)

cv2.imshow("Ellipse", ellipse)

cv2.waitKey(0)

cv2.destroyAllWindows()

همانطور که قابل مشاهده است ، در صفحه ای به اندازه ی ۳۰۰ در ۳۰۰ که تمام عناصر ماتریس آن صفر هستند ( صفحه ی تمام سیاه ) یک مربع سفید در وسط صفحه از مختصات (۵۰ ، ۵۰) تا (۲۵۰ ، ۲۵۰) رسم میکنیم ، سپس در صفحه ای مشابه به رسم نیم دایره میپردازیم.

تصاویر به این شکل خواهند بود :

عملیات بیتی تصویر در OpenCV :

حال به بررسی ۴ عملیات

bitwise_and
bitwise_or
bitwise_xor
bitwise_not

روی تصاویر خواهیم پرداخت :

# Shows only where they intersect
And = cv2.bitwise_and(square, ellipse)
cv2.imshow("AND", And)
cv2.waitKey(0)

# Shows where either square or ellipse is 
bitwiseOr = cv2.bitwise_or(square, ellipse)
cv2.imshow("OR", bitwiseOr)
cv2.waitKey(0) 

# Shows where either exist by itself
bitwiseXor = cv2.bitwise_xor(square, ellipse)
cv2.imshow("XOR", bitwiseXor)
cv2.waitKey(0)

# Shows everything that isn't part of the square
bitwiseNot_sq = cv2.bitwise_not(square)
cv2.imshow("NOT - square", bitwiseNot_sq)
cv2.waitKey(0)

### Notice the last operation inverts the image totally

cv2.destroyAllWindows()

# Shows only where they intersect

And = cv2.bitwise_and(square, ellipse)

cv2.imshow("AND", And)

cv2.waitKey(0)

# Shows where either square or ellipse is

bitwiseOr = cv2.bitwise_or(square, ellipse)

cv2.imshow("OR", bitwiseOr)

cv2.waitKey(0)

# Shows where either exist by itself

bitwiseXor = cv2.bitwise_xor(square, ellipse)

cv2.imshow("XOR", bitwiseXor)

cv2.waitKey(0)

# Shows everything that isn't part of the square

bitwiseNot_sq = cv2.bitwise_not(square)

cv2.imshow("NOT - square", bitwiseNot_sq)

cv2.waitKey(0)

### Notice the last operation inverts the image totally

cv2.destroyAllWindows()

عملیات bitwise_and :

در نتیجه ی عملیات and بین دو تصویر قسمت هایی که پیکسل در هر دوی آن تصاویر ۱ ( سفید ) است ، سفید ( مقدار 1 ) باقی خواهد ماند ، و بقیه ی پیکسل ها صفر ( سیاه ) خواهند بود و نتیجه به این شکل خواهد بود :

عملیات bitwise_or :

در نتیجه ی این عملیات قسمت هایی از تصویر نهایی سفید ( مقدار یک ) خواهد بود که مربع یا نیم دایره در آن نقاط سفید باشند.
و نتیجه به این شکل خواهد بود :

عملیات bitwise_xor :

در نتیجه ی عملیات xor ، قسمت هایی از تصویر که مربع و نیم دایره تفاوت بیتی ( یکی صفر و دیگری یک ؛ یکی سیاه و دیگری سفید ) دارند ، سفید می شود.
نتیجه شکل زیر خواهد بود :

عملیات bitwise_not :

این تابع نیز قسمت هایی از تصویر که بیت ۰ دارند ۱ میکند و بلعکس ( پیکسل های سیاه را سفید میکند و پیکسل های سفید را سیاه )

مثال عملی با تصویر رنگی :

import cv2 
import numpy as np

image = cv2.imread('./images/input.jpg')
cropped = image[100:600 , 150:650]
cv2.imshow("Beautiful Cow!", cropped)
cv2.waitKey(0)

circle = np.zeros((500,500,3), np.uint8)
cv2.circle(circle, (250, 250), 250, (255,255,255), -1) 
cv2.imshow("Circle", circle)
cv2.waitKey(0)

output_image = cv2.bitwise_and(cropped, circle)
cv2.imshow("Output Image", output_image)
cv2.waitKey(0)

cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('./images/input.jpg')

cropped = image[100:600 , 150:650]

cv2.imshow("Beautiful Cow!", cropped)

cv2.waitKey(0)

circle = np.zeros((500,500,3), np.uint8)

cv2.circle(circle, (250, 250), 250, (255,255,255), -1)

cv2.imshow("Circle", circle)

cv2.waitKey(0)

output_image = cv2.bitwise_and(cropped, circle)

cv2.imshow("Output Image", output_image)

cv2.waitKey(0)

cv2.destroyAllWindows()

اگر تصویر گاو اصلی را crop کنیم و سپس با این تصویر and کنیم :

با توجه به اینکه میدانیم هر چیزی که با ۱ ، and شود ، حاصل خود آن میشود ، و هرچیزی که با ۰ ، and شود حاصل ۰ خواهد بود پس در نتیجه تصویر به این شکل در خواهد آمد :

همانطور که مشاهده میشود پیکسل هایی از تصویر گاو که در تناظر با قسمت های سیاه تصویر دایره هستند ، از بین خواهند رفت.(سیاه میشوند)

برای درک عملگر بیتی دو تصویر به مثال زیر توجه کنید :

square = np.zeros((10, 10), np.uint8)
cv2.rectangle(square, (2, 2), (8, 8), 2, -1) # 2 : 010

circle1 = np.zeros((10, 10), np.uint8)
cv2.circle(circle1, (5, 5), 2, 3, -1)  # 3 : 011


circle2 = np.zeros((10, 10), np.uint8)
cv2.circle(circle2, (5, 5), 2, 4, -1) # 4 : 100


output1 = cv2.bitwise_and(square, circle1)
output2 = cv2.bitwise_and(square, circle2)

print("--square--")
print(square)
print("--circle1--")
print(circle1)
print("--circle2--")
print(circle2)
print("--output1--")
print(output1)
print("--output2--")
print(output2)

square = np.zeros((10, 10), np.uint8)

cv2.rectangle(square, (2, 2), (8, 8), 2, -1) # 2 : 010

circle1 = np.zeros((10, 10), np.uint8)

cv2.circle(circle1, (5, 5), 2, 3, -1) # 3 : 011

circle2 = np.zeros((10, 10), np.uint8)

cv2.circle(circle2, (5, 5), 2, 4, -1) # 4 : 100

output1 = cv2.bitwise_and(square, circle1)

output2 = cv2.bitwise_and(square, circle2)

print("--square--")

print(square)

print("--circle1--")

print(circle1)

print("--circle2--")

print(circle2)

print("--output1--")

print(output1)

print("--output2--")

print(output2)

خروجی به شکل زیر خواهد بود :

--square--
[[0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 2 2 2 2 2 2 2 0]
 [0 0 2 2 2 2 2 2 2 0]
 [0 0 2 2 2 2 2 2 2 0]
 [0 0 2 2 2 2 2 2 2 0]
 [0 0 2 2 2 2 2 2 2 0]
 [0 0 2 2 2 2 2 2 2 0]
 [0 0 2 2 2 2 2 2 2 0]
 [0 0 0 0 0 0 0 0 0 0]]
--circle1--
[[0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 3 0 0 0 0]
 [0 0 0 0 3 3 3 0 0 0]
 [0 0 0 3 3 3 3 3 0 0]
 [0 0 0 0 3 3 3 0 0 0]
 [0 0 0 0 0 3 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]]
--circle2--
[[0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 4 0 0 0 0]
 [0 0 0 0 4 4 4 0 0 0]
 [0 0 0 4 4 4 4 4 0 0]
 [0 0 0 0 4 4 4 0 0 0]
 [0 0 0 0 0 4 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]]
--output1--
[[0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 2 0 0 0 0]
 [0 0 0 0 2 2 2 0 0 0]
 [0 0 0 2 2 2 2 2 0 0]
 [0 0 0 0 2 2 2 0 0 0]
 [0 0 0 0 0 2 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]]
--output2--
[[0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0]]

--square--

[[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 2 2 2 2 2 2 2 0]

[0 0 0 0 0 0 0 0 0 0]]

--circle1--

[[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 3 0 0 0 0]

[0 0 0 0 3 3 3 0 0 0]

[0 0 0 3 3 3 3 3 0 0]

[0 0 0 0 3 3 3 0 0 0]

[0 0 0 0 0 3 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]]

--circle2--

[[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 4 0 0 0 0]

[0 0 0 0 4 4 4 0 0 0]

[0 0 0 4 4 4 4 4 0 0]

[0 0 0 0 4 4 4 0 0 0]

[0 0 0 0 0 4 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]]

--output1--

[[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 2 0 0 0 0]

[0 0 0 0 2 2 2 0 0 0]

[0 0 0 2 2 2 2 2 0 0]

[0 0 0 0 2 2 2 0 0 0]

[0 0 0 0 0 2 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]]

--output2--

[[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]

[0 0 0 0 0 0 0 0 0 0]]

دستکاری تصویر (3) – مثال‌های عملی در OpenCV

در openCV, دستکاری تصویر, یادداشت‌های کلاسی2018-02-24 المیرا قربانی

تبدیلات همگن (Affine Transform)

انتقال (Translation) :

import cv2
import numpy as np
image = cv2.imread('images/input.jpg')
# Store height and width of the image
height, width = image.shape[:2]
quarter_height, quarter_width = height/4, width/4
#       | 1 0 Tx |
#  T  = | 0 1 Ty |

# T is our translation matrix
T = np.float32([[1, 0, quarter_width], [0, 1,quarter_height]])
# We use warpAffine to transform the image using the matrix, T
img_translation = cv2.warpAffine(image, T, (width, height))
cv2.imshow('Translation', img_translation)
cv2.waitKey()
cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/input.jpg')

# Store height and width of the image

height, width = image.shape[:2]

quarter_height, quarter_width = height/4, width/4

# | 1 0 Tx |

# T = | 0 1 Ty |

# T is our translation matrix

T = np.float32([[1, 0, quarter_width], [0, 1,quarter_height]])

# We use warpAffine to transform the image using the matrix, T

img_translation = cv2.warpAffine(image, T, (width, height))

cv2.imshow('Translation', img_translation)

cv2.waitKey()

cv2.destroyAllWindows()

برای پیاده سازی این تبدیلات از cv2.warpAffine استفاده میکینم.

به طور مثال در کد زیر :

پس از خواندن عکس و دریافت عرض و طول تصویر:

cv2.imread('images/input.jpg')

height, width = image.shape[:2]

cv2.imread('images/input.jpg')

height, width = image.shape[:2]

یک نسبت دلخواه برای انتقال طول و عرض تصویر در نظر گرفتیم :

quarter_height, quarter_width = height/4, width/4

1	quarter_height, quarter_width = height/4, width/4

با استفاده از ضرب ماتریس انتقال در مختصات تصویر ،تصویر انتقال پیدا میکند :

T = np.float32([[1, 0, quarter_width], [0, 1, quarter_height]])
# پارامتر اول ، سطر اول
# پارامتر دوم ، سطر دوم

T = np.float32([[1, 0, quarter_width], [0, 1, quarter_height]])

# پارامتر اول ، سطر اول

# پارامتر دوم ، سطر دوم

از warpAffine برای تبدیل عکس استفاده میکنیم که ورودی های آن به صورت زیر است :

#image, transform matris , (width, height)=>output image
cv2.warpAffine(image, T, (width, height))

1 2	#image, transform matris , (width, height)=>output image cv2.warpAffine(image, T, (width, height))

چرخاندن (Rotations) :

*یادآوری

ماتریس دوران:

دوران در opencv

cv2.getRotationMatrix2D(rotation_center_x, rotation_center_y, angle of rotation, scale)  
# rotation_center_x : مرکز چرخش نسبت به عرض   
# rotation_center_y : مرکز چرخش نسبت به ارتفاع
# angle of rotation : زوایه چرخش

cv2.getRotationMatrix2D(rotation_center_x, rotation_center_y, angle of rotation, scale)

# rotation_center_x : مرکز چرخش نسبت به عرض

# rotation_center_y : مرکز چرخش نسبت به ارتفاع

# angle of rotation : زوایه چرخش

import cv2
import numpy as np
image = cv2.imread('images/input.jpg')
height, width = image.shape[:2]
# Divide by two to rototate the image around its centre
rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), 20, .5)
print(rotation_matrix)
rotated_image = cv2.warpAffine(image, rotation_matrix, (width, height))
cv2.imshow('Rotated Image', rotated_image)
cv2.waitKey()
cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/input.jpg')

height, width = image.shape[:2]

# Divide by two to rototate the image around its centre

rotation_matrix = cv2.getRotationMatrix2D((width/2, height/2), 20, .5)

print(rotation_matrix)

rotated_image = cv2.warpAffine(image, rotation_matrix, (width, height))

cv2.imshow('Rotated Image', rotated_image)

cv2.waitKey()

cv2.destroyAllWindows()

از نقص های این روش میتوان به ایجاد فضاهای سیاه اطراف تصویر اشاره کرد که در ادامه فضاهای سیاه ایجاد شده اطراف تصویر را با کراپ از بین میبریم.

روشی دیگر برای دوران :

ترانهاده ماتریس

ماتریس ترانهاده با تغییر جای سطر ها با ستون ها باعث چرخش تصویر میشود و فضای سیاه اطراف تصویر ایجاد نمی کند .

#Other Option to Rotate
img = cv2.imread('images/input.jpg')
rotated_image = cv2.transpose(img)
cv2.imshow('Rotated Image - Method 2', rotated_image)
cv2.waitKey()
cv2.destroyAllWindows()

#Other Option to Rotate

img = cv2.imread('images/input.jpg')

rotated_image = cv2.transpose(img)

cv2.imshow('Rotated Image - Method 2', rotated_image)

cv2.waitKey()

cv2.destroyAllWindows()

flip تصویر

تصویر را در جهت افق و خط عمود آینه می کند.

# Let's now to a horizontal flip.
flipped = cv2.flip(image, 1)
cv2.imshow('original', image) 
cv2.imshow('Horizontal Flip', flipped) 
cv2.waitKey()
cv2.destroyAllWindows()

# Let's now to a horizontal flip.

flipped = cv2.flip(image, 1)

cv2.imshow('original', image)

cv2.imshow('Horizontal Flip', flipped)

cv2.waitKey()

cv2.destroyAllWindows()

پارامتر دوم :

cv2.flip(image, 1)

1	cv2.flip(image, 1)

صفر یا false عکس را حول محور x ها قرینه میکند.

یک یا True عکس را حول محور y ها قرینه میکند.

تغییر اندازه (scaling, resizing) و درون‌یابی (interpolations)

cv2.resize(image, dsize(output image size), x scale, y scale, interpolation)
# image : دریافت عکس ورودی
# dsize(output image size) : اندازه تصویر خروجی
# x scale, y scale : تغییر مقیاس در راستای x و y
# interpolation : روش درون یابی

cv2.resize(image, dsize(output image size), x scale, y scale, interpolation)

# image : دریافت عکس ورودی

# dsize(output image size) : اندازه تصویر خروجی

# x scale, y scale : تغییر مقیاس در راستای x و y

# interpolation : روش درون یابی

fx و fy پارامتر های نام دار هستند میتوان آنها را به تابع پاس نداد.

روش های درون یابی :

Bilinear Interpolation (درج وابسته به ۴ پیکسل ۴ طرف)
Bicubic interpolation (درج وابسته به ۴ پیکسل ۴ طرف به علاوه ۴ پیکسل اریب)
Nearest Neighbor (نزدیکترین همسایه)

import cv2
import numpy as np
# load our input image
image = cv2.imread('images/input.jpg')
cv2.imshow('Original Image', image) 
cv2.waitKey()

#  bilinear interpolation (used by default)
# Let's make our image 3/4 of it's original size
image_scaled = cv2.resize(image, None, fx=0.75, fy=0.75)
cv2.imshow('Scaling - Linear Interpolation', image_scaled) 
cv2.waitKey()

# bicubic interpolation over 4x4 pixel neighborhood
# Let's double the size of our image
img_scaled = cv2.resize(image, None, fx=2, fy=2, interpolation = cv2.INTER_CUBIC)
cv2.imshow('Scaling - Cubic Interpolation', img_scaled)
cv2.waitKey()

# nearest-neighbor interpolation
# Let's skew the re-sizing by setting exact dimensions
img_scaled = cv2.resize(image, (900, 400), interpolation = cv2.INTER_AREA)
cv2.imshow('Scaling - Skewed Size', img_scaled) 
cv2.waitKey()
cv2.destroyAllWindows()

import cv2

import numpy as np

# load our input image

image = cv2.imread('images/input.jpg')

cv2.imshow('Original Image', image)

cv2.waitKey()

# bilinear interpolation (used by default)

# Let's make our image 3/4 of it's original size

image_scaled = cv2.resize(image, None, fx=0.75, fy=0.75)

cv2.imshow('Scaling - Linear Interpolation', image_scaled)

cv2.waitKey()

# bicubic interpolation over 4x4 pixel neighborhood

# Let's double the size of our image

img_scaled = cv2.resize(image, None, fx=2, fy=2, interpolation = cv2.INTER_CUBIC)

cv2.imshow('Scaling - Cubic Interpolation', img_scaled)

cv2.waitKey()

# nearest-neighbor interpolation

# Let's skew the re-sizing by setting exact dimensions

img_scaled = cv2.resize(image, (900, 400), interpolation = cv2.INTER_AREA)

cv2.imshow('Scaling - Skewed Size', img_scaled)

cv2.waitKey()

cv2.destroyAllWindows()

استفاده از ماتریس تبدیل

جهت هایی را که میخواهیم scale شوند را در قطر ماتریس قرار میدهیم.

import cv2
import numpy as np
image = cv2.imread('images/input.jpg')
# Store height and width of the image
height, width = image.shape[:2]
#       | Sx 0 0 |
#  T  = | 0 Sy 0 |
# T is our translation matrix
T = np.float32([[0.5, 0, 0], [0, 0.5,0]])
# We use warpAffine to transform the image using the matrix, T
img_translation = cv2.warpAffine(image, T, (width, height))
cv2.imshow('Translation', img_translation)
cv2.waitKey()
cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/input.jpg')

# Store height and width of the image

height, width = image.shape[:2]

# | Sx 0 0 |

# T = | 0 Sy 0 |

# T is our translation matrix

T = np.float32([[0.5, 0, 0], [0, 0.5,0]])

# We use warpAffine to transform the image using the matrix, T

img_translation = cv2.warpAffine(image, T, (width, height))

cv2.imshow('Translation', img_translation)

cv2.waitKey()

cv2.destroyAllWindows()

معایب :

مشکل سیاهی تصویر را دارد.
عکس بعد از اعمال interpolations باید crop شود .

Image Pyramids

در بعضی موارد، ما باید با تصاویری با وضوح مختلف تصویر مشابه کار کنیم. به عنوان مثال، هنگام جستجو برای چیزی در یک تصویر، مانند چهره، ما مطمئن نیستیم که کدام اندازه از شئ در تصویر وجود دارد.

import cv2
image = cv2.imread('images/input.jpg')
smaller = cv2.pyrDown(image)
larger = cv2.pyrUp(smaller)
cv2.imshow('Original', image )
cv2.imshow('Smaller ', smaller )
cv2.imshow('Larger ', larger )
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2

image = cv2.imread('images/input.jpg')

smaller = cv2.pyrDown(image)

larger = cv2.pyrUp(smaller)

cv2.imshow('Original', image )

cv2.imshow('Smaller ', smaller )

cv2.imshow('Larger ', larger )

cv2.waitKey(0)

cv2.destroyAllWindows()

در این روش عکس را به صورت پلکانی به سایز های مختلف می بریم :

smaller = cv2.pyrDown(image)
larger = cv2.pyrUp(smaller)

1 2	smaller = cv2.pyrDown(image) larger = cv2.pyrUp(smaller)

کاربرد: آموزش به هوش مصنوعی برای تشخیص اشیاء

Cropping

Opencv تابع مشخص برای کراپ کردن ندارد.

روش های جایگزین :

یکی از روش های کراپ کردن slicing است که با دادن بازه ی دقیقی از x ,y (برای ساده تر شدن عکس را بصورت دو بعدی و سیاه سفید تصور میکنیم)همان بازه ی مشخص شده را کراپ می کنیم.

import cv2
import numpy as np
image = cv2.imread('images/input.jpg')
height, width = image.shape[:2]
# Let's get the starting pixel coordiantes (top  left of cropping rectangle)
start_row, start_col = int(height * .25), int(width * .25)
# Let's get the ending pixel coordinates (bottom right)
end_row, end_col = int(height * .75), int(width * .75)
# Simply use indexing to crop out the rectangle we desire
cropped = image[100:300 , 200:800]
cv2.imshow("Original Image", image)
cv2.imshow("Cropped Image", cropped) 
cv2.waitKey(0) 
cv2.destroyAllWindows()

import cv2

import numpy as np

image = cv2.imread('images/input.jpg')

height, width = image.shape[:2]

# Let's get the starting pixel coordiantes (top left of cropping rectangle)

start_row, start_col = int(height * .25), int(width * .25)

# Let's get the ending pixel coordinates (bottom right)

end_row, end_col = int(height * .75), int(width * .75)

# Simply use indexing to crop out the rectangle we desire

cropped = image[100:300 , 200:800]

cv2.imshow("Original Image", image)

cv2.imshow("Cropped Image", cropped)

cv2.waitKey(0)

cv2.destroyAllWindows()

نکات :

مختصات شروع و پایان حتما باید اعداد صحیح باشند.

در بازه نویسی به صورت [ x1 : x2 , y1:y2 ] :

x1 شامل بازه میشود اما x2 نوشته نمیشود .

روش دیگر اسلایس کردن ماتریس ها به کمک numpy است.

مثال:

a=np.array([[100,200,400],[1,2,3]])

میخواهیم عناصر سطر اول [0] و ستون دوم [1] را انتخاب کنیم.

a [0: , 1:] => array([[200, 400],[ 2, 3]])

دستکاری تصویر (2) – دوران، انتقال، مقیاس و درون‌یابی

در openCV, دستکاری تصویر, یادداشت‌های کلاسی2018-02-24 نفیسه داوری

Rotation (دوران)

همانطور که در درس هندسه تحلیلی خوانده ایم برای چرخاندن نقطه ای به اندازه ی α خلاف جهت عقربه ساعت باید مختصات آن نقطه را در ماتریس چرخش ضرب کنیم.که نقطه دوران یافته به صورت زیر میباشد.

تابعی که در opencv برای این کار گمارده شده است به صورت زیر است:

GetRotationMatrix2D(rotation_center_x , rotation_center_y , angle of rotation ,scale)

1	GetRotationMatrix2D(rotation_center_x , rotation_center_y , angle of rotation ,scale)

که آرگومان اول و دوم به ترتیب x و y مرکز دوران را میگیرند و آرگومان بعدی زاویه چرخش و آرگومان اخر آپشن اضافه ای در اختیار ما قرار داده است و عددی برای بزرگنمایی یا کوچک نمایی تصویر میگیرد و بدون درگیر کردن ما با ماتریس چرخش و سینوس و کسینوس این تبدیل را به خوبی انجام میدهد.=)

خروجی این تابع؛ ماتریس چرخش یا دوران می باشد.که میتوان با تابع پرینت آن را نمایش داد.

اما برای بدست آوردن تصویر دوران یافته کافیست از تابع زیر استفاده کرده و این ماتریس چرخش را به آن بدهیم و در خروجی این تابع عکس دوران یافته را بگیریم.

WarpAffine(image  ,rotation matrix , (cols , rows))

1	WarpAffine(image ,rotation matrix , (cols , rows))

2D Translation (انتقال دوبعدی)

برای انتقال یک نقطه از مکانی به مکان دیگر از ماتریس زیر استفاده میکنیم:

که در اینجا:

x´ = x + Tx = 1 * x + 0 * y + Tx

y´ = y + Ty = 0 * x + 1 * y + Ty

و به این صورت میتوانیم تصویر را جابجا کنیم.

به صورت خلاصه تر این ماتریس به این صورت بیان میشود:

1 ها مقدار مقیاس گذاری را مشخص میکنند یعنی 1 خانه ی (0 و 0) نشان دهنده scale در راستای ایکس و 1 خانه ی (1 و 1) نشان دهنده scale در راستای ایگرگ میباشد.که چون در اینجا مقادیر 1 هستند یعنی اندازه ی تصویر بدون تغییر میماند و بزرگ نمایی یا کوچک نمایی انجام نمیشود.

تابعی که برای این کار در opencv در نظر گرفته اند بدین صورت است:

WarpAffine(image  ,translation matrix , (cols , rows))

1	WarpAffine(image ,translation matrix , (cols , rows))

آرگومان اول تصویر میباشد و آرگومان دوم ماتریس انتقال و آرگومان اخر سایز عکس خروجی است.خروجی این تابع عکس انتقال یافته می باشد.

و خود ماتریس انتقال را میتوانیم بدین صورت بسازیم:

Np.float32([[1 , 0 , tx] , [0 , 1 , ty]])

Scalling (مقیاس گذاری)

ما اگر بخواهیم مثلا یک ماتریس 2 در 2 را به ماتریس 6 در 6 تبدیل کنیم یک سری نقاط(پیکسل) را نداریم.

با این 4 روش میخواهیم این نقاط را بسازیم.

Nearest Neighbor (نزدیکترین همسایه)
Bilinear Interpolation (درج وابسته به ۴ پیکسل ۴ طرف)
Bicubic interpolation (درج وابسته به ۴ پیکسل ۴ طرف به علاوه ۴ پیکسل اریب)
استفاده از ماتریس تغییر شکل (با استفاده از تابع warpaffine با ارقام دلخواه و ترتیب گفته شده در ماتریس scalling، که در ابتدا آمده است)

این مقیاس گذاری دو حالت دارد:

بزرگ نمایی
کوچک نمایی

روش نزدیکترین همسایه(ساده ترین روش):

در این روش مثلا فلان پیکسل را نسبت می بندیم که آن روی یک پیکسل متناظرش در ماتریس جدید می افتد پس همان مقدار پیکسل را به آن میدهیم.سپس پیکسل دیگری را بررسی میکنیم که مثلا هیچ پیکسلی را متناظرش در ماتریس جدید نمی یابیم و در آن پیکسل مقدار نزدیکترین پیکسل را قرار می دهیم.

روش درج وابسته به۴ پیکسل ۴ طرف:نسبت به روش قبلی دقیقتر است.همانطور که مشخص است مقادیر 4 پیکسل اطراف را میانگین گرفته و پیکسل های خالی را پر میکنیم.

روش درج وابسته به ۴ پیکسل ۴ طرف به علاوه ۴ پیکسل اریب: همانطور که مشخص است مقادیر 16 پیکسل اطراف را میانگین گرفته و پیکسل های خالی را پر میکنیم. این روش از همه دقیقتر و کندتر است(به دلیل محاسبات بیشتر).

حال میخواهیم تابعی در opencvکه این کار را انجام میدهد بیان کنیم:

Resize(image, dsize(output image size), x scale, y scale, interpolation)

1	Resize(image, dsize(output image size), x scale, y scale, interpolation)

آرگومان اول تصویر مورد نظر است.آرگومان بعدی سایز عکس خروجی ست و دو آرگومان بعدی مقدار یا درصد مقیاس گذاری را مشخص میکند.(مثلا اگر عدد ۲ را به هردو آنها پاس دهیم یعنی میخواهیم تصویر در راستای طول و عرض ۲ برابر شود) و آرگومان اخر روش مقیاس گذاری(که در بالا توضیح دادیم) را تعیین میکند.خروجی این تابع نیز تصویر scale شده میباشد.

توجه:اگر هم اندازه تصویر خروجی را پاس دهیم هم مقادیر مقیاس گذاری؛ تابع اندازه را بر عدد یا درصد مقیاس ترجیح داده و آن را عملی میکند.

در آخر مقایسه انواع روش های scaleرا باهم میبینیم:

دستکاری تصویر (1) – ماتریس‌های تبدیل

در دستکاری تصویر, یادداشت‌های کلاسی2018-02-24 عاطفه ولی‌پور

در جلسات قبل با مفهوم فضاهای رنگی آشنا شدیم و خواندیم که هر عکس رنگی از سه کانال رنگی (R,G,B) تشکیل شده است که هر کدام می توانند از صفر تا 255 مقدار بگیرند .

و اگر ما دستور image.shape را برای یک عکس رنگی چاپ کنیم خروجی اینچنین خواهد بود

(height,width,3)

که عدد 3 نشان دهنده ی وجود هر سه کانال رنگی قرمز، سبز و آبی است اما اگر عکس را در حالت سایه و سفید (gray scale) ببریم خروجی دستور تنها طول و عرض عکس خواهد بود و دیگر تنها یک کانال رنگی وجود دارد که به صورت باینری است و صفر نشان دهنده ی نبود رنگ و 1 بیش ترین مقدار وجود رنگ را نشان میدهد(صفر نشان دهنده رنگ سیاه و یک نشان دهنده ی رنگ سفید است).

حال اگر بخواهیم برای یک عکس رنگی از هریک از کانال هایش به صورت جداگانه خروجی بگیریم از دستورات زیر استفاده میکنیم:

zeros = np.zeros([height,width], dtype = "uint8") # zeros = np.zeros(image.shape[:2], dtype = "uint8")

red = cv2.merge([zeros, zeros, R])

green = cv2.merge([zeros, G, zeros])

blue = cv2.merge([B, zeros, zeros])

zeros = np.zeros([height,width], dtype = "uint8") # zeros = np.zeros(image.shape[:2], dtype = "uint8")

red = cv2.merge([zeros, zeros, R])

green = cv2.merge([zeros, G, zeros])

blue = cv2.merge([B, zeros, zeros])

که خروجی آن برای هر کانال به صورت زیر خواهد بود:

تا اینجای کار با مفاهیم اولیه ی open cv آشنا شدیم اکنون میخواهیم وارد مبحت image manipulations بشیم که لازمه ای این مبحث این هستش که یه دوره ی سریعی روی مباحث جبر خطی که عمدتا در هندسه تحلیلی عنوان شده داشته باشیم .

انواع روش های image manipulations یا دستکاری تصویر:

انتقال های همگن یا غیر همگن ( (Transformations, affine and non affine
تبدیلات (Translations)
Rotations (دوران)
Scaling, re-sizing and interpolations ( درون یابی یا interpolations به معنای این است که در هنگام تغییر سایز عکس پیکسل هایی که خالی میماند را با چه الگوریتمی میخواهیم پر کنیم.)
Image Pyramids

انتقال

Transformations ها کلا تبدیلات ماتریسی هستند که عموما به صورت ضرب دو ماتریس هستند که ماتریس سومی را به عنوان خروجی میدهند و به دو نوع کلی همگن یا غیر همگن تقسیم میشوند.

تبدیلات همگن

تبدیل همگن یا تبدیل آفین یا transformation Affine نوعی تبدیل ریاضی است که خطی بودن و نسبت فاصله ها در آن حفظ می شود.(خطوطی که موازی بودند پس از تبدیل هم حتما موازی باقی میمانند اما طول و زاویه ی بین خطوط لزوما حفظ نمیشود).

بدین ترتیب در نتیجه یک تبدیل همگن، تمامی نقاط روی یک خط در ورودی، در خروجی نیز روی یک خط خواهند ماند.

انتقال، تجانس، تشابه و چرخش نمونه هایی از تبدیل های همگن هستند.

نکته هر تبدیل خطی همگن هست اما هر تبدیل همگنی خطی نیست.

معرفی وکتور

یک بردار یک بعدی است. که دو نوع دارد وکتور ستونی و سطری:

1)وکتور ستونی 2) وکتور سطری

برخی از ویژگی هایی که وکتور در ریاضیات دارد مانند جهت بردار ممکن است در مفاهیم برنامه نویسی صدق نکند اما همچنان میتوانیم از برخی ویژگی هایش مانند محاسبه نرم اقلیدسی استفاده کنیم.

نحوه محاسبه نرم اقلیدسی:

اگر دو وکتور به نام های A,B داشته باشیم نرم اقلیدسی آن برابر است با

ماتریس

ماتریس همان بردار mxn است که در برنامه نویسی نیز همین معنا را دارد و یک عکس سیاه و سفید درواقع یک ماتریس است که به میزان عرض عکس سطر و ارتفاع آن ستون دارد و هر درایه نمایانگر یک پیکسل است که میتواند ازصفر تا 255 مقدار بگیرد.