Ի՞նչ կարելի է անել OpenCV-ով
Python-ում OpenCV գրադարանի ամենից հաճախ օգտագործվող և հիմնարար ֆունկցիաների ակնարկ։
Ի՞նչ է OpenCV-ն։ Պարզ ասած՝ պատկերների մշակման գրադարան է։
Այս մեկ նախադասությունը բավական է OpenCV-ն բնութագրելու համար, բայց գրադարանն իրականում շատ ավելին է առաջարկում։ Այն սկզբում գրվել է C++-ով՝ որպես պատկերների վրա գործողությունների համար շատ արագ, բաց կոդով համակարգչային տեսողության գրադարան։ Այսօր OpenCV-ն կարելի է օգտագործել նաև Python-ից և Java-ից, և այն տարածված է մեքենայական ուսուցման մեջ՝ նախամշակման և հետմշակման համար, ինչպես նաև համակարգչային տեսողության դասական ալգորիթմներում։ Դրա օգնությամբ կարելի է կարդալ, խմբագրել, փոխակերպել և պահպանել թվային պատկերներ, կիրառել մորֆոլոգիական և երկրաչափական ձևափոխություններ, և նույնիսկ հետևել օբյեկտների կամ առանձնացնել հատկանիշներ համակարգչային տեսողության դասական մեթոդներով։
Այս ձեռնարկում անցնում ենք OpenCV-ի ամենից հաճախ օգտագործվող և հիմնարար ֆունկցիաներով Python-ում։
Տեղադրում
venv-ով՝
pip install opencv-python
mamba միջավայրով՝
mamba install -c conda-forge opencv
poetry-ով՝
poetry add opencv-python
Ինչ գործիք էլ օգտագործեք, OpenCV-ի կոնկրետ տարբերակը կարող եք ամրագրել այսպես՝
opencv-python==4.6.0.66
Պատկերի բեռնումը և հիմնական մանիպուլյացիաները
Սկսենք պատկեր կարդալու, ցուցադրելու և ֆայլում գրելու հիմնական ֆունկցիաներից։ Ամբողջ ձեռնարկում աշխատելու ենք մի պատկերով, որը ճանաչում է համակարգչային տեսողությամբ զբաղվող յուրաքանչյուր մասնագետ՝ lenna.png։
import cv2
import numpy as np
import sys
# load the image
file_path: str = "lenna.png"
img: np.ndarray = cv2.imread(filename=file_path,flags=cv2.IMREAD_UNCHANGED)
# check whether image was correctly loaded
if img is None:
sys.exit(f"Could not read the image {file_path}.")
# display image and wait for keyboard input
cv2.imshow(winname="Display image", mat=img)
# wait for the user key press and hide the window
key = cv2.waitKey(delay=0)
# if the `s` was pressed save the image
if key == ord("s"):
cv2.imwrite(filename="lenna_out.png", img=img)
cv2.imread-ին փոխանցվող դրոշակները թույլ են տալիս պատկերը կարդալ տարբեր ռեժիմներով, օրինակ՝ IMREAD_UNCHANGED, IMREAD_GRAYSCALE, IMREAD_COLOR և այլն։ Ռեժիմների ամբողջական ցանկը հասանելի է cv2.ImreadModes էջում։
cv2.waitKey ֆունկցիան OpenCV-ի պատուհանում սպասում է x միլիվայրկյան, մինչև ստեղն սեղմվի։ Երբ delay պարամետրը 0 է, այն անվերջ սպասում է ստեղնաշարի մուտքին։ Դրա համար սովորաբար ընտրում են 0, քանի որ այդպես սպասում է մինչև օգտատիրոջ արձագանքը։ Եթե փոխանցեք որևէ այլ արժեք, պատուհանը կփակվի կամ այդ ժամանակը լրանալուց հետո, կամ ստեղն սեղմելիս՝ կախված նրանից, թե որն է առաջինը։
Հաջորդը կարող ենք կարդալ մեր պատկերի ձևը (shape)՝
h, w, c = img.shape
BGR ընդդեմ RGB
Հիշեք, որ OpenCV-ն թվային պատկերները լռելյայն բեռնում է BGR ձևաչափով։ Այսինքն՝ OpenCV-ի եռալիք զանգվածի առաջին ալիքը կարմիրը չէ, այլ կապույտը։ cv.imread ֆունկցիան սա հաշվի է առնում, և պատկերները ճիշտ են ցուցադրվում, բայց հենց փորձում ենք OpenCV-ով բեռնված պատկերը ցույց տալ matplotlib-ով, տեղի է ունենում մի տարօրինակ բան, ինչպես երևում է նկար 1-ի արդյունքում։
import matplotlib.pyplot as plt
import matplotlib.image as AxesImage
imgplot:AxesImage = plt.imshow(X=img)
plt.show()
Նկար 1. Lenna պատկերը BGR ձևաչափով։
Դա տեղի է ունենում, որովհետև կարմիր և կապույտ ալիքները լռելյայն տեղերով փոխված են։ Փոխարկումը կարելի է հետ շրջել cvtColor-ով։
rgb_image: np.ndarray = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2RGB)
Նկար 2. Lenna պատկերը RGB ձևաչափով։
Այժմ ամեն ինչ նորից ճիշտ է երևում։
OpenCV-ի պատկերների տեսակները
OpenCV-ի ամենապարզ պատկերի տեսակը np.uint8-ն է։ Սա 1 բայթանոց անստորագիր ամբողջ թիվ է, ուստի պահում է 0-ից մինչև 255 արժեքներ։ Մոխրագույն պատկերը մեկ պիքսելի համար օգտագործում է 1 բայթ, գունավորը՝ 3 բայթ, իսկ լրացուցիչ ալֆա ալիքով պատկերը՝ 4 բայթ։ Նկատի ունեցեք, որ jpg պատկերները երբեք ալֆա ալիք չեն ունենում, ուստի եթե ձեր պատկերին թափանցիկություն է պետք, ընտրեք png։
Լռելյայն OpenCV-ով բեռնված պատկերն ունի np.uint8 տեսակը՝
>>> print(img.dtype)
uint8
Նախքան թվային պատկերը նեյրոնային ցանցին փոխանցելը՝ այն պետք է փոխարկել float-ի, և սովորաբար նաև նորմալացնում են։ Հետևյալ կոդը դա անում է՝
normalized_img: np.ndarray = img.astype(np.float32)/255.0
կամ
normalized_img: np.ndarray = cv2.normalize(img.astype(np.float32), dst=None, alpha=1.0, beta=0.0, norm_type=cv2.NORM_INF
Պատկերը նորմալացնելու համար, որպեսզի նրա ամենափոքր արժեքը դառնա զրո, իսկ ամենամեծը՝ 1, կարող ենք գրել՝
float_img: np.ndarray = img.astype(np.float32)
normalized_img: np.ndarray = (float_img - np.min(float_img))/(np.max(float_img) - np.min(float_img))
կամ
normalized_img: np.ndarray = cv2.normalize(img.astype(np.float32), dst=None, alpha=1.0, beta=0.0, norm_type=cv2.NORM_MINMAX)
Այս դեպքում պատկերը հայտնվում է 0-1 միջակայքում։ Սակայն հաճախ ուզում ենք պատկերը նորմալացնել իր միջինի և ստանդարտ շեղման միջոցով։ Դա կարող են անել և՛ numpy-ը, և՛ OpenCV-ը՝
mean: tuple[float] = (0.485, 0.456, 0.406)
std: tuple[float] = (0.229, 0.224, 0.225)
float_img: np.ndarray = img.astype(np.float32)
normalized_img: np.ndarray = (float_img/255.0 - mean)/std
Դա կարելի է անել նաև անմիջապես խորը ուսուցման ֆրեյմվորքում, օրինակ՝ torchvision-ում։ Այս մոտեցումն ավելի լավն է, քանի որ սովորաբար օգտվում է GPU արագացումից։
import torch
from torchvision import transforms
transforms = torch.nn.Sequential(
transforms.Normalize(mean, std),
)
normalized_img: torch.tensor = transforms(torch.tensor(float_img/255.0).permute(2,0,1))
Վերադառնալով պատկերների տեսակներին՝ բժշկական պատկերները, օրինակ՝ ռենտգենյան նկարները, ինչպես նաև խորության պատկերները սովորաբար պահվում են որպես 16-բիթանոց մոխրագույն քարտեզներ։ Երբ այդպիսի պատկերը բեռնվում է հիշողության մեջ, այն ունենում է uint16 տեսակ՝ 0-65536 միջակայքի արժեքներով։
>>> import pydicom
>>> dicom = pydicom.read_file("./heart.DCM")
>>> data = dicom.pixel_array
>>> print(data.dtype)
uint16
Նման պատկերը ցուցադրելու համար պետք է այն փոխարկել uint8-ի։
normalized_img: np.ndarray = cv2.normalize(data.astype(np.float32), dst=None, alpha=256.0, beta=0.0, norm_type=cv2.NORM_INF).astype(np.uint8)
cv2.imshow("dicom_image", np.transpose(normalized_img[:3],(1,2,0)))
cv2.waitKey(0)
Նկար 3. 16 բիթով պահված dicom պատկերի ցուցադրում։ Ծնկի ՄՌՏ սկանավորման մեկ հարթություն։ Աղբյուր՝ Figshare
Վերջին տեսակը, որն երբեմն օգտագործվում է երկուական դիմակներ պահելու համար, bool-ն է։
h, w, c = img.shape
mask: np.ndarray = np.ones_like(a=img,dtype=bool)
mask[h//2-20:h//2+20,w//2-20:w//2+20] = 0
img *= mask
cv2.imshow(winname="masked_image",mat=img)
cv2.waitKey(delay=0)
Նկար 4. Lenna պատկերը երկուական դիմակի կիրառումից հետո։
Պատկերների հիմնական գործողությունները և պատկերների մշակումը
Պատկերի հիստոգրամ
Հիստոգրամը ցույց է տալիս պատկերի ինտենսիվությունների բաշխումը։ Պիքսելի յուրաքանչյուր հնարավոր արժեքի համար այն հաշվում է, թե քանի պիքսել ունի այդ ինտենսիվությունը։ uint8-ի համար հնարավոր արժեքները 0-255 են։ Հիստոգրամը բացահայտում է պատկերի օգտակար հատկություններ, ինչպիսիք են ինտենսիվության բաշխումը, կոնտրաստը և պայծառությունը։ Քանի որ հիստոգրամը կարելի է կառուցել միայն միալիք (մոխրագույն) պատկերի համար, մի քանի ալիքով պատկերը պահանջում է առանձին հիստոգրամ յուրաքանչյուր ալիքի համար։
colors: tuple[str] = ('b','g','r')
for i,color in enumerate(colors):
histogram: np.ndarray = cv2.calcHist(images=[img], channels=[i], mask=None, histSize=[256], ranges=[0,256])
plt.plot(histogram, color=color)
plt.xlim([0,256])
plt.show()
Նկար 5. Lenna պատկերի հիստոգրամը։
Հիստոգրամը ցույց է տալիս, որ Lena պատկերը պարունակում է շատ բարձր ինտենսիվության կարմիր պիքսելներ։ Սա համապատասխանում է մեր տեսածին, քանի որ պատկերն իսկապես կարմրավուն է։
Հիստոգրամի հավասարեցում
Հիստոգրամի հավասարեցումը ձգում է հիստոգրամը՝ պատկերի կոնտրաստը մեծացնելու համար։ Երբ պիքսելները ընկնում են ինտենսիվության միջակայքի միայն ստորին կեսում (0-127) կամ միայն վերին մասում (128-255), կոնտրաստը ցածր է, որովհետև բոլոր պիքսելները նման ինտենսիվություն ունեն։ Հիստոգրամը հավասարեցնելուց հետո պատկերի պիքսելները ընդգրկում են ինտենսիվության բոլոր հասանելի մակարդակները, ինչը բարձրացնում է կոնտրաստը։
Նկար 6. Հիստոգրամի հավասարեցումը՝ կիրառված Lenna պատկերի վրա։
equalized_channels: np.ndarray = [cv2.equalizeHist(src=img[:,:,channel]) for channel in range(img.shape[2])]
equalized_img: np.ndarray = np.concatenate(np.expand_dims(equalized_channels, axis=3), axis=2)
colors: tuple[str] = ('r','g','b')
fig = plt.figure()
ax1 = fig.add_subplot(221)
ax2 = fig.add_subplot(222)
ax3 = fig.add_subplot(223)
ax4 = fig.add_subplot(224)
ax1.title.set_text('Original histogram')
ax2.title.set_text('Equalized histogram')
ax3.title.set_text('Original image')
ax4.title.set_text('Equalized image')
plt.subplot(2,2,4)
rgb_equalized_img: np.ndarray = cv2.cvtColor(src=equalized_img, code=cv2.COLOR_BGR2RGB)
plt.imshow(rgb_equalized_img)
plt.subplot(2,2,2)
image_histogram(img=rgb_equalized_img, colors=colors)
plt.subplot(2,2,3)
rgb_img: np.ndarray = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2RGB)
plt.imshow(rgb_img)
plt.subplot(2,2,1)
image_histogram(img=rgb_img, colors=colors)
plt.show()
Կոնտրաստի և պայծառության կարգավորում
Պայծառություն
Պայծառությունը փոխել նշանակում է ամբողջ պատկերին պարզապես հաստատուն գումարել կամ դրանից հանել։ Սա համապատասխանում է հիստոգրամի տեղաշարժին ձախ կամ աջ, ընդ որում արժեքները կտրվում են 255-ով կամ 0-ով՝ կախված տեղաշարժի ուղղությունից։
shift: np.ndarray = np.array([0,0,-40], dtype=int)
img = img.astype(int)
img += shift
img = np.clip(a=img, a_min=0, a_max=255)
img = img.astype(np.uint8)
for i, color in enumerate(colors):
histogram: np.ndarray = cv2.calcHist(images=[img], channels=[i], mask=None, histSize=[256], ranges=[0,256])
plt.plot(histogram, color=color)
plt.xlim([0,256])
rgb_image: np.ndarray = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2RGB)
plt.subplot(2,2,2)
plt.imshow(rgb_image)
plt.show()
Նկար 7. Պայծառության կարգավորումը՝ կիրառված Lenna պատկերի վրա։
Նկար 7-ը ցույց է տալիս, որ կարմիր ալիքներից constant = 20 հանելը ամբողջ հիստոգրամը տեղափոխում է ձախ, ուստի պատկերը ավելի քիչ կարմիր է թվում։ Եթե փոխարենը տեղաշարժենք յուրաքանչյուր պիքսել, կստանանք պայծառության կարգավորման էֆեկտը։
Պայծառության կարգավորումը պահանջում է նախապես պատկերը փոխարկել int64-ի, քանի որ uint8 արժեքների պարզ տեղաշարժը կհանգեցներ արժեքների «պտտման» (wrap around)։
Կոնտրաստ
Կոնտրաստը կարգավորելը հավասարազոր է հիստոգրամը մասշտաբավորելուն, այսինքն՝ արժեքները բազմապատկելուն։
scale: np.ndarray = np.array([1.4, 1.4, 1.0], dtype=float)
img = img.astype(float)
img *= scale
img = np.clip(a=img, a_min=0, a_max=255)
img = img.astype(np.uint8)
for i, color in enumerate(colors):
histogram: np.ndarray = cv2.calcHist(images=[img], channels=[i], mask=None, histSize=[256], ranges=[0,256])
plt.plot(histogram, color=color)
plt.xlim([0,256])
rgb_image: np.ndarray = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2RGB)
plt.subplot(2,2,2)
plt.imshow(rgb_image)
plt.show()
Նկար 8. Կոնտրաստի կարգավորումը՝ կիրառված Lenna պատկերի վրա։
Գամմա-ուղղում
Գամմա-ուղղումը պատկերի պայծառությունը կարգավորում է ոչ գծային եղանակով։
Այն լուսավորում է պատկերի մութ հատվածները՝ առանց մնացած մասը հագեցնելու։ Սա հատկապես օգտակար է վատ լուսավորության պայմաններում արված լուսանկարների համար, ինչպիսին ներքևում ցուցադրվածն է։
def image_histogram(img: np.ndarray,colors: tuple[str]) -> None:
for i, color in enumerate(colors):
histogram: np.ndarray = cv2.calcHist(images=[img], channels=[i], mask=None, histSize=[256], ranges=[0,256])
plt.plot(histogram, color=color)
plt.xlim([0,256])
colors: tuple[str] = ('b','g','r')
plt.subplot(2,2,3)
plt.imshow(img)
plt.subplot(2,2,1)
image_histogram(img=img, colors=colors)
# gamma correction
plt.subplot(2,2,2)
gamma: float = 0.4
img = img.astype(float)
img = np.clip(pow(img / 255.0, gamma) * 255.0, 0, 255)
img = np.clip(a=img, a_min=0, a_max=255)
img = img.astype(np.uint8)
image_histogram(img=img, colors=colors)
rgb_image: np.ndarray = cv2.cvtColor(src=img, code=cv2.COLOR_BGR2RGB)
plt.subplot(2,2,4)
plt.imshow(rgb_image)
plt.show()
Նկար 9. Գամմա-ուղղումը՝ կիրառված անհավասար պայծառությամբ պատկերի վրա։ Աղբյուր՝ Canon
Գամմա-ուղղմամբ ամբողջ պատկերը դառնում է ավելի պայծառ, բայց ոչ մի տարածք չի հագեցվում։ Արդյունքը ցույց է տալիս նկար 9-ը։
OpenCV-ը համակարգչային տեսողության կիրառություններում
OpenCV-ը լավագույնս աշխատում է պատկերների նախա- և հետմշակման, ինչպես նաև համակարգչային տեսողության դասական խնդիրների համար։ Ստորև համառոտ դիտարկում ենք OpenCV-ով ուղղանկյուններ հայտնաբերելը։
Սկսում ենք երկու ուղղանկյուն պարունակող պատկերից։
Նկար 10. Ուղղանկյունների հայտնաբերման խնդրի համար օգտագործված խաղաթղթերի պատկերը։ Աղբյուր՝ Sostrenegrene
Առաջին քայլը պատկերը մոխրագույն ռեժիմով կարդալն է։ Սա կարևոր է, որովհետև շեմավորման (thresholding) գործողությունը, որը պատրաստվում ենք օգտագործել, աշխատում է միայն միալիք պատկերների վրա։
# load the image in grayscale
file_path: str = "./cards.png"
img: np.ndarray = cv2.imread(filename=file_path, flags=cv2.IMREAD_GRAYSCALE)
Շեմավորումից առաջ պատկերը պետք է թեթևակի աղոտել։ Սա հեռացնում է աղմուկը և շեմավորման ավելի հարթ արդյունք է տալիս։
img = cv2.medianBlur(src=img, ksize=5)
Այստեղ օգտագործում ենք ադապտիվ շեմավորում։ Նկար 10-ը ստվեր է պարունակում, և ադապտիվ շեմավորումն օգնում է փոխհատուցել պատկերի տարբեր շրջաններում անհավասար պայծառությունը։
thresholded_image: np.ndarray = cv2.adaptiveThreshold(
src=img,
maxValue=255,
adaptiveMethod=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
thresholdType=cv2.THRESH_BINARY,
blockSize=11,
C=2,
)
Միայն շեմավորումն արդեն տալիս է բավական լավ եզրագծեր, ինչպես ցույց է տալիս նկար 11-ը։
Նկար 11. Խաղաթղթերը ադապտիվ գաուսյան շեմավորումից հետո։
Այնուամենայնիվ, հաջորդ քայլից՝ եզրագծերի հայտնաբերումից, առաջ ուզում ենք հեռացնել աղմուկը։ Դրա համար շեմավորված պատկերի վրա կիրառում ենք մորֆոլոգիական բացում։
kernel5x5: np.ndarray = np.ones(shape=(5,5), dtype=np.uint8)
opened_image: np.ndarray = cv2.morphologyEx(
src=thresholded_image,
op=cv2.MORPH_OPEN,
kernel=kernel5x5,
)
Նկար 12. Խաղաթղթերը բացման գործողությունից հետո։
Լավ է։ Արդյունքն այժմ որոշ չափով ավելի մաքուր է, ուստի կարող ենք անցնել եզրագծերի հայտնաբերմանը։
contours, hierarchy = cv2.findContours(
image=opened_image,
mode=cv2.RETR_LIST,
method=cv2.CHAIN_APPROX_TC89_L1,
)
Երբ ունենք նկար 12-ի եզրագծերը, անցնում ենք դրանց ֆիլտրմանը։ Ուզում ենք թողնել միայն ուղղանկյունի և քառակուսու ձև ունեցող եզրագծերը։ Նախ սահմանում ենք MIN_ALLOWED_AREA, որը դեն է նետում բոլոր չափազանց փոքր եզրագծերը (պատկերի աղմուկը)։ Այնուհետև եզրագծերը մեկ առ մեկ անցնելով՝ հաշվում ենք դրանցից յուրաքանչյուրի նվազագույն պարփակող ուղղանկյունը։ Հետո հաշվում ենք եզրագծի մակերեսը և համեմատում երկու մակերեսները։ Երբ դրանք մոտ են, եզրագիծը կարող է ուղղանկյուն լինել, ուստի պատկերի վրա այն նշում ենք ուղղանկյունով և պիտակով։ Ամբողջական կոդը ստորև է։
Նկար 13-ը ցույց է տալիս վերջնական արդյունքը։ Մեր փնտրած բոլոր ուղղանկյունները ճիշտ են հայտնաբերվել։
Նկար 13. Ուղղանկյունների հայտնաբերման խնդրի վերջնական արդյունքը։
# load the image in grayscale
file_path: str = "./cards.png"
img: np.ndarray = cv2.imread(filename=file_path, flags=cv2.IMREAD_GRAYSCALE)
# check whether image was correctly loaded
if img is None:
sys.exit(f"Could not read the image {file_path}.")
img = cv2.medianBlur(src=img, ksize=5)
thresholded_image: np.ndarray = cv2.adaptiveThreshold(
src=img,
maxValue=255,
adaptiveMethod=cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
thresholdType=cv2.THRESH_BINARY,
blockSize=11,
C=2,
)
kernel5x5: np.ndarray = np.ones(shape=(5,5), dtype=np.uint8)
opened_image: np.ndarray = cv2.morphologyEx(
src=thresholded_image,
op=cv2.MORPH_OPEN,
kernel=kernel5x5,
)
contours, hierarchy = cv2.findContours(
image=opened_image,
mode=cv2.RETR_LIST,
method=cv2.CHAIN_APPROX_TC89_L1,
)
h, w = img.shape
MIN_ALLOWED_AREA: Final[float] = 0.1*h*w
for cnt in contours:
rect: np.ndarray = cv2.minAreaRect(points=cnt)
box: np.ndarray = cv2.boxPoints(box=rect)
box = np.int0(box)
box_area: float = cv2.contourArea(contour=box)
area: float = cv2.contourArea(contour=cnt)
if box_area 0 or area 0:
continue
areas_ratio: float = (min(area, box_area)/max(area, box_area))
if area > MIN_ALLOWED_AREA and areas_ratio < 1.2 and areas_ratio > 0.8:
x1, y1 = cnt[0][0]
# label rectangle detected on the image
cv2.putText(img, 'Rectangle', (x1, y1), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 255, 0), 2)
sorted_bbox: np.ndarray = box[np.argsort(np.linalg.norm(box, axis=1))]
# corners are in order bottom left, bottom right or top left, top left or bottom right, top right
# to be in the drawing order last two corners need to switch places
sorted_bbox_tmp: np.ndarray = sorted_bbox[2].copy()
sorted_bbox[2] = sorted_bbox[3]
sorted_bbox[3] = sorted_bbox_tmp
# draw detected rectangle on the image
img = cv2.drawContours(
image=img,
contours=[sorted_bbox],
contourIdx=-1,
color=(0,255,0),
thickness=3,
)
cv2.imshow(winname="result", mat=img)
cv2.waitKey(delay=0)
Ամփոփում
Համակարգչային տեսողության դասական խնդիրների և պատկերների մշակման համար OpenCV-ը հիանալի գրադարան է։ Նրա հիմնական ուժեղ կողմերը արագությունը, մի քանի լեզվի աջակցությունը և պատկերների մշակման ֆունկցիաների լայն շրջանակն են։ Այս մեծ բաց կոդով գրադարանը սկզբում կառուցվել է c++-ով, և c++-ից ժառանգած որոշ իրականացման ընտրություններ դեռ տեսանելի են և՛ python-ում, և՛ java-ում։ Մինչ նեյրոնային ցանցերի գերիշխանությունը այն նաև առաջատար գրադարաններից էր համակարգչային տեսողության այնպիսի խնդիրներ լուծելու համար, ինչպիսիք են տեքստի հայտնաբերումը, օբյեկտների հայտնաբերումը, օբյեկտների դասակարգումը, օբյեկտների ճանաչումը, հատկանիշների առանձնացումը, դեմքերի հայտնաբերումը, պատկերի սեգմենտավորումը, շարժման հետևումը և օբյեկտների հետևումը։ Իմ կարծիքով՝ OpenCV-ը հիանալի ուղեկից է նեյրոնային ցանցերի համար մուտքային պատկերները մշակելիս, օրինակ՝ պատկերների ֆիլտրման կամ տեսախցիկի կալիբրացիայի համար։