‫‪Simply OpenCv‬‬

‫طريقك حنو تعلم الرؤية احلاسوبية‬
‫ومعاجلة الصورة الرقمية‬
‫‪Computer Vision‬‬
1 ‫ ببساطة‬OpenCv
‫‪2‬‬ ‫‪ OpenCv‬ببساطة‬

‫ُسخصخُامكربة ُ‬
‫امنعخخُاإلمكرتونٌخُمنُامكربةُتصٌغخُ‪ُPDF‬منشىسحُذؽزُسخصخُاإلتذاعُاملشبغٍُا ُإلصذاسحُامشاتػخُ‬
‫‪ُCreative Common v4‬ذؽزُرشوغ‪ُ:‬امنعثخُ–ُاملشبسكخُتبملصهُ–ُغذوُاإلظرغاللُامرعبسي‪ُ .‬‬

‫‪ .1‬سخصخُاملشبعُاإلتذاغٍ‪(ُ CC-NC-‬امغريُذعبسًخ)‪ً :‬ى هدمٍ خًلم يف نٔى وطىًِو وطهًًٍ ؤو‬
‫خإلغدفص ؤو كظى ؾزدنص خًوظدذ وَكٌدً هٌل طشدء ٌسؽ نًَ خٓظًالي خًوظدذ طـدًَدً رإي ضىَش‬
‫فدًوظدذ مـدين متدمدً وًـس ؤن ًكٍ هًٍى‪.‬‬

‫‪ .2‬امنعثخُ‪ً :BY -‬ـس ننً نٍس ؤو طهًًٍ خًوظدذ يون ٌهُ خملاًف وخملطًَ خألضًل‪.‬‬

‫‪ .3‬املشبسكخُتبملصه‪ :SA-‬بٌخ طم خشظلدق ؤي نمٍ من هٍخ خًوظدذ مؼٍ نمٍ هظدذ خهُ ؤو ملدٌصش‬
‫طهٌٌمٌص ؤو فًًٌى فٌـس ؤن ًظم نٍسهد رنفٕ خًُهطص (خملشدم خإلرًخنٍ خًنٔزص‪ ،‬خملشدَهص‬
‫ردملؼٍ‪ ،‬خًًًن طـدًَص)‪.‬‬
‫ُ‬
‫شكشاًُمنمعبهمنيُيفُمشاظػخُامكربة ُ‬
‫و‪ُ.‬غثذهيُغًل‪ُ،‬و‪ُ.‬غثذهيُغبدل‪ُ،‬و‪.‬نىسهبنُغالء ُ‬

‫ًٌظىخضٍ مو خملاًف‬
‫‪Khaleddobosh544@gmail.com‬‬
‫‪LinkedIn‬كٔدذ‬
‫‪http://www.linkedin.com/in/khaled-aldobosh‬‬

‫هدًً خًًرش‬
‫‪ 8341‬هـ خملىخفم ‪َ 7182‬‬
3 ‫ ببساطة‬OpenCv
‫‪4‬‬ ‫‪ OpenCv‬ببساطة‬

‫ملذمخُامكبذج ُ‬
‫بسم الله الرحمن الرحيم‬

‫خًلمً هلل َذ خًهدملٍن‪ ،‬رهً مُوَ ؤهًت من ‪ 8‬ؤشهُ من خًهمٍ خملٔظمُ إلنًخي هٍخ خًوظدذ خنظهٌع‬
‫من هظدرظه وقهُ هٌل طُخه رهٍخ خًظنٌٔم خًٍي خٓظًُق من وكظٍ وؿهًي خًوؼًن‪ .‬خًوظدذ ًٌٕ‬
‫طُؿمص كُفٌص ًوظدذ آهُ وبمند من طإًٌفٍ‪ ،‬كٌؽ خنظمًض نىل مُؿو َثًٌس يف خًوظدرص وهى خًًنم‬
‫خًٍي طلًمه موظزص ‪ opencv‬وخملىؿىي نىل مىكههد‪ ،‬وخًهًًً من خملُخؿو وخملىخكو خآلهُي‪.‬‬

‫ظمٌؼُاألكىادُامرٍُيفُامكربةُذمُذؼثٌلهبُوذعشًثهبُتشكهُغمًل ُ‬

‫ؤيٌس خملُخؿو خألؿنزٌص خًظٍ كُؤطهد ًظهٌم خًُئًص خًلدٓىرٌص ردٓظوًخَ موظزص ‪ opencv‬ال طهظم‬
‫رٍسق خًوىي بال ؿّء ًًٔن منه ؤو كً ال ًظم خًظؿُق ًٌٍسق ؤرًخ ًٍخ خٓظؼمُض خًوؼًن من خًىكع‬
‫ًفهم خًوىي وٌسكه ًٌلدَت فلً هدنع هربيت رًٌص ردًؼىن ضفُ ؤمد خآلن وهلل خًلمً فإطلنع ًًص‬
‫ردًؼىن‪.‬‬

‫يف خملُخؿو خألؿنزٌص ًوىن هندن خفرتخع مٔزم روربطى يف ًًص خًربمـص ردًؼىن‪ ،‬ؤمد يف هٍخ‬
‫خًوظدذ فدنظربض ؤن خًلدَت ال ًهٌم شٌح نن خًًٌص ًٍخ رًؤض مهه من خًطفُ ردٓظؼندء ؤن ًوىن ًًًه‬
‫مهُفص وًى ضًًنش ردًربمـص هظهٌٌمص ‪ if‬و‪ else if‬و‪ for‬و‪.while‬‬

‫هٍ فلُش فٌهد ملًمص نكًُص وؿدنس نمًل فةٌخ خٓظطهس نٌٌى فهم خمللًمص خًنكًُص ًٌفلُش فال‬
‫طلٌم فإيٌس خمللًمدض خًنكًُص ٌنونى طوؿٌهد يون فهمهد كٌؽ ٌنونى خالنظلدي ًٌـدنس خًهمًل‬
‫وطؿزٌم خًوىي رشوٍ مزدٌس‪.‬‬

‫يف خًزًخًص ٓإٌسق ؤٓدٌٓدض مهدًـص خًطىَش خًظٍ ٓظٔدنًند يف رًخًص خالنؿالق مبـدي خًُئًص‬
‫خًلدٓىرٌص‪ ،‬ورهً ًٌى ٓإٌسق ؤٓدٌٓدض ًًص خًزدًؼىن‪ ،‬رهً ًٌى ٌنونى خًزًء رظهٌم خٓظوًخَ‬
‫موظزص ‪( OpenCv‬خملوظزص خًربمـٌص خملفظىكص ًٌُئًص خًلدٓىرٌص)‪.‬‬
‫‪5‬‬ ‫‪ OpenCv‬ببساطة‬

‫بهذاء‬
‫بىل ام ّشؼمخ املهذاحُ منػبملني‪ُ ..‬‬
‫بىل امصبدقُ امىغذُ األمني‪..‬‬
‫بىل امزي ذشربقُ مشئًرهُ امػٌىن‪..‬‬
‫بىل من تبمعنخ مػه ؤمتنى ؤن ؤكىن‪..‬‬
‫ظٌذنب مؽمذ صىل هي غنٌهُوظنم‬

‫بىل غبصمخُ امصربُ وؤًىةُ هزا امػرص‪..‬‬
‫بىل منهمٍ ونبصؽٍ يف كه ؤمش‪..‬‬
‫بىل من غنّمنٍ امصثبد يفُ َمشُ املؽن‪..‬‬
‫ؤيب امغبيل‬

‫بىل صبؼثخُ املنجُ امذافئُ‪..‬‬
‫بىل نثؼُ امؽنبنُ ومفربػُ امعنبن‪..‬‬
‫ؤنهه منهب امصرب واألمبن‪..‬‬
‫بىل من ُ‬
‫سيب امغفشان‪..‬‬
‫بىل من ؤسظى تهب من ّ ُ‬
‫وامذيت امغبمٌخ‬

‫بىل امنعىو امرٍ ؤنبسد ظنمخ وؼذيت‪..‬‬
‫بىل من تبمرثعم ؤػنلىا طؽكرٍ‪..‬‬
‫بىل امزًن ؼني ؤسي اترعبمرهم ذكىنُ ظػبديت‪..‬‬
‫بىل من تهم ًشرذ ؤصسي وتهم ذنعًل وؼذيت‪..‬‬
‫بخىيت وؤخىايت‬

‫ؤمظٌز مػهم ؤؼىل مؽظبدُ امؽٌبح‪..‬‬
‫ُ‬ ‫بىل من‬
‫بىل من يل مػهم ؤظمه امزكشًبد‪..‬‬
‫بىل من ركشهم يف املنجُ مىظىد‪..‬‬
‫بىل من كذسهم غنذي مٌغ مه ؼذود‪..‬‬
‫ؤصذكبيئُُُ‬
‫‪6‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفهشط ُ‬

‫‪7‬‬ ‫ىظؼ‬
‫امفهشطُامل َ‬
‫‪15‬‬ ‫امشئًخُامؽبظىتٌخُ‪COMPUTER VISION‬‬
‫‪21‬‬ ‫ؤظبظٌبد مػبمعخُامصىسحُ‪IMAGE PROCESSING‬‬
‫‪25‬‬ ‫ػشًلخُذصثٌزُمكرثخُ‪OPENCV‬‬
‫‪33‬‬ ‫ملذمخُغنُمغخُتبًصىن‬
‫‪34‬‬ ‫ؤظبظٌبدُمغخُ‪PYTHON‬‬
‫‪39‬‬ ‫مٌضادُامىاظهخُامشظىمٌخُ‪ُGUI‬يفُ‪OPENCV‬‬
‫‪44‬‬ ‫امفصهُاألول‪ُ:‬مٌضادُامىاظهخُامشظىمٌخُ‪ُGUI‬يفُ‪OPENCV‬‬
‫‪68‬‬ ‫امفصهُامصبين‪ُ:‬امػمنٌبدُاألظبظٌخُغىلُامصىس‬
‫‪91‬‬ ‫امفصهُامصبمض‪ُ:‬مػبمعخُامصىسحُيفُ‪OPENCV‬‬
‫‪194‬‬ ‫امفصهُامشاتؼ‪ُ:‬اإلػبسادُيفُ‪OPENCV‬‬
‫‪216‬‬ ‫امفصهُامخبمغ‪ُ:‬املخؼؼبدُامثٌبنٌخُيفُ‪OPENCV‬‬
‫‪242‬‬ ‫امفصهُامعبدط‪ُ:‬ذؽىًالدُامصىسحُيفُ‪OPENCV‬‬
‫امفصهُامعبتؼ‪ُ:‬مٌضحُامكشفُوامىصفُ‪255 FEATURE DETECTION AND DESCRIPTION‬‬
‫‪349‬‬ ‫امفصهُامصبمن‪ُ:‬ذؽنٌهُامفٌذًىُ‪VIDEO ANALYSIS‬‬
‫‪338‬‬ ‫امفصهُامربظؼ‪ُ:‬اكرشبفُاألظعبوُ‪OBJECT DETECTION‬‬
‫‪353‬‬ ‫ذؼثٌلبدُغمنٌخ‬
‫‪354‬‬ ‫املشاظؼُامشئٌعٌخ‬
‫‪7‬‬ ‫‪ OpenCv‬ببساطة‬

‫ىظؼ‬
‫امفهشطُاملُ َُ‬
‫ُ‬
‫‪4‬‬ ‫ملذمخُامكبذج‬
‫‪6‬‬ ‫امفهشط‬
‫‪7‬‬ ‫امفهشطُاملىظؼ‬
‫‪15‬‬ ‫امشئًخُامؽبظىتٌخُ‪COMPUTER VISION‬‬
‫‪15‬‬ ‫مب هٍ امشئًخُامؽبظىتٌخ‬
‫‪15‬‬ ‫ذؼثٌلبدُامشئًخُامؽبظىتٌخ‬
‫‪17‬‬ ‫املهبوُامشئٌعٌخُمنشئًخُامؽبظىتٌخ‪:‬‬
‫‪18‬‬ ‫امكبمرياُامشكمٌخ‪DIGITAL CAMERA‬‬
‫‪88‬‬ ‫ملدَنص رٍن ؤيخيت خًظطىًُ ٌخض خًوُؾ خًظشدرهٍ وخًوُؾ خًُكمٍ‬
‫‪18‬‬ ‫مػبمعخ امصىسح امشكمٌخُ‪DIGITAL IMAGE PROCESSING‬‬
‫‪19‬‬ ‫مكرثخُ‪OPENCV‬‬
‫‪19‬‬ ‫مؽرىتبد مكرثخُ‪OPENCV‬‬
‫‪24‬‬ ‫ذؼثٌلبدُ‪OPENCV‬‬
‫‪24‬‬ ‫مغبدُامربمعخُيفُ‪OPENCV‬‬
‫‪21‬‬ ‫ؤظبظٌبد مرػنمُمػبمعخُامصىسحُ‪IMAGE PROCESSING‬‬
‫‪25‬‬ ‫ػشًلخُذصثٌزُمكرثخُ‪OPENCV‬‬
‫‪25‬‬ ‫ػشًلخُذصثٌزُمكرثخُ‪ُOPENCV‬غىلُنظبوُ‪WINDOWS‬‬
‫‪28‬‬ ‫ػشًلخُذصثٌزُمكرثخُ‪ُOPENCV‬غىلُنظبوُامرشغٌهُ‪UBUNTU‬‬
‫‪32‬‬ ‫ػشًلخُذصثٌزُمكرثخُ‪ُOPENCV‬غىلُامشاظثرييُتبي‬
‫‪33‬‬ ‫ملذمخُغنُمغخُتبًصىن‬
‫‪43‬‬ ‫ممٌّخض ًًص ردًؼىن‬
‫‪34‬‬ ‫ؤظبظٌبدُمغخُ‪PYTHON‬‬
‫‪8‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪34‬‬ ‫مفرسُتبًصىنُامرفبغًل‬
‫‪36‬‬ ‫امػمنٌبدُاألظبظٌخ‬
‫‪37‬‬ ‫ؼفظُامربنبمغُيفُظكشتز‬
‫‪44‬‬ ‫امفصهُاأل ُول‪ُ:‬مٌضادُامىاظهخُامشظىمٌخُ‪ُGUI‬يفُ‪OPENCV‬‬
‫‪41‬‬ ‫ػشًلخُغشضُصىسحُوؼفظهب‬
‫‪41‬‬ ‫ذػنمُكشاءحُامصىسحُوغشطهبُوؼفظهبُغنُػشًمُامرىاتؼُامربمٌخ‬
‫‪34‬‬ ‫كُخءش ونُع خًطىَش‬
‫‪47‬‬ ‫امرلبغُامفٌذًىُمنُامكبمريا‬
‫‪49‬‬ ‫ذشغٌهُامفٌذًىُمنُمنف‬
‫‪54‬‬ ‫ذىاتؼُامشظم‬
‫‪05‬‬ ‫َٓم هـ‬
‫‪08‬‬ ‫َٓم مٔظؿٌٍ‬
‫‪03‬‬ ‫َٓم يخثُش‬
‫‪00‬‬ ‫َٓم كؿو ندكظ‬
‫‪05‬‬ ‫َٓم مػٌو‬
‫‪05‬‬ ‫بغدفص نظ ًٌطىَش‬
‫‪58‬‬ ‫ؤؼذاسُامفإسح‬
‫‪64‬‬ ‫رشًؽُامرمشًشُامعبنثٍ‬
‫‪68‬‬ ‫امفصهُامصبين‪ُ:‬امػمنٌبدُاألظبظٌخُغىلُامصىس‬
‫‪71‬‬ ‫خصبئصُامصىسح‬
‫‪72‬‬ ‫املنؼلخُاملهمخُيفُامصىسحُ(‪)IMAGE ROI‬‬
‫‪74‬‬ ‫فصهُودمغُكنىادُامصىسح‬
‫‪75‬‬ ‫بنشبءُؼذودُمنصىسح‬
‫‪77‬‬ ‫امػمنٌبدُامعربًخُغىلُامصىس‬
‫‪77‬‬ ‫ؿمو خًطىَ‬
‫‪78‬‬ ‫يمف خًطىَ‬
‫‪79‬‬ ‫خًهمٌٌدض نىل مٔظىي خًزع‪(BITWISE OPERATIONS( :‬‬
‫‪84‬‬ ‫ذلنٌبدُكٌبطُاألداءُوذؽعٌنه‬
‫‪9‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪83‬‬ ‫كٌدْ خأليخء نن ؾًُم موظزص ‪OPENCV‬‬
‫‪80‬‬ ‫خًلٍ خملؼديل خالفرتخيض يف ‪OPENCV‬‬
‫‪85‬‬ ‫كٌدْ خأليخء يف ‪IPYTHON‬‬
‫‪88‬‬ ‫خًوؿىخض خًظٍ ًـس خطزدنهد ًٌلطىي نىل خأليخء خملؼديل‬
‫‪91‬‬ ‫امفصهُامصبمض‪ُ:‬مػبمعخُامصىسحُيفُ‪OPENCV‬‬
‫‪93‬‬ ‫ذغٌريُامفظبءادُامنىنٌخُ‪CHANGING COLOR SPACES‬‬
‫‪94‬‬ ‫طًًٌن خًفػديئ خًٌىين‬
‫‪93‬‬ ‫طهلس خألؿٔدَ‬
‫‪98‬‬ ‫هٌف ٌنونند بًـدي خًلٌمص خًٌىنٌص خملؿٌىذ طهلزهد يف خًفػدء ‪HSV‬؟‬
‫‪99‬‬ ‫ذػرٌجُامصىسحُُُ‪IMAGE THRESHOLDING‬‬
‫‪99‬‬ ‫خًظهظٌس خًزٌٔـ (‪(SIMPLE THRESHOLDING‬‬
‫‪854‬‬ ‫خًظهظٌس خملظوٌف (‪(ADAPTIVE THRESHOLDING‬‬
‫‪855‬‬ ‫خًظلىًٍ خًؼنديئ ال وطٔى (‪(OTSU’S BINARIZATION‬‬
‫‪114‬‬ ‫امرؽىًالدُامهنذظٌخُغىلُامصىسح‬
‫‪888‬‬ ‫خًظلـٌم ‪SCALING‬‬
‫‪888‬‬ ‫خًنلٍ ‪TRANSLATION‬‬
‫‪884‬‬ ‫خًظًوًُ ‪ROTATION‬‬
‫‪880‬‬ ‫طلىًٍ ؤفٌنٍ ‪AFFINE TRANSFORMATION‬‬
‫‪887‬‬ ‫خًظلىًٍ خملنكىَي )‪)PERSPECTIVE TRANSFORMATION‬‬
‫‪119‬‬ ‫ذهزًجُامصىسحُُُ)‪)SMOOTHING IMAGES‬‬
‫‪845‬‬ ‫خًؿٍ ػنديئ خًزهً _ طُشٌم خًطىَ‬
‫‪844‬‬ ‫خملُشم خملظىٓـ (‪)AVERAGING‬‬
‫‪843‬‬ ‫خملُشم خًًإويس (‪)GAUSSIAN FILTERING‬‬
‫‪840‬‬ ‫خملُشم خألوٓؿٍ (‪)MEDIAN FILTERING‬‬
‫‪847‬‬ ‫خملُشم خًؼنديئ خًـدنزٍ (‪)BILATERAL FILTERING‬‬
‫‪129‬‬ ‫امرؽىًالدُمنُامنبؼٌخُامشكنٌخُ(‪)MORPHOLOGICAL TRANSFORMATIONS‬‬
‫‪845‬‬ ‫نمٌٌص خًظأهٍ‪EROSION‬‬
‫‪848‬‬ ‫نمٌٌص خًظمًي ‪DILATION‬‬
‫‪844‬‬ ‫نمٌٌص خًفظم ‪OPENING‬‬
‫‪10‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪844‬‬ ‫نمٌٌص خإليالق ‪CLOSING‬‬
‫‪844‬‬ ‫نمٌٌص خًظًَؾ خًشوًل ‪MORPHOLOGICAL GRADIENT‬‬
‫‪843‬‬ ‫نمٌٌص كزهص خًلمص ‪TOP HAT‬‬
‫‪840‬‬ ‫نمٌٌص خًلزهص خًٔىيخء ‪BLACK HAT‬‬
‫‪845‬‬ ‫خًهنرص خًرتهٌزٍ ‪( :STRUCTURING ELEMENT‬خًلندم ‪)MASK‬‬
‫‪137‬‬ ‫ذذسظبدُامصىسحُ‪IMAGE GRADIENTS‬‬
‫‪847‬‬ ‫مشظلدض ٓىرٌٍ وشدَ ‪SOBEL AND SCHARR DERIVATIVES‬‬
‫‪848‬‬ ‫مشظم الرالٌٓدن ‪LAPLACIAN DERIVATIVES‬‬
‫‪141‬‬ ‫مكرشفُامؽىافُكبينُ‪CANNY EDGE DETECTION‬‬
‫‪833‬‬ ‫خهظشدف كىخف هدين ردٓظوًخَ موظزص ‪OPENCV‬‬
‫‪146‬‬ ‫ؤهشامبدُامصىسحُ‪IMAGE PYRAMIDS‬‬
‫‪805‬‬ ‫يمف خًطىَ ردٓظوًخَ خألهُخمدض‬
‫‪153‬‬ ‫مؼبتلخُاملىامجُ‪TEMPLATE MATCHING‬‬
‫‪803‬‬ ‫مؿدرلص خًلىخًس يف ‪OPENCV‬‬
‫‪855‬‬ ‫مؿدرلص خًلىخًس ًهًش ؤؿٔدَ مهدً‬
‫‪163‬‬ ‫ذؽىًهُهبفُمنخؽُ‪HOUGH LINE TRANSFORM‬‬
‫‪850‬‬ ‫طلىًٍ هدف يف ‪OPENCV‬‬
‫‪858‬‬ ‫طلىًٍ هدف خالكظٌليل ‪PROBABILISTIC HOUGH TRANSFORM‬‬
‫‪171‬‬ ‫ذؽىًهُهبفُمنذائشحُ‪HOUGH CIRCLE TRANSFORM‬‬
‫‪174‬‬ ‫ذعضئخُامصىسحُتبظرخذاوُخىاسصمٌخُ‪WATERSHED‬‬
‫‪181‬‬ ‫االشرلبقُاألمبمٍُامرفبغًلُتبظرخذاوُخىاسصمٌخُ‪GRABCUT‬‬
‫‪194‬‬ ‫امفصهُامشاتؼ‪ُ:‬اإلػبسادُيفُ‪OPENCV‬‬
‫‪191‬‬ ‫مبُهٍُاإلػبساد؟‬
‫‪193‬‬ ‫كٌفُذشذعمُاإلػبساد؟‬
‫‪195‬‬ ‫ػشًلخُذلشًجُاإلػبس‬
‫‪196‬‬ ‫خصبئصُاإلػبساد‬
‫‪895‬‬ ‫نّوَ خًطىَش ‪MOMENTS‬‬
‫‪897‬‬ ‫مٔدكص خإلؾدَ ‪CONTOUR AREA‬‬
‫‪897‬‬ ‫ملٌـ خإلؾدَ ‪CONTOUR PERIMETER‬‬
‫‪11‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪897‬‬ ‫طلًُس خإلؾدَ ‪CONTOUR APPROXIMATION‬‬
‫‪898‬‬ ‫يالف خًظلًذ ‪CONVEX HULL‬‬
‫‪458‬‬ ‫خملٔظؿٌٍ خمللٌـ ‪BOUNDING RECTANGLE‬‬
‫‪453‬‬ ‫خًًخثُش خمللٌؿص خألضًًُص ‪MINIMUM ENCLOSING CIRCLE‬‬
‫‪450‬‬ ‫خًلؿو خًندكظ خملظالثم مو خإلؾدَ ‪FITTING AN ELLIPSE‬‬
‫‪450‬‬ ‫خًوـ خملظالثم مو خإلؾدَ ‪FITTING A LINE‬‬
‫‪246‬‬ ‫املضًذُمنُخصبئصُاإلػبسادُ‪CONTOUR PROPERTIES‬‬
‫‪455‬‬ ‫نٔزص خألرهدي ‪ASPECT RATIO‬‬
‫‪455‬‬ ‫خالمظًخي (خًلًوي) ‪EXTENT‬‬
‫‪457‬‬ ‫خًطالرص (خًشًش) ‪SOLIDITY‬‬
‫‪457‬‬ ‫خًلؿُ خملودفح ‪EQUIVALENT DIAMETER‬‬
‫‪457‬‬ ‫خًظًوًُ‬
‫‪457‬‬ ‫خًلندم ونلدؽ خًزٌؤٍ ‪MASK AND PIXEL POINTS‬‬
‫‪458‬‬ ‫خملظىٓـ خًٌىين ؤو خًشًش خملظىٓؿص ‪MEAN COLOR OR MEAN INTENSITY‬‬
‫‪458‬‬ ‫نلدؽ خًشًش ‪EXTREME POINTS‬‬
‫‪249‬‬ ‫ذىاتؼُاإلػبسادُاإلطبفٌخُ‪CONTOURS MORE FUNCTIONS‬‬
‫‪459‬‬ ‫نٌىذ خًظلًذ ‪CONVEXITY DEFECTS‬‬
‫‪484‬‬ ‫نلؿص مػٌو خالهظزدَ ‪POINT POLYGON TEST‬‬
‫‪484‬‬ ‫ملدَنص خألشودي ‪MATCH SHAPES‬‬
‫‪216‬‬ ‫امفصهُامخبمغ‪ُ:‬املخؼؼبدُامثٌبنٌخُيفُ‪OPENCV‬‬
‫‪217‬‬ ‫اإلًعبد‪ُ،‬امشظم‪ُ،‬امرؽنٌهُيفُاملخؼؼبدُامثٌبنٌخ‬
‫‪488‬‬ ‫بًـدي خملوؿـ خًزٌدين ‪FIND HISTOGRAM‬‬
‫‪489‬‬ ‫كٔدذ خملوؿـ خًزٌدين يف ‪OPENCV‬‬
‫‪445‬‬ ‫كٔدذ خملوؿـ خًزٌدين يف ‪NUMPY‬‬
‫‪448‬‬ ‫َٓم خملوؿـ خًزٌدين ‪PLOTTING HISTOGRAMS‬‬
‫‪224‬‬ ‫ذعىًخُاملخؼؽُامثٌبينُ‪HISTOGRAM EQUALIZATION‬‬
‫‪445‬‬ ‫خملوؿـ خًزٌدين خملظىخِن يف ‪OPENCV‬‬
‫‪447‬‬ ‫‪( CLAHE‬طٔىًص خملوؿـ خًزٌدين ٌو خًظزدًن خمللًوي وخملظوٌف)‬
‫‪229‬‬ ‫املخؼؽُامثٌبينُشنبيئُامثػذُ(‪)2D HISTOGRAMS‬‬
12 ‫ ببساطة‬OpenCv

449 OPENCV ‫ يف‬2D ‫خملوؿـ خًزٌدين‬
449 NUMPY ‫ يف‬2D ‫خملوؿـ خًزٌدين‬
445 )PLOTTING 2D HISTOGRAMS( ً‫َٓم خملوؿؿدض خًزٌدنٌص ػندثٌص خًزه‬
233 HISTOGRAM BACK PROJECTIONُ‫اإلظلبغُامخنفٍُمنمخؼؽُامثٌبين‬
443 NUMPY ‫هىخَِمٌص خإلٓلدؽ خًوٌفٍ يف‬
447 OPENCV ‫هىخَِمٌص خإلٓلدؽ خًوٌفٍ يف‬
242 OPENCVُ‫امفصهُامعبدطُذؽىًالدُامصىسحُيف‬
243 FOURIER TRANSFORMُ‫ذؽىًهُفىسًٌهُمنصىسح‬
433 NUMPY ‫طلىًٍ فىًٌَه يف‬
437 OPENCV ‫طلىًٍ فىًٌَه يف‬
249 :PERFORMANCE OPTIMIZATION OF DFTُ‫األداءُاملصبيلُمرؽىًهُفىسًٌهُاملرلؼؼ‬
255 FEATURE DETECTION AND DESCRIPTIONُ‫ُمٌضحُامكشفُوامىصف‬:‫امفصهُامعبتؼ‬
257 UNDERSTANDING FEATURESُ‫فهمُاملٌضاد‬
264 HARRIS CORNER DETECTIONُ‫مكرشفُصواًبُهبسًغ‬
454 OPENCV ‫موظشف ِؤوًص هدًَٕ يف‬
450 CORNER WITH SUBPIXEL ACCURACY ٍ‫يكص خًّؤوًص مو خًزٌؤٍ خًفُن‬
267 ‫ُ&ُمٌضادُظٌذحُمنرػلج‬SHI-TOMASIُ‫مكرشفُصواًب‬
271 (SCALE-INVARIANT FEATURE TRANSFORM(ُSIFT‫ملذمخُبىل‬
470 OPENCV ‫ يف‬SIFT
278 (SPEEDED-UP ROBUST FEATURES)ُ)‫ُ(ذرسًؼُاملٌضادُاملىًخ‬SURFُ‫ملذمخُبىل‬
488 OPENCV ‫ يف‬SURF
284 ‫ُالكرشبفُامضواًب‬FASTُ‫خىاسصمٌخ‬
480 OPENCV ‫ يف‬FAST
287 )‫ُ(املٌضادُاالترذائٌخُاملعرلنخُاملىًخُامصنبئٌخ‬BRIEF
489 OPENCV‫ يف‬BRIEF
291 (ORIENTED FAST AND ROTATED BRIEF(ُ)BRIEFُ‫ُومذوس‬FASTُ‫ُ(مىظه‬ORB
494 OPENCV ‫ يف‬ORB
295 FEATURE MATCHINGُ‫ذؼبتمُاملٌضاد‬
490 BRUTE-FORCE ‫ؤٓدٌٓدض خملؿدرلص‬
‫‪13‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪497‬‬ ‫مؿدرلص خًلىش خملٌٔؿُش مو خًىخضف ‪ORB‬‬
‫‪499‬‬ ‫مؿدرلص ‪FLANN BASED‬‬
‫‪344‬‬ ‫مٌضحُاملؼبتلخُ‪ُHOMOGRAPHYُ+‬إلًعبدُاألظعبو‬
‫‪349‬‬ ‫امفصهُامصبمن‪ُ:‬ذؽنٌهُامفٌذًىُ‪VIDEO ANALYSIS‬‬
‫‪314‬‬ ‫خىاسصمٌخُ‪ُMEANSHIFT‬و‪CAMSHIFT‬‬
‫‪485‬‬ ‫هىخَِمٌص ‪MEANSHIFT‬‬
‫‪485‬‬ ‫هىخَِمٌص ‪CAMSHIFT‬‬
‫‪319‬‬ ‫امرذفمُامثرصيُ‪OPTICAL FLOW‬‬
‫‪448‬‬ ‫ؾًُلص ًىهدْ هدنًي‪ًٌ -‬ظًفم خًزرصي يف ‪OPENCV‬‬
‫‪447‬‬ ‫هؼدفص خًظًفم خًزرصي يف ‪OPENCV‬‬
‫‪332‬‬ ‫ػشػُامخنفٌخُ‪BACKGROUND SUBTRACTION‬‬
‫‪444‬‬ ‫هىخَِمٌص ؾُق خًوٌفٌص ‪MOG‬‬
‫‪443‬‬ ‫هىخَِمٌص ؾُق خًوٌفٌص ‪MOG4‬‬
‫‪338‬‬ ‫امفصهُامربظؼ‪ُ:‬اكرشبفُاألظعبوُ‪OBJECT DETECTION‬‬
‫‪338‬‬ ‫اكرشبفُاألظعبوُتبظرخذاوُخىاسمٌخُ‪HAAR CASCADES‬‬
‫‪435‬‬ ‫هىخَِمٌص ‪HARR CASCADE‬يف ‪OPENCV‬‬
‫‪430‬‬ ‫هؿىخض طًًَس خًوىخَِمٌص ًٌظهُف نىل خًشوٍ خملؿٌىذ‬
‫‪353‬‬ ‫ذؼثٌلبدُغمنٌخ‬
‫‪354‬‬ ‫املشاظؼُامشئٌعٌخ‬
‫مقدمة‬

‫” العلم مغرس كـل فخر فافتخـر ‪ ...‬واحذر يفوتـك فخـر ذاك المغـرس‬
‫‪ ...‬من هـمـهـ في مطعـمـ أو ملبـس‟‬ ‫واعلم بأن العـلم ليس يناله‬

‫الإمام الشافعي‬
‫‪15‬‬ ‫‪ OpenCv‬ببساطة‬

‫امشئًخُامؽبظىتٌخُ‪Computer Vision‬‬
‫مب هٍ امشئًخُامؽبظىتٌخ‬
‫هٍ بكًي مـدالض نٌم خًلدٓىذ خًظٍ طظػمن ؾُق طلطٌٍ ومهدًـص وطلٌٌٍ وفهم خًطىَ‪،‬‬
‫وطهًف خًُئًص خًلدٓىرٌص بىل رندء طؿزٌلدض كديَش نىل فهم ملظىي خًطىَ هٌل ًفهمهد خإلنٔدن‬
‫رهًف خالٓظفديش منهد يف طؿزٌلدض موظٌفص وطهظرب ؤًػدً بكًي خملـدالض خًظٍ ؤكًػع ػىَش يف‬
‫خًظؿزٌلدض خًهنًٌٓص خًلًًؼص خًُورىطٌص منهد وخًطندنٌص‪ٌ .‬نون ًٌطىَ خًُكمٌص ؤن طإهٍ نًش ؤشودي‬
‫مؼٍ ضىَ مظظدرهص )فًًٌى( ‪ ،‬مشدهً من نًش هدمًنخض ؤو ضىَش مظهًيش خالرهدي من خملدٓلدض‬
‫خًؿزٌص‪.‬‬

‫ذؼثٌلبدُامشئًخُامؽبظىتٌخ ُ‬
‫طؿزٌلدض خًىخكو خالفرتخيض‬ ‫‪.8‬‬
‫خالٓظوًخمدض خًؿزٌص وطلٌٌٍ خًطىَ خًؿزٌص وطشوٌظ رهؼ خألمُخع ‪.‬‬ ‫‪.4‬‬
‫نمٌٌدض خًظلوم خًطندنٌص وخًُورىطدض خًطندنٌص‪.‬‬ ‫‪.4‬‬
‫نمٌٌدض خملالكص هٌل يف خًهُردض ٌخطٌص خًلُهص وخًُورىض خًنلدي)‪(mobile robot‬‬ ‫‪.3‬‬
‫‪.‬هشف خألكًخغ وخالشودص مؼٍ خملُخكزص خملُثٌص وخًظهُف نىل خالشودص‪.‬‬ ‫‪.0‬‬
‫ططنٌف خملهٌىمدض وخملهؿٌدض وفهُٓص كىخنً خًزٌدندض ًٌطىَ وخًفًًٌى‪.‬‬ ‫‪.5‬‬

‫وخكًش من ؤهم طؿزٌلدض خًُئًص خًلدٓىرٌص هٍ خًُئًص خًلدٓىرٌص خًؿزٌص ؤو مهدًـص خًطىَ خًؿزٌص‬
‫وهٍخ خملـدي ًهظمً نىل خٓظوالص خملهٌىمدض من خًطىَ خًُكمٌص رًٌص خًىضىي بىل طشوٌظ ؾزٍ‬
‫ًٌمًُؼ ‪.‬رشوٍ ندَ طوىن خملهٌىمدض نىل شوٍ ضىَ مدًوُوٓوىرٌص ؤو ضىَ شهدنٌص)‪ ، (x-rays‬ؤو‬
‫ضىَ شهدنٌص ًلونٌص )‪ (angiography images‬ؤو ضىَ فىق ضىطٌص ‪.‬‬

‫همؼدي نن خملهٌىمدض خيل ٌنون خٓظوالضهد من خًطىَ خًُكمٌص خًؿزٌص هٍ خألوَخَ ؤو ططٌس‬
‫خًٍسخًٍن ؤو خًظًًنخض خًوزٌؼص خألهُي ‪.‬وٌنون ؤًػدً ؤن طٔظوًَ خًُئًص خًلدٓىرٌص ًلٌدْ خألرهدي‬
‫‪16‬‬ ‫‪ OpenCv‬ببساطة‬

‫ًلنػدء‪ ،‬وطًفم خًًَ ‪.‬هٍخ خملـدي ؤًػدً ًًنم خألرلدغ خًؿزٌص رظىفًن مهٌىمدض ؿًًًش مؼالً نن‬
‫رنٌص خًًمدى وؤًػد ً نن مٔظىي خًهالؾ خًؿزٍ‪.‬‬
‫خًظؿزٌم خًؼدين ًٌُئًص خًلدٓىرٌص هى يف خًطندنص ‪.‬ؤكٌدندً طًنى رُئًص خآلًص )‪(machine vision‬‬
‫كٌؽ طوىن خملهٌىمدض خملٔظوٌطص من خًطىَش طهًف بىل طؿىًُ خًهمٌٌص خإلنظدؿٌص مؼال طلًًً‬
‫مودن وخكًخػٌدض وخطـده خًلؿو ًيك طلىَ ٌَخم َورىض رةًظلدؾهد‪.‬‬
‫هظؿزٌم آهُ ًٌُئًص خًلدٌٓىرٌص يف خًطندنص‪ ،‬نمٌٌص خًظلوم يف خًـىيش كٌؽ ًظم فلظ خملنظف‬
‫خًنهديئ رشوٍ آيل من كزٍ خآلًص ًٌظإهً من نًَ وؿىي ؤًص ؤهؿدء ؤو نٌىذ بنظدؿٌص‪.‬‬

‫ظبوُصنبغٍُمامتزًُػرمذُغىلُامشئًخُامؽبظىتٌخ‬

‫وخكًش من ؤكًغ خًظؿزٌلدض ًٌُئًص خًلدٓىرٌص هٍ خملُهزدض ٌخطٌص خًلُهص مؼٍ خًًىخضدض ؤو‬
‫خًهُردض خًطًًنش خملّويش ردًهـالض)‪ ، (wheeled mobile robot‬خًٌٔدَخض ؤو خًشدكندض‪،‬‬
‫وخًؿدثُخض رًون ؾٌدَ‪.‬‬

‫خملُهزدض خًٍخطٌص خًلُهٌص طٔظوًَ خًُئًص خًلدٓىرٌص‬
‫يف خملالكص‪ ،‬ورندء هُخثـ ًٌزٌجص خمللٌؿص)‪،(SLAM‬‬
‫ومهُفص خملودن خًلديل ًٌمُهزص وطـإوِ خًهلزدض‬
‫‪(obstacle avoiding).‬وٌنون ؤن طٔظوًَ ؤًػدً‬
‫إلهظشدف ؤكًخغ مهٌنص مؼٍ كُخثم يف خًًدردض ؤو‬
‫ؤَع طلظىي نفـ ؤو يدِ ‪.‬بهظشدف خًفػدء ًظم خآلن نن‬
‫غشتخُنبظبُ‪ُCuriosity‬غىلُكىكجُاملشًؾُذػرمذُتشكهُ‬
‫ؾًُم خملُهزدض ٌخطٌص خًلُهص خملًنمص رإنكمص خًُئًص‬
‫ؤظبيسُغىلُامشئًخُامؽبظىتٌخ‬
‫خًلدٓىرٌص‪.‬‬
‫‪17‬‬ ‫‪ OpenCv‬ببساطة‬

‫املهبوُامشئٌعٌخُمنشئًخُامؽبظىتٌخ ُ‬
‫‪ ‬امرػشفُ‪Recognition‬‬
‫هٍ خملهمص خًظلًًٌٌص يف خًُئًص خًلدٓىرٌص‪ ،‬وهٍ‬
‫خًلٌدَ رظلًًً مد بٌخ هدنع خًطىَش طلظىي ؤو ال‬
‫طلظىي ؿٌٔلً‪ ،‬مهٌٌلً‪ ،‬ؤو نشدؾدً مهٌندً ‪.‬هٍه خملهمص‬
‫من خملمون كٌهد رزدٓؿص ورًون ؤي ؿهً ًٍهُ‬
‫رىخٓؿص خإلنٔدن‪ً ،‬ون ال طّخي هٍه خملٔإًص يًن ملٌىًص‬
‫رشوٍ فهدي ونهديئ من كزٍ خًلدٓىذ يف شوٌهد‬
‫خًهدَ ‪.‬ؿمٌو خًؿُق خملىؿىيش ًلٍ هٍه خملٔإًص طلىَ‬
‫رةًـدي ؤفػٍ خًلٌىي من ؤؿٍ بًـدي ؤشودي مهٌنص هدألشودي خًهنًٌٌٓص‪ ،‬وؿىه خألشودص‪ ،‬خألكُف‬
‫خملؿزىنص ؤو خملوظىرص‪ ،‬ؤو خًٌٔدَخض‪ ،‬ويف كدالض مهٌنص فلـ ملًيش نىل خًًدًس ركُوف بغدءش‬
‫ملًيش‪ ،‬هٌفٌص ووغهٌص مهٌنص ًٌـٔم ردًنٔزص ًٌودمًنخ ‪.‬‬

‫‪ ‬امرؽذًذ ‪Identification‬‬
‫طلًًً مؿدرم وكًٌ ًٌـٔم خملهُف ‪.‬‬
‫مؼالً ‪:‬طلًًً وؿه شوظ مهٍن ؤو‬
‫خًظهُف نىل رطمص شوظ مهٍن ؤو ٌٓدَش‬
‫من نىم مهٍن‪.‬‬

‫‪ ‬امرؽشيُ‪ُ Detection‬‬
‫ًظم خًزلؽ يف رٌدندض خًطىَش إلًـدي ؿٔم مهٍن ‪.‬مؼدي ‪:‬طلُي وؿىي هالًد مًُػص يف ضىَش ؾزٌص‪،‬‬
‫خًظلُي نن وؿىي ٌٌٓدَش نىل ؾًُم رسًو‪ .‬هٌل ًىغم خًشوٍ خًظديل ًظلًًً مالمم خًىؿه‪.‬‬
‫‪18‬‬ ‫‪ OpenCv‬ببساطة‬

‫امكبمرياُامشكمٌخ ‪Digital Camera‬‬
‫ًلً قهُض خًودمًنخض خًُكمٌص من كىخيل نٍس ٓنىخض‪ ،‬وهٍ طهً خآلن من ؤهًت خألؿهّش خالًورتونٌص‬
‫خٓظوًخمد يف خًظؿزٌلدض خًظـدًَص وخًطندنٌص وطهظرب خًودمًنخ خًُكمٌص ؿهدِ خًُئًص ألي نكدَ ‪.‬طشزه‬
‫خًودمًنخ يف هٍه خًلدالض خًهٍن خًزٍسًص يف نكدَ خًُئًص‬
‫خًطندنٍ‪ ،‬وخًظٍ ٌنون ؤن طوىن نىم من ؤنىخم خًودمًنخض‬
‫ٌخض خًوُؾ خًظشدرهٍ ؤو هدمًنخض خًُكمٌص‪ ،‬كٌؽ ؤنه يف‬
‫خًودمًنخض ٌخض خًوُؾ خًظشدرهٍ خًػىء ًطؿًَ رشدشص‬
‫كٔدٓص ًٌػىء وهٍه خًشدشص طلٌٍ رىٓدؾص كّمص‬
‫خإلًورتون وبن خإلشدَش خًندطـص طٔظوًَ ًٌمهدًـص‪.‬‬
‫يف خًودمًنخض خًُكمٌص بن خًهندرص خمللإومص ًٌػىء خمللؿهص وخملىؿىيش يف يخَش مظودمٌص ًظم‬
‫بٓظوًخمهد‪ ،‬وخإلشدَش خًندطـص من هٍه خًهندرص طٔظهمٍ ًٌمهدًـص‪.‬‬
‫ملبسنخ تني ؤدايت امرصىًش راد امخشط امرشبتهٍ وامخشط امشكمٍ ُ‬
‫‪ ‬ممٌضاد امكبمريا امرشبتهٌخ‬
‫خًوٌفص خًلٌٌٌص نٔزٌدً‪ ،‬خإلًػدق )خًظلٌٌٍ( خألنىل‪ ،‬مٔظىي متٌٌّ َمديي ؤفػٍ‪.‬‬
‫‪ ‬ممٌضاد امكبمريا امشكمٌخ‬
‫طظإًف هٍه خًودمًنخ من نًٓص وكٔدْ )يخَش مظودمٌص( وخًٍي ًظػمن‪ :‬مورب خًفًًٌى‪ ،‬مىًً‬
‫خًنزػدض خملٔظوًَ من ؤؿٍ خًظّخمن ويخَخض مٔم منؿلٌص‪ ،‬هٌهد غمن نفٕ خًٍسًلص ‪.‬هٍخ ًهنٍ‬
‫ؤن خًودمًنخض طّن فلـ رػو يُخمدض وٌنون ؤن طُهس رٔهىًص نىل خًُورىض ‪.‬وًون خًودمًنخ ٌخض‬
‫خًوُؾ خًظشدرهٍ ٌنون خن طّن مجدض خًًُخمدض‪.‬‬
‫ذ‬

‫مػبمعخ امصىسح امشكمٌخُ‪Digital Image Processing‬‬
‫هى ؤكً فُوم نٌم خًُئًص خًلدٓىرٌص‪ ،‬طهظم رةؿُخء نمٌٌدض نىل خًطىَ رهًف طلٔنٌهد ؾزلدً ملهدًًن‬
‫ملًيش ؤو خٓظوالص رهؼ خملهٌىمدض منهد ‪.‬نكدَ مهدًـص خًطىَ خًظلًٌٌي ًظإًف من ٓظص مُخكٍ‬
‫مظظدًٌص وهٍ نىل خًرتطٌس‪:‬‬
‫‪ .8‬اظرؽصبل امصىسح )‪ (Image acquisition‬رىٓدؾص كٔدْ غىيئ )هدمًنخ)‪.‬‬
‫‪ .4‬املػبمعخ املثذئٌخ)‪ (pre-processing‬ططفٌص خًطىَش من خًظشىًش وطلىًٌهد بىل ضىَش ػندثٌص‪.‬‬
‫‪ .4‬ذلؼٌؼ امصىسح )‪ً (segmentation‬فطٍ خملهٌىمدض خملهمص يف خًطىَش نن خًوٌفٌص‪.‬‬
‫‪19‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ .3‬اظرخالص املمٌضاد )‪ (features extraction‬طلًًً خًطفدض خًهدمص وخملمٌّش يف خًطىَش‪.‬‬
‫‪ .0‬ذصنٌف املمٌضاد )‪ (classification‬وَرؿهد ردًنمـ خًٍي طهىي بًٌه وخًظهُف نىل خألمندؽ‪.‬‬
‫‪ .5‬فهم امصىسح )‪(image understanding‬‬

‫وطٔظوًَ نكم مهدًـص خًطىَش يف خًوؼًن من خًظؿزٌلدض والٌٌٓل طؿزٌلدض خًُئًص خًلدٓىرٌص يف‬
‫خًظلوم خآليل‪،‬وخًُورىطدض‪.‬‬

‫مكرثخُ‪OpenCV‬‬
‫خملوظزص خًربمـٌص خملفظىكص ًٌُئًص خًلدٓىرٌص‬
‫(‪)OpenCv‬هٍ موظزص خكرتخندض رُمـٌص طهًف رشوٍ‬
‫ؤٌٓديس بىل طؿىًُ خًُئًص خًلدٓىرٌص‪ ،‬كدمع رظؿىًُهد ٌسهص‬
‫بنظٍ ‪ (Intel).‬وه موظزص رُمـٌص مـدنٌص طلع َهطص‬
‫خملطًَ خملفظىكص)‪ٌ . (open source BSD license‬نون‬
‫بٓظوًخمهد نىل ؿمٌو خألنكمص خًلدٓىرٌص‪ ،‬وهٍ طُهّ رشوٍ‬
‫ؤٓديس نىل مهدًـص خًطىَش ردًّمن خًللٌم)‪. (real time‬‬
‫مؽرىتبد مكرثخُ‪OpenCv‬‬
‫‪ :Core‬وكًش منؿٌص مًمـص ًظلًًً هٌدهٍ خًزٌدندض خألٓدٌٓص‪ ،‬خملٔظوًمص من كزٍ‬ ‫‪‬‬
‫ؿمٌو وكًخض ؤهُي‬
‫‪ :Imgproc ‬وكًش مهدًـص خًطىَ خيل ط ُهنى رهمٌٌدض طلٍٔن خًطىَش ههمٌٌدض خًرتشٌم‪،‬‬
‫وخًظلىًالض خًهنًٌٓص نىل خًطىَ مؼٍ طًًٌن كـم خًطىَش‪ ،‬طًًٌن طزدًن وٌٓؿىم خًطىَش‪،‬‬
‫طهًًٍ خًهٌٔظىيُخَ ًٌطىَش وخًهًًً من خًهمٌٌدض‪.‬‬
‫‪ :Video ‬وكًش طلٌٌٍ خًفًًٌى خيل طظػمن طلًًُخض خًلُهص ًٌهًف‪ ،‬خًوٌفٌص وخًزٌجص‬
‫خمللٌؿص‪ ،‬هىخَِمٌدض طظزو خًودثن ؤو خًهًف‪.‬‬
‫‪ :Calib3d ‬وكًش طلٌٌٍ خملهٌىمدض ًٌطىَش ػندثٌص خألرهدي وخًظٍ هٍ مإهىٌش من خألٓدْ‬
‫من رٌجص ػالػٌص خألرهدي وطلظىي نىل هىخَِمٌدض طلًًً خًوىخص خملهمص ًٌزٌجص ػالػٌص‬
‫خألرهدي‪.‬‬
‫‪20‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ :Features2d‬وهٍ خملٔاوًص نن هشف خًوطدثظ خملهُوفص ًٌهًف وفطٌهد نن ردق‬ ‫‪‬‬
‫خًزٌجص خمللٌؿص مؼٍ خألشودي خًهنًٌٓص مؼالً )مُرو‪ ،‬يوخثُ‪ ،‬مٔظؿٌالض‪(.‬‬
‫‪ :Objectdetect‬هشف نن وؿىه وكدالض من خًفجدض خمللًيش مٔزلد )نىل ٌٓزٌٍ‬ ‫‪‬‬
‫خملؼدي‪ ،‬وؿىه‪ ،‬نٌىن‪ ،‬ؤهىخذ‪ ،‬ؤشودص‪ ،‬خًٌٔدَخض ‪..‬بًى‪(.‬‬
‫‪ :Highgui ‬وهٍ وخؿهص ٌٓهٌه خالٓظوًخَ الًظلدؽ خًفًًٌى وخًطىَش ‪ ،‬ردإلغدفص بىل كًَخض‬
‫ؤهُي ًىخؿهص خملٔظوًَ‪.‬‬
‫‪ُ :CPU module‬طٔظوًَ هدمٍ خًلًَخض خًلٔدرٌص ًٌنكدَ نن ؾًُم خٓظوًخَ كىش‬ ‫‪‬‬
‫رؿدكص مهدًـص خًفًًٌى من ؤؿٍ طؿزٌم هىخَِمٌدض‪. OpenCV‬‬
‫ذؼثٌلبدُ‪ُ OpenCv‬‬
‫ؤنكمص خًظهُف نىل خًىؿىه‪Facial recognition system‬‬ ‫‪‬‬
‫ؤنكمص خًظهُف نىل خإلٌندءخض )‪ Gesture recognition‬خألوخمُ نن ؾًُم خإلٌندءخض مؼٍ‬ ‫‪‬‬
‫طلًُى هُيس ًشوظ مهدق نن ؾًُم كُهص‬
‫خًهٍن‪(.‬‬
‫خًظفدنٍ رٍن خًومزٌىطُ وخإلنٔدن‪HCI.‬‬ ‫‪‬‬
‫خًُورىض خًنلدي‪Mobile Robot.‬‬ ‫‪‬‬
‫خًظهُف نىل خًهًف‪Object Identification.‬‬ ‫‪‬‬
‫مالكلص خًلُهص‪Motion Tracking.‬‬ ‫‪‬‬
‫مغبدُامربمعخُامرٍُذذغمُ‪ُ OpenCv‬‬
‫موظزص ‪ OpenCV‬موظىرص ؤٓدٓدً رًٌص‪ً ، C++‬ونهد طًنم مهكم ًًدض خًربمـص رشوٍ هدمٍ مؼٍ ‪:‬‬
‫‪Python‬‬ ‫‪‬‬
‫‪Java‬‬ ‫‪‬‬
‫‪Matlab/Octave‬‬ ‫‪‬‬
‫‪C#‬‬ ‫‪‬‬
‫‪Perl‬‬ ‫‪‬‬
‫‪Ch‬‬ ‫‪‬‬
‫‪Ruby‬‬ ‫‪‬‬
‫ذ‬

‫طهٌم ‪ OpenCv‬رًٌص خًزدًؼىن (‪ )Python‬ؤٓهٍ روؼًن ملدَنص ردًًٌدض خألهُي‪ًًٍ .‬ى ٓإٌسق هٍخ خًوظدذ خنظٌليخ‬
‫نىل هٍه خًًٌص‪ .‬ال طوف من هٍه خًًٌص فهٍ ًًص رٌٔؿص ؿًخ‪ ،‬وؤرٔـ هؼًنخ من ًًص خًًس فلً طهٌمظهد ؤػندء طهٌم‬
‫ًًص ‪ٓ .OpenCv‬إكىَ رٍسق ؤٓدٌٓدض هٍه خًًٌص كظى طنؿٌم ًظهٌم ‪.OpenCv‬‬
‫‪21‬‬ ‫‪ OpenCv‬ببساطة‬

‫ؤظبظٌبد مػبمعخُامصىسحُ‪Image Processing‬‬
‫مبُهٍُامصىسحُمنُوظههُنظشُامؽبظجُاآليل؟ ُ‬
‫خًطىَش هٍ نزدَه نن مطفىفص خرهديهد متؼٍ خرهدي خًطىَش خًللٌلٌص (ردًزٌؤٍ) فةٌخ هدنع خرهدي‬
‫خًطىَش ‪ 385*555‬رٌؤٍ بٌخ خرهدي خملطفىفص هٍ ‪.385*555‬‬
‫مبُهىُامثٌكعه؟ ُ‬
‫خًزٌؤٍ هى ؿّء من خًطىَش وٌنؼٍ مُرو من‬
‫مُرهدض خًطىَش وًلظىي نىل كٌمص مهٌنه طزهد‬
‫ًٌىن خًٍي ًلظىًه هٍخ خًزٌؤٍ ؤو هٍخ خملُرو‬
‫من خًطىَش‪.‬‬
‫مبراًُػنٍُانُامكبمرياُ‪ُ8‬مٌعبُتٌكعه؟ ُ‬
‫ؤي ؤن مٔدكص خًطىَش خًظٍ طٌظلؿهد = ‪ 8‬مٌـد‬
‫رٌؤٍ = ‪ 8555555‬رٌؤٍ‪ ،‬مؼدي‪ :‬بٌخ هدن هندًى هدمًنخ طٌظلـ ضىَش رلـم ‪ 8045×4538‬بٌخ خًندطف‬
‫ٌٓوىن ‪ 4.4‬مٌٌىن رٌؤٍ خي ‪ 4.4‬مٌـد ‪.‬بٌخ هٌٌل ِخي نًي خًزٌؤٍ يف خًطىَش هٌٌل هدنع خًطىَش‬
‫ؤوغم وؤنلى‪.‬‬
‫كٌفًُلشؤُامؽبظجُامصىسح؟ ُ‬
‫ٌهُند ٓدرلد خن خًطىَش يف خًلدٓس متؼٍ مبطفىفص خرهديهد طٔإوي خرهدي خًطىَش‪ ..‬ونندرصهد = نًي‬
‫خًزٌؤٍ ‪ ...‬وهٍ ننرص ًلظىي كٌمص خًٌىن خًٍي طلظىًه خًزٌؤٍ‪...‬‬
‫كٌمخُامنىنُيفُامثٌكعه ُ‬
‫خًطىَش ننًمد طٌظلـ ًهد ؤهًت من شوٍ‪ ..‬فهندًى ضىَ خرٌؼ وخٓىي فلـ‪ ..‬وهندًى ضىَ ‪ Gray‬خي‬
‫خرٌؼ وخٓىي وَضديص‪ ..‬وهندًى ضىَ مٌىنه‪ ..‬بًى ‪.‬هند نإيت ًظهًُف مهم يف خي ‪Image‬‬
‫‪processing‬وهى‪ : number of bits per pixel‬خي نًي خي ‪ Bit‬خًظٍ متؼٍ فٌهد خي رٌؤٍ‬
‫خًىخكًش وخهظطدَهد‪Bpp‬‬
‫فةٌخ هدنع خًطىَش ‪ً Bpp 8‬هنٍ ‪ bit‬وخكًه فلـ‪ ..‬فهٍ طلظمٍ خمد ضفُ ؤو وخكً‪ ..‬وهٍ خًطىَش‬
‫خألرٌؼ وخألٓىي فلـ‪ ..‬خألرٌؼ هى خًىخكً وخالٓىي هى خًطفُ وبٌخ هدنع ‪ Bpp 4‬مهندهد خن هٍ‬
‫ؤًىخن‬ ‫رٌؤٍ متؼٍ يف ‪ bit 4‬ومهندهد خن ‪ range‬خألًىخن كً ِخي وؤضزم‬
‫‪22‬‬ ‫‪ OpenCv‬ببساطة‬

‫وهوٍخ كظى نطٍ خىل خًطىَ خملٌىنص وهٍ طٌظلـ يف خًودمًنخ ‪ 4‬مُخض ًٌطىَش خًىخكًش‪ ..‬مُه طلٌٕ‬
‫خًٌىن خألكمُ ومُه طلٌٕ خًٌىن خالهٍص ومُه طلٌٕ خًٌىن خالَِق ‪ ...‬وطٔمى خي ‪ RGB‬خي خن خًطىَش‬
‫خملٌىنص ًهد ‪ 4‬مطفىفدض مطفىفص ًلهٍص ومطفىفه ًلكمُ ومطفىفه ًلَِق‪.‬‬
‫وهند خًزٌؤٍ خًىخكًش متؼٍ يف ‪ٌ bit. 43‬تدنٌص ًلكمُ وٌتدنٌص ًلَِق وٌتدنٌص ًلهٍص‪ ..‬وهند ًوىن‬
‫وهًٍى خالهٍص وهًٍى خألَِق‪ .‬بٌخ ً نًي خكظٌلالض‬ ‫نًي خكظٌلالض يَؿدض خالكمُ =‬
‫= ‪ً 85777485‬ىن‬ ‫خألًىخن ًٌزٌؤٍ هوٍ =‬
‫منخص ُ‬
‫بٌخ كمع ردٓظًندء خًزٌؤٍ َكم (‪ )5,5‬خي ؤوي مُرو يف خًطىَش ٓظـً خًندطف ممؼٍ يف ‪ 4‬كٌم‬
‫(‪ )400,400,400‬وهٍ كٌمص خي‪ . R,G,B‬بٌخ هدنع خي ‪ 4‬كٌم كٌمظهد ‪ 400‬فهٍخ ٌنؼٍ خًٌىن خألرٌؼ‬
‫وبٌخ هدنىخ ؿمٌهد ‪ 5‬بٌخ هٍخ هى خًٌىن خألٓىي‬

‫مالؼظخ‪ :‬بٌخ هدن هندًى ًىن ؤضفُ مؼال فةنه ٌنون خن ًوىن ًه ؤهًت من كٌم يف خي ‪ RGB‬مبهنى خنه ٌنون‬
‫خٓظنظدؿه رإهًت من ؾًُلص (طلٌٌٍ خالَِق وًِديش خالكمُ وخالهٍص‪ًِ ،‬ديش خالهٍص وخالَِق وخالكمُ‪ ،‬طلٌٌٍ خالكمُ‬
‫وخالَِق وًِديش خالهٍص ‪ ....‬بًى)‬
‫ُ‬
‫مبُهىُامفٌذًىُؤوُامثضُامؽٍُ؟؟ ُ‬
‫خًزؽ خًلٍ ؤو خًفًًٌى مد هى بال نزدَه نن خًظلدؽ نًي هزًن من خًطىَ يف خًؼدنٌص خًىخكًش ونُغهد‬
‫ردًرتطٌس‪ ..‬وطٔمى ‪ number of frames per second‬وهند طٔمى خًطىَش فًُم ‪Frame..‬وهٌٌل‬
‫ِخي نًي خي ‪ frames‬يف خًؼدنٌص خًىخكًش هٌٌل هدن خًفًًٌى مّخمن ًٌللٌلص‪..‬‬

‫مصبل‪ :‬بٌخ هدنع خًودمًنخ ‪ frame per second 85‬وهدنع ططىَ مزدَش هُش كًَ ٓظـً فُق هزًن‬
‫ؿًخ يف خًىكع ٓظـً خًوُه متُ يف خًللٌلٌص ػم رهًهد رؼىخين ٓظـًهد يف خًودمًنخ‪ ..‬وٓظالكل‬
‫هٍخ يف خملىردًالض خًلًٌنص ؤنى طلُن ًًن ررسنه وخًودمًنخ طزؼهد رهًهد رفُق وكظٍ‪ًًٍ .‬ى طـً‬
‫يف خًودمًنخض وغو ًٔمى ‪ Sport‬خًٍي ًًًّ من نًي خي ‪ fbs‬كظى طـدَي خًىخكو‪.‬‬
‫‪23‬‬ ‫‪ OpenCv‬ببساطة‬

‫مبُهٍُمػبمعخُامصىس؟؟ُومبُهٍُامػمنٌبدُامشًبطٌخُامرٍُذعشيُغنٌهب؟‬
‫مبد خن خًطىَ متؼٍ يف مطفىفدض بٌخ ٌنونند خؿُخء نٌٌهد هٍ خًهمٌٌدض خًًُدغٌص خًظٍ طـُي نىل‬
‫خملطفىفدض‪ :‬رًخًص من خًـمو وخًؿُق كظى خملهديالض وخًظلىًالض )‪(transformations‬‬
‫وخمللٌىذ ويًنهد‬

‫مبراُنعرفٌذُمنُرمك؟ ُ‬
‫‪ ‬امعمؼ‪ُ :‬بٌخ ؿمهع نىل ضىَش مد ‪ 4‬مطفىفدض هٌهد طلظىي نىل ننرص = ‪ 8‬فٔظـمو نىل‬
‫مطفىفص خي ‪ red 1‬وهًٍى خالهٍص وهًٍى خالَِق ‪ ...‬فةٌخ ِخيض كٌمص خالكمُ وخالهٍص‬
‫وخالَِق فةنى طلرتذ من خالرٌؼ كٌٌال فٔظـً خن خًطىَش خضزلع ؤهًت بغدءش‬

‫‪ ‬امؼشػ‪ :‬بٌخ خًظلؿع ضىَطٍن ًنفٕ خًـٔم يف نفٕ خًكُوف وؾُكع خًطىَطٍن من‬
‫رهػهم ٓظلطٍ نىل ضىَش ؿًًًه طلظىي خًفُوكدض رٌنهم (مبهنى ؤنى بٌخ خًظلؿع ضىَش‬
‫‪24‬‬ ‫‪ OpenCv‬ببساطة‬

‫ًـٔم مُه ػم وغهع نٌٌه ؿٔم خهُ وخًظلـ مُه خهُي وؾُكع خًطىَطٍن ٓظـً خًندطف‬
‫نزدَه نن ضىَش ٓىيخء ال طلظىي بال خًـٔم خًٍي وغهظه ماهُخ‬

‫‪ ‬امرؽىًالد‪ :‬هؼًنخ مد نٔمو نن خًظشىًش ؤو خالهظّخِ (خًزؤٌص) وهٍ نزدَه نن ضىَش طم‬
‫خًظلدؾهد ررسنه فإضزلع خًطىَش يًن وخغلص وهند ًظم خؿُخء نٌٌهد ‪transformations‬‬
‫طلىَ رهمٍ ‪ًٌ Filter‬ظشىًش وخنديش خًطىَش وخغلص مؼٍ‪، Fourier transformation‬‬
‫‪.geometric transformation‬‬

‫مبُهٍُمكرثخُال‪ OpenCv‬؟ ُ‬

‫هٌل وغلند ٓدرلد خن هٍ خًهمٌٌدض نىل خًطىَ هٍ مـُي نمٌٌدض ًَدغٌص رلظه‪ ..‬وًون ًٌٕ من‬
‫خملهلىي خن خملربمـٍن ٌٓلىمىن رهمٍ هٍ هٍه خًهمٌٌدض يف هٍ مُه ًٔظوًمىن فٌهد خًطىَ‬
‫وًًٍى طم خنشدء موظزه خي‪ OpenCv‬خًظٍ هٍ نزدَه نن موظزه طلظىي نىل يوخي طلىَ رهمٍ مهكم‬
‫نمٌٌدض خًطىَ خًظٍ ًلظدؿهد خملربمـٍن‪.‬‬

‫هٌل طلظىي نىل يوخي طلىَ رظلًًً خؿٔدَ مهٌنه يف خًطىَش مؼٍ خًوؿىؽ وخالشودي خًهنًٌٓص‬
‫ويوخي خهُي ًظلًًً خألًىخن‪ ،‬هٌل ٌنون خٓظًندء مٌفدض ‪ XML‬هدضه رظلًًً وؿه خالنٔدن ونٌنٌه‬
‫وشهُه وًًه وؿٔمه هوٍ‪.‬‬

‫وٌنون خٓظوًخمهد يف خًظهُف نىل خًشوظ هٌل ٌنون نمٍ مطنف ‪ classifier‬هدص رإي ؿٔم‬
‫(خًظلدؽ ضىَ نًًًه ًنفٕ خًـٔم من هٍ خالطـدهدض كظى طظهُف نٌٌه خًودمًنخ من هٍ‬
‫خالطـدهدض) ‪ ...‬وًٌٕ هٍخ ملظرصخ نىل خالنٔدن فلـ رٍ ؤي ؿٔم (مؼدي مزدًَدض هُش خًلًَ)‪.‬‬
‫‪25‬‬ ‫‪ OpenCv‬ببساطة‬

‫ػشًلخُذصثٌزُمكرثخُ‪OpenCv‬‬

‫‪Windows‬‬
‫‪raspberry pi‬‬

‫‪ .1‬ررقؼةذتثبقتذؿؽتبةذ‪OpenCv‬ذعؾىذـظامذ‪Windows‬‬
‫ررقؼةذ‪:1‬ذ(ؿدتحدـة)‬
‫ؿشروحةذيفذاؾػقدقوذاؾتاؾقةذ(اـؼرذعؾىذاؾػقدقوذودتشافدذاؾشرحذبعدذاالـتؼالذدلوؼعذ‪ )youtube‬ذ‬
‫‪ https://www.youtube.com/watch?v=BAFSi_xTGiI‬ذ‬
‫ررقؼةذ‪:2‬ذذ(قدوقاً)‬

‫ٌنونى طلمٌٍ هٍ مٌف نىل كًي وطنطٌزهم وخكً طٌى خألهُ‬
‫ؾتحؿقلذذبرـاؿجذ)‪python(x,y‬ذذ‪https://python-xy.github.io/downloads.html‬‬ ‫‪‬‬
‫محلذادلؾفذاؾتاؾيذاؾذيذحيويذجمؿوعةذإصداراتذدلؽتبةذ‪OpenCv‬‬ ‫‪‬‬

‫‪https://drive.google.com/file/d/0B0kFf-‬‬
‫‪FN5r9tS1EzSlppUGItNUU/view?usp=sharing‬‬

‫ثمذؼمذبتـصقبذبرـاؿجذ)‪python(x,y‬ذؽؿاذفوذواضحذيفذاؾصورةذاؾتاؾقة‪ :‬ذ‬
‫‪26‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫تلؽدذؿنذوجودذعالؿةذاؾصحذعـدذؿؽتبةذ‪OpenCv‬ذضؿنذؼائؿةذ‪python‬‬
27 ‫ ببساطة‬OpenCv
28 ‫ ببساطة‬OpenCv

Ubuntu‫ذعؾىذـظامذاؾتشغقلذ‬OpenCv‫ ررقؼةذتثبقتذؿؽتبةذ‬.2

‫ رؿًُلظٍن‬Debian – Ubuntu – mint ٍ‫ نىل ؤنكمص ًٌنوٕ مؼ‬openCV ‫ٌنونى طنطٌس‬
‫ من مٔظىيندض خًربخمف‬pre-compiled ‫ خألوىل من هالي طنطٌس خملٌفدض خًـدهّش‬،‫موظٌفظٍن‬
:‫ يف كدًص نكدَ ؤورنظى ًوفٍ ؤن طلىَ رظنفٌٍ خألمُ خًظديل‬:ً‫مؼال‬
$ sudo apt-get install libopencv-dev python-opencv

ُ‫ للملفات المصدرية من البداية (وتضمن هذه الطريقحُامؽصىلُغىل‬Compile ‫الطريقة الثانية هي عن طريق عمل‬
ُ .‫ؤؼذسُنعخخُمنُاملكرثخ‬
:‫وقم بكتابة التعليمات التالية‬Terminal ‫افرؾُظؼشُاألوامر‬

.َ‫) خًنكد‬package( َّ‫طلًًؽ ك‬
$ sudo apt-get update

$ sudo apt-get upgrade

َ‫طؼزٌع ؤيوخض خملؿى‬
$ sudo apt-get install build-essential cmake git pkg-config

JPEG, PNG, TIFF ‫طلظدؾ خًلَّ خًظدًٌص ًظٔظؿٌو كُخءش ؤنىخم خًطىَ خملوظٌفص هـ‬OpenCv ‫موظزص‬
$ sudo apt-get install libjpeg8-dev libtiff4-dev libjasper-dev libpng12-dev

.OpenCv ‫طنطٌس خملوظزدض خًظٍ ٓنٔظوًمهد ًظلٔن ؤيخء موظزص‬
$ sudo apt-get install libatlas-base-dev gfortran

.‫ وطنطٌس خملوظزدض خًظٍ نًًُهد‬python َّ‫ خملٔاوي نن بيخَش ك‬pip ‫طنطٌس‬
$ wget https://bootstrap.pypa.io/get-pip.py

$ sudo python get-pip.py

‫ذ‬

$ sudo pip install virtualenv virtualenvwrapper

$ sudo rm -rf ~/.cache/pip

‫ذ‬
29 ‫ ببساطة‬OpenCv

# virtualenv and virtualenvwrapper

export WORKON_HOME=$HOME/.virtualenvs

source /usr/local/bin/virtualenvwrapper.sh

‫ذ‬

$ source ~/.bashrc

‫ذ‬

$ mkvirtualenv cv

python 2.7 ‫طنطٌس‬
$ sudo apt-get install python2.7-dev

python ٍ‫ يخه‬Numpy ‫طنطٌس موظزص‬
$ pip install numpy

OpenCv ‫طنًٍّ موظزص‬
$ cd ~

$ git clone https://github.com/Itseez/opencv.git

$ cd opencv

$ git checkout 3.0.0

opencv_contrib ًٍّ‫طن‬
‫) خًظٍ هدنع مىؿىيش‬SIFT, SURF, etc.( ٍ‫ٓنٔظوًمه كظى نٔظؿٌو خٓظوًخَ رهؼ خًظىخرو مؼ‬
.OpenCV 3.0 ًًً‫ ػم طم كٍفهد يف خإلضًخَ خًـ‬OpenCv ‫ ملوظزص‬2.4.X َ‫يف خإلضًخ‬
$ cd ~

$ git clone https://github.com/Itseez/opencv_contrib.git

$ cd opencv_contrib

$ git checkout 3.0.0

‫ذ‬
30 ‫ ببساطة‬OpenCv

$ cd ~/opencv

$ mkdir build

$ cd build

$ cmake -D CMAKE_BUILD_TYPE=RELEASE \

-D CMAKE_INSTALL_PREFIX=/usr/local \

-D INSTALL_C_EXAMPLES=ON \

-D INSTALL_PYTHON_EXAMPLES=ON \

-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib/modules \

-D BUILD_EXAMPLES=ON ..

‫ذ‬

$ make

‫ذ‬
31 ‫ ببساطة‬OpenCv

$ sudo make install

$ sudo ldconfig

‫ذ‬

$ cd ~/.virtualenvs/cv/lib/python2.7/site-packages/

$ ln -s /usr/local/lib/python2.7/site-packages/cv2.so cv2.so

.‫ رشوٍ ضلٌم‬OpenCv ‫خآلن ًنوظرب هٍ كمند رةنًخي موظزص‬
$ workon cv

$ python

>>> import cv2

>>> cv2.__version__

'3.0.0'

:ًَ‫خملط‬
‫ ذ‬/http://www.pyimagesearch.com/2015/06/22/install-opencv-3-0-and-python-2-7-on-ubuntu

‫ذ‬

‫ذ‬
‫‪32‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫‪ .3‬ررقؼةذتثبقتذؿؽتبةذ‪OpenCv‬ذعؾىذاؾرادبرييذباي‪ :‬ذ‬

‫ٌنونى ردٓظوًخَ خًلدٓس خملطًُ خًُخٓزًني ردي ملهدًـص خًطىَ يون خًلدؿص ًٌومزٌىطُ فرسنص‬
‫مهدًـظهد ًٌطىَ رسًهص مبد ًوفٍ (رٍ وٌنونهد مهدًـص خًفًًٌى ؤًػدً)‪ .‬ملن ال ًهُف مد هٍ‬
‫خًُخٓزًني ردي فدنطلى رلُخءش خًوظدذ خملمٌّ رادبرييذبايذببدارة ًٌمهنًْ نزً َن نًل وخًٍي‬
‫ًٍسق فٌه فدثًطهد وؾًُلص خٓظهٌلًهد رشوٍ مفطٍ ومزٔـ‪.‬‬

‫ؤًػدً ٌنونى خٓظهٌلي ؤي ًىكص طهمٍ رنكدَ ًٌنوٕ مؼٍ ‪ BegalBone‬ؤو ‪ OrangePi‬ؤو ‪NanoPi‬‬

‫ًظنًٍّ موظزص ‪ OpenCv‬نىل خًُخٓزًني ردي خطزو خًوؿىخض خملىؿىيش نىل خًُخرـ خًظديل‪:‬‬
‫‪ www.pyimagesearch.com‬ذ‬
‫‪http://www.pyimagesearch.com/2015/10/26/how-to-install-opencv-3-on-raspbian-jessie/‬‬
‫‪33‬‬ ‫‪ OpenCv‬ببساطة‬

‫ملذمخُغنُمغخُتبًصىن‬
‫قٌع هٌمص خًزدًؼىن "خألضٌص" طهرب نن ػهزدن غوم ًهٌش يف خنهدَ‬
‫خألمدِون ورهؼ مٔظنلهدض خفًُلٌد ًون مدبن خىت ندَ ‪ 8998‬كظى‬
‫خهظٔس هٍخ خالٓم شهُه ؿًًًش رٍن خملربمـٍن فإضزلع هٌمص خًزدًؼىن طهرب نن ؤشهُ ًًدض‬
‫خًربمـص مفظىكص خملطًَ يف خًهدمل وخًظٍ طهظرب من ًًدض خملٔظىي خًهديل وطظمٌّ رزٔدؾص هظدرظهد‬
‫وكُخءطهد ملدَنص رزدكٍ خًًٌدض‪.‬‬

‫طهظرب ًًص ردًؼىن ًًص طفًٔنًص‪ ،‬مظهًيش خأليُخع وطٔظوًَ رشوٍ وخٓو يف خًهًًً من خملـدالض‪،‬‬
‫هزندء خًربخمف خملٔظلٌص ردٓظوًخَ خًىخؿهدض خًُٓىمٌص ‪ GUI‬ويف نمٍ رُخمف خًىًس‪ ،‬ردإلغدفص بىل‬
‫خٓظوًخمهد هًٌص رُمـص نطٌص ًٌظلوم يف ؤيخء رهؼ من ؤشهُ خًربخمف خملهُوفص ؤو يف رندء رُخمف‬
‫مٌللص ًهد‪ ،‬هٌل طًنم خًربمـص خملظىخًِص ورُمـص خًلىخٌٓس خًودَكص ‪Supercmputers (cluster‬‬
‫)‪– parrallel programming‬هٌل طًنم رُمـص مندفٍ خًظلوم ‪ GPIO‬يف ًىكص خًُخٓزًني ردي‪.‬‬

‫رشوٍ ندَ ٌنون خٓظوًخَ ردًؼىن ًربمـص خًربخمف خًزٌٔؿص ًٌمزظًثٍن‪ ،‬وإلنـدِ خملشدًَو خًػومص‬
‫هإي ًًص رُمـٌص ؤهُي يف نفٕ خًىكع‪ .‬يدًزدً مد ًُنطم خملزظًثٍن يف مًٌخن خًربمـص رظهٌم هٍه‬
‫خًًٌص ًٔهىًظهد وكىطهد يف ٌخض خًىكع‪ ،‬ومو ًٌى نـً مآٔدض نمالكص طٔظوًَ هٍه خًًٌص يخهٍ‬
‫رُخمـهد مؼٍ ؿىؿٍ و مآٔص خًفػدء خًًويل "ندٓد‪."NASA‬‬

‫يدًزدً مد طلطٍ هٍه خًًٌص نىل خًرتطٌس خًُخرو ؤو خًودمٕ يف كدمئص ؤشهُ ًًدض خًربمـص يف خًهدمل‬
‫(طزهدً ألكطدثٌدض مىكو ‪ GitHUB‬خًشهًن ملشدَهص خألهىخي خًربمـٌص)‪ ،‬نشإض ردًؼىن يف مُهّ‬
‫‪CWI‬مُهّ خًهٌىَ وخًلدٓس خآليل رإمٔرتيخَ نىل ًً "ؿىًًو فدن َُِوَ" ‪Guido van Rossum‬‬
‫يف ؤوخهُ خًؼٌلنٌندض‪ ،‬وهدن ؤوي بنالن ننهد يف ندَ ‪ ،8998‬طم هظدرص نىخش خًًٌص رًٌص خًًس ‪ C‬ؤؾٌم‬
‫ًنخ نن بنـدره ر ِفُكَص مرسكٌص هًٌّص شهًنش من رًُؿدنٌد‪،‬‬
‫فدن َُِوَ خٓم "ردًؼىن" نىل ًًظه طهز ً‬
‫هدنع طؿٌم نىل نفٔهد خٓم مىنظٍ ردًؼىن ‪Monty Python‬‬
‫‪34‬‬ ‫‪ OpenCv‬ببساطة‬

‫ممقزاتذؾغةذباقثون ذ‬
‫طهمٍ نىل ؿمٌو ؤنكمص خًظشًٌٍ وخضًخَطهد خملوظٌفص‪ :‬وًنًوِ – ًٌنوٕ (ومشظلدطه) –‬
‫ًىنوٕ (ومشظلدطه) – ؤنكمص خًهىخطف خمللمىًص مؼٍ ‪ Symbian‬و ‪Android‬‬
‫وؿىي ؤيٌس خملوظزدض خإلغدفٌص مههد فظٔؿٌو يف ردًؼىن بًـدي موظزص ًوٍ يشء وؤيٌس‬
‫هٍه خملوظزدض طإيت مُفلص مو خًًٌص‪ً ،‬ون هندن كٌٌٍ من خملوظزدض خًظٍ طلظدؾ خىل‬
‫طلمٌٌهد من مطديَ هدَؿٌص ومن خألمؼٌص نىل هٍه خملوظزدض‪ :‬خًزٌىطىغ‪ ،‬مندفٍ خًظلوم‬
‫خإلًورتوين‪ ،‬وخؿهدض خًىًس‪ ،‬خًظهدمٍ مو خًشزوص و خإلنرتنع‪ ،‬رُمـص خًلىخٌٓس خًفدثلص‪،‬‬
‫طؿزٌلدض ٓؿم خملوظس‪ ،‬موظزدض ًظطمٌم خألًهدذ ػندثٌص وػالػٌص خألرهدي ‪ ....‬بًى‪.‬‬
‫خًظودمٍ مو ‪ ++C‬و ‪Java‬‬
‫طهمٍ غمن رٌجص طفدنٌٌص ؤو نرب ٓوُرظدض (مٌفدض) موظىرص‬
‫خًظهدمٍ مو كىخنً خًزٌدندض خًظدًٌص‬
‫‪Oracle, sybase , PostGres, mSQL , persistence , dbm‬‬

‫ؤظبظٌبدُمغخُ‪python‬‬
‫مفرسُتبًصىنُامرفبغًل‬
‫طظٌلِ ًًص ردًؼىن رةمودنٌص نمٍ رُخمف نن ؾًُم هظدرظهد يف مٌف (ٓوُرع) ؤو طشًٌٌهد مزدٌسش‬
‫ومشدهًه خًنظدثف فىَ هظدرظهد نن ؾًُم مفرس ردًؼىن خًظفدنًل وخًٍي ٌنونى طشًٌٌه من ٓؿُ‬
‫خألوخمُ مزدٌسش نرب هظدرص ‪ python‬ؤو ٌنونى طشًٌٌه ردًػًـ مُطٍن نىل ؤًلىنص ‪ IDLE‬خملىؿىيش‬
‫يف مودن طنطٌس ‪.python‬‬
‫‪35‬‬ ‫‪ OpenCv‬ببساطة‬

‫شوطٌدً ؤفػٍ خًظهدمٍ مو مفرس خًزدًؼىن من ٓؿُ خألوخمُ ‪ .‬فلـ خفظم ٓؿُ خألوخمُ وخهظس هٌمص‬
‫‪ python‬هٌل يف خًطىَش خًظدًٌص‪.‬‬

‫خًػدً ٌنونى خٓظوًخَ ملَُ نطىص مظؿىَ مؼٍ ‪Sublime‬ؤو ‪ًٌٔ ATOM‬دنًن نىل هظدرص رُخمف‬
‫ردًؼىن رٔهىًص وخكرتخفٌص‬
‫‪/https://www.sublimetext.com‬‬
‫‪36‬‬ ‫‪ OpenCv‬ببساطة‬

‫امػمنٌبدُاألظبظٌخ ُ‬
‫ٓنوظس ؤوي رُندمف ًهُع ؿمٌص "مُكزدً ؤًهد خًهدمل" ‪ Hello World‬وًٌى نن ؾًُم هظدرص خألمُ‬
‫‪ print‬ػم خًـمٌص خملُخي نُغهد مؼٍ خًطىَش خًظدًٌص‪:‬‬
‫" ‪print " Hello World‬‬
‫ٓنـً ؤن مفرس ردًؼىن خًظفدنًل كً خقهُ خًنظٌـص فىَخ ً مبـُي خًػًـ نىل َِ ‪Enter‬‬

‫ذ‬
‫امػمنٌبدُامؽعبتٌخ‪ُ :‬‬
‫طٔظؿٌو خًزدًؼىن خًلٌدَ ردًهمٌٌدض خًلٔدرٌص مزدٌسش مؼٍ خًـمو‪ ،‬خًؿُق‪ ،‬خًلٔمص‪ ،‬خًٍصذ‪.‬‬
‫خهظس ‪ 1+1‬ػم خغًـ ‪Enter‬‬

‫خهظس ‪ٌ( 2*2-1‬صذ ‪ 4‬يف ‪ 4‬ػم ؾُق ‪)8‬‬

‫ذ‬
‫ذػشًفُاملرغرياد‪ُ :‬‬
‫ًظهًُف ؤي مظًًن َكمٍ يف ًًص خًزدًؼىن هٍ مد نٌٌى فهٌص هى هظدرص خٓم (خملظًًن = كٌمظه)‬
‫وًهُع كٌمص خملظًًن نوظس ‪ print‬ػم خٓم خملظًًن‬
‫‪x=2‬‬
‫‪print x‬‬

‫ذ‬
‫ًظًًن خملظًًنخض خًنطٌص (هٌمص ؤو ؿمٌص) نوظس خٓم خملظًًن ػم = "خًوالَ خًٍي ًلظىًه خملظًًن" –‬
‫ال طنىس نالمدض " " رٍن كٌمص خملظًًن مؼٍ‪:‬‬
‫"‪myName = "Khaled‬‬
‫‪print myName‬‬

‫إليالق خملفرس خًظفدنًل من ٓؿُ خألوخمُ نػًـ نىل َِ ‪Ctrl+D‬‬
‫‪37‬‬ ‫‪ OpenCv‬ببساطة‬

‫ؼفظُامربنبمغُيفُظكشتز ُ‬
‫يف خألمؼٌص خًٔدرلص خٓظوًمند خًزدًؼىن يف طنفٌٍ خألوخمُ مزدٌسش نرب خملفرس خًظفدنًل‪ً ،‬ون ردًظإهًٌ‬
‫ننًمد نزنٍ مشدًَو كلٌلص فٔنلظدؾ ًوظدرص رُخمف ػدرظص ال طػٌو مند مبـُي يٌم خملفرس وًهمٍ‬
‫هٍخ ٌنونند خٓظوًخَ ؤي ملَُ نطىص وهظدرص نفٕ خألوخمُ خًٔدرلص وكفكهد نىل ضىَش ٓوُرع‬
‫(مٌف نًص) ردمظًخي ‪ py‬وهى خمظًخي ؿمٌو رُخمف خًزدًؼىن‪ٌ( .‬نونى خٓظوًخَ ؤي ملَُ نطىص‬
‫مؼٍ ‪)Sublime – ATOM – Notepad++‬‬
‫خفظم رُندمف ملَُ خًنطىص ‪ ،‬ػم خهظس خًنظ و خكفل خملٌف ردٓم ‪ sum.py‬يخهٍ خملـًٌ‬
‫‪.C:\Users\ASUS‬‬
‫(‪ ASUS‬هى خٓم خملٔظوًَ ننًي ‪ ،‬غو رًال منه خٓم خملٔظوًَ خًٍي ًًًى)‬

‫ذ‬
‫تشنبمغُمعمؼُسكمني ُ‬
‫‪x=3‬‬
‫‪y=1+2‬‬
‫‪sum=x+y‬‬
‫‪print sum‬‬
‫ًظشًٌٍ خًربندمف خفظم ٓؿُ خألوخمُ وخهظس‬
‫‪python sum.py‬‬

‫ذ‬
‫‪38‬‬ ‫‪ OpenCv‬ببساطة‬

‫تشنبمغُمرػشًفُذبتؼُواظرذغبئه ُ‬
‫ؾتعرقفذتابعذـؽتبذاألؿرذ‪def‬ذثمذـؽتبذادمذاؾتابع ثمذـػتحذؼودنيذومنررذهلؿاذادلتغرياتذادلطؾوبة ثمذـؽـبذ‬
‫ـؼطتنيذ(ذ‪:‬ذ)ذوـرتكذػاصلذثمذـؽتبذاألواؿرذاؾيتذدقـػذفاذاؾتابع‪ .‬ذ‬

‫ذ‬

‫تشنبمغُمرػشًفُمصفىفخ ُ‬
‫ٓنلظدؾ ًٌمطفىفدض ألنند ٓنظهدمٍ مو خًطىَ وخًطىَش نزدَش نن مطفىفص‬
‫ٓنلىَ رظهًُف مطفىفص خٓمهد ‪array‬وطلظىي نىل خًهندرص ]‪ .[2,4,7,9‬ػم كمند ردٓظًندء خًهنرص‬
‫خًٍي طُطٌزه ‪ 4‬يف خملطفىفص‪.‬‬

‫ذ‬

‫ُتشنبمغُمرػشًفُمصفىفخُتبالظرػبنخُمبكرثخُ‪.Numpy‬‬
‫ؤوال كمند ردٓظًنخي موظزص ‪ Numpy‬ػم نُفند مطفىفص خٓمهد ‪array‬وطلظىي نىل خًهندرص‬
‫]‪ .[2,4,7,9‬ػم كمند ردٓظًندء خًهنرص خًٍي طُطٌزه ‪ 4‬يف خملطفىفص‪.‬‬

‫ذ‬
‫الفصل الأول‬

‫” هؤلاء الذين يمتللكون الجنون الكافي ليؤمنوا أن‬
‫بإمكانهم تغيير العالم‪ ،‬هم من يغيرونه بالفعل ‟‬
‫ستيف جوبز – شر يك مؤسس لشركة ‪Apple‬‬
‫‪40‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُاأل ُول‪ُ:‬مٌضادُامىاظهخُامشظىمٌخُ‪ُGUI‬يفُ‬
‫‪ُ OpenCv‬‬
‫‪ ‬امثذءُيفُامرػبمهُمؼُامصىس‬
‫ذػنمُذؽمٌهُامصىسحُوغشطهبُوؼفظهب‪ُ .‬‬
‫ُ‬

‫‪ ‬امثذءُيفُامرػبمهُمؼُامفٌذًى‬
‫ذػنمُذشغٌهُفٌذًى‪ُ،‬امرلبغُفٌذًىُمنُامكبمريا‪ُ،‬وؼفظُامفٌذًىُاملنرلؽ‪ُ .‬‬
‫ُ‬

‫‪ ‬مٌضادُامشظمُيفُ‪OpenCv‬‬
‫ذػنمُسظمُخؽ‪ُ،‬معرؼٌه‪ُ،‬دائشحُوامػذًذُمنُاألشكبلُمؼُذىاتؼُمكرثخُ‬
‫‪ُ .OpenCv‬‬
‫ُ‬

‫ُ‬
‫‪ ‬اظرخذاوُامفإسحُكفششبحُمنشظم‬
‫سظمُؤيُسظمخُتبظرخذاوُامفإسح‪ُ .‬‬
‫ُ‬
‫اظرخذاوُرشًؽُامرمشًشُامعبنثٍ)‪ُ (Track bar‬كنىؼخُؤمىان‬
‫ذػنمُبنشبءُرشًؽُظبنثٍُمنرؽكمُتثػعُامثبسامرتاد‪ُ .‬‬
‫ذ‬
‫ذ‬
‫‪41‬‬ ‫‪ OpenCv‬ببساطة‬

‫ػشًلخُغشضُصىسحُوؼفظهب‬

‫امهذف‪ُ :‬‬
‫طهٌم كُخءش خًطىَش ونُغهد وكفكهد نن ؾًُم خًظىخرو خًظدًٌص ‪:‬‬
‫)(‪cv2.imread(), cv2.imshow(), cv2.imwrite‬‬
‫طلٍٔن ؾًُلص نُع خًطىَش نن ؾًُم خٓظًنخي موظزص‪. Matplotlib‬‬

‫ذ‬
‫امصىسحُاألصنٌخُ‬ ‫ذ‬
‫‪42‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬كشاءحُوغشضُامصىسح‪:‬‬
‫اؾربـاؿجذاؾتاؾيذدقؼومذبتحؿقلذاؾصورةذاؾدابؼةذوحػظفاذبادلدتوىذاؾرؿاديذوؿنذثمذدقؼومذبعرضفا ذ‬

‫امكىد‪:‬‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬

‫)‪img = cv2.imread('gift.jpg',0‬‬

‫)‪cv2.imshow('image',img‬‬
‫)‪cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬

‫ُ‬
‫امنرٌعخ‪:‬‬
‫ذ‬

‫ذ‬
‫رشػُامكىد‪ُ :‬‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬

‫يف خًزًخًص كمند ردٓظًندء موظزص ‪ OpenCv‬وموظزص ‪( Numpy‬يخمئد ٓنلىَ ردٓظًندثهٌل)‬

‫)‪img = cv2.imread('gift.jpg',0‬‬

‫كمند رلُخءش خًطىَش نن ؾًُم خألمُ )(‪ cv2.imread‬وهّندهد يف مظًًن ٓمٌنده ‪img‬‬
‫ذ‬
‫‪43‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامربتؼُ )(‪ُ :imread‬‬
‫خملظًًن خألوي هى خٓم خًطىَش (ًـس وغو مٔدَ خًطىَش هدمٍ ؤو وغههد غمن مـًٌ خًهمٍ)‬
‫وخملظًًن خًؼدين هى ماٌس ًلًي هٌفٌص كُخءش خًطىَش وًإهٍ ػالغ كٌم‪:‬‬
‫‪ cv2.IMREAD_COLOR ‬مهندهد ؤكُؤ خًطىَش ردألًىخن خًودمٌص رًون شفدفٌص (ًودفح َكم ‪)8‬‬
‫‪ cv2.IMREAD_GRAYSCALE ‬مهندهد ؤكُؤ خًطىَش ردًٌىن خًُمديي (ًودفح َكم ‪)5‬‬
‫‪ cv2.IMREAD_UNCHANGED ‬مهندهد ؤكُؤ خًطىَش ردألًىخن خًودمٌص مو شفدفٌص (ًودفح‬
‫َكم ‪)8-‬‬
‫يف كدًص نًَ وغو كٌمص يف خملظًًن خًؼدين طوىن خًلٌمص خالفرتخغٌص ‪8‬‬
‫ذ‬
‫)‪cv2.imshow('image',img‬‬
‫كمند رهُع خًطىَش نن ؾًُم خألمُ ‪cv2.imshow‬‬
‫رشػُامربتؼُ)( ‪ُ :imshow‬‬
‫خملظًًن خألوي هى ؤٓم خًندفٍش خًظٍ ٓنهُع نٌٌهد خًطىَش‬
‫خملظًًن خًؼدين هى طدرو كُخءش خًطىَش‬
‫)‪cv2.waitKey(0‬‬
‫ػم ؤهربند خًربندمف ؤن ًنظكُ مًش ِمنٌص مهٌنص ورهً خنهدء هٍه خملًش ًلىَ خًربندمف رظنفٌٍ خألمُ‬
‫خًٍي رهًه‪.‬نػو كٌمص خًّمن خملؿٌىذ خنظكدَه غمن خألكىخْ (خًّمن ًلٔس ردملًٌل ػدنٌص)‬
‫وبٌخ وغهند َكم ‪ٌٓ 5‬نظكُ خًربندمف كظى ًظم غًـ ؤي مفظدق من ًىكص خملفدطٌم‪.‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫طدرو بيالق (طًمًن) ؿمٌو خًنىخفٍ خًظٍ فظلندهد نن ؾًُم هٍخ خًربندمف‪.‬‬
‫مالككص‪ :‬بٌخ ؤَيند طلـٌم كـم خًطىَش ملد ًندٓس خًشدشص فهٌٌند خٓظوًخَ خألمُ ‪ cv2.namedWindow‬مو‬
‫خًهٌم ؤن ًه هٌدًَن‪:‬‬

‫‪cv2.WINDOW_AUTOSIZE‬‬ ‫‪‬‬
‫‪cv2.WINDOW_NORMAL‬‬ ‫‪‬‬

‫)‪cv2.namedWindow('image', cv2.WINDOW_NORMAL‬‬
‫)‪cv2.imshow('image',img‬‬
‫)‪cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫‪44‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪-2‬ؼفظُامصىسح‪ُ :‬‬
‫مؽفظُامصىسحُنعرخذوُاألمشُ‪ُ cv2.imwrite‬‬
‫شبهذُامربنبمغُامربيل‪ُ :‬‬
‫وقٌفص خًربندمف‪ً :‬لىَ هٍخ خًربندمف رظلمٌٍ خًطىَش وكُخءطهد ردملٔظىي خًُمديي ػم نُغهد‪.‬‬
‫وهططند مفظدق ‪ًٌ Esc‬وُوؾ من ندفٍش خًطىَش ننً خًػًـ نٌٌه وهططند خملفظدق ‪ً s‬لفل‬
‫خًطىَش‪.‬‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬

‫)‪img = cv2.imread('gift.jpg',0‬‬
‫)‪cv2.imshow('image',img‬‬

‫)‪k = cv2.waitKey(0‬‬
‫‪if k == 27:‬‬ ‫)‪# wait for Esc key to exit ([27 =Esc] in ASCII‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫‪elif k == ord('s'):‬‬ ‫‪# wait for 's' key to save and exit‬‬
‫)‪cv2.imwrite('copygift.png',img‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫رشػُامكىد‪:‬‬
‫ؤوي ؤَرو ؤٓؿُ طم ٌسكهد ٓدرلد‬
‫)‪k = cv2.waitKey(0‬‬
‫خنظكُ كظى ًظم غًـ ؤي مفظدق من ًىكص خملفدطٌم‬
‫ػم هّن كٌم خًلُف خًٍي غًؿند نٌٌه يف مظًًن ٓمٌنده ‪k‬‬
‫‪if k == 27:‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫بٌخ هدن خًلُف خملػًىؽ هى ‪( Esc‬خًَّ ‪ Esc‬يف خًوٌزىَي ًودفح خًُكم ‪ 47‬رشفُش خآلٓيك) ؤيٌم‬
‫ؿمٌو خًنىخفٍ‬
‫‪elif k == ord('s'):‬‬

‫بٌخ هدن خًلُف خملػًىؽ هى ‪( s‬طهٌٌمص ‪ ord‬طهنٍ كىي خمللُف خًٍي رًخهٌهد ًٌُكم خًٍي ًلدرٌه‬
‫رشفُش خآلٓيك)‬
‫)‪cv2.imwrite('copygift.png',img‬‬
‫خكفل خًطىَش ‪ img‬ردٓم ؿًًً "‪( "copygift.png‬هند خالٓم خًـًًً ًٌطىَش خًـًًًش هى‬
‫‪)copygift‬‬
‫ذ‬
45 ‫ ببساطة‬OpenCv

ُ :imwrite()ُ‫رشػُامربتؼ‬
‫ ؤٓم خًطىَش خًـًًًش (يف كدًص نًَ وغو مٔدَ ملًي ٌٓظم كفل خًطىَش‬:‫ خملظًًن خألوي‬
)ٍ‫خًـًًًش يف مـًٌ خًهم‬
‫ خًطىَش خملؿٌىذ كفكهد‬:‫ خملظًًن خًؼدين‬
ُ :Matplotlibُ‫ُذؽعنيُػشًلخُغشضُامصىسحُغنُػشًمُمكرثخ‬-3
ُ :‫امكىد‬
import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('gift.jpg',0)

plt.imshow(img, cmap = 'gray', interpolation = 'bicubic')
plt.xticks([]), plt.yticks([]) # to hide tick values on X and Y axis
plt.show()
:‫امنرٌعخ‬

‫ذ‬

ُ :‫رشػُامكىد‬
‫ؤوي ؤَرو ؤٓؿُ طم ٌسكهد مٔزلد‬
plt.imshow(img, cmap = 'gray', interpolation = 'bicubic')

‫ طدرو نُع خًطىَش‬plt.imshow
‫ذ‬
plt.xticks([]), plt.yticks([])
‫‪46‬‬ ‫‪ OpenCv‬ببساطة‬

‫وقٌفص هٍخ خًٔؿُ بهفدء طًَؿدض ملىَ ‪ x‬و‪ y‬من ندفٍش خًطىَش‬
‫(كم رلٍف هٍخ خًٔؿُ والكل خًفُق)‬

‫ذ‬
‫ذ‬
‫)(‪plt.show‬‬
‫طدرو فظم خًطىَش غمن ندفٍش‪.‬‬

‫هندن خًهًًً من خًوٌدَخض مظىفُش غمن موظزص ‪ًٌ ،matplotlib‬لطىي نىل طهٌٌٌلض ؤهًت غمن‬
‫هٍه خملوظزص ٌنونى كُخءش خملُؿو خًودص رهد‪.‬‬

‫يف خًوىي خًٔدرم الكل رإنه بٌخ نُغند خًطىَش رًًن خملٔظىي خًُمديي ٓنشدهً رإن ًىن خًطىَش ؤهظٌف فٌل هى‬
‫خًٔزس!‬
‫ذ‬
‫امعثج‪ُ :‬‬
‫ننً طلمٌٍ خًطىَ نرب ‪ OpenCv‬نلطٍ نىل خًطىَش رطًٌص ‪ BGR‬وًون ننً نُع خًطىَش رـ‬
‫‪ً Matplotlib‬ظم خنظزدَهد ‪( RGB‬ؤي ًوىن خألكمُ ؤَِق وردًهوٕ) ًًٍى ًـس مُخندش هٍخ خًىغو‬
‫وخالنظزده ًظزًًٍ خألًىخن كزٍ بقهدَهد نرب ‪Matplotlib‬‬
‫ذ‬
‫)‪ OpenCv => (B, G, R‬ذ‬
‫)‪Matplotlib => (R, G, B‬‬
‫ذ‬
‫‪47‬‬ ‫‪ OpenCv‬ببساطة‬

‫اؾتؼاطذاؾػقدقوذؿنذاؾؽاؿرياذ‬

‫يف خملؼدي خًظديل ٓنلىَ ردًظلدؽ ضىَ من خًودمًنخ ونُغهد‬
‫ررسنص كظى طكهُ خًطىَ نىل هٌجص فًًٌى رؽ مزدٌس‪.‬‬
‫(خًودمًنخ ننًمد ططىَ فًًٌى مزدٌس هٍ ردًللٌلص طٌظلـ نًش‬
‫بؾدَخض ًٌطىَ ررسنص ندًٌص وطلىَ رهُغهد فظزًو ًند وهإن‬
‫خًودمًنخ ططىَ رؽ مزدٌس)‪.‬‬

‫مالككص‪ :‬هٍ بؾدَ من بؾدَخض خًطىَش خملٌظلؿص ًًنى فًُم ‪.frame‬‬

‫(هٌٌل ِخي نًي بؾدَخض خًطىَ خملٌظلؿص يف خًؼدنٌص ٓنلطٍ نىل ِمن كلٌلٍ ؤهرب ًنلٍ خًطىَش)‪.‬‬
‫امكىد‪ُ ُ:‬‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬

‫)‪cap = cv2.VideoCapture(0‬‬

‫‪while(True):‬‬
‫‪# Capture frame-by-frame‬‬
‫)(‪ret, frame = cap.read‬‬
‫‪# Our operations on the frame come here‬‬
‫)‪gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY‬‬
‫‪# Display the resulting frame‬‬
‫)‪cv2.imshow('frame',gray‬‬
‫‪if cv2.waitKey(1) == ord('q'):‬‬
‫‪break‬‬

‫‪# When everything done, release the capture‬‬
‫)(‪cap.release‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫ذ‬

‫رشػُامكىد‪ُ :‬‬
‫)‪cap = cv2.VideoCapture(0‬‬

‫أيذحددذاؾؽاؿرياذاؾيتذدـؾتؼطذبفاذاؾػقدقوذؿنذاؾؽاؿرياذومسفاذذ‪ cap‬ذ‬
‫‪48‬‬ ‫‪ OpenCv‬ببساطة‬

‫امربتؼُ)( ‪ :VideoCapture‬طدرو خًظلدؽ خًطىَ من خًودمًنخ‪ .‬كٌمص خملظًًن خًٍي رًخهٍ خًلىٍٓن‬
‫متؼٍ طُطٌس خًودمًنخ (بٌخ هند نٔظوًَ هدمًنخ وخكًش فٔظإهٍ يدًزد خًرتطٌس ‪ ،5‬وبٌخ هدن ًًًند ‪4‬‬
‫هدمًنخض وؤَيند طشًٌٍ خًودمًنخ ‪ٓ 4‬نػو رًي ضفُ خًُكم ‪( 4‬‬
‫‪while(True):‬‬
‫كٌلص ال نهدثٌص مد يخَ خًٍسؽ ‪ TRUE‬مللم فةٌخ طلىي بىل ‪ٓ FALSE‬ىف طنظهٍ كٌلص ‪while‬‬
‫)(‪ret, frame = cap.read‬‬

‫امربتؼُ)(‪ًُread‬هًٌ كٌمظدن هٌل‪:‬‬
‫خملظًًن ‪ً :frame‬وّن رًخهٌه خًطىَش (خًفًُم) خملٌظلـ من خًودمًنخ وًٌى نن ؾًُم خًظدرو‬
‫)(‪.cap.read‬‬
‫املرغريُ‪ً :ret‬إهٍ خًلٌمص خملهديش من خًظدرو )(‪ cap.rad‬وطوىن كٌمظه بمد‪ True‬ؤو ‪.False‬‬
‫فةٌخ هدنع خًلٌمص ‪True‬هٍخ ًهنٍ رإن خًودمًنخ طٌظلـ خًطىَ‪ ،‬ؤمد بٌخ هدنع خًلٌمص ‪ False‬فهٍخ‬
‫ًهنٍ رإن خًودمًنخ ال طٌظلـ خًطىَ ‪.‬‬
‫تبخرصبس خًظدرو )(‪ً cap.read‬وّن خًطىَش خملٌظلؿص من خًودمًنخ يف خملظًًن ‪ ، frame‬وًهٌمند هٍ‬
‫خًودمًنخ طٌظلـ خًطىَ ؤَ ال نن ؾًُم طوًّن كٌمص ‪ True‬ؤو ‪ False‬يف خملظًًن ‪.ret‬‬
‫ؤكٌدند ال طهمٍ مهى خًظهٌٌمص )(‪ cap.read‬ننًهد ٌنونى ؤن طٔظهمٍ رًال منهد خًظهٌٌمص‬
‫)(‪.cap.isOpened‬‬
‫)‪gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY‬‬
‫كىي كٌمص هٍ بؾدَ من بؾدَخض خًطىَش ًٌىن خًُمديي وهّنهد يف مظًًن ٓمٌنده ‪gray‬‬
‫امربتؼُ)(‪ُ :cvtColor‬‬
‫خملظًًن خألوي ٌنؼٍ ؤٓم خًطىَش وخملظًًن خًؼدين ٌنؼٍ خملٔظىي خًٌىين خملؿٌىذ (هند خهرتند‬
‫مٔظىي خًٌىن خًُمديي)‪.‬‬
‫)‪cv2.imshow('frame',gray‬‬
‫ؤنُع خًطىَش ‪ frame‬ردًٌىن خًُمديي‬
‫‪if cv2.waitKey(1) == ord('q'):‬‬
‫‪break‬‬
‫بٌخ طم غًـ مفظدق ‪ q‬كم ردًوُوؾ من كٌلص ‪ while‬ويف خألمُ خًٍي رهًه ٌٓظم بيالق ؿمٌو‬
‫خًنىخفٍ خملفظىكص‪.‬‬
‫)(‪cap.release‬‬
‫هٍخ خألمُ مٔاوي نن طلًُُ خًودمًنخ (ؤي ؤًلدف طشًٌٌهد)‪.‬‬
49 ‫ ببساطة‬OpenCv

‫تشغقلذاؾػقدقوذؿنذؿؾف ذ‬

‫ ردٓم‬cv2.VideoCapture() ‫ فلـ نٔظزًي طُطٌس خًودمًنخ يف خًظدرو‬.‫مٌلػٍ ملد ٓزم‬
.‫خًفًًٌى‬
import numpy as np
import cv2

cap = cv2.VideoCapture('C:\Users\A\Documents\video.mp4')

while(True):
# Capture frame-by-frame
ret, frame = cap.read()
# Our operations on the frame come here
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Display the resulting frame
cv2.imshow('frame',gray)
if cv2.waitKey(10) == ord('q'):
break

# When everything done, release the capture
cv2.destroyAllWindows()

‫ فإنع رلدؿص ألن‬،‫ بن مل ًهمٍ مهى خًوىي خًٔدرم ًهًَ خًلًَش نىل كُخءش خًفًًٌى‬OpenCv 3 َ‫ يف بضًخ‬:‫مالككص‬
.ffmpeg or gstreamer‫طنطس‬

Make sure proper versions of ffmpeg or gstreamer is installed. Sometimes,‫ذ‬
it is a headache to work with Video Capture mostly due to wrong nstallation
of ffmpeg/gstreamer.
‫‪50‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذىاتؼُامشظم ُ‬

‫ذذذذذذذ‬
‫امهذف‪ُ :‬‬
‫‪ ‬طهٌم َٓم موظٌف خألشودي خًهنًٌٓص ردٓظوًخَ موظزص ‪.OpenCv‬‬
‫‪ٓ ‬نظهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪:‬‬
‫‪cv2.line(), cv2.circle(), cv2.rectangle(), cv2.ellipse(), ‬‬
‫)(‪cv2.putText‬‬
‫ٓنالكل ننً خٓظوًخَ هٍه خًظىخرو رإنهد طلظىي نىل خملظًًنخض خًظدًٌص‪:‬‬
‫‪ .8‬خًطىَش خًظٍ ٌٓظم خًُٓم نٌٌهد‬
‫‪ً .4‬ىن خًشوٍ (ًظلًًً خًٌىن منَُ ػالغ كٌم هٍ ‪)R,G,B‬‬
‫‪ٌٓ .4‬لهص خًوـ‬
‫‪ .3‬نىم خًوـ (مظطٍ – مظلؿو‪)..‬‬
‫سظمُخؽ‬
‫يف هٍخ خملؼدي ٓرنٓم هـ كؿُي يف خًطىَش‬ ‫ًُٓم هـ نلظدؾ بكًخػٌص خًزًخًص وخًنهدًص‪.‬‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬
‫‪# Create a black image‬‬
‫)‪img = np.zeros((512,512,3), np.uint8‬‬

‫‪# Draw a diagonal blue line with thickness of 5 px‬‬
‫)‪cv2.line(img,(0,0),(511,511),(0,0,255),5‬‬

‫‪# lets see‬‬
‫)‪cv2.imshow('imag',img‬‬
‫)‪cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫ذ ذ‬
‫‪51‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامكىد‪:‬‬
‫)‪img = np.zeros((512,512,3), np.uint8‬‬
‫ذ‬

‫امربتؼُ)(‪ُ :np.zeros‬‬
‫ذًُٓم ضىَش ًىنهد ؤٓىي (مطفىفص ضفًُص‪ :‬نندرصهد طوىن ؿمٌههد ؤضفدَ ‪ = 5‬خًٌىن خألٓىي)‬
‫ُُُاملرغريُاأل ُول‪ :‬ؤوي كٌمظٍن هٌل ؤرهدي خملطفىفص (كـم خًطىَش) وػدًؽ مظًًن هى نملهد‬
‫‪uint8‬‬ ‫املرغريُامصبين‪ٌ :‬نؼٍ نىم نندرص خملطفىفص خًظٍ طوىن خًطىَش هند خًنىم هى‬
‫‪ Uint8‬هٍ خهظطدَ ًـ ‪ unsigned integer 8-bit‬نًي ضلٌم يًن ملًٌ ردإلشدَش ًظإًف من ‪8‬‬
‫رع‬
‫)‪cv2.line(img,(0,0),(511,511),(0,0,255),5‬‬
‫ذ‬

‫امربتؼُ)( ‪ًٔ line‬ظوًَ ًُٓم هـ‪ً ،‬ظػمن نًش مظًًنخض طٔدنًند يف نمٌٌص خًُٓم وهٍ‪:‬‬
‫خملظًًن خألوي هى ؤٓم خًطىَش وخملظًًن خًؼدين هى بكًخػٌدض رًًص خًوـ وخملظًًن خًؼدًؽ هى‬
‫بكًخػٌدض نهدًص خًوـ وخملظًًن خًُخرو هى كٌمص خًٌىن )‪ (B,G,R‬وخملظًًن خًودمٕ هى ٌٓلهص خًوـ‬
‫________________________________________ ذ‬

‫سظمُمعرؼٌه ُ‬
‫ؾردمذادلدتطقلذجيبذأنذحنددذزأوقتهذاؾعؾقاذاؾقدرىذوزأوقتهذاؾدػؾىذاؾقؿـى‪ .‬ذ‬
52 ‫ ببساطة‬OpenCv

:‫كىدُسظمُمعرؼٌهُغىلُصىسحُظىداء‬
import numpy as np
import cv2
# Create a black image
img = np.zeros((512,512,3), np.uint8)

#Draw Rectangle
cv2.rectangle(img,(100,100),(250,250),(0,255,0),3)

# lets see
cv2.imshow('imag',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

‫ذ‬

ُ :‫رشػُامكىد‬
cv2.rectangle(img,(100,100),(250,250),(0,255,0),3)

‫ وقٌفظه هٍ َٓم مٔظؿٌٍ وًظم طلًًً هطدثظ هٍخ خملٔظؿٌٍ نن ؾًُم‬rectangle()ُ‫امربتؼ‬
‫ خملظًًن خألوي هى ؤٓم خًطىَش وخملظًًن خًؼدين وخًؼدًؽ هٌل بكًخػٌدض ِؤوًص‬.‫خملظًًنخض خًظدًٌص‬
.‫خملٔظؿٌٍ خًهٌٌد خًٌرسي وخًٔفىل خًٌمنى‬
53 ‫ ببساطة‬OpenCv

:‫كىدُسظمُمعرؼٌهُغىلُصىسحُمىظىدحُمعثلب‬
import numpy as np
import cv2
from matplotlib import pyplot as plt

# read image
img =cv2.imread('brid.jpg')

#invert color from B,G,R to R,G,B
b,g,r = cv2.split(img) # get b,g,r
img = cv2.merge([r,g,b]) # switch it to RGB

# Draw a diagonal blue line with thickness of 5 px
cv2.rectangle(img,(400,35),(570,160),(255,0,0),3)

# lets see
plt.imshow(img)
plt.show()

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

ُ :‫رشػُامكىد‬
b,g,r = cv2.split(img) # get b,g,r
img = cv2.merge([r,g,b]) # switch it to RGB

.‫ هٍ وخكً ًىكًه‬B, G, R ‫ وقٌفظه خًلطىي نىل ؤًىخن خًطىَش خًـ‬cv2.split()
‫‪54‬‬ ‫‪ OpenCv‬ببساطة‬

‫)(‪ cv2.merge‬وقٌفظه يمف خألًىخن ٓنٔظوًمه ًًمف خألًىخن خًظٍ كطٌند نٌٌهد من خًظدرو خًٔدرم‬
‫وًون رطًٌص مهوىٓص‪( .‬ؤكطً رًمف خألًىخن رطًٌص مهوىٓص‪ ،‬رإن ؤرًي خًٌىن خألكمُ ردًٌىن خألَِق‬
‫وردًهوٕ ؤمد خًٌىن خألهٍص ٓنزلٍ نىل طُطٌزه هم هى‪ ،‬فنلطٍ نىل خًرتطٌس ‪ RGB‬رًي ‪)BGR‬‬
‫كمند ردٓظًندء خًظدرهٍن خًٔدرلٍن ًظلىًٍ خألًىخن من خًرتطٌس ‪ BGR‬بىل ‪.RGB‬‬

‫ًلً ٌهُند ٓدرلد رإن موظزص ‪cv2‬طهُع خألًىخن ردًرتطٌس ‪ BGR‬وًون موظزص ‪ matplotlib‬طإهٍ‬
‫خًرتطٌس ‪ً RGB‬هٍخ خًٔزس كً نؤند خألًىخن ًظكهُ خًطىَش ردًٌىن خًللٌلٍ‪ .‬ؿُذ كٍف هًٍن‬
‫خًٔؿًُن وٓظهُف مدٌخ ٌٓلًغ‪ٌٓ( .‬طزم خًٌىن خألكمُ رًي خألَِق وخألَِق رًي خألكمُ)‪.‬‬

‫مالؼظخ‪ُ:‬مكرثخُ ‪cv2‬ذػشضُاألمىانُتبمرتذٌجُ‪ُ،BGR‬تٌنٌلُمكرثخُ‪ُmatplotlib‬ذػشضُاألمىانُتبمرتذٌجُ‪ُ .RGB‬‬

‫)‪cv2.rectangle(img,(100,100),(250,250),(0,255,0),3‬‬

‫امربتؼُ)( ‪ rectangle‬وقٌفظه هٍ َٓم مٔظؿٌٍ وًظم طلًًً هطدثظ هٍخ خملٔظؿٌٍ نن ؾًُم‬
‫خملظًًنخض خًظدًٌص‪ :‬خملظًًن خألوي هى ؤٓم خًطىَش وخملظًًن خًؼدين وخًؼدًؽ هٌل بكًخػٌدض ِؤوًص‬
‫خملٔظؿٌٍ خًهٌٌد خًٌرسي وخًٔفىل خًٌمنى‪ُ .‬‬
‫ذ‬

‫سظمُدائشح ُ‬
‫ًُٓم يخثُش نلظدؾ مُهّهد ونطف كؿُهد‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬

‫)'‪img =cv2.imread('brid.jpg‬‬

‫‪# Draw circle‬‬
‫)‪cv2.circle(img,(480,120), 80, (0,0,255), 5‬‬

‫)‪cv2.imshow('imag',img‬‬
‫)‪cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫ذ‬
‫‪55‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫رشػُامكىد‪ُ :‬‬
‫)‪cv2.circle(img,(250,250), 63, (0,0,255), 5‬‬

‫امربتؼ ُ)( ‪ circle‬وقٌفظه َٓم يخثُش خملظًًن خألوي هى خٓم خًطىَش خًظٍ ٓرنٓم نٌٌهد وخملظًًن‬
‫خًؼدين هى مُهّ خًًخثُش وخملظًًن خًؼدًؽ هى كؿُ خًًخثُش وخملظًًن خًُخرو هى ًىن خًًخثُش وخملظًًن‬
‫خًودمٕ ٌنؼٍ ٌٓلهص ملٌـ خًًخثُش‪.‬‬
‫ذ‬

‫سظمُكؼؼُنبكص ُ‬
‫ًُٓم كؿو ندكظ نلظدؾ متًُُ نًش مظًًنخض (خملُهّ ‪ +‬ؤؾىخي خمللىًٍَن ‪ِ+‬ؤوًص خًًوَخن ‪ِ+‬ؤوًص‬
‫خًزًخًص وخًنهدًص) ًظم خًُٓم نن ؾًُم خٓظًندء خًظدرو ‪cv2.ellipse‬‬
‫)‪cv2.ellipse(img,(480,256),(100,50),0,0,180,255,5‬‬

‫ذ‬
‫‪56‬‬ ‫‪ OpenCv‬ببساطة‬

‫سظمُمظنؼ ُ‬
‫ًُٓم مػٌو نلظدؾ َئوْ خإلكًخػٌدض ومن ػم نـهٌهد رشوٍ مطفىفص وًـس ؤن طوىن هٍخ‬
‫خملطفىفص ردًطًٌص ‪int32‬خملؼدي خًظديل ًُٓم مػٌو رإَرو َئوْ‬

‫)‪pts = np.array([[410,65],[470,30],[500,35],[570,90]], np.int32‬‬
‫))‪pts = pts.reshape((-1,1,2‬‬
‫))‪cv2.polylines(img,[pts],True,(0,0,255‬‬

‫ًى هدنع كٌمص خملظًًن خًؼدًؽ ًٌظدرو )(‪ cv2.polylines‬هٍ ‪ً False‬لطٌند نىل مػٌو مفظىق ‪.‬‬
‫ٌنون ًٌظدرو خًٔدرم َٓم نًش مٔظلٌٌلض مهد‪ ،‬مد نٌٌى بال متًُُ مطفىفدض خًنلدؽ وهٍخ ؤفػٍ من‬
‫َٓم هٍ مٔظلٌم نىل كًي‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫بطبفخُنصُمنصىسح ُ‬
‫ُ‬
‫إلغدفص نظ ًٌطىَش نٌٌى طلًًً مد ًًل‪:‬‬
‫خًنظ خًٍي طًًُ بيَخؿه‪ ،‬مىغو خًنظ ردًنٔزص ًٌطىَش (من خًّؤوًص خًٔفىل خًٌرسي)‪ ،‬نىم خًوـ‪،‬‬
‫كـم خًوـ ردًزٌؤٍ‪ ،‬خًٌٔلهص‪ ،‬خًٌىن‪ ،‬هٍ خًوـ مظطٍ ؤَ منفطٍ‪.‬‬

‫‪font = cv2.FONT_HERSHEY_SIMPLEX‬‬
‫)‪cv2.putText(img,'OpenCV',(10,300), font, 4,(255,255,255),5‬‬
‫ذ‬
‫‪57‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫ذ‬

‫مالككص‪ٌ :‬نونى خٓظًندء ؤهًت من طدرو َٓم نىل نفٕ خًطىَش‬
58 ‫ ببساطة‬OpenCv

ُ ‫ؤؼذاسُامفإسح‬

.OpenCv ‫يف هٍه خًًَْ ٓنظهٌم خًظهدمٍ مو ؤكًخغ خًفإَش يف‬
cv2.setMouseCallback() ‫ٓنظهٌم خٓظوًَ خًظدرو خًظديل‬

‫ ؤو‬،‫ هٍ ؤي يشء مُطزـ ردًفإَش مؼٍ غًـ خًَّ خألًرس‬:‫ؤكًخغ خًفإَش‬
‫خًى‬.........‫ ؤو خًػًـ مُطٍن‬،‫َفو خًػًـ‬

‫( خملودن خًٍي ًىؿً ره ماٌس خًفإَش‬X,Y) ‫ بكًخػٌدض‬cv2.setMouseCallback() ‫ًهؿٌند خًظدرو‬
:‫ ٌنونى هظدرص خألمُ خًظديل‬،‫ملهُفص ؤكًخغ خًفإَش خملظىفُش‬.‫نىل خًشدشص‬
import cv2
events = [i for i in dir(cv2) if 'EVENT' in i]
for a in events :
print a
‫ذ‬

E EVENT_FLAG_ALTKEY
EVENT_FLAG_CTRLKEY
EVENT_FLAG_LBUTTON
EVENT_FLAG_MBUTTON
EVENT_FLAG_RBUTTON
EVENT_FLAG_SHIFTKEY
EVENT_LBUTTONDBLCLK
EVENT_LBUTTONDOWN
EVENT_LBUTTONUP
EVENT_MBUTTONDBLCLK
EVENT_MBUTTONDOWN
EVENT_MBUTTONUP
EVENT_MOUSEHWHEEL
EVENT_MOUSEMOVE
EVENT_MOUSEWHEEL
EVENT_RBUTTONDBLCLK
EVENT_RBUTTONDOWN
‫ ذ‬EVENT_RBUTTONUP
59 ‫ ببساطة‬OpenCv

ُ ‫امشظمُتبظرخذاوُامفإسح‬
‫ ٌنونى طنفٌٍ ؤي ؤمُ ننً خًػًـ نىل َِ خًفإَش نن ؾًُم خًظدرو خًٍي ٓظوظزه وًون هند ٓنلظرص نىل‬:‫مالككص‬
.‫خٓظوًخَ كًغ خًػًـ نىل َِ خًفإَش ًٌُٓم فلـ‬
:1‫مصبل‬
‫ وٓننشإ طدرو خٓظًندء مُطزـ‬.‫ٓننشإ طؿزٌم رٌٔـ ًُٓم يخثُش ننًمد نػًـ ردًفإَش نىل خًشدشص‬
.‫رلًغ غًـ َِ خًفإَش خألًرس مُطٍن ًُٓم يخثُش‬
import cv2
import numpy as np

# mouse callback function
def draw_circle(event,x,y,flags,param):
if event == cv2.EVENT_LBUTTONDBLCLK:
cv2.circle(img,(x,y),100,(255,0,0),-1)
# Create a black image, a window and bind the function to window
img = np.zeros((512,512,3), np.uint8)
cv2.namedWindow('image')
cv2.setMouseCallback('image',draw_circle)

while(1):
cv2.imshow('image',img)
if cv2.waitKey(20) == 27:
break
cv2.destroyAllWindows()

‫ذ‬
‫‪60‬‬ ‫‪ OpenCv‬ببساطة‬

‫ُ‬
‫رشػُامكىد‪ُ ُ :‬‬
‫‪def draw_circle(event,x,y,flags,param):‬‬
‫ذ‬

‫طٔظوًَ نزدَش ‪ًdef‬ظهًُف خًظىخرو يف ًًص ردًؼىن‬
‫نُفند طدرو ردٓم ‪ draw_circle‬ومَُند ًه ‪ 0‬كٌم‪.‬‬

‫‪if event == cv2.EVENT_LBUTTONDBLCLK:‬‬
‫)‪cv2.circle(img,(x,y),100,(255,0,0),-1‬‬
‫ذ‬

‫بٌخ هدن خًلًغ خملػًىؽ هى خًػًـ نىل َِ خملإوْ خألًرس مُطٍن نفٍ مد رًخهٍ ؿمٌص ‪if‬‬
‫خًٍسؾٌص‪ :‬خَٓم يخثُش مُهّهد هى بكًخػٌدض )‪ (x,y‬ملىكو ماٌس خًفإَش‬

‫)‪img = np.zeros((512,512,3), np.uint8‬‬
‫)'‪cv2.namedWindow('image‬‬
‫ذ‬

‫كمند رةنشدء ضىَش ًىنهد ؤٓىي رلـم ‪ 512 x 512‬ػم ٓمٌند ندفٍش خًطىَش ردالٓم ‪.image‬‬

‫)‪cv2.setMouseCallback('image',draw_circle‬‬

‫امربتؼ ُ)(‪ ُ setMouseCallback‬مٔاوي نن طنفٌٍ كًغ خًفإَش وهند ٌٓلىَ رُٓم يخثُش نن‬
‫ؾًُم خٓظًندء خًظدرو خًٍي ؤنشإنده يف رًخًص خًوىي وهى ‪.draw_circle‬‬
‫رشػُامربتؼُ)(‪ُ setMouseCallback‬‬
‫خملظًًن خألوي هى ؤٓم خًندفٍش خملؿٌىذ طنفٌٍ كًغ خًفإَش نٌٌهد‪.‬‬
‫خملظًًن خًؼدين هى خألمُ خملؿٌىذ طنفٌٍه ننً كًوغ كًغ خًفإَش‪.‬‬
‫ذ‬

‫ذ‬
61 ‫ ببساطة‬OpenCv

ُ :2‫مصبل‬
‫ ًًٍى ٌٓوىن ًًي‬،‫ٓنلىَ يف هٍخ خملؼدي رُٓم مٔظؿٌٍ ؤو يخثُش رند ًء نىل خًلدًص خًظٍ ٓنوظدَهد‬
.‫ وخكً ًُٓم مٔظؿٌٍ وخألهُ ًُٓم يخثُش‬،‫طدرو خٓظًندء خًطىَش ًًًه شلٍن‬

‫ ٓنلىَ رظهًًٍ خًوىي‬.‫هٍخ خملؼدي كً ًنفهند يف رهؼ خًظؿزٌلدض هظظزو خألؿٔدَ وطلؿٌو خًطىَش‬
‫ وًٌظنلٍ رٍن خهظٌدَ مٔظؿٌٍ ؤو‬،َ‫خًٔدرم رلٌؽ ٓنوظدَ رإن نُٓم يخثُش ؤو مٔظؿٌٍ كٔس مد نوظد‬
.‫ من ًىكص خملفدطٌم‬m ‫يخثُش نػًـ نىل كُف‬

import cv2
import numpy as np

drawing = False # true if mouse is pressed
mode = True # if True, draw rectangle. Press 'm' to toggle to curve
ix,iy = -1,-1

# mouse callback function
def draw_circle(event,x,y,flags,param):
global ix,iy,drawing,mode

if event == cv2.EVENT_LBUTTONDOWN:
drawing = True
ix,iy = x,y
elif event == cv2.EVENT_MOUSEMOVE:
if drawing == True:
if mode == True:
cv2.rectangle(img,(ix,iy),(x,y),(0,255,0),-1)
else:
cv2.circle(img,(x,y),5,(0,0,255),-1)
elif event == cv2.EVENT_LBUTTONUP:
drawing = False
if mode == True:
cv2.rectangle(img,(ix,iy),(x,y),(0,255,0),-1)
else:
cv2.circle(img,(x,y),5,(0,0,255),-1)

img = np.zeros((512,512,3), np.uint8)
cv2.namedWindow('image')
cv2.setMouseCallback('image',draw_circle)

‫ذ‬
62 ‫ ببساطة‬OpenCv

while(1):
cv2.imshow('image',img)
k = cv2.waitKey(1)
if k == ord('m'):
mode = not mode
elif k == 27:
break

cv2.destroyAllWindows()
‫ذ‬

ُ ُ:3‫مصبل‬
.‫يف خملؼدي خًٔدرم َٓمند مٔظؿٌٍ ممظٌح فهٍ رةمودنى طًًٌن ًٌى ًُٓم مٔظؿٌٍ مفُى‬
ُ :‫امؽه‬

import cv2
import numpy as np

drawing = False
mode = False
ix,iy = -1,-1
# mouseCallback Function
def draw_circle(event,x,y,flags,param):
global ix,iy,drawing,mode,spareimg,img

if event == cv2.EVENT_LBUTTONDOWN:
drawing = True
ix,iy = x,y

‫ذ‬
63 ‫ ببساطة‬OpenCv

elif event == cv2.EVENT_MOUSEMOVE:
if drawing == True:
if mode == True:
img = spareimg.copy()
spareimg = img.copy()
cv2.rectangle(img,(ix,iy),(x,y),(0,255,0),2)
else:
cv2.circle(img,(ix,iy),3,(0,0,255),-1)
cv2.line(img,(ix,iy),(x,y),(0,0,255),3)
ix,iy = x,y

elif event == cv2.EVENT_LBUTTONUP:
drawing = False
if mode == True :
cv2.rectangle(img,(ix,iy),(x,y),(0,255,0),2)
spareimg = img.copy()
else:
cv2.circle(img,(x,y),3,(0,0,255),-1)

img = cv2.imread('gift.jpg',1)
spareimg = img.copy()
# img = np.zeros((512,512,3),np.uint8)
cv2.namedWindow('image',cv2.WINDOW_NORMAL)
cv2.setMouseCallback('image',draw_circle)

while(1):
cv2.imshow('image',img)
k = cv2.waitKey(1)
if k == ord('m'):
mode = not mode
elif k == 27:
break

cv2.destroyAllWindows()

‫ذ‬

‫ذ‬
‫‪64‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشًؽُامرمشًشُامعبنثٍ ُ‬
‫‪ ‬اظرخذاوُرشًؽُامرمشًشُامعبنثٍ)‪ُ (Track bar‬كنىؼخُؤمىان‬
‫امهذف‪ُ :‬‬
‫‪ ‬طهٌم بنشدء ٌسًـ ٓلس يف ندفٍش ‪ windows‬غمن موظزص ‪.OpenCv‬‬
‫‪ٓ ‬نظهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪. cv2.getTrackbarPos() , cv2.createTrackbar():‬‬
‫ُ‬
‫كىدُامرعشتخ‪ُ :‬‬
‫ٓننشإ طؿزٌم رٌٔـ ًهُع ًىن ملًي يف ندفٍش‪ ،‬وًظم طًًٌن خًٌىن خملهُوع نن ؾًُم ػالػص‬
‫ؤٌسؾص ٓلس‪ ،‬هٍ ؤيخش ٓلس متؼٍ ًىن ‪ .R,G,B‬ذ‬

‫ٓنهٍن خًٌىن خألٓىي هٌىن خفرتخيض‪.‬‬
‫اؾتابعذ)(‪cv2.getTrackbarPos‬ذقلخذذادلتغرياتذاؾتاؾقة‪ :‬ذ‬
‫ذ‬
‫ؤوي مظًًن ٌنؼٍ ؤٓم ٌسًـ خًٔلس‪ ،‬وػدين مظًًن هى خٓم خًنفٍش خًظٍ ٓنػو نٌٌهد خأليخش‪ ،‬وػدًؽ‬
‫مظًًن هى خًلٌمص خالفرتخغٌص‪ ،‬وَخرو مظًًن هى خًلٌمص خًهكمى‪ ،‬وهدمٕ مظًًن هى طدرو خالٓظًندء‬
‫(ؤي خألمُ خملؿٌىذ طنفٌٍه)‪.‬يف مؼدًند هٍخ ًن نٔظهمٍ طدرو خالٓظًندء ًًٍى ٓنمَُ ًه طدرو ُهٌزٍ‪.‬‬

‫وهندن طؿزٌم آهُ ًظدرو خالٓظًندء وهى خٓظوًخمه هَّ طزًًٍ (ألن موظزص ‪ OpenCv‬ال طلىي‬
‫هدضٌص َِ)‪ًًٍ ،‬ى ٓننشإ هدضٌص ًظفهٌٍ قهىَ خًٌىن ؤو ال هٌل هى مىغم يف خًوىي خًظديل‪:‬‬
65 ‫ ببساطة‬OpenCv

import cv2
import numpy as np

def nothing(x):
pass

# Create a black image, a window
img = np.zeros((300,512,3), np.uint8)
cv2.namedWindow('image')

# create trackbars for color change
cv2.createTrackbar('R','image',0,255,nothing)
cv2.createTrackbar('G','image',0,255,nothing)
cv2.createTrackbar('B','image',0,255,nothing)

# create switch for ON/OFF functionality
switch = '0 : OFF \n1 : ON'
cv2.createTrackbar(switch, 'image',0,1,nothing)

while(1):
cv2.imshow('image',img)
k = cv2.waitKey(1) & 0xFF
if k == 27:
break
# get current positions of four trackbars
r = cv2.getTrackbarPos('R','image')
g = cv2.getTrackbarPos('G','image')
b = cv2.getTrackbarPos('B','image')
s = cv2.getTrackbarPos(switch,'image')

if s == 0:
img[:] = 0
else:
img[:] = [b,g,r]

cv2.destroyAllWindows()
‫ذ‬
‫‪66‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ :‬‬

‫ذ‬

‫ذ‬
‫الفصل الثاني‬

‫”من سلك طر يقا يلتمس فيه علما سهل اللله له طر يقا‬
‫إلى الجنة ‟‬
‫سيد الرُسل – محمد صلى الل له عليه وسلم‬
‫‪68‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُامصبين‪ُ:‬امػمنٌبدُاألظبظٌخُغىلُامصىس ُ‬

‫‪ ‬امػمنٌبدُاألظبظٌخُغىلُامصىس‬

‫طهٌم كُخءش خًزٌؤٍ وهٌفٌص طًًٌن كٌمظه‪ ،‬وطهٌم نٔى ؿّء ملًي من خًطىَش‪،‬‬
‫ونمٌٌدض ؤٓدٌٓص ؤهُي‬

‫‪ ‬امػمنٌبدُامؽعبتٌخُغىلُامصىس‬

‫بؿُخء نمٌٌدض كٔدرٌص نىل خًطىَ‬
‫ُ‬

‫‪ ‬ذلنٌبدُكٌبطُاألداءُوذؽعٌنه‬

‫خًلطىي نىل خًلٍ خًٍي نًًُ وًون رؿًُلص ؤرسم‪ ،‬وطهٌم فلظ رسنص خًوىي‪،‬‬
‫وهٌفٌص خًلطىي نىل خًوىي خملؼديل‪.‬‬

‫‪ ‬األدوادُامشًبطٌخُيفُمكرثخُ‪OpenCv‬‬

‫ُ‬

‫ذ‬

‫امػمنٌبدُاألظبظٌخُغىلُامصىس‬
‫‪69‬‬ ‫‪ OpenCv‬ببساطة‬

‫امهذف‪ُ :‬‬
‫كشاءحُكٌمخُؤيُتٌكعهُيفُامصىسحُوػشًلخُذػذًهُكٌمره‪.‬‬
‫مػشفخُخصبئصُامصىسح‪.‬‬
‫ذغريُمنؼلخُمؽذدحُمنُامصىسح‪.‬‬
‫دمغُامصىسُوفصنهب‪.‬‬

‫ؤيٌس خًهمٌٌدض خالٓدٌٓص نىل خًطىَش طظم نن ؾًُم خالٓظهدنص مبوظزص ‪ ،numpy‬وطظم رشوٍ ؤفػٍ‬
‫من خٓظهٌلي موظزص ‪ًًٍ .OpenCv‬ى ًـس ؤن طظهُف نىل موظزص ‪ Numpy‬رشوٍ ؿًٌ‪.‬‬
‫كشاءحُوذػذًهُكٌمخُؤيُتٌكعهُيفُامصىسح‬
‫ينند نلمٍ خًطىَش خملٌىنص خًظدًٌص‬
‫كظى نزًؤ ردًٍسق نٌٌهد‪.‬‬

‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)'‪img = cv2.imread('robot_football.jpg‬‬
‫ذ‬

‫ٌنونند خًىضىي ًلٌمص ؤي رٌؤٍ نن ؾًُم بكًخػٌدض خًٔؿُ وخًهمىي )‪.(X,Y‬‬
‫‪70‬‬ ‫‪ OpenCv‬ببساطة‬

‫ردًنٔزص ًٌطىَش خملٌىنص ننً كُخءش كٌمص خًزٌؤٍ ٌٓظم كُخءش ػالغ ؤًىخن وهٍ خألكمُ وخألهٍص‬
‫وخألَِق‪ .‬خًوىي خًظديل ٌٓلُؤ ؤًىخن خًزٌؤٍ خًٍي بكًخػٌدطه ‪ x=100 , y=100‬وٌٓهًٌ ًند كٌمص‬
‫خألًىخن ‪.R G B‬‬
‫]‪px = img[100,100‬‬
‫‪print px‬‬
‫ذ‬

‫[‪139‬ذذ‪68‬ذذ‪]41‬‬

‫كُخءش ًىن وخكً‪ :‬خًوىي خًظديل فلـ ٌٓلُؤ خًٌىن خألكمُ‬
‫‪# accessing only blue pixel‬‬
‫]‪red = img[100,100,2‬‬
‫‪print red‬‬
‫ذ‬

‫‪ 41‬ذ‬

‫ٌنونى طًًٌن ًىن ؤي رٌؤٍ يف خًطىَش نن ؾًُم طًًٌن كٌمظه‪.‬‬
‫يف خًوىي خًظديل ٓنًًن كٌمص ًىن خًزٌؤٍ خًٍي بكًخػٌدطه )‪ (100,100‬بىل خًٌىن خألكمُ‪.‬‬
‫]‪img[100,100] = [0, 0,255‬‬
‫]‪print img[100,100‬‬
‫ذ‬

‫مالككص‪:‬‬
‫‪ ‬موظزص ‪Numpy‬هٍ ؤفػٍ موظزص ملهدًـص خملطفىفدض ررسنص‬
‫‪ ‬ننً خٓظهٌلي خًؿًُلص خًٔدرلص ًٌىضىي بىل هٍ رٌؤٍ ٌٓايي هٍخ خألمُ ًزؿح يف‬
‫خًربندمف‪.‬‬
‫ًظهدمٍ مو هٍ رٌؤٍ ًىكًه ًفػٍ خٓظوًخَ خًظدرهٍن )(‪ item‬و )(‪ itemset‬وًٌى هٌل ًًل‪:‬‬
‫خًوىي خًظديل ٌٓلُؤ كٌمص خًٌىن خألكمُ يف خًزٌؤٍ ٌو خإلكًخػٌص )‪.(10,10‬‬
‫(خًٌىن خألكمُ ًودفح َكم ‪ ،4‬وخًٌىن خألهٍص ًودفح خًُكم ‪ ،1‬وخًٌىن خألَِق ًودفح خًُكم ‪)0‬‬
‫‪# accessing RED value‬‬
‫)‪img.item(10,10,2‬‬
‫ذ‬
‫‪71‬‬ ‫‪ OpenCv‬ببساطة‬

‫خآلن ٓنًًن كٌمص خًـ ‪( R‬خًٌىن خألكمُ) يف خًزٌؤٍ ٌو خإلكًخػٌدض )‪ (10 , 10‬ونٔظزًًه رلٌمص ًىنٌص‬
‫كٌمظهد ‪.100‬‬
‫(كدَن رٍن خًنظٌـص يف خًوىي خًٔدرم وهٍخ خًوىي يف نفٕ خًزٌؤٍ والكل مدٌخ كًغ)‬
‫‪# modifying RED value‬‬
‫)‪img.itemset((10,10,2),100‬‬
‫)‪img.item(10,10,2‬‬
‫ذ‬

‫ذ‬

‫خصبئصُامصىسح‬
‫نًي خًلنىخض ( ‪ ،)channels‬نًي خألٓؿُ‪ ،‬نًي خألنمًش‪ ،‬نًي خًزٌؤالض‪...... ،‬‬
‫ملهُفص شوٍ خًطىَش ‪(shape‬نًي خألٓؿُ‪ ،‬نًي خألنمًش‪ ،‬نًي خًلنىخض) نوظس خًوىي خًظديل‪:‬‬
‫‪print img.shape‬‬
‫ذ‬

‫(‪,3‬ذ‪,320‬ذ‪ )320‬ذ‬

‫ذ‬

‫‪print img.size‬‬ ‫ملهُفص نًي خًزٌؤالض نوظس خًوىي خًظديل‪:‬‬
‫‪1268568‬‬

‫ملهُفص نىم رٌدندض خًطىَش نوظس خًوىي خًظديل‪:‬‬
‫‪print img.dtype‬‬
‫ذ‬
‫‪ uint8‬ذ‬

‫ًـس خالنظزده ًنىم رٌدندض خًطىَش ألنه ًىؿً خًهًًً من خألهؿدء طلًغ يف رٌجص ‪Opencv_Python‬‬
‫ٓززه نىم رٌدندض خًطىَش ‪data type‬‬
‫ذ‬
‫‪72‬‬ ‫‪ OpenCv‬ببساطة‬

‫املنؼلخُاملهمخُيفُامصىسحُ(‪ُ )Image ROI‬‬
‫ُ‬
‫مبُامللصىدُتـُ‪ROI‬؟! ُ(‪ُ )Region Of Interest‬‬

‫ؤكٌدند نلظدؾ ًظلًُُ منؿلص ملًيش من خًطىَش‪ ،‬فمؼال من ؤؿٍ خهظشدف خًهٍن نٌٌى ؤوال خًزلؽ‬
‫نن خًىؿه‪ ،‬ومن ػم نػو كًوي ًٌىؿه ونلىَ ردًزلؽ يخهٍ هٍه خًلًوي نن خًهٌنٍن‪ .‬هٍه خًهمٌٌص‬
‫طىفُ نٌٌند خًزلؽ غمن خًطىَش هٌهد وطلٔن رسنص ويكص خالهظشدف (ألن خًهٌنٍن يخمئد مىؿىيش‬
‫نىل خًىؿه ‪ ) :D‬وًظلٔن خأليخء (ألنند رلؼند غمن مٔدكص ضًًنش)‪.‬‬
‫ذ‬

‫يف هٍخ خًوىي خًظديل ٓنلىَ رظلًًً منؿلص من خًطىَش ومن ػم نلىَ رنٔوهد ووغههد يف مودن ؤهُ‬
‫من خًطىَش‪.‬‬

‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪from matplotlib import pyplot as plt‬‬

‫)'‪img = cv2.imread('football.jpg‬‬

‫]‪part = img[150:300, 400:550‬‬
‫‪img[150:300, 50:200] = part‬‬

‫)‪plt.imshow(img‬‬
‫)][(‪plt.xticks‬‬
‫)][(‪plt.yticks‬‬
‫)(‪plt.show‬‬
‫ذ‬

‫ؤنكُ ًٌنظٌـص يف خًطىَ خًظدًٌص‪:‬‬
‫‪73‬‬ ‫‪ OpenCv‬ببساطة‬

‫كثه‪ُ :‬‬
‫ذ‬

‫ذ‬ ‫ذ‬

‫ذ‬

‫تػذ‪ُ :‬‬

‫ذ‬

‫شدهً هٌف طم نٔى خًوُش مُطٍن‪.‬‬
‫رشػُامكىد‪ُ :‬‬
‫]‪part = img[150:300, 400:550‬‬
‫هزاُامعؼشُمعاولُغنُاملعمُامزيُنشًذُنعخه ُ‬
‫ًنفُع ؤن خكًخػٌدض خًّؤوًص خًهٌٌد خًٌرسي ًٌلٔم خملُخي نٔوه هٍ )‪ (X1,Y1‬وبكًخػٌدض خًّؤوًص‬
‫خًٔفىل خًٌمنى هٍ )‪ ، (X2,Y2‬ننًهد ٌٓوىن خًرتطٌس هٌل ًًل‪img[Y1:Y2, X1:X2] :‬‬

‫‪img[150:300, 50:200] = part‬‬
‫هٍخ خًٔؿُ مٔاوي نن خًلٔم خًٍي نًًُ وغو خًلٔم خملنٔىن فٌه‪ ،‬وًإهٍ ؤًػد نفٕ خًرتطٌس‬
‫خًٔدرم ]‪.img[Y1:Y2, X1:X2‬‬

‫مالككص‪ً :‬ـس مُخندش ؤن ًوىن خًفُق رٍن ‪ X1‬و ‪ X2‬نفٔه يف خًلٔم خملنٔىن‪ ،‬وهًٍى خألمُ ردًنٔزص ًـ‪ Y1‬و‪.Y2‬‬
‫‪74‬‬ ‫‪ OpenCv‬ببساطة‬

‫فصهُودمغُكنىادُامصىسح ُ‬
‫ؤكٌدند نلظدؾ ؤن نلىَ ًفطٍ كنىخض ؤًىخن خًطىَش ‪ B,G,R‬هٍ كندش ًىنٌص نىل كًي‪ .‬رلٌؽ ٌنونند‬
‫خًظهدمٍ مو هٍ كندش ًىنٌص رشوٍ منفطٍ‪ ،‬هٌل ٌنونند ؤًػد يمف كنىخض خألًىخن مهد ًٌلطىي نىل‬
‫ضىَش مٌىنص‪.‬‬

‫ؾًُلص خًفطٍ وخًًمف ٓهٌص ؿًخ وٌنونى خًلٌدَ رًٍى نن ؾًُم خًوىي خًظديل‪:‬‬
‫)‪b,g,r = cv2.split(img‬‬ ‫تعليمة فصل قنوات األلوان عه بعضها ‪#‬‬
‫))‪img = cv2.merge((b,g,r‬‬ ‫تعليمة دمج قنوات األلوان مع بعضها ‪#‬‬
‫ذ‬

‫‪# Or‬‬
‫]‪b = img[:,:,0‬‬
‫ذ‬

‫ًنفُع ؤنى طًًُ ؤن طـهٍ ؿمٌو خًزٌؤالض يف خًلندش ‪ R‬كٌمظهد ضفُ‪ٓ ،‬ظلىَ يف خًزًخًص رفطٍ‬
‫كنىخض خألًىخن نن ؾًُم طهٌٌمص )( ‪ split‬ػم ٓظـهٍ كٌمص خًلندش ‪R‬طٔإوي خًطفُ‪( .‬هٍه خًهمٌٌص‬
‫رؿٌجص)‬
‫ٌنونى فهٍ خألمُ خًٔدرم رشوٍ ؤرٔـ نن ؾًُم خالٓظهدنص مبوظزص خملطفىفدض ‪ ،Numpy‬وٌٓظم‬
‫خألمُ خًٔدرم رشوٍ ؤرسم‪ .‬شدهً ًوىي خًظديل‪:‬‬
‫‪img[:,:,2] = 0‬‬
‫ذ‬

‫ذنثٌه‪ُ :‬‬
‫نمٌٌص ‪ split‬طإهٍ وكع هزًن نٔزٌد ًظنفٌٍ خألمُ‪ًًٍ ،‬ى ال طٔظهمٌهد بال ننً خًٍصوَش‪ ،‬وخٓظهمٍ رًال ننهد‬
‫خًهمٌٌدض نىل خملطفىفدض فهٍ ؤفػٍ روؼًن‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬
‫‪75‬‬ ‫‪ OpenCv‬ببساطة‬

‫بنشبءُؼذودُمنصىسح ُ‬
‫بٌخ ؤَيض بنشدء كًوي ًٌطىَش خٓظهمٍ خًظدرو )(‪.cv2.copyMakeBorder‬‬
‫ًإهٍ هٍخ خًظدرو خملظًًنخض خًظدًٌص‪:‬‬
‫ضىَش خًًهٍ‪ ،‬خًلمص‪ ،‬خًلدنًش‪ ،‬خًٌمٍن‪ ،‬خًٌٔدَ‪ ،‬نُع خًلًوي‪ ،‬نىم خًلًوي‪ً ،‬ىن خًلً‪.‬‬
‫مظًًن نىم خًلًوي ًإهٍ خًلٌم خًظدًٌص‪:‬‬

‫‪ :cv2.BORDER_CONSTANT‬بغدفص ًىن ػدرع ًٌلًوي (ًإهٍ كٌمص خًٌىن من خملظًًن خًظديل)‬
‫‪ :cv2.BORDER_REFLECT‬نوٕ نندرص خًلًوي مؼٍ ‪...‬‬

‫‪ FEDCBA | ABCDEFG | GFEDCBA‬ذ‬
‫خملٌىن ردًُمديي نهظربه كٌمص خًلًوي وخًهندرص خًظٍ كىي خًلًوي هٍ خملٌىنص ردألَِق‪ .‬هٍ كُيف‬
‫ٌنؼٍ كٌمص ًىنٌص ًزٌؤٍ‪.‬‬
‫‪ :cv2.BORDER_REFLECT_101 or cv2.BORDER_DEFAULT‬نفٕ خًظهٌٌمص خًٔدرلص وًون‬
‫مو خًلٌٌٍ من خًظًًنخض‬

‫‪GFEDCBA | ABCDEFG | GFEDCBA‬‬
‫‪ً :cv2.BORDER_REPLICATE‬ظم نٔى خًهنرص خألهًن يف ؿمٌو خألنلدء مؼٍ‪:‬‬

‫‪AAAAA | ABCDEFGH | HHHHHHH‬‬
‫‪ ،‬ال ٌنون طفًٔنه وًون ٌٓزًو هوٍخ‪ : :‬خًظفدف خًلًوي‪v2.BORDER_WRAP‬‬

‫‪ CDEFGH | ABCDEFGH | ABCDEFG‬ذ‬

‫خملظًًن خألهًن هى خًٌىن (فلـ نٔظهمٌه يف كدي ؤهرتند خًنىم خألوي من خًلًوي)‬

‫كظى نفهم ؤنىخم خًلًوي رشوٍ ؤوغم ٓنوظس خًربندمف خًظديل خًٍي ًلظىي نىل هٍ ؤنىخم خًلًوي‪.‬‬
76 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt

BLUE = [255,0,0]

img1 = cv2.imread(' opencv_logo.jpg')

replicate = cv2.copyMakeBorder(img1,10,10,10,10,cv2.BORDER_REPLICATE)
reflect = cv2.copyMakeBorder(img1,10,10,10,10,cv2.BORDER_REFLECT)
reflect101 = cv2.copyMakeBorder(img1,10,10,10,10,cv2.BORDER_REFLECT_101)
wrap = cv2.copyMakeBorder(img1,10,10,10,10,cv2.BORDER_WRAP)
constant= cv2.copyMakeBorder(img1,10,10,10,10,cv2.BORDER_CONSTANT,value=BLUE)

plt.subplot(231),plt.imshow(img1,'gray'),plt.title('ORIGINAL')
plt.subplot(232),plt.imshow(replicate,'gray'),plt.title('REPLICATE')
plt.subplot(233),plt.imshow(reflect,'gray'),plt.title('REFLECT')
plt.subplot(234),plt.imshow(reflect101,'gray'),plt.title('REFLECT_101')
plt.subplot(235),plt.imshow(wrap,'gray'),plt.title('WRAP')
plt.subplot(236),plt.imshow(constant,'gray'),plt.title('CONSTANT')

plt.show()

‫ذ‬

‫ذ‬
‫‪77‬‬ ‫‪ OpenCv‬ببساطة‬

‫امػمنٌبدُامعربًخُغىلُامصىس‬
‫امهذف‪ُ :‬‬
‫طهٌم خًهًًً من خًهمٌٌدض خًلٔدرٌص نىل خًطىَش مؼٍ‪ :‬خإلغدفص‪ ، addition‬خًؿُق‬
‫‪ ،subtraction‬خًهمٌٌدض خًظٍ طـُي نىل مٔظىي خًزع (‪.)bitwise operations‬‬
‫طهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪cv2.addWeighted()،cv2.add () :‬‬

‫ظمؼُامصىس‪ُ :‬‬
‫ٌنون ؿمو ضىَطٍن من هالي خًظدرو )( ‪ cv2.add‬ؤو رزٔدؾص من هالي ؿمو خملطفىفدض‬
‫‪ً ، res = img1 + img2.‬ون ًـس ؤن متٌى خملطفىفظٍن نفٕ خًهمم ‪depth‬وخًنىم ‪ type‬ؤو ؤن‬
‫طوىن خملطفىفص خًؼدنٌص كٌمظهد ضلٌلص‪.‬‬
‫مالككص‪ :‬هندن فُق رٍن نمٌٌدض خًـمو خًهًيًص رىخٓؿص ‪Numpy‬ونمٌٌدض خًـمو رىخٓؿص ‪ ،OpenCv‬فدألوىل‬
‫هٍ نمٌٌص ؾُق ؤمد خًؼدنٌص فهٍ نمٌٌص ؿمو رلع‪.‬‬
‫شبهذُاملصبلُامربيل‪ُ :‬‬
‫ٓنلىَ رةنشدء ضىَطٍن رنفٕ خًنىم وٓنـُي نٌٌهٌل نمٌٌص خًـمو مُش ردالٓظهدنص مبوظزص‬
‫‪OpenCv‬ومُش ؤهُي ردالٓظهدنص مبوظزص‬
‫)]‪x = np.uint8([250‬‬
‫)]‪y = np.uint8([10‬‬ ‫‪.Numpy‬‬
‫ذ‬

‫)‪print cv2.add(x,y‬‬ ‫‪# 250+10 = 260 => 255‬‬ ‫خًـمو ردالٓظهدنص رـموظزص‬
‫‪OpenCv‬‬
‫ذ‬
‫]]‪ [[255‬ذ‬

‫خًـمو ردالٓظهدنص رـ ‪numpy‬‬
‫‪print x+y‬‬ ‫‪# 250+10 = 260 % 256 = 4‬‬
‫ذ‬
‫]]‪ [[4‬ذ‬

‫ٓظشدهً خًنظدثف رشوٍ وخغم ننً ؿمو خًطىَطٍن‪ ،‬ومبد ؤن نمٌٌص خًـمو ردالٓظهدنص مبوظزص‬
‫‪ OpenCv‬هدنع نظدثـهد ؤفػٍ ًٍخ ٓنٔظهمٌهد يخمئد ننً خًـمو‪.‬‬
78 ‫ ببساطة‬OpenCv

ُ
ُ :‫دمغُامصىس‬
‫هند ؤًػد نلىَ رـمو خًطىَ وًون نهؿٍ هٍ منهد وِن موظٌف ؤي ٓنهؿٍ هٍ ضىَش شفدفٌص‬
.‫ هٌل هى وخغم يف خًطىَش خًظدًٌص‬،‫موظٌفص نن خألهُي‬

‫وخًطىَش خًؼدنٌص‬0.7 )‫ خًطىَش خألوىل وِنهد (ؤي ملًخَ شفدفٌظهد‬،‫هند ؤهٍند ضىَطٍن ًًمـهم مهد‬
cv2.addWeighted ‫وٓنلىَ رًمف هدطٍن خًطىَطٍن نن ؾًُم خًظدرو‬،0.3 ‫وِنهد‬

import cv2
import numpy as np
from matplotlib import pyplot as plt

img1 = cv2.imread('logo_opencv.png',1)
img2 = cv2.imread('football.jpg',1)

# 600X600 sound cool
# img2 = cv2.resize(img2,(img1.shape[1],img1.shape[0]))
img2 = cv2.resize(img2,(750,600))
img1 = cv2.resize(img1,(750,600))

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

plt.imshow(res)
plt.xticks([]),plt.yticks([])
plt.show()

:‫امنرٌعخ‬
‫‪79‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫ذ‬

‫امػمنٌبدُغىلُمعرىيُامثز‪ُ (bitwise operations(ُ:‬‬

‫طظػمن نمٌٌدض‪ bitwise‬خًهمٌٌدض خًظدًٌص ‪.NOT ،XOR ،OR ،AND‬‬

‫هٍ خًهمٌٌدض ًهد فدثًش هزًنش ننً طلًًً ؤي ؿّء من خًطىَش شوٌه ًٌٕ مٔظؿٌٍ‪ .‬مؼالً يف‬
‫خًربندمف خًظديل ٓنلىَ رىغو شهدَ ‪OpenCv‬نىل ِؤوًص خًطىَش‪ ،‬وهٍخ خألمُ ال ٌنون فهٌه رهمٌٌص‬
‫خًـمو (‪ (Addition‬ألن خًٌىن ٓىف ًظًًن‪ ،‬وال ردًًمف )‪(blending‬ألن خًٌىن ٌٓطزم شفدفد‪ً ،‬ون‬
‫ٌنونند ؤن نفهٍ ًٌى رهمٌٌص خالٓندي ‪ ROI‬هٌل كمند رهد يف هٍخ خًفطٍ وًون خملشوٌص رإن شهدَ‬
‫‪OpenCv‬شوٌه يًن مٔظؿٌٍ ًًٍى ٓنلىَ مبد ًًل‪:‬‬
80 ‫ ببساطة‬OpenCv

import cv2
import numpy as np

# Load two images
img1 = cv2.imread('football.jpg')
img2 = cv2.imread('opencv_logo.png')

# I want to put logo on top-left corner, So I create a ROI
rows,cols,channels = img2.shape
roi = img1[0:rows, 0:cols ]

# Now create a mask of logo and create its inverse mask also
img2gray = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY)
ret, mask = cv2.threshold(img2gray, 10, 255, cv2.THRESH_BINARY)
mask_inv = cv2.bitwise_not(mask)

# Now black-out the area of logo in ROI
img1_bg = cv2.bitwise_and(roi,roi,mask = mask_inv)

# Take only region of logo from logo image.
img2_fg = cv2.bitwise_and(img2,img2,mask = mask)

# Put logo in ROI and modify the main image
dst = cv2.add(img1_bg,img2_fg)
img1[0:rows, 0:cols ] = dst

cv2.imshow('res',img1)
cv2.waitKey(0)
cv2.destroyAllWindows()

‫ذ‬
‫‪81‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامكىد‪ُ :‬‬
‫يف خًزًخًص كمند ردٓظًنخي موظزص ‪OpenCv‬وموظزص ‪ Numpy‬ػم كمند رظلمٌٍ خًطىَطٍن وهّند هٍ‬
‫ضىَش يف مظًًن‪.‬‬
‫‪# I want to put logo on top-left corner, So I create a ROI‬‬
‫‪rows,cols,channels = img2.shape‬‬
‫] ‪roi = img1[0:rows, 0:cols‬‬
‫ذ‬

‫ػم كمند رلُخءش خرهدي ضىَش شهدَ‪( OpenCv‬كظى نهُف خًلـم خًٍي ٓظإهٍه ضىَش‬
‫خًشهدَ ًنلىَ رلـّه يف خًطىَش خًظٍ ٓنػو نٌٌهد خًشهدَ (ضىَش خملٌهس))‪ ،‬وهّند‬
‫كٌمص ضفىف ضىَش خًشهدَ يف خملظًًن ‪ ،row‬وكٌمص خنمًطهد يف خملظًًن ‪،cols‬‬
‫ونًي كنىخطهد يف خملظًًن ‪.channels‬‬

‫ػم كمند رظلًًً مىكو يف خًطىَش خًٍي ٓنػو نٌٌه شهدَ ‪ ،OpenCv‬خملىكو خًٍي‬
‫ٓنػو فٌه خًشهدَ وهى خًّؤوًص خًٌرسي خًهٌٌد ًٌطىَش‪ ،‬وًٌى نن ؾًُم خًوىي‬
‫خًظديل‪:‬‬
‫] ‪ img1[0:rows, 0:cols‬كُخءش خًلٌّ من خًطىَش خًٍي طزًؤ بكًخػٌدطه من )‪)0,0‬‬
‫بىل )‪ )row,col‬وطوًّنه يف خملظًًن ‪( roi‬كٌؽ ‪ row‬و ‪ col‬هٌل ؤرهدي ضىَش شهدَ ‪.)OpenCv‬‬
‫ذ‬

‫‪# Now create a mask of logo and create its inverse mask also‬‬
‫)‪img2gray = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY‬‬
‫)‪ret, mask = cv2.threshold(img2gray, 10, 255, cv2.THRESH_BINARY‬‬
‫)‪mask_inv = cv2.bitwise_not(mask‬‬

‫ذ‬

‫خآلن ٓننشإ كندم(‪ً )mask‬طىَش شهدَ‪.OpenCv‬‬

‫(خًًدًص هند من بنشدء كندم هى طلًًً خملنؿلص خملوظىذ فٌهد شهدَ ‪OpenCv‬فلـ يون طلًًً‬
‫خًوٌفٌص ( ًهمٍ كندم ًٌشهدَ ًـس نٌٌند خًلٌدَ مبد ًًل‪:‬‬
‫ذ‬
‫‪82‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ .8‬طلىًٍ خًطىَش خًظٍ ٓننشإ ًهد خًلندم (هند هٍ ضىَش خًشهدَ) ًٌمٔظىي خًُمديي‪.‬‬
‫‪ .4‬ػم خًلٌدَ ردٓظًندء طدرو ؤٓمه طدرو خًظهظٌس (‪ )threshold‬خًٍي ٓنلىَ من هالًه رلُخءش‬
‫ًىن مهٍن فلـ وًٌى كٔس مـدي خألًىخن خًٍي نًًُ بقهدَه‪ ،‬هند ٓنوظدَ مـدي خًٌىن‬
‫خألٓىي (ٌٓظم ٌسق طدرو خًظهظٌس يف خًفطىي خًالكلص)‬
‫‪ .4‬يف خًنهدًص ٓنلىَ رهوٕ خًظلًًً ألنند ال نًًُ كندم خًٌىن خألٓىي خًٍي كىي خًشهدَ وبمند‬
‫نًًُ بنشدء كندم ًٌشهدَ فلـ ًًٍى كمند رهمٌٌص خًهوٕ نن ؾًُم خًظدرو‬
‫)( ‪ً( cv2.bitwise_not‬ى مل نلم رهمٌٌص خًهوٕ ٓظالكل ؤن خًشهدَ ؤضزم مـىف وٌٓكهُ‬
‫خًٌىن خألٓىي خًٍي كىي خًشهدَ)‬

‫طدرو خًظهظٌس ()‪ cv2.threshold‬وقٌفظه ردهظطدَ بقهدَ مـدي ًىين مهٍن يف خًطىَش‪ ،‬وًإهٍ هٍخ‬
‫خًظدرو خملظًًنخض خًظدًٌص‪:‬‬

‫خملظًًن خألوي هى ؤٓم خًطىَش خملؿٌىرص‪ ،‬خملظًًن خًؼدين وخًؼدًؽ هٌل ؤنىل وؤيىن كٌمص ًٌهظٌص خًٌىنٌص‬
‫خملؿٌىرص (يف مؼدًند نلًي مـدي نظزص خًٌىن خألٓىي)‪ ،‬وخملظًًن خًُخرو هى نىم خًظهظٌس‪.‬‬

‫هند خٓظهمٌند طدرو خًظهظٌس إلقهدَ خًٌىن خألٓىي فلـ‪.‬‬
‫‪# Now black-out the area of logo in ROI‬‬
‫)‪img1_bg = cv2.bitwise_and(roi,roi,mask = mask_inv‬‬

‫ذ‬

‫خآلن نلىَ رهمٌٌص طهظٌم خملنؿلص خًظٍ نًًُ وغو خًشهدَ فٌهد وًٌى نن ؾًُم نمٌٌص ‪.and‬‬
‫‪# Take only region of logo from logo image.‬‬
‫)‪img2_fg = cv2.bitwise_and(img2,img2,mask = mask‬‬

‫ذ‬
‫‪83‬‬ ‫‪ OpenCv‬ببساطة‬

‫هٍخ خًوىي ًلىَ ردٓظوُخؾ منؿلص خًشهدَ فلـ يون خملنؿلص خًٔىيخء (خًوٌفٌص) وطوًّنهد يف‬
‫خملظًًن ‪.img2_fg‬‬
‫‪# Put logo in ROI and modify the main image‬‬
‫)‪dst = cv2.add(img1_bg, img2_fg‬‬
‫‪img1[0:rows, 0:cols ] = dst‬‬
‫ذ‬

‫خآلن ٓنلىَ ردًوؿىش خًنهدثٌص وهٍ بقهدَ خًشهدَ يف خملودن خًٍي كًينده يف ضىَش خملٌهس وًٌى‬
‫نن ؾًُم نمٌٌص خًـمو هٌل هى وخغم يف خًوىي‪ ،‬ػم كمند رهُع نظٌـص خًـمو نىل خًّؤوًص خًٌرسي‬
‫خًهٌٌد من خًطىَش‪.‬‬

‫وؤهًنخ نهُع خًنظٌـص نن ؾًُم خًظدرو )(‪.imshow‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪84‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذلنٌبدُكٌبطُاألداءُوذؽعٌنه ُ‬
‫امهذف‪ُ :‬‬
‫يف مهدًـص خًطىَش نظهدمٍ مو نًي هزًن من خًهمٌٌدض يف خًؼدنٌص‪ ،‬وًًٍى ًـس ننً هظدرص خًوىي ؤال‬
‫نهظم فلـ روظدرظه رشوٍ ضلٌم فلـ‪ ،‬وبمند ًـس نٌٌند خالنظزده ًوظدرص خًوىي رلٌؽ ًظم طنفٌٍ‬
‫خًربندمف ردًشوٍ خألرسم‪.‬‬
‫ًًٍى يف هٍ خًفطٍ ٓنظهٌم مد ًًل‪:‬‬
‫‪ ‬كٌدْ ؤيخء خًربندمف‬
‫‪ ‬رهؼ خًظلٌٔندض ًظلٍٔن خًربندمف‬
‫ٓنظهُف نىل خًظىخرو خًظدًٌص‪cv2.getTickCount, cv2.getTickFrequency :‬‬
‫مبهّي نن موظزص ‪ ،OpenCv‬ردًؼىن ًلًَ ًند وكًش ‪ time‬خًظٍ طٔدنًند نىل كٌدْ خًىكع خًالَِ‬
‫ًظنفٌٍ طهٌٌمص ؤو مـمىنص طهٌٌٌلض‪ ،‬ووكًش ‪ profile‬خًظٍ طهؿٌند طلًُُ هدمٍ نن خًربندمف مؼٍ‪:‬‬
‫خًّمن خملٔظًُق ًظنفٌٍ هٍ طدرو – نًي خملُخض خًظٍ طم خٓظًندء فٌهد هٍ طدرو ‪......‬خًى‪.‬‬

‫كٌبطُاألداءُغنُػشًمُمكرثخُ‪ُ OpenCv‬‬
‫امربتؼُُُ‪ً cv2.getTickCount‬هؿٌند نًي يوَخض خًٔدنص (‪ )clock-cycles‬خًظٍ طم خٓظًُخكهد‬
‫ًظنفٌٍ ؤمُ ؤو نًش ؤوخمُ يف خًربندمف‪.‬‬
‫امربتؼُ‪ً cv2.getTickFrequency‬هؿٌند طُيي يوَخض خًٔدنص(‪ ،)clock-cycle‬ؤو نًي يوَخض‬
‫خًٔدنص يف خًؼدنٌص‪.‬‬
‫إلًـدي ِمن طنفٌٍ خًوىي ردًؼىخين نٌٌى ؤن طوظس هٌل ًًل‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)(‪e1 = cv2.getTickCount‬‬

‫‪# your code execution‬‬

‫)(‪e2 = cv2.getTickCount‬‬
‫)(‪time = (e2 - e1)/ cv2.getTickFrequency‬‬

‫مصبل‪ُ :‬‬
‫‪85‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪import cv2‬‬
‫‪import numpy as np‬‬

‫)'‪img1 = cv2.imread(' brid.jpg‬‬

‫)(‪e1 = cv2.getTickCount‬‬

‫‪for i in xrange(5,49,2):‬‬
‫)‪img1 = cv2.medianBlur(img1,i‬‬

‫)(‪e2 = cv2.getTickCount‬‬

‫)(‪t = (e2 - e1)/cv2.getTickFrequency‬‬
‫‪print t‬‬
‫‪# Result I got is 0.521107655 seconds‬‬
‫ذ‬

‫مالككص‪ٌ :‬نونى كٌدْ خًىكع ؤًػد نن ؾًُم خًىكًش ‪ ،time‬رلٌؽ ًلٔس فُق خًىكع رٍن خٓظًندء خًظدرو يف‬
‫ؤوي مُش وننً خٓظًندثه يف خملُش خًؼدنٌص )(‪.time.time‬‬
‫‪ .1‬احللذادلثاؾيذاالػرتاضيذيفذ‪ :OpenCv‬ذ‬

‫طظػمن ‪OpenCv‬خًهًًً من خًظىخرو خًظٍ ٌنون طنفٌٍهد رشوٍ مؼديل‪ ،‬فًٌٍى بٌخ هدن ًًًند نكدَ‬
‫ًًنم هدضٌص ؿهٍ خًوىي مؼديل ؤَ ال ننًهد ًـس خٓظًالي هٍه خًودضٌص (طلًُزد مهكم خملهدًـدض‬
‫خًـًًًش طًنم هٍه خًودضٌص) وطوىن مفهٌص ننً طنفٌٍ خًربندمف رشوٍ خفرتخيض‪.‬‬

‫ملهُفص هٍ ِمن طنفٌٍ خًوىي مؼديل ؤَ ال نلىَ ردٓظًندء خًظدرو )(‪ cv2.useOptimized‬خًٍي‬
‫ًهًٌ ًند كٌمص ‪ TRUE‬بٌخ هدنع هدضٌص خًوىي خملؼديل ممونص وبال ٌٓهؿٌند ‪FALS‬‬
‫هٌل ٌنونند طفهٌٍ وبًًدء طفهٌٍ هٍه خًودضٌص نن ؾًُم خًظدرو )(‪.cv2.setUseOptimized‬‬
‫شدهً خًوىي خًظديل‪:‬‬
‫‪# check if optimization is enabled‬‬

‫)(‪cv2.useOptimized‬‬
‫‪TRUE‬‬
‫)‪%timeit res = cv2.medianBlur(img,49‬‬
‫ذ‬

‫ذ‬ ‫‪10 loops, best of 3: 34.9 ms per loop‬‬
‫‪86‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪# Disable it‬‬

‫)‪cv2.setUseOptimized(False‬‬
‫ذ‬

‫)(‪cv2.useOptimized‬‬
‫ذ‬

‫‪FALSE‬‬

‫)‪%timeit res = cv2.medianBlur(img,49‬‬
‫ذ‬

‫‪ 10 loops, best of 3: 64.1 ms per loop‬ذ‬

‫هم شدهًند يف خألهىخي خًٔدرلص رإنه ننً طفهٌٍ هدضٌص خملؼدًٌص يف خًوىي ٌٓوىن ؤرسم رلىخيل‬
‫خًػهفٍن من خًوىي خًٍي نًٌٍ طفهٌٍ هٍه خًودضٌص فٌه‪.‬‬
‫‪ .2‬ؼقاسذاألداءذيفذ‪:IPython‬‬

‫ؤكٌدند نلظدؾ رإن نلٌٕ ؤيخء نمٌٌظٍن مظشدرهظٍن‪.‬‬
‫رٌجص ‪IPython‬طّويند رهٍخ خألمُ خًٔلُي نن ؾًُم خًظهٌٌمص ‪.%timeit‬‬
‫هٍه خًظهٌٌمص طشًٍ خًربندمف نًش مُخض ًظهؿٌند ؤيق وؤفػٍ نظٌـص‪.‬‬
‫وهٍه خًؿًُلص مندٓزص ؤًػد ًٌظهٌٌٌلض خملفُيش‪.‬‬
‫مؼال هٍ طهُف ؤي من نمٌٌدض خًـمو خًلٔدرٌص ؤفػٍ‬

‫)‪ x = 5; y = x**2, x =5; y = x*x, x = np.uint8([5]); y = x*x or y = np.square(x‬؟‬

‫هٍخ مد ٓنهُفه من هالي خألمُ خًظديل‪:‬‬
‫ذ‬

‫‪x=5‬‬

‫‪%timeit y=x**2‬‬
‫ذ‬

‫ذ‬ ‫‪10000000 loops, best of 3: 73 ns per loop‬‬
‫‪87‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪%timeit y=x*x‬‬
‫ذ‬

‫ذ‬ ‫‪10000000 loops, best of 3: 58.3 ns per loop‬‬

‫)]‪z = np.uint8([5‬‬

‫‪%timeit y=z*z‬‬
‫ذ‬

‫ذ‬ ‫‪1000000 loops, best of 3: 1.25 us per loop‬‬

‫)‪%timeit y=np.square(z‬‬
‫ذ‬

‫ذ‬ ‫‪1000000 loops, best of 3: 1.16 us per loop‬‬

‫ٌنونند خالٓظنظدؾ ردن نمٌٌص خًٍصذ ‪ y=x*x‬ؤرسم رلىخيل ‪20‬مُش ملدَنص مو ‪Numpy‬‬
‫وبٌخ ؤهٍند رهٍن خالنظزدَ بنشدء خملطفىفدض فلً ًطٍ ًلىيل رسنص ؤنىل رـ ‪ 100‬مُش‪ ،‬يشء يًُس‬
‫ؤًٌٕ هًٍى؟ (هٍه خًؼًُش يف موظزص ‪ًNumpy‬ـُي خًهمٍ نىل بضالكهد)‬

‫‪ ‬نمٌٌدض خألَكدَ يف ردًؼىن ؤرسم من خًهمٌٌدض خًظٍ طظم يف ‪ Numpy‬ردًنٔزص ًٌهمٌٌدض خًظٍ طظػمن‬
‫ننرص ؤو ننرصًن‪.‬‬
‫‪ ‬خٓظهٌلي ‪ً Numpy‬وىن ًه فدثًش ننً خِيًدي كـم خملطفىفص كٌٌال‪.‬‬
‫ذ‬
‫ٓنلىَ خآلن رظـًُس مؼدي آهُ‪ .‬يف هٍه خملُش ٓنلدَن ؤيخء خًظدرهٍن )(‪،cv2.countNonZero‬‬
‫)(‪ً np.count_nonzero‬نفٕ خًطىَش‪.‬‬
‫ذ‬
‫)‪%timeit z = cv2.countNonZero(img‬‬
‫ذ‬
‫ذ‬ ‫‪100000 loops, best of 3: 15.8 us per loop‬‬
‫ذ‬
‫)‪%timeit z = np.count_nonzero(img‬‬
‫ذ‬
‫‪1000 loops, best of 3: 370 us per loop‬‬
‫‪88‬‬ ‫‪ OpenCv‬ببساطة‬

‫ٓنالكل ؤن طىخرو ‪cv2‬ؤرسم رلىخيل ‪ 25‬مُش من طىخرو ‪Numpy‬‬

‫مالككص‪ :‬نديش ِمن طنفٌٍ طىخرو ‪OpenCv‬ؤرسم روؼًن من خًّمن خملٔظًُق يف ‪Numpy‬وًٌى ًنفٕ خًهمٌٌص‪،‬‬
‫ًون هندن خٓظؼندءخض وًٌى ننً خٓظهٌلي موظزص ‪ًٌNumpy‬هُع رًي خًنٔى‪.‬‬

‫األ ُوامشُامعؽشًخُمـُ ‪ُ :IPython‬‬
‫ًىؿً هندن خًهًًً من خألوخمُ خًٔلًُص ًلٌدْ خأليخء وؤوخمُ إلنؿدء مللص موظرصش نن خًوىي وؤمُ‬
‫إلنؿدء مللص نن ؤي ٓؿُ من خًوىي‪ ،‬وؤمُ ًلٌدْ كـم خًٍخهُش خًظٍ خٓظهٌوهد خًربندمف‪.‬‬

‫‪ .3‬اخلطواتذاؾيتذجيبذاتباعفاذؾؾحصولذعؾىذاألداءذادلثاؾي‪ :‬ذ‬

‫ننً هظدرص خًربندمف نٌٌى ؤوال ؤن طىؿً خًشوٍ خًٍي ٓظؿزم ره خًوىخَِمٌص رشوٍ رٌٔـ ػم‬ ‫‪‬‬
‫طىغم نمٌهد رشوٍ ضلٌم‪ ،‬ػم طىؿً خملشدهٍ خًظٍ فٌهد‪ ،‬ػم طىؿً ؤمؼٍ (ؤفػٍ) كٍ ًظوظس‬
‫ره خًوىخَِمٌص‪.‬‬
‫طـنس خٓظوًخَ خًلٌلدض رزدًؼىن كًَ خإلمودن وهطىضد خًلٌلدض خًؼندثٌص وخًؼالػٌص‬ ‫‪‬‬
‫(‪( double/triple loops‬نكُخ ًزؿجهد‬ ‫‪‬‬
‫خٓظفً من خملظًًنخض خملهُفص مٔزلد‬ ‫‪‬‬
‫ال طنٔى خملطفىفدض مدمل طلظف ًهد‪ ،‬وكإوي خٓظوًخَ خًهُع رً ًال نن نٔوهد ألن نٔوهد‬ ‫‪‬‬
‫نمٌٌص موٌفص ًٌىكع‬
‫كظى رهً طؿزٌم خًوؿىخض خًٔدرلص بن رلٍ رُندمـى رؿٌجدً ؤو مل ًهً ممون طهًًٌه‪ ،‬ننًهد‬ ‫‪‬‬
‫ٌنونى خًظرسًو ردٓظوًخَ موظزدض مؼٍ ‪ًcython‬ـهٍ خًربندمف ؤرسم‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪89‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫الفصل الثالث‬

‫” هناك اختياران مبدئيان في الحياة‪ :‬إما أن تتقبل‬
‫ظروف الوضع الحالي كما هي‪ ،‬أو أن تتقبل مسؤولية‬
‫تغيير هذا الوضع ‟‬
‫د‪ .‬دينيس ويتلي – كاتب ومحاضر أمريكي‬
‫‪91‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُامصبمض‪ُ:‬مػبمعخُامصىسحُيفُ‪ُ OpenCv‬‬
‫‪ ‬طًًٌن خًفػدءخض خًٌىنٌص ‪Changing ColorSpaces‬‬
‫‪ٓ ‬ظظهٌم ؾًُلص طًًٌن فػدء خًطىَش ملوظٌف خًفػدءخض خًٌىنٌص‬
‫‪ ‬طهٌم طهلس ؿٔم مٌىن يف خًفًًٌى‬

‫‪ ‬طهظٌس خًطىَش (خًظهظٌس‪ :‬هى نمٌٌص بقهدَ نظزص ًىنٌص مهٌنص)‬
‫‪Image Thresholding‬‬

‫ٓظظهٌم هٌف طلىي خًطىَش ًطىَش ػندثٌص (فلـ ؤرٌؼ وؤٓىي) وًٌى‬
‫ردٓظوًخَ بكًي خًؿُق‪:‬‬
‫خًظهظٌس خًهدَ ‪ ،global thresholding‬خًظهظٌس خملظوٌف ‪Adaptive‬‬
‫‪ ،thresholding‬خًظلىًٍ خًؼنديئ ال وطٔى ‪Otsu’s banalization‬‬
‫‪ ‬خًظلىًالض خًهنًٌٓص نىل خًطىَ ‪Geometric Transformations‬‬
‫‪of Images‬‬

‫ٓظظهٌم هٌف طؿزٌم موظٌف خًظلىًالض خًهنًٌٓص نىل خًطىَش مؼٍ‬
‫خًًوَخن وطلٌٌٍ خًطىَش و ‪......‬خًى‬
‫‪ ‬طهًٍس خًطىَش ‪Smoothing Images‬‬
‫طهٌم هٌفٌص ؾمٕ خًطىَش‪ ،‬فٌرتش خًطىَش‬

‫‪ ‬خًظلىًالض من خًندكٌص خًشوٌٌص (‪)Morphological‬‬
‫‪:Morphological Transformations‬‬

‫خًظهُف نىل خًظلىًالض خًشوٌٌص خًظٍ طظم نىل خًشوٍ مؼٍ خًظأهٍ‪،‬‬
‫خًظمًي‪ ،‬خًفظم‪ ،‬خإليالق‬
‫طًَؿدض خًطىَش ‪:Image Gradients‬‬

‫طهٌم بًـدي طًَؿدض خًطىَش وبًـدي كىخفهد‪.‬‬

‫موظشف كىخف هدين ‪Canny Edge Detection‬‬ ‫‪‬‬
‫‪92‬‬ ‫‪ OpenCv‬ببساطة‬

‫طهٌم بًـدي خًلىخف (كًوي خًشوٍ) مو موظشف كىخف هدين‬ ‫‪‬‬

‫‪ ‬ؤهُخمدض خًطىَش ‪:Image Pyramids‬‬

‫خًظهُف نىل ؤهُخمدض خًطىَش وؾًُلص خٓظوًخمهد ملّؾ خًطىَش‬

‫‪ ‬ملدَنص خًلىخًس ‪Template Matching‬‬

‫طهٌم خًزلؽ نن ؤي هدثن يف خًطىَش ردٓظوًخَ مؿدرلص خًلىخًس‬

‫‪ ‬طلىًٍ هدف ًٌوـ ‪Hough Line Transform‬‬

‫طهٌم خهظشدف خًوؿىؽ خًظٍ يف خًطىَش‪.‬‬

‫‪ ‬طلىًٍ هدف ًًٌوخثُ ‪Hough Circle Transform‬‬
‫‪ ‬طهٌم خهظشدف نن خًًوخثُ يف خًطىَش‪.‬‬

‫‪ ‬طلؿٌو خًطىَش ردٓظوًخَ هىخَِمٌص ‪:Watershed‬‬
‫‪ ‬طهٌم طلٌٔم خًطىَش رؿًُلص خملـمهدض خملدثٌص)‪(Watershed‬‬

‫خالشظلدق خألمدمٍ خًظفدنًل ردٓظوًخَ هىخَِمٌص ‪GrabCut‬‬

‫طهٌم هىخَِمٌص ‪GrabCut‬الٓظوُخؾ خألؿٔدَ خألمدمٌص يف خًطىَش‪.‬‬
‫‪93‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذغٌريُامفظبءادُامنىنٌخُ‪ُ Changing Color spaces‬‬

‫اهلدف‪:‬‬

‫يف هٍخ خًفطٍ ٓنظهٌم ؾًُلص خًظلىًٍ من فػدء ًىين بىل آهُ‪ ،‬مؼالً من‪BGR ↔ Gray‬‬
‫ومن ‪BGR↔HSV‬‬
‫ردإلغدفص بىل ًٌى ٓننشح طؿزٌم ًٔظوُؾ ؿٔم مهٍن يف خًفًًٌى‬
‫طهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪cv2.inRange()،cv2.cvtColor() :‬‬

‫‪ -1‬ذغٌريُامفظبيئُامنىين ُ‬

‫هندن ؤهًت من ‪ 805‬ؾًُلص ًظًًٌن خًفػدءخض خًٌىنٌص مظدكص يف ‪ .OpenCv‬وًون ٓنًَْ فلـ‬
‫خًظلىًٍ من خًفػدثٌٍن خًٌىنٌٍن خألهًت خنظشدَخ ً وهٌل‪:‬‬
‫‪BGR↔Gray‬و ‪BGR↔HSV‬‬
‫ًظًًن خًفػدء خًٌىين ٓنٔظوًَ خًظدرو )‪ cv2.cvtColor(input_image, flag‬كٌؽ كٌمص خملظًًن‬
‫‪flag‬هٍ خًظٍ ٓىف طلًي ًند نىم خًظلىًٍ‪ .‬مؼال ًٌظلىًٍ من ‪ BGR‬بىل ‪ GRAY‬طوىن كٌمص‬
‫خملظًًن ‪flag‬هٍ ‪ cv2.COLOR_BGR2GRAY‬وًٌظلىًٍ من ‪ BGR‬بىل ‪ HSV‬نٔظهمٍ خملظًًن‬
‫‪cv2.COLOR_BGR2HSV‬‬
‫‪94‬‬ ‫‪ OpenCv‬ببساطة‬

‫ملهُفص كٌم خًفػدءخض خألهُي خًظٍ ًإهٍهد خملظًًن ‪ flag‬شًٍ خًوىي خًظديل‪:‬‬
‫‪import cv2‬‬
‫])'_‪flags = [i for i in dir(cv2) if i.startswith('COLOR‬‬
‫‪for x in flags:‬‬
‫‪print x‬‬
‫ذ‬

‫‪COLOR_BAYER_BG2BGR‬‬
‫‪COLOR_BAYER_BG2BGR_VNG‬‬
‫‪COLOR_BAYER_BG2GRAY‬‬
‫‪COLOR_BAYER_BG2RGB‬‬
‫‪COLOR_BAYER_BG2RGB_VNG‬‬
‫‪COLOR_BAYER_GB2BGR‬‬
‫‪COLOR_BAYER_GB2BGR_VNG‬‬
‫‪COLOR_BAYER_GB2GRAY‬‬
‫‪COLOR_BAYER_GB2RGB‬‬
‫‪COLOR_BAYER_GB2RGB_VNG‬‬
‫‪COLOR_BAYER_GR2BGR‬‬
‫‪COLOR_BAYER_GR2BGR_VNG‬‬
‫‪COLOR_BAYER_GR2GRAY‬‬
‫‪.......‬‬

‫‪etc...‬‬

‫مالككص‪ :‬يف خًفػدء ‪ HSV‬مـدي خًٔؿىم هى ]‪ ،[0 , 179‬مـدي خإلشزدم ]‪ ،[0 , 255‬مـدي خًلٌم ]‪.[0 , 255‬‬
‫ومـدالض خًلٌم هٍه كً طوظٌف من رُندمف آلهُ‪ًًٍ ،‬ى بٌخ كدَنع كٌم‪OpenCv‬رًًنهد ٓظلظدؾ ًالنظزده ًؿزٌهٌص‬
‫هٍه خملـدالض‪.‬‬
‫‪ -2‬تعؼبذاألجدام ذ‬

‫طهٌمند ًٌظى هٌف نلىي خًطىَش من خًفػدء ‪ BGR‬بىل خًفػدء ‪ ،HSV‬وخآلن ٌنونند خٓظهٌلي هٍه‬
‫خًودضٌص يف خٓظوُخؾ ؿٔم مٌىن‪ .‬يف خًفػدء ‪ٌ HSV‬نون متؼٌٍ خألًىخن رٔهىًص ؤهرب من خًفػدء‬
‫‪BGR‬ؤًدنًند نىل متٌٌّ خألًىخن يف قُوف خإلغدءش خملوظٌفص ألنه ًهظم ردًٔؿىم‪ .‬يف طؿزٌلند‬
‫خًظديل ٓنلىَ ردٓظوُخؾ ؿٔم مٌىن ؤَِق من فًًٌى وًٌى نن ؾًُم نمٍ مد ًًل‪:‬‬

‫‪ )8‬نإهٍ هٍ بؾدَ من خًفًًٌى‬
‫‪ )4‬نلىي من ‪ BGR‬بىل ‪HSV‬‬
‫‪ )4‬نلىَ رظهظٌس خًطىَش خمللىًص وًٌى نن ؾًُم ؤهٍ نظزص خًٌىن خملؿٌىذ (هند ٓنإهٍ نظزص‬
‫خًٌىن خألَِق)‬
95 ‫ ببساطة‬OpenCv

‫ وننً ًٌى ٌنونى خٓظوًخَ هٍه خًنظٌـص‬،‫) ٓنلطٍ ردًنهدًص نىل خًـٔم خملٌىن ردألَِق ًىكًه‬3
.‫يف خًظؿزٌم خًٍي طًًُه‬

:‫خًوىي خًظديل ًىغم هٍه خًوؿىخض‬

import cv2
import numpy as np

cap = cv2.VideoCapture(0)

while(1):
# Take each frame
_, frame = cap.read()

# Convert BGR to HSV
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)

# define range of blue color in HSV
lower_blue = np.array([110,50,50])
upper_blue = np.array([130,255,255])

# Threshold the HSV image to get only blue colors
mask = cv2.inRange(hsv, lower_blue, upper_blue)

# Bitwise-AND mask and original image
res = cv2.bitwise_and(frame,frame, mask= mask)

cv2.imshow('frame',frame)
cv2.imshow('mask',mask)
cv2.imshow('res',res)
k = cv2.waitKey(5) & 0xFF
if k == 27:
break
cv2.destroyAllWindows()

‫ذ‬
‫‪96‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامكىد ُ‬
‫)‪cap = cv2.VideoCapture(0‬‬
‫ذ‬

‫خٓظًندء طدرو خًظلدؽ خًفًًٌى وطوًّن بؾدَخض خًطىَ (خًفٌُندض ‪ )Frames‬خًظٍ طوىن خًفًًٌى يف‬
‫خملظًًن ‪cap‬‬
‫‪# Take each frame‬‬
‫)(‪_, frame = cap.read‬‬
‫ذ‬

‫‪ ‬خًوؿىش خألوىل‪ :‬نلطٍ نىل هٍ بؾدَ يف خًفًًٌى‪.‬‬
‫خًظدرو )(‪ً cap.read‬هؿٌند بؾدَخض خًطىَ خملٌظلؿص ‪ ،‬وغهند َمّ خًشلؿص ( _ ) يف خملظًًن‬
‫خألوي ألنند ال نًًُه ونًًُ فلـ خٓظهٌلي خملظًًن خًؼدين ‪ frame‬خًٍي ٓظوّن رًخهٌه بؾدَ خًطىَش‬
‫خملٌظلـ‪.‬‬
‫(طم ٌسق هٍخ خألمُ مٔزلدً يف خًفطٍ خًؼدين)‪.‬‬
‫‪# Convert BGR to HSV‬‬
‫)‪hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV‬‬

‫‪ ‬خًوؿىش خًؼدنٌص‪ :‬طلىًٍ خًطىَ خملٌظلؿص من خًفػدء خًٌىين ‪ BGR‬بىل ‪.HSV‬‬
‫‪ ‬خًوؿىش خًؼدًؼص‪ :‬هٍ طهظٌس خًطىَش (ؤي ٓنإهٍ مـدي ًىين مهٍن إلقهدَه ًىكًه)‬
‫مبهنى ؤهُ نلطً ردًظهظٌس هند هى نمٍ كندم ملـدي ًىين مهٍن يف خًطىَش رلٌؽ ٌٓكهُ هٍخ‬
‫خًٌىن ردألرٌؼ وؤي ًىن هدَؾ خملـدي خًٌىين خًٍي خهرتنده ٌٓوىن ردًٌىن خألٓىي‪ .‬وًٌى نن ؾًُم‬
‫خًظهٌٌٌلض خًظدًٌص‪:‬‬
‫‪# define range of blue color in HSV‬‬
‫)]‪lower_blue = np.array([110,50,50‬‬
‫)]‪upper_blue = np.array([130,255,255‬‬
‫ذ‬

‫نلىَ رظهًُف كًي (نظزظٍ) خملـدي خًٌىين خًٍي نًًُه يف خًفػدء ‪( HSV‬هند خهرتند مـدي خًٌىن‬
‫خألَِق)‬
‫كمند رإهٍ ؤكٍ نظزص ًىنٌص ملـدي خًٌىن خألَِق وهّندهد يف خملظًًن ‪lower_blue‬‬
‫وؤهٍند ؤهرب نظزص ًىنٌص ملـدي خًٌىن خألَِق وهّندهد يف خملظًًن ‪upper_blue‬‬
‫‪97‬‬ ‫‪ OpenCv‬ببساطة‬

‫)‪mask = cv2.inRange(hsv, lower_blue, upper_blue‬‬
‫ذ‬

‫كمند رظوًّن خملـدي خًٌىين (رٍن كٌمظٍ خًهظزظٍن خًظٍ خهرتندهٌل) خًٍي نًًُه يف خملظًًن ‪mask‬‬
‫وًٌى نن ؾًُم خًظدرو)(‪.cv2.inRange‬‬
‫‪# Bitwise-AND mask and original image‬‬
‫)‪res = cv2.bitwise_and(frame,frame, mask= mask‬‬
‫ذ‬

‫نلىَ رهمٍ نمٌٌص ‪ًٌ and‬كهُ خملـدي خًٌىين خًٍي خهرتنده فلـ يون خملـدالض خًٌىنٌص خألهُي‪.‬‬

‫ذ‬

‫يف مؼدًند هٍخ مؼٌند خًٌىن خألَِق ردًىخكً فةٌخ هدن خًٌىن خًٍي يف خًطىَش رنفٕ كٌمص خملـدي خًٌىن‬
‫خألَِق ٌٓهؿٌند‪8‬‬
‫(‪)1 AND 1 = 1‬ذذذذذذذذذذذذذ(أزرقذ‪AND‬ذأزرقذ=ذ‪ )1‬ذ‬

‫وؤي ًىن ًٌٕ غمن خملـدي خًٌىين خألَِق ٌٓوىن ننًهد ندطف نمٌٌص ‪ AND‬هى ‪( 5‬خًٌىن خألٓىي)‪.‬‬
‫)‪cv2.imshow('frame',frame‬‬
‫)‪cv2.imshow('mask',mask‬‬
‫)‪cv2.imshow('res',res‬‬
‫ذ‬

‫كم رهُع خًطىَ خملٌظلؿص (ٌٓظم نُغهد نىل شوٍ فًًٌى رٔزس رسنص طلًًؽ خًظلدؽ خًطىَ‬
‫خًهدًٌص)‪ ،‬ونُع خًلندم‪ ،‬ونُع خًـٔم خألَِق فلـ يون يًنه من خألًىخن‪ .‬الكل رإن هندن رهؼ‬
‫خًػـٌف يف خًطىَش‪ٓ ،‬رني يف خًفطىي خًلديمص هٌف ٓنًٍّ هٍخ خًػـٌف‪.‬‬

‫مالككص‪ :‬هٍخ ؤرٔـ ؾًُلص ًظهلس ؿٔم‪ ،‬وننًمد طلرتف طىخرو خإلؾدَخض ‪ٌٓ contours‬وىن بمودنى خًلٌدَ‬
‫ردًهًًً من خألشٌدء مؼٍ بًـدي مُهّ خًـٔم‪ ،‬طهلس خألؿٔدَ‪َٓ ،‬م َٓىمدض مبـُي طلًُى ًًن ؤمدَ خًودمًنخ‪،‬‬
‫وطهٌم خًهًًً من خألشٌدء خملمظهص يف خًفطىي خًلديمص‪.‬‬
‫ذ‬
‫‪98‬‬ ‫‪ OpenCv‬ببساطة‬

‫كٌفُميكننبُبًعبدُاملٌمخُامنىنٌخُاملؼنىةُذػلثهبُيفُامفظبءُ‪HSV‬؟ ُ‬
‫هٍخ خًٔاخي ًهً من خألٓجٌص خًشدثهص خًظٍ ط ُٔإي نىل خملىكو خملهىَ ‪.stackoverflow.com‬‬
‫روٍ رٔدؾص ٌنونى مهُفص خًلٌمص خًٌىنٌص خملؿٌىرص غمن ‪HSV‬وًٌى نن ؾًُم خًظدرو خًٍي‬
‫خٓظهمٌنده ٓدرلدً )(‪ً cv2.cvtColor‬ون رًي متًُُ كٌمص خًطىَش ًٌظدرو منَُ ًه خًلٌمص خًٌىنٌص خًظٍ‬
‫نًًُهد يف ‪ .BGR‬نىل ٓزٌٍ خملؼدي إلًـدي كٌمص خًٌىن خألهٍص يف ‪ HSV‬نوظس خألوخمُ خًظدًٌص‪:‬‬

‫)]]] ‪green = np.uint8([[[0,255,0‬‬
‫)‪hsv_green = cv2.cvtColor(green,cv2.COLOR_BGR2HSV‬‬
‫‪print hsv_green‬‬
‫ذ‬
‫]]]‪[[[ 60 255 255‬‬

‫خآلن ٌنونى ؤهٍ ؤيىن كٌمص وؤنىل كٌمص ملـدي خًٌىن خألهٍص ردطزدم خًلدنًش خًظدًٌص‪:‬‬
‫]‪ُ [H-10, 100,100] and [H+10, 255, 255‬‬
‫خًلدنًش (]‪ )[H+10] ،[H-10‬ال طهمٍ يخمئدً مهند‪ًًٍ ،‬ى ًفػٍ ؤن طلًي ًًوًد رنفٔى ؤنىل وؤيىن‬
‫كٌمص نن ؾًُم متًُُ ؤيىن كٌمص ًهظزص ًٌىن خألهٍص يف ‪ RGB‬وؤنىل كٌمص ًهظزص ًٌىن خألهٍص يف‬
‫‪.RGB‬‬
‫متًُن‪ :‬ؿُذ رنفٔى خٓظوُخؾ ؤهًت من ؿٔم مٌىن رنفٕ خًىكع مؼال خألؿٔدَ خًَّكدء وخًوٍصخء‬
‫وخًلمُخء‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪99‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذػرٌجُامصىسحُُُ‪ُ Image Thresholding‬‬

‫ُ‬
‫امرػرٌج‪ُ:‬هىُبظهبسُغرثخُمىنٌخُمػٌنخُغنذمبُنلىلُغرثنبُامصىسحُؤيُؤظهشنبُمعرىيُمىينُ‬
‫مؽذدُيفُامصىسح ُ‬

‫‪Original image‬‬ ‫‪Thresholding‬‬

‫ذ‬

‫امهذف ُ‬
‫‪ ‬يف هٍخ خًًَْ ٓنًَْ خًظهظٌس خًزٌٔـ‪ ،‬وخًظهظٌس خملظوٌف‪ ،‬وطهظٌس ؤوطٔى‪.‬‬
‫‪ٓ ‬نظهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪cv2.threshold, cv2.adaptiveThreshold :‬‬
‫ذ‬

‫‪ -1‬اؾتعتقبذاؾبدقطذ(‪:(Simple Thresholding‬ذ‬

‫هٍه خًؿًُلص رٌٔؿص‪ ،‬ننًمد طفىق كٌمص خًزٌؤٍ كٌمص ملًيش‪ًٔ ،‬نً ًه ‪(1‬خرٌؼ يدًزد)‪ ،‬وبال ًٔنً‬
‫ًه ‪(0‬يدًزد خًٌىن خألٓىي( ‪ ،‬خًظدرو خملٔظوًَ ًهٍه خًهمٌٌص هى)(‪.cv2.threshold‬‬
‫رشػُامربتؼُ)(‪ُ :cv2.threshold‬‬
‫املرغريُاأل ُول‪ٌ :‬نؼٍ خًطىَش خملؿٌىرص‪ ،‬وًـس ؤن طوىن هٍه خًطىَش ردملٔظىي خًُمديي‪.‬‬
‫املرغريُامصبينُوامصبمض‪ :‬هٌل ؤيىن وؤنىل كٌمص ًٌهظزص خًظٍ ٓظطنف خًزٌؤالض من هالًهد‪.‬‬
‫املرغريُامشاتؼ‪ :‬طلًَ موظزص ‪ًOpenCv‬ند نًش هٌدَخض ًٌظهظٌس وًظم طلًًً ًٌى نن ؾًُم‬
‫هٍخ خملظًًن‬
‫‪cv2.THRESH_BINARY‬‬
‫‪cv2.THRESH_BINARY_INV‬‬
‫‪cv2.THRESH_TRUNC‬‬
100 ‫ ببساطة‬OpenCv

cv2.THRESH_TOZERO
‫ ذ‬cv2.THRESH_TOZERO_INV

‫ذ‬

:‫ٓنلىَ رظؿزٌم هٍ هٍه خألنىخم يف خًوىي خًظديل‬

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('gradient.bmp',0)
ret,thresh1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
ret,thresh2 = cv2.threshold(img,127,255,cv2.THRESH_BINARY_INV)
ret,thresh3 = cv2.threshold(img,127,255,cv2.THRESH_TRUNC)
ret,thresh4 = cv2.threshold(img,127,255,cv2.THRESH_TOZERO)
ret,thresh5 = cv2.threshold(img,127,255,cv2.THRESH_TOZERO_INV)

titles = ['Original Image','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
images = [img, thresh1, thresh2, thresh3, thresh4, thresh5]

for i in xrange(6):
plt.subplot(2,3,i+1),plt.imshow(images[i],'gray')
plt.title(titles[i])
plt.xticks([]),plt.yticks([])

plt.show()

ُ :‫امنرٌعخ‬
101 ‫ ببساطة‬OpenCv

‫ذ‬

ُ :‫رشػُامكىد‬
img = cv2.imread('gradient.bmp',0)
‫ذ‬

img ‫كُخءش خًطىَش وطوًّنهد يف خملظًًن‬
ret,thresh1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
ret,thresh2 = cv2.threshold(img,127,255,cv2.THRESH_BINARY_INV)
ret,thresh3 = cv2.threshold(img,127,255,cv2.THRESH_TRUNC)
ret,thresh4 = cv2.threshold(img,127,255,cv2.THRESH_TOZERO)
ret,thresh5 = cv2.threshold(img,127,255,cv2.THRESH_TOZERO_INV)
‫ذ‬

)ً‫(طم ٌسكه ٓدرلد‬cv2.threshold() ‫كمند رظهظٌس خًطىَش ردٓظوًخَ طدرو خًظهظٌس خًزٌٔـ‬
:‫ ًهًٌ نظٌـظٍن‬cv2.threshold() ‫خًظدرو‬
.)‫ ٌٓظم ٌسكهد الكلد يف كٔم (خًظلىًٍ خًؼنديئ ال وطٔى‬retval ٍ‫خًنظٌـص خألوىل ه‬
.‫ خًطىَش خًظٍ طم طهظٌزهد‬threshold ٍ‫وخًنظٌـص خًؼدنٌص ه‬

titles = ['Original Image','BINARY','BINARY_INV','TRUNC','TOZERO','TOZERO_INV']
‫ذ‬
‫‪102‬‬ ‫‪ OpenCv‬ببساطة‬

‫بنؿدء ؤٌٓلء ًٌنىخفٍ خًظٍ ٌٓظم فظلهد وهّند هٍه خألٌٓلء يف مطفىفص ٓمٌندهد ‪titles‬‬

‫]‪images = [img, thresh1, thresh2, thresh3, thresh4, thresh5‬‬
‫ذ‬

‫طوــًّن كٌمــص خًطــىَش ونظٌـــص خًظهظٌــس خألوىل وخًؼدنٌــص وخًؼدًؼــص وخًُخرهــص وخًودمٔــص يف مطــفىفص‬
‫ٓمٌندهد ‪images‬‬

‫‪for i in xrange(6):‬‬
‫)'‪plt.subplot(2,3,i+1),plt.imshow(images[i],'gray‬‬
‫)]‪plt.title(titles[i‬‬
‫)][(‪plt.xticks([]),plt.yticks‬‬
‫ذ‬

‫‪ ‬كمند رةنشدء كٌلص ‪for‬كظى نكهُ نن ؾًُلهد خًنىخفٍ خًظٍ ٓظهُع ًند نظدثف خًظهظٌس‪.‬‬
‫‪Plt.subplot ‬طدرو يف موظزص ‪ matplotlib‬وقٌفظه بقهدَ ؤهًت من ضىَش يف ندفٍش وخكًش‬
‫(ؤوي مظًًن وػدين مظًًن هٌل كـم خًندفٍش‪ ،‬وػدًؽ مظًًن ًلًي نًي خًنىخفٍ)‬
‫‪ُPlt.imshow() ‬طدرو ًظهٌجص نُع خًطىَ خملؿٌىرص‪.‬‬
‫‪ Plt.title() ‬إلنؿدء ؤٌٓلء خًطىَ خملؿٌىرص‪.‬‬
‫‪ُplt.xticks([]),plt.yticks([]) ‬هٍه خًظهٌٌمص إلهفدء طًَؿدض ملىَ خًـ ‪ x‬و ‪. y‬‬

‫)(‪plt.show‬‬
‫ذ‬

‫)(‪ Plt.show‬طدرو ًهُع خًنىخفٍ خًظٍ طم طهٌجظهد من كزٍ خًظدرو )(‪. plt.imshow‬‬
‫ذ‬

‫ذ‬

‫ذ‬
‫‪103‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -2‬اؾتعتقبذادلتؽقفذ(‪:(Adaptive Thresholding‬‬

‫يف خًلٔم خًٔدرم خٓظهمٌند كٌمص ندمص ًلٌمص خًهظزص‪ ،‬وًون هٍخ خألمُ يًن ؿًٌ‪ ،‬فوٍ ضىَش متٌى‬
‫ٌسوؽ بغدءش موظٌفص يف مندؾم موظٌفص منهد‪ًًٍ ،‬ى ٓنٔظهمٍ خًظهظٌس خملظوٌف‪.‬‬

‫خًظهظٌس خملظوٌف هى هىخَِمٌص كٔدذ نظزص منؿلص ضًًنش يف خًطىَش‪ًًٍ ،‬ى ٓنلطٍ نىل نًش‬
‫نظزدض ًهًش مندؾم يف نفٕ خًطىَش‪ ،‬وهٍخ ٌٓهؿٍ نظدثف ؤفػٍ ًٌطىَ يف موظٌف ٌسوؽ خإلغدءش‪.‬‬
‫خًظهظٌس خملظوٌف ٌنظٌى ‪ 4‬مظًًنخض يهٍ ومظًًن هُؾ وكًٌ‪.‬‬

‫‪ o‬ؾًُلص خًظوٌٌف هٍ خًظٍ ٓظلًي ؾًُلص كٔدذ كٌمص خًهظزص‪ ،‬هندن ؾًُلظدن ًٌلٔدذ‪:‬‬
‫‪ :cv2.ADAPTIVE_THRESH_MEAN_C ‬كٌمص خًهظزص ملظىٓـ مٔدكدض مندؾم‬
‫خًـىخَ‪.‬‬
‫‪ :cv2.ADAPTIVE_THRESH_GAUSSIAN_C ‬كٌمص خًهظزص ملظىٓـ ؤوِخن مـمىم‬
‫خًلٌم خملظـإوَش‪ ،‬كٌؽ ؤن خألوِخن هٍ خًندفٍش خًًإوٌٓص‪.‬‬
‫‪ً :Block Size o‬لًي كـم منؿلص خًـىخَ‬
‫‪ :C o‬ػدرع خًؿُق من خملظىٓـ خًلٔديب ؤو خملظىٓـ خملىِون‪ ،‬كٌمظه طوىن مىؿزص ندي ًش وًون‬
‫ٌنون ؤن طوىن كٌمظه ؤًػد ضفُ ؤو كٌمص ٓدًزص‪.‬‬

‫مبُهىُاملرىظؽُاملىصون؟ُومبُامفشقُتنيُاملرىظؽُامؽعبيبُواملرىظؽُاملىصون؟ُُ(سًبطٌبد) ُ‬
‫ُ‬
‫ملهُفص مد هى خملظىٓـ خملىِون ومد هى خًفُق رٌنه ورٍن خملظىٓـ خًلٔدذ خنظلٍ ًهٍخ خًُخرـ‪:‬‬
‫‪http://www.mediafire.com/download/lztw213xna3n2xh‬‬

‫خًوىي خًظديل ًىغم خًفُق رٍن خًظهظٌس خًهدَ وخًظهظٌس خملظوٌف ًٌطىَش يف ٌسوؽ بغدءش موظٌفص‪:‬‬
104 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('dav.jpg',0)
img = cv2.medianBlur(img,5)

ret,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
th2 = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_MEAN_C,\
cv2.THRESH_BINARY,11,2)
th3 = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,\
cv2.THRESH_BINARY,11,2)

titles = ['Original Image', 'Global Thresholding (v = 127)',
'Adaptive Mean Thresholding', 'Adaptive Gaussian Thresholding']
images = [img, th1, th2, th3]

for i in xrange(4):
plt.subplot(2,2,i+1),plt.imshow(images[i],'gray')
plt.title(titles[i])
plt.xticks([]),plt.yticks([])
plt.show()
‫ذ‬

:‫امنرٌعخ‬
‫‪105‬‬ ‫‪ OpenCv‬ببساطة‬

‫هٌل هى وخغم من خًنظدثف رإن خًظهظٌس خملظوٌف ًهؿٍ نظٌـص ؤفػٍ وغـٌف ؤكٍ‪.‬‬
‫رشػُامكىد‪ُ :‬‬
‫)‪img = cv2.medianBlur(img,5‬‬
‫ذ‬

‫خًظدرو )(‪ًٔ medianBlur‬ظوًَ ًؿمٕ خًطىَش ردٓظوًخَ خًفٌرت خملظىٓـ‪.‬‬
‫خملظًًن خألوي هى ؤٓم خًطىَش‪ ،‬خملظًًن خًؼدين ٌنؼٍ يَؿص خًؿمٕ‪.‬‬

‫)‪ret,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY‬‬
‫ذ‬

‫طهظٌس خًطىَش ردٓظوًخَ طدرو خًظهظٌس خًزٌٔـ )( ‪( threshold‬طم ٌسكه مٔزلدً)‪.‬‬

‫\‪th2 = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_MEAN_C,‬‬
‫)‪cv2.THRESH_BINARY,11,2‬‬
‫ذ‬

‫طهظٌس خًطىَش ردٓظوًخَ طدرو خًظهظٌس خملظوٌف )( ‪:adaptiveThreshold‬‬
‫املرغريُاأل ُول هى خًطىَش خملؿٌىذ طهظٌزهد (ًـس ؤن طوىن خًطىَش يف خملٔظىي خًُمديي)‬
‫املرغريُامصبين ٌنؼٍ ؤيىن كٌمص ًٌهظزص‬
‫املرغريُامصبمض ؤنىل كٌمص ًٌهظزص‪ .‬يف خًظهظٌس خملظوٌف ٓنوظدَ ؤكً خًظىخرو خًظدًٌص‪:‬‬
‫‪cv2.ADAPTIVE_THRESH_MEAN_C‬‬ ‫‪‬‬
‫‪cv2.ADAPTIVE_THRESH_GAUSSIAN_C‬‬ ‫‪‬‬

‫خملظًًن خًُخرو هى نىم خًظهظٌس (طم ٌسكه مٔزلد)‬
‫خملظًًن خًودمٕ هى ‪ Block Size‬وٌنؼٍ كـم خًزٌؤالض خملظـإوَش خًظٍ طٔظوًَ ًلٔدذ كٌمص‬
‫نظزص خًزٌؤٍ‪.‬‬
‫خملظًًن خًٔديْ هى خًؼدرع ‪ C‬خًٍي ٌنؼٍ نديش ً ػدرع خًؿُق من خملظىٓـ ؤو خملظىٓـ خملىِون‬
‫كٌمظه طوىن نديش مىؿزص وًون ٌنون ؤن طوىن كٌمظه ؤًػد ضفُ ؤو كٌمص ٓدًزص‪.‬‬
‫\‪th3 = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,‬‬
‫)‪cv2.THRESH_BINARY,11,2‬‬
‫ذ‬

‫نفٕ خًظدرو خًٔدرم مو خهظالف رٌٔـ وهى ردهظٌدَ نىم طدرو خملظًًن خًؼدًؽ‪.‬‬
‫‪106‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -3‬اؾتحوقلذاؾثـائيذالذوتدوذ(‪:(Otsu’s Binarization‬‬

‫ًلً ؤوغلند يف خًلٔم خًٔدرم رإن خًظدرو )(‪ً cv2.threshold‬هًٌ كٌمظٍن هٌل ‪threshold‬‬
‫و‪ ،retVal‬وٌسكند خملظًًن خًؼدين ‪ ،threshold‬وًون خملظًًن خألوي ‪ retVal‬مل نٍسكه‪ ،‬فٌل هى‬
‫نمٌه؟؟‬
‫يف خًظهظٌس خًزٌٔـ كمند ردهظٌدَ كٌمص نشىخثٌص ًٌهظزص‪ ،‬ػم نن ؾًُم خًظـًُس نلًي خًلٌم‬
‫خملؼدًٌص ًٌظهظٌس‪ ،‬وًون بٌخ هدن ًًًند ضىَش ػندثٌص خًطًٌص (خمللطىي ردًطىَش ػندثٌص خًطًٌص هٍ‬
‫خًطىَش خًظٍ متٌى كمظٍن يف خملوؿـ خًزٌدين ًهد( ‪ٓ ،‬نإهٍ كٌمص نظزص وٓؿص رٍن هدطٍن خًلمظٍن‬
‫وهٍخ مد ًفهٌه طلىًٍ ؤوطٔى‪.‬‬

‫ذ‬

‫مٌوظ‪:‬‬
‫طلىًٍ ؤوطٔى وقٌفظه كٔدذ كٌمص خًهظزص ًٌطىَ ػندثٌص خًطًٌص (خًطىَش خًظٍ متٌى كمظٍن يف‬
‫خملوؿـ خًزٌدين ًهد)‪.‬ردًنٔزص ًٌطىَ يًن خًؼندثٌص طلىًٍ ؤوطٔى ًن ًوىن يكٌلدً‪.‬‬

‫ًظؿزٌم طلىًٍ ؤوطٔى نٔظوًَ خًهٌم ‪ .cv2.THRESH_OTSU‬وًٌلطىي نىل كٌمص خًهظزص رزٔدؾص‬
‫كم رظمًُُ خًلٌمص ضفُ‪ ،‬ننًهد خًوىخَِمٌص ٓظلٔس كٌمص خًهظزص خملؼدًٌص وطهًٌ كٌمظهد وطوّنهد‬
‫يف خملظًًن ‪ .retVal‬طهظٌس ؤوطٔى بٌخ مل ًُٔظَهمٍ‪ ،‬ننًهد ٓظوىن كٌمص ‪ retVal‬رنفٕ كٌمص خًهظزص‬
‫خملٔظوًمص‪.‬‬
107 ‫ ببساطة‬OpenCv

‫يف خملؼدي خًظديل ضىَش خًًهٍ ٌخض غـٌف‬
َ‫يف خًلدًص خألوىل ٓنؿزم نىل خًطىَش خًظهظٌس خًهد‬
)‫(خًظهظٌس خًزٌٔـ‬
‫يف خًلدًص خًؼدين نؿزم خًظهظٌس كٔس ؤوطٔى‬
‫يف خًلدًص خًؼدًؼص ٓنلىَ ؤوال رةِخًص خًػـٌف من خًطىَش نن‬
.‫ ػم ٓنؿزم طُشٌم ؤوطٔى‬5x5 ْ‫ؾًُم طؿزٌم مُشم يإويس رلٌد‬
import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('noisy.JPG',0)

# global thresholding
ret1,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)

# Otsu's thresholding
ret2,th2 = cv2.threshold(img,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# Otsu's thresholding after Gaussian filtering
blur = cv2.GaussianBlur(img,(5,5),0)
ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)

# plot all the images and their histograms
images = [img, 0, th1,
img, 0, th2,
blur, 0, th3]
titles = ['Original Noisy Image','Histogram','Global Thresholding (v=127)',
'Original Noisy Image','Histogram',"Otsu's Thresholding",
'Gaussian filtered Image','Histogram',"Otsu's Thresholding"]

for i in xrange(3):
plt.subplot(3,3,i*3+1),plt.imshow(images[i*3],'gray')
plt.title(titles[i*3]), plt.xticks([]), plt.yticks([])
plt.subplot(3,3,i*3+2),plt.hist(images[i*3].ravel(),256)
plt.title(titles[i*3+1]), plt.xticks([]), plt.yticks([])
plt.subplot(3,3,i*3+3),plt.imshow(images[i*3+2],'gray')
plt.title(titles[i*3+2]), plt.xticks([]), plt.yticks([])
plt.show()
‫ذ‬
108 ‫ ببساطة‬OpenCv

:‫امنرٌعخ‬

‫ذ‬

ُ :‫رشػُُُامكىد‬
# global thresholding
ret1,th1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
‫ذ‬

.‫طهظٌس خًطىَش وفم طدرو خًظهظٌس خًزٌٔـ‬
# Otsu's thresholding
ret2,th2 = cv2.threshold(img,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
‫ذ‬

‫طهظٌس خًطىَش وفم طهظٌس ؤوطٔى‬
blur = cv2.GaussianBlur(img,(5,5),0)
‫ذ‬

)‫ (ٌٓظم ٌسكه الكلد‬.5x5 ‫ٓنًٍّ خًػـٌف من خًطىَش نن ؾًُم طؿزٌم مُشم يإويس رلـم‬
ret3,th3 = cv2.threshold(blur,0,255,cv2.THRESH_BINARY+cv2.THRESH_OTSU)
‫ذ‬

‫طؿزٌم طهظٌس ؤوطٔى‬
109 ‫ ببساطة‬OpenCv

# plot all the images and their histograms
images = [img, 0, th1,
img, 0, th2,
blur, 0, th3]
‫ذ‬

.image ‫طوًّن خًطىَش وطهظٌزدطهد وموؿؿدطهد خًزٌدنٌص يف مطفىفص ٓمٌندهد‬

‫ ذ‬:‫مترقن‬

.ٍ‫خهظس طؿزٌم ضًًن ًظًًٌن كٌمص خًهظزص ًطىَش مد نن ؾًُم ٌسًـ خًظمًُُ خًـدنز‬
ُ :‫امؽه‬
import cv2
import numpy as np
def nothing(x):
pass
img = cv2.imread('shape2.jpg',0)
#Generate trackbar Window Name
TrackbarName='value threshold'

#Make Window and Trackbar
cv2.namedWindow('Window')
cv2.createTrackbar(TrackbarName,'Window',0,255,nothing)

# Allocate destination image
Threshold = np.zeros(img.shape, np.uint8)

# Loop for get trackbar pos and process it
while True:
#Get position in trackbar
TrackbarPos = cv2.getTrackbarPos(TrackbarName,'Window')

#Apply Threshold
cv2.threshold(img,TrackbarPos,255,cv2.THRESH_BINARY, Threshold)

# Show in window
cv2.imshow('Window',Threshold)

# If you press "ESC", it will return value
ch = cv2.waitKey(5)
if ch == 27:
break

cv2.destroyAllWindows()
‫‪110‬‬ ‫‪ OpenCv‬ببساطة‬

‫امرؽىًالدُامهنذظٌخُغىلُامصىسح ُ‬

‫امهذف‪ُ :‬‬
‫‪ ‬طهٌم طؿزٌم موظٌف خًظلىًالض خًهنًٌٓص نىل خًطىَش‪ ،‬مؼٍ خًنلٍ‪ ،‬خًظًوًُ‪ ،‬طلىًالض‬
‫خًظلًُس‪.affine‬‬
‫‪ٓ ‬نظهٌم خٓظوًخَ خًظدرو ‪cv2.getPerspectiveTransform‬‬

‫غمنٌبدُامرؽىًه ُ‬
‫‪ًOpenCv‬هؿٌند طدرهٌٍن ًٌظلىًٍ هٌل ‪. cv2.warpPerspective،cv2.warpAffine‬‬
‫نن ؾًُم هًٍن خًظدرهٌٍن ٌنونى بًـدي هٍ ؤنىخم خًظلىًٍ‪.‬‬

‫‪ ‬خًظدرو ‪ٌcv2.warpAffine‬نٌى مطفىفص طلىًٍ كـمهد ‪.2x3‬‬
‫‪ ‬خًظدرو ‪ٌ cv2.warpPerspective‬نٌى مطفىفص طلىًٍ رلـم ‪.3x3‬‬
111 ‫ ببساطة‬OpenCv

ُ Scalingُ ‫ امرؽعٌم‬
ًًً‫ كٌؽ ٌنون طل‬.cv2.resize() ‫ وًٌى نن ؾًُم خًظدرو‬،‫هٍ نمٌٌص طلًًً كـم (ؤرهدي) خًطىَش‬
‫ وطٔظوًَ ؤٓدًٌس خالٓظٌفدء‬.‫كـم خًطىَش ًًوًدً وٌنون طلًًًه نن ؾًُم ندمٍ خًظلـٌم‬
.‫خملوظٌفص‬

cv2.INTER_CUBIC (slow)‫ و‬،‫ ًٌظلٌظ‬cv2.INTER_AREA ٍ‫ؤفػٍ ؤٓدًٌس خالٓظٌفدء ه‬
‫ رشوٍ خفرتخيض ًوىن ؤٌٓىذ خالٓظٌفدء هى‬.ًٌ‫ ًٌظزه‬cv2.INTER_LINEAR‫ و‬،‫ًٌظلًُس‬
.ًٌ‫ؤي خًظزه‬cv2.INTER_LINEAR

:‫خًوىي خًظديل ًىغم مد طلًػند ننه‬
import cv2
import numpy as np
img = cv2.imread('gift.jpg')

res = cv2.resize(img, None, fx=2, fy=2, interpolation = cv2.INTER_CUBIC)

print img.shape
print res.shape

‫ذ‬

)320‫ذ‬,320‫ذ‬,3(

)640‫ذ‬,640‫ذ‬,3(

:ُ‫ٌنون هظدرص خًوىي خًٔدرم رشوٍ آه‬
#OR
height, width = img.shape[:2]
res = cv2.resize(img,(2*width, 2*height), interpolation = cv2.INTER_CUBIC)
‫ذ‬

)320‫ذ‬,320‫ذ‬,3(

)640‫ذ‬,640‫ذ‬,3(

ُ Translationُُُ‫ امنله‬
:‫ ًٌلٌدَ رهمٌٌص خًنلٍ نظزو خًوؿىخض خًظدًٌص‬.‫خًنلٍ هى نمٌٌص بِخكص ؿٔم مد‬
112 ‫ ببساطة‬OpenCv

َ‫ ومنَُ ًهد ملًخ‬M ‫ػم نلىَ رةنشدء مطفىفص‬ ‫نلًي ملًخَ خالنًّدق ردإلكًخػٌدض‬

[ ]‫خالنًّدق خًٍي نًًُه‬
.cv2.warpAffine() ‫ ومنَُهد ًٌظدرو‬np. float32 ‫ػم نلىَ رظلىًٍ هٍه خملطفىفص ًٌطًٌص‬

:(100,50) َ‫شدهً خملؼدي خًظديل خًٍي ًىغم خنًّدق خًطىَش (خملطفىفص) مبلًخ‬
import cv2
import numpy as np

img = cv2.imread('gazal.jpg',0)

rows,cols = img.shape
M = np.float32([[1,0,100],[0,1,50]])
dst = cv2.warpAffine(img,M,(cols,rows))

cv2.imshow('img',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬

ُ :‫امنرٌعخ‬

‫ذ‬

‫ذ‬
‫‪113‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامكىد‪ُ :‬‬
‫‪rows,cols = img.shape‬‬
‫ذ‬

‫طوًّن نًي ضفىف وؤنمًش خًطىَش ‪ img‬يف خملظًًنًن ‪ rows‬و‪. cols‬‬

‫)]]‪M = np.float32([[1,0,100],[0,1,50‬‬
‫ذ‬

‫من خًنىم ‪np. float32‬‬ ‫[‬ ‫طهًُف مطفىفص ]‬
‫ٓنٔظوًَ هٍه خملطفىفص ًظلًًً خنًّدق خًطىَش ردمللًخَ )‪.(100,50‬‬
‫))‪dst = cv2.warpAffine(img,M,(cols,rows‬‬
‫ذ‬

‫ؿهٍ خًطىَش طنّخق مبلًخَ )‪ (100,50‬نن ؾًُم متًُُ خملطفىفص ‪ًٌ M‬ظدرو )(‪.cv2.warpAffine‬‬
‫خملظًًن خًؼدًؽ ًٌظدرو )(‪ً cv2.warpAffine‬لًي كٌدْ ضىَش خًوُؾ‪.‬‬
‫ذ‬

‫‪ ‬امرذوًشُ‪ُ Rotation‬‬
‫ًٌلٌدَ رهمٌٌص طًوًُ خًطىَش رّؤوًص ? نلىَ مبد ًًل‪:‬‬
‫?‬ ‫?‬
‫[‬ ‫ننشإ مطفىفص من خًشوٍ ]‬
‫?‬ ‫?‬

‫موظزص ‪ OpenCv‬طىفُ ًند مطفىفص ًظًوًُ خًطىَش كىي ؤي نلؿص ورإي ِؤوًص نًًُهد‪ .‬وًٌى من هالي‬
‫خًظدرو ‪.cv2.getRotationMatrix2D‬‬

‫خملؼدي خًظديل ًًوَ ًند خًطىَش رّؤوًص ْ‪ 95‬يَؿص يون طًًٌن كـم خًطىَش‪.‬‬
114 ‫ ببساطة‬OpenCv

import cv2
import numpy as np

img = cv2.imread('gazal.jpg',0)

rows,cols = img.shape
M = cv2.getRotationMatrix2D((cols/2,rows/2),90,1)
dst = cv2.warpAffine(img,M,(cols,rows))

cv2.imshow('img',dst)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬

ُ :‫امنرٌعخ‬

‫ذ‬

ُ :‫رشػُامكىد‬
M = cv2.getRotationMatrix2D((cols/2,rows/2),90,1)
‫ذ‬

.‫ًلًي ًند ِؤوًص خًًوَخن خًظٍ نًًُ طًوًُ خًطىَش رهد‬cv2.getRotationMatrix2D ‫خًظدرو‬
:cv2.getRotationMatrix2D () ‫ٌسق خًظدرو‬
.‫ خملظًًن خألوي ًلًي مُهّ يوَخن خًطىَش‬
.‫ خملظًًن خًؼدين ًلًي ِؤوًص خًًوَخن‬
.‫ خملظًًن خًؼدًؽ ًلًي كـم ضىَش خًوُؾ‬
dst = cv2.warpAffine(img,M,(cols,rows))
‫ذ‬
‫‪115‬‬ ‫‪ OpenCv‬ببساطة‬

‫نفٕ خًٍسق يف خًفلُش خًٔدرلص‪ ،‬وًون هٍه خملُش رًي ؤن منَُ مطفىفص ‪ً M‬ظًًٌن خًلـم مَُنند‬
‫مطفىفص ‪ً M‬ظلًًً ِؤوًص خًًوَخن‪.‬‬
‫‪ ‬ذؽىًهُؤفٌنٍُ‪ُ Affine Transformation‬‬

‫ذ‬

‫يف هٍخ خًظلىًٍ هٍ خًوؿىؽ خملظىخًِص يف خًطىَش خألضٌٌص‪ٓ ،‬ظزلى مظىخًِص يف ضىَش خًوُؾ‪.‬‬
‫إلًـدي مطفىفص خًظلىًٍ نلظدؾ ػالػص نلدؽ من خًطىَش خألضٌٌص وخًنلدؽ خملندقُش ًهد يف ضىَش‬
‫خًوُؾ‪ ،‬ػم ٌٓلىَ خًظدرو ‪ cv2.getAffineTransform‬رةنشدء مطفىفص ‪ 2x3‬وخًظٍ ٓنمَُهد ًظدرو‬
‫خًظلىًٍ ‪.cv2.warpAffine‬‬

‫خنكُ ًٌمؼدي خًظديل‪ ،‬وشدهً خًنلدؽ خملوظدَش (خًنلدؽ خملٌىنص ردًٌىن خألضفُ)‪.‬‬
116 ‫ ببساطة‬OpenCv

import cv2
import numpy as np

img = cv2.imread('hello.png',0)
rows,cols = img.shape
pts1 = np.float32([[67,160],[370,115],[371,263]])
pts2 = np.float32([[20,114],[370,115],[371,263]])
M = cv2.getAffineTransform(pts1,pts2)
dst = cv2.warpAffine(img,M,(cols,rows))

cv2.imshow('orginal',img)
cv2.imshow('res',dst)

k = cv2.waitKey(0)

cv2.destroyAllWindows()
‫ذ‬

ُ :‫امنرٌعخ‬

‫ذ‬

ُ :‫رشػُامكىد‬

pts1 = np.float32([[50,50],[200,50],[50,200]])

.ٍ‫ ًٌنلدؽ خًطفُخء ًٌطىَش خًًه‬y‫ و‬x ‫خألَكدَ خًظٍ رٍن خًلىٍٓن ] [ متؼٍ بكًخػٌدض‬
‫ذ‬
‫‪117‬‬ ‫‪ OpenCv‬ببساطة‬

‫)]]‪pts2 = np.float32([[10,100],[200,50],[100,250‬‬
‫ذ‬

‫خألَكدَ خًظٍ رٍن خًلىٍٓن ] [ متؼٍ بكًخػٌدض ‪ x‬و‪ًٌ y‬نلدؽ خًطفُخء ًٌطىَش خًوُؾ‪.‬‬

‫)‪M = cv2.getAffineTransform(pts1,pts2‬‬
‫ذ‬

‫خألن نلىَ رلٔدذ طلىًٍ ؤفٌنٍ رٍن ػالػص ؤِوخؾ من خًنلدؽ خًؼالػص خًطفُخء خًظٍ يف ضىَش خًًهٍ‬
‫وخًوُؾ نن ؾًُم خًظدرو )( ‪.getAffineTransform‬‬

‫))‪dst = cv2.warpAffine(img,M,(cols,rows‬‬
‫ذ‬

‫وؤهًنخ ً نلىَ رظؿزٌم طلىًٍ ؤفٌنٍ خًٍي كٔزنده نىل خًطىَش خملؿٌىرص نن ؾًُم خًظدرو ‪warpAffin‬‬
‫)(‪ً .‬إهٍ هٍخ خًظدرو ػالغ مظًًنخض‪ ،‬خألوي هى خًطىَش خملؿٌىذ بؿُخء طلىًٍ ؤفٌنٍ نٌٌهد‪ ،‬وخملظًًن‬
‫خًؼدين ٌنؼٍ ملًخَ طلىًٍ ؤفٌنٍ خملؿٌىذ‪ ،‬وخملظًًن خًؼدًؽ ًلًي كٌدْ ضىَش خًوُؾ‪.‬‬
‫ذ‬

‫‪ ‬امرؽىًهُاملنظىسيُ)‪ُ )Perspective Transformation‬‬
‫ذ‬
118 ‫ ببساطة‬OpenCv

.ًٍ‫ ٓظزلى خًوؿىؽ خملظىخًِص هٌل هٍ رهً خًظلى‬،3X3 ‫ًٌلٌدَ رهٍخ خًظلىًٍ ٓنلظدؾ مطفىفص‬
‫ وػالػص من‬،‫إلًـدي خًظلىًٍ نلظدؾ ؤَرو نلـ يف ضىَش خًًهٍ ومد ًلدرٌهد من خًنلدؽ يف ضىَش خًوُؾ‬
‫ وًٌى من‬،ًٍ‫ ننًهد ٌنون بًـدي مطفىفص خًظلى‬،‫هٍه خًنلدؽ ًـس ؤال طوىن نىل خٓظلدمص وخكًش‬
cv2.warpPerspective ‫ رهً ًٌى نؿزم خًظدرو‬،cv2.getPerspectiveTransform ‫هالي خًظدرو‬
:‫ خًوىي خًظديل ًىغم ًٌى‬.3X3 ًٍ‫مو مطفىفص خًظلى‬
import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread(' drawing.jpg',0)
rows,cols,ch = img.shape

pts1 = np.float32([[56,65],[368,52],[28,387],[389,390]])/2
pts2 = np.float32([[0,0],[300,0],[0,300],[300,300]])/2

M = cv2.getPerspectiveTransform(pts1,pts2)
dst = cv2.warpPerspective(img,M,(150,150))

plt.subplot(121),plt.imshow(img),plt.title('Input')
plt.subplot(122),plt.imshow(dst),plt.title('Output')
plt.show()
‫ذ‬

ُ ‫امنرٌعخ‬

‫ذ‬

:‫ًٌمًًّ من خملهٌىمدض نٌٌى رلُخءش خملُؿو‬
‫ ذ ذ‬Computer Vision: Algorithms and Applications " Richard Szeliski"
‫‪119‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذهزًجُامصىسحُُُ)‪ُ )Smoothing Images‬‬

‫ذ‬

‫ذ‬

‫امهذف‪ُ :‬‬
‫طهٌم هٌفٌص طًزٌش خًطىَش ردٓظوًخَ نًش مُشلدض ًٌرتيي منوفؼ(‪.)LPF‬‬
‫طهٌم طؿزٌم مُشلدض مطنىنص هطٌطد ًٌطىَ (خًؿٍ ػنديئ خًزهً) (‪.)2D Convolution‬‬
‫ذ‬
‫‪120‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬امؼٍُشنبيئُامثػذُ_ُذششٌؾُامصىس ُ‬
‫هٌل بن خالشدَخض خًىكًٌش خًزهً (‪ٌ )one-dimensional signals‬نونند طُشٌلهد (فٌرتطهد)‬
‫مبُشلدض خًرتيي خملنوفؼ وخملُطفو ‪ ، LPF , H PF‬هًٍى خألمُ ٌنونند طؿزٌله نىل خًطىَش‪.‬‬

‫ذ‬

‫ٌنونند طُشٌم خًطىَش ردٓظوًخَ مُشلدض ‪. HPF،LPF‬‬
‫‪ ‬خملُشم ‪ًٔ LPF‬دنً نىل بِخًص خًػـٌف ؤو طًزٌش خًطىَش (‪.)blurring‬‬
‫‪ ‬خملُشم ‪ًٔ HPF‬دنًند يف بًـدي خًلىخف يف خًطىَش‪.‬‬
‫موظزص ‪OpenCv‬طىفُ ًند خًظدرو )( ‪ cv2.filter2D‬خًٍي ًٔدنًند يف نمٌٌص ؾٍ (يمف) خًلندم مو‬
‫خًطىَش ًنلطٍ نىل ضىَش مُشلص‪ ،‬همؼدي نىل ًٌى ٓنـُذ طؿزٌم خملُشم خملظىٓـ نىل خًطىَش‪.‬‬
‫ٓنهُف كندم رلـم ‪ًٌ 5x5‬مُشم خملظىٓـ هٌل ًًل‪:‬‬

‫[‬ ‫]‬

‫ذ‬

‫هٍه خًهمٌٌص طايي ًلٔدذ خملظىٓـ ملـمىنص خًزٌؤالض خًىخكهص غمن خًلندم‪.‬‬
‫ؾزم خًوىي خًظديل وشدهً خًنظٌـص‪:‬‬
121 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('opencv_logo.png')

kernel = np.ones((5,5),np.float32)/25
dst = cv2.filter2D(img,-1,kernel)

plt.subplot(121),plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(dst),plt.title('Averaging')
plt.xticks([]), plt.yticks([])
plt.show()
‫ذ‬

ُ :‫امنرٌعخ‬
‫ذ‬

‫ذ‬

‫ذ‬

:‫رشػُامكىد‬
kernel = np.ones((5,5),np.float32)/25
‫ذ‬

‫ ػم‬np.float32 ‫ من خًنىم‬5x5 ‫ كـمهد هى‬،np.ones()ُ‫بنشدء مطفىفص وخكًًص نن ؾًُم خألم‬
.‫ ٓنٔظهمٍ هٍه خملطفىفص هلندم ًرتشٌم خًطىَش‬.25 ‫كٔمند خملطفىفص نىل‬

dst = cv2.filter2D (img, -1, kernel)
‫ذ‬ ‫ذ‬

.‫ خًٍي ٌٓلىَ ررتشٌم خًطىَش وفلد ًهٍخ خًلندم‬cv2.filter2D ‫ ًٌظدرو‬Kernel ‫نلىَ رظمًُُ خًلندم‬
(-1) ‫ وخًؼدين رلًي خًهمم خًٌىين ًطىَش خًوُؾ فةٌخ هدنع كٌمظه‬،ٍ‫خملظًًن خألوي هى ضىَش خًًه‬
‫ وخملظًًن خًؼدًؽ ٌنؼٍ خًلندم خًٍي ًـس ؤن‬،ٍ‫ٓنلطٍ نىل ضىَش رنفٕ خًهمم خًٌىين ًطىَش خًًه‬
.float ‫ًوىن رلندش وخكًش مبطفىفص من خًنىم‬
‫‪122‬‬ ‫‪ OpenCv‬ببساطة‬

‫ػمغُامصىسحُ(‪ُ )Image Blurring‬‬
‫طظم نمٌٌص ؾمٕ خًطىَش ردٓظهٌلي كندم مُشم خًرتيي خملنوفؼ‪ .‬كٌؽ ًٔظوًَ إلِخًص خًػـٌف‬
‫من خًطىَش‪ ،‬وهطىضد خًرتييخض خملُطفهص (مؼٍ خًػـٌف وخًلىخف‪ ،)..‬وطنهم خًلىخف (طؿمٔهد‬
‫رلٌؽ طـهٌهد ؤهف)‪ً( ،‬ون هندن ؤنىخم من طلنٌدض خًؿمٕ ال طلىَ رؿمٕ خًلىخف)‪ .‬خملوظزص‬
‫‪OpenCv‬طىفُ ًند ؤَرو طلنٌدض ًٌؿمٕ‪:‬‬

‫‪ -1‬ادلرذحذادلتودطذ(‪)Averaging‬‬

‫ًظم ًٌى نن ؾًُم ًف خًطىَش مو مُشم ضنًوكٍ (ٌنؼٍ خًلندم) (ننًمد ؤكىي ًف خًطىَش مو كندم‬
‫ؤي متًُُ خًلندم نىل هٍ خًطىَش وخًٍي ٌٓهؿٌند ضىَش ؿًًًش نزدَش نن نظٌـص ملطٌص خًلندم مو‬
‫خًطىَش خألضٌٌص)‪ ،‬فهى ًإهٍ رزٔدؾص مظىٓـ هٍ رٌؤٍ يف خًطىَش طلع منؿلص خًلندم‪ ،‬ؤًظزًي‬
‫خًهنرص خملُهّي يف خًزٌؤٍ ردملظىٓـ‪ .‬طظم هٍه خًهمٌٌص نن ؾًُم خًظدرو‬
‫)(‪cv2.blur‬ؤو )(‪.cv2.boxFilter‬‬
‫ًـس نٌٌند طلًًً ؾىي ونُع خًلندم خملهًي‪.‬‬
‫ًنفُع ًًًند كندم مُشم ضنًوكٍ كـمه ‪ ،3x3‬ننًهد ٓىف ًزًو هٌل ًًل‪:‬‬
‫‪x‬‬
‫[‬ ‫]‬
‫بقعة من الصورة بحجم ‪3x3‬‬

‫ٌنؼٍ خملظىٓـ‪ .‬هند خٓظوًمند خًـىخَ‪.3x3‬‬ ‫خًورس‬
‫(مطؿٌم خًـىخَ ًهنٍ هند ؤرهدي خملطفىفص)‪.‬‬

‫مالككص‪ :‬بٌخ مل طُي خٓظوًخَ خملُشم خًطنًوكٍ‪ ،‬خٓظوًَ خًظدرو )(‪ cv2.boxFilter‬ومَُ ًه خملظًًن‬
‫‪normalize=False.‬‬

‫ؤًمِ نكُش نىل خًربندمف خًظديل ٌو خًلندم ‪:5x5‬‬
123 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('opencv_logo.png')

blur = cv2.blur(img,(5,5))

plt.subplot(121),plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(blur),plt.title('Blurred')
plt.xticks([]), plt.yticks([])
plt.show()
‫ذ‬

ُ :‫امنرٌعخ‬

‫ذ‬

:‫رشػُامكىد‬
blur = cv2.blur(img, (5,5))
‫ذ‬

.cv2.blur() ‫طُشٌم خًطىَش ردٓظوًخَ طلنٌص خًرتشٌم خملظىٓـ وًٌى نن ؾًُم خًظدرو‬

ُ :cv2.blur()ُ‫رشػُامربتؼ‬
ُ
‫ وخملظًًن خًؼدين ٌنؼٍ كـم خًلندم (كـم خملُشم‬،‫خملظًًن خألوي ًإهٍ خًطىَش خملُخي طُشٌلد‬
.)ٍ‫ًطنًوك‬
‫ذ‬
‫‪124‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -2‬ادلرذحذاؾغلوديذ(‪:)Gaussian Filtering‬‬

‫خآلن رًال من خٓظهٌلي خملُشم خًطنًوكٍ خًٍي ًظإًف من نندرص مظٔإوًص‪ٓ ،‬نٔظوًَ خملُشم‬
‫خًًإويس‪ ،‬وًٌى نن ؾًُم طؿزٌم خًظدرو )(‪ .cv2.GaussianBlur‬يف خًزًخًص ًـس نٌٌند طلًًً ؾىي‬
‫ونُع كندم خملُشم خًًإويس رإنًخي مفُيش ومىؿزص‪ ،‬ونلًي ؤًػدً خالنلُخف خملهٌدَي نىل‬
‫خمللىًَن ‪ X‬و ‪ .Y‬ويف كدي هدن ؤكً خمللىًَن مهؿى فلـ ًوىن خًؼدين مٔإوًدً ًه‪ ،‬وبٌخ هدن هال‬
‫خمللىًَن كٌمظهم ضفُ ًلٔزدن من كـم خًلندم‪.‬‬

‫خملُشم خًًإويس مفًٌ ؿًخ ً إلِخًص خًػـٌف خًًإويس من خًطىَش‪ .‬بٌخ ؤكززع ٌنونى بنشدء كندم‬
‫يإويس ردٓظوًخَ خًظدرو )(‪.cv2.getGaussianKernel‬‬

‫خًوىي خًظديل نفٕ خًوىي خًٔدرم مو طًًن ٓؿُ وخكً فلـ‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪from matplotlib import pyplot as plt‬‬

‫)'‪img = cv2.imread('opencv_logo.png‬‬

‫)‪blur = cv2.GaussianBlur(img,(5,5),0‬‬

‫)'‪plt.subplot(121),plt.imshow(img),plt.title('Original‬‬
‫)][(‪plt.xticks([]), plt.yticks‬‬
‫)'‪plt.subplot(122),plt.imshow(blur),plt.title('Blurred‬‬
‫)][(‪plt.xticks([]), plt.yticks‬‬
‫)(‪plt.show‬‬
‫ذ‬

‫ُامنرٌعخ‪ُ :‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪125‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامكىد‪:‬‬
‫)‪blur = cv2.GaussianBlur(img,(5,5),0‬‬
‫ذ‬

‫طُشٌم خًطىَش ردٓظوًخَ طلنٌص خًرتشٌم خًًإويس وًٌى نن ؾًُم خًظدرو )(‪.cv2.Gaussianblur‬‬
‫ٌسق خًظدرو )(‪cv2.GaussianBlur‬‬
‫‪ ‬خملظًًن خألوي ًإهٍ خًطىَش خملُخي طُشٌلد‪.‬‬
‫‪ ‬خملظًًن خًؼدين ٌنؼٍ كـم خًلندم خًًإويس‪.‬‬
‫‪ ‬خملظًًن خًؼدًؽ ٌنؼٍ ملًخَ خالنلُخف خملهٌدَي‪.‬‬
‫‪ -3‬ادلرذحذاألودطيذ(‪:)Median Filtering‬‬

‫خًظدرو ‪ً cv2.medianBlur‬لٔس مظىٓـ مـمىنص خًزٌؤالض خًظٍ طلع خًلندم ؤًظزًي‬
‫خًنظٌـص ردًهنرص خملُهّي‪ .‬هٍخ خملُشم فهدي ؿًخ يف كدًص غـٌف خملٌم وخًفٌفٍ‪.‬‬
‫مؼدي‪ًًً :‬ند رلهص (مـمىنص رٌؤالض يف خًطىَش) طإهٍ رؤالطهد خًلٌم خًظدًٌص‪:‬‬
‫‪100,25,20,20,15,20,20,20,10‬‬

‫‪ 20‬ذ ‪ 25‬ذ ‪ 100‬ذ‬ ‫‪ 20‬ذ ‪ 25‬ذ ‪ 100‬ذ‬ ‫رهً طؿزٌم خملُشم خألوٓؿٍ نٌٌهد ططزم خًنظٌـص‪:‬‬
‫‪ 20‬ذ ‪ 15‬ذ ‪ 20‬ذ‬ ‫‪ 20‬ذ ‪ 20‬ذ ‪ 20‬ذ‬
‫‪ 100,25,20,20,20,20,20,15,10‬ذ‬

‫‪ 10‬ذ ‪ 20‬ذ ‪ 20‬ذ‬ ‫‪ 10‬ذ ‪ 20‬ذ ‪ 20‬ذ‬ ‫خًلٌمص خألوٓؿٌص رًي ‪80‬‬ ‫ذ‬

‫ذ‬

‫من خملالكل رإنه يخمئد يف خملُشلدض خًٔدرلص رإن خًهنرص خملُهّي يف خًزلهص ًٔظزًي رلٌمص كً ال‬
‫طوىن مىؿىيش يف نفٕ خًزلهص خًظٍ مَُند فىكهد خًندفٍش‪ ،‬نىل خًهوٕ من خملُشم خألوٓؿٍ خًٍي‬
‫ًٔظزًي خًهنرص خملُهّي رزٌؤٍ من نفٕ خًزلهص‪ ،‬مٌل ًايي ًظلٌٌٍ خًػـٌف رشوٍ فهدي‪.‬‬

‫كٌدْ خًلندم يف خملُشم خألوٓؿٍ ًـس ؤن ًوىن ضلٌم ومفُي‪.‬‬
126 ‫ ببساطة‬OpenCv

.ٍ‫ ردٓظوًخَ خملُشم خألوٓؿ‬50% ‫يف خملؼدي خًظديل ٓنلىَ رظوفٌؼ خًػـٌف من خًطىَش رنٔزص‬
import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('noisy_opencv.png')

median = cv2.medianBlur(img,5)

plt.subplot(121),plt.imshow(img),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(median),plt.title('Median')
plt.xticks([]), plt.yticks([])
plt.show()

ُ :‫ُامنرٌعخ‬

‫ذ‬

:‫رشػُامكىد‬
median = cv2.medianBlur(img,5)
‫ذ‬

.cv2.medianblur() ‫طُشٌم خًطىَش ردٓظوًخَ طلنٌص خًرتشٌم خألوٓؿٍ وًٌى نن ؾًُم خًظدرو‬
‫ذ‬
‫ ذ‬:cv2.medianBlur()‫ذرحذاؾتابعذ‬

.‫ خملظًًن خألوي ًإهٍ خًطىَش خملُخي طُشٌلد‬
... 7 ،0 ،4 :ٍ‫ مؼ‬8 ‫ ًـس ؤن ًوىن فُيًد وؤهرب من‬،‫ خملظًًن خًؼدين ٌنؼٍ كـم خًلندم‬
‫‪127‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -4‬ادلرذحذاؾثـائيذاجلاـيبذ(‪:)Bilateral Filtering‬‬

‫يف خملُشلدض خًٔدرلص نالكل ؤنهد متٌٍ ًؿمٕ خًلىخف‪ ،‬وًون هٍخ خألمُ ال ًلًغ يف كدًص‬
‫خٓظوًخَ خملُشم خًؼنديئ )(‪ ،cv2.bilateralFilter‬وهٍه هٍ وقٌفظه خألٓدٌٓص‪ ،‬فهى ًًٍّ خًػـٌف‬
‫يون خًلدق خًٍصَ ردًلىخف‪ ،‬فدًلىخف طٔدنًند يف خًظهُف نىل خألشودي‪.‬‬

‫نمٌٌص خًرتشٌم خًؼنديئ رؿٌجص ملدَنص مو خملُشلدض خألهُي‪ .‬ؤًػدً شدهًند ٓدرلد هٌف ؤن خملُشم‬
‫خًًإويس ال ًهظم رشًش خًزٌؤالض خًظٍ طلع خًلندم هٍ هٍ مظلدَرص ردًشًش ؤَ ال‪ ،‬مٌل ًايي‬
‫ًؿمٕ خًلىخف‪.‬‬

‫خملُشم خًؼنديئ خًـدنزٍ ًإهٍ ؤًػد كندم يإويس وًون مو مٍصوذ بغديف طدرو ًفُق شًش‬
‫خًزٌؤالض‪ ،‬ورهٍه خًهمٌٌص ًوىن كٔس هٍ من خًـىخَ خملودين‪ ،‬وخًـىخَ يف خًشًش‪ ،‬ورًٍى ًلدفل‬
‫نىل خًلىخف‪.‬‬

‫خًوىي خًظديل ًىغم ًٌى‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪from matplotlib import pyplot as plt‬‬

‫)'‪img = cv2.imread('opencv_ios.png‬‬

‫)‪blur = cv2.bilateralFilter(img,9,75,75‬‬

‫)'‪plt.subplot(121),plt.imshow(img),plt.title('Original‬‬
‫)][(‪plt.xticks([]), plt.yticks‬‬
‫)' ‪plt.subplot(122),plt.imshow(blur),plt.title('Blurred‬‬
‫)][(‪plt.xticks([]), plt.yticks‬‬
‫)(‪plt.show‬‬
‫ذ‬
‫‪128‬‬ ‫‪ OpenCv‬ببساطة‬

‫ُامنرٌعخ‪ُ ُ:‬‬

‫رشػُامكىد‪:‬‬
‫)‪blur = cv2.bilateralFilter(img,9,75,75‬‬

‫طدرو ؾمٕ خًطىَش ردٓظوًخَ خملُشم خًؼنديئ‪.‬‬
‫ٌسق خًظدرو )( ‪:bilateralFilter‬‬

‫‪ ‬خملظًًن خألوي ٌنؼٍ خًطىَش خملؿٌىرص‪.‬‬
‫‪ ‬خملظًًن خًؼدين وخًؼدًؽ وخًُخرو منَُهم هٌل يف خملُشم خًًإويس‪ ،‬كٌؽ خملظًًن خًؼدين‬
‫وخًؼدًؽ ٌنؼالن كـم خًلندم خًًإويس وخملظًًن خًُخرو ٌنؼٍ ملًخَ خالنلُخف خملهٌدَي‪.‬‬

‫خًطىَش خًظدًٌص ًزىَي خًورتوين فٌهد غـٌف ردًطىَش فؿزلند نٌٌهد خملُشم خملظىٓـ وخألوٓؿٍ‪.‬‬
‫شدهً خًفُق رٍن خملُشلٍن‪.‬‬
‫‪129‬‬ ‫‪ OpenCv‬ببساطة‬

‫امرؽىًالدُمنُامنبؼٌخُامشكنٌخُ(‪)Morphological Transformations‬‬

‫ذ‬

‫امهذف‪ُ :‬‬
‫طهٌم موظٌف خًهمٌٌدض نىل خًظلىًالض خًظٍ طـُي نىل خًشوٍ مؼٍ خًظأهٍ‪ ،‬خًظمًي‪،‬‬
‫خًفظم‪ ،‬خإليالق ‪ ....‬خًى‬
‫طهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪cv2.morphologyEx()، cv2.dilate()،cv2.erode() :‬‬
‫ُ‬
‫مػنىمبدُنظشًخ‪ُ :‬‬
‫خًظلىًالض خًشوٌٌص هٍ رهؼ خًهمٌٌدض خًزٌٔؿص خًظٍ طـُي نىل شوٍ خًطىَش‪ ،‬طنفٍ نديش نىل‬
‫خًطىَ خًؼندثٌص‪ .‬ونلظدؾ ًظنفٌٍ هٍه خًهمٌٌص ًًهٌٍن‪ ،‬خًًهٍ خألوي هى خًطىَش خألضٌٌص‪ ،‬ؤمد خًًهٍ‬
‫خًؼدين هى خًهنرص خًرتهٌزٍ (خملطفىفص خملٔاوًص نن طلًًً خًلندم) خًٍي ًلًي ؾزٌهص خًهمٌٌص‪.‬‬

‫خًهمٌٌدض خألٓدٌٓص هٍ نمٌٌص خًظأهٍ ونمٌٌص خًظمًي ‪.Erosion and Dilation‬‬
‫ونمٌٌدض خًفظم وخإليالق وخًظًَؾ ‪.Opening, Closing, Gradient‬‬

‫ٓرني هٌف ٓنؿزم هٍه خًهمٌٌدض نىل خًطىَش خًظدًٌص‪:‬‬

‫ذ‬

‫ذ‬
‫‪130‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -1‬عؿؾقةذاؾتكؽل‪: Erosion‬‬

‫خًفوُش خألٓدٌٓص ًٌظأهٍ هٍ متدمد مؼٍ طأهٍ خًرترص‪ ،‬ننً طؿزٌم نمٌٌص خًظأهٍ نىل خًشوٍ طايي‬
‫ًظنهٌم كًوي خًٔؿم خألمدمٍ (كإوي يخمئد ؤن طلُص ؤن ًوىن خًٔؿم خألمدمٍ ردًٌىن خألرٌؼ)‪.‬‬
‫كٌفُذرمُغمنٌخُامرأكه؟! ُ‬
‫‪ ‬خًزٌؤٍ يف خًطىَش خألضٌٌص ًإهٍ كٌمظٍن بمد ‪ 0‬ؤو ‪( 1‬ؤٓىي ؤو ؤرٌؼ)‪.‬‬
‫‪ ‬خًزٌؤٍ خًٍي يف خًطىَش خألضٌٌص ٌٓهظرب ‪ 1‬فلـ بٌخ هدنع ؿمٌو خًزٌؤالض طلع خًلندم‬
‫‪ ،1‬وبال ٌٓظم طـدهٌه ؤي ًإهٍ خًلٌمص ‪.0‬‬
‫‪ ‬خًٍي ًلًغ هى ؤن هٍ رٌؤٍ كًُس من خًلًوي ٓىف ًظم طـدهٌه‪ٓ .‬مى خًلًوي خًظٍ‬
‫ٌٓظم طأهٌهد ًظىكف نىل كـم خًلندم‪.‬‬

‫هٍه خًهمٌٌص طفًٌند يف بِخًص خًػـٌف هدًنلدؽ خًزٌػدء خًطًًنش (هٌل شدهًند يف فطٍ خًفػدء‬
‫خًٌىين) وطفًٌند ؤًػدً يف فطٍ ؿٔمٍن مظطٌٍن هؿٌد‪.‬‬
‫امكىد‪ُ :‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)‪img = cv2.imread('j.png',0‬‬
‫)‪kernel = np.ones((5,5),np.uint8‬‬
‫)‪erosion = cv2.erode(img,kernel,iterations = 1‬‬
‫)‪cv2.imshow('orginal',img‬‬
‫)‪cv2.imshow('erosion',erosion‬‬
‫ذ‬
‫)‪k = cv2.waitKey(0‬‬
‫امنرٌعخ‪ُ :‬‬
‫ُ‬
‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ ذ‬

‫ذ‬
‫‪131‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -2‬عؿؾقةذاؾتؿددذ‪:Dilation‬‬

‫نمٌٌص خًظمًي نوٕ نمٌٌص خًلع‪ .‬هند طإهٍ نندرص خًزٌؤٍ خًلٌمص ‪1‬بٌخ هدن ننرص وخكً من‬
‫نندرصه طلع خًلندم ‪ 1‬نىل خألكٍ‪ ،‬ونظٌـص ًًٍى طّيخي كـم خملنؿلص خًزٌػدء‪.‬‬

‫ردًهديش ننً طؿزٌم نمٌٌص خًظأهٍ إلِخًص غـٌف خملنؿلص خًزٌػدء يف خًطىَش نالكل رإن مٔدكص‬
‫خًـٔم كً كٌع‪ً ،‬هٍخ خًٔزس نظزو نمٌٌص خًظأهٍ رهمٌٌص خًظمًًً كظى نًًّ من مٔدكص خًـٔم‬
‫خًٍي طأهٍ‪ .‬فهمٌٌص خًظمًي مفًٌش الٓرتؿدم خألؿّخء خملظأهٌص من خًـٔم‪.‬‬

‫امكىد‪ُ :‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)‪img = cv2.imread('j.png',0‬‬

‫)‪kernel = np.ones((5,5),np.uint8‬‬
‫)‪dilation = cv2.dilate(img,kernel,iterations = 1‬‬

‫)‪cv2.imshow('orginal',img‬‬
‫)‪cv2.imshow('dilation',dilation‬‬
‫)‪k = cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫ذ‬

‫امنرٌعخ‪ُ :‬‬
‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪132‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -3‬ذعؿؾقةذاؾػتح ‪:Opening‬‬

‫نمٌٌص خًفظم هٍ نزدَش نن نمٌٌص خًظأهٍ ‪ +‬خًظمًي‪ .‬هٍه خًهمٌٌص مفًٌش إلِخًص خًػـٌف هٌل ٌسكند‬
‫ٓدرلد‪ .‬وطظم نرب خًظدرو )(‪.cv2.morphologyEx‬‬

‫امكىد‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)‪img = cv2.imread('j.png',0‬‬
‫)‪kernel = np.ones((5,5),np.uint8‬‬
‫)‪opening = cv2.morphologyEx(img, cv2.MORPH_OPEN, kernel‬‬

‫)‪cv2.imshow('orginal',img‬‬
‫)‪cv2.imshow('opening',opening‬‬
‫)‪k = cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫ذ‬

‫امنرٌعخ‪ُ :‬‬
‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ ذ‬

‫ذ‬

‫ذ‬

‫‪ -4‬عؿؾقةذاإلغالقذ‪:Closing‬‬

‫نوٕ نمٌٌص خًفظم‪ ،‬نلىَ ؤوال رظنفٌٍ نمٌٌص خًظمًي ػم نمٌٌص خًظأهٍ‪.‬هٍه خًهمٌٌص مفًٌش ًًٔ‬
‫خًؼلىذ يف خًـٔم ومفًٌش ًًٔ خًنلدؽ خًٔىيخء خًطًًنش نىل خًـٔم‪.‬‬
133 ‫ ببساطة‬OpenCv

ُ :‫امكىد‬
import cv2
import numpy as np
img = cv2.imread('j.png',0)
kernel = np.ones((5,5),np.uint8)

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

cv2.imshow('orginal',img)
cv2.imshow('closing',closing)
k = cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬

:‫امنرٌعخ‬
‫ذ‬

‫ذ‬

‫ذذذ‬

‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ ذ‬

‫ ذ‬:Morphological Gradient‫ عؿؾقةذاؾتدرجذاؾشؽؾيذ‬-5

.‫ رلٌؽ ٓظزًو هلًوي ًٌـٔم‬،‫هى خًفُق رٍن نمٌٌص خًظأهٍ وخًظمًي‬
import cv2
import numpy as np
img = cv2.imread('j.png',0)
kernel = np.ones((5,5),np.uint8)

gradient = cv2.morphologyEx(img, cv2.MORPH_GRADIENT, kernel)
cv2.imshow('orginal',img)
cv2.imshow('gradient',gradient)

k = cv2.waitKey(0)
cv2.destroyAllWindows()

‫ذ‬
‫‪134‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪:‬‬

‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ ذ‬

‫‪ -6‬عؿؾقةذؼبعةذاؾؼؿةذ‪:Top Hat‬‬

‫هى خًلُق رٍن نمٌٌص فظم خًطىَش وخًطىَش نفٔهد‪ .‬يف خًوىي خًظديل ٓنؿزم كندم رلـم ‪.9x9‬‬
‫امكىد‪ُ :‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)‪img = cv2.imread('j.png',0‬‬
‫)‪kernel = np.ones((9,9),np.uint8‬‬

‫)‪tophat = cv2.morphologyEx(img, cv2.MORPH_TOPHAT, kernel‬‬

‫)‪cv2.imshow('orginal',img‬‬
‫)‪cv2.imshow(' tophat ', tophat‬‬
‫)‪k = cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫ذ‬

‫امنرٌعخ‪:‬‬

‫ذ‬ ‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ‬

‫ذ‬
135 ‫ ببساطة‬OpenCv

:Black Hat‫ عؿؾقةذاؾؼبعةذاؾدوداءذ‬-7

.‫هى خًلُق رٍن نمٌٌص بيالق خًطىَش وخًطىَش خألضٌٌص‬

ُ :‫امكىد‬
import cv2
import numpy as np
img = cv2.imread('j.png',0)
kernel = np.ones((9,9),np.uint8)

blackhat = cv2.morphologyEx(img, cv2.MORPH_BLACKHAT, kernel)

cv2.imshow('orginal',img)
cv2.imshow(' blackhat ', blackhat)
k = cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬

ُ
:‫امنرٌعخ‬

‫ذذذذذذذذذذذذذذ‬

‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
136 ‫ ببساطة‬OpenCv

ُ )maskُ‫ُ(املنبع‬:Structuring Elementٍُ‫ امػنرصُامرتكٌث‬
‫ وًون ؤكٌدند‬،‫ وهدن شوٌه مٔظؿًٌل‬Numpy ‫ؤنشإند ٓدرلد ننرصخ طُهٌس ًًوي ردالٓظهدنص مبوظزص‬
‫خًظدرو‬OpenCv ‫ وًهٍخ خًٔزس وفُض ًند موظزص‬،ٍ‫نلظدؾ ألشودي ؤهُي هدًًخثُي وخًلؿه‬
‫ وٓظلطٍ نىل خًلندم خًٍي‬،‫ فلـ مَُ شوٍ وكـم خًلندم‬.cv2.getStructuringElement()
.‫طًًُه‬
# Rectangular Kernel
>>> cv2.getStructuringElement(cv2.MORPH_RECT,(5,5))
‫ذ‬

array([[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]], dtype=uint8) ‫ذ‬
# Elliptical Kernel
>>> cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
‫ذ‬

array([[0, 0, 1, 0, 0],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[0, 0, 1, 0, 0]], dtype=uint8)

# Cross-shaped Kernel
>>> cv2.getStructuringElement(cv2.MORPH_CROSS,(5,5))
‫ذ‬

array([[0, 0, 1, 0, 0],
[0, 0, 1, 0, 0],
[1, 1, 1, 1, 1],
[0, 0, 1, 0, 0],
[0, 0, 1, 0, 0]], dtype=uint8)

ُ :‫مشظؼُبطبيف‬
‫ذ‬ at HIPR2Morphological Operations 
‫ذ‬
‫‪137‬‬ ‫‪ OpenCv‬ببساطة‬

‫امهذف‪ُ :‬‬
‫‪ ‬يف هٍخ خًفطٍ ٓنظهٌم بًـدي طًَؿدض ؤًىخن خًطىَش وطهٌم خًـدي كىخف خألؿٔدَ‪.‬‬
‫‪ٓ ‬نظهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪. cv2.Laplacian()، cv2.Scharr()،cv2.Sobel() :‬‬
‫نكُي‪:‬‬
‫‪ OpenCv‬توػرذؾـاذثالثذأـواعذؿنذؿرذحاتذاؾتدرجذ(ؿرذحاتذاؾرتددذادلرتػعذ‪)HPF‬ذوفي‪:‬ذ ذ‬
‫دوبقل‪,‬ذذار‪,‬ذالبالدقانذذذ‪ . Laplacian, Scharr,Sobel‬ذ‬
‫ذ‬

‫‪ -1‬ؿشتؼاتذدوبقلذوذارذ‪:Sobel and Scharr Derivatives‬‬

‫نمٌٌص ٓىرٌٍ نزدَش نن يمف رٍن نمٌٌظٍ خًرتشٌم خًًإويس ونمٌٌص خًظفدغٍ(خالشظلدق)‪ًًٍ ،‬ى فهٍ‬
‫ؤهًت ملإومص ًٌػـٌف‪ .‬وٌنونى طلًًً خطـده خملشظم (ؤفلٍ ؤَ نمىيي) نن ؾًُم خًظلوم رلٌم‬
‫مظًًنخض خًًهٍ‪ ،‬وٌنونى ؤًػد خًظلوم رلـم خًلندم من هالي مظًًن يف خًًهٍ‪.‬‬

‫بٌخ مَُض خًلٌمص (‪ًٌ )-1‬مظًًن خملٔاوي نن طلًًً كـم خًلندم فٌٔهؿٍ كندم رلـم ‪ 3x3‬من‬
‫خًنىم ‪ Scharr‬وخًٍي ٌٓهؿٌند نظدثف ؤفػٍ‪.‬‬
‫ذ‬
138 ‫ ببساطة‬OpenCv

:Laplacian Derivatives‫ ؿشتقذالبالدقانذ‬-2

ٍ‫كٌؽ ه‬ ‫ًلٔس الرالٌٓدن خًطىَش خملهؿى من هالي خًهالكص‬
.ٌٍ‫مشظم ًُىؿً ردٓظوًخَ مشظم ٓىر‬
:‫ ٌٓوىن خًلندم خملٔظوًَ هٌل ًًل‬،1 ‫ًنفرتع مؼالً ؤن كـم خًلندم هدن‬

[ ]

ُ
ُ :‫امكىد‬
‫ ومظًًن نمم‬،5x5 ْ‫ خألكنهص هٌهد ٓظوىن رلٌد‬.ً‫خًوىي خًظديل ٌٓىغم مد ٓزم يف رُندمف وخك‬
.np.unit8 ‫ ًٌلطىي نىل خًنظٌـص رطًٌص‬-1 ‫خًطىَش منَُ ًه خًلٌمص‬

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('dave.jpg',0)

laplacian = cv2.Laplacian(img,cv2.CV_64F)
sobelx = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=5)
sobely = cv2.Sobel(img,cv2.CV_64F,0,1,ksize=5)

plt.subplot(2,2,1),plt.imshow(img,cmap = 'gray')
plt.title('Original'), plt.xticks([]), plt.yticks([])
plt.subplot(2,2,2),plt.imshow(laplacian,cmap = 'gray')
plt.title('Laplacian'), plt.xticks([]), plt.yticks([])
plt.subplot(2,2,3),plt.imshow(sobelx,cmap = 'gray')
plt.title('Sobel X'), plt.xticks([]), plt.yticks([])
plt.subplot(2,2,4),plt.imshow(sobely,cmap = 'gray')
plt.title('Sobel Y'), plt.xticks([]), plt.yticks([])

plt.show()
‫ذ‬

‫ذ‬
‫‪139‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ :‬‬

‫ذ‬

‫رشػُامكىد‪ُ :‬‬
‫)‪laplacian = cv2.Laplacian(img,cv2.CV_64F‬‬
‫ذ‬

‫خملظًًن خألوي هى ضىَش خًًهٍ‪ ،‬وخملظًًن خًؼدين ٌنؼٍ نمم ضىَش خًوُؾ‪.‬‬

‫)‪sobelx = cv2.Sobel(img,cv2.CV_64F,1,0, ksize=5‬‬
‫ذ‬

‫)( ‪ :cv.Sobel‬خملظًًن خألوي هى ضىَش خًًهٍ‪ ،‬وخملظًًن خًؼدين ٌنؼٍ نمم ضىَش خًوُؾ‪ ،‬وخملظًًن‬
‫خًؼدًؽ ٌنؼٍ خالشظلدق ردًنٔزص ًٌملىَ ‪ X‬وخملظًًن خًُخرو ٌنؼٍ خالشظلدق ردًنٔزص ًٌملىَ‪Y‬‬
‫‪،‬وخملظًًن خًودمٕ ٌنؼٍ كٌدْ خًلندم (ًـس ؤن ًوىن ‪ 0 ،4 ،8‬ؤو ‪)7‬‬
‫ذ‬

‫)‪sobely = cv2.Sobel(img,cv2.CV_64F,0,1, ksize=5‬‬
‫ذ‬
140 ‫ ببساطة‬OpenCv

ُ :‫كظٌخُمهمخ‬
‫ وًون هندن مشوٌص‬cv2.CV_8U ‫ ؤو‬np.uint8 ‫يف خملؼدي خألهًن ًًًند نىم رٌدندض خًوُؾ هى‬
‫ طوىن خًلىخف ننً خالنظلدي من خالٓىي ًلرٌؼ رلٌمص‬،‫ فهنً خًظلىًٍ من خًنىم خألوي ًٌؼدين‬،‫رٌٔؿص‬
‫ ًًٍى ننً طلىًٍ خًزٌدندض ًٌنىم‬،‫ خمد ننً خًظلىًٍ ردًهوٕ فٔظوىن رلٌمص ٓدًزص‬،‫مىؿزص‬
.ً ‫ نفلً طٌى خًلىخف ألنهد طهظرب ؤضفدَخ‬np.unit8

ٍ‫ ؤفػٍ هٌدَ هى ؤن طزلٍ نىل نىم رٌدندض خًوُؾ رطًٌص ؤنىل مؼ‬،‫بٌخ ؤَيض ؤن طوظشف خًلىخف‬
‫ ػم نلىًهد ًٌطًٌص‬،‫ ومن ػم نإهٍ خًلٌمص خملؿٌلص ًهد‬،cv2.CV_64F،cv2.CV_16S
. np.unit8

.‫ وًزٍن خًوؿإ خًلدضٍ ردًلدًص خألوىل‬،ٍ‫خًوىي خًظديل ًىغم هٍخ خإلؿُخء نىل مُشم ٓىرٌٍ خألفل‬

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('box.png',0)

# Output dtype = cv2.CV_8U
sobelx8u = cv2.Sobel(img,cv2.CV_8U,1,0,ksize=5)

# Output dtype = cv2.CV_64F. Then take its absolute and convert to cv2.CV_8U
sobelx64f = cv2.Sobel(img,cv2.CV_64F,1,0,ksize=5)
abs_sobel64f = np.absolute(sobelx64f)
sobel_8u = np.uint8(abs_sobel64f)

plt.subplot(1,3,1),plt.imshow(img,cmap = 'gray')
plt.title('Original'), plt.xticks([]), plt.yticks([])
plt.subplot(1,3,2),plt.imshow(sobelx8u,cmap = 'gray')
plt.title('Sobel CV_8U'), plt.xticks([]), plt.yticks([])
plt.subplot(1,3,3),plt.imshow(sobel_8u,cmap = 'gray')
plt.title('Sobel abs(CV_64F)'), plt.xticks([]), plt.yticks([])
plt.show()

‫ذ‬
‫‪141‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ ُ:‬‬

‫ذ‬

‫مكرشفُامؽىافُكبينُ‪ُ Canny Edge Detection‬‬

‫ذ‬
‫‪142‬‬ ‫‪ OpenCv‬ببساطة‬

‫امهذف‪ُ :‬‬
‫بًـدي خًلىخف (كًوي خألؿٔدَ) مو موظشف كىخف هدين‪.‬‬
‫خٓظوًخَ خًظدرو )(‪.cv2.Canny‬‬
‫نظشي‪ُ :‬‬
‫موظشف كىخف هدين هى هىخَِمٌص مشهىَش ًظلًًً خًلىخف‪ .‬كٌؽ طظإًف هٍه خًوىخَِمٌص من‬
‫نًش مُخكٍ‪ ،‬وٓىف منُ نىل هٍه خملُخكٍ هؿىش روؿىش‪:‬‬
‫ذأ‪ .‬ختػقضذاؾضجقجذ‪Noise Reduction‬‬

‫مبد ؤن خهظشدف خًلىخف ًظإػُ رػـٌف خًطىَش‪ًًٍ ،‬ى ؤوي هؿىش ٓنلىَ رهد هٍ بِخًص هٍخ خًػـٌف‬
‫نن ؾًُم خٓظوًخَ مُشم يإويس ‪ ، 5x5‬هٌل طهٌمند ٓدرلد‪.‬‬

‫ب‪ .‬إجيادذذدةذتدرجذاؾصورة‬
‫ذ‬

‫خًطىَش خملُشلص طُشم رهًهد وفم كندم ٓىرٌٍ يف هال خالطـدهٍن خًهمىيي وخألفلٍ ًنلطٍ نىل‬
‫‪.‬‬ ‫وضىَش ردالطـده خًهمىيي‬ ‫خًظًَؾ (خملشظم خألويل) ًطىَش يف خالطـده خألفلٍ‬

‫ومن هدطٍن خًطىَطٍن ٌنونند خًـدي طًَؾ خًلدفص وخطـده هٍ رٌؤٍ نىل خًنلى خًظديل‪:‬‬
‫√‬

‫خطـده خًظًَؾ(خالشظلدق) يخمئد نمىيي نىل خًلدفص‪ ،‬وًظم طلًُزه بىل ؤكً من خألَرو خًّوخًد خملظمؼٌص‬
‫ردالطـده خالفلٍ وخًهمىيي وخطـده خًلؿًُن‪.‬‬

‫ت‪ .‬إزاؾةذاؾتشوقشذاالذأعظؿيذ‪Non-maximum Suppression‬‬
‫ذ‬

‫رهً خًلطىي نىل خًظًَؾ وخالطـده‪ً ،‬ظم بؿُخء مٔم ًٌطىَش ًلٍف خًزٌؤالض خًظٍ ال طشوٍ‬
‫خًلدفص‪ًًٍ ،‬ى فلظ هٍ رٌؤٍ‪ ،‬فٌٌل بٌخ هدنع كٌمظه ؤهرب (ؤنكم) من كٌمص خًزٌؤالض خملـإوَش‬
‫ًه يف خالطـده وخًشًش‪.‬‬
‫‪143‬‬ ‫‪ OpenCv‬ببساطة‬

‫خنكُ ًٌطىَ ًظدًٌص‬

‫ذ‬ ‫ذ‬

‫خًنلؿص ‪ A‬نىل خًلدفص (يف خالطـده خألفلٍ)‪ .‬ومن خًؿزٌهٍ ؤن ًوىن خطـده خًلدفص ردطـده خملٌٍ‪.‬‬
‫خًنلؿص ‪ B‬و‪ C‬يف خطـده خًظًَؾ‪ًًٍ .‬ى ًظم فلظ خًنلؿص ‪ A‬ملدَنص مو خًنلؿص ‪ B‬و‪ C‬ملهُفص مد بٌخ‬
‫هدنع هٍه خًنلؿص طشوٍ خًلٌمص خًهكمى خًلدًٌص‪.‬‬

‫بٌخ هدنع كٌمص خًنلؿص ‪ِ A‬فهالً هٍ ؤنكم كٌمص ًظدرو ًٌوؿىش خًظٍ رهًهد وبٌخ مل طون نكمى ًظم‬
‫كٍفهد رىغو خًلٌمص ‪ .0‬وردهظطدَ‪ ،‬فةن خًنظٌـص خًظٍ نلطٍ نٌٌهد هٍ ضىَش ػندثٌص مو كىخف ؤنهم‪.‬‬
‫ث‪ .‬اؾتعتقبذادلُتبار ذ‪ :Hysteresis Thresholding‬ذ‬
‫ذ‬

‫يف هٍه خملُكٌص نلًي فٌٌل بٌخ هدنع خًلىخف فهال كىخف ؤَ ال‪ًًٍ ،‬ى نلظدؾ كٌمظٍن ًٌهظزص‪،‬‬
‫نكمى وضًُي (‪ ،)minVal ،maxVal‬وؤي كدفص شًش طًَؿهد ؤهرب من خًلً خألنىل نهظربهد كدفص‬
‫ؤهًًٌص وبٌخ هدنع كٌمظهد ؤكٍ من خًلً خأليىن ال نهظربهد كدفص ونطفُهد‪ .‬ؤمد ردًنٔزص ًٌلٌمص‬
‫خًىٓؿى فنهظمً نىل خططدًهد فةٌخ هدنع مظطٌص مو كدفص ؤهًًٌص فنإهٍهد ؤمد بٌخ هدنع يًن مظطٌص‬
‫ال نإهٍهد‪ .‬شدهً خًطىَش خًظدًٌص‪:‬‬

‫ذ‬
‫‪144‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬خًلدفص ‪ A‬فىق كٌمص خًهظزى خًهكمى ‪ًًٍmaxVal‬ى نهظربهد كدفص ؤهًًٌص‪.‬‬
‫‪ ‬خًلدفص ‪C‬ؤٓفٍ ‪maxVal‬وًونهد مظطٌص مو خًلدفص ‪ًًٍ ،A‬ى نهظربهد ؤًػدً كدفص ؤهًًٌص‪.‬‬
‫‪ ‬خًلدفص ‪ B‬نىل خًُيم من ؤنهد فىق خًلٌمٍ خًًنٌد ًٌهظزص ‪ minVal‬ويف نفٕ منؿلص خًلدفص ‪C‬‬
‫وًونهد يًن مظطٌص مو كدفص ؤهًًٌص ًًٍى ٓنظوٌظ منهد رظطفًنهد‪.‬‬

‫نظٌـص ملد ٓزم ًـس ؤن نهظم ؿًخ ردهظٌدَ كٌمص ضلٌلص ًـ ‪ minVal‬و‪ maxVal‬كظى نلطٍ نىل‬
‫نظٌـص ضلٌلص‪ .‬هٍه خًهمٌٌص طًٍّ ؤًػدً خًػـٌف خًطًًن ًٌزٌؤٍ رفُع ؤن خًلىخف هؿىؽ ؾىًٌص‬
‫(ؤي طًٍّ خًلىخف خًلطًنش)‪ًًٍ .‬ى يف خًنهدًص ٓنلطٍ فلـ نىل خًلىخف خًلىًص‪.‬‬

‫‪ ‬اكرشبفُؼىافُكبينُتبظرخذاوُمكرثخُ‪ُ :OpenCv‬‬
‫‪ OpenCv‬وغهع ًند ؿمٌو خًوؿىخض خًٔدرلص يف طدرو وخكً وهى )(‪.cv2.Canny‬‬

‫رشػُامربتؼُ)(‪ُ :cv2.Canny‬‬
‫ؤوي مظًًن هى ضىَش خملؿٌىذ خهظشدف كىخفهد‪ ،‬وخملظًًن خًؼدين وخًؼدًؽ هٌل كًخ خًهظزص‪ ،‬وخملظًًن‬
‫خًُخرو هى كٌدْ كندم ٓىرٌٍ خمل ُٔظهمٍ إلًـدي طًَؾ خًطىَش (ردًلدًص خالفرتخغٌص طوىن كٌمظه ‪،)3‬‬
‫وخملظًًن خًودمٕ وخألهًن هى ‪ L2gradient‬وقٌفظه هٍ طلًًً خملهديًص خًظٍ طىؿً شًش خًظًَؾ‪،‬‬
‫فةٌخ هدنع كٌمظه ضلٌلص ‪ TRUE‬فةنه ًٔظوًَ خملهديًص خًظٍ ٌهُندهد ٓدرلد وهٍ‪:‬‬
‫√‬

‫وهٍ ؤهًت يكص‪.‬‬
‫ؤمد بٌخ هدنع كٌمظه ‪ False‬فٌٔٔظوًَ خملهديًص خًظدًٌص‪:‬‬

‫|‬ ‫|‬ ‫|‬ ‫|‬

‫(خًلدًص خالفرتخغٌص ًٌمظًًن خًودمٕ طوىن ‪.)FALSE‬‬
145 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('patella.png',0)

edges = cv2.Canny(img,90,250)

plt.subplot(121),plt.imshow(img,cmap = 'gray')
plt.title('Original Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(edges,cmap = 'gray')
plt.title('Edge Image'), plt.xticks([]), plt.yticks([])
plt.show()
‫ذ‬

ُ :‫امنرٌعخ‬

‫ذ‬

ُ :‫مشاظؼُبطبفٌخ‬
 Canny edge detector at Wikipedia
 Canny Edge Detection Tutorial by Bill Green, 2002.

ُ :‫متشًن‬
‫خهظس طؿزٌم ضًًن الهظشدف كىخف هدين ًطىَش مد وكم رظلًًً كٌمص خًهظزظٍن نن ؾًُم ٌسًـ‬
.‫ ورهٍه خًؿًُلص ٓظفهم ؿًٌخ طإػًن كٌمص خًهظزدض نىل نظٌـص خهظشدف خًلىخف‬،side bar ‫خالنّالق‬
‫ذ‬
‫‪146‬‬ ‫‪ OpenCv‬ببساطة‬

‫أفراؿاتذاؾصورةذ‪Image Pyramids‬ذ‬

‫ذ‬

‫ذ‬

‫امهذف‪ُ :‬‬
‫ٓنظهُف نىل ؤهُخمدض خًطىَش‬
‫ٓنٔظهمٍ يمف خًطىَ ردٓظوًخَ خألهُخمدض‪ٓ ،‬ننشح فدههص ؿًًًش "رُطفدق" (رُطلدي ‪+‬‬
‫طفدق)‪.‬‬
‫ٓنظهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪. cv2.pyrDown()، cv2.pyrUp():‬‬
‫نظشي‪ُ :‬‬
‫نديش نظهدمٍ مو ضىَ ٌخض كٌدْ ػدرع‪ ،‬وًون كً نلظدؾ ؤن نظهدمٍ مو كٌدٓدض موظٌفص ًٌطىَش‬
‫نفٔهد‪ .‬فهىل ٓزٌٍ خملؼدي ننً خًزلؽ نن يشء مد يف خًطىَش مؼٍ خًىؿه‪ ،‬نلند ًٔند مظإهًًن مد‬
‫هى كـم خًـٔم خملىؿىي يف خًطىَش‪ًًٍ ،‬ى ٓنلظدؾ إلنشدء مـمىنص من خًطىَ رلٌدٓدض موظٌفص‬
‫وخًزلؽ نن خًىؿىه يف ؿمٌو خًطىَ‪.‬‬

‫طٔمى مـمىنص خًطىَ ٌخض خًلٌدٓدض خملوظٌفص رهَُ خًطىَش (ألنه ننً خالكظفدف رهد ووغههد فىق‬
‫رهػهد خًزهؼ من ؤهرب ضىَش (ؤيق ضىَش) ألضًُ ضىَش (ؤكٍ ضىَش يكص) ٓظزًو نىل شوٍ هُمٍ)‪.‬‬
‫هندن نىنٍن ألهُخمدض خًطىَش‪ :‬خًهَُ خًًإويس وخًهَُ خالراليس‪.‬‬
‫‪147‬‬ ‫‪ OpenCv‬ببساطة‬

‫ًظشوٍ ؤنىل مٔظىي (خألهف يكص) يف خًهَُ خًًإويس نن ؾًُم كٍف خألٓؿُ وخالنمًش خملظهدكزص‬
‫يف خملٔظىي خأليىن ًٌهَُ (خألنىل يكص)‬

‫ػم ًظشوٍ هٍ رٌؤٍ يف خملٔظىي خألنىل ًٌهَُ رظؿزٌم خًلندم خًًإويس نىل ‪5‬رٌؤالض من‬
‫خملٔظىي خأليىن ًٌهَُ‪ .‬ونظٌـص ًًٍى ًظلٌظ كـم خًطىَش ًٌُرو‪ .‬هٍه خًهمٌٌص طٔمى ؤوهظدف‬
‫(‪.)Octave‬‬

‫ًٔظمُ هٍخ خألمُ هٌٌل ضهًند ًلمص خًهَُ (طنوفؼ خًًكص وًلٍ كـم خًطىَش هٌٌل ضهًند مٔظىي‬
‫ؤنىل ردطـده خًلمص)‪ .‬ؤمد ننً خًظلُن من مٔظىي ؤنىل ملٔظىي ؤيىن ًًًّ كـم ووغىق خًطىَش‪.‬‬
‫ًظم بنـدِ نمٌٌص ًِديش كـم ووغىق خًطىَش ونلطدنهٌل نن ؾًُم خًظدرهٍن‪cv2.pyrDown() :‬‬
‫و)(‪.cv2.pyrUp‬‬
‫‪ ‬خًظدرو )(‪ ًًًّ cv2.pyrUp‬يكص وكـم خًطىَش‪.‬‬
‫‪ ‬خًظدرو )(‪ً cv2.pyrDown‬وفف يكص وكـم خًطىَش‪.‬‬

‫خًطىَش خًظدًٌص طزٍن ػالغ مٔظىًدض من خًهَُ خًًإويس‪:‬‬

‫ذ‬
‫‪148‬‬ ‫‪ OpenCv‬ببساطة‬

‫شدهً خًوىي خًظديل هٌف ٌٓوفؼ يكص خًطىَش‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬

‫)‪img = cv2.imread('sonic.jpg',1‬‬
‫)‪lower_reso = cv2.pyrDown(img‬‬

‫)‪cv2.imshow('orginal',img‬‬
‫)‪cv2.imshow('lower_reso Image',lower_reso‬‬
‫)‪k = cv2.waitKey(0‬‬
‫)(‪cv2.destroyAllWindows‬‬

‫امنرٌعخ‪ُ :‬‬

‫ذ‬

‫وشدهً خًوىي خًظديل هٌف ًًٌّٓ وغىق خًطىَش خًطًًنش‪ ،‬وًون طٍهُ رإن خًطىَش خًندطـص ننً‬
‫خًنّوي يف خًهَُ طوظٌف نن خًطىَش خألضٌٌص ألن طىًًٌ ضىَش ؤكٍ يكص ًلٍف مهٌىمدض من خًطىَش‪،‬‬
‫وًًٍى ٓظوىن موظٌفص ٌنونى مالككص خًفُق يف خًطىَش ننً طؿزٌم خًوىي خًظديل‪:‬‬

‫)‪higher_reso = cv2.pyrUp(lower_reso‬‬
‫ذ‬
‫‪149‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫خألهُخمدض خالرالٌٓص طظشوٍ من خألهُخمدض خًًإوٌٓص‪ ،‬وال ًىؿً طدرو موطظ ًهد‪.‬‬

‫ضىَ خًهَُ خالراليس مهكم نندرصهد ؤضفدَ‪ .‬طٔظهمٍ ؾًُلص خًهَُ خالراليس ًػًـ خًطىَ‪ .‬كٌؽ‬
‫ًظشوٍ خملٔظىي يف خًهَُ خالراليس من هالي خًفُق رٍن خملٔظىي خملندقُ ًٌهَُ خًًإويس مو‬
‫نٔوص موربش يف خملٔظىي خأليىن ًٌهَُ‪.‬‬

‫خًطىَش خًظدًٌص طزٍن ػالغ مٔظىًدض من خًهَُ خالراليس‪:‬‬
‫‪150‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬دمغُامصىسُتبظرخذاوُا ُألهشامبد‪ُ :‬‬
‫بكًي طؿزٌلدض خالهُخمدض هٍ يمف خًطىَ‪. Blending‬‬

‫ننً يمف ضىَ مهد كً ال طزًو خًطىَش خًندطـص ؿًٌش رٔزس وغىق خالنلؿدم رٍن خًطىَ‪ًًٍ ،‬ى‬
‫ٓنلظدؾ ًؿًُلص طٔدنًند نىل مّؾ خًطىَ مهد رٔهىًص ورًون فلًخن خًزٌدندض‪ ،‬وهٍخ مد طىفُه ًند‬
‫ؤهُخمدض خًطىَش‪.‬‬

‫ؤكً خألمؼٌص خًظلًًٌٌص نىل ًٌى هى نمٌٌص خًًمف رٍن فوهظٍن هٌل خًظفدق وخًربطلدي‪ ،‬شدهً خًطىَش‬
‫خًظدًٌص ًظفهم مد ؤكطً‪.‬‬

‫نمٌٌص خًًمف رٍن خًظفدق وخًربطلدي طظم نىل خًنلى خًظديل‪:‬‬

‫نلمٍ ضىَش خًظفدكص وخًربطلدًص‬ ‫‪.8‬‬
‫نىؿً خًهَُ خًًإويس ًٌظفدكص وخًربطلدًص (يف هٍخ خملؼدي ؤوؿًند ‪6‬مٔظىًدض ًٌهَُ(‬ ‫‪.4‬‬
‫من خًهَُ خًًإويس نىؿً خًهَُ خالراليس‬ ‫‪.4‬‬
‫خآلن نـمو خًلٔم خًٌٔدَي ًٌظفدكص مو خًلٔم خًٌمٌنٍ ًٌربطلدًص يف هٍ مٔظىي من خًهَُ‬ ‫‪.3‬‬
‫خالراليس‪.‬‬
‫وؤهًنخ ً من ضىَ خًهَُ خملـمىنص نزنٍ خًطىَش خألضٌٌص‪.‬‬ ‫‪.0‬‬
151 ‫ ببساطة‬OpenCv

‫خًوىي خًظديل ًٍسق ؾًُلص خًظنفٌٍ هؿىش روؿىش وروٍ رٔدؾص (ًٌظزٌٔـ وخإلًػدق كمند روظدرص خًوىي‬
)‫ بن هٍخ خًؿًُلص يف هظدرص خًوىي ٓظايي الٓظهالن كٔم هزًن من خًٍخهُش‬.‫رهٍه خًؿًُلص‬

import cv2
import numpy as np,sys

A = cv2.imread('apple.png')
B = cv2.imread('orange.png')

# generate Gaussian pyramid for A
G = A.copy()
gpA = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpA.append(G)

# generate Gaussian pyramid for B
G = B.copy()
gpB = [G]
for i in xrange(6):
G = cv2.pyrDown(G)
gpB.append(G)

# generate Laplacian Pyramid for A
lpA = [gpA[5]]
for i in xrange(5,0,-1):
GE = cv2.pyrUp(gpA[i])
L = cv2.subtract(gpA[i-1],GE)
lpA.append(L)

‫ذ‬
152 ‫ ببساطة‬OpenCv

# generate Laplacian Pyramid for B
lpB = [gpB[5]]
for i in xrange(5,0,-1):
GE = cv2.pyrUp(gpB[i])
L = cv2.subtract(gpB[i-1],GE)
lpB.append(L)

# Now add left and right halves of images in each level
LS = []
for la,lb in zip(lpA,lpB):
rows,cols,dpt = la.shape
ls = np.hstack((la[:,0:cols/2], lb[:,cols/2:]))
LS.append(ls)

# now reconstruct
ls_ = LS[0]
for i in xrange(1,6):
ls_ = cv2.pyrUp(ls_)
ls_ = cv2.add(ls_, LS[i])

# image with direct connecting each half
real = np.hstack((A[:,:cols/2],B[:,cols/2:]))

plt.imshow(ls_)
plt.show()

plt.imshow(real)
plt.show()
‫ذ‬

ُ :‫مشظؼُبطبيف‬
Image Blending 

‫ذ‬

‫ذ‬

‫ذ‬
‫‪153‬‬ ‫‪ OpenCv‬ببساطة‬

‫مؼبتلخُاملىامجُ‪ُ Template Matching‬‬

‫امهذف‪ُ :‬‬
‫بًـدي ؿٔم يخهٍ ضىَش ردٓظوًخَ مؿدرلص خًلىخًس‬
‫ٓنظهٌم خٓظوًخَ خًظىخرو‪cv2.minMaxLoc()، cv2.matchTemplate():‬‬
‫ُ‬
‫مػنىمبدُنظشًخ‪ُ :‬‬
‫ُ‬
‫مؿدرلص خًلىخًس هٍ ؾًُلص ًٌزلؽ وبًـدي مىغو كدًس ًٌطىَش غمن ضىَش ؤهرب‪ .‬موظزص ‪OpenCv‬‬
‫طىفُ ًند خًظدرو )(‪ً cv2.matchTemplate‬ظنفٌٍ نمٌٌص مؿدرلص خًلدًس‪.‬‬

‫ًنظفم يف خًزًخًص نىل مطؿٌلٍن وهٌل ضىَش خًلدًس وضىَش خًهًف‪ .‬فةٌخ ؤَيند خًزلؽ مؼال نن‬
‫ضىَش وؿه خًؿفٍ يف خًطىَش خًظدًٌص‪ ،‬فةنند نٔمٍ ضىَش خًىؿه ردًلدًس‪ ،‬وخًطىَش خًظٍ رلؼند رًخهٌهد‬
‫نن ضىَش خًىؿه ردًطىَش خًهًف‪.‬‬
‫‪154‬‬ ‫‪ OpenCv‬ببساطة‬

‫نمٌٌص ملؿدرلص طظم رزٔدؾص رلٌؽ منَُ ضىَش خًلدًس فىق ضىَش خًهًف ونلدَن رٍن خًلدًس وهٍ‬
‫رلهص يف ضىَش خًهًف كظى نـً ضىَش خًلدًس خملؿٌىرص‪ .‬هندن نًش ؾُق ًهمٌٌص خمللدَنص غمن‬
‫موظزص ‪.OpenCV‬‬

‫طظم نمٌٌص خملؿدرلص نن ؾًُم متًُُ ضىَش خًلدًس نىل هدمٍ ضىَش خًهًف‪ ،‬وطوىن خًطىَش خًندطـص‬
‫نن خمللدَنص ضىَش َمديًص‪ ،‬رلٌؽ هٍ رٌؤٍ غمنهد ًًي نىل همٌص خًزٌؤالض خملـإوَش ًه خًظٍ‬
‫طظؿدرم مو خًلدًس‪.‬‬

‫بٌخ هدنع ضىَش خًًهٍ رلـم (‪ )W x H‬وضىَش خًلدًس كـمهد (‪ٌٓ ،)w x h‬وىن كـم ضىَش خًوُؾ‬
‫( ‪ ،)W-w+1 x H-h+1‬ننً خًلطىي نىل ضىَش نظٌـص خملؿدرلص ٌنونى خٓظهٌلي خًظدرو‬
‫)(‪ cv2.minMaxLoc‬إلًـدي ؤهرب وؤكٍ كٌمص من نندرص خملطفىفص (ًٌطىَش خًندطـص نن خملؿدرلص)‬
‫رلٌؽ ًهًٌ ًند هٍخ خًظدرو كٌمظٍن ردًشوٍ )‪. (x,y‬‬

‫بٌخ خنظربند هدطٍن خًلٌمظٍن هٌل بكًخػٌدض خًّؤوًص خًٌرسي خًهٌٌد ًٌمٔظؿٌٍ‪ ،‬وخنظربند خن نُع هٍخ‬
‫خملٔظؿٌٍ وؾىًه هى (‪ )w x h‬ننًهد ٌٓوىن هٍخ خملٔظؿٌٍ هى خًٍي ٌٓلًي منؿلص خًلدًس يف‬
‫خًطىَش خًندطـص (ًٌظىغٌم‪ :‬ؤهٍند خًؿىي وخًهُع من ضىَش خًلدًس وؤهٍند بكًخػٌدض ِؤوًص‬
‫خملٔظؿٌٍ من خًظدرو )(‪.) minMaxLoc‬‬

‫مالككص‪ :‬بٌخ خٓظوًمع ‪ cv2.TM_SQDIFF‬هؿًُلص ًٌملدَنص فٌفػٍ خٓظوًخَ كٌمص ضًُي فهٍ طهؿٍ نظٌـص‬
‫ؤفػٍ ًٌمؿدرلص‪.‬‬

‫‪ ‬مؼبتلخُاملىامجُيفُ‪ُ :OpenCv‬‬
‫يف هٍخ خملؼدي ٓنلىَ ردًزلؽ نن وؿه خًؿفٍ(خًلدًس) يف خًطىَش خًٔدرلص (خًهًف)‪ًًٍ ،‬ى ٓننشإ‬
‫كدًس هٌل ًًل‪:‬‬
155 ‫ ببساطة‬OpenCv

:‫ٓنـُذ هٍ ؾُق خمللدَنص وٓنشدهً نظدثـهد‬
import cv2 ‫ذ‬
import numpy as np
from matplotlib import pyplot as plt
‫ذ‬
img = cv2.imread('kid_football.jpg',0)
img2 = img.copy() ‫ذ‬
template = cv2.imread('template.jpg',0)
w, h = template.shape[::-1]
‫ذ‬
# All the 6 methods for comparison in a list
methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR', ‫ذ‬
'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF',
'cv2.TM_SQDIFF_NORMED']
for meth in methods: ‫ذ‬
img = img2.copy()
method = eval(meth)
# Apply template Matching
res = cv2.matchTemplate(img,template,method)
min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res)

# If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum
if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:
top_left = min_loc
else:
top_left = max_loc
bottom_right = (top_left[0] + w, top_left[1] + h)

cv2.rectangle(img,top_left, bottom_right, 255, 2)

plt.subplot(121),plt.imshow(res,cmap = 'gray')
plt.title('Matching Result'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img,cmap = 'gray')
plt.title('Detected Point'), plt.xticks([]), plt.yticks([])
plt.suptitle(meth)
plt.show()
156 ‫ ببساطة‬OpenCv

‫ ذ‬:‫اؾـتقجة‬

cv2.TM_CCOEFF 

‫ذ‬

cv2.TM_CCOEFF_NORMED 

‫ذ‬

‫ذ‬

cv2.TM_CCORR 

‫ذ‬

‫ذ‬

‫ذ‬
157 ‫ ببساطة‬OpenCv

cv2.TM_CCORR_NORMED 

‫ذ‬

cv2.TM_SQDIFF 

‫ذ‬

cv2.TM_SQDIFF_NORMED 

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪158‬‬ ‫‪ OpenCv‬ببساطة‬

‫ٌنونى خملالككص رإن نظٌـص خٓظوًخَ ‪ًٌٔ cv2.TM_CCORR‬ع ؿًٌش‪.‬‬
‫رشػُامكىد‪ُ :‬‬
‫)‪img = cv2.imread('kid_football.jpg',0‬‬
‫)(‪img2 = img.copy‬‬
‫)‪template = cv2.imread('template.jpg',0‬‬
‫]‪w, h = template.shape[::-1‬‬
‫ذ‬

‫يف خًزًخًص كمند ردٓظًندء موظزظٍ ‪ OpenCv‬و‪ .Numpy‬ػم ه ّّند خًطىَش خًهًف (خًطىَش خملؿٌىذ‬
‫بًـدي خًـٔم غمنهد) يف خملظًًن ‪ img‬وكمند رنٔى خًطىَش وطوًّنهد يف خملظًًن ‪ .imge2‬ػم ه ّّند‬
‫ضىَش خًلدًس يف خملظًًن ‪ .template‬ورهً ًٌى هّند خَطفدم ونُع ضىَش خًلدًس يف خملظًًنًن ‪w‬‬
‫و‪ h‬وًٌى نن ؾًُم خًظدرو )(‪.shape‬‬

‫‪methods = ['cv2.TM_CCOEFF', 'cv2.TM_CCOEFF_NORMED', 'cv2.TM_CCORR',‬‬
‫]'‪'cv2.TM_CCORR_NORMED', 'cv2.TM_SQDIFF', 'cv2.TM_SQDIFF_NORMED‬‬
‫ذ‬

‫ؤنشإند مطفىفص وهّنهد رًخهٌه خألٌٓلء خًظٍ رٍن خألكىخْ‪ .‬هٍه خألٌٓلء ٓظمؼٍ ؤٌٓلء خًنىخفٍ خًظٍ‬
‫ٓنهُغهد‪.‬‬
‫‪for meth in methods:‬‬
‫)(‪img = img2.copy‬‬
‫)‪method = eval(meth‬‬
‫ذ‬

‫خًًدًص هند من كٌلص ‪for‬هٍ نُع هٍ ؾُق خمللدَنص‪.‬‬
‫وقٌفص خًظدرو )(‪ eval‬هى بِخًص نالمص خالكظزدْ (ًظىغٌم ؤهًت شدهً خألمؼٌص من فـا)‬

‫‪# Apply template Matching‬‬
‫)‪res = cv2.matchTemplate(img,template,method‬‬
‫)‪min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res‬‬
‫ذ‬

‫نلىَ رهمٌٌص خملؿدرلص نن ؾًُم خًظدرو )(‪.cv2.matchTemplate‬‬

‫خملظًًن خألوي ًهٍخ خًظدرو ٌنؼٍ خًطىَش خًهًف وخملظًًن خًؼدين ٌنؼٍ ضىَش خًلدًس وخملظًًن خًؼدًؽ‬
‫ٌنؼٍ ؾًُلص خمللدَنص‪.‬‬
‫‪159‬‬ ‫‪ OpenCv‬ببساطة‬

‫)‪min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(res‬‬
‫ذ‬

‫رشوٍ ندَ خًظدرو )(‪ً minMaxLoc‬ىؿً كٌمص ؤهرب وؤكٍ ننرص يف خملطفىفص وًهؿٌند ؤًػد مىكو‬
‫هًٍن خًهنرصًن غمن خملطفىفص ردإلكًخػٌدض )‪.(x,y‬‬

‫يف ٓؿُ خًوىي هٍخ ٓنلًي خملنؿلص خًظٍ طم بًـدي فٌهد ضىَش خًلدًس غمن خًطىَش خًهًف‬
‫مبٔظؿٌٍ وًٌى ردالٓظهدنص ردًظدرو )(‪ cv2.minMaxLoc‬خًٍي ًهًٌ ًند ؤنىل وؤيىن كٌمص‬
‫ًٌزٌؤٍ يف خًطىَش خًندطـص نن خملؿدرلص مو مىغو هًٍن خًزٌؤٌٍن غمن هٍه خًطىَش‪ .‬نوظدَ‬
‫ؤكًخػٌدض ؤكً هًٍن خملىغهٍن ًنلًي بكًخػٌدض خًّوًص خًٌرسي خًهٌٌد ًٌمٔظؿٌٍ‪( .‬يف مؼدًند ننً‬
‫خٓظهٌلي خًؿًُلص ‪ٓ cv2.TM_CCOEFF‬نلطٍ نىل خًلًًن (‪ .) )98 ،44( )85 ،844‬ػم نوظدَ خًلً‬
‫خملندٓس خًٍي ٌنؼٍ ِؤوًص خملٔظؿٌٍ‪.‬‬

‫ٌٓظم طوًّن خًلً خأليىن يف خملظًًن ‪ min_loc‬وخًلً خألنىل يف خملظًًن ‪ .max_loc‬هٌل كطٌند‬
‫كظى خآلن نىل بكًخػٌدض ِؤوًص خملٔظؿٌٍ‪ ،‬ونلظدؾ خآلن ًظلًًً كًوي منؿلص خملؿدرلص ًًٍى ًـس‬
‫ؤن نهُف ؾىي ونُع هٍخ خملٔظؿٌٍ‬
‫ُفكٌفُظنػشفُامؼىلُوامػشض؟ ُ‬
‫ؾىي ونُع خملٔظؿٌٍ هٌل نفٕ ؾىي ونُع ضىَش خًلدًس‪.‬‬
‫‪# If the method is TM_SQDIFF or TM_SQDIFF_NORMED, take minimum‬‬
‫‪if method in [cv2.TM_SQDIFF, cv2.TM_SQDIFF_NORMED]:‬‬
‫‪top_left = min_loc‬‬
‫‪else:‬‬
‫‪top_left = max_loc‬‬
‫)‪bottom_right = (top_left[0] + w, top_left[1] + h‬‬

‫)‪cv2.rectangle(img,top_left, bottom_right, 255, 2‬‬

‫يف هٍخ خًوىي خهرتند ؤكًخػٌدض مىغو ؤنىل ؤو ؤيىن كٌمص ًٌزٌؤٍ وًٌى كٔس هٍ ؾًُلص‬
‫ملدَنص‪ ،‬فزدًنٔزص ألهُ ؾًُلظٍ ملدَنص خهرتند بكًخػٌدض خًلٌمص خأليىن فهى خًلً خملندٓس ًظلًًً‬
‫ؤكًخػٌدض ِؤوًص مٔظؿٌٍ منؿلص خملؿدرلص‪ ،‬ؤمد ردًنٔزص ًؿُق خمللدَنص خًزدكٌص فلً خهرتند بكًخػٌدض‬
‫خًلٌمص خألنىل فهى خألنٔس ًظلًًً ؤكًخػٌدض ِؤوًص هٍخ خملٔظؿٌٍ‪ .‬وؤهًنند كمند رُٓم مٔظؿٌٍ‬
‫كىي منؿلص خًلدًس خملىؿىيش يف ضىَش خًهًف‪.‬‬
160 ‫ ببساطة‬OpenCv

ُ :ً‫ مؼبتلخُاملىامجُمػذحُؤظعبوُمػب‬
‫ وًون خفرتع‬،‫يف خًٔدرم رلؼند نن ؿٔم وخكً وهى وؿه خًؿفٍ وخًٍي ًىؿً مُش وخكًش يف خًطىَش‬
‫ ننًهد ًن ًنفو خٓظوًخَ خًظدرو‬،‫رإن ًًًند ؤهًت من ؿٔم نًًُ بًـديه ردًطىَش‬
‫ ًنإهٍ خملؼدي خًظديل من ًهزص مدًَى‬.‫ وًـس رًالً ننه خٓظوًخَ خًظهظٌس‬cv2.minMaxLoc()
:‫خملشهىَش‬

import cv2
import numpy as np
from matplotlib import pyplot as plt

img_rgb = cv2.imread('mario.jpg')
img_gray = cv2.cvtColor(img_rgb, cv2.COLOR_BGR2GRAY)
template = cv2.imread('mario_coin.png',0)
w, h = template.shape[::-1]

res = cv2.matchTemplate(img_gray,template,cv2.TM_CCOEFF_NORMED)
threshold = 0.8
loc = np.where( res >= threshold)
for pt in zip(*loc[::-1]):
cv2.rectangle(img_rgb, pt, (pt[0] + w, pt[1] + h), (0,0,255), 2)

cv2.imshow('res',img_rgb)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫ ذ‬:‫اؾـتقجة‬
‫ذ‬
‫ذ‬
‫‪161‬‬ ‫‪ OpenCv‬ببساطة‬

‫شدهً من ضىَش نظٌـص خملؿدرلص رإن خًنلـ خًزٌػدء خألهًت ٓؿىند متؼٍ خًزٌؤالض خًظٍ طإهٍ ؤهرب‬
‫كٌمص‪ ،‬وخًظٍ َٓمند ننًهد مٔظؿٌٍ مٌىن ردألكمُ هٌل هى وخغم يف خًطىَش خًٔدرلص‪.‬‬
‫معبغذحُمرشػُامكىد‪ُ :‬‬
‫ًنهُف مطفىفص ‪ A‬ػندثٌص خًزهً ‪ 2D‬طإهٍ خًلٌم خًظدًٌص‪:‬‬
‫?‬ ‫?? ?‬ ‫?‬

‫? ?‬ ‫? ?‬

‫)]]‪A = np.array([[2,3,4,5,6,78,97,100],[8,3,1,5,7,8,9,10‬‬
‫‪print A‬‬
‫ذ‬

‫ٓنؿزم نٌٌهد خًظدرو )‪ np.where(A > threshold‬وٓنػو خًٍسؽ رًخهٍ هٍخ خًظدرو رإن ًإهٍ‬
‫نندرص خملطفىفص خًظٍ كٌمظهد طوىن ؤهرب من ‪( 0‬ؤي نػو خًـ ‪ )threshold = 5‬وٌٓهًٌ ًند خًظدرو‬
‫مىغو هٍه خًهندرص غمن خملطفىفص‪( .‬يف خًوىي مؿدرلص خًلىخًس ًهًش خؿٔدَ يًن خي ‪threshold‬‬
‫وشدهً مدٌخ ًلطٍ)‬
‫‪threshold = 5‬‬
‫)‪loc = np.where( A > threshold‬‬
‫ذ‬
‫))]‪(array([0, 0, 0, 0, 1, 1, 1, 1, 1]), array([4, 5, 6, 7, 0, 4, 5, 6, 7‬‬

‫شدهً خًنظٌـص خًٔدرلص ٓرتي رإنه ؤندي مىغو هٍ ننرص يف خملطفىفص غمن خًٍسؽ رُكم خًٔؿُ‬
‫وخًهمىي كٌؽ خًـ‪ array‬خألوىل متؼٍ خًٔؿُ وخًـ ‪ array‬خًؼدنٌص متؼٍ خًهمىي‪.‬‬
‫‪162‬‬ ‫‪ OpenCv‬ببساطة‬

‫هٍخ خملىكو ًلىي نىل نًش ؤمؼٌص كظى طفهم خًهمٌٌدض خًظٍ طـُي نىل خملطفىفص وخًظٍ‬
‫خٓظوًمندهد يف خًوىي‪:‬‬
‫‪https://docs.scipy.org/doc/numpy-dev/user/quickstart.html‬‬

‫ذ‬

‫خًطىَش خًظدًٌص طهُع نظٌـص خًزلؽ نن خالي يس غمن خًزىَي‪.‬‬

‫ذ‬

‫خًطىَش خًظدًٌص طهُع نظٌـص خًزلؽ نن خمللإومص يف خًزىَي خالًورتوين‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪163‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذؽىًهُهبفُمنخؽُ‪ُ Hough Line Transform‬‬

‫ذ‬

‫امهذف‪ُ :‬‬
‫يفذفذاذاؾػصل ذ‬

‫ٓنظهٌم مد هى مفهىَ طلىًٍ هدف‬
‫ٓرني هٌف ٓنٔظهمٍ طلىًٍ هدف ًٌوشف نن خًوؿىؽ يف خًطىَش‬
‫ٓنظهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪cv2.HoughLinesP()،cv2.HoughLines() :‬‬
‫مػنىمبدُنظشًخ‪ُ :‬‬
‫طلىًٍ هدف هى طلنٌص شدثهص الهظشدف ؤي شوٍ ٌنون متؼٌٌه مبهديًص ًَدغٌص‪ ،‬كٌؽ ٌنونه‬
‫خهظشدف خًشوٍ كظى وًى هدن خًشوٍ مظلؿو ؤو مشىه كٌٌال‪ٓ ،‬رني هٌف ًهمٍ هٍخ خًظلىًٍ‬
‫ًٌوشف نن خًوؿىؽ خًظٍ يف خًطىَش‪.‬‬

‫ؤو ٌنون متؼٌٌه ردًشوٍ خًزدَمرتي‬ ‫خًوـ ٌنؼٍ ًَدغٌد ردملهديًص‬
‫كٌؽ ? متؼٍ مٔدفص خملٔظلٌم خًهمىيي من خملزًؤ نىل‬ ‫?‬ ‫?‬
‫خًوـ‪ ،‬و ? متؼٍ خًّؤوًص رٍن هٍخ خملٔظلٌم خًهمىيي وخمللىَ خألفلٍ )‪ ،(x‬وكٌدْ هٍه خًّؤوًص‬
‫ًوىن رهوٕ نلدَذ خًٔدنص‪.‬‬

‫نظٌـص ملد ٓزم‪ ،‬بٌخ خًوـ مُ ؤٓفٍ خملزًؤ ٓظوىن كٌمص ? مىؿزص‬
‫وخًّؤوًص ٓظوىن ؤكٍ من ‪ ،ْ 885‬ؤمد بٌخ مُ فىق خملزًؤ خًّؤوًص رًي‬
‫ؤن نلىي بن ِؤوًظه ؤهرب من ‪ٓ 885‬نإهٍ ِؤوًظه رلٌؽ طوىن ؤكٍ‬
‫من ‪ ْ 885‬وًون ? ٓظإهٍ كٌمص ٓدًزص‪ ،‬وؤي هـ نمىيي ِؤوًظه‬
‫ٓظوىن ‪ ْ 5‬يَؿص وؤي هـ ؤفلٍ ٓظوىن ِؤوًظه ‪ ْ 95‬يَؿص‪.‬‬
‫‪164‬‬ ‫‪ OpenCv‬ببساطة‬

‫كٌفُذرمُغمنٌخُذؽىًهُهبفُمنخؽ‪ُ :‬‬
‫ؤوال نٌٌند متؼٌٍ هٍ هـ وفم ردَخمرتًن هٌل )‪ .(?, θ‬يف خًزًخًص ًننشإ مطفىفص ‪ 2D‬ؤو مُخهم‬
‫( ُم َـ ِم ْو) (ًالكظفدف رلٌمص خًزدَخمرتًن ? و‪ )θ‬ونلىَ يف خًزًخًص رظطفًنهم‪ٓ ،‬نـهٍ ضفىف‬
‫خملطفىفص ‪ًًٌ rows‬الًص نىل ?‪ ،‬وؤنمًش خملطفىفص ‪ًًٌcolumns‬الًص نىل ‪.θ‬‬

‫‪ ‬كـم خملطفىفص ًهظمً نىل خًًكص خًظٍ نلظدؿهد‪ً .‬نفرتع ؤنند نًًُ يكص خًّؤوًص طٔإوي ‪ْ 8‬‬
‫يَؿص‪ٓ ،‬نلظدؾ ملطفىفص رـ ‪ 885‬نمىي‪.‬‬
‫‪ ‬مبد ؤن ؤهرب مٔدفص ممونص ًـ ? هٍ كؿُ خًطىَش‪ًًٍ ،‬ى ًٌلطىي نىل يكص ‪ 8‬رٌؤٍ‪،‬‬
‫ٓنلظدؾ ملطفىفص نًي ضفىفهد ًٔإوي كؿُ خًطىَش‪.‬‬
‫‪ً ‬نفُع ًًًند ضىَش رلـم ‪ 100x100‬فٌهد هـ ؤفلٍ ردًىٓـ‪ .‬هٍ ؤوي نلؿص ًى من خًوـ‬
‫مو مهُفظى إلكًخػٌدض ًٌنلؿص )‪ (x,y‬خًظٍ خهرتطهد‪.‬‬
‫‪ ‬نىع كٌم ‪ θ=0,1,2,…. ,180‬يف مهديًص خًوـ‪ٓ ،‬ظلطٍ نىل كٌمص ? رلٔس كٌمص ‪θ‬‬
‫خًظٍ نىغندهد‪.‬‬
‫‪ ‬يف هٍ ِوؾ )‪ٌ (?, θ‬نونى ًِديش كٌمص خملُخهم مبلًخَ ‪ 8‬يف هالًد )‪ (?, θ‬خمللدرٌص ًهد‪.‬كظى‬
‫خآلن ًىؿً يف خملُخهم خًوٌٌص ‪ )50,90( =1‬خًظٍ طوىن رـدنس خًوالًد خألهُي خًظٍ يف‬
‫خملُخهم‪.‬‬
‫‪ ‬خآلن هٍ خًنلؿص خًؼدنٌص من نىل خًوـ وخفهٍ نفٕ خًيشء خًٍي فهٌنده يف خًٔدرم‪ٓ ،‬ظشدهً‬
‫ًِديش يف كٌمص خًوالًد خمللدرٌص ًـ )‪ (?, θ‬خًظٍ كطٌع نٌٌهد‪ ،‬هٍه خملُش خًوٌٌص ٓظطزم‬
‫كٌمظهد ‪.)50,90( = 4‬‬
‫مد طفهٌه ردًػزـ رإنى ططىض ًلٌم )‪( (?,θ‬يف هٍ نلؿص نإهٍهد ًًًّ نًي خألضىخض هٌل يف‬
‫خالنظودردض) (نن ؾًُم ًِديش نًي خألضىخض ٓنهُف نًي نلدؽ خًوـ فنهٌم ؾىي خًوـ)‪ ،‬نلىَ‬
‫رظنفٌٍ نفٕ خًهمٌٌص خًٔدرلص نىل ؿمٌو نلدؽ خًوـ‪ ،‬وننً هٍ نلؿص ٓظًًّ كٌمص خًوٌٌص (‪)50,90‬‬
‫ؤو ًًٌّٓ ضىطهد‪ ،‬رٌنٌل خًوالًد خألهُي كً ًًًّ نًي ؤضىخطهد ؤو ال‪ ،‬ورهٍه خًؿًُلص ٓنطٍ ًٌنهدًص‬
‫وٓظلطٍ خًوٌٌص (‪ )50,90‬نىل كٌمص ؤنىل ضىض‪.‬‬
‫ًًٍى بٌخ هنع طزلؽ يف خملُخهم نن ؤنىل ضىض ٓظلطٍ نىل خًلٌمص (‪ )50,90‬خًظٍ ٓظوربند رإن‬
‫هندن هـ يف خًطىَش نىل مٔدفص ‪ 05‬من خملزًؤ ورّؤوًص ‪ 95‬يَؿص‪.‬‬
‫وهٍه هٍ آًٌص نمٍ طلىًٍ هدف ًٌوـ‪ ،‬وٌنون طؿزٌله خًػدً ردٓظوًخَ موظزص ‪ ،Numpy‬وطكهُ‬
‫خًلٌم خملوظدَش يف خملُخهم هنلدؽ ٌَوش رٌػدء فٌم بٌخ مؼٌنده رطىَش َمديًص‪.‬‬
‫‪165‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫خًطىَش خًظٍ نىل خًٌمٍن طىغم نظٌـص طلىًٍ هدف ًٌمٔظلٌمٍن خملىغلٍن نىل خًشوٍ خًٌٔدَي‪.‬‬
‫ًًّديش فهمى ألًٌص نمٍ طلىًٍ هدف ٌنونى خالؾالم نىل مد ًًل‪:‬‬
‫‪‬‬ ‫(ذافدذاؾرمسةذادلتحرؽةذاؾيتذتشرحذؽقفذقتمذزقادةذؼقؿةذاخلالقاذيفذادلراؽم) ‪Image Courtesy: Amos Storkey‬‬
‫‪‬‬ ‫‪Image courtesy: Wikipedia‬‬
‫(حيويذفذاذادلوؼعذعؾىذذرحذؿبدطذعؾىذذؽلذردومذتوضقحقة) ذ‪Explain Hough Transformation stackoverflow‬‬

‫‪ ‬ذؽىًهُهبفُيفُ‪:OpenCv‬‬
‫هٍ يشء طم ٌسكه ٓدرلد مىؿىي يف خًظدرو )(‪ ،cv2.HoughLines‬وهى رزٔدؾص ًهًٌ مطفىفص ًلٌم‬
‫)‪ ،(?, θ‬كٌؽ ? طلدْ ردًزٌؤٍ‪ ،‬و‪ θ‬طلدْ ردًُخيًدن‪.‬‬

‫خملظًًن خألوي ٌنؼٍ ضىَش خًًهٍ وخًظٍ ًـس ؤن طوىن ردًطًٌص خًؼندثٌص )‪ًًٍ ،(binary image‬ى‬
‫نؿزم خًظهظٌس ؤو نٔظوًَ موظشف كىخف هدين ًٌلطىي نىل ضىَش ػندثٌص وًٌى كزٍ طؿزٌم‬
‫طلىًٍ هدف‪.‬‬

‫ػدين وػدًؽ مظًًن هٌل ? و‪ θ‬نىل خًرتطٌس‪َ .‬خرو مظًًن هى خًهظزص‪ ،‬وخًظٍ طهنٍ ؤكٍ ضىض ًـس ؤن‬
‫نلطٍ نٌٌه ًنهظربه هـ‪ .‬طٍهُ نًي خألضىخض ًهظمً نىل نًي خًنلدؽ نىل خًوـ‪ ،‬وهٍخ ًهنٍ ؤضًُ‬
‫ؾىي ًٌوـ خًٍي ًـس خهظشدفه‪.‬‬
166 ‫ ببساطة‬OpenCv

:1‫مصبل‬
import cv2
import numpy as np

img = cv2.imread('dave.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,50,150,apertureSize = 3)

lines = cv2.HoughLines(edges,1,np.pi/180,200)
for rho,theta in lines[0]:
a = np.cos(theta)
b = np.sin(theta)
x0 = a*rho
y0 = b*rho
x1 = int(x0 + 1000*(-b))
y1 = int(y0 + 1000*(a))
x2 = int(x0 - 1000*(-b))
y2 = int(y0 - 1000*(a))

cv2.line(img,(x1,y1),(x2,y2),(0,0,255),2)

cv2.imshow('Cany',edges)
cv2.imshow('res',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
ُ
ُ :‫امنرٌعخ‬
‫ذ‬ ‫ذ‬
167 ‫ ببساطة‬OpenCv

ُ :2‫مصبل‬

import cv2
import numpy as np

img = cv2.imread('car2.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,50,500,apertureSize = 3)

lines = cv2.HoughLines(edges,1,np.pi/180,120)
for rho,theta in lines[0]:
a = np.cos(theta)
b = np.sin(theta)
x0 = a*rho
y0 = b*rho
x1 = int(x0 + 1000*(-b))
y1 = int(y0 + 1000*(a))
x2 = int(x0 - 1000*(-b))
y2 = int(y0 - 1000*(a))

cv2.line(img,(x1,y1),(x2,y2),(0,0,255),1)

cv2.imshow('Binary Image',edges)
cv2.imshow('res',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

‫ذ‬

ُ :‫امنرٌعخ‬

ُ ُ
‫‪168‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬ذؽىًهُهبفُاالؼرٌليلُ‪ُ :Probabilistic Hough Transform‬‬
‫يف طلىًٍ هدف خًٔدرم الككند رإنه الهظشدف مٔظلٌم رزدَخمرتًن ؤنـّند خًوؼًن من خًلٔدردض‪ ،‬نىل‬
‫هٍ كدي هندن طلٍٔن ًهٍه خًظلنٌص وًظم ًٌى رإهٍ نلدؽ نشىخثٌص رًي ؤهٍ خًنلدؽ هٌهد‪ ،‬وهٍخ ًن‬
‫ًاػُ نىل خًنظٌـص‪ ،‬فوٍ مد نٌٌند هى طوفٌؼ كٌمص خًهظزص‪.‬‬

‫شدهً ًٌطىَش خًظدًٌص خًظٍ طلدَن رٍن طلىًٍ هدف وطلىًٍ هدف خالكظٌليل‪.‬‬
‫خًطىش مإهىٌش من هٍخ خملىكو ‪Image Courtesy: Franck Bettinger’s home page‬‬

‫ذ‬ ‫‪.‬‬
‫خٓظوًخَ موظزص ‪ OpenCv‬يف خهظشدف خًوؿىؽ ًهظمً نىل كىش خًوؿىؽ خملوظشفص ًًٍى‬
‫ٓنٔظهمٍ طلىًٍ هدف خالكظٌليل خملظًَؾ‪.‬‬
169 ‫ ببساطة‬OpenCv

‫ ٌنٌى هٍخ خًظدرو مظًًنًٍن‬.‫ الهظشدف خًوؿىؽ خًلىًص‬cv2.HoughLinesP() ‫ٓنٔظهمٍ خًظدرو‬
:‫هٌل‬
.‫ وًُفؼ هٍ هـ يون هٍه خًلٌمص‬، ‫ ؤكٍ ؾىي ًٌوـ‬:minLineLength 
.ً ‫ خملٔدفص خألنكمٌص خملٔمىكص رٍن ؤؿّخء خًوـ النظزدَه هؿدً وخكًخ‬:maxLineGap 

‫ ؤمد يف خًلدًص‬،‫وؤفػٍ يشء يف هٍخ خًظدرو رإنه ًهًٌ ًند رشوٍ مزدٌس نلؿص رًخًص خًوـ ونلؿص نهدًظه‬
‫ ؤمد خآلن‬.‫ وهدن هندن ضهىرص يف بًـدي هٍ خًنلدؽ‬،‫خًٔدرلص كطٌند فلـ نىل ردَمرتخض خًوؿىؽ‬
.‫ؤضزم رةمودنند ؤن نلطٍ نىل هٍه خًنلدؽ رٔهىًص‬
import cv2
import numpy as np

img = cv2.imread('dave.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,50,150,apertureSize = 3)

minLineLength = 100
maxLineGap = 10
lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap)

for x1,y1,x2,y2 in lines[0]:
cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)
cv2.imshow('Binary Image',edges)
cv2.imshow('res',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬

ُ :‫امنرٌعخ‬
ُ ُ
170 ‫ ببساطة‬OpenCv

ُ :2‫مصبل‬
import cv2
import numpy as np

img = cv2.imread('car2.jpg')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,50,150,apertureSize = 3)

minLineLength = 100
maxLineGap = 10
lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap)

for x1,y1,x2,y2 in lines[0]:
cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)

cv2.imshow('Binary Image',edges)
cv2.imshow('res',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
ُ

ُ

‫ ذ‬:‫ؿراجعذإضاػقة‬

Hough Transform on Wikipedia 

‫ذ‬
‫‪171‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذؽىًهُهبفُمنذائشحُ‪Hough Circle Transform‬‬

‫ٓنظهٌم خٓظوًخَ طلىًٍ هدف ًإلًـدي خًًوخثُ يف خًطىَش‪.‬‬
‫ٓنظهٌم خٓظوًخَ خًظدرو‪. cv2.HoughCircles():‬‬

‫هدًظديل‬ ‫متؼٍ ًَدغٌد‬ ‫خًًخثُش‬
‫هٌل مُهّ خًًخثُش‪ ،‬و ‪r‬هى نطف كؿُ خًًخثُش‪.‬‬ ‫‪(,‬‬ ‫كٌؽ )‬

‫نالكل وؿىي ػالغ ردَخمرتخض ًًٍى ٓنلظدؾ ملُخهم ػاليث خًزهً ‪ 3D‬إلؿُخء طلىًٍ هدف‪ ،‬وًون هٍخ‬
‫خألمُ ًن ًوىن فهدي رشوٍ ؿًٌ‪ًًٍ ،‬ى موظزص ‪OpenCV‬طٔظوًَ ؾًُلص هدف ًٌظًَؾ ( ‪Hough‬‬

‫‪ ،)Gradient Method‬وخًظٍ طهظمً نىل طًَؾ خًلىخف (ًِديش خًلىخف)‪.‬‬

‫)]]]]]‪cv2.HoughCircles(image, method, dp, minDist[, circles[, param1[, param2[, minRadius[, maxRadius‬‬

‫خًظدرو خًٍي ٓنٔظوًمه هند هى )(‪ .cv2.HoughCircles‬مظًًنخطه هٍ‪:‬‬
‫‪ :Image‬ضىَش خًًهٍ‪ً .‬ـس ؤن طوىن خًطىَش يف خملٔظىي خًُمديي‪.‬‬
‫‪ :Method‬ؾًُلص خملٔظوًمص الهظشدف خًًوخثُ خًظٍ يف خًطىَش ‪ ،‬كدًٌد ٓنظٔظهمٍ خًؿًُلص‬
‫‪.cv2.HOUGH_GRADIENT‬‬
‫‪ :dp‬هٍخ خًزدَخمرت ٌنؼٍ نٔزص خًهوٕ وًاػُ نىل كُخَ خملُخهم رظلًًً يكص خًطىَش‪ .‬فةٌخ هدن ‪dp=1‬‬
‫فٌٔلًي خملُخهم يكص خًطىَش هٌل يف ضىَش خًًهٍ‪ ،‬ؤمد بٌخ هدن ‪ dp=2‬فٌٔلًي خملُخهم يكص‬
‫خًطىَش رنطف كـم خًطىَش خألضٌٌص‪.‬‬
‫‪ :minDist‬ؤكٍ مٔدفص مٔمىكص رٍن مُهّ خًًخثُش خملوظشفص‪ .‬بٌخ هدنع كٌمص هٍخ خًزدَمرت ضًًنش‬
‫ؿًخ ٓظالكل رإن هندن يوخثُ هؼًنش رـىخَ رهػهد‪ .‬وبٌخ هدنع خملٔدفص هزًنش ؿًخ ً ٓظالكل خهظفدء‬
‫رهؼ خًًوخثُ‪.‬‬
‫‪ :circle_storage‬يف ًًص خي ‪ٌ C‬نؼٍ طدرو ٌخهُش خًظوًّن خًظٍ ٌٓوّن ٌٌٓٔص خًًوخثُ خملوظشفص‬
‫(ال ًهمند)‬
172 ‫ ببساطة‬OpenCv

‫ ومبد ؤنند ٓنوظدَ ؾًُلص‬.‫ خًزدَمرت خًؼدين ًلًي وقٌفص هٍخ خًزدَمرت‬:param1
‫ فهٍخ خًزدَمرت ٌٓمؼٍ ؤنىل كٌمص ًٌهظزص يف موظشف خًلىخف‬.CV_HOUGH_GRADIENT
.‫ ؤمد ؤضًُ كٌمص ًٌهظزص ٓظوىن ؤضًُ مبُطٍن من كٌمص خًهظزص خًهٌٌد‬،‫هدين‬

‫ ومبد ؤنند ٓنوظدَ ؾًُلص‬.‫ خًزدَمرت خًؼدين ًلًي وقٌفص هٍخ خًزدَمرت‬:param2
‫ بٌخ خهرتند ؤضًُ كٌمص‬.‫ فهٍخ خًزدَمرت ًلًي كٌمص نظزص خملُخهم‬.CV_HOUGH_GRADIENT
‫ وبٌخ خهرتند‬.)‫ًٌهظزص ٓنلطٍ نىل ؤهرب نًي من خًًوخثُ خملوظشفص (مبد يف ًٌى خًًوخثُ خًودٌرص‬
.‫ؤهرب كٌمص ًٌهظزص ٓنلطٍ نىل ؤهرب خكظٌلي ألن طوىن فهالً يخثُش موظشفص‬
.‫ ؤضًُ كٌدْ ًنطف كؿُ خًًخثُش‬:minRadius
.‫ ؤهرب كٌدْ ًنطف كؿُ خًًخثُش‬:maxRadius

‫ ذ‬:‫امكىد‬

import cv2
import numpy as np

img = cv2.imread('OpenCV_Logo.png',0)
img = cv2.medianBlur(img,5)
cimg = cv2.cvtColor(img,cv2.COLOR_GRAY2BGR)

circles = cv2.HoughCircles(img,cv2.cv.CV_HOUGH_GRADIENT,1,20,
param1=50,param2=30,minRadius=0,maxRadius=0)

circles = np.uint16(np.around(circles))

for i in circles[0,:]:
# draw the outer circle
cv2.circle(cimg,(i[0],i[1]),i[2],(0,255,0),2)
# draw the center of the circle
cv2.circle(cimg,(i[0],i[1]),2,(0,0,255),3)

cv2.imshow('detected circles',cimg)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬
‫‪173‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ :‬ذ‬

‫ذ‬

‫مالككص‪ :‬يف موظزص ‪ OpenCv‬خإلضًخَ ‪ 4‬كم رظمًُُ خملظًًن خًؼدين ًٌظدرو ردًشوٍ ‪ cv2.cv.CV_HOUGH‬ؤَ بٌخ‬
‫هدن بضًخَ موظزص ‪ OpenCv‬خًٍي طٔظهمٌه هى خإلضًخَ ‪ 4‬فلم رظمًُُ خملظًًن خًؼدين ردًشوٍ‬
‫‪.cv2.HOUGH_GRADIENT‬‬
‫ذ‬

‫مالككص‪ :‬مَُند ًٌظدرو ‪ cv2.HoughCircles‬خًزدَمرتًن ‪ minRadius‬و ‪maxRadius‬رلٌمظٍن ‪ ،0,0‬وهٍخ‬
‫ًهنٍ رإن ًإهٍ هٍ خًًوخثُ ٓىخء هدنع ضًًنش ؤَ هزًنش‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪174‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذعضئخُامصىسحُتبظرخذاوُخىاسصمٌخُ‪Watershed‬‬

‫ذ‬

‫امهذف‪ُ :‬‬
‫طهٌم طلٌٔم خًطىَش رؿًُلص خًظـمهدض خملدثٌص)‪.(Watershed‬‬
‫طهٌم خٓظوًخَ خًظدرو )(‪.cv2.watershed‬‬
‫ملذمخُنظشًخ‪ُ :‬‬
‫هىخَِمٌص‪ watershed‬هٍ هىخَِمٌص طلًًٌٌص طٔظوًَ ًظـّثص خًطىَش ألكٔدَ وطفًٌند هٍه‬
‫خًوىخَِمٌص ننً خٓظوُخؾ خألؿٔدَ خملظالمٔص ؤو خملظًخهٌص فٌٌل رٌنهد هدًلؿو ًنلًًص يف خًطىَش‬
‫خًظٍ يف خألنىل‪.‬‬
‫ٌنونند متؼٌٍ ؤي ضىَش َمديًص رشوٍ ٓؿم ؾىرىيُخيف رلٌؽ خًشًخض خًٌىنٌص خًهدًٌص متؼٍ خًلمم‬
‫وخًظالي وخًشًخض خًٌىنٌص خملنوفػص متؼٍ خًىيًدن‪ٓ .‬نزًؤ مبٍء هٍ خًىيًدن خملنهًّص (خًلٌمص‬
‫خًطًُي خمللٌٌص) ردملدء وهٍ ويخي رٌىن ممٌّ نن خألهُ (خًىٓم)‪ٓ .‬رتطفو خملٌده خنظٌليخ نىل‬
‫خَطفدم خًلمم (خًظًَؿدض خًٌىنٌص) خمللٌؿص ردًىيًدن وٓظزًؤ خملٌده خملٌىنص رإًىخن موظٌفص ردالهظالؽ‬
‫مو رهػهد‪ ،‬وًظـنس هٍخ خألمُ ٓنزنٍ كىخؿّ ننً خألمدهن خًظٍ ًظم فٌهد خالهظالؽ‪ .‬ونٔظمُ رطس‬
‫خملدء ورندء خًلىخؿّ كظى يمُ هٍ خًلمم ردملدء‪ ،‬وننًهد فةن خًلىخؿّ خًظٍ طم رندءهد ٓظهؿٌند‬
‫نظٌـص خًظلؿٌو وهٍخ هى خمللطىي روٌمص ‪( watershed‬مـمهدض خملٌده)‪ً .‬ظفهم هٌف ًظم هٍخ‬
‫خألمُ رشوٍ ؤوغم ٌنونى ًِدَش ضفلص خًىًس ‪ CMM webpage on watershed‬خًظٍ طلىي نىل َٓىَ‬
‫مظلُهص وطىغٌلٌص‪.‬‬
‫‪175‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًهمٌٌص خًٔدرلص كً طهؿٌند طلؿٌهد مفُؾد رٔزس وؿىي غـٌف يف خًطىَش‪ًًٍ ،‬ى وفُض ‪OpenCv‬‬
‫ًٌمٔظوًَ رإن ًلًي خملندؾم خًظٍ ًًًُ يمـهد وخملندؾم خًظٍ ال ًًًُ يمـهد‪ .‬وهٍخ هى طلؿٌو‬
‫خًطىَش خًظفدنًل‪ ،‬كٌؽ نلًي خملندؾم خًظٍ طشوٍ خًـٔم خألمدمٍ رٌىن وكً‪ ،‬ػم نلًي خملندؾم‬
‫خًظٍ طشوٍ هٌفٌص خًـٔم خألهًٌش رٌىن موظٌف‪ ،‬ؤمد خملندؾم خًظٍ مل نظإهً منهد فنلًيهد رلٌمظهد‬
‫ومن ػم نؿزم خًوىخَِمٌص‪ ،‬رهً خًظؿزٌم ٓرني خًلًوي ٓظظلًغ‪ ،‬ويف خًنهدًص ٓظلًي كًوي‬
‫خًـٔم وٓظإهٍ خًلٌمص ‪. -1‬‬
‫ُامكىد‪ُ :‬‬
‫يف خملؼدي خًظديل ٓنشدهً هٌف ٓنٔظوًَ طلىًٍ خملٔدفص مو هىخَِمٌص ‪ً watershed‬ظلؿٌو‬
‫(ًظـّثص) خألؿٔدَ خملظالمٔص‪ًٌ .‬ون ًًًند خًطىَش خًظدًٌص ًٌنلىي‪ ،‬هٍ كؿهص نلًًص مظالمٔص مو‬
‫خألهُي‪ ،‬وبٌخ ؾزلند خًظهظٌس ٓظزلى هٌل هٍ مظالمٔص‪.‬‬

‫ذ‬

‫ٓنزًؤ رةًـدي خًلًوي خًظلًُزٌص ًٌنلىي وًٌى ردٓظوًخَ طهظٌس ؤوطٔى‪.‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬

‫)'‪img = cv2.imread('coins.png‬‬
‫)‪gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY‬‬
‫= ‪ret, thresh‬‬
‫)‪cv2.threshold(gray,0,255,cv2.THRESH_BINARY_INV+cv2.THRESH_OTSU‬‬
‫ذ‬
‫‪176‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ :‬‬

‫ذ‬

‫خآلن ٓنلظدؾ إلِخًص ؤي غـٌف ردًٌىن خألرٌؼ يف خًطىَش‪ًًٍ ،‬ى ٓنلىَ رظؿزٌم نمٌٌص خًفظم نىل‬
‫خًشوٍ خًٔدرم‪ ،‬وإلِخًص خًؼلىذ خًٔىيخء خًطًًنش يف خألؿٔدَ نلىَ رهمٌٌص خإليالق‪.‬وخآلن نلن‬
‫مظإهًًن رإن خملندؾم خًلًُزص من مُهّ خًـٔم هٍ مندؾم ؤمدمٌص‪ ،‬وخملندؾم خًزهًٌش نن خًـٔم‬
‫هٍ خًوٌفٌص‪.‬‬

‫خملندؾم خًىكًٌش خًظٍ ًٔند مظإهًًن منهد هٍ هٍ ؤمدمٌص ؤَ هٌفٌص هٍ منؿلص كًوي خًهمٌص‪.‬‬
‫ًًٍى نلظدؾ الٓظوُخؾ خملندؾم خملظإهًًن نىل ؤنهد كؿهص خًنلىي (متؼٍ خملنؿلص خألمدمٌص)‪،‬‬
‫ٓنٔظهمٍ نمٌٌص خًلع ‪ Erosion‬إلِخًص خًزٌؤالض خمللٌؿص رلؿهص خًنلىي وٌٓوىن هٍخ خخألمُ‬
‫مفًٌ ؿًخً يف كدي هدنع خًلؿو ال متٕ رهػهد‪ ،‬ؤمد يف كدي خًلؿو متٕ رهػهد فٔنلظدؾ ًهمٍ‬
‫طلىًٍ ًٌمٔدفص ػم نؿزم نظزص مندٓزص‪.‬‬

‫رهً ًٌى نٌٌند بًـدي منؿلص خًوٌفٌص خألهًٌش‪ًًٍ ،‬ى ٓنلىَ رهمٌٌص خًظمًًً ‪ًٌ dilate‬نظٌـص‪،‬‬
‫ورهٍخ ٌنونند خًظإهً من ؤن خملنؿلص خًظٍ يف خًوٌفٌص هٍ هٍ هٌفٌص ؤهًٌش ؤَ ال‪ ،‬ألن منؿلص‬
‫خًلًوي مّخًص رٍن خًـٔم وخًوٌفٌص‪ .‬شدهً خًطىَش خًظدًٌص خًظٍ طىغم خألمًُن خًٔدرلٍن‪.‬‬
177 ‫ ببساطة‬OpenCv

‫ذ‬

‫خملندؾم خملظزلٌص خًظٍ ال نهُف هٍ هٍ ؿٔم ؤَ هٌفٌص (هٍ خملندؾم خًظٍ طٌظلٍ رهد خًلؿو خًنلًًص‬
‫ ًنزًٍ ؤن طوىن كديَش نىل‬watershed ‫ هىخَِمٌص‬،)‫وخًوٌفٌص ؤو كظى خًلؿو خًنلًًص مو رهػهد‬
.‫بًـديهد‬
‫ وٌنون مهُفظهد من هالي ؾُق خًوٌفٌص خألهًٌش من خألمدمٌص‬،‫نًنى هٍه خملندؾم خملظزلٌص ردًلًوي‬
.‫خألهًٌش‬
# noise removal
kernel = np.ones((3,3),np.uint8)
opening = cv2.morphologyEx(thresh,cv2.MORPH_OPEN,kernel, iterations = 2)

# sure background area
sure_bg = cv2.dilate(opening,kernel,iterations=3)

# Finding sure foreground area
dist_transform = cv2.distanceTransform(opening,cv2.cv.CV_DIST_L2,5)
ret, sure_fg = cv2.threshold(dist_transform,0.7*dist_transform.max(),255,0)

# Finding unknown region
sure_fg = np.uint8(img)
unknown = cv2.subtract(sure_bg,sure_fg)
‫ذ‬

‫ رًي ؤن متَُ ًهٍخ خًظدرو‬4 َ‫ خإلضًخ‬OpenCv ‫ غمن موظزص‬distanceTransform() ‫ يف خًظدرو‬:‫مالككص‬
.cv2.DIST_L2 ‫ كم رظمًُُ خملظًًن‬cv2.cv.CV_DIST_L2 ‫خملظًزًن‬
‫‪178‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ ُ:‬‬
‫ورظهظٌس خًطىَش نلطٍ نىل مندؾم خًلؿو خًنلًًص وخًظٍ مظإهًًن من ؤنهد كؿو نلًًص وًظم فطٍ‬
‫خًل ؿو خًنلًًص نن رهؼ (يف رهؼ خألكٌدن كً طوىن مهظم فلـ ردٓظوُخؾ خًـّء خألمدمٍ يون فطٍ‬
‫خألؿٔدَ نن رهػهد‪ .‬يف هٍه خًلدًص ال طلظدؾ ألن طٔظهمٍ خًظلىًٍ خملٔديف‪ ،‬فلـ مد طلظدؿه هى‬
‫خٓظوًخَ نمٌٌص خًلع ‪ Erosion‬الٓظوُخؾ خملنؿلص خألمدمٌص خألهًٌش)‪.‬‬

‫ذ‬ ‫ذ‬

‫خألن ؤضزلند مظإهًًن من مندؾم خًلؿو خًنلًًص وخًوٌفٌص‪ًًٍ .‬ى ٓننشإ نالمص ‪( Maker‬مطفىفص‬
‫رنفٕ كـم خًطىَش خألضٌٌص وًون رنىم رٌدندض ‪ )int32‬ونىٓم خملندؾم يخهٌهد‪.‬خملندؾم (خألمدمٌص ؤو‬
‫خًوٌفٌص) خملظإهًًن منهد نلًيهد رإي نًي ضلٌم مىؿس‪ ،‬وًون رإَكدَ موظٌفص ًوٍ ؿٔم‪.‬‬
‫وخملندؾم خًظٍ ًٔند مظإهًًن منهد نًم كٌمظهد ضفُ‪.‬‬

‫وًًٍى ٓنٔظوًَ خًظدرو )(‪ cv2.connectedComponents‬وخًٍي ًلًي هٌفٌص خًطىَش ردًلٌمص‬
‫ضفُ‪ ،‬وخألؿٔدَ خألهُي ًلًيهد رإنًخي ضلٌلص خرظًخ ًء من ‪.1‬وًون بٌخ هدنع كٌمص خًوٌفٌص ‪0‬‬
‫ٓظهظربهد هىخَِمٌص ‪ watershed‬يًن مهٌىمص‪ًًٍ ،‬ى رًالً من ًٌى ٓنلًي خملندؾم يًن خملهٌىمص‬
‫رـ ‪.0‬‬
‫‪179‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪# Marker labelling‬‬
‫)‪ret, markers = cv2.connectedComponents(sure_fg‬‬

‫‪# Add one to all labels so that sure background is not 0, but 1‬‬
‫‪markers = markers+1‬‬

‫‪# Now, mark the ' of unknown with zero‬‬
‫‪markers[unknown==255] = 0‬‬
‫ذ‬

‫امنرٌعخ‪ُ :‬‬
‫خًطىَش خًظدًٌص طزٍن خًنظٌـص خًظٍ طهُع هًُؿص خألًىخن ‪ ،JET‬كٌؽ خألَِق خًًدمم ًهُع خملندؾم‬
‫خًًًن مهٌىمص(خملـهىًص)‪ ،‬وخًلؿو خًنلًًص خملظإهًًن منهد طٌىن رإًىخن موظٌفص (كٌم موظٌفص)‪ً ،‬ظم‬
‫نُع خملندؾم خملظزلٌص وخًظٍ هٍ هٌفٌدض ؤهًٌش رٌىن ؤَِق ؤفظم ردًنٔزص ًٌمندؾم خملـهىًص‪.‬‬

‫ذ‬

‫خآلن ًًًند نالمص ‪Maker‬ؿدهّش‪ ،‬وكدن خًىكع ًظنفٌٍ خًوؿىش خًنهدثٌص وطؿزٌم هىخَِمٌص‬
‫‪ ،watershed‬ننًهد ضىَش خًهالمص ‪ٓ Maker‬ظظهًي‪ ،‬وخملنؿلص خًلًويًص ٓظإهٍ خًلٌمص ‪. -1‬‬

‫)‪markers = cv2.watershed(img,markers‬‬
‫]‪img[markers == -1] = [255,0,0‬‬
‫ذ‬

‫ذ‬
‫‪180‬‬ ‫‪ OpenCv‬ببساطة‬

‫الكل خًنظٌـص ٓرتي ؤن رهؼ خًلؿو طم طلؿٌههد رشوٍ مؼديل وؤهُي ًٌٔع هًٍى‪.‬‬

‫ذ‬

‫ذ‬

‫ذ‬

‫مُخؿو بغدفٌص‪:‬‬

‫‪ً( CMM page on Watershed Transformation‬لىي هٍ خملُؿو نىل ضىَ مظلُهص مو‬
‫خًهًًً من خألمؼٌص خًظٍ طزٔـ ًٍسق)‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪181‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫ذ‬
‫ذ‬
‫امهذف‪ُ :‬‬
‫طهٌم هىخَِمٌص ‪GrabCut‬الٓظوُخؾ خألؿٔدَ خألمدمٌص يف خًطىَش‪.‬‬
‫ٓننشح طؿزٌم طفدنًل ردٓظوًخمهد‬
‫ذ‬
‫امنظشي‪ُ :‬‬
‫خًهًف من هىخَِمٌص ‪ GrabCut‬خٓظوُخؾ خألؿٔدَ خألمدمٌص خًظٍ يف خًطىَش رإكٍ طفدنٍ من‬
‫خملٔظوًَ‪.‬هٌف ًلىَ خملٔظوًَ رظنفٌٍ هٍه خًوىخَِمٌص؟‬

‫يف خًزًخًص ًُٓم خملٔظوًَ مٔظؿٌٍ كىي خملنؿلص خألمدمٌص (ًنزًٍ ؤن طوىن خملنؿلص خألمدمٌص‬
‫(خًـٔم) متدمد يخهٍ خملٔظؿٌٍ)‪ ،‬ومن ػم ًلىَ رظوُخَ طؿزٌم خًوىخَِمٌص كظى خًىضىي ألفػٍ‬
‫نظٌـص‪.‬‬
‫ًون يف رهؼ خألكٌدن كً ال نلطٍ نىل خًنظٌـص خملُيىرص رٔزس خألهؿدء خًلدضٌص ننً طهٌٌم‬
‫خًوٌفٌص هإمدمٌص‪ ،‬ؤو ردًهوٕ‪ٓ.‬نلظدؾ يف هٍه خًلدًص إلنديش طهٌٌم ًٌنظٌـص‪ ،‬مؼٍ خًظلًًً ًًوًد‬
‫رٍصردض (خًظلًًً روزٔص خًفإَش) طلًي ؤمدهن خألهؿدء يف خًطىَش خًندطـص‪ًًٍ ،‬ى رهً خًلٌدَ رهٍه‬
‫خًهمٌٌص نلطٍ نىل نظٌـص ؤيق‪.‬‬

‫شدهً خملؼدي خًظديل خًٍي ٓنلىَ فٌه ؤوال رُٓم مٔظؿٌٍ كىي خًـٔم‪ ،‬ومن ػم نلىَ رةغدفص‬
‫خًٌمٔدض خألهًنش نن ؾًُم ٌصردض خًفإَش‪ .‬كٌؽ خًٍصردض ردًٌىن خألرٌؼ ًظلًًً خملنؿلص‬
‫خألمدمٌص‪ ،‬وخًٍصردض خًظٍ ردًٌىن ألٓىي ًظلًًً خًوٌفٌص‪ ،‬ومن ػم ٓنلطٍ نىل نظٌـص ؿًٌش‪.‬‬
‫‪182‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬ ‫ذ‬
‫ذ‬
‫ومكنُمبُامزيُؼهُتبمخنفٌخ؟ ُ‬
‫َّ‬
‫ؤوالً ًُٓم خملٔظوًَ مٔظؿٌٍ وهٍ يشء هدَؿه ًهً هٌفٌص ؤهًٌش‪ًًٍ ،‬ى ًـس طػمٍن‬ ‫‪‬‬
‫خًـٔم هدمال يخهٍ خملٔظؿٌٍ‪ .‬هٍ يشء يهٍ خملٔظؿٌٍ يًن مهُوف فلٔس خًزٌدندض‬
‫خًظٍ ًًهٌهد خملٔظوًَ ًظم طهٌٍن خملنؿلص خألمدمٌص وخًوٌفٌص‪.‬‬
‫ًلىَ خًلدٓىذ رهً ًٌى رةنؿدء نالمدض ردالنظٌلي نىل خًزٌدندض خملهؿدش‪ ،‬رلٌؽ ًلىَ‬ ‫‪‬‬
‫رظلًًً خملنؿلص خًوٌفٌص من خألمدمٌص‪.‬‬
‫كدًٌد ٓنٔظوًَ منـ خًوالثـ خًًإويس )‪ً (GMM‬ظلًًً منـ (شوٍ) خملنؿلص خًوٌفٌص‬ ‫‪‬‬
‫وخألمدمٌص‪.‬‬
‫خنظٌلي خ نىل خًزٌدندض خملهؿدش ًظهٌم ‪ GMM‬وًنشإ طىِند ؿًًًخ ًٌزٌؤالض‪ ،‬كٌؽ ططنف‬ ‫‪‬‬
‫خًزٌؤالض خًًًن مهُفص بمد همنؿلص ؤمدمٌص ملظمٌص ؤو هٌفٌص ملظمٌص وًٌى ردالنظٌلي نىل‬
‫نالكظهد مو خًزٌؤالض خملهُفص رًالًص بكطدثٌدض خألًىخن (مؼٍ خًظـمٌو رهندكًٌ)‪.‬‬
‫ًظم رندء خًُٓم خًزٌدين من طىِم خًزٌؤالض هٍخ‪ .‬طظمؼٍ خًهلًش ردًزٌؤٍ‪ .‬طػدف نلًطٍن‬ ‫‪‬‬
‫بغدفٌص وهٌل نلًش خملطًَ ونلًش خملرصف‪ .‬هٍ رٌؤٍ ؤمدمٍ ًظطٍ رهلًش خملطًَ وهٍ‬
‫رٌؤٍ هٌفٍ ًظطٍ رهلًش خملرصف‪.‬‬
‫وِن(كٌمص) خًلىخف خًظٍ طظطٍ رهلًش خملنزو ‪/‬خملرصف طهؿٍ خكظٌلًٌص ؤن ًوىن خًزٌؤٍ‬ ‫‪‬‬
‫ًنظمٍ ًٌمنؿلص خألمدمٌص ‪ /‬خًوٌفٌص‪ .‬طلًي خألوِخن رٍن خًزٌؤالض مبهٌىمدض خًلدفص ؤو‬
‫طشدره خًزٌؤٍ‪ ،‬فةٌخ هدن هندن فُق هزًن رإًىخن خًزٌؤالض خملرتخرؿص فدًلدفص رٌنهم‬
‫ٓظؤس وِندً ؤهف‪.‬‬
‫‪183‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬هىخَِمٌص ‪mincut‬طٔظهمٍ ًظلؿٌو خًُٓم خًزٌدين‪ ،‬كٌؽ طلؿهه ًهلًيت منزو ومرصف‬
‫رإكٍ طدرو طوٌفص‪ .‬وطدرو خًظوٌفص هى مـمىم هٍ ؤوِخن خًلىخف خمللؿىنص‪ ،‬ورهً خًلؿو‪ ،‬هٍ‬
‫خًزٌؤالض خملظطٌص رهلًش خملطًَ ططزم ؤمدمٌص‪ ،‬وخملظطٌص رهلًش خملرصف ططزم هٌفٌص‪.‬‬
‫‪ ‬طٔظمُ خًهمٌٌص كظى ًظلدَذ خًظطنٌف‪.‬‬

‫خًطىَش خًظدًٌص طىغم هٍه خًهمٌٌص‪.‬‬

‫ذ‬

‫مصبلُذىطٌؽٍ‪ُ :‬‬
‫ُ‬
‫ًظؿزٌم هىخَِمٌص ‪ GrabCut‬يف ‪ OpenCv‬نٔظوًَ خًظدرو)(‪ ، cv2.grabCut‬ومظًًنخض هٍخ خًظدرو‬
‫هٍ‪:‬‬
‫‪ :img ‬ضىَش خًًهٍ‬
‫‪ :mask ‬كندم خًطىَش وخًٍي ًلًي خملندؾم خألمدمٌص وخًوٌفٌص ؤو خكظٌلًٌظهد (ؤي خكظٌلي هٍ‬
‫هٍ خمدمٌص خَ هٌفٌص) ‪ ،‬وًظم ًٌى نن ؾًُم خألنالَ (‪ )flags‬خًظدًٌص‪:‬‬
‫‪cv2.GC_PR_FGD cv2.GC_BGD, cv2.GC_FGD, cv2.GC_PR_BGD, ‬‬
‫‪ ‬ؤو رزٔدؾص منَُ خألَكدَ خًظدًٌص ‪ 0,1,2,3‬ردًرتطٌس‪.‬‬
‫‪184‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ :rect‬وهٍ بكًخػٌدض خملٔظؿٌٍ خًٍي ًظػمن خًـٔم خألمدمٍ ردًطًٌص )‪.(x, y, w, h‬‬ ‫‪‬‬
‫‪ :bdgModel, fgdModel‬هٍ مطفىفدض طٔظوًمهد خًوىخَِمٌص يخهٌٌد ‪ٌ،‬نونى فلـ‬ ‫‪‬‬
‫متًُُ مطفىفص ضفًُص رطًٌص ‪ np.float64‬ورلـم )‪.(1.65‬‬
‫‪ :iterCount‬نًي خملُخض خًظٍ ًـس ؤن طوَُ خًوىخَِمٌص فٌهد‪.‬‬ ‫‪‬‬
‫‪ً :mode‬ـس ؤن طوىن ‪ cv2.GC_INIT_WITH_RECT‬ؤو‬ ‫‪‬‬
‫‪ cv2.GC_INIT_WITH_MASK‬ؤو وغو مُهزدً وخًٍي ًلًي مد بٌخ هدن ٌٓظم طلًًً‬
‫خًـٔم خالمدمٍ نن ؾًُم َٓم مٔظؿٌٍ ؤو نن ؾًُم ٌصردض (هزٔدض) ؤَِخَ خًفإَش‪.‬‬

‫يف خًزًخًص ٓنزًؤ رىغو خملٔظؿٌٍ‪ٓ ،‬نلمٍ خًطىَش‪ ،‬وننشإ كندم ًٌطىَش‪ ،‬وننشإ خملطفىفظٍن‬
‫‪ bdgModel‬و‪ ،fgdModel‬ػم منَُ ردَمرتخض خملٔظؿٌٍ (بكًخػٌدطه وؾىًه ونُغه)‪.‬نٔمم رظشًٌٍ‬
‫خًوىخَِمٌص ‪ 0‬مُخض‪.‬‬

‫خًنمـ ‪ً mode‬ـس ؤن ًوىن ‪ cv2.GC_INIT_WITH_RECT‬ألنند نٔظوًَ مٔظؿٌٍ‪.‬ػم نشًٍ‬
‫خًـ ‪ ،GrabCut‬ننً ًٌى ط ُ َه ًَي ضىَش خًلندم‪.‬‬

‫يف خًطىَش خًـًًًش خملهًًص ًٌلندم‪ ،‬خًزٌؤالض ٓىف طهٌم رإَرو ؤنالَ طًي نىل خًوٌفٌص ؤو‬
‫خمللًمص (هٌل يف خًٔدرم)‪.‬رهًهد نهًي خًلندم رلٌؽ ططزم خًزٌؤالض خًظٍ ؤَكدمهد ‪ 5‬و‪ 4‬هٌفٌص‬
‫ؤهًٌش (نػو فٌهم خًلٌمص ضفُ)‪ ،‬ؤمد خًزٌؤالض رإَكدَ ‪ 8‬و‪ 4‬طوىن ؤمدمٌص ؤهًٌش (نػو فٌهد خًلٌمص‬
‫‪(.8‬‬

‫خآلن ؤضزم ًًًند خًلندم خًنهديئ ؿدهّ‪ .‬هٍ مد نٌٌند ٌصره ردًطىَش خألضٌٌص ًنلطٍ نىل نظٌـص‬
‫خًظلؿٌو خملُيىرص‪.‬‬
185 ‫ ببساطة‬OpenCv

import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('deer.jpg')
mask = np.zeros(img.shape[:2],np.uint8)

bgdModel = np.zeros((1,65),np.float64)
fgdModel = np.zeros((1,65),np.float64)

rect = (50,50,450,290)
cv2.grabCut(img,mask,rect,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_RECT)

mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')
img = img*mask2[:,:,np.newaxis]

plt.imshow(img),plt.colorbar(),plt.show()

‫ذ‬

‫ذ‬
‫ذ‬
186 ‫ ببساطة‬OpenCv

‫الكل رإنه قهُ يف خًطىَش كٔم من خًوٌفٌص ال نًًُ بقهدَه ًًٍى ًـس نٌٌند خٓظوًخَ خًؿًُلص‬
‫خًؼدنٌص وخًظٍ طظم رظلًًً خًلندم نرب ؤيخش هدضص (هدملإوْ) رلٌؽ نلًي خألؿٔدَ خألهًٌش ردًٌىن‬
:‫خألرٌؼ وخًوٌفٌص خألهًٌش ردًٌىن خألٓىي ونوظس مد ًًل‬

# newmask is the mask image I manually labelled
newmask = cv2.imread('newmask.png',0)

# whereever it is marked white (sure foreground), change mask=1
# whereever it is marked black (sure background), change mask=0
mask[newmask == 0] = 0
mask[newmask == 255] = 1

mask, bgdModel, fgdModel =
cv2.grabCut(img,mask,None,bgdModel,fgdModel,5,cv2.GC_INIT_WITH_MASK)

mask = np.where((mask==2)|(mask==0),0,1).astype('uint8')
img = img*mask[:,:,np.newaxis]
plt.imshow(img),plt.colorbar(),plt.show()
‫ذ‬
‫ذ‬
‫ذ‬

‫ذ‬ ‫ذ‬
‫ذ‬
‫‪187‬‬ ‫‪ OpenCv‬ببساطة‬

‫ٌنونى طلمٌٍ هىي خٓظوُخؾ خًـٔم ألي ضىَش نن ؾًُم طلًًً خملنؿلص خألمدمٌص من خًوٌفٌص‬
‫رىخٓؿص ٌصردض خًفإَش من هالي خًُخرـ خًظديل‪:‬‬
‫‪ https://github.com/downingstreet/GrabCut/blob/master/grabcut.py‬ذ‬

‫هٍ مد نٌٌى خطزدم خًوؿىخض خًظٍ ًهُغهد خًوىي ننً طشًٌٌه‪.‬‬

‫ذ‬

‫ذ‬

‫الكل يف خًطىَش خًندطـص خًٔدرلص رإنه طم خهظفدء يوخًٌس خًٌٔدَش ًًٍى ٓنلىَ رهمٍ ٌصردض رَّ‬
‫خًفإَش ًظلًًً خًًوخًٌس هنؿلص ؤمدمٌص‪.‬‬
‫‪188‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫الكل خآلن هٌف قهُض يوخًٌس خًٌٔدَش يف خًطىَش‪.‬‬

‫ذ‬

‫ذ‬

‫ذ‬
‫الفصل الرابع‬

‫” الإبداع هو النظر في المألوف بطر يقة غير مألوفة ‟‬

‫أحمد الشقيري‬
‫‪190‬‬ ‫‪ OpenCv‬ببساطة‬

‫اؾػصلذاؾرابع‪:‬ذاإلراراتذيفذ‪ OpenCv‬ذ‬
‫ذ‬

‫امهذف‪ُ :‬‬
‫ُ‬
‫ذػنمُبًعبدُوسظمُمالمؾُامشكه‪.‬‬

‫ذػنمُبًعبدُمالمؾُمخرنخُمإلػبساد‪ُ،‬مصهُاملعبؼخ‪ُ،‬املؽٌؽ‪ُ،‬مؽٌؽُ‬
‫معرؼٌه‪.....ُ،‬امخ‬

‫ذػنمُبًعبدُخصبئصُاإلػبساد‪ُ،‬مصهُامصالتخُؤيُامكصبفخ‪ُ......ُ،‬‬

‫ذػنمُبًعبدُذشىهبدُامرؽذة‪ُ،‬نلؼخُمظنؼُاالخرثبس‪ُ،‬ذؼبتمُاألشكبلُ‬
‫املخرنفخ‬

‫امرػشفُغىلُامرذسطُامهشمٍُمإلػبساد‪.‬‬

‫ذ ذ‬
‫‪191‬‬ ‫‪ OpenCv‬ببساطة‬

‫امهذف‪ُ :‬‬
‫فهم مد هٍ خإلؾدَخض‪.‬‬
‫طهٌم بًـدي وَٓم خإلؾدَخض‪.‬‬
‫ٓنظهٌم خٓظوًخَ خًظىخرو‪. cv2.drawContours()،cv2.findContours() :‬‬
‫مبُهٍُاإلػبساد؟ ُ‬
‫ٌنون ٌسكهد رزٔدؾص رإنهد نزدَش نن منلنٌدض طػم هٍ خًنلدؽ خملظطٌص مو رهػهد (نىل ؾىي‬
‫خًلًوي)‪ ،‬وخًظٍ متٌى نفٕ خًٌىن ؤو خًشًش‪ ،‬وهٍه خإلؾدَخض هٍ ؤيوخض مفًٌش ًظلٌٌٍ خًشوٍ‪،‬‬
‫وخهظشدف خألؿٔدَ وخًظهُف نٌٌهد‪.‬‬
‫مالؼظبدُهبمخ‪ُ :‬‬
‫ًٌلطىي نىل ؤفػٍ نظٌـص خٓظوًَ خًطىَ خًؼندثٌص‪ًًٍ ،‬ى كزٍ ؤًـدي خإلؾدَخض ٓنٔظوًَ‬
‫نمٌٌص خًظهظٌس ؤو موظشف كىخف هدين‪.‬‬
‫طدرو بًـدي خًلىخف ًًًن خًطىَش خألضٌٌص‪ًًٍ ،‬ى بٌخ ؤَيض خًلفدف نىل خًطىَش كم رهمٍ‬
‫نٔوص خكظٌدؾٌص ًٌطىَش وهّنه يف مظًًن آهُ‪.‬‬
‫بًـدي خإلؾدَخض يف ‪ًOpenCv‬شزه بًـدي ؿٔم ؤرٌؼ من هٌفٌص ٓىيخء‪ًًٍ ،‬ى ًـس ؤن‬
‫ًوىن خًودثن خًٍي طزلؽ ننه ردًٌىن خألرٌؼ وخًوٌفٌص ًـس ؤن طوىن ٓىيخء (ال طنىس هٍخ‬
‫خألمُ)‪.‬‬
‫بٌخ هدنع خًطىَش خًؼندثٌص يًن وخغلص ٌنونى خالٓظهدنص ردًظلىًالض خًظٍ طظم نىل خًشوٍ‬
‫مؼٍ نمٌٌص خًظمًًً ‪.Dilation‬‬
192 ‫ ببساطة‬OpenCv

‫ينند نشدهً هٌف ٓنىؿً بؾدَخض (مالمم) ضىَش ػندثٌص يف خًوىي خًظديل خًٍي ٌٓىغم ًند ؾًُلص‬
:‫بًـدي خإلؾدَخض‬
import numpy as np
import cv2
im = cv2.imread('test.jpg')

imgray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(imgray,127,255,0)
# Get all the contours found in the thresholdimage
# syntax for opencv2
contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
# syntax for opencv3
#thresh ,contours, hierarchy = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)

ُ :‫رشػُامكىد‬
imgray = cv2.cvtColor(im,cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(imgray,127,255,0)
‫ذ‬

‫ٓنلىي خًطىَش ًٌىن خًُمديي ػم ٓنلىَ رظلىًٍ خًطىَش ًٌطًٌص خًؼندثٌص (ؤرٌؼ وؤٓىي) وًٌى نن‬
.‫ؾًُم خًظهظٌس‬
contours, hierarchy =
cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
‫ذ‬

.cv2.findcontours ‫نلىَ رهمٌٌص بًـدي خإلؾدَخض نن ؾًُم خًظدرو‬
:cv2.findcontours() ‫ٌسق خًظدرو‬
.)‫ خملظًًن خألوي ٌنؼٍ ضىَش خًًهٍ (ًـس ؤن طوىن ردًطًٌص خًؼندثٌص‬
.)‫ خملظًًن خًؼدين ٌنؼٍ منـ خٓرتيخي خإلؾدَ (ٓنٍسكه الكلد‬
.)‫ خملظًًن خًؼدًؽ هى طلًُس خإلؾدَ (ٓنٍسكه الكلد‬
.hierarchy ٍ‫ وطٌٍٔٔ خإلؾدَخض خًهُم‬contours ‫وكٌم خًوُؾ خًظٍ ًهًٌهد خًظدرو هٍ خإلؾدَخض‬
Numpy ‫ وهٍ بؾدَ مفُي هى نزدَش نن مطفىفص‬،‫خإلؾدَخض خملوظشفص طوىن نىل شوٍ كدمئص ردًؼىن‬
.‫إلكًخػٌدض نلدؽ كًوي خًـٔم‬
193 ‫ ببساطة‬OpenCv

ُ ‫كٌفُذشذعمُاإلػبساد؟‬
‫ وٌنونند ؤن طٔظوًَ هٍخ خًظدرو ًُٓم ؤي‬.cv2.drawContours ‫ًُٓم خإلؾدَخض نٔظوًَ خًظدرو‬
.‫شوٍ ًًًند نلدؾه خمللٌؿص‬
ُ :cv2.drawContoursُ‫رشػُامربتؼ‬
.ٍ‫ خملظًًن خألوي هى ضىَش خًًه‬
.‫ خملظًًن خًؼدين هى خإلؾدَخض خملؿىذ َٓمهد وخًظٍ متَُ ًهٍخ خملظًًن هلدمئص ردًؼىن‬
‫ خملظًًن خًؼدًؽ هى فهُْ خإلؾدَخض (مفًٌ ننً َٓم بؾدَ مفُي رلٌؽ منَُ ًه طُطٌس‬
. )-1 ‫ ًُٓم هٍ خإلؾدَخض منَُ ًهٍخ خملظًًن خًلٌمص‬،‫خإلؾدَ خملُخي َٓمه‬
.‫ خًى‬....‫ خملظًًنخض خألهُي هٍ خًٌىن وخًٌٔلهص‬
:‫ًُٓم هٍ خإلؾدَخض خًظٍ يف خًطىَش نوظس‬
img = cv2.drawContours(img, contours, -1, (0,255,0), 3)
‫ذ‬

:‫ًُٓم بؾدَ مفُي نوظس‬
img = cv2.drawContours(img, contours, 3, (0,255,0), 3)
‫ذ‬

:‫يف مهكم خألكٌدن ٓنٔظوًَ ؤٌٓىذ ؤفػٍ ًُٓم خإلؾدَخض وهى هدًظديل‬
cnt = contours[4]
img = cv2.drawContours(img, [cnt], 0, (0,255,0), 3)

import numpy as np ‫ذ‬
import cv2
img = cv2.imread('shape.png') ‫ذ‬
imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
ret,thresh = cv2.threshold(imgray,127,255,0) ‫ذ‬
contours, hierarchy =
cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)
‫ذ‬
cv2.drawContours(img, contours, -1, (0,255,0), 3)

cv2.imshow('counter',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫‪194‬‬ ‫‪ OpenCv‬ببساطة‬

‫مالككص هدمص‪ً :‬ـس خهظٌدَ يَؿص خًظهظٌس رهندًص كظى نلطٍ نىل بؾدَخض خًطىَش خًظٍ نًًُهد‪.‬‬

‫خًطىَش خًٔدرلص طلظىي نىل ‪ 5‬بؾدَخض‪ٌ .‬نونند َٓم بؾدَ مفُي كىي خًـٔم خًٍي نًًُه وًٌى نن‬
‫ؾًُم خملظًًن خًؼدًؽ ًٌظدرو ‪.cv2.drawContours‬‬

‫فةٌخ ؤَيند َٓم خإلؾدَ خًؼدين منَُ ًٌمظًًن خًؼدًؽ خًلٌمص‬
‫]‪.contours[1‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ًُٓم خإلؾدَ خًؼدًؽ منَُ ًه خًلٌمص ]‪ contours[2‬وهوٍخ‪.‬‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪195‬‬ ‫‪ OpenCv‬ببساطة‬

‫ػشًلخُذلشًجُاإلػبس‪ُ :‬‬
‫هٍخ هى خملظًًن خًؼدًؽ يف طدرو بًـدي خإلؾدَخض )(‪.cv2.findcontours‬‬
‫مبُهٍُوظٌفرهُومبُهٍُامفبئذحُمنه؟ ُ‬
‫كٌند ٓدرلدً ؤن رإن خإلؾدَخض نزدَش نن كًوي خًشوٍ وخًظٍ متٌى نفٕ خًشًش خًٌىنٌص‪ .‬هٌل كمند‬
‫رظوًّن بكًخػٌدض خًنلدؽ خًظٍ طشوٍ كًوي خًشوٍ‪ ،‬وًون هٍ هّند ؿمٌو بكًخػٌدض خًنلدؽ خًظٍ‬
‫طشوٍ هٍه خًلًوي؟‬
‫هٍخ هى مد ٌٓظم طلًًًه ردٓظوًخَ ؾًُلص طلًُس خإلؾدَخض‪.‬بٌخ مَُند ًهٍخ خملظًًن خًلٌمص‬
‫‪ٓ cv2.CHAIN_APPROX_NONE‬ىف ًوّن ؿمٌو نلدؽ خًلًوي‪.‬‬

‫ومكنُههُنؽربطُمرخضًنُظمٌؼُامنلبغ؟ ُ‬
‫نىل ٓزٌٍ خملؼدي ؤوؿً خإلؾدَ ًوـ مٔظلٌم‪ ،‬هٍ طلظدؾ ًوٍ خًنلدؽ خًظٍ نىل خًوـ كظى نٔظؿٌو‬
‫متؼٌٍ هٍخ خًوـ؟ نلن رلدؿص فلـ ًنلؿظٍن‪ ،‬نلؿص يف رًخًص خًوـ ونلؿص ؤهُي يف نهدًظه‪ ،‬وهٍخ مد‬
‫ًفهٌه خًظدرو ‪ cv2.CHAIN_APPROX_SIMPLE‬فهى ًًٍّ هٍ نلؿص ِخثًش نن خًلدؿص‪ ،‬وردًظديل‬
‫ٌٓظم خًظىفًن يف كـم خًٍخهُش‪.‬‬

‫خًطىَش خًظدًٌص طىغم مد طهٌمنده‪ ،‬كٌؽ يف خملٔظؿٌٍ خًٌٔدَي ؾزلند خًظدرو‬
‫‪ cv2.CHAIN_APPROX_NONE‬فظم طلًًً ؿمٌو نلدؽ خملٔظؿٌٍ (ردًٌىن خألَِق)‪ ،‬ؤمد يف‬
‫خًطىَش خًٌمٌنٌص ًٌمٔظؿٌٍ ؾزلند خًظدرو ‪ cv2.CHAIN_APPROX_SIMPLE‬فلدَ رظلًًً فلـ‬
‫خًنلدؽ خًٍصوًَص ًُٓم خملٔظؿٌٍ وهٍ خألَرو خًنلدؽ خملٌىنص ردألَِق‪.‬‬

‫ذ‬
‫‪196‬‬ ‫‪ OpenCv‬ببساطة‬

‫خصبئصُاإلػبساد ُ‬
‫امهذف‪ُ :‬‬
‫طهٌم بًـدي خًوطدثظ خملوظٌفص ًإلؾدَخض مؼٍ خملٔدكص‪ ،‬خمللٌـ‪ ،‬خملُهّ‪ ،‬خملُرو خمللٌـ‪.‬‬
‫ٓنظهٌم خٓظوًخَ خًهًًً من خًظىخرو خًظٍ ًهد نالكص ردإلؾدَخض‬
‫‪ .1‬عزومذاؾصورةذ‪ :Moments‬ذ‬

‫خًهّوَ طٔدنًند نىل كٔدذ رهؼ خًوطدثظ مؼٍ مُهّ هظٌص ؿٔم‪ ،‬مٔدكص ؿٔم‪ ..... ،‬خًى‪.‬‬
‫ًٌمًًّ من خملهٌىمدض نن خًهّوَ َخؿو ضفلص وًوٌزًًٌد ‪Image Moments‬‬
‫خًهّوَ رشوٍ ؤٓديس هٍ خًوطدثظ خًظٍ ططف شوٍ خًطىَش وؤمىَ ؤهُي هدملٔدكص وخًظىؿه‬
‫وخًٌٔلهص وخالًظىخء و ‪ .....‬خًى‪ٌ .‬نونند خٓظوًخَ هٍه خًوطدثظ ًٌظهُف نىل خألشودي خًظٍ يف‬
‫خًطىَش‪.‬‬
‫نّوَ خًطىَش هٍ نفٕ فوُش خًهَّ يف خملٌودنٌى‪ .‬ؤوي نَّ ٌٓهؿٌى مُهّ خًوظٌص‪ ،‬كٌؽ خًوظٌص‬
‫متؼٍ شًش(هؼدفص) خًزٌؤٍ‪ ،‬وػدين نَّ ًوربند هٌف طوظٌف هٍه خًوظٌص كىي مُهّ خًوظٌص ؤي ؤن‬
‫خًوظٌص يف خملُهّ يًن خًوظٌص كىًه (ننً يَخٓص منؿلص من خًـٔم)‪ .‬رنفٕ خًؿًُلص خًظٍ طلطٍ‬
‫فٌهد نىل نؿدًص ًـٔم نىل ؤَع خًىخكو‪ٌ ،‬نونى خًلطىي بكًي نّوَ خًطىَش‪ .‬وهٍخ ًهؿٌى‬
‫خمللإوَ خًُثٌٌٔص)‪ًٌ (x,y‬شوٍ خًٍي طًًُ وضفه‪.‬‬
‫خًظدرو )(‪ً cv2.moments‬لًَ فهُْ روٍ خًهّوَ خمللٔىرص‪ ،‬شدهً خملؼدي خًظديل‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)‪img = cv2.imread('star.jpg',0‬‬

‫)‪ret,thresh = cv2.threshold(img,127,255,0‬‬
‫)‪contours,hierarchy = cv2.findContours(thresh, 1, 2‬‬

‫]‪cnt = contours[0‬‬
‫)‪M = cv2.moments(cnt‬‬

‫‪print M‬‬

‫ذ ذ‬
‫‪197‬‬ ‫‪ OpenCv‬ببساطة‬

‫ٌنونند خًلطىي نىل رٌدندض مفًٌش مؼٍ خملٔدكص‪ ،‬خملُهّ‪ ..... ،‬خًى‬ ‫من كٌم خًهّوَ هٍه‬
‫و‬ ‫خملُهّ ًهؿى ردًهالكص‪:‬‬
‫ٌنون طنفٌٍ هٍه خًهالكص رطًٌص رُمـٌص هٌل ًًل‪:‬‬
‫)]'‪cx = int(M['m10']/M['m00‬‬
‫)]'‪cy = int(M['m01']/M['m00‬‬

‫‪print cx, cy‬‬
‫ذ‬

‫‪544‬ذ‪ 343‬ذ‬

‫‪ .2‬ؿداحةذاإلرارذ‪ :Contour Area‬ذ‬

‫طلٔس مٔدكص خإلؾدَ من هالي خًظدرو )(‪ cv2.contourArea‬ؤو ]'‪.M['m00‬‬
‫)‪area = cv2.contourArea(cnt‬‬
‫‪print area‬‬

‫‪678.5‬‬
‫‪ .3‬حمقطذاإلرارذ‪ :Contour Perimeter‬ذ‬

‫ًٔمى ؤًػد ؾىي خًلؿُ‪ً ،‬ظم كٔدره من هالي خًظدرو )(‪.cv2.arcLength‬‬
‫مظًًنه خًؼدين ًلًي فٌٌل بٌخ هدن خإلؾدَ مًٌم (بٌخ مُنند ًه ‪ )TRUE‬ؤَ فلـ منلنٍ‪.‬‬
‫)‪perimeter = cv2.arcLength(cnt, True‬‬
‫‪print perimeter‬‬
‫ذ‬
‫‪128.669046402‬‬
‫‪ .4‬تؼرقبذاإلرار ‪ :Contour Approximation‬ذ‬

‫ًلُذ شوٍ خإلؾدَ ًشوٍ آهُ مو نًي َئوْ ؤكٍ ردالنظٌلي نىل خًًكص خًظٍ نلًيهد‪ ،‬وًٌى رظؿزٌم‬
‫هىخَِمٌص يويالْ رىهُ ‪. Douglas-Peucker‬‬

‫ًفهم ًٌى‪ ،‬خفرتع رإنى طزلؽ نن مُرو يف ضىَش مد‪ ،‬وًون رٔزس مشوٌص مد كطٌع نىل مُرو‬
‫مشىه (هٌل هى مهُوع يف خًطىَش خًظدًٌص)‪ ،‬ننًهد ٌنونند خٓظهٌلي طدرو طلًُس خإلؾدَ ًٌلطىي نىل‬
‫خملُرو خملؿٌىذ‪.‬‬
‫‪198‬‬ ‫‪ OpenCv‬ببساطة‬

‫خملظًًن خًؼدين ًظدرو طلًُس خإلؾدَ (‪ )epsilon‬هى كٌمص ؤنكم هؿإ مٔمىق ره ًٌلطىي نىل‬
‫خًظلًُس خملؿٌىذ‪ ،‬وًـس خهظٌدَه رهندًص ًٌلطىي نىل خًنظٌـص خملُيىرص‪.‬‬
‫)‪epsilon = 0.1*cv2.arcLength(cnt,True‬‬
‫)‪approx = cv2.approxPolyDP(cnt,epsilon,True‬‬

‫)‪cv2.drawContours(img, [approx], -1, (0,255,0), 3‬‬
‫ذ‬

‫يف خًطىَش خًظٍ يف خًىٓـ‪ ،‬خًوـ خألهٍص ٌنؼٍ طلًُس خإلؾدَ‪.‬‬
‫يف خًطىَش خًىٓؿى نٔزص خًظلًُس هٍ ‪ 10%‬من ؾىي خملنلنٍ ( ‪epsilon = 10% of arc‬‬
‫‪.)length‬‬
‫ؤمد يف خًطىَش خًٌمٌنٌص فنٔزص خًظلًُس ‪ 1%‬من ؾىي خملنلنٍ ( ‪epsilon = 1% of the arc‬‬
‫‪.)length‬‬
‫خملظًًن خًؼدًؽ ًظدرو طلًُس خإلؾدَ )(‪ً cv2.approxPolyDP‬لًي فٌٌل بٌخ هدن خمللنٍ مًٌم ؤَ‬
‫ال‪.‬‬

‫المربع المشوه‬ ‫تقريب اإلطار‬ ‫تقريب اإلطار‬
‫بنسبة ‪%10‬‬ ‫بنسبة ‪%1‬‬
‫ذ‬

‫‪ .5‬غالفذاؾتحدبذ‪ :Convex Hull‬ذ‬

‫يالف خًظلًذ ًزًو ًند هظلًُس خإلؾدَ‪ ،‬وًونه ًٌٕ هًٍى (كً‬
‫طوىن خًنظدثف مظشدرهص يف رهؼ خًلدالض)‪ .‬فهى ًهنٍ ملدؾو‬
‫خملنلنٌدض خًزدَِش(خملنظفوص)(خمللًرص)‪ ،‬وؤًػد خمللدؾو خمللهُش‪.‬‬
‫خمللدؾو خمللهُش (خملنظفوص ًـهص خًًخهٍ) طًنى رهٌىذ‬
‫خملنلنٍ‪.‬‬
‫نىل ٓزٌٍ خملؼدي شدهً خًطىَش خًظدًٌص‪ ،‬خًوـ خألكمُ ًهُع‬
‫يالف خًظلًذ ًشوٍ خًًٌ‪.‬‬
199 ‫ ببساطة‬OpenCv

ٍ‫هٍ خالهظالفدض نن شوٍ خملنلن‬.‫خألٓهم ٌو خالطـدهٍن خًظٍ يف خًطىَش طكهُ نٌىذ خًظلًذ‬
:‫خًوًل خمللًذ ٌنون بًـديهد وفم خًظدرو‬

hull = cv2.convexHull(points[, hull[, clockwise[, returnPoints](
‫ذ‬

‫ ذ‬:cv2.convexHull ()‫ذرحذاؾتابعذ‬
:‫ ًإهٍ خملظًًنخض خًظدًٌص‬،‫طدرو كٔدذ يالف خًظلًذ‬
.َ‫ منَُ ًهٍخ خملظًًن نلدؽ خإلؾد‬:points[ ‫ خملظًًن خألوي‬
.‫ يدًزد نظـنزه‬،‫ مظًًن هُؾ طلًذ خًًالف‬:hull [ ‫ خملظًًن خًؼدين‬
‫ ٌٓوىن هُؾ طلًذ خًًالف مو‬TRUE ‫ بٌخ هدن‬:‫ خطـده خًهٌم‬:clockwise [ ‫ خملظًًن خًؼدًؽ‬
.ٕ‫نلدَذ خًٔدنص وبال ردًهو‬
‫ طهًٌ بكًخػٌدض‬،TRUE ‫ خفرتخغٌد كٌمظهد‬،‫ نلدؽ خالٓظهديش‬:returnPoints] ‫ خملظًًن خًُخرو‬
.‫ طهًٌ ماٌسخض ًنلدؽ طلًذ ًًالف‬FALSE ‫ ؤمد بٌخ هدنع كٌمظهد‬،‫نلدؽ طلًذ خًًالف‬

:‫ًًٍى ًٌلطىي نىل ملًذ خًًالف هٌل يف خًطىَش خًٔدرلص ًوظفى روظدرص مد ًًل‬
hull = cv2.convexHull(cnt)

ُ :‫مصبل‬
import numpy as np
import cv2 ‫ذ ذ‬
img = cv2.imread('hand.jpg')
imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
‫ذ‬
ret,thresh = cv2.threshold(imgray,245,255,0)
thresh_inv=cv2.bitwise_not(thresh) ‫ذ‬
contours, hierarchy =
‫ذ ذ‬
cv2.findContours(thresh_inv,cv2.RETR_TREE,cv2.CHAIN_APPROX_NONE)

hull = cv2.convexHull(contours[0])
‫ذ ذ ذ‬
cv2.drawContours(img, hull, -1, (0,0, 255), 3)

cv2.imshow('Image_hull',img) ‫ذ‬
cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬
‫‪200‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًنلدؽ خًظٍ ردًٌىن خألكمُ هٍ نلدؽ يالف خًظلًذ(‪.)hull‬‬
‫ًى وضٌند رٍن هٍه خًنلدؽ ٓنلطٍ نىل يالف خًظلًذ‪.‬‬

‫وًون بٌخ ؤَيند بًـدي نٌىذ خًظلًذ نلظدؾ ؤن منَُ خًلٌمص‬
‫‪ًٌ False‬مظًًن خًُخرو يف ًظدرو )( ‪cv2.convexHull‬‬
‫(‪.)returnPoints = False‬‬

‫ًفهم ًًٍى ٓنإهٍ ضىَش خملٔظؿٌٍ خًٍي يف خًطىَش‬
‫خًٔدرلص‪ .‬يف خًزًخًص ؤوؿًند بؾدَ هٍخ خملٔظؿٌٍ‪ ،‬خآلن‬
‫ٓنىؿً يالف خًظلًذ ًهٍخ خملٔظؿٌٍ مو وغو كٌمص ‪ TRUE‬يف خملظًًن خًُخرو ًظدرو كٔدذ‬
‫يالف خًظلًذ (‪ )returnPoints = True‬فنلطٍ نىل خًنظٌـص خًظدًٌص ‪[[[234 202]], [[ 51‬‬
‫]]]‪ 202]], [[ 51 79]], [[234 79‬وخًظٍ متؼٍ خًنلدؽ خألَرو ًّوخًد خملٔظؿٌٍ ‪.‬‬

‫خآلن بٌخ فهٌند نفٕ خًوؿىخض خًٔدرلص وًون رًي وغو كٌمص ‪ٓ TRUE‬نػو كٌمص ‪FALSE‬‬
‫(‪ٓ )returnPoints = False‬ىف نلطٍ نىل خًنظٌـص خًظدًٌص ]]‪[[129],[ 67],[ 0],[142‬‬
‫وخًظٍ متؼٍ فهُْ (يًٌٍ) خًنلدؽ خمللدرٌص ًهد يف خإلؾدَ ‪ ،‬نىل ٓزٌٍ خملؼدي ًنفلظ نظٌـص كٌمص‬
‫مد‪:‬‬
‫]]‪ cnt [129] = [[234, 202‬كطٌند نىل نفٕ خًنظٌـص خًٔدرلص (ونفٕ خألمُ مؿزم نىل خًنلدؽ‬
‫خألهُي)‬

‫ٓنشدهً هٍخ خألمُ مُش ؤهُي ننً خًظلًغ نن نٌىذ خًظلًذ )‪.(convexity defects‬‬

‫‪ .6‬اؾتحؼقذؿنذاؾتحدبذ‪ :Checking Convexity‬ذ‬

‫ًظم خًظللم فٌٌل بٌخ هدن خملنلنٍ ملًذ ؤَ ال‪ ،‬نن ؾًُم خًظدرو )(‪.cv2.isContourConvex‬‬
‫هٍخ خًظدرو ًهًٌ كٌمص بمد ‪ TRUE‬ؤو ‪.FALSE‬‬
‫ذ‬
‫)‪k = cv2.isContourConvex(cnt‬‬
201 ‫ ببساطة‬OpenCv

‫ ذ‬:Bounding Rectangle‫ ادلدتطقلذاحملقطذ‬.7

.َ‫ًه نىندن هٌل خملٔظلٌم وخملًو‬
:‫ ادلدتطقلذاحملقطذادلدتؼقم‬.A

.‫ ًًٍى ٌٓوىن كـمه ؤضًُي‬،ًُ‫ًهؿٍ مٔظؿٌٍ مٔظلٌم رًون ؤي طًو‬
.cv2.boundingRect() ‫ًلٔس هٍخ خملٔظؿٌٍ من هالي خًظدرو‬
.‫ ونُع خملٔظؿٌٍ وؾىًه‬،ٌٍ‫ًهؿٌند هٍخ خًظدرو بكًخػٌدض خًّؤوًص خًٌرسي خًهٌٌد ًٌمٔظؿ‬
x,y,w,h = cv2.boundingRect(cnt)
cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)

‫ يف هٍخ خملؼدي كزٍ َٓم خملٔظؿٌٍ خمللٌـ ٓنـهٍ يف خًطىَش خًؼندثٌص ًىن خًًٌ ردًٌىن‬:1‫مصبل‬
.)thresh_inv( ‫خألرٌؼ وًىن خًوٌفٌص ردألٓىي ًًٍى ٓنلىَ رهوٕ نمٌٌص خًظهظٌس‬

import numpy as np
import cv2
img = cv2.imread('hand.jpg')
imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

ret,thresh = cv2.threshold(imgray,245,255,0)
thresh_inv=cv2.bitwise_not(thresh)

contours, hierarchy =
cv2.findContours(thresh_inv,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cnt =contours[0]
hull = cv2.convexHull(cnt)

x,y,w,h = cv2.boundingRect(cnt)
cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),2)

#cv2.drawContours(img, contours[0], -1, (0,0, 255), 3)

cv2.imshow('Image_hull',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫ذ‬
202 ‫ ببساطة‬OpenCv

.Dilation ًًً‫ يف هٍخ خملؼدي خًطىش خًؼندثٌص ٓظوىن يًن وخغلص ًٍخ ٓنٌـإ ًهمٌٌص خًظم‬:2‫مصبل‬
import numpy as np
import cv2
img = cv2.imread('airplan.jpg')
imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

ret,thresh = cv2.threshold(imgray,207,255,0)
thresh_inv=cv2.bitwise_not(thresh)

kernel = np.ones((15,15),np.uint8)
dilation = cv2.dilate(thresh,kernel,iterations = 1)
cv2.imshow('dilation',dilation)

contours, hierarchy =
cv2.findContours(dilation,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cnt =contours[1]

#draw hull Rectangle
x,y,w,h = cv2.boundingRect(cnt)
cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)

cv2.imshow('Image_hull',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫‪203‬‬ ‫‪ OpenCv‬ببساطة‬

‫المستطيل المحيط المستقيم‬ ‫تعتيب ‪ +‬تمديد‬

‫‪ .B‬ادلدتطقلذاحملقطذادلدور‪:‬‬

‫هند ًُٓم خملٔظؿٌٍ خمللٌـ رإضًُ مٔدكص‪ ،‬وًإهٍ خملٔظؿٌٍ ِؤوًص يوَخن (ؤي ًوىن خملٔظؿٌٍ‬
‫مًخَ رّؤوًص مد)‪ً.‬لٔس هٍخ خملٔظؿٌٍ من هالي خًظدرو )(‪.cv2.minAreaRect‬‬

‫ًهؿٌند هٍخ خًظدرو بكًخػٌدض خًّؤوًص خًٌرسي خًهٌٌد ًٌمٔظؿٌٍ‪ ،‬وؾىي ونُع خملٔظؿٌٍ‪ ،‬ردإلغدفص‬
‫ًًٍى ِؤوًص ًهؿٌند ِؤوًص يوَخن خملٔظؿٌٍ‪ًُٓ .‬م خملٔظؿٌٍ ٓنلظدؾ مهُفص ِوخًد خملٔظؿٌٍ خألَرو‪،‬‬
‫ٌنونند خًلطىي نىل هٍه خًّوخًد من هالي خًظدرو )(‪.cv2.boxPoints‬‬

‫)‪rect = cv2.minAreaRect(cnt‬‬
‫)‪box = cv2.cv.BoxPoints(rect‬‬

‫)‪box = np.int0(box‬‬
‫)‪cv2.drawContours(im,[box],0,(0,0,255),2‬‬
‫ذ‬

‫مالؼظخ‪ُ :‬‬
‫بٌخ ؤَيض طؿزٌم خًظدرو ‪ cv2.cv.BoxPoints‬غمن موظزص ‪OpenCv‬خإلضًخَ ‪ 4‬نٌٌى ؤن طٔظزًًه‬
‫ردًظدرو )(‪.cv2.boxPoints‬‬
‫ذ‬

‫ذ‬

‫ذ‬
‫‪204‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًطىَش خًظدًٌص طهُع نىنٍ خملٔظؿٌٍ خمللٌـ (خملٔظلٌم وخملًوَ)‪ .‬خملٔظؿٌٍ خمللٌـ خملٔظلٌم‬
‫مٌىن ردًٌىن خألهٍص‪ ،‬ؤمد خملٔظؿٌٍ خمللٌـ خملًوَ مٌىن ردًٌىن خألكمُ‪.‬‬

‫ذ‬

‫‪ .8‬اؾدائرةذاحملقطةذاألصغرقةذ‪ :Minimum Enclosing Circle‬ذ‬

‫هٍ خًًخثُش خًظٍ طًؿٍ خًـٔم رإكٍ مٔدكص‪ ،‬وًظم ًٌى نن ؾًُم خًظدرو‬
‫)(‪.cv2.minEnclosingCircle‬‬
‫)‪(x,y),radius = cv2.minEnclosingCircle(cnt‬‬
‫))‪center = (int(x),int(y‬‬
‫)‪radius = int(radius‬‬
‫)‪cv2.circle(img,center,radius,(0,255,0),2‬‬
‫ذ‬

‫ذ‬

‫ذ‬
205 ‫ ببساطة‬OpenCv

‫ ذ‬:Fitting an Ellipse‫ اؾؼطعذاؾـاؼصذادلتالئمذؿعذاإلرارذ‬.9

.‫ًظم بكدؾص خًـٔم رلؿو ندكظ‬
.cv2.fitEllipse() ‫ًظم َٓم هٍ خًلؿو نن ؾًُم خًظدرو‬
ellipse = cv2.fitEllipse(cnt)
im = cv2.ellipse(im,ellipse,(0,255,0),2)
‫ذ‬

‫ذ‬

‫ ذ‬:Fitting a Line‫ اخلطذادلتالئمذؿعذاإلرارذ‬.10

cv2.fitLine() ‫ًظم َٓم هٍخ خًوـ نن ؾًُم خًظدرو‬
rows,cols = img.shape[:2]
[vx,vy,x,y] = cv2.fitLine(cnt, cv2.DIST_L2,0,0.01,0.01)
lefty = int((-x*vy/vx) + y)
righty = int(((cols-x)*vy/vx)+y)
img = cv2.line(img,(cols-1,righty),(0,lefty),(0,255,0),2)
‫ذ‬
‫‪206‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫املضًذُمنُخصبئصُاإلػبسادُ‪ُ Contour Properties‬‬
‫ٓنظهٌم خٓظوًخَ هطدثظ خًـٔم خملٔظهمٌص روًتش مؼٍ خًطالرص وخًلؿُ خملودفح وكندم خًطىَش‬
‫وخًوؼدفص خملظىٓؿص‪.‬‬
‫‪ -1‬ـدبةذاألبعادذ‪ :Aspect Ratio‬ذ‬

‫متؼٍ نٔزص خًهُع نىل خالَطفدم ًٌمٔظؿٌٍ خمللٌـ ردًـٔم‪.‬‬

‫)‪x,y,w,h = cv2.boundingRect(cnt‬‬
‫‪aspect_ratio = float(w)/h‬‬
‫ذ‬

‫‪ -2‬االؿتداد (احلدود)ذ‪:Extent‬‬

‫خالمظًخي هى نٔزص مٔدكص خإلؾدَ نىل مٔدكص خملٔظؿٌٍ خمللٌـ‪.‬‬

‫)‪area = cv2.contourArea(cnt‬‬
‫)‪x,y,w,h = cv2.boundingRect(cnt‬‬
‫‪rect_area = w*h‬‬
‫‪extent = float(area)/rect_area‬‬
‫ذ‬
207 ‫ ببساطة‬OpenCv

:Solidity‫ اؾصالبةذ(اؾشدة)ذ‬-3

.‫هٍ نٔزص مٔدكص خإلؾدَ نىل مٔدكص خملنؿلص خمللًرص‬

area = cv2.contourArea(cnt)
hull = cv2.convexHull(cnt)
hull_area = cv2.contourArea(hull)
solidity = float(area)/hull_area
‫ذ‬

:Equivalent Diameter‫ اؾؼطرذادلؽاػ ذ‬-4

.َ‫هى كؿُ خًًخثُش خًظٍ مٔدكظهد من نفٕ مٔدكص خإلؾد‬

area = cv2.contourArea(cnt)
equi_diameter = np.sqrt(4*area/np.pi)
‫ذ‬

‫ذ‬:‫ اؾتدوقر‬-5

.‫ خًوىي خًظديل ًهؿٍ خمللىَ خالهرب وخالضًُ وخألؾىخي‬.‫هٍ خًّؤوًص خًظٍ طم طًوًُ خًـٔم رهد‬
(x,y),(MA,ma),angle = cv2.fitEllipse(cnt)
‫ذ‬

:Mask and Pixel Points‫ اؾؼـاعذوـؼاطذاؾبقؽدلذ‬-6

‫ ٌنون مهُفص هٍه‬،‫يف رهؼ خألكٌدن كً نلظدؾ الٓظوًخَ ؿمٌو خًنلدؽ خًظٍ طشوٍ هٍخ خًـٔم‬
:‫خًنلدؽ من هالي مد ًًل‬
mask = np.zeros(imgray.shape,np.uint8)
cv2.drawContours(mask,[cnt],0,255,-1)
pixelpoints = np.transpose(np.nonzero(mask))
#pixelpoints = cv2.findNonZero(mask) ‫ذ‬
‫‪208‬‬ ‫‪ OpenCv‬ببساطة‬

‫هندن ؾًُلظٍن ملهُفص خًنلدؽ خًظٍ طشوٍ خًـٔم‪:‬‬
‫‪ ‬خًؿًُلص خألوىل ردٓظوًخَ طىخرو موظزص ‪.Numpy‬‬
‫‪ ‬خًؿًُلص خًؼدنٌص ردٓظوًخَ طىخرو موظزص ‪( OpenCv‬ؤهُ ٓؿُ طهٌٌم يف خًوىي خًٔدرم)‪.‬‬
‫خًنظٌـص نفٔهد ردًؿًُلص خألوىل مو خهظالف رٌٔـ‪ ،‬فموظزص ‪Numpy‬طهؿٍ خإلكًخػٌدض‬
‫رطًٌص (ٓؿُ‪ ،‬نمىي)‪ ،‬رٌنٌل موظزص ‪OpenCv‬طهؿٍ خإلكًخػٌدض رطًٌص (‪.) X،Y‬‬
‫‪ -7‬ادلتودطذاؾؾوـيذأوذاؾشدةذادلتودطةذ‪ :Mean Color or Mean Intensity‬ذ‬

‫نٔظؿٌو بًـدي خملهًي خًىٓؿٍ ًٌىن‪ .‬ؤو ٌنونند ؤًـدي خًشًش خًٌىنٌص خًىٓؿٌص ًٌـٔم يف خملٔظىي‬
‫خًُمديي‪ٓ .‬نلىَ ردٓظهٌلي خًلندم مُش ؤهُي ًٌلٌدَ رًٍى‪ .‬ذ‬

‫)‪mean_val = cv2.mean(im,mask = mask‬‬
‫ذ‬

‫‪ -8‬ـؼاطذاؾشدةذ‪:Extreme Points‬‬

‫نلدؽ خًشًش طهنٍ نلدؽ خًـٔم خًهٌىًص وخًٔفٌٌص وؤكىص خًٌمٍن وؤكىص خًٌٔدَ‪.‬‬

‫)]‪leftmost = tuple(cnt[cnt[:,:,0].argmin()][0‬‬
‫)]‪rightmost = tuple(cnt[cnt[:,:,0].argmax()][0‬‬
‫)]‪topmost = tuple(cnt[cnt[:,:,1].argmin()][0‬‬
‫)]‪bottommost = tuple(cnt[cnt[:,:,1].argmax()][0‬‬

‫نىل ٓزٌٍ خملؼدي‪ ،‬بٌخ ؾزلند نلدؽ خًشًش نىل هًُؿص مًًنص ؤنًًدن ٓنلطٍ نىل خًنظٌـص خًظدًٌص‪:‬‬
‫ذ‬

‫ذ‬
‫‪209‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذىاتؼُاإلػبسادُاإلطبفٌخُ‪ُ Contours More Functions‬‬
‫امهذف‪ُ :‬‬
‫نٌىذ خًظلًذ وهٌفٌص بًـديهد‬
‫بًـدي ؤكٍ مٔدكص من نلؿص بىل خملػٌو‪.‬‬
‫ملدَنص خألشودي خملوظٌفص‪.‬‬

‫امنظشيُ‪ُ+‬امكىد‪ُ :‬‬
‫ُ‬
‫‪ -1‬عقوبذاؾتحدبذ‪:Convexity Defects‬ذذ‬

‫ًلً طهٌمند يف خًفطٍ خًٔدرم خًٍي ًظوٌم نن خإلؾدَخض مد هى يالف خًظلًذ‪ .‬ؤي خنلُخف(فُق)‬
‫ًٔؿم خًـٔم نن يالف خمللًذ ًهظرب نٌس طلًذ‪ .‬موظزص ‪OpenCv‬وفُض ًند طدرو ؿدهّ إلًـدي‬
‫هٍه خًهٌىذ )(‪.cv2.convexityDefects‬‬
‫)‪hull = cv2.convexHull(cnt,returnPoints = False‬‬
‫)‪defects = cv2.convexityDefects(cnt,hull‬‬
‫ذ‬
‫]]‪[[[ 267 370 313 22563‬‬

‫]]‪[[ 370 372 371 142‬‬

‫]]‪[[ 373 377 374 114‬‬

‫]]‪[[ 377 479 450 30081‬‬

‫]]]‪[[ 264 266 265 114‬‬
‫ذ‬

‫مالككص‪ :‬طٍهُ رإنند مُنند ًٌمظًًن ‪ returnPoints‬يف خًظدرو ‪ cv2.convexHull‬خًلٌمص ‪ً FALSE‬يك نىؿً‬
‫نٌىذ خًظلًذ (‪.)returnPoints = False‬‬
‫ًهًٌ خًظدرو )( ‪ convexityDefects‬مطفىفص رلٌؽ هٍ ضف ًلىي خًلٌم خًظدًٌص] نلؿص خًزًخًص‪،‬‬
‫نلؿص خًنهدًص‪ ،‬ؤرهً نلؿص‪ ،‬خملٔدفص خًظلًُزٌص ألرهً نلؿص [‪ .‬خًلٌم خًؼالغ خألوىل طهدي رشوٍ ماٌس‬
‫ملىغو خًنلؿص نىل خإلؾدَ‪.‬‬
210 ‫ ببساطة‬OpenCv

،‫ٓنوظس رُندمف طىغٌلٍ ًلىَ رُٓم مٔظلٌم من نلؿص خًزًخًص بىل نلؿص خًنهدًص‬
.‫وًُٓم يخثُش كىي ؤرهً نلؿص‬
‫طٍهُ خًلٌم خًؼالغ خألوىل ؤنًٌض هماٌس ًُكم خإلؾدَ (كٌم نزىذ خًظلًذ مل طهدي‬
‫ ًًٍى ًـس ؤن نلٍص هٍه خًلٌم يخمئد من خملطفىفص خًظٍ طلظىي‬.)‫رشوٍ بكًخػٌدض‬
.)َ‫نىل بكًخػٌدض خإلؾدَ خمللًي (َكم خإلؾد‬

import numpy as np
import cv2
img = cv2.imread('hand.jpg')
imgray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

ret,thresh = cv2.threshold(imgray,230,255,0)
thresh_inv=cv2.bitwise_not(thresh)

contours, hierarchy = cv2.findContours(thresh_inv,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cnt =contours[0]

hull = cv2.convexHull(cnt,returnPoints = False)
defects = cv2.convexityDefects(cnt,hull)
#print defects
#print defects.shape
for i in range(defects.shape[0]):
s,e,f,d = defects[i,0]
start = tuple(cnt[s][0])
end = tuple(cnt[e][0])
far = tuple(cnt[f][0])
cv2.line(img,start,end,[0,255,0],2)
cv2.circle(img,far,5,[0,0,255],-1)

#cv2.drawContours(img, contours[0], -1, (0,0, 255), 3)

cv2.imshow('Image_hull',img)
cv2.waitKey(0)
cv2.destroyAllWindows()

‫ذ‬
‫‪211‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ :‬‬
‫ذ‬

‫ذ‬

‫ٌسقُامكىد‪ُ :‬‬
‫يف هٍخ خًوىي ًفهم وقٌفص هٍ ٓؿُ رشوٍ ؿًٌ كم ردٓظوًخَ خًظهٌٌمص ‪ًٌٔprint‬هٍ نٌٌى فهم‬
‫خًوىي‪.‬‬
‫ذ‬
‫)‪ret,thresh = cv2.threshold(imgray,230,255,0‬‬
‫ذ‬ ‫)‪thresh_inv=cv2.bitwise_not(thresh‬‬

‫كمند رهمٌٌص خًظهظٌس فكهُض خًًٌ رٌىن خٓىي وخًوٌفٌص رٌىن خرٌؼ‪ًًٍ ،‬ى كمند رهوٕ نظٌـص‬
‫خًظهظٌس نن ؾًُم خًظدرو )(‪ cv2.bitwise_not‬كظى طكهُ خًًٌ ردًٌىن خألرٌؼ‪.‬نلىَ رةًـدي‬
‫خإلؾدَخض نن ؾًُم خًظدرو )(‪.cv2.findContours‬‬

‫)‪contours, hierarchy = cv2.findContours(thresh_inv,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE‬‬
‫]‪cnt =contours[0‬‬

‫ذ‬

‫ػم نوّن خإلؾدَ خألوي (هند ٌنؼٍ خإلؾدَ كىي خًًٌ) يف مظًًن ٓمٌنده ‪.cnt‬‬

‫)‪hull = cv2.convexHull(cnt,returnPoints = False‬‬

‫نىؿً خًنلدؽ خًظٍ طوىن يالف خًظلًذ ًإلؾدَ نن ؾًُم خًظدرو ‪ cv2.convexHull‬ومنَُ ًٌزدَمرت‬
‫خًؼدين ًهٍخ خًظدرو خًلٌمص ‪False‬كظى نٔظؿٌو ؤًـدي نٌىذ خًظلًذ‪.‬‬
‫‪212‬‬ ‫‪ OpenCv‬ببساطة‬

‫)‪defects = cv2.convexityDefects(cnt,hull‬‬ ‫ذ‬

‫نىؿً خًنلدؽ خًظٍ طشوٍ نٌىذ طلًذ خإلؾدَ نن ؾًُم خًظدرو )(‪ cv2.convexityDefects‬خًٍي‬
‫ٌٓهًٌ ًند ؤَرو كٌم‪( ،‬مؼال [ ‪ ) ] 457 475 484 44054‬ؤوي ػالغ كٌم منهد طاٌس بىل مىغو‬
‫نلدؽ نٌىذ خًظلًذ‪.‬‬

‫‪for i in range(defects.shape[0]):‬‬

‫نلىَ رظوُخَ خًلٌلص كٔس نًي نلدؽ نٌىذ خًظلًذ (يف مؼدًند ًىؿً ‪ 84‬نلؿص ًًٍى طم نوًُُ‬
‫كٌلص ‪ 84 for‬مُش)‬

‫ردكٍ خًوىي ًن خٌسكه كإوي فهمه ًىكًن نن ؾًُم طهٌٌمص ‪.print‬‬
‫ذ‬

‫‪ -2‬ـؼطةذؿضؾعذاالختبارذ‪:Point Polygon Test‬‬

‫خًظدرو )(‪ً cv2.pointPolygonTest‬ىؿً ؤكرص مٔدفص رٍن نلؿص يف خًطىَش وخإلؾدَ‪.‬‬
‫فهى ًفًٌند يف طلًًً مىكو خًنلؿص ردًنٔزص ًإلؾدَ‪ ،‬هٍ هٍ يخهٍ ملٌـ خإلؾدَ ؤَ هدَؿه ؤَ نىل‬
‫خإلؾدَ‪ً .‬هًٌ هٍخ خًظدرو كٌمص ٓدًزص بٌخ هدنع خًنلؿص هدَؾ ملٌـ خإلؾدَ‪.‬‬

‫نىل ٓزٌٍ خملؼدي ٌنوند خًظللم من خًنلؿص (‪ )50,50‬هٌل ًًل‪:‬‬
‫(‪dist = cv2.pointPolygonTest(cnt,(50,50),True‬‬
‫ذ‬

‫ػدًؽ مظًًن يف خًظدرو )(‪ cv2.pointPolygonTest‬هى ‪ ،measureDist‬بٌخ هدنع كٌمظه ‪TRUE‬‬
‫ٌٓىؿً رهً خًنلؿص‪ ،‬وبٌخ هدنع كٌمظه ‪ٌٓFalse‬ىؿً هٍ خًنلـ يخهٍ خإلؾدَ ؤَ يخهٌه ؤَ نىل‬
‫خإلؾدَ‪.‬‬
‫بٌخ ؤندي خًظدرو خًلٌمص (‪ )1.0‬فدًنلؿص يخهٍ خإلؾدَ‪ ،‬وبٌخ ؤندي خًلٌمص )‪ )-1.0‬فدًنلؿص هدَؾ خإلؾدَ‪،‬‬
‫وبٌخ ؤندي خًلٌمص (‪ (0.0‬فدًنلؿص نىل خإلؾدَ‪.‬‬
‫‪213‬‬ ‫‪ OpenCv‬ببساطة‬

‫مالككص‪ :‬بٌخ مل طُيس رةًـدي خملٔدفص طإهً رإن طـهٍ كٌمص هٍخ خملظًًن ‪( ،False‬ألن نمٌٌص كٔدذ خملٔدفص طإهٍ‬
‫وكع ؾىًٍ) مٌل ًـهٍ ِمن طنفٌٍ خًظدرو ؤرسم رػهفٍن ؤو ػالػص‪.‬‬
‫‪ -3‬ؿؼارـةذاألذؽالذ‪:Match Shapes‬‬

‫موظزص ‪OpenCv‬طىفُ ًند خًظدرو )(‪ cv2.matchShapes‬خًٍي ٌنونند من خمللدَنص رٍن شوٌٍن ؤو‬
‫بؾدًَن‪ ،‬وًهًٌ كٌمص ًنظٌـص خمللدَنص طىغم هٍخ خًظشدره‪ ،‬وهٌٌل هدنع نظٌـص خمللدَنص ؤكٍ هٌٌل هدن‬
‫خًظشدره ؤهرب‪.‬‬
‫طلٔس هٍه خًلٌمص خنظٌليخ نىل كٌم خًهّوَ‪ ،‬وًىؿً ؤًػد هندن ؾُق موظٌفص إلًـدي كٌمص نظٌـص‬
‫خمللدَنص‪ .‬خًوىي خًظديل ًىغم هٍه خًؿُق‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬

‫)‪img1 = cv2.imread('star1.jpg',0‬‬
‫)‪img2 = cv2.imread('star2.jpg',0‬‬

‫)‪ret, thresh = cv2.threshold(img1, 127, 255,0‬‬
‫)‪ret, thresh2 = cv2.threshold(img2, 127, 255,0‬‬
‫)‪contours,hierarchy = cv2.findContours(thresh,2,1‬‬
‫]‪cnt1 = contours[0‬‬
‫)‪contours,hierarchy = cv2.findContours(thresh2,2,1‬‬
‫]‪cnt2 = contours[0‬‬

‫)‪ret = cv2.matchShapes(cnt1,cnt2,1,0.0‬‬
‫ذ‬ ‫‪print ret‬‬

‫كمع رظؿزٌم طدرو ملدَنص خألشودي مللدَنص خألشودي ‪ A‬و‪ B‬و‪ C‬خًظٍ يف خًطىَش خًظدًٌص‪:‬‬

‫ذ‬
‫‪214‬‬ ‫‪ OpenCv‬ببساطة‬

‫فودنع خًنظٌـص هدًظديل‪:‬‬
‫‪ ‬ملدَنص خًشوٍ ‪ A‬مو نفٔه هدنع نظٌـص خمللدَنص = ‪0.0‬‬
‫‪ ‬ملدَنص خًشوٍ ‪ A‬مو خًشوٍ ‪ B‬فودنع نظٌـص خمللدَنص = ‪0.001946‬‬
‫‪ ‬ملدَنص خًشوٍ ‪A‬مو خًشوٍ ‪C‬فودنع نظٌـص خمللدَنص = ‪0.326911‬‬

‫طًوًُ خًطىَش ًن ًاػُ هؼًنخ نىل نظٌـص خمللدَنص‪.‬‬
‫ذ‬

‫شبهذُؤًظبَ‪ُ :‬‬
‫‪Hu-Moments‬ذفيذدبعةذعزومذالذتتلثرذباؾدورانذأوذتغريذاحلجم‪.‬ذميؽـكذإجيادذفذهذاؾعزومذؿنذخاللذاؾتابعذ‬

‫)(‪ .cv2.HuMoments‬ذ‬

‫)‪a = cv2.HuMoments(contours‬‬
‫)‪print a ,'\n', len(a‬‬
‫ذ‬

‫ذ‬

‫متشًن‪ُ :‬‬
‫كدَن رٍن ضىَيت كُفٍن ؤو َكمٍن ردٓظوًخَ خًظدرو )(‪( cv2.matchShapes‬هٍخ خملؼدي ٌنؼٍ ؤرٔـ‬
‫هؿىش نلى خًـ ‪.)OCR‬‬

‫خًـ ‪ OCR‬ردهظطدَ نزدَش نن هىخَِمٌص ًظلىًٍ خألَكدَ ؤو خألكُف خملُٓىمص بىل نظ)‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫الفصل الخامس‬

‫” الجميع عباقرة للكن إن حكمت على قدرة سمكة في تسلق الشجرة‬
‫ستعيش حياتها كلها وهي تؤمن بأنها غبية ‟‬

‫ألبرت أينشتين‬
‫‪216‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُامخبمغ‪ُ:‬املخؼؼبدُامثٌبنٌخُيفُ‬
‫‪ُ OpenCv‬‬

‫خملوؿؿدض خًزٌدنٌص ‪ :8-‬خًزلؽ‪ ،‬خًُٓم‪ ،‬خًظلٌٌٍ!!!‬

‫طهٌم خًزلؽ نن خإلؾدَ وَٓمه‬

‫خملوؿؿدض خًزٌدنٌص ‪ :4-‬مهديًص خًُٓم خًزٌدين‪.‬‬

‫طهٌم طللٌم خًظودفا ًٌموؿؿدض خًزٌدنٌص ًٌلطىي نىل ؤفػٍ نٔزص طزدًن ًٌطىَش‪.‬‬

‫خملوؿؿدض خًزٌدنٌص ػندثٌص خًزهً ‪:2D Histograms‬‬

‫طهٌم وبًـدي خملوؿـ خًزٌدين ػنديئ خًزهً‪.‬‬

‫خإلٓلدؽ خًوٌفٍ ًٌموؿـ خًزٌدين‪:‬‬

‫طهٌم بًـدي خملوؿـ خًزٌدين ًإلٓلدؽ خًوٌفٍ الهظشدف ؿٔم مٌىن رٌىن مهٍن يف خًطىَش‪.‬‬
‫‪217‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذادلخططاتذاؾبقاـقةذيفذ‪ OpenCv‬ذ‬

‫اإلًعبد‪ُ،‬امشظم‪ُ،‬امرؽنٌهُيفُاملخؼؼبدُامثٌبنٌخ‪ُ :‬‬
‫امهذف‪ُ :‬‬
‫بًـدي خملوؿؿدض خًزٌدنٌص ردٓظوًخَ طىخرو هٍ من ‪OpenCv‬و‪.numpy‬‬
‫َٓم خملوؿؿدض خًزٌدنٌص ردٓظهٌلي طىخرو ‪OpenCv‬و‪Matplotlib‬‬
‫ٓنظهٌم خٓظوًخَ خًظىخرو‪np. histogram ()،cv2.calcHist() :‬‬
‫امنظشي‪ُ :‬‬
‫خملوؿـ خًزٌدين ًهؿٌند فوُش ندمص نن خًطىَش‪ً ،‬ظمؼٍ رلٌم خًزٌؤالض نىل خمللىَ ‪ x‬ونًيهد‬
‫خملىخفم نىل خمللىَ ‪.Y‬‬
‫هى فلـ نزدَش نن ؾًُلص ؤهُي ًفهم خًطىَش‪ .‬ردًنكُ ًٌموؿـ خًزٌدين ًٌطىَش فةنند نلطٍ نىل فوُش‬
‫ندمص نن طىِم خًشًش خًٌىنٌص يف خًطىَش‪ ،‬وؤيٌس طؿزٌلدض مهدًـص خًطىَش خًٌىَ ال طوٌى من‬
‫خٓظهٌلي خملوؿؿدض خًزٌدنٌص‪.‬‬
‫خًطىَش خًظدًٌص مإهىٌش من مىكو ؿدمهص هدمربًًؾ ‪ Cambridge in Color website‬وطظػمن خًطىَش‬
‫مو موؿؿهد خًزٌدين‪ .‬مو خًهٌم ؤن خملوؿـ خًزٌدين مُٓىَ ًٌطىَش خًُمديًص وًٌٕ خملٌىنص‪.‬‬

‫ذ‬

‫ذ‬
‫‪218‬‬ ‫‪ OpenCv‬ببساطة‬

‫خملنؿلص خًٌرسي من خملوؿـ خًزٌدين طهُع همٌص خًزٌؤالض خًظٍ ًىنهد يدمم (نمٌم)‪ ،‬وخملنؿلص‬
‫خًٌمنى طكهُ همٌص خًزٌؤالض خألفظم‪ .‬ورًٍى نالكل يف خًطىَش رإن خًزٌؤالض خألفظم ؤكٍ من‬
‫خًزٌؤالض خأليمم‪ ،‬ؤمد ردًنٔزص ًٌزٌؤالض خًظٍ يف خًىٓـ فومٌظهد كٌٌٌص‪.‬‬
‫‪ ‬بًعبدُاملخؼؽُامثٌبينُ‪ُ :Find Histogram‬‬
‫رهً ؤن ؤهٍند فوُش نن خملوؿؿدض خًزٌدنٌص‪ٌ ،‬نونند خآلن ؤن نهُف ؾًُلص بًـديهد نرب هٍ من‬
‫موظزص ‪OpenCv‬و‪ ،Numpy‬وًون كزٍ خًزًء نلظدؾ ًفهم رهؼ خملطؿٌلدض خملُطزؿص ردملوؿـ‬
‫خًزٌدين‪:‬‬
‫‪ :BINS‬خملوؿـ خًزٌدين خًٔدرم ًكهُ نًي خًزٌؤالض ًوٍ كٌمص وًكهُ ؤًػد شًطهد خًٌىنٌص‪،‬‬
‫وردًظديل ٓنلظدؾ ًـ ‪ 265‬كٌمص ًإلقهدَ‪ ،‬وًون مدٌخ نفهٍ بٌخ ؤَيند ؤن نلٔس خملوؿـ خًزٌدين‬
‫ملـمىنص رٌؤالض طلو كٌمظهد يف مـدي ؿّيئ ملًي؟ نىل ٓزٌٍ خملؼدي‪ ،‬نًًُ بًـدي نًي‬
‫‪ 16-31‬ػم ‪ ،......،‬ػم من ‪240‬بىل ‪.255‬‬ ‫خًزٌؤالض خًظٍ شًطهد خًٌىنٌص رٍن ‪ 0-15‬ػم من‬
‫ٓنلظدؾ فلـ ًـ ‪ 16‬كٌمص ًظمؼٌٍ خملوؿـ خًزٌدين وهٍخ مد ٓنشدهًه يف رهؼ خألمؼٌص يف‬
‫ذ‬ ‫‪. OpenCV Tutorials on histograms‬‬

‫ًًٍى مد ًـس نٌٌند فهٌه هى ؿمو خًلٌم خًظٍ يف خملوؿـ خًزٌدين خًوًل خًُمشً ِوٌص ًلٌمص وخكًش يف‬
‫خملوؿـ خًزٌدين خملطًُ‪ ،‬ؤي كٔم خملوؿـ خًوًل ًـ ‪ 16‬كٔم مظٔإوي‪ ،‬وننًهد ًًنى هٍ كٔم رـ‬
‫‪ .BIN‬يف خملوؿـ خًزٌدين خًُثًٌس ًٌطىَش خًٔدرلص هدن نًي خًلٌم ‪ 256‬كٌمص‪ ،‬وًُمّ ًلٌم خًـ‬
‫‪ BINS‬خًٔدرلص رـ ‪.histSize‬‬

‫‪ :DIMS‬نًي خًزدَخمرتخض (خملهدًًن) خًظٍ طـمو خًزٌدندض‪ .‬يف خملوؿـ خًٔدرم ؤهٍند فلـ شًش‬
‫خًزٌؤٍ رهٍن خالنظزدَ ًًٍى ٓظوىن كٌمظهد هند ‪.1‬‬

‫‪ :RANGE‬هى مـدي خًشًخض خًٌىنٌص خًظٍ نًًُ كٌدٓهد‪ ،‬ردًهديش طوىن من ‪0‬بىل ‪ 256‬ؤي خملـدي‬
‫هدمٍ (ؿمٌو كٌم خًشًخض (خًهمم خًٌىين))‪.‬‬
‫ذ‬

‫ذ‬
‫‪219‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬ؼعبةُاملخؼؽُامثٌبينُيفُ‪ُ :OpenCv‬‬
‫ٓنٔظوًَ خآلن خًظدرو )(‪ cv2.calcHist‬إلًـدي خملوؿـ خًزٌدين‪ٓ ،‬نظهُف نىل هٍخ خًظدرو ونىل‬
‫مظًًنخطه‪:‬‬
‫)]]‪cv2.calcHist(images, channels, mask, histSize, ranges[, hist[, accumulate‬‬ ‫ذ ذ‬

‫خملظًًن خألوي ‪ٌ :image‬نؼٍ خًطىَش خألضـٌٌص مـن نـىم ‪ unit8‬ؤو ‪ ،float32‬وًــس ؤن طوظـس غـمن‬
‫ؤكىخْ‪ ،‬مؼٍ "]‪.‚[img‬‬

‫خملظًًن خًؼدين ‪ :channels‬يًٌٍ خًلندش خًظٍ نًًُ ؤن نإهٍ فٌهد خملوؿــ خًزٌـدين ملٔـظىي خًطـىَش‪،‬‬
‫يف كدي هدنع خًطىَش َمديًص طوىن خًلندش وخكًش‪ ،‬ؤمد يف كدًص خًطىَش خملٌىنص فٌمونند طلًًً خًلنـدش‬
‫خًٌىنٌص (‪ R‬ؤو ‪ G‬ؤو ‪ )B‬نن ؾًُم متًُُ خًلٌمص خًظٍ نًًُهد ‪ 0‬ؤو ‪ 1‬ؤو ‪( 2‬هٍ َكم ٌنؼٍ كندش)‪.‬‬

‫خملظًًن خًؼدًؽ ‪ :mask‬كندم خًطىَش‪ ،‬بٌخ ؤَيض بًـدي خملوؿـ خًزٌدين ًودمـٍ خًطـىَش طوـىن كٌمظـه‬
‫‪ ،None‬ؤمد بٌخ ؤَيض بًـدي خملوؿــ خًزٌـدين ملنؿلـص ملـًيش فهٌٌـى بنشـدء كنـدم ضـىَش مندٓـس‬
‫ومتًُُهد ًهٍخ خملظًًن‪.‬‬

‫خملظًـًن خًُخرـو ‪ٌ :histSize‬نؼـٍ نـًي خًــ‪ ، BINS‬وًــس هظدرظـه غـمن ؤكـىخْ ][‪ًٌ ،‬لطـىي نـىل‬
‫خملـدي خًودمٍ منَُ ]‪.[256‬‬

‫خملظًًن خًودمٕ ‪ :range‬هٍخ خملظًًن ٌنؼٍ خملـدي ورشوٍ خفرتخيض ًوىن خملـدي من ]‪.[0,256‬‬

‫ٓنزًؤ ردملؼدي خًظديل رةًـدي خملوؿـ خًزٌدين ًطىَش َمديًص‪.‬‬

‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪import matplotlib.pyplot as plt‬‬

‫)‪img = cv2.imread('sonic.jpg',0‬‬

‫)]‪hist = cv2.calcHist([img],[0],None,[256],[0,256‬‬
‫‪print hist.shape‬‬

‫)‪(256, 1‬‬
‫‪220‬‬ ‫‪ OpenCv‬ببساطة‬

‫خملوؿـ خًزٌدين هند هى مطفىفصرلـم ‪ ، 256x1‬هٍ كٌمص طىخفم نًي من خًزٌؤالض يف خًطىَش‬
‫مو كٌمص خًزٌؤٍ خمللدرٌص ًهد‪.‬‬
‫‪ ‬ؼعبةُاملخؼؽُامثٌبينُيفُ‪ُ :Numpy‬‬
‫ٓنٔظوًَ خًظدرو )( ‪ np. histogram‬خملىؿىي غمن موظزص ‪ Numpy‬يف بًـدي خملوؿـ خًزٌدين‪.‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪import matplotlib.pyplot as plt‬‬

‫)‪img = cv2.imread('home.jpg',0‬‬
‫)]‪hist,bins = np.histogram(img.ravel(),256,[0,256‬‬

‫‪print hist.shape‬‬
‫ذ‬

‫)‪(256, 1‬‬
‫ٌسق‪:‬‬
‫)(‪np.histogram‬‬
‫)(‪ravel‬‬
‫ٓنلطٍ نىل نظٌـص مؼٍ نظٌـص خًظدرو خًٔدرم (‪.)cv2.calcHist‬‬

‫متٌى موظزص ‪Numpy‬خًظدرو)(‪ np.bincount‬وهى ؤرسم رـ ‪ 10X‬مُش من )(‪ًًٍ ،np.histogram‬ى‬
‫يف خملوؿـ خًزٌدين خألكديي خًزهً ًفػٍ خٓظوًخَ خًظدرو )(‪ ،np.bincount‬وًون ال طنىس ؤن‬
‫طػو ‪ minlength= 256‬يف هٍخ خًظدرو‪.‬‬

‫)‪hist = np.bincount(img.ravel(),minlength=256‬‬ ‫ؿثالً‪ :‬ذ‬

‫ذ‬

‫مالككص‪ :‬طىخرو ‪OpenCv‬ؤرسم رلىخيل ‪ 40X‬مُش من ‪ًًٍ ، np.histogram‬ى خٓظهمٍ طىخرو موظزص ‪OpenCv‬‬
‫ننً َٓم خملوؿـ خًزٌدين ًٌطىَش‪.‬‬
221 ‫ ببساطة‬OpenCv

ُ :Plotting Histogramsُ‫ سظمُاملخؼؽُامثٌبين‬
:‫هندن ؾًُلظٍن ًٌُٓم‬
.Matplotlib ‫ ردٓظوًخَ طىخرو خًُٓم يف‬:‫ ؾًُلص كطًنش‬
.OpenCv ‫ ردٓظوًخَ طىخرو خًُٓم يف‬:‫ ؾًُلص ؾىًٌص‬
‫ذ‬

‫ ذ‬:Matplotlib‫ اؾردمذبادتخدامذ‬-1

:‫طدرو ؿدهّ ًُٓم خملوؿؿدض خًزٌدنٌص‬Matplotlib ‫طىفُ ًند موظزص‬
‫ وال نلظدؾ‬،‫ هٍخ خًظدرو ًىؿً مزدٌسش خملوؿـ خًزٌدين وًُٓمه‬.matplotlib.pyplot.hist()
.‫ ًُٓم خملوؿـ خًزٌدين‬np.histogram ‫ وال‬cv2.calcHist َ‫الٓظوًخ‬

:‫شدهً خًوىي خًظديل‬
import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('home.jpg',0)

plt.hist(img.ravel(),256,[0,256])
#plt.imshow(img, cmap = 'gray')
plt.show()
‫ذ‬

ُ :‫امنرٌعخ‬

‫ذ‬
‫‪222‬‬ ‫‪ OpenCv‬ببساطة‬

‫ٌنونى ؤًػد خٓظوًخَ خًُٓم خًهديي يف ‪ًُٓMatplotlib‬م خملوؿؿدض خًزٌدنٌص ًٌطىَ خملٌىنص ‪.‬‬
‫ٓظلظدؾ يف خًزًخًص بًـدي رٌدندض خملوؿـ خًزٌدين‪ ،‬هٌل يف خًوىي خًظديل‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪from matplotlib import pyplot as plt‬‬

‫)'‪img = cv2.imread('home.jpg‬‬
‫)'‪color = ('b','g','r‬‬
‫‪for i,col in enumerate(color):‬‬
‫)]‪histr = cv2.calcHist([img],[i],None,[256],[0,256‬‬
‫)‪plt.plot(histr,color = col‬‬
‫)]‪plt.xlim([0,256‬‬
‫ذ‬ ‫)(‪plt.show‬‬

‫امنرٌعخ‪:‬‬

‫رةمودنى خًظللم من خًطىَش خًٔدرلص رلٌؽ ٓظـً خًٌىن خألَِق نٔزظه ندًٌص رٔزس خًٌٔلء‬
‫‪ -2‬اؾردمذبادتخدامذ‪ :OpenCv‬ذ‬

‫تطبققذاؾؼـاعذ‪ :Application of Mask‬ذ‬

‫ًلً خٓظوًمند فٌٌل ٓزم خًظدرو )(‪ cv2.calcHist‬إلًـدي خملوؿـ خًزٌدين ًودمٍ خًطىَش‪ ،‬ؤمد بٌخ‬
‫ؤَيند بًـدي خملوؿـ خًزٌدين ملنؿلص ملًيش فهٌٌى بنشدء ضىَش رٌػدء (خًلندم) يف مودن خملنؿلص‬
‫خًظٍ نًًُ َٓم خملوؿـ خًزٌدين ًهد‪ ،‬وخملندؾم خًزدكٌص من خًطىَش نـهٌهد ٓىيخء‪ .‬ػم منَُ هٍخ‬
‫خًلندم‪( .‬شدهً خًطىَش خًظدًٌص)‬
223 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('home.jpg',0)
# create a mask
mask = np.zeros(img.shape[:2], np.uint8)
mask[100:300, 100:400] = 255
masked_img = cv2.bitwise_and(img,img,mask = mask)
# Calculate histogram with mask and without mask
# Check third argument for mask
hist_full = cv2.calcHist([img],[0],None,[256],[0,256])
hist_mask = cv2.calcHist([img],[0],mask,[256],[0,256])

plt.subplot(221), plt.imshow(img, 'gray')
plt.subplot(222), plt.imshow(mask,'gray')
plt.subplot(223), plt.imshow(masked_img, 'gray')
plt.subplot(224), plt.plot(hist_full), plt.plot(hist_mask)
plt.xlim([0,256])

plt.show()

ُ :‫امنرٌعخ‬
‫ وخملوؿـ خًزٌدين خألهٍص ٌنؼٍ خملوؿـ‬،‫خملوؿـ خًزٌدين خألَِق ٌنؼٍ خملوؿـ خًزٌدين ًوٍ خًطىَش‬
.‫خًزٌدين ملنؿلص خًلندم‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

ُ :‫مشاظؼُبطبفٌخ‬
Cambridge in Color website
‫‪224‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذعىًخُاملخؼؽُامثٌبينُ‪ُ Histogram Equalization‬‬
‫امهذف‪ُ :‬‬
‫يفذفذاذاؾؼدم‪ :‬ذ‬

‫ٓنظهٌم مد هى مفهىَ طٔىًص خملوؿـ خًزٌدين‪ ،‬وهٌف نٔظوًمه ًظلٍٔن طزدًن خًطىَش‪.‬‬
‫ذػشًف‪ُ :‬‬
‫طٔىًص خملوؿـ خًزٌدين (طٔىًص خًهٌٔظىيُخَ)‪ :‬هٍ ؾًُلص مهدًـص خًطىَش ًػزـ خًظزدًن ردٓظوًخَ‬
‫خملوؿـ خًزٌدين ًٌطىَش‪.‬‬
‫نظشحُغبمخ‪ُ :‬‬
‫فٌٌون ًًًند ضىَش كٌم رٌؤالطهد مظـمهص يف نلؿص وخكًش يف خًطىَش‪ ،‬مؼال خًطىَش خًالمهص كٌم‬
‫رٌؤالطهد مظـمهص ردملندؾم ندًٌص خًلمم‪ ،‬وًون خًطىَش خًـًٌش متٌى طىِند منظكم ًٌلٌم‪ ،‬وًًٍى‬
‫نلظدؾ ًنٍس طٌى خًلٌم نىل مـدي ؤوٓو‪ ،‬وهٍخ ًايي ًظلٍٔن طزدًن خًطىَش‪.‬‬

‫ذ‬

‫ذ‬

‫ًٌمًًّ من خًظفدضٌٍ ٌنونى ًِدَش ضفلص وًوٌزًًٌد ‪ Histogram Equalization‬ؤمد هند فٔىف‬
‫نشدهً طؿزٌم طٔىًص خملوؿـ خًزٌدين نن ؾًُم موظزظٍ ‪ Numpy‬و‪.OpenCv‬‬

‫يف خًزًخًص ٓنؿزم طٔىًص خملوؿـ خًزٌدين ردالٓظهدنص مبوظزص ‪ Numpy‬هٌل يف خًوىي خًظديل‪:‬‬
225 ‫ ببساطة‬OpenCv

import cv2
import numpy as np :‫شرح‬
from matplotlib import pyplot as plt
flatten()
img = cv2.imread('wiki.jpg',0)
hist,bins = np.histogram(img.flatten(),256,[0,256]) cumsum()

cdf = hist.cumsum()
cdf_normalized = cdf * hist.max()/ cdf.max()

plt.plot(cdf_normalized, color = 'b')
plt.hist(img.flatten(),256,[0,256], color = 'r')
plt.xlim([0,256])
plt.legend(('cdf','histogram'), loc = 'upper left')
plt.show()
‫ذ‬

‫ ونلن رلدؿص‬،ً‫ننً مشدهًش خملوؿـ خًزٌدين ٓظـً ؤن خملوؿـ ًظمىغو يف خملنؿلص خألهًت بٌسخكد‬
‫ ًًٍى نلن رلدؿص ًظدرو ًلىَ رظىًِو خًزٌؤالض نىل هدمٍ خملنؿلص رًي َٓم‬،‫ًودمٍ خًؿٌف‬
.‫خًزٌؤالض يف خملنؿلص خألهًت ٓؿىند‬
‫ ونؿزم نالكدض طٔىًص خملوؿـ‬،)0 ‫وخآلن نٌٌند خًزلؽ نن ؤهفؼ نلؿص يف خملوؿـ خًزٌدين (مد نًخ‬
‫ وٌنونند ؤًػد خٓظوًخَ مفهىَ مطفىفص خًلندم يف‬،‫خًزٌدين هٌل هى مٍسوق يف ضفلص وقؽقبقدقا‬
:‫ كٌؽ طـُي خًهمٌٌدض فلـ نىل خًهندرص يًن خمللنهص وًٌى هٌل ًًل‬،Numpy
‫ذ‬
cdf_m = np.ma.masked_equal(cdf,0) :‫شرح‬
cdf_m = (cdf_m - cdf_m.min())*255.0/(cdf_m.max()-cdf_m.min()) ‫اآلنذأصبحذ‬
np.ma.masked_equal()
cdf = np.ma.filled(cdf_m,0).astype('uint8')
‫ؾدقـاذجدولذ‬
np.ma.filled()
‫‪226‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًزلؽ خًٍي ًهؿٌند مهٌىمدض نن كٌمص هٍ رٌؤٍ يف ضىَش خًوُؾ ردًنٔزص ًوٍ كٌمص رٌؤٍ يف‬
‫ضىَش خًًهٍ‪ٓ .‬نؿزم نمٌٌص خًظلىًٍ وًٌى هٌل ًًل‪:‬ذ ذ‬

‫]‪img2 = cdf[img‬‬
‫ذ‬

‫خآلن رةمودنند كٔدذ خملوؿـ خًزٌدين وخًـ ‪cdf‬هٌل ٓزم‪ ،‬وخًنظٌـص ٓظزًو هٌل ًًل‪.‬‬

‫ذ‬

‫هندن مٌّش مهمص وهٍ رإن خًطىَش كظى وًى هدنع ؤيمم‪ ،‬فٔنلطٍ ردًنهدًص نىل نفٕ خًنظٌـص‪ ،‬ؤي‬
‫ٌنونند خٓظوًخمه هٍسوؽ بغدءش مُؿهٌص‪ ،‬وهى مفًٌ يف نًش كدالض‪ ،‬مؼال يف خًظهُف نىل خًىؿىه‬
‫وكزٍ ؤن نإهٍ نٌندض من ضىَش خًىؿه ًٌظهُف نىل خًىؿه نلىَ رظٔىًص خملوؿـ خًزٌدين ًٌطىَش‬
‫ًٌلطىي نىل ضىَش وخغلص ًٌظهُف نىل خًىؿه يف قُوف خإلغدءش خملوظٌفص‪.‬‬
‫‪ ‬املخؼؽُامثٌبينُاملرىاصنُيفُ‪ُ :OpenCV‬‬
‫موظزص ‪OpenCV‬طىفُ ًند خًظدرو )(‪ cv2.equalizeHist‬خًٍي يهٌه هى ضىَش َمديًص وًهؿٌند يف‬
‫خًوُؾ نفٕ خًطىَش وًون رظزدًن ًىين ؤوغم‪.‬‬
‫خًوىي خًظديل ًىغم ًٌى‪:‬‬
‫ذ‬

‫)‪img = cv2.imread('wiki.jpg',0‬‬
‫)‪equ = cv2.equalizeHist(img‬‬
‫‪res = np.hstack((img,equ)) #stacking images side-by-side‬‬
‫)‪cv2.imwrite('res.png',res‬‬
‫‪227‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫ٌنونى خآلن ؤهٍ نًش ضىَ رٍسوؽ بغدءش موظٌفص وطؿزم نٌٌهم طدرو طٔىًص خملوؿـ خًزٌدين‬
‫)(‪ً cv2.equalizeHist‬ظلٍٔن خًطىَش‪ ،‬وطللم من خًنظٌـص‪.‬‬
‫ؾًُلص طٔىًص خملوؿـ خًزٌدين طهمٍ رشوٍ ؿًٌ ننًمد ًوىن طىِم خًشًش خًٌىنٌص ًزٌؤالض خًطىَش‬
‫ملطىَ يف منؿلص مهٌنص‪ ،‬وًن طهمٍ رشوٍ ؿًٌ يف خألمدهن خًظٍ ًىؿً فٌهد خهظالف هزًن يف‬
‫خًشًش خًٌىنٌص‪.‬‬
‫‪(ُCLAHE ‬ذعىًخُاملخؼؽُامثٌبينُروُامرثبًنُاملؽذ ُودُواملركٌف)‪ُ ُ:‬‬
‫)‪CLAHE (Contrast Limited Adaptive Histogram Equalization‬‬
‫خًظٔىًص خًٔدرلص ًٌموؿـ خًزٌدين طإهٍ رهٍن خالنظزدَ خًظزدًن خًوًل ًٌطىَش‪ ،‬وًون ؤكٌدند كً ال طهمٍ‬
‫مهند‪ ،‬فدًطىَش خًظدًٌص طكهُ ضىَش خًًهٍ وهُؿهد رهً خًظٔىًص خًشدمٌص ًٌموؿـ خًزٌدين‪ :‬خًوٌفٌص‬
‫كً طوىن طلٔنع يف خًطىَش خًٔدرلص‪ ،‬وًون مالمم خًىؿه طزًو مملٌص‪ ،‬وهٍخ ألن طٔىًص خملوؿـ‬
‫خًزٌدين ًٌٔع مُهّش نىل منؿلص وخكًش هٌل ٓزم‪.‬‬

‫ذ‬ ‫ذ‬

‫ذ‬
‫‪228‬‬ ‫‪ OpenCv‬ببساطة‬

‫ًلٍ هٍه خملشوٌص نٔظوًَ طٔىًص خملوؿـ خًزٌدين خملظوٌفص‪ ،‬وًٌى رظلٌٔم خًطىَش ملوهزدض‬
‫(خفرتخغٌد كٌدْ خملوهس ‪ 8X8‬يف ‪ )OpenCV‬ػم هٍ موهس يف خًطىَش ًظم طٔىًص خملوؿـ خًزٌدين‬
‫ًه نىل كًي‪ ،‬كٌؽ نالكل رإنه ًإهٍ رهٍن خالنظزدَ هٍ ؿّء من خًطىَش ًىكًه‪.‬‬
‫يف كدًص وؿىي غـٌف‪ ،‬نؿزم كً ًٌظزدًن‪ ،‬فةٌخ هدن خملوؿـ ؤنىل من كً خًظزدًن خمللًي (خفرتخغٌد‬
‫‪ 40‬يف ‪ً )OpenCV‬ظم كظ هٍه خًزٌؤالض وطىًِههد رشوٍ منظكم نىل خملوهزدض خألهُي كزٍ‬
‫طؿزٌم نمٌٌص طٔىًص خملوؿـ‪.‬وؤهًنخ ًظم بؿُخء نمٌٌص خالٓظٌفدء خًؼنديئ خًوؿٍ نىل خًلًوي ًظنهٌم‬
‫خالنظلدي‪ .‬خًوىي خًظديل ًهُع ؾًُلص طؿزٌم ‪ CLAHE‬يف ‪:OpenCV‬‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬
‫)‪img = cv2.imread('tsukuba_l.png',0‬‬

‫‪# create a CLAHE object (Arguments are optional).‬‬
‫))‪clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8‬‬
‫)‪cl1 = clahe.apply(img‬‬
‫)‪cv2.imwrite('clahe_2.jpg',cl1‬‬
‫ذ‬

‫ذ‬

‫وهٌل نُي يف خًنظٌـص رإن طفدضٌٍ خًىؿه كً طلٔنع‪.‬‬
‫مشاظؼُبطبفٌخ‪ُ :‬‬
‫‪Wikipedia page on Histogram Equalization‬‬ ‫‪‬‬
‫‪Masked Arrays in Numpy‬‬ ‫‪‬‬
‫?‪How can I adjust contrast in OpenCV in C‬‬ ‫‪‬‬
‫?‪How do I equalize contrast & brightness of images using OpenCV‬‬ ‫‪‬‬
‫‪229‬‬ ‫‪ OpenCv‬ببساطة‬

‫املخؼؽُامثٌبينُشنبيئُامثػذُ(‪)2D Histograms‬‬
‫امهذف‪ُ :‬‬
‫يف هٍه خًىكًش ٓنظهٌم بًـدي وَٓم خملوؿـ ػنديئ خًزهً‪ٌٓ .‬فًٌند يف خًفطىي خًلديمص‪.‬‬
‫ملذمخ‪ُ :‬‬
‫يف خًٔدرم ؤوؿًند وَٓمند خملوؿـ خًزٌدين ؤكديي خًزهً (ًٔمى ؤكديي خًزهً ألنه ًإهٍ فلـ‬
‫هدضٌص وخكًش مؼٍ كٌمص شًش خًظًَؾ خًُمديي ًٌزٌؤٍ)‪ ،‬ؤمد كدًٌد فٔنزلؽ نن هدضٌظٍن ًُٓمهد‬
‫رشوٍ ػاليث خألرهدي‪ .‬طٔظهمٍ نديش إلًـدي خملوؿؿدض خًزٌدنٌص ًلًىخن كٌؽ طوىندن كٌمص خًـظًَؾ‬
‫خًٌىين وخًظشزو ًوٍ رٌؤٍ‪.‬‬
‫‪ ‬املخؼؽُامثٌبينُ‪ُ2D‬يفُ‪ُ :OpenCv‬‬
‫ًلٔس رزٔدؾص ؿًخ ً من هالي خًظدرو خًظدرو )(‪ٓ .cv2.calcHist‬نلظدؾ ًظلىًٍ خًطىَش من خًفػدء‬
‫‪ BGR‬بىل ‪( HSV‬طٍهُ يف خملوؿـ خًزٌدين ‪ 1D‬هند نلىي من خًفػدء ‪ BGR‬بىل خملٔظىي‬
‫خًُمديي‪ .)GRY‬وهند ردَخمرتخض خًظدرو )(‪ٓ cv2.calcHist‬ظوىن هدًظديل‪:‬‬
‫‪ :channels = [0,1] ‬ألنند رلدؿص ًلندطٍن ‪ H‬و ‪.S‬‬
‫‪ًٌ180 :bins = [180,256] ‬مٔظىي ‪ H‬و ‪ًٌ 256‬مٔظىي ‪.S‬‬
‫‪ :range = [0,180,0,256] ‬كٌمص خًظًَؾ خًٌىين ‪Hue‬طوىن رٍن ‪0‬و ‪ ،180‬رٌنٌل كٌمص‬
‫خإلشزدم طوىن رٍن خًـ ‪0‬و ‪.256‬‬

‫شبهذُامكىدُامربيل‪ُ :‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫)'‪img = cv2.imread('home.jpg‬‬

‫)‪hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV‬‬
‫)]‪hist = cv2.calcHist([hsv], [0, 1], None, [180, 256], [0, 180, 0, 256‬‬
‫ذ‬

‫‪ ‬املخؼؽُامثٌبينُ‪ُ2D‬يفُ‪ُ :Numpy‬‬
‫ًًي موظزص ‪ Numpy‬ؤًػد طدرو ًٌلٔدذ وهى )(‪( np.histogram2d‬طٍهُ رإنه يف خملوؿـ‬
‫خًزٌدين ‪ 1D‬خٓظهمٌند خًظدرو )(‪.)np.histogram‬‬
‫‪230‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪from matplotlib import pyplot as plt‬‬
‫)'‪img = cv2.imread('home.jpg‬‬

‫)‪hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV‬‬
‫)]]‪hist, xbins, ybins = np.histogram2d(h.ravel(),s.ravel(),[180,256],[[0,180],[0,256‬‬
‫ذ‬

‫ؤوي مظًًن ًهٍخ خًظدرو هى خملٔظىي ‪ ،H‬وخملظًًن خًؼدين هى خملٔظىي ‪ ،S‬وخًؼدًؽ هى نًي خًـ ‪،BIN‬‬
‫وخًُخرو مـدًهد‪ .‬وخآلن ٓننظلٍ ًٌوؿىش خًظدًٌص وهٍ ؾًُلص َٓم خملوؿؿدض خًزٌدنٌص ‪.2D‬‬

‫‪ ‬سظمُاملخؼؼبدُامثٌبنٌخُشنبئٌخُامثػذُ(‪ُ :)Plotting 2D Histograms‬‬
‫اؾطرقؼةذاألوىلذبادتخدامذ)(‪:cv2.imshow‬‬

‫مبد ؤن خًنظٌـص هٍ مطفىفص ػندثٌص خًزهً فًٌٍى ٌنون نُغهد هطىَش َمديًص ردٓظوًخَ خًظدرو‬
‫خًٔدرم‪ ،‬وًون ًن نلطٍ نىل فوُش هزًنش نن خألًىخن بال بٌخ هند نىل نٌم رلٌم خًظًَؾ )‪ً (Hue‬لًىخن‬
‫خملوظٌفص‪.‬‬

‫اؾطرقؼةذاؾثاـقةذبادتخدامذؿؽتبةذ‪:Matplotlib‬ذ‬

‫ٌنونند خٓظوًخَ خًظدرو )(‪ًُٓ plt.imshow‬م خملوؿـ خًزٌدين ػنديئ خًزهً رإشودي موظٌفص‪ ،‬مٌل‬
‫ٌٓهؿٌند فوُش ؤفػٍ نن شًش خًزٌؤالض خملوظٌفص‪ ،‬وًون ًن ًهؿٌند فوُش هدفٌص نن خألًىخن من ؤوي‬
‫نكُش بال بٌخ هند نهُف كٌمص خًظًَؾ ًلًىخن خملوظٌفص‪ .‬ومو ًٌى ًفػٍ خٓظهٌلي هٍه خًؿًُلص فهٍ‬
‫ؤفػٍ وؤرٔـ‪.‬‬

‫مالككص‪ :‬ننً خٓظوًخَ هٍخ خًظدرو طٍهُ وغو خملظًًن ‪ nearest‬يف خًهٌم ‪ًٌ interpolation‬لطىي نىل نظدثف‬
‫ؤفػٍ ('‪.)interpolation = 'nearest‬‬
‫ذ‬
‫‪231‬‬ ‫‪ OpenCv‬ببساطة‬

‫شدهً خًوىي خًظديل‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪from matplotlib import pyplot as plt‬‬
‫)'‪img = cv2.imread('home.jpg‬‬

‫)‪hsv = cv2.cvtColor(img,cv2.COLOR_BGR2HSV‬‬
‫) ]‪hist = cv2.calcHist( [hsv], [0, 1], None, [180, 256], [0, 180, 0, 256‬‬

‫)'‪plt.imshow(hist,interpolation = 'nearest‬‬
‫)(‪plt.show‬‬
‫امنرٌعخ‪ُ :‬‬
‫خًطىَش خًظدًٌص هٍ ًٌطىَش خألضٌٌص مو موؿؿهد خًزٌدين خملٌىن‪ .‬خمللىَ ‪ً X‬هُع كٌمص ‪( S‬خإلشزدم)‪،‬‬
‫وخمللىَ ‪ً Y‬هُع كٌمص خًظًَؾ (‪.)Hue‬‬

‫يف خملوؿـ خًزٌدين نشدهً رهؼ خًلٌم خًهدًٌص طلًُزد ننً ‪ ، H=100 ,S=200‬وهٍخ ًلدرٍ ًىن‬
‫خًٌٔلء خألَِق‪ .‬وؤًػد ًىؿً هندن رهؼ خًلٌم كٌمظهد ندًٌص طلًُزد ننً ‪ ، H=25 , S=100‬وهٍخ‬
‫ًلدرٍ خًٌىن خألضفُ ًٌلرص‪.‬‬
‫اؾطرقؼةذاؾثاؾثةذبادتخدامذأدؾوبذاؾعقـاتذيفذ‪:OpenCv‬‬

‫وهى هٌل يف خملؼدي خًزٌٔـ خملُفم يف خملىكو خًٍي نطزع فٌه موظزص ‪ OpenCv‬غمن خملٔدَ‪.‬‬
‫"‪"C:\opencv\sources\samples\python2\color_histogram.py‬‬
‫‪232‬‬ ‫‪ OpenCv‬ببساطة‬

‫بٌخ شًٌع هٍخ خًوىي ٌنونى مشدهًش خملوؿـ خًزٌدين خًٍي ًهُع خألًىخن خملظىخفلص‪ ،‬وروٌٌلض‬
‫رٌٔؿص فهى ًوُؾ خًوىي خًٌىين ًٌموؿـ خًزٌدين‪ .‬خًنظٌـص ؿًٌش ؿًخ (نىل خًُيم من ؤنى طلظدؾ بىل‬
‫بغدفص مـمىنص بغدفٌص من خًوؿىؽ)‬

‫يف هٍخ خًوىي خملربمف ؤنشإ هًُؿص مٌىنص يف خًفػدء ‪ ،HSV‬ػم كىًهد ًٌفػدء ‪ .BGR‬نظٌـص ضىَش‬
‫خملوؿـ خًزٌدين طوىن مٍصورص رٌىن خًوًُؿص‪ .‬وخٓظوًَ ؤًػد رهؼ هؿىخض خملهدًـص إلِخًص‬
‫خًزٌؤالض خًطًًنش خملهّوًص‪ًٌ ،‬لطىي نىل موؿـ رٌدين ؿًٌ‪ٌ .‬نونى خًهىيش ًهٍخ خًربندمف‬
‫وطشًٌٌه وطلٌٌٌه‪ ،‬كٌؽ ٓظالكل رإنه ًهؿٍ ردًفهٍ خألًىخن خًللٌلٌص خملىؿىيش يف خًطىَش‪.‬‬

‫ذ‬

‫ٌنونى ؤن طُي يف خملوؿـ خًزٌدين رىغىق مد هٍ خألًىخن خملىؿىيش‪ ،‬فهندن خًٌىن خألَِق وخًٌىن‬
‫خألضفُ ورهؼ خًزٌدع رٔزس َكهص خًشؿُنف‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪233‬‬ ‫‪ OpenCv‬ببساطة‬

‫اإلظلبغُامخنفٍُمنمخؼؽُامثٌبينُ‪ُ Histogram Back projection‬‬
‫امهذف‪ُ :‬‬
‫يف هٍخ خًفطٍ ٓنظهٌم ؾًُلص بٓلدؽ خملوؿـ خًزٌدين نىل ضىَش هٌفٌص وفدثًطهد‪.‬‬
‫مػنىمبدُنظشًخ‪ُ :‬‬
‫طهًُف‪ back-projection‬يف نٌم خًظطىًُ‪:‬‬
‫هى بٓلدؽ خًطىَش نىل هٌفٌص شدشص نطف شفدفص ًٌظم‬
‫نُغهد هٌل يف فٌٌم خًظطىًُ‪ ،‬ؤو إلٓظوًخمهد هوٌفٌص يف‬
‫خًظطىًُ‪.‬‬
‫ذ‬

‫ٓنظٔظهمٍ هٍه خًظلنٌص ًظلؿٌو خًطىَش ؤو إلًـدي خألؿٔدَ خملهمص يف خًطىَش‪.‬‬
‫روٌٌلض رٌٔؿص‪ ،‬طهظمً هٍه خًوىخَِمٌص نىل بنشدء ضىَش رنفٕ كٌدْ ضىَش خًًهٍ (وًون رلندش‬
‫وخكًش)‪ ،‬رلٌؽ هٍ رٌؤٍ فٌهد ًظىخفم مو خكظٌلي ؤن ًنظمٍ ًٌـٔم خملؿٌىذ‪ .‬روٌٌلض ؤهًت‬
‫رٔدؾص‪ ،‬ضىَش خًوُؾ ٌٓوىن فٌهد خًـٔم خملؿٌىذ ؤهًت رٌدغدً ردًنٔزص ًزدكٍ ؤؿّخء خًطىَش‪.‬‬

‫ًٔظوًَ خإلٓلدؽ خًوٌفٍ ًٌموؿـ خًزٌدين مو هىخَِمٌص مالكلص خألؿٔدَ ‪ٌٓ( Camshift‬ظم ٌسق‬
‫هىخَِمٌص ‪ Camshift‬الكلدً)‪.‬‬

‫كٌفُنعرؼٌؼُاملٌبوُتبمخؼىادُامرٍُرشؼنبهبُظبتل ُبً؟ُ ُ‬
‫ننشإ موؿـ رٌدين ًٌطىَش خًظٍ طلىي نىل خًـٔم خملؿٌىذ (يف ضىَطند خألؿٔدَ هٍ خألَع‬
‫وخًالنس وخًٌٔلء) (يف خًطىَش خًظدًٌص نٌند خألَع رإنهد خًـٔم خملؿٌىذ)‪ ،‬خًـٔم ًـس ؤن ٌنل‬
‫خًطىَش كظى نلطٍ نىل ؤفػٍ نظٌـص‪ ،‬وًفػٍ خٓظهٌلي خملوؿـ خًزٌدين خملٌىن(‪ )2D‬رًالً من‬
‫خملوؿـ خًُمديي(‪ ،)1D‬ألن ًىن خًـٔم ؤفػٍ ؾًُلص ًظلًًً خًـٔم ملدَنص مو شًش خًٌىن‬
‫خًُمديي‪.‬‬
‫ػم نلىَ رةٓلدؽ خملوؿـ خًزٌدين ًطىَش خًـٔم هٌفٌد نىل ضىَش خالهظزدَ (خًظٍ نلن رلدؿص ألن‬
‫نـً خًـٔم فٌهد)‪ .‬روٌٌلض ؤهُي ٓنلٔس خكظٌلي خنظٌلء هٍ رٌؤٍ ًلَع ونهُغه‪ ،‬ورهً ًٌى‬
‫رهمٌٌص خًظهظٌس نلطٍ نىل خألَغٌص ًىكًهد‪.‬‬
‫‪234‬‬ ‫‪ OpenCv‬ببساطة‬

‫يف خًطىَش خًظدًٌص خٓظهمٌع خملنؿلص خًظٍ رًخهٍ خملٔظؿٌٍ خألَِق ههٌنص رٌٔؿص (خًـٔم‬
‫خملؿٌىذ)‪ ،‬وؤَيض ؤن خٓظوُؾ هدمٍ خألَغٌص نن ؾًُم هٍ خًهٌنص ردٓظوًخَ هىخَِمٌص خإلٓلدؽ‬
‫خًوٌفٍ‪.‬‬

‫ذ‬

‫‪ ‬خىاسصمٌخُاإلظلبغُامخنفٍُيفُ‪ُ :Numpy‬‬
‫يف خًزًخًص نلظدؾ ؤن نلٔس خملوؿـ خًزٌدين‬
‫خملٌىن ًٌـٔم خًٍي نًًُ بًـديه (وًٌون ’‪)‘M‬‬
‫وخًطىَش خًظٍ نًًُ خًزلؽ فٌهد نن خًـٔم‬
‫(وًظون ’‪.)‘I‬‬
235 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt

#roi is the object or region of object we need to find
roi = cv2.imread('rose_red.png')
hsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV)

#target is the image we search in
target = cv2.imread('rose.png')
hsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV)

# Find the histograms using calcHist. Can be done with np.histogram2d also
M = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )
I = cv2.calcHist([hsvt],[0, 1], None, [180, 256], [0, 180, 0, 256] )

‫ هٌىكص وبنشدء‬R َ‫ ؤي خٓظوًخ‬،R ‫ نىل‬backproject ‫ ػم نلىَ رهمٌٌص‬، ‫ػم نىؿً خًنٔزص‬
‫ ؤي‬،‫ضىَش ؿًًًش فٌهد هٍ رٌؤٍ ملظمٍ ؤن ًوىن مؿدرم ًٌهًف‬

‫ متؼٍ خإلشزدم خًٌىين‬S‫ و‬،(x,y) ‫) متؼٍ خًظًَؾ خًٌىين ًٌزٌؤٍ خًٍي بكًخػٌدطه‬hue( h‫كٌؽ‬
. ‫ رهً ًٌى نؿزم خًٍسؽ‬.(x,y) ٍٔ‫ًٌزٌو‬
R = M/(I+1)
ravel()
h,s,v = cv2.split(hsvt) reshape()
B = R[h.ravel(),s.ravel()]
B = np.minimum(B,1)
B = B.reshape(hsvt.shape[:2])
‫ذ‬

ٍ‫ متؼ‬D ‫كٌؽ‬ ‫خآلن نؿزم نمٌٌص خًٌف (خًؿٍ) مو كندم نىل شوٍ كُص يخثُي‬
.‫خًلندم خًلُيص‬
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
cv2.filter2D(B,-1,disc,B) getStructuringElement()
B = np.uint8(B)
cv2.normalize(B,B,0,255,cv2.NORM_MINMAX) cv2.normalize()
‫‪236‬‬ ‫‪ OpenCv‬ببساطة‬

‫خآلن نلطٍ نىل مودن خًـٔم نن ؾًُم ؤنكم شًش ًىنٌص ُمهؿى ًٌـٔم‪ ،‬ورهًهد ٌنونند خًلٌدَ‬
‫ردًظهظٌس ًٌلطىي نىل نظدثف ؤفػٍ‪.‬‬
‫)‪ret,thresh = cv2.threshold(B,50,255,0‬‬

‫هٍخ هى هٍ خألمُ!!‬

‫ذ‬

‫ذ‬

‫ذ‬
237 ‫ ببساطة‬OpenCv

ُ :OpenCvُ‫ خىاسصمٌخُاإلظلبغُامخنفٍُيف‬
‫ ردَومرتخطه طلًُزد هٍ نفٕ خًظدرو‬،cv2.calcBackProject() ‫خًظدرو‬OpenCv ‫طىفُ ًند‬
ٍ‫ وًـس طهًًٌه كز‬،‫ ؤكً ردَومرتخطه هى خملوؿـ خًزٌدين ًٌـٔم خملُخي بًـديه‬.cv2.calcHist()
َُ‫ رهً ًٌى ًـس نٌٌند ؤن من‬.‫ ًهًٌ هٍخ خًظدرو خًطىَش خمللظمٌص‬.ٍ‫متًُُه ًظدرو خإلٓلدؽ خًوٌف‬
:‫ خًوىي خًظديل ًىغم ًٌى‬.‫كندم كُيص نىل خًطىَش ػم نؿزم نمٌٌص خًظهظٌس‬

import cv2
import numpy as np

roi = cv2.imread('rose_red.png')
hsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV)

target = cv2.imread('rose.png')
hsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV)

# calculating object histogram
roihist = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256] )

# normalize histogram and apply backprojection
cv2.normalize(roihist,roihist,0,255,cv2.NORM_MINMAX)
dst = cv2.calcBackProject([hsvt],[0,1],roihist,[0,180,0,256],1)

# Now convolute with circular disc
disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5))
cv2.filter2D(dst,-1,disc,dst)

# threshold and binary AND
ret,thresh = cv2.threshold(dst,50,255,0)
thresh = cv2.merge((thresh,thresh,thresh))
res = cv2.bitwise_and(target,thresh)

res = np.vstack((target,thresh,res))
cv2.imshow('res',res) , cv2.waitKey(0), cv2.destroyAllWindows()

‫ذ‬

‫ذ‬
‫‪238‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامكىد‪ُ :‬‬
‫)'‪roi = cv2.imread('rose_red.png‬‬
‫)‪hsv = cv2.cvtColor(roi,cv2.COLOR_BGR2HSV‬‬
‫ذ‬

‫كمند رظوًّن ضىَش خًـٔم خملؿٌىذ (خًىَيش خًلمُخء) يف خملظًًن ‪ ،roi‬ػم كىًند خًطىَش من خًفػدء‬
‫‪ RGB‬بىل ‪ًٔ HSV‬هىًص خًظهدمٍ مو هٍخ خًفػدء خًٌىين‪.‬‬
‫)'‪target = cv2.imread('rose.png‬‬
‫)‪hsvt = cv2.cvtColor(target,cv2.COLOR_BGR2HSV‬‬
‫ذ‬

‫ػم كمند رظوًّن خًطىَش خًهًف ؤي خًطىَش خًظٍ ٓنزلؽ فٌهد نن خًـٔم (ضىَش خًىَوي) يف خملظًًن‬
‫‪ ،target‬ػم كىًند خًطىَش من خًفػدء ‪ RGB‬بىل ‪ًٔ HSV‬هىًص خًظهدمٍ مو هٍخ خًفػدء خًٌىين‪.‬‬
‫‪# calculating object histogram‬‬
‫) ]‪roihist = cv2.calcHist([hsv],[0, 1], None, [180, 256], [0, 180, 0, 256‬‬
‫ذ‬

‫رهً ًٌى كمند رظهٌجص خملوؿـ خًزٌدين ًٌطىَش خًـٔم خملؿٌىذ وًٌى نن ؾًُم خًظدرو‬
‫)(‪.cv2.calcHist‬‬
‫‪# normalize histogram and apply backprojection‬‬
‫)‪cv2.normalize(roihist,roihist,0,255,cv2.NORM_MINMAX‬‬
‫ذ‬

‫)‪dst = cv2.calcBackProject([hsvt],[0,1],roihist,[0,180,0,256],1‬‬
‫ذ‬

‫هند كمند رهمٌٌص خالٓلدؽ نىل خًوٌفٌص نن ؾًُم خًظدرو ‪ . calcBackProject‬ردَخمرتخطه هٍ‪:‬‬
‫‪cv2.calcBackProject(images, channels, hist, ranges, scale[, dst]) → dst‬‬
‫‪ ‬خملظًًن خألوي ‪ً :images‬لًي ضىَ خًًهٍ (هند مَُند فلـ ضىَش وخكًش وهٍ خًطىَش‬
‫خًهًف خًظٍ ٓنزلؽ فٌهد نن خًـٔم)‪ ،‬وخًظٍ ًـس ؤن طوىن رنفٕ خًلـم ونفٕ خًهمم‬
‫خًٌىين ‪.CV_8U or CV_32F‬‬
‫‪ ‬خملظًًن خًؼدين ‪ً channels‬لًي خًلنىخض خًظٍ ٌٓؿزم نٌٌهد نمٌٌص خالٓلدؽ نىل خًوٌفٌص‬
‫(‪.)back projection‬‬
‫‪ ‬خملظًًن خًؼدًؽ ‪ٓ :hist‬نمَُ ًه خملوؿـ خًزٌدين ًطىَش خًـٔم خملؿٌىذ‪.‬‬
‫‪239‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬خملظًًن خًُخرو ‪ٓ range‬نمَُ ًه كًوي ؤرهديخملوؿـ خًزٌدين‪.‬‬
‫‪ ‬خملظًًن خًودمٕ [ ‪( :scale‬خهظٌدَي) ندمٍ طلًًً خًلـم ًنظٌـص نمٌٌص خالٓلدؽ نىل‬
‫خًوٌفٌص‪.‬‬
‫‪ ‬خًظدرو ‪ً calcBackProject‬لٔس خالٓلدؽ خًوٌفٍ ًٌموؿـ خًزٌدين‪ .‬وهى مشدره ًٌظدرو‬
‫‪ calcHist‬خًٍي ًىؿً خملوؿـ خًزٌدين ننً هٍ مىغو )‪ (x,y‬كٌؽ خًظدرو ًـمو خًلٌم من‬
‫خًِب (‪ًٌ )BIN‬موؿـ خًزٌدين ًٌطىَش‪ .‬وًون‬
‫خًلنىخض خًٌىنٌص خملوظدَش ًطىَش خًًهٍ‪ ،‬وًىؿً ِ ْ‬
‫هند رًي ًِديش نًي خًِب‪ ،‬خًظدرو ًلُؤ كٌم خًِب‪ ،‬وًـًوًهد كٔس خًلـم‪ ،‬وًوّنهد يف )‪.(x,y‬‬

‫ٌنونى بًـدي وطهلس خألؿٔدَ ٌو خًٌىن خًّخهٍ يف خملشهً من هالي خطزدم مد ًًل‪:‬‬
‫‪ .8‬كزٍ طهلس خًـٔم نلىَ رظطىًُ خًـٔم خملؿٌىذ طهلزه ردًودمًنخ رلٌؽ ًًؿٍ ؤهرب مٔدكص‬
‫من خًطىَش خملٌظلؿص‪ .‬ػم نلىي ضىَش خًـٔم خًظٍ خًظلؿندهد ًٌفػدء ‪ HSV‬ونلٔس خملوؿـ‬
‫خًزٌدين ًٌطىَش غمن خًلندش ‪ .)hue( H‬كً ًظػمن خملوؿـ خًزٌدين نلدؽ كىش وًٌى كٔس ًىن‬
‫خًـٔم خًٔدثً‪.‬‬
‫‪ .4‬ننً طهلس خًـٔم نلىي هٍ ؤؾدَ ضىَش (‪ )frame‬من خًفًًٌى خملٌظلـ من خًودمًنخ (خًٍي‬
‫ٓنزلؽ غمنه نن خًـٔم) بىل خًفػدء ‪ ،HSV‬ػم نىؿً خالٓلدؽ خًوٌفٍ ًوٍ ‪frame‬غمن‬
‫خًفػدء ‪ HSV‬وًٌى نن ؾًُم بؿُخء نمٌٌدض كٔدرٌص نىل خملوؿـ خًزٌدين ًطىَش خًـٔم‬
‫خملؿٌىذ‪ .‬ػم نلىَ رةؿُخء نمٌٌص خًظهظٌس نىل نظٌـص خالٓلدؽ خًوٌفٍ كظى نومً خألًىخن‬
‫خًػهٌفص‪ .‬وؤًػد ٌنون ؤن طومً خًزٌؤالض خًظٍ ًوىن بشزدنهد خًٌىين يًن هديف‪ ،‬هدًزٌؤالض‬
‫خًهدمتص ؿًخ ً ؤو خًٔدؾهص ؿًخ ً‪.‬‬
‫‪ .4‬نىؿً خألؿّخء خًظٍ ًىؿً رٌنهد طُخرـ يف ضىَش خًوُؾ‪ ،‬نىل ٌٓزٍ خملؼدي ؤهرب ؿّء‪.‬‬

‫هٍه خًوؿىخض طلًُزد طشزه هىخَِمٌص ‪ً Camshift‬ظهلس خًـٔم نن ؾًُم خًٌىن‪.‬‬

‫‪# Now convolute with circular disc‬‬
‫))‪disc = cv2.getStructuringElement(cv2.MORPH_ELLIPSE,(5,5‬‬
‫ذ‬
‫‪240‬‬ ‫‪ OpenCv‬ببساطة‬

‫يف هٍخ خألمُ ٓنلىَ رةنشدء كظدم كُيص وًٌى نن ؾًُم خًظدرو ‪ getStructuringElement‬كٌؽ‬
‫منَُ ًه خًشوٍ خًٍي نًًُه‪ .‬هند مَُند ًهٍخ خًظدرو شوٍ كؿو ندكظ (كُص)‪ ،‬وخملظًًن خًؼدين ًهٍخ‬
‫خًظدرو منَُ ًه كـم خًلندم‪.‬‬
‫)‪cv2.filter2D(dst,-1,disc,dst‬‬
‫ذ‬

‫هند ٓنلىَ ردالٓظهدنص ردًظدرو ‪ً cv2.filter2D‬رتشٌم خًطىَش وفلد ًٌلندم خًلُيص‪.‬‬
‫خملظًًن خألوي هى ضىَش خًًهٍ‪ ،‬وخًؼدين رلًي خًهمم خًٌىين ًطىَش خًوُؾ وبٌخ هدنع كٌمظه )‪(-1‬‬
‫ٓنلطٍ نىل ضىَش رنفٕ خًهمم خًٌىين ًطىَش خًًهٍ‪ ،‬وخملظًًن خًؼدًؽ ٌنؼٍ خًلندم خًٍي ًـس ؤن‬
‫ًوىن رلندش وخكًش مبطفىفص من خًنىم ‪.float‬‬
‫‪# threshold and binary AND‬‬
‫)‪ret,thresh = cv2.threshold(dst,50,255,0‬‬
‫))‪thresh = cv2.merge((thresh,thresh,thresh‬‬
‫)‪res = cv2.bitwise_and(target,thresh‬‬
‫ذ‬

‫وؤهًنخ ٓنلىَ رهمٌٌص طهظٌس خًطىَش خًندطـص نن خإلٓلدؽ نىل خًوٌفٌص إلهٌلي خألًىخن خًظٍ شًطهد‬
‫خًٌىنٌص غهٌفص‪.‬‬
‫))‪res = np.vstack((target,thresh,res‬‬
‫)(‪cv2.imshow('res',res) , cv2.waitKey(0), cv2.destroyAllWindows‬‬
‫ذ‬

‫خًظدرو )(‪ٓ np.vstack‬نٔظهمٌه ًـمو ػالػص ضىَ يف ضىَش وخكًش‪ ،‬ػم ٓنهُع خًنظٌـص غمن‬
‫ندفٍش‪ .‬ؤي ٓنهُع نظدثف ػالغ ضىَ يف ندفٍش وخكًش‪.‬‬
‫الفصل السادس‬

‫”النجاح ليس نتيجة لعدم ارتكاب أي أخطاء‪،‬‬
‫وللكنه نتيجة لعدم تكرار نفس الخطأ مرتين ‟‬
‫جورج برنارد شو ‪ -‬مؤلف أيرلندي شهير‪.‬‬
‫‪242‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُامعبدط‪ُ:‬ذؽىًالدُامصىسحُيفُ‪ُ OpenCV‬‬

‫حتوقلذػورققه‪:‬ذ‬

‫طهٌم بًـدي طلىًٍ فىًٌَه ًٌطىَش‪.‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪243‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذؽىًهُفىسًٌهُمنصىسحُ‪ُ Fourier Transform‬‬
‫امهذف‪ُ ُ:‬‬
‫بًـدي طلىًٍ فىًٌَه ًٌطىَش ردٓظوًخَ ‪.OpenCv‬‬ ‫‪‬‬
‫خالٓظفديش من طىخرو خًـ‪ FFT‬خملىؿىيش يف ‪.Numpy‬‬ ‫‪‬‬
‫خٓظوًخَ طلىًٍ فىًٌَه يف رهؼ خًظؿزٌلدض‪.‬‬ ‫‪‬‬
‫طهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪. cv2.idft()،cv2.dft () :‬‬ ‫‪‬‬
‫مػنىمبدُنظشًخ‪ُ :‬‬
‫ًٔظوًَ طلىًٍ فىًٌَه ًظلٌٌٍ هطدثظ خًرتيي ملوظٌف خملُشلدض‪.‬‬
‫يف خًطىَ ػندثٌص خًزهً ‪ًٔ 2D‬ظوًَ طلىًٍ فىًٌَه خملظلؿو ‪Discrete Fourier ( DFT‬‬
‫‪ )Transform‬إلًـدي خملـدي خًرتييي‪ .‬ؤرسم هىخَِمٌص ًلٔدذ طلىًٍ فىًٌَه هٍ ‪Fast ( FFT‬‬
‫‪ًٌ )Fourier Transform‬لطىي نىل طفدضٌٍ ؤهًت نن هٍخ خملىغىم ٌنونى كُخءش ؤي هظدذ ًظوٌم‬
‫نن مهدًـص خًطىَش ؤو خإلشدَش‪.‬‬

‫ٌنونند خنظزدَ ‪ f‬هى طُيي خإلشدَش‪ ،‬وبٌخ ؤهٍند‬ ‫ردًنٔزص ًإلشدَش خًـٌزٌص‬
‫مـدًهد خًرتييي رهٍن خالنظزدَ ٓرني ‪( spike‬خًًّديش خملفدؿإش يف خإلشدَش) يف طُيي خإلشدَش ‪ .f‬بٌخ‬
‫ؤهٍند نٌندض من خإلشدَش ًظشوٌٍ بشدَش مظلؿهص‪ٓ ،‬نلطٍ نىل نفٕ خملـدي خًرتييي‪ ،‬وًون‬
‫ٓظوىن رشوٍ يوَي يف خملـدي ]‪ [-π,+π‬ؤو ]‪( [0 , 2π‬ؤو ]‪ [0 , N‬ردًنٔزص ًٌنلؿص ‪ N‬يف طلىًٍ‬
‫فىًٌَه خملظلؿو ‪)DFT‬‬

‫ٌنونند ؤن نهظرب خًطىَش هدإلشدَش خًظٍ ؤهٍند نٌندض منهد يف هال خالطـدهٍن ‪ًًٍ .x,y‬ى ننًمد نإهٍ‬
‫طلىًٍ فىًٌَه ًٌطىَش يف هال خالطـدهٍن ‪ X‬و‪ٓ Y‬نلطٍ نىل خًرتيي خًٍي ٌٓمؼٍ خًطىَش‪ .‬رشوٍ‬
‫رًًهٍ ‪ ،‬بٌخ هدن مؿدي خإلشدَش خًـٌزٌص ًظًًن ررسنص هزًنش ويف وكع كطًن ٌنونند خنظزدَهد بشدَش‬
‫ٌخض طُيي مُطفو‪ ،‬ؤمد بٌخ هدن مؿدي خإلشدَش ًظًًن رزؿدء ٓظوىن بشدَش ٌخض طُيي منوفؼ‪ٌ ،‬نونند‬
‫طؿزٌم نفٕ خًفوُش نىل خًطىَش‪.‬‬
‫‪244‬‬ ‫‪ OpenCv‬ببساطة‬

‫مرىُمؼبلُامصىسحًُرغريُتشكهُكثري؟ُ ُ‬
‫ًظًًن رشوٍ هزًن ننً نلدؽ خًلىخف ؤو خًػـٌف‪ًٌ ،‬ى ٌنونند خًلىي رإن نلدؽ خًلىخف وخًػـٌف‬
‫ٌخض طُيي مُطفو يف خًطىَش‪ .‬ؤمد بٌخ مل ًون هندن طًًن هزًن يف خملؿدي ٓظوىن خًنلدؽ ٌخض طُيي‬
‫منوفؼ يف خًطىَش‪ .‬وخآلن ٓنشدهً هٌف ٓنىؿً طلىًٍ فىًٌَه ًٌطىَش‪.‬‬
‫‪ ‬ذؽىًهُفىسًٌهُيفُ‪ُ :Numpy‬‬
‫ٓــنىؿً طلىًــٍ فىًٌَــه ردٓــظوًخَ موظزــص ‪ .Numpy‬كٌــؽ متٌــى مـمىنــص ‪ FFT‬إلًـــدي طلىًــٍ‬
‫فىًٌَه‪.‬‬
‫امربتؼُاملعاولُغنُذؽىًهُفىسًٌهُهىُ)(‪ُ،np.fft.fft2‬ظٌػؼٌنبُهزاُامربتؼُامرؽىًهُامرتدديُ‬
‫كمصفىفخُغلذًخ‪ُ .‬‬
‫خملظًًن خألوي ًهٍخ خًظدرو هى ضىَش خًًهٍ (ًـس ؤن طوىن َمديًص)‪،‬‬
‫ػدين مظًًن هٌدَي وهى خملٔاوي نن طلًًً كٌدْ مطفىفص خًوُؾ‪ ،‬فةٌخ هدن خًلٌدْ ؤهرب من‬
‫ضىَش خًًهٍ ٌٓظم متًًً خًطىَش رإضفدَ كزٍ كٔدذ ‪ ،FFT‬وبٌخ هدن ؤكٍ من كـم ضىَش خًًهٍ‬
‫ٌٓظم كظ خًطىَش‪ ،‬وبٌخ مل منَُ ؤي كٌمص يف هٍخ خملظًًن ٌٓوىن كٌدْ ضىَش خًوُؾ رنفٕ كٌدْ‬
‫ضىَ خًًهٍ‪.‬‬
‫خآلن رهً ؤن كطٌند نىل خًنظٌـص‪ ،‬فةن خًرتيي خًطفُي ًٌهنرص (خملُهزص خملٔظمُش ‪ٌٓ )DC‬وىن يف‬
‫ؤنىل خًّؤوًص خًٌرسي‪ًًٍ ،‬ى ٓنلظدؾ إلِخكص خًنظٌـص مبلًخَ ‪ 2N‬يف هال خالطـدهٍن‪ ،‬وًٌى من هالي‬
‫خًظدرو )(‪ًٔ( np.fft.fftshift‬هىًص خًظلٌٌٍ)‪.‬‬
‫رهً ًٌى نٌٌند بًـدي كـم خًؿٌف (‪ )magnitude spectrum‬هٌل ًًل‪:‬‬
‫‪import cv2‬‬
‫‪import numpy as np‬‬
‫‪from matplotlib import pyplot as plt‬‬
‫)‪img = cv2.imread('kid_football.jpg',0‬‬

‫)‪f = np.fft.fft2(img‬‬
‫)‪fshift = np.fft.fftshift(f‬‬
‫))‪magnitude_spectrum = 20*np.log(np.abs(fshift‬‬

‫)'‪plt.subplot(121),plt.imshow(img, cmap = 'gray‬‬
‫)][(‪plt.title('Input Image'), plt.xticks([]), plt.yticks‬‬
‫)'‪plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray‬‬
‫)][(‪plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks‬‬
‫)(‪plt.show‬‬
‫ذ‬
‫‪245‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًنظٌـص ٓظزًو هٌل ًًل‪:‬‬

‫ذ‬

‫ٌنونند ؤن نُي رإن خملنؿلص خألهًت رٌدغد هٍ يف خملُهّ وهٍخ ًزٍن ًند رإن خًرتييخض خملنوفػص هٍ‬
‫خًٔدثًش‪.‬‬

‫رهً بًـدي خًرتيي من هالي خًظلىًٍ خًرتييي ٌنونى خآلن خًلٌدَ رهًش نمٌٌدض نىل خملـدي‬
‫خًرتييي مؼٍ طُشٌم خًرتيي خملُطفو‪ ،‬وبنديش رندء خًطىَش ؤي بًـدي نوٕ ‪ًًٍ ،DFT‬ى ٌنونى‬
‫رزٔدؾص ؤن طًٍّ خًرتييخض خملنوفػص نن ؾًُم طؿزٌم كندم مٔظؿًٌل رلـم ‪ ،60x60‬ػم نؿزم‬
‫خًظلىًٍ خًهوًس ردٓظوًخَ خًظدرو )(‪ np.fft.ifftshift‬رلٌؽ طإيت خملُهزص خملٔظمُش ‪ DC‬يف‬
‫خًّؤوًص خًٌرسي خًهٌٌد مُش ؤهُي (ؤي طهىي خًطىَش ملودنهد)‪.‬‬

‫رهً ًٌى نىؿً طلىًٍ فىًٌَه خًهوًس ردٓظوًخَ خًظدرو )(‪ ،np.ifft2‬وخًنظٌـص ؤًػد ٓظوىن ؤنًخي‬
‫نلًًص‪ ،‬ننًهد ٌنونند ؤهٍ كٌمظهد خملؿٌلص‪.‬‬
246 ‫ ببساطة‬OpenCv

import cv2
import numpy as np
from matplotlib import pyplot as plt
img = cv2.imread('kid_football.jpg',0)

f = np.fft.fft2(img)
fshift = np.fft.fftshift(f)

rows, cols = img.shape
crow,ccol = rows/2 , cols/2

fshift[crow-30:crow+30, ccol-30:ccol+30] = 0
f_ishift = np.fft.ifftshift(fshift)
img_back = np.fft.ifft2(f_ishift)
img_back = np.abs(img_back)

plt.subplot(131),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(132),plt.imshow(img_back, cmap = 'gray')
plt.title('Image after HPF'), plt.xticks([]), plt.yticks([])
plt.subplot(133),plt.imshow(img_back)
plt.title('Result in JET'), plt.xticks([]), plt.yticks([])
‫ذ‬ plt.show()

‫ذ‬

‫ذ‬

‫ذ‬
‫‪247‬‬ ‫‪ OpenCv‬ببساطة‬

‫طكهُ خًطىَش خًندطـص خًلىخف خًظٍ يف خًطىَش نظٌـص ًظؿزٌم مُشم خًرتيي خملُطفو‪ ،‬وهٍخ ًًي ؤًػد‬
‫نىل ؤن مهكم خًزٌدندض خًظٍ يف خًطىَش طلو يف منؿلص خًرتيي خملنوفؼ من خًؿٌف‪ً .‬لً شدهًند‬
‫هٌف ؤوؿًند طلىًٍ فىًٌَه ‪ DFT‬و‪( IDFT‬طلىًٍ فىًٌَه خملظلؿو ونؤه) ويًنهد يف ‪،Numpy‬‬
‫وفٌٌل ًًل ٓنلىَ رنفٕ خألمُ وًون غمن موظزص‪.OpenCv‬‬

‫بٌخ الككع يف خًطىَ خًندطـص هندن نًخ خًلىخف نلدؽ غـٌف ؤهُي (مؼٍ خًظٍ ننً خًٔهم خألكمُ)‪،‬‬
‫وًٌى رٔزس طإػًن خًندفٍش خملٔظؿٌٌص خملٔظهمٌص هلندم‪ .‬طٔمى نلدؽ خًػـٌف هٍه رظإػًن خالهظّخِ‬
‫‪ ،ringing effects‬وًٌظًٌس نىل هٍه خملشوٌص خٓظهمٍ خملُشم خًًإويس رًي مُشم خًندفٍش‬
‫خملٔظؿٌٌص‪.‬‬

‫‪ ‬ذؽىًهُفىسًٌهُيفُ‪ُ :OpenCv‬‬
‫موظزص ‪OpenCv‬طىفُ ًند خًظدرهٌٍن )( ‪ًٌ cv2.idft()،cv2.dft‬لٌدَ رهمٌٌص خًظلىًٍ‪ً .‬هًٌ نفٕ‬
‫خًنظدثف خًٔدرلص وًون رلندطٍن‪ ،‬ؤوي كندش متؼٍ خًلٔم خًللٌلٍ ًٌطىَش خًندطـص‪ ،‬وػدين كندش متؼٍ‬
‫خًلٔم خًظوًٌل ًٌطىَش خًندطـص‪ .‬ضىَش خًًهٍ ًـس ؤن طوىن ردًطًٌص ‪.np. float32‬‬

‫‪import numpy as np‬‬
‫‪import cv2‬‬
‫‪from matplotlib import pyplot as plt‬‬

‫)‪img = cv2.imread('kid_football.jpg',0‬‬

‫)‪dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT‬‬
‫)‪dft_shift = np.fft.fftshift(dft‬‬

‫= ‪magnitude_spectrum‬‬
‫))]‪20*np.log(cv2.magnitude(dft_shift[:,:,0],dft_shift[:,:,1‬‬

‫)'‪plt.subplot(121),plt.imshow(img, cmap = 'gray‬‬
‫)][(‪plt.title('Input Image'), plt.xticks([]), plt.yticks‬‬
‫)'‪plt.subplot(122),plt.imshow(magnitude_spectrum, cmap = 'gray‬‬
‫)][(‪plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks‬‬
‫)(‪plt.show‬‬
‫ذ‬

‫ذ‬
248 ‫ ببساطة‬OpenCv

:‫امنرٌعخ‬

‫ذ‬

ٕ‫ خًٍي ًهًٌ هٍ من خًؿىًٌص وخًّؤوًص يف نف‬cv2.cartToPolar() ‫ٌنونى ؤًػد خٓظوًخَ خًظدرو‬
‫ يف خًٔدرم شدهًند‬،(IDFT) ‫ خآلن ٓنلىَ رةًـدي خًظلىًٍ خًهوًس ًظلىًٍ فىًٌَه خملظلؿو‬.‫خًٌلكص‬
‫ (خًٍي ٓىف ًًٍّ خًرتييخض‬LPF ‫ ؤمد هٍه خملُش ٓنؿزم مُشم‬،HPF ‫هٌف ؾزلند مُشم طُي‬
ً‫نن‬1 ‫ ويف خًزًخًص نلىَ رةنشدء كندم ًإهٍ خًلٌمص‬.)‫خملُطفهص من خًطىَش مٌل ًايي ًظًزٌش خًطىَش‬
.‫خًرتييخض خملنوفػص‬
import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('kid_football.jpg',0)

dft = cv2.dft(np.float32(img),flags = cv2.DFT_COMPLEX_OUTPUT)
dft_shift = np.fft.fftshift(dft)

rows, cols = img.shape
crow,ccol = rows/2 , cols/2

# create a mask first, center square is 1, remaining all zeros
mask = np.zeros((rows,cols,2),np.uint8)
mask[crow-30:crow+30, ccol-30:ccol+30] = 1

# apply mask and inverse DFT
fshift = dft_shift*mask ‫ذ‬
f_ishift = np.fft.ifftshift(fshift)
img_back = cv2.idft(f_ishift)
img_back = cv2.magnitude(img_back[:,:,0],img_back[:,:,1]) ‫ذ‬

plt.subplot(121),plt.imshow(img, cmap = 'gray')
plt.title('Input Image'), plt.xticks([]), plt.yticks([])
plt.subplot(122),plt.imshow(img_back, cmap = 'gray')
plt.title('Magnitude Spectrum'), plt.xticks([]), plt.yticks([])
plt.show()
‫‪249‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ :‬‬

‫ذ‬

‫مالككص‪ :‬هدًهديش طىخرو طلىًٍ فىًٌَه] )(‪ [cv2.dft () ,cv2.idft‬ملوظزص ‪ OpenCv‬ؤرسم من نكًنخطهد يف‬
‫‪ .Numpy‬وًون طىخرو ‪ Numpy‬هٍ ؤهًت ٓهىًص يف خالٓظوًخَ‪.‬‬

‫األداءُاملصبيلُمرؽىًهُفىسًٌهُاملرلؼؼُ ‪Performance Optimization of‬‬
‫‪ُ :DFT‬‬
‫ؤيخء طلىًٍ فىًٌَه خملظلؿو ‪ DFT‬ؿًٌ ردًنٔزص ًزهؼ ؤكـدَ خملطفىفص‪ .‬فّمن خًظنفٌٍ ًوىن ؤرسم‬
‫ننًمد طوىن خملطفىفص مُفىنص ًٌلىي ‪ .4‬ؤًػدً خملطفىفدض خًظٍ كٌدٓهد ًوىن غهفٍ ؤو ‪ 4‬ؤغهدف ؤو‬
‫‪ 0‬ؤغهدف ًظم مهدًـظهد روفدءش طدمص‪.‬‬
‫ًًٍى بٌخ هنع كٌم روطىص ؤيخء خًوىي‪ٌ ،‬نونى طهًًٍ كـم خملطفىفص ألكً خألكـدَ خالهظٌدًَص‬
‫(وًٌى رلشى خملطفىفص رإضفدَ) كزٍ بًـدي طلىًٍ فىًٌَه خملظلؿو ‪( .DFT‬ؤي نًًّ كـم خملطفىفص‬
‫ونهزح خًلـم خًّخثً رإضفدَ)‪ .‬يف موظزص ‪ً OpenCV‬ـس ؤن طلىَ رلشى خملطفىفص رإضفدَ رشوٍ‬
‫ًًوي‪ ،‬وًون يف موظزص ‪ٓ Numpy‬ظلًي خًلٌدْ خًـًًً ًلٔدذ طلىًٍ فىًٌَه ‪( FFT‬طلىًٍ‬
‫فىًٌَه خًرسًو) وٓىف ًظم طلشى خملطفىفص رإضفدَ رشوٍ ؤطىمدطٌيك‪.‬‬

‫امعاالُاآلن‪ُ،‬كٌفُنىظذُامؽعمُاملصبيلُمنمصفىفخ؟ ُ‬
‫موظزص ‪ OpenCv‬طىفُ ًند خًظدرو )(‪ cv2.getOptimalDFTSize‬ملهُفص خًلـم خملؼديل‪ٌ .‬نونى‬
‫طؿزٌم هٍخ خألمُ نىل هٍ من )(‪ cv2.dft‬و )(‪.np.fft.fft2‬‬
250 ‫ ببساطة‬OpenCv

‫ خًظٍ طىفُهد ًند رٌجص‬%timeit ٌٍ‫ينند نظللم من خأليخء ردٓظوًخَ ؤيخش كٔدذ ِمن خًظنف‬
"C:\Python27\IPython (Qt)" َ‫ غمن هٍخ خملٔد‬IPython ‫ ٓظـً ؤيخش‬.IPython

In [1]: cd Pictures
C:\Users\ASUS\Pictures
In [2]: import cv2
In [3]: import numpy as np
In [4]: img = cv2.imread('kid_football.jpg',0)
In [5]: rows,cols = img.shape
In [6]: print rows,cols

334‫ذ‬500

In [7]: nrows = cv2.getOptimalDFTSize(rows)
In [8]: ncols = cv2.getOptimalDFTSize(cols)
In [9]: print nrows, ncols

360‫ذ‬500

.(360,500) ‫( بىل‬334,500) ‫ننً خمللدَنص رٍن خًنظدثف ٓظالكل رإنه طم طهًًٍ خًلـم من‬

ًٍ‫ نلىَ رلشىهد رإضفدَ رشوٍ ًًوي) ونىؿً ِمن طلى‬OpenCv ‫خآلن ينند نلشىهد رإضفدَ (يف‬
‫ وننٔى رٌدندض خًطىَش‬،‫ ٌنون فهٍ هٍخ خألمُ رةنشدء مطفىفص ضفًُص هزًنش خًلـم‬.DFT ‫فىًٌَه‬
.cv2.copyMakeBorder() ‫ ؤو نٔظوًَ خًظدرو‬،‫بىل هٍه خملطفىفص‬
251 ‫ ببساطة‬OpenCv

In [10]: nimg = np.zeros((nrows,ncols))
In [11]: nimg[:rows,:cols] = img
‫ذ‬

‫ ذ‬OR

In [12]: right = ncols - cols
In [13]: bottom = nrows - rows
In [14]: bordertype = cv2.BORDER_CONSTANT
‫ذ‬
In [15]: nimg = cv2.copyMakeBorder(img,0,bottom,0,right,bordertype, value = 0)

:Numpy ‫خآلن ٓنلٔس خأليخء ردًنٔزص ملوظزص‬
In [16]: %timeit fft1 = np.fft.fft2(img)

loops, best of 3: 45.5 ms per loop‫ذ‬10

In [17]: %timeit fft2 = np.fft.fft2(img,[nrows,ncols])

loops, best of 3: 8.46 ms per loop‫ذ‬100

‫ مُخض من خًوىي‬3 ‫ردمللدَنص رٍن خًرسنظٍن ٓظـً ؤن ؤيخء خًوىي خًؼدين هدن ؤفػٍ فهى ؤرسم رلىخيل‬
.OpenCv ‫ خآلن ٓنـُذ نفٕ خألمُ وًون هٍه خملُش ردٓظوًخَ طىخرو موظزص‬.‫خألوي‬
‫ذ‬
In [18]: %timeit dft1= cv2.dft(np.float32(img),flags=cv2.DFT_COMPLEX_OUTPUT)
‫ذ‬

loops, best of 3: 2.22 ms per loop‫ذ‬100

In [19]: %timeit dft2= cv2.dft(np.float32(nimg),flags=cv2.DFT_COMPLEX_OUTPUT)

loops, best of 3: 1.73 ms per loop‫ذ‬1000

.‫ؤًػد ردمللدَنص رٍن ِمن طنفٌٍ خًوىي خألوي وخًؼدين ٓظـً ؤن ِمن طنفٌٍ خًوىي خًؼدين هدن ؤرسم‬
ٌٍ‫فٔظـً ؤن ِمن طنف‬Numpy ‫ وموظزص‬OpenCV ‫وٌنونى خمللدَنص ؤًػد رٍن ؤيخء طىخرو موظزص‬
.Numpy ‫ ؤرسم روؼًن من ِمن طنفٌٍ ًظىخرو يف‬OpenCv ‫طىخرو موظزص‬
‫ذ‬
252 ‫ ببساطة‬OpenCv

‫ملبراُاملششؾُا ُالتاليسُهىُمششؾُذشددُمشذفؼ؟‬
‫ هى‬Sobel ‫؟ وملدٌخ‬HPF ‫ ملدٌخ الرالٌٓدن هى مُشم‬،‫ًلً طم ؾُق هٍخ خًٔاخي يف رهؼ خملنظًًدض‬
‫؟‬HPF ‫مُشم‬
‫ وكم‬،FFT ‫هٍ فلـ طلىًٍ فىًٌَه ًالرالٌٓدن ًلكـدَ هزًنش ًـ‬.‫خإلؿدرص هدنع كٔس طلىًٍ فىًٌَه‬
:‫ هدًظديل‬،‫رظلٌٌٌهد مبد خن خًلندم يف خملـدي خًّمنٍ فظلىًٌه ًٌمـدي خًرتييي ٌٓىغم ٌٓىهه‬
import cv2
import numpy as np
from matplotlib import pyplot as plt

# simple averaging filter without scaling parameter
mean_filter = np.ones((3,3))

# creating a guassian filter
x = cv2.getGaussianKernel(5,10)
gaussian = x * x.T

# different edge detecting filters
# scharr in x-direction
scharr = np.array([[-3, 0, 3],
[-10,0,10],
[-3, 0, 3]])

# sobel in x direction
sobel_x= np.array([ [-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]])

# sobel in y direction
sobel_y= np.array([ [-1,-2,-1],
[0, 0, 0],
[1, 2, 1]])

#laplacian
laplacian=np.array([[0, 1, 0],
[1,-4, 1],
[0, 1, 0]])
‫ذ‬
253 ‫ ببساطة‬OpenCv

filters = [mean_filter, gaussian, laplacian, sobel_x,
sobel_y, scharr]
filter_name = ['mean_filter',
'gaussian','laplacian',
'sobel_x', \
'sobel_y', 'scharr_x']

fft_filters = [np.fft.fft2(x) for x in filters]
fft_shift = [np.fft.fftshift(y) for y in fft_filters]
mag_spectrum = [np.log(np.abs(z)+1) for z in fft_shift]

plt.figure(figsize=(10,5))
for i in xrange(6):
plt.subplot(2,3,i+1),plt.imshow(mag_spectrum[i],cmap = 'gray')
plt.title(filter_name[i]), plt.xticks([]), plt.yticks([])

plt.show()
‫ذ‬

‫ذ‬

.‫من خًطىَ خًندطـص ٌنونند رىغىق طلًُُ فٌٌل بٌخ هدن خملُشم ممُ ًٌرتييخض خًهدًٌص ؤَ خملنوفػص‬
ُ
ُ :‫مشاظؼُبطبفٌخ‬
by Steven LeharAn Intuitive Explanation of Fourier Theory 
at HIPRFourier Transform 
What does frequency domain denote in case of images? 
‫الفصل السابع‬

‫” إن المهام العظام يمكن إنجازها حين يستغل الإنسان وقته بكفاءة ‟‬
‫د‪.‬إبراهيم الفقي‬
‫‪255‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُامعبتؼ‪ُ:‬مٌضحُامكشفُوامىصفُ ‪Feature‬‬
‫‪ُ Detection and Description‬‬
‫‪ ‬فهم مٌّخض خًطىَش‬
‫مد هٍ خملٌّخض خًُثٌٌٔص يف خًطىَش؟ هٌف ٌنون بًـدي هٍه خملٌّخض كظى طوىن‬
‫مفًٌش ًند؟‬

‫‪ ‬موظشف ِوخًد هدًَٕ ‪Harris Corner Detection‬‬
‫خًّوخًد هٍ مٌّش ؿًٌش وًون هٌف ٌنون بًـديهد‪.‬‬

‫‪ ‬موظشف ِوخًد ‪ & Shi-Tomasi‬مٌّخض ؿًٌش ًٌظهلس‬
‫ٓنظهٌم هٌفٌص خهظشدف ِوخًد ‪.Shi-Tomasi‬‬

‫‪ ‬ملًمص بىل ‪( SIFT‬مٌّش خًظلىًٍ خًؼدرظص خًلٌدْ) (‪(Scale-Invariant Feature Transform‬‬
‫موظشف ِوخًد هدًَٕ يًن ؿًٌ هفدًص ننً طًًن كٌدْ خًطىَش‪ ،‬نظٌـص ًًٍى كدمع‬
‫خملؿىَش ‪ Lowe‬رىغو ؾًُلص إلًـدي خًهندرص خًؼدرظص خًلٌدْ‪ .‬وؤؾٌلع نٌٌهد خٓم‬
‫‪.SIFT‬‬

‫ملًمص بىل ‪( SURF‬خملٌّخض خًلىًص خملرسنص) )‪(Speeded-Up Robust Features‬‬

‫بن مٌّش ‪ SIFT‬ؿًٌش‪ ،‬وًونهد يًن رسًهص مبد فٌه خًوفدًص‪ًًٍ ،‬ى طم خنشدء نٔوص‬
‫ؤرسم وؤؾٌم نٌٌهد خٓم ‪.SURF‬‬
‫‪FAST ‬ؤرسم هىخَِمٌص الهظشدف خًّوخًد‬
‫هٍ ؾُق خملٌّخض خًٔدرلص ؿًٌش يف رهؼ خألكٌدن‪ ،‬وًونهد ًٌٔع رسًهص مبد فٌه‬
‫‪256‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًوفدًص ًظهمٍ مو خًظؿزٌلدض خًظٍ طهمٍ ردًىكع خًللٌلٍ) مؼٍ خًٌٔدَش ٌخطٌص خًلٌديش و ‪ًًٍ ،)...‬ى طم‬
‫بًـدي هىخَِمٌص ‪ FAST‬وخًظٍ طهمٍ يف خًىكع خًللٌلٍ‪.‬‬
‫‪(BRIEF ‬خملٌّخض خالرظًخثٌص خملٔظلٌص خًلىًص خًؼندثٌص)‬
‫)‪(Binary Robust Independent Elementary Features‬‬

‫رٔزس خٓظهالن خًٍخهُش خًوزًن من كزٍ ‪ SIFT‬طم بًـدي ‪ BRIEF‬خًظٍ طىفُ يف‬
‫خًٍخهُش وطهؿٌند رسنص ؤهرب ردملؿدرلص‪.‬‬

‫‪( ORB ‬مىؿه ‪ FAST‬ومًوَ ‪(Oriented FAST and Rotated ( )BRIEF‬‬
‫‪BRIEF‬‬
‫‪ SIFT‬و ‪ً SURF‬لىمىن رهمٍ ؿًٌ‪ ،‬وًون ملشوٌص رإنه يًن مـدين وًـس يفو‬
‫رػو يوالَخض هٍ ٓنص‪.‬‬
‫ًلٍ هٍه خملشوٌص وفُض ًند موظزص ‪OpenCv‬رًًٍ نن ‪ SIFT‬و ‪SURF‬وهى‬
‫‪.ORB‬‬

‫‪ ‬مٌّش خملؿدرلص ‪Feature Matching‬‬
‫ًلً طهٌمند هؼًنخ نىل مٌّش خًوشف وخًىضف‪ ،‬وخآلن كدن خًىكع ًنظهٌم هٌف‬
‫نؿدرم موظٌف خألوضدف‪.‬‬
‫موظزص ‪ OpenCv‬طىفُ ًند طلنٌظٍن ًهٍخ خألمُ وهٌل‪:‬‬
‫مؿدرلص ‪ Brute-Force‬ومؿدرلص ‪.FLANN based‬‬

‫‪ ‬مٌّش خملؿدرلص ‪ Homography +‬إلًـدي خألؿٔدَ‬
‫خآلن ؤضزلند نهُف مد هٍ مٌّش خملؿدرلص ينند خآلن نًمـهد مو خملىيًٍ ‪calib3d‬‬
‫إلًـدي خألؿٔدَ يف خًطىَش خملهلًش‪.‬‬
‫‪257‬‬ ‫‪ OpenCv‬ببساطة‬

‫فهمُاملٌضادُ‪Understanding Features‬‬

‫ذ‬

‫امهذف‪ُ :‬‬
‫يف هٍخ خًفطٍ ٓنلإوي فلـ فهم خملٌّخض خًُثٌٔص يف خًطىَش (خًوطدثظ خملمٌّش يف‬
‫خًطىَش)‪ ،‬وًنهُف ملدٌخ هٍ مهمص‪ ،‬وملدٌخ مٌّش خًّوخًد هٍ مٌّش مهمص‪.‬‬
‫امرشػ‪ُ :‬‬
‫يف ًهزص طُهٌس خًطىَ نلظدؾ ًظـمٌو خًلؿو خًطًًنش من خًطىَ ًظشوٌٍ ضىَش هزًنش‪ .‬هٌف‬
‫ًٔظؿٌو خإلنٔدن متٌٌّ خًلؿو خملنفطٌص خملشوٌص ًٌطىَش خًىخكًش؟ وهٍ ٌنون ًٌلدٓىذ نكًُدً رإن‬
‫ٌنٌى مؼٍ هٍه خًلًَش؟ وبٌخ ؤمون هٍخ ملدٌخ ال ٌنونند بنشدء رُندمف ًلىَ رـمو نًش ضىَ ملندقُ‬
‫خًلٌدش خًللٌلٌص خًؿزٌهص يف ضىَش وخكًش هزًنش؟ ؤو ٌنونند بنشدء رُندمف ًطنو مـٔم ػاليث خألرهدي‬
‫‪ 3D‬من مـمىنص ضىَ ملـٔم؟‬
‫ؿمٌو خألٓجٌص خًٔدرلص طُهّ كىي هٌف ًٔظؿٌو خًلدٓس طـمٌو ضىَ موظٌفص ًنفٕ خملشهً يف‬
‫ضىَش وخكًش؟‬
‫خًـىخذ‪ :‬نلن نزلؽ نن ؤمندؽ ملًيش ؤو مٌّخض فًًُش وخًظٍ ٌنون رٔهىًص طظزههد‪ ،‬وملدَنظهد‬
‫رٔهىًص‪.‬‬
‫بٌخ ؤَيند طهًُف هٍه خملٌّش‪ ،‬فمن خًطهس خًظهزًن ننهد روٌٌلض وًونند نهُف مد هٍ‪ ،‬فدًلًَش نىل‬
‫خًظمٌٌّ مىؿىيش فٌند ردألضٍ وكظى ننً خألؾفدي خًطًدَ ًًٍى طـًهم ًٔظؿٌهىن ؤن ًٌهزىخ ًهزص‬
‫طُهٌس خًطىَش خملفووص‪ ،‬رلٌؽ ًٔظؿٌهىخ ؤن ًـمهىخ خًلؿو وًلًيوخ خًظشدره فٌٌل رٌنهد‪.‬‬
‫ذ‬
‫‪258‬‬ ‫‪ OpenCv‬ببساطة‬

‫وامعاالُا ُآلنُمبُهٍُهز ُاملٌضاد؟ُ ُ‬
‫خًـىخذ‪ً :‬ـس ؤن ًوىن مفهىمد من كزٍ خًلدٓس ؤًػد!‬
‫كٔندً‪ ،‬فمن خًطهس خًلىي هٌف طـً خًزٍس هٍه خملٌّخض‪ ،‬ألنهد مربمـص مٔزلد يف خًًمدى‪ ،‬وًون‬
‫بٌخ نكُند رهمم بىل خًطىَش ورلؼند نن ؤمندؽ موظٌفص‪ٓ ،‬نـً يشء مؼًن ًالهظٌلَ‪ .‬نىل ٓزٌٍ‬
‫خملؼدي ًنإهٍ خًطىَش خًظدًٌص‪:‬‬

‫ذ‬

‫نالكل رإن خًلؿو خًٔظص خملىؿىيش يف خنىل خًطىَش من ‪ F  A‬هٍ مىؿىيش غمن خًطىَش‪.‬‬
‫خًلؿهص ‪ A‬و ‪B‬نزدَش نن ؤٓؿم مٔظىًص‪ ،‬وطنظٍس يف مندؾم هؼًنش من خًطىَش ًًٍى فمن خًطهس‬
‫خًهؼىَ نٌٌهد يف مودن ملًي يف خًطىَش‪.‬‬
‫خًلؿهص ‪C‬و‪ D‬متؼٍ كىخف خملزنى‪ ،‬وٌنونى ؤن طـً مىكههد رشوٍ طلًُزٍ وًون ؤن طىؿً مودنهد‬
‫خمللًي فهٍخ ضهس نىند مد‪ .‬ألن هٍه خًلؿهص مىؿىيش نىل ؾىي خًلدفص‪ ،‬وهٍ نفٔهد يف هٍ مودن‪.‬‬
‫نالكل من ؾزٌهص خًلدفص رإن مٌّش خًلىخف ؤفػٍ من خألٓؿم خملٔظىًص‪ ،‬وًونهد ًٌٔع ؿًٌش مبد فٌه‬
‫خًوفدًص‪.‬‬
‫خًلؿهظٍن ‪ E‬و‪ F‬متؼٍ رهؼ ِوخًد خملزنى‪ ،‬وٌنون خًهؼىَ نٌٌهد رٔهىًص‪ ،‬ألن خًّوخًد ننً طلًُوهد يف‬
‫ؤي خطـده ٓظزًو موظٌفص‪ً ،‬هٍخ ٌنون خنظزدَهد مٌّش ؿًٌش‪.‬‬
‫‪259‬‬ ‫‪ OpenCv‬ببساطة‬

‫خآلن ٓننظلٍ ًٌٍسق خًظديل كظى نفهم رشوٍ ؤفػٍ‪:‬‬

‫ذ‬

‫خًٍسق ردًػزـ مؼٍ فىق‪.‬‬
‫فدًزلهص خًَّكدء متؼٍ خًٔؿم خملٔظىي‪ ،‬ومن خًطهس خًهؼىَ نٌٌهد وطهلزهد‪ ،‬وؤًنٌل كُهظهد ٓظزًو‬
‫نفٔهد‪ .‬خًزلهص خًٔىيخء متؼٍ خًلدفص‪ ،‬بٌخ كُهظهد رشوٍ نمىيي ٓظظًًن‪ ،‬رٌنٌل بٌخ كُهظهد رشوٍ‬
‫ؤفلٍ ًن طظًًن (وهٍخ خألمُ متدمدً مؼٍ خًٔدرم فهنًمد نلُن خًلدفص رشوٍ مىخِي ًؿىي خًلدفص‬
‫ٓظزًو نفٔهد)‪.‬‬

‫خًزلهص خًلمُخء متؼٍ خًّؤوًص‪ ،‬ؤًنٌل كُهظهد ٓظزًو مبنكُ موظٌف‪ًًٍ ،‬ى نهظرب خًّوخًد ٌو مٌّش‬
‫ؿًٌش يف خًطىَش (ًٌٔع خًّوخًد ًىكًهد هٍ مٌّش ؿًٌش‪ ،‬ففٍ رهؼ خًلدالض طهظرب خًنلدؽ ؤًػد ٌو‬
‫مٌّش ؿًٌش)‪.‬‬
‫تػذُؤنُؤظثنبُغىلُامعاالُاأل ُولُوهى‪ُ،‬مبُهٍُاملٌضاد؟ُ ُ‬

‫خًٔاخي خًٍي ًؿُق نفٔه خآلن‪ ،‬هٌف نىؿً هٍه خملٌّخض؟ ؤو هٌف نىؿً خًّوخًد؟‬
‫خًـىخذ‪ :‬من هالي خًلًْ‪ ،‬كٌؽ نزلؽ نن مندؾم يف خًطىَش طظًًن ؤهًت من يًنهد ننً‬
‫طلًُوهد‪ ،‬ونهرب نن هٍخ رًٌص خًلدٓىذ مبد ًٔمى خهظشف خملٌّخض ‪ ،Feature Detection‬وهٍخ‬
‫مد ٓنظًؤوًه يف خًفطىي خًلديمص‪.‬‬

‫ًنفرتع رإنند ؤوؿًند خملٌّخض خًظٍ يف خًطىَش‪ ،‬فزهً بًـديند ًهد‪ً ،‬ـس نٌٌند مؿدرلظهد مو ضىَش‬
‫ؤهُي‪ ،‬وًظم ًٌى رإهٍ منؿلص كىي خًزلهص خملمٌّش ونلىَ رىضفهد‪( ،‬مؼال خًـّء خًٍي يف خألنىل‬
‫‪260‬‬ ‫‪ OpenCv‬ببساطة‬

‫ٌنؼٍ خًٌٔلء خًَّكدء‪ ،‬وخًلٔم خًٔفًل ٌنؼٍ منؿلص خًزندء‪ ،‬نىل خًزندء هندن رهً خًّؿدؾ‪... ،‬خًى)‪،‬‬
‫ورشوٍ مشدره ًهٍخ خألمُ ًلىَ خًلدٓىذ رًٍى‪ ،‬ؤًمى هٍخ رىضف خملٌّش ‪Feature‬‬
‫‪ .Description‬رهً خًلطىي نىل خملٌّش وخًىضف ًظم خٓظوًخَ ًٌى بمد ًرتطٌس خملٌّخض ؤو‬
‫ًٌىضىي بىل خًطىَ ؤو ًفهٍ ؤي يشء نًًُه‪.‬‬

‫إلًـدي خملٌّخض ووضفهد ومؿدرلظهد يف ‪ OpenCv‬نٔظوًَ نًش هىخَِمٌدض مظنىنص‪.‬‬

‫امهذف‪ُ :‬‬
‫فهم مفهىَ موظشف ِؤوًد هدًَٕ‬
‫ٓنظهٌم خٓظوًخَ خًظىخرو خًظدًٌص‪. cv2.cornerSubPix()، cv2.cornerHarris():‬‬
‫ُ‬
‫ملذمخُنظشًخ‪ُ :‬‬
‫يف خًفطٍ خًٔدرم َؤًند رإن خًّوخًد هٍ مندؾم يف خًطىَش فٌهد خهظالف هزًن يف خًوؼدفص (خًشًش)‬
‫خًٌىنٌص يف ؿمٌو خطـدهدض هٍه خملنؿلص‪.‬‬
‫يف هٍه خًوىخَِمٌص ٓنلىَ رظلىًٍ خألفودَ خًزٌٔؿص خًٔدرلص كىي خملٌّخض ًطًٌص ًَدغٌص‪ ،‬فهٍه‬
‫خًوىخَِمٌص طلىَ رشوٍ ؤٓديس نىل كٔدذ خالهظالف ردًشًش ننً طلًُى )‪ (u,v‬روٍ خالطـدهدض‪،‬‬
‫وهٍخ مد ًهرب ننه ًَدغٌد هٌلذقؾي‪ :‬ذ‬
‫‪261‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬ ‫∑‬ ‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ‬

‫‪Window function‬‬ ‫شدة اإلزاحة‬ ‫الشدة‬

‫ذ‬

‫طدرو خًندفٍش ‪window function‬بمد ندفٍش مٔظؿٌٌص ؤو ندفٍش يإوٌٓص‪ ،‬خًًدًص منه بنؿدئند وِن‬
‫إلًـدي خًّوخًد‪ .‬نؿزم‬ ‫خًزٌؤالض خًظٍ طلع خملٔظؿٌٍ‪ .‬نٌٌند خالٓظفديش من كٌمص خًظدرو‬
‫منشىَ طدًٌىَ خملىٓو نىل خملهديًص خًٔدرلص وردًلٌدَ رزهؼ خًوؿىخض خًًُدغٌص نلطٍ نىل مد ًًل‪:‬‬
‫] [‬

‫∑‬ ‫[‬ ‫حقثذذ]‬

‫هٌل مشظلٍ خًطىَش ردالطـدهٍن ‪ x‬و‪ٌ( y‬نون بًـديهٌل رٔهىًص من هالي خًظدرو‬
‫)(‪ًٌ( .)cv2.Sobel‬ظٍهًن طدرو ٓىرٌٍ‪ Sobel‬مُ مهند مٔزلد)‬

‫رهً ًٌى نطٍ ًٌـّء خًُثًٌس‪ ،‬وخًٍي ًلًي خكظٌلي ؤن طلىي خًندفٍش ِؤوًص ؤو ال طلىي‪.‬‬

‫كٌؽ‪:‬‬

‫هٌل خًلٌم خًٍخطٌص ًـ ‪.M‬‬

‫هٍه خًلٌم خًٍخطٌص هٍ خًظٍ طلَُ فٌٌل بٌخ هدنع خملنؿلص هٍ ِؤوًص ؤَ كدفص ؤَ مٔظىي‪.‬‬
‫طوىن كٌمظهم ضًًنش ‪‬‬ ‫و‬ ‫‪ ‬ننًمد طوىن |‪ |R‬ضًًنش‪ ،‬وهٍخ ًلًغ ننًمد‬
‫خملنؿلص مٔظىًص‪.‬‬
‫‪‬‬ ‫ؤو ردًهوٕ ؤي‬ ‫‪ ‬ننًمد طوىن ‪ ،R<0‬وهٍخ ًلًغ ننًمد‬
‫خملنؿلص كدفص‪.‬‬
‫‪ ‬ننًمد طوىن ‪ R‬هزًنش‪ ،‬وهٍخ ًلًغ ننًمد و طوىن كٌمظهم هزًنش و ‪‬‬
‫خملنؿلص ِؤوًص‪.‬‬
262 ‫ ببساطة‬OpenCv

:‫ هٌل ًًل‬،‫ٌنون متؼٌٍ هٍه خًلٌم نىل شوٍ ضىَش‬

‫ذ‬

‫ ورإهٍ خًهظزص ًهد‬.‫ضىَش خًًهٍ ملوظشف ِوخًد هدًَٕ ًـس ؤن طوىن ضىَش يف خملٔظىي خًُمديي‬
‫ ٓنلىَ ردٓظوًخَ موظشف ِوخًد هدًَٕ نىل‬.‫ردًشوٍ خملندٓس ٓظهؿٌند خًّوخًد خًظٍ يف خًطىَش‬
.‫ضىَش رٌٔؿص‬

ُ :OpenCVُ‫ مكرشفُ ُصؤوًخُهبسًغُيف‬

:ٍ‫ مظًًنخطه ه‬.‫ ًهٍخ خًًُع‬cv2.cornerHarris() ‫خًظدرو‬OpenCv ‫طىفُ ًند موظزص‬
.float32 ‫ ًـس ؤض طوىن َمديًص ومن خًنىم‬، ٍ‫ ضىَش خًًه‬:Img 
.‫ كٌدْ خًـىخَ ردًنٔزص الهظشدف خًلىخف‬:blockSize 
.ًَ‫ خمل ُْٔظو‬sobel ٌٍ‫ ردَخمرت خًفظلص ملشظم ٓىر‬:Ksize 
.‫ خًزدَخمرت خًلُ ملوظشف هدًَٕ يف خملهديًص‬:K 
import cv2
import numpy as np
filename = 'car.jpg' ‫ذ‬
img = cv2.imread(filename)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

gray = np.float32(gray)
dst = cv2.cornerHarris(gray,2,3,0.04)

#result is dilated for marking the corners, not important
dst = cv2.dilate(dst,None)

# Threshold for an optimal value, it may vary depending on the image.
img[dst>0.01*dst.max()]=[0,0,255]
‫‪263‬‬ ‫‪ OpenCv‬ببساطة‬

‫)‪cv2.imshow('dst',img‬‬
‫‪if cv2.waitKey(0) & 0xff == 27:‬‬
‫)(‪cv2.destroyAllWindows‬‬

‫امنرٌعخ‪ُ :‬‬

‫رشػُامكىد‪ُ :‬‬
‫يف خًزًخًص كمند ردٓظًندء موظزص ‪ OpenCv‬وموظزص ‪ ،Numpy‬ػم كمند رظوًّن خًطىَش يف خملظًًن‬
‫‪ ،filename‬ػم كمند رلُخءش خًطىَش نن ؾًُم خًظدرو )(‪ ،cv2.imread‬ػم كمند رظلىًٍ خًطىَش بىل‬
‫خملٔظىي خًُمديي نن ؾًُم خًظدرو )(‪ ،cv2.imread‬ػم كمند رظلىًٍ خًطىَش ًٌطًٌص ‪ float32‬وًٌى‬
‫نن ؾًُم خًظدرو)(‪. np. float32‬‬
‫)‪dst = cv2.cornerHarris(gray,2,3,0.04‬‬

‫ػم كمند ردهظشدف ِوخًد هدًَٕ نن ؾًُم خًظدرو )(‪ cv2.cornerHarris‬وًلً ٌسكند ٓزدكد مد هٍ‬
‫خًزدَخمرتخض خًظٍ ًإهٍهد‪( .‬مالككص ًفهم هٍ مظًًن رشوٍ ؤوغم ؿُذ طًًٌن هٍ كٌمص ًىكًهد‬
‫وشدهً مد خًٍي ٌٓلطٍ يف خًطىَش)‬
‫)‪dst = cv2.dilate(dst,None‬‬
‫ذ‬
‫‪264‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًظدرو )(‪ cv2.dilate‬هى طدرو خًظمًًً (طم ٌسكه مٔزلد يف فطٍ خًظلىالض خملىَفىًىؿٌص) فلـ‬
‫خٓظوًمنده ًظىغٌم خًهالمدض خملٌىنص ردًٌىن خألكمُ وخًظٍ طًي نىل ِوخًد هدًَٕ (هٍخ خًٔؿُ يًن‬
‫مهم ٌنونى نًَ هظدرظه)‪.‬‬

‫‪# Threshold for an optimal value, it may vary depending on the image.‬‬
‫]‪img[dst>0.01*dst.max()]=[0,0,255‬‬
‫ذ‬

‫هٍه خًظهٌٌمص مٔاوًص نن طٌىًن ؤمدهن ِوخًد هدًَٕ ردًٌىن خألكمُ‪ ،‬كٌؽ خًلٌمص ]‪ [0,0,255‬متؼٍ‬
‫خًٌىن خألكمُ يف خًفػدء ‪ ،BGR‬وهٍخ خًٔؿُ ؤًػد ًلًي خًهظزص خًظٍ نًًُ بقهدَهد ًهٍه خًّوخًد‪،‬‬
‫كٌؽ كمند هند رظلًًً كٌمص خًهظزص خًًنٌد رـ ‪.5.58‬‬

‫(ؿُذ طوزًن وططًًن كٌمص خًهظزص وشدهً مد خًٍي ٌٓلًغ_ ٓرتي رإنه هٌٌل كمع رظوفٌؼ‬
‫خًهظزص خًًنٌد ًًٌّٓ نًي خًنلدؽ خملهٌمص ردًٌىن خألكمُ ًّوخًد هدًَٕ نىل خًطىَش‪ ،‬وهٌٌل كمند‬
‫رًّديش هٍه خًهظزص ٌٓنوفؼ نًي خًنلدؽ خملهٌمص ردًٌىن خألكمُ ًّوخًد هدًَٕ)‪.‬‬

‫ٌنونى خٓظزًخي ٓؿُ خألوخمُ هٍخ ردًظهٌٌمص خًظدًٌص‪:‬‬
‫)‪ret, dst = cv2.threshold(dst,0.01*dst.max(),255,0‬‬

‫)‪cv2.imshow('dst',img‬‬
‫ذ‬

‫ويف خًنهدًص نلىَ رهُع خًطىَش غمن ندفٍش خٓمهد '‪ 'dst‬وًٌى نن ؾًُم خًظدرو )(‪.cv2.imshow‬‬
‫ذ‬
265 ‫ ببساطة‬OpenCv

ُ :Corner with SubPixel Accuracyٍُ‫ دكخُام ُضؤوًخُمؼُامثٌكعهُامفشغ‬
.‫ؤكٌدند نلظدؾ ًًكص ؤهرب ننً خهظشدف خًّوخًد‬
‫ فٌٌلطىي نىل يكص‬.cv2.cornerSubPix() ‫طىفُ ًند هٍخ خألمُ من هالي خًظدرو‬OpenCv ‫موظزص‬
،‫ وخًٍي ًلىَ ررتشٌم خًندطف‬cv2.cornerSubPix ‫ؤهرب منَُ ندطف خهظشدف ِوخًد هدًَٕ ًٌظدرو‬
.‫ًٌلطىي نىل نظدثف ؤيق‬
import cv2
import numpy as np

filename = 'car.jpg'
img = cv2.imread(filename)
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

# find Harris corners
gray = np.float32(gray)
dst = cv2.cornerHarris(gray,2,3,0.04)
dst = cv2.dilate(dst,None)
ret, dst = cv2.threshold(dst,0.01*dst.max(),255,0)
dst = np.uint8(dst)

# find centroids
ret, labels, stats, centroids = cv2.connectedComponentsWithStats(dst)

# define the criteria to stop and refine the corners
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.001)
corners = cv2.cornerSubPix(gray,np.float32(centroids),(5,5),(-1,-1),criteria)

# Now draw them
res = np.hstack((centroids,corners))
res = np.int0(res)
img[res[:,1],res[:,0]]=[0,0,255]
img[res[:,3],res[:,2]] = [0,255,0]

cv2.imshow('dst',img)
if cv2.waitKey(0) & 0xff == 27:
cv2.destroyAllWindows()

.4 َ‫ خإلضًخ‬OpenCV ‫ يًن مىؿىي يف موظزص‬cv2.connectedComponentsWithStats ‫ خًظدرو‬:‫مالككص‬
‫‪266‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ :‬‬

‫ذ‬
‫‪267‬‬ ‫‪ OpenCv‬ببساطة‬

‫مكرشفُصواًبُ‪ُ&ُShi-Tomasi‬مٌضادُظٌذحُمنرػلج ُ‬
‫خًهًف‬
‫ٓنظهٌم خٓظوًخَ هدشف آهُ ًٌّوخًد وهى‪ :‬موظشف خًّؤوًص ‪.Shi-Tomasi‬‬
‫ٓنظهٌم خٓظوًخَ خًظدرو خًظديل‪. cv2.goodFeaturesToTrack():‬‬
‫ُ‬ ‫امنظشي‪:‬‬
‫موظشف خًّوخًد ‪ً Shi-Tomasi‬هؿٍ نظٌـص ؤفػٍ ملدَنص مو موظشف خًّوخًد هدًَٕ‪.‬‬
‫يف موظشف هدًَٕ طم ؤهٍ طدرو خًظلطٌٍ هٌل ًًل‪:‬‬

‫رًالً نن ًٌى خكرتق ‪Shi-Tomasi‬خًظديل‪:‬‬

‫هٌل فهٌند مو‬ ‫بٌخ هدنع ؤهرب من كٌمص خًهظزص نهظربهد ِؤوًص‪ .‬وبٌخ َٓمندهد يف خًفػدء‬
‫موظشف خًّوخًد هدًَٕ فٔنلطٍ نىل خًطىَش خًظدًٌص‪.‬‬

‫ذ‬

‫نهًهد ِؤوًص (خملنؿلص‬ ‫نالكل من خًطىَش رإنه فلـ ننًمد طوىن كٌمص و ؤنىل من كٌمص خًلً خأليىن‬
‫خملٌىنص ردًٌىن خألهٍص)‪.‬‬
‫ذ‬
‫‪268‬‬ ‫‪ OpenCv‬ببساطة‬

‫ُامكىد‪ُ :‬‬
‫موظزص ‪ OpenCv‬طلىي خًظدرو )(‪ ،cv2.goodFeaturesToTrack‬وخًٍي ًُ ْى ِؿ ًْ خًّوخًد خألكىي ‪ N‬يف‬
‫خًطىَش نن ؾًُم موظشف ‪( Shi-Tomasi‬ؤو موظشف ِوخًد هدًَٕ بٌخ خٓظهمٌظه)‪ .‬خًطىَش ًـس ؤن‬
‫طوىن يف مٔظىي خًٌىن خًُمديي‪ .‬كم رظلًًً نًي خًّوخًد خًظٍ طًًُ بًـديهد‪ ،‬ػم كًي مٔظىي‬
‫خًًكص‪ ،‬وخًٍي ًًي نىل خًلً خأليىن ًًكص خًّؤوًص‪ ،‬رلٌؽ بن كٌمص ؤي ِؤوًص طوىن طلع خًلً خأليىن‬
‫طُفؼ (ؤي طإهٍ خًلٌمص ‪ .)0‬ػم نّوي خًظدرو رإكٍ مٔدفص مٔمىكص رٍن خًّوخًد خملوظشفص‪.‬‬

‫هٍ هٍه خملهؿٌدض طـهٍ خًظدرو ًىؿً خًّوخًد خًظٍ يف خًطىَش رلٌؽ هٍ ِؤوًص طلع مٔظىي خًًكص‬
‫خملؿٌىرص طُفؼ‪ ،‬ػم طوّن خًّوخًد خملظزلٌص خنظٌليخ نىل مٔظىي خًًكص وررتطٌس طندِيل‪ .‬ػم ًإهٍ‬
‫خًظدرو ؤوي ؤكىي ِؤوًص‪ ،‬وًظوٌظ من هٍ خًّوخًد خًلًُزص من مـدي خملٔدفص خألكٍ من خملٔمىق‪،‬‬
‫وًهًٌ خًّوخًد خًلىًص ‪ .N‬يف خملؼدي خًظديل ٓنلإوي بًـدي ؤفػٍ ‪ِ 25‬ؤوًص‪:‬‬

‫‪import numpy as np‬‬
‫‪import cv2‬‬
‫‪from matplotlib import pyplot as plt‬‬

‫)'‪img = cv2.imread('car.jpg‬‬
‫)‪gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY‬‬

‫)‪corners = cv2.goodFeaturesToTrack(gray,25,0.01,10‬‬
‫)‪corners = np.int0(corners‬‬

‫‪for i in corners:‬‬
‫)(‪x,y = i.ravel‬‬
‫)‪cv2.circle(img,(x,y),3,255,-1‬‬

‫)(‪plt.imshow(img),plt.show‬‬
‫‪269‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪:‬‬

‫ذ‬ ‫ذ‬

‫ذ‬

‫من نظٌـص خًطىَش نٔظنظف رإن هٍخ خًظدرو مندٓس ؤهًت ًٌظهلس ‪ ،tracking‬وهٍخ مد ٓرنخه يف‬
‫خًفطىي خًلديمص‪.‬‬
‫رشػُامكىد‪ُ :‬‬
‫يف خًزًخًص نلىَ رلُخءش خًطىَش وطوًّنهد يف خملظًًن ‪ ،img‬ػم نلىَ رظلىًٍ خًطىَش ملٔظىي خًىن‬
‫خًُمديي‪.‬‬
‫)‪corners = cv2.goodFeaturesToTrack(gray,25,0.01,10‬‬
‫ذ‬

‫نلىَ رةًـدي خًّوخًد خألكىي خًظٍ يف خًطىَش وًٌى نن ؾُق خًظدرو )(‪.cv2.goodFeaturesToTrack‬‬
‫مظًًنخض هٍخ خًظدرو هٍ‪:‬‬
‫‪ ‬خملظًًن خألوي هى ضىَش خًًهٍ وًـس ؤن طوىن يف خملٔظىي خًُمديي‪.‬‬
‫‪ ‬خملظًًن خًؼدين ًلًي نًي خًّوخًد خًظٍ نًًُ خهظشدفهد‪.‬‬
‫‪ ‬خملظًًن خًؼدًؽ ًلًي مٔظىي يكص خًّوخًد خملوظدَش‪ ،‬كٌؽ ًلًي خًهظزص خًًنٌد ًٌّوخًد‬
‫خملوظدَش‪.‬‬
‫‪ ‬خملظًًن خًُخرو ًلًي ؤكٍ مٔدفص مٔمىكص رٍن خًّوخًد خملوظشفص‪.‬‬
‫)‪corners = np.int0(corners‬‬
‫ذ‬

‫خًظدرو )(‪ np.int0‬وقٌفظه هند بًًدء خألَكدَ خًظٍ رهً خًفدضٌص ًٌلٌمص خًظٍ منَُهد ًه‪ .‬فمؼال بٌخ هدن‬
‫خًُكم ‪ً 5.76‬طزم خًُكم ‪.0‬‬
‫‪270‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪corners=5.76‬‬
‫)‪x = np.int0(corners‬‬
‫‪print x‬‬
‫ذ‬

‫‪5‬‬

‫مصبلُآخش‪ُ :‬‬
‫)]‪corners= np.array([5.76,3.5,6.78,7‬‬
‫)‪x = np.int0(corners‬‬
‫‪print x‬‬
‫ذ‬

‫]‪[5 3 6 7‬‬

‫‪for i in corners:‬‬
‫)(‪x,y = i.ravel‬‬
‫)‪cv2.circle(img,(x,y),3,255,-1‬‬
‫ذ‬

‫ػم كمند رهمٍ كٌلص ‪ for‬كظى نوّن بكًخػٌدض خًّوخًد خًظٍ كطٌند نٌٌهد يف خملظًًنًن ‪ x‬و‪ ،y‬ػم‬
‫نلىَ رظمًُُ هٍه خإلكًخػٌدض ًظدرو َٓم خًًوخثُ )(‪ cv2.circle‬كظى نهٌم نلدؽ خًّوخًد رًوخثُ مٌىنص‬
‫ردًٌىن خألكمُ‪ .‬خًظدرو )( ‪ ravel‬يف موظزص ‪numpy‬مٔاوي نن طلىًٍ خملطفىفص ػندثٌص خًزهً ‪2D‬‬
‫بىل مطفىفص ؤكديًص خًزهً ‪.1D‬‬
‫مصبل‪ُ :‬‬
‫)]]‪a = np.array([[1,2], [4,5‬‬
‫)(‪a.ravel‬‬

‫]‪[1 2 4 5‬‬

‫هند كمند رظلىًٍ خملطفىفص ػندثٌص خًزهً ‪ 2D‬بىل ‪ 1D‬كظى نٔظؿٌو خًلطىي نىل بكًخػٌدض ‪x‬‬
‫ًىكًهد وبكًخػٌدض ‪ًy‬ىكًهد ًنمَُهد ًظدرو َٓم خًًوخثُ‪.‬‬
‫‪271‬‬ ‫‪ OpenCv‬ببساطة‬

‫ملذمخُبىل‪(Scale-Invariant Feature Transform(ُSIFT‬‬
‫امهذف‪:‬‬
‫ٓنظهُف نىل هىخَِمٌص ‪.SIFT‬‬
‫طهٌم بًـدي خًنلدؽ خًُثٌٌٔص ًـ ‪ SIFT‬و مىخضفدطهد‪.‬‬
‫ذ‬

‫امنظشي‪ُ :‬‬
‫يف خًفطٌٍن خًٔدرلٍن شدهًند رهؼ موظشفدض خًّوخًد هموظشف هدًَٕ‪ ،‬وشدهًند هٌف ؤن مٌّخض‬
‫خًطىَش همٌّش خًّؤوًص طزلى هٌل هٍ ننً طًوًُ خًطىَش‪ ،‬ؤي ؤن خًّؤوًص ال طظإػُ ردًظًوًُ‪ ،‬وًون مد‬
‫خًٍي ًلًغ ملٌّش خًّؤوًص بٌخ يًنند كـم خًطىَش؟ خًـىخذ ٌنون ؤن ططزم ًٌٔع رّؤوًص‪ ،‬فهىل‬
‫ٓزٌٍ خملؼدي شدهً خًطىَش خًظدًٌص‪ٓ ،‬ظشدهً ِؤوًص يف ضىَش ضًًنش يخهٍ ندفٍش ضًًنش (خًندفٍش‬
‫متؼٍ خًلندم)‪ .‬بٌخ كمند رظوزًن خًطىَش مو خالكظفدف رنفٕ كـم كندم خًندفٍش ٓظهظرب مٔؿلص ؤي‬
‫ًٌٔع رّؤوًص‪ .‬وهٍخ ًًي نىل ؤن ِوخًد هدًَٕ طظإػُ ننً طًًن كـم خًطىَش‪.‬‬
‫ذ ذ‬

‫ذ‬

‫رٔزس مشوٌص طإػُ ِوخًد هدًَٕ ننً طًًن خًلـم‪ ،‬كدَ خملؿىَون رةًـدي هىخَِمٌص ؿًًًش طلدفل‬
‫نىل مٌّش خًّوخًد ننً طًًن خًلـم وؤؾٌلىخ نٌٌهد غمن ؤوَخق خًزلؽ خٓم ‪( SIFT‬خهظطدَ ًوٌمص‪:‬‬
‫مٌّش خًظلىًٍ خًؼدرظص خًلـم)‬
‫طظإًف هٍه خًوىخَِمٌص من ؤَرو مُخكٍ وهٍ‪:‬‬
‫‪ ‬خهظشدف خًلٌمص خًهكمى ًٌلـم‪.‬‬
‫‪ ‬طلًًً خًنلدؽ خألٓدٌٓص خًظٍ متؼٍ خًّوخًد‪.‬‬
‫‪ ‬طهٌٍن خالطـده (إلِخًص طإػًنخض خًًوَخن وخًلـم)‪.‬‬
‫‪ ‬بنشدء وخضف (ردٓظوًخَ خملوؿؿدض خًزٌدنٌص ًالطـدهدض)‪.‬‬
‫ذ‬
‫‪272‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -1‬ؿؽتشفذاؾؼقؿةذاؾعظؿىذؾؼقاسذاحلجم )‪: (Scale-space Extrema Detection‬‬

‫من خًىخغم من خًطىَش خًٔدرلص رإنند ال نٔظؿٌو خٓظوًخَ نفٕ كندم خًندفٍش ًٌوشف نن خًنلدؽ‬
‫خًُثٌٌٔص (خًّوخًد) خًظٍ يف خًطىَ ٌخض خألكـدَ موظٌفص‪ٌ .‬نون خٓظوًخَ نفٕ خًندفٍش ًٌوشف نن‬
‫خًّوخًد خألضًُ من خًندفٍش‪ ،‬وًون ًٌوشف نن خًّوخًد خًوزًنش ٓنلظدؾ ًندفٍش ؤهرب‪ً ،‬هٍخ ًظم خٓظهٌلي‬
‫مُشم كٌدْ خًلـم (‪ .)Scale-space‬وخًٍي ًهظمً نىل بًـدي الرالٌٓدن خًًإويس(‪ًٌ )LoG‬طىَش مو‬
‫كٌم كـم موظٌفص ًٌطىَش (?)‪.‬‬
‫الرالٌٓدن خًًإويس ًهمٍ هموظشف ًٌنلدؽ‪ ،‬رلٌؽ ًوظشف خًنلدؽ كظى وًى طم طًًٌن كـم خًطىَش‪.‬‬
‫روٌٌلض موظرصش‪ ? ،‬متؼٍ مهدمٍ خًلٌدْ(خًلـم)‪ ،‬نىل ٓزٌٍ خملؼدي يف خًطىَش خًٔدرلص رظؿزٌم‬
‫خًلندم خًًإويس نىل كـم ضًًن ًٌطىَش ٓنلطٍ نىل كٌمص ندًٌص ألضًُ ِؤوًص‪ ،‬رٌنٌل بٌخ ؾزلند‬
‫خًلندم خًًإويس نىل نفٕ خًطىَش وًون رلـم ؤهرب ٓنلطٍ نىل كٌمص طظندٓس متدمد مو هِ َ ْ‬
‫رب‬
‫خًّؤوًص‪.‬‬
‫ًًٍى ٌنونند بًـدي ؤهرب كٌمص كدًٌص ًٌلٌدْ وخًلـم‪ ،‬ننًهد ٓنلطٍ نىل كدمئص من خًلٌم ‪(x , y ,‬‬
‫)? وخًظٍ طهنٍ وؿىي نلدؽ ِوخًد ملظمٌص ننً خإلكًخػٌص )‪ (x , y‬ننً خًلـم ?‪ .‬وًون هٍه‬
‫خًهمٌٌص طٔظهٌى وكع‪ًًٍ ،‬ى ٓنٌـإ الٓظوًخَ خًفُق خًًإويس يف هىخَِمٌص ‪ SFIT‬ألن هٍخ خألمُ‬
‫ًهً ؤرٔـ وًون ًلىَ ردملهمص خملؿٌىرص‪ً .‬ظم هٍخ خألمُ نن ؾًُم ؾُق خًظشىًش خًًإويس‬
‫(‪ًٌ )Gaussian blurring‬طىَش رلـمٍن موظٌفٍن ًٌطىَش‪ .‬هٍه خًهمٌٌص طظم نىل كٌم ٌتدنٌص‬
‫موظٌفص ًٌطىَش يف خًهَُ خًًإويس‪ ،‬وهٍخ ًظمؼٍ يف خًطىَش خًظدًٌص‪:‬‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫‪number of octaves= 4، number of scale levels = 5‬‬
‫‪273‬‬ ‫‪ OpenCv‬ببساطة‬

‫رهً بًـدي خًفُق خًًإويس (‪ً )DoG‬ظم خًزلؽ نن خًلٌمص خًهكمى خًلدًٌص غمن خملٔظىًدض‬
‫خملوظٌفص‪ ،‬فهىل ٓزٌٍ خملؼدي ًظم ملدَنص رٌؤٍ وخكً مو ‪ 8‬رٌؤالض مـإوَش ًه وًظم ملدَنظه ؤًػد‬
‫مو ‪ 9‬رٌؤالض من خملٔظىي خًٍي رهًه ومو ‪ 9‬رٌؤالض من خملٔظىي خًٍي كزٌه‪ ،‬ويف كدًص وؿىي‬
‫هٍه خًلٌمص خًهكمى هندن خكظٌلًٌص خن طوىن خًنلدؽ خًُثٌٌٔص متؼٍ ِؤوًص‪.‬‬

‫وهٍخ ًهنٍ رشوٍ ؤٓديس رإن خًنلدؽ خًُثٌٌٔص هٍ ؤفػٍ ممؼٍ ننً طًًن كـم خًطىَش‪ ،‬وهٍخ مد‬
‫طىغله خًطىَش خًظدًٌص‪:‬‬

‫ذ‬

‫‪ -2‬حتدقدذاؾـؼاطذاألدادقةذ(‪)Keypoint‬ذاؾيتذمتثلذاؾزواقا‪:‬‬

‫رهً بًـدي خًنلدؽ خًُثٌٌٔص خمللظمٍ ؤن طوىن ِوخًد‪ً ،‬ـس خًلٌدَ رظطفٌظهد ًٌلطىي نىل خًنلدؽ‬
‫خألهًت خكظٌلالً ؤن طوىن ِوخًد‪ ،‬وًظم هٍخ مبٔدنًش منشىَ طدًٌىَ‪ ،‬وًٌى نرب طلًًً نظزص مهٌنص‬
‫ًٌلٌم خًهكمى وؤي كٌمص طوىن ؤكٍ من هٍه خًهظزص طُفؼ‪ ،‬وطًنى هٍه خًهظزص رهظزص خًظزدًن‬
‫‪.contrastThreshold‬‬

‫خًفُق خًًإويس ‪ًًً DoG‬ه كٔدٌٓص ندًٌص ًٌلىخف ًًٍى ًـس بِخًظهد‪ً ،‬هٍخ ًظم خٓظوًخَ مفهىَ‬
‫مشدره ملوظشف ِوخًد هدًَٕ‪ ،‬وًٌى نن ؾًُم خٓظوًخَ مطفىفص ‪ )H( 2x2 Hessian‬وخًظٍ‬
‫طلدَن خًلٌم خًٍخطٌص ًٌنلدؽ‪ ،‬فةٌخ هدن خًندطف ؤهرب من نظزص مهٌنص طًنى ‪ edgeThreshold‬يف‬
‫‪ OpenCv‬فةنه ًظم شؿس خًنلؿص‪ ،‬وردًظديل فةن خًنلدؽ خًزدكٌص هٍ خًنلدؽ خملهمص خًلىًص‪.‬‬
‫ذ‬
‫‪274‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ -3‬اجتاهذاؾتعقنيذ‪:Orientation Assignment‬‬

‫خآلن ًظم طهٌٍن خالطـده ًوٍ من خًنلدؽ خًُثٌٌٔص ًظللٌم خًؼزدض ؤًػد وًون هٍه خملُش ننً طًوًُ‬
‫خًطىَش‪ً .‬ظم ؤهٍ خملنؿلص خملـإوَش كىي مىكو خًنلدؽ خًُثٌٌٔص وًٌى خنظٌليخ نىل خًلـم‪ .‬وًظم‬
‫كٔدذ ملًخَ خًظًَؾ وخطـدهه يف طٌى خملنؿلص‪ً .‬ظم خنشدء موؿـ رٌدين ًٌظىؿه ًه ‪ 36‬رن ( ‪)BIN‬‬
‫طشمٍ ‪ 455‬يَؿص‪ .‬طإهٍ كٌمهد رلٔس ملًخَ خًًوَخن وخًندفٍش خًًخثًُص خًًإوٌٓص خًىِن مو ?‬
‫طٔإوي ‪ 8.0‬مُش من كـم خًنلدؽ خًُثٌٌٔص‪ً .‬ظم ؤهٍ ؤنىل كمص يف خملوؿـ خًزٌدين وؤي كمص فىق‬
‫‪ً 80%‬ظم ؤهٍهد رهٍن خالنظزدَ ًلٔدذ خًظىؿه‪ .‬بنه ًنشإ نلدؽ ؤٓدٌٓص رنفٕ خملىكو وخًلـم‬
‫وًون ردطـدهدض موظٌفص‪ ،‬وهٍخ ًفًٌ يف خٓظلُخًَه خملؿدرلص‪.‬‬
‫‪ -4‬واصفذاؾـؼطةذاؾرئقدقة‪:‬‬

‫خآلن ًظم بنشدء وخضف ًٌنلؿص خًُثٌٌٔص‪ .‬وًوىن رلـم ‪ 16x16‬وكىي خًنلؿص خًُثٌٌٔص‪ً .‬ظم طلٌٔمه‬
‫بىل ‪ 85‬مُرو فُنٍ رلـم ‪ .4x4‬وًوٍ منهد ًظم بنشدء موؿـ رٌدين رـ ‪ 8‬رن ًًٌوَخن‪ًًٍ .‬ى ًىؿً‬
‫‪ 848‬رن ًٌلندم خًوًل‪ .‬متؼٍ هٍه خًزندض (‪ )BINS‬رشهدم ًىضف خًنلؿص خًُثٌٌٔص‪ .‬ردإلغدفص ًًٍى‬
‫ًظم خطودٌ نًش طًخرًن ًٌظللم من كىطهد ننً كًوغ طًًنخض يف خإلغدءش وخًًوَخن‪.‬‬
‫‪ -5‬ؿطابؼةذاؾـؼطةذاؾرئقدقة‪:‬‬

‫ًظم مؿدرلص خًنلدؽ خًُثٌٌٔص رٍن ضىَطٍن نن ؾًُم طلًًً ؤكُذ خًنلدؽ خملـإوَش‪ .‬وًون يف رهؼ‬
‫خًلدالض كً ًوىن هندن مؿدرلظدن كًُزظدن ؿًخ من رهػهٌل‪ .‬وهٍخ كً ًلًغ رٔزس خًػـٌف ؤو‬
‫ألٓزدذ ؤهُي‪ ،‬ويف هٍه خًلدًص طإهٍ نٔزص ؤكُذ مٔدفص بىل ػدين ؤكُذ مٔدفص‪ ،..‬فةٌخ هدنع ؤهرب‬
‫من ‪ً 5.8‬ظم َفؼ خًنظٌـص‪ ،‬وهٍخ ًًٍّ ‪ 90%‬من نظدثف خملؿدرلص خًودؾجص رٌنٌل ًُؿو ‪ 5%‬من‬
‫نظدثف خملؿدرلص خًطلٌلص‪.‬‬

‫هٍخ هى مٌوظ هىخَِمٌص ‪ SFIT‬وًظفدضٌٍ ؤهًت ٌنونى خًهىيش ألوَخق خًزلؽ خًودضص رهٍه‬
‫خًوىخَِمٌص طٍهُ رإن هٍه خًوىخَِمٌص ًهد كلىق نٍس‪ًًٍ ،‬ى هٍ يف خًلٔم خًًًن مـدين ًـ‬
‫‪.OpenCv‬‬

‫هىخَِمٌص ‪ SFIT‬يًن مـدنٌص ًًٍى ٓنالكل رإنهد مىؿىيش يف خضًخَ ‪ OpenCv‬خًلًًم ‪ v2‬ؤمد يف خإلضًخَ‬
‫خألكًغ ‪ v3‬فهٍ يًن مىؿىيش‪.‬‬
‫ذ‬
275 ‫ ببساطة‬OpenCv

ُ :OpenCvُ‫ُيف‬SIFT 
‫ ًنزًؤ مو خًنلدؽ خألٓدٌٓص‬.OpenCv ‫ يف موظزص‬SIFT‫ينند نزًؤ رظهٌم خًىقدثف خملظدكص ي‬
‫ ػم نلىَ رظمًُُ خًزٌدندض خملوظٌفص بًٌه‬،SFIT ‫ يف خًزًخًص نٌٌند رندء (بنشدء) ؿٔم‬.‫ونٔظفدي منهد‬
.‫ وكً طم ٌسق ًٌى رشوٍ ؿًٌ يف ؤوَخق خًزلؽ خًودضص رهٍه خًوىخَِمٌص‬،‫وهٍخ ؤمُ خهظٌدَي‬

import cv2
import numpy as np

img = cv2.imread('car.jpg')
gray= cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

sift = cv2.SIFT()
kp = sift.detect(gray,None)

img=cv2.drawKeypoints(gray,kp)

cv2.imwrite('sift_keypoints.jpg',img)

cv2.imshow('image',img)
cv2.waitKey()
cv2.destroyAllWindows()
‫ذ‬

ُ :‫امنرٌعخ‬

‫ذ‬
‫‪276‬‬ ‫‪ OpenCv‬ببساطة‬

‫رشػُامكىد‪ُ :‬‬
‫ؤوالً كمند رلُخءش خًطىَش ػم كمند رظلىًٌهد ملٔظىي خًٌىن خًُمديي‪.‬‬
‫)(‪sift = cv2.SIFT‬‬
‫ذ‬

‫ػم كمند رةنشدء ؿٔم هىخَِمٌص ‪ SFIT‬وًٌى نن ؾًُم خًظدرو )(‪.cv2.SIFT‬‬
‫)‪kp = sift.detect(gray,None‬‬
‫ذ‬

‫خًظدرو )(‪ً sift.detect‬ىؿً خًنلدؽ خًُثٌٌٔص خًظٍ يف خًطىَش‪ٌ .‬نونى متًُُ كندم بٌخ ؤَيض خًزلؽ‬
‫ننهد فلـ يف ؿّء ملًي‪ .‬هٍ نلؿص َثٌٌٔص ًهد طُهٌس هدص وهٍ طلىي نىل خًهًًً من‬
‫خًوطدثظ مؼٍ خإلكًخػٌدض )‪ ،(x,y‬وكـم خًـىخَ ٌو خملهنى‪ ،‬وخًّؤوًص خًظٍ طلًي خالطـده‪،‬‬
‫وخالٓظـدرص خًظٍ طلًي كىش خًنلدؽ خًُثٌٌٔص‪.‬‬
‫)‪img=cv2.drawKeypoints(gray,kp‬‬
‫ذ‬

‫موظزص ‪ OpenCv‬ؤًػد طىفُ ًند خًظدرو )(‪ cv2.drawKeyPoints‬وخًٍي ًلىَ رُٓم يوخثُ ضًًنش يف‬
‫مىخكو خًنلدؽ خًُثٌٌٔص‪ .‬بٌخ مَُض خًهٌم‬
‫‪ً cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS‬هٍخ خًظدرو ٓىف ًُٓم‬
‫يخثُش رلـم خًنلؿص خألٓدٌٓص وٌٓهُع ؤًػد خالطـده‪ .‬شدهً خملؼدي خًظديل‪.‬‬

‫)‪img=cv2.drawKeypoints(gray,kp,flags=cv2.DRAW_MATCHES_FLAGS_DRAW_RICH_KEYPOINTS‬‬

‫ذ‬
‫‪277‬‬ ‫‪ OpenCv‬ببساطة‬

‫خآلن ًنلٔس خًىضف‪ .‬موظزص ‪OpenCv‬طىفُ ًند ؾًُلظٍن ًٌلٌدَ رلٔدذ خًىضف‪:‬‬
‫‪ .8‬مبد ؤنند ٓدرلد ؤوؿًند خًنلدؽ خًُثٌٌٔص‪ٌ ،‬نونى بٌخ ً خٓظًندء خًظدرو )(‪ sift.compute‬وخًٍي‬
‫ًلٔس خًىضف من هالي خًنلدؽ خًُثٌٌٔص خًظٍ ؤوؿًندهد‪ .‬مؼٍ‪kp,des = :‬‬
‫)‪.sift.compute(gray,kp‬‬
‫‪ .4‬بٌخ مل طلم رةًـدي خًنلدؽ خًُثٌٌٔص من كزٍ‪ ،‬ننًهد ٌنونى بًـدي خًنلدؽ خًُثٌٌٔص وخًىضف‬
‫يف هؿىش وخكًش من هالي خًظدرو )(‪ . sift.detectAndCompute‬وًٌى هٌل يف خًوىي‬
‫خًظديل‪:‬‬

‫)(‪sift = cv2.SIFT‬‬
‫)‪kp, des = sift.detectAndCompute(gray,None‬‬

‫هند ‪ kp‬متؼٍ كدمئص(مطفىفص) ردًنلدؽ خألٓدٌٓص‪ ،‬و‪ des‬متؼٍ مطفىفص من خًشوٍ <نًي خًنلدؽ‬
‫خًُثٌٌٔص × ‪ًًٍ >48‬ى ٓنلطٍ نىل خًنلدؽ خألٓدٌٓص وخًىضف‪ .‬ويف خًفطىي خًلديمص ٓنظهٌم‬
‫هٌف نؿدرم رٍن خًنلدؽ خًُثٌٌٔص يف ضىَ موظٌفص‪.‬‬
‫ذ‬
‫‪278‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫ملذمخ‪ُ :‬‬
‫بن مٌّش ‪ SIFT‬ؿًٌش‪ ،‬وًونهد يًن رسًهص مبد فٌه خًوفدًص‪ًًٍ ،‬ى طم خنشدء نٔوص ؤرسم وؤؾٌم نٌٌهد‬
‫خٓم ‪SURF‬‬

‫امهذف‪ُ :‬‬
‫ٓنظهٌم ؤٓدٌٓدض ‪.SURF‬‬
‫ٓنظهٌم خٓظوًخَ طىخرو ‪ SURF‬يف ‪.OpenCv‬‬
‫ُ‬
‫ملذمخُنظشًخ‪ُ :‬‬
‫يف خًفطٍ خًٔدرم شدهًند هٌف ؤن هىخَِمٌص ‪ SFIT‬طفًٌند يف طلًًً خًنلدؽ خًُثٌٌٔص وخًىضف‪،‬‬
‫وًونهد هدنع رؿٌجص نٔزٌدً وخملٔظوًَ رلدؿص ًنٔوص ؤرسم‪ًًٍ ،‬ى كدَ نًش مؿىًَن رةًـدي نٔوص‬
‫ؿًًًش مرسنص وؤؾٌلىخ نٌٌهد غمن ؤوَخق خًزلؽ خًودضص رهم خٓم ‪Speeded Up " SURF‬‬
‫‪."Robust Features‬‬

‫يف ‪ SFIT‬شدهًند هٌف طم طلًُس الرالٌٓدن خًًإويس رةًـدي خًفُق خًًإويس إلًـدي كـم خًطىَش‪،‬‬
‫(ًٌظٍهًن‪ :‬الرالٌٓدن خًًإويس ًهمٍ هموظشف ًٌنلدؽ خًُثٌٌٔص رلٌؽ ًوظشف هٍه خًنلدؽ كظى‬
‫وًى طًًن كـم خًطىَش) ؤمد يف ‪ SURF‬فظم طزٌٔـ هٍخ خألمُ ؤهًت رلٔدذ خملُشم خًطنًوكٍ‪.‬‬

‫خًطىَش خًظدًٌص طىغم هٍخ خًظلًُس‪ .‬خملٌّش خًىكًٌش ًهٍخ خًظلًُس رإنه ننً خًلٌدَ رؿٍ خًطىَش مو‬
‫خملُشم خًطنًوكٍ فةنه ٌنون رٔهىًص كٔدره نن ؾًُم مودمٌص خًطىَ‪ .‬وٌنون ؤن ًلٔس رنفٕ‬
‫خألمُ من ؤؿٍ ؤكـدَ موظٌفص‪ .‬وطهظمً ‪ SURF‬ؤًػد نىل خًهىخمٍ خمل ُ َل ًَيش ملطفىفص هٌٌٔدن‬
‫‪ً Hessian‬وٍ من خملىغو وخًلٌدْ‪.‬‬
‫‪279‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫ًلٔدذ خالطـده‪ ،‬طٔظوًَ ‪ SURF‬خالٓظـدردض خملىؿٌص (‪ )wavelet responses‬يف هٍ من‬
‫خالطـدهٍن خألفلٍ وخًهمىيي ورـىخَ رلـم ‪ 5‬ؤغهدف خًلٌدْ )‪ ،)6S‬ونؿزم ؤًػدً خألوِخن خًًإوٌٓص‬
‫خملندٓزص نىل ًٌى‪ .‬ػم ًظم َٓم خًندطف هنلدؽ يف خًفػدء هٌل هى وخغم يف خًطىَش خًظدًٌص‪.‬‬
‫وًظم طلًًُ خالطـده خًًدًس نن ؾًُم كٔدذ‬
‫مـمىم هٍ خالٓظـدردض غمن ِؤوًص مظًًنش‬
‫رلٌمص ‪ 55‬يَؿص‪.‬‬
‫خًيشء خملؼًن ًالهظٌلَ هى ؤن خالٓظـدرص‬
‫خملىؿٌص ٌنون بًـديهد رٔهىًص ردًًص ننً ؤي‬
‫كـم ًٌطىَش‪.‬‬
‫يف خًهًًً من خًظؿزٌلدض ػزدض خًًوَخن يًن‬
‫مؿٌىذ ًًٍى ال كدؿص إلًـدي هٍخ خًظىؿه‪ ،‬مٌل‬
‫ًايي ًظرسًو ِمن طنفٌٍ خًوىخَِمٌص‪.‬‬
‫‪ً SURF‬ىفُ وقٌفص طًنى ‪ Upright-SURF‬ؤو‬
‫يَؿص‪.‬‬ ‫‪ U-SURF‬طلٔن خًرسنص ‪ ،‬وهٍ فهدًص ًلىخيل‬
‫يف موظزص ‪ OpenCv‬هندن نٌم (ردَخمرت) ًلًي هٍ نٔظوًمهد ؤَ ال‪ ،‬فةٌخ هدنع كٌمص خًهٌم ‪5‬‬
‫ٌٓلٔس خًظىؿه‪ ،‬وبٌخ هدنع كٌمص خًهٌم ‪ً 8‬ن ًلٔس خًظىؿه وردًظديل ٌٓوىن ؤرسم‪.‬‬
‫‪280‬‬ ‫‪ OpenCv‬ببساطة‬

‫ردًنٔزص ًىضف خملٌّخض‪ SURF ،‬طٔظوًَ خالٓظـدرص خملىؿٌص يف خالطـده خألفلٍ وخًهمىيي‬
‫(نٔظوًَ مظودمٌص خًطىَش مُش ؤهُي ًـهٍ هٍخ ًظم رٔهىًص)‪.‬‬
‫طإهٍ خًنلدؽ خملـإوَش كىي خًنلدؽ خألٓدٌٓص ردًلٌدْ ‪ 20s×20s‬كٌؽ ‪ٌ s‬نؼٍ خًلٌدْ‪ .‬ػم طلٔم‬
‫نىل ‪4×4‬ملؿو فُنٍ‪ .‬ػم نإهٍ خالٓظـدرص خألفلٌص وخًهمىيًص ًوٍ منؿلص فُنٌص‪ ،‬ونشوٍ مظـهص‬
‫(شهدم) مؼٍ هٍخ‬
‫‪.‬‬ ‫∑‬ ‫∑‬ ‫| |∑ | |∑‬
‫ننًمد ًظم متؼٌٌهد مبظـهص‪ً ،‬هؿٍ ‪ SURF‬مٌّش وضف رـ ‪ 53‬رهً‪ .‬وًون هٌٌل كٌٌندهد كطٌند نىل‬
‫رسنص ؤهًت وًون نىل كٔدذ خًًكص‪.‬‬

‫و | | ًلٔس‬ ‫ًٌلطىي نىل يكص ؤهرب‪ٌSURF ،‬نٌى منـ آهُ ًٌىضف رـ ‪ 848‬رهً‪ .‬ؿمو‬
‫| ًلٔس رشوٍ‬ ‫و|‬ ‫‪ .‬ورشوٍ مشدره‪ ،‬ؿمو‬ ‫و‬ ‫رشوٍ منفطٍ ننًمد‬
‫منفطٍ وفلدً إلشدَش ‪.‬‬
‫وردًظديل ننً مػدنفص نًي خملٌّخض ال ًػدف نمٌٌدض كٔدرٌص مهلًش‪.‬‬
‫موظزص‪ OpenCv‬طىفُ ًند خًهمٍ نىل هال خًنمؿٍن وًٌى رػزـ كٌمص خًهٌم رٍن ‪ 5‬و‪ ،8‬رلٌؽ خًهٌم ‪5‬‬
‫ًىغو ردًنٔزص ًـ ‪ 53‬رهً‪ ،‬ؤمد خًهٌم ‪ 0‬فٌىغو ردًنٔزص ًـ ‪ 848‬رهً‪( .‬ننً نًَ وغو ؤي كٌمص ًٌهٌم‬
‫ًوىن رشوٍ خفرتخيض ‪.)848‬‬

‫هندن طلٍٔن آهُ وهى ردٓظوًخَ بشدَش الرالٌٓدن (ؤػُ مطفىفص هٌٌٔدن ‪ ... )Hessian‬وهٍخ ال ًًًّ‬
‫ال ؤػندء خالهظشدف‪ ،‬وهٍه خإلشدَش طىغم خًوٌفٌدض خًهدمتص وَخء‬
‫خًظهلًٌ خًلٔديب ألنه ملٔىذ ؤض ً‬
‫خألؿٔدَ خًزٌػدء ؤو ردًهوٕ‪ ،‬وننً خملؿدرلص فلـ ٓنلدَن خملٌّخض فٌٌل بٌخ هدنع متٌى نفٕ‬
‫خًظزدًن (هٌل هى مهُوع يف خًطىَش خًظدًٌص)‪ .‬هٍه خملهٌىمدض خًلٌٌٌص طٔمم رظرسًو نمٌٌص‬
‫خملؿدرلص‪ ،‬يون خًظلٌٌٍ من ؤيخء خًىضف‪.‬‬

‫ذ‬
‫‪281‬‬ ‫‪ OpenCv‬ببساطة‬

‫روٌٌلض موظرصش‪ ،‬بن ‪ SURF‬طهؿٍ خًهًًً من خملٌّخض يف هٍ مُكٌص‪ ،‬كٌؽ ًكهُ خًظلٌٌٍ رإنهد‬
‫ؤرسم رلىخيل ‪ 4‬ؤغهدف من ‪ ،SFIT‬رٌنٌل خأليخء ٌندػٍ ‪ .SFIT‬و‪ SURF‬ؿًٌش ًٌظهدمٍ مو خًطىَ‬
‫خملًوَش وخًػزدرٌص(خملشىشص)‪ ،‬وًونهد يًن ؿًٌش يف خًظهدمٍ مو خًظًًن يف ندكٌص خًُئًص وخإلغدءش‪.‬‬
‫‪ُSURF ‬يفُ‪ُ :OpenCv‬‬
‫موظزص ‪ OpenCv‬طىفُ وقدثف ًـ ‪ SURF‬متدمد مؼٍ ‪.SFIT‬‬
‫يف ‪ SURF‬هندن رهؼ خًٍسوؽ هٌدًَص مؼٍ ضفص خًزهً‪ 848/53 :‬رهً‪ ،‬خالطـده‪ :‬نمىيي (ؤي رًون‬
‫خطـده) \ نديي (ؤي مو خطـده)‪ .‬هٍ هٍه خًظفدضٌٍ ٌسكع غمن ؤوَخق خًزلؽ‪ .‬ؤًظوًَ خًظدرهٍن‬
‫)(‪ SURF.compute()،SURF.detect‬إلًـدي خًنلدؽ خًُثٌٌٔص وخًىضف‪.‬‬

‫يف خألمؼٌص خًظدًٌص ٓنظهٌم بًـدي خًنلدؽ خًُثٌٌٔص وخًىضف ونُٓمهد‪:‬‬
‫ؤوال نلىَ رظلمٌٍ خًطىَش‪.‬‬
‫)‪>>> img = cv2.imread('fly.png',0‬‬
‫ذ‬

‫ػم ننشإ ؿٔم ‪ٌ .SURF‬نونى طلًًً خًزدَخمرتخض الكلد‬
‫هند غزؿند نظزص مطفىفص هٌٌٔدن رـ ‪.355‬‬
‫)‪>>> surf = cv2.SURF(400‬‬
‫ذ‬

‫نىؿً خًنلدؽ خألٓدٌٓص وخًىضف رشوٍ مزدٌس‬
‫)‪>>> kp, des = surf.detectAndCompute(img,None‬‬

‫)‪>>> len(kp‬‬
‫ذ‬

‫‪Out: 699‬‬
‫ذ‬

‫‪ 599‬نلؿص نًي غوم ًٌُٓم ًًٍى نًًّ خًهظزص ًنطٍ ًـ ‪ 05‬نلؿص‪ ،‬وًون ننً خملؿدرلص ٓنلظف هٍ‬
‫هٍه خًنلدؽ وًون ًٌٕ خآلن‪.‬‬
‫‪>>> print surf.hessianThreshold‬‬
‫ذ‬

‫‪Out: 400.0‬‬
‫ذ‬

‫ٓنـهٍ كٌمص خًهظزص مؼال ‪ .05555‬طٍهُ هٍخ فلـ ًُٓم خًنلدؽ نىل خًطىَش‪.‬‬
282 ‫ ببساطة‬OpenCv

>>> surf.hessianThreshold = 50000

>>>kp, des = surf.detectAndCompute(img,None)

>>>print len(kp)
‫ذ‬
Out: 47

.‫ ًًٍى ٓرنٓمه نىل خًطىَش‬05 ‫خًهًي مندٓس ؤكٍ من‬
>>> img2 = cv2.drawKeypoints(img,kp,None,(255,0,0),4)
>>> plt.imshow(img2),plt.show()
‫ذ‬

‫ذ‬

‫ذ‬

‫ ػم نفلظ نٌم‬.)‫ (خًطىَش خًظدًٌص طىغم ًٌى‬.‫ ًًٍى ًن طـً هندن خطـده‬U-SURF ‫خآلن ٓنؿزم‬
‫ (هٍخ ًهنٍ نًَ وؿىي‬TRUE ‫ نـهٌهد‬False ‫ فةٌخ هدنع كٌمظه‬،‫خالطـده ونظإهً هٍ هى نمىيي ؤَ ال‬
.)‫خطـده‬
>>> print surf.upright
‫ذ‬

False

>>> surf.upright = True
‫ذ‬
‫‪283‬‬ ‫‪ OpenCv‬ببساطة‬

‫نهًٌ كٔدذ مٌّخض خًظلدؽ ونُٓمهد‪.‬‬
‫)‪>>> kp = surf.detect(img,None‬‬
‫)‪>>> img2 = cv2.drawKeypoints(img,kp,None,(255,0,0),4‬‬
‫ذ‬

‫)(‪>>> plt.imshow(img2),plt.show‬‬
‫ذ‬

‫شدهً خًنظٌـص ٓرتي رإن ؿمٌو خالطـدهدض خملهُوغص هٍ رنفٕ خالطـده‪ .‬هٍخ ًهؿٍ رسنص يف وكع‬
‫خًظنفٌٍ ؤهًت من خًٔدرم‪.‬‬

‫ذ‬

‫ؤهًنخ ً ٓنفلظ كٌدْ خًىخضف ونًًنه بىل ‪ 848‬رهً فلـ بٌخ هدن خًزهً ‪-53‬رهً‪ .‬ػم نىؿً كٌدْ‬
‫خًىخضف‪.‬‬
‫)(‪>>> print surf.descriptorSize‬‬
‫ذ‬
‫‪Out:64‬‬
‫هٍخ ًهنٍ ؤن كٌمص نٌم "خًظمًًً" كٌمظه هٍ ‪.FALSE‬‬
‫‪>>> surf.extended‬‬
‫ذ‬

‫‪Out: FALSE‬‬

‫مبد ؤن كٌمص خًهٌم ‪ FALSE‬فنـهٌهد ‪ً TRUE‬نلطٍ نىل وضف ذ ‪ -848‬رهً‪.‬‬
‫‪284‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪>>> surf.extended‬‬
‫)‪>>>kp, des = surf.detectAndCompute(img,None‬‬
‫)(‪>>>print surf.descriptorSize‬‬
‫ذ‬

‫‪Out: 128‬‬

‫‪>>> print des.shape‬‬

‫(‪Out:)848 ،37‬‬ ‫الذتـدىذبلنذؼدمذادلطابؼةذدـؼومذبهذيفذػصلذآخر‪.‬‬

‫هٍ ؾُق خملٌّخض خًٔدرلص ؿًٌش يف رهؼ خألكٌدن‪ ،‬وًونهد ًٌٔع رسًهص مبد فٌه خًوفدًص كظى طهمٍ‬
‫مو خًظؿزٌلدض خًظٍ طهمٍ ردًىكع خًللٌلٍ )مؼٍ خًٌٔدَش ٌخطٌص خًلٌديش‪ ،‬وطهلس ؿٔم يف خًىكع‬
‫خًللٌلٍ مؼٍ ًىكص خملُهزدض خملودًفص‪...... ،‬خًى)‪ًًٍ ،‬ى طم بًـدي هىخَِمٌص ‪ FAST‬وخًظٍ طهمٍ‬
‫يف خًىكع خًللٌلٍ ‪.Real-time‬‬

‫امهذف‪ُ :‬‬
‫ٓنفهم ؤٓدٌٓدض هىخَِمٌص ‪.FAST‬‬
‫ٓنىؿً خًّوخًد ردٓظوًخَ طىخرو ‪ OpenCv‬خًودضص روىخَِمٌص ‪.FAST‬‬

‫ملذمخُنظشًخ‪ُ :‬‬
‫ؿقزةذاالؽتشافذبادتخدامذ‪ :FAST‬ذ‬

‫‪ .8‬خهرت رٌؤٍ ? يف خًطىَش كٌؽ ٌٓظم طهًُفه هنلؿص ؤٓدٌٓص ؤو يًن ؤٓدٌٓص‪ .‬وًظون شًش‬
‫خًزٌؤٍ ??‪.‬‬
‫‪ .4‬كًي كٌمص نظزص مندٓزص ?‪.‬‬
‫‪ .4‬خنظرب ؤن هندن يخثُش رـ ‪ 85‬رٌؤٍ كىي خًزٌؤٍ (شدهً خًطىَش خًظدًٌص)‪.‬‬
‫‪285‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ .3‬خًزٌؤٍ ? ًوىن ِؤوًص بٌخ ُو ِؿ ًَ مـمىنص ? من خًزٌؤالض خملظـإوَش يف خًًخثُش (من خًـ‬
‫(هٌل هى مزٍن يف خًطىَش‪،‬‬ ‫‪ 85‬رٌؤٍ) رلٌؽ طوىن هٌهد ؤٓؿو من ? ‪ ?? +‬ؤو ؤنظم من‬
‫ٓظـً هؿىؽ مظلؿهص رٌػدء)‪ .‬هند طم خهظٌدَ ? ًظوىن ‪.84‬‬
‫‪ .0‬طم خكرتخق خهظزدَ خًرسنص خًهدًٌص ‪ high-speed test‬الٓظزهدي نًي هزًن من خًنلدؽ خًظٍ‬
‫ًٌٔع رّؤوًص‪ .‬وهٍخ خالهظزدَ فلـ ًفلظ ؤَرهص رٌؤالض وهٍ ‪(1 , 9 ,5 ,13‬ؤوال ًفلظ‬
‫خًزٌؤٍ ‪ 8‬و‪ 9‬فٌٌل بٌخ هدند ٓدؾهٍن ؤَ ندمتٍن‪ .‬بٌخ هدن هًٍى ًفلظ ‪ 0‬و‪ .)84‬كظى ًوىن‬
‫خًزٌؤٍ ? ِؤوًص‪ً ،‬ـس ؤن ًوىن ػالػص من هٍه خًزٌؤالض نىل خألكٍ ؤهًت ٓؿىند من ??‬
‫‪ ،‬وبال فٌن ًوىن خًزٌؤٍ ? ِؤوًص‪ .‬هٍخ خملوظشف رلً ٌخطه ؤيخثه‬ ‫? ‪ +‬ؤو ؤيمم من‬
‫نديل‪ ،‬وًون هندن نًش نلدؽ غهف‪.‬‬

‫ؤوي ػالغ نلدؽ طظلًي ردٓظوًخَ طلنٌدض طهٌٌم خألًص‪ .‬وطلٍ ردٓظوًخَ خإلهٌلي خال ؤنكمٍ‪.‬‬

‫املنخص‪ُ :‬‬
‫هٍه خًوىخَِمٌص ؤرسم رهًش مُخض من موظشفدض خًّوخًد خًٔدرلص‪ ،‬وًونهد ال طظلمٍ مٔظىًدض ندًٌص‬
‫من خًػـٌف‪ .‬وهٍه خًوىخَِمٌص طهظمً نىل خًهظزص‪.‬‬
‫‪ُFAST ‬يفُ‪ُ :OpenCv‬‬
‫‪ًٔ FAST‬ظًنى هإي موظشف مٌّخض آهُ يف ‪ .OpenCv‬كٌؽ ٌنونى طلًًً كٌمصخًهظزص‪،‬‬
‫وٌنونند طؿزٌم خإلهٌلي خًًًن ؤنكمٍ ؤو نًَ طؿزٌله‪ ،‬وخًـىخَ خًىخؿس خٓظوًخمه‪ ،‬وًه ػالػص ؤنالَ‬
‫وهٍ‪:‬‬
‫‪‬‬ ‫‪cv2.FAST_FEATURE_DETECTOR_TYPE_5_8‬‬
286 ‫ ببساطة‬OpenCv

 cv2.FAST_FEATURE_DETECTOR_TYPE_7_12
 cv2.FAST_FEATURE_DETECTOR_TYPE_9_16

.FAST ‫خًوىي خًظديل ًزٍن هٌف نوظشف ونُٓم خًنلدؽ خملٌّش يف‬
import numpy as np
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('Writing.jpg')

# Initiate FAST object with default values
fast = cv2.FastFeatureDetector()

# find and draw the keypoints
kp = fast.detect(img,None)
img2 = cv2.drawKeypoints(img, kp, color=(255,0,0))

# Print all default params
print "Threshold: ", fast.getInt('threshold')
print "nonmaxSuppression: ", fast.getBool('nonmaxSuppression')
#print "neighborhood: ", fast.getInt('type')
print "Total Keypoints with nonmaxSuppression: ", len(kp)

# Disable nonmaxSuppression
fast.setBool('nonmaxSuppression',0)
kp = fast.detect(img,None)

print "Total Keypoints without nonmaxSuppression: ", len(kp)
img3 = cv2.drawKeypoints(img, kp, color=(255,0,0))

cv2.imshow('max Suppression',img2)
cv2.imshow(' non max Suppression',img3)
cv2.waitKey()
cv2.destroyAllWindows()
‫ذ‬

‫ذ‬
‫‪287‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذافدذاؾـتقجة‪:‬ذاؾصورةذاؾيتذعؾىذاؾقدارذتعرضذ‪FAST‬ذؿعذاإلمخادذاؾغريذأعظؿي‪,‬ذبقـؿاذاؾصورةذاؾيتذعؾىذاؾقؿنيذ‬

‫تعرضذ‪FAST‬ذبدونذاإلمخادذاؾغريذأعظؿي‪.‬‬

‫ذ‬ ‫ذ‬

‫ذ‬

‫‪(ُBRIEF‬املٌضادُاالترذائٌخُاملعرلنخُاملىًخُامصنبئٌخ) ُ‬

‫ملذمخ‪ُ :‬‬
‫رٔزس خٓظهالن خًٍخهُش خًوزًن من كزٍ ‪ SIFT‬طم بًـدي ‪ BRIEF‬خًظٍ طىفُ يف خًٍخهُش وطهؿٌند‬
‫رسنص ؤهرب ردملؿدرلص‪.‬‬
‫امهذف‪ُ :‬‬
‫يف هٍخ خًفطٍ ٓنظهٌم ؤٓدٌٓدض هىخَِمٌص ‪.BRIEF‬‬
‫ملذمخُنظشًخ‪ُ :‬‬
‫نلن نهٌم رإن ‪SFIT‬طٔظوًَ ‪-848‬رهً شهدم ًٌىضف‪ .‬ألنهد طٔظهمٍ ؤَكدَ ًٌنلدؽ من نىم ‪،float‬‬
‫طإهٍ رشوٍ ؤٓديس ‪ 084‬ردًع‪ .‬رشوٍ مشدره ‪ SURF‬ؤًػد طإهٍ ؤكٍ يشء ‪ 405‬ردًع (من ؤؿٍ ‪-53‬‬
‫رهً)‪ .‬بنشدء مؼٍ هٍه خًشهدم آلالف خملٌّخض ًٔظهٌى خًوؼًن من خًٍخهُش وهٍخ يشء يًن نمًل‬
‫وهدضص يف خألنكمص خملًمـص وخًظٍ طوىن ٌخهُطهد ملًويش‪ .‬وهٌٌل هدنع خًٍخهُش خًظٍ خٓظهٌوندهد‬
‫ؤهرب ننًهد نمٌٌص خملؿدرلص ٓظإهٍ وكع ؤؾىي‪.‬‬
‫‪288‬‬ ‫‪ OpenCv‬ببساطة‬

‫وًون هٍ هٍه خألرهدي كً ال ًوىن هندن كدؿص بًٌهد ننً خملؿدرلص خًفهٌٌص‪ًًٍ .‬ى ٌنونند ؤن نػًؿهد‬
‫رهًش ؾُق مؼٍ ‪ PCA‬و‪ .LDA‬وهندن ؾُق ؤهُي مؼٍ خًظـّثص ردٓظوًخَ ‪( LSH‬خًظـّثص خًلٔدٓص‬
‫خمللٌٌص) وطٔظوًَ ًظلىًٍ ضفدض ‪SFIT‬من ؤَكدَ ًٌنلدؽ من نىم ‪float‬بىل ٓالٍٓ ػندثٌص‬
‫‪ .binary strings‬هٍه خًٔالٍٓ خًؼندثٌص طٔظوًَ ملؿدرلص خملٌّخض ردٓظوًخَ مٔدفص خملزدًًص‬
‫‪ .Hamming distance‬وهٍخ ًهؿٌند رسنص ؤفػٍ‪ ،‬ألن بًـدي خملٔدفص خملزدًًص ًٔظهمٍ فٌه فلـ‬
‫‪ XOR‬ونًخي ًٌزٌع ‪ ،bit count‬وخًظٍ طوىن رسًهص ؿًخ يف خملهدًـدض خًلًًؼص مو طهٌٌٌلض‬
‫‪ .SSE‬وًون هند ٓنلظدؾ إلًـدي خألوضدف يف خًزًخًص‪ ،‬وفلـ ننًثٍ ٌنونند طؿزٌم نمٌٌص خًظـّثص‪،‬‬
‫وهٍخ ال ًايي ًلٍ مشوٌص خٓظهالن خًٍخهُش خًظٍ وخؿهظند يف خألوي‪.‬‬

‫‪ BRIEF‬طّويند ردهظطدَ إلًـدي خًٌٌٔٔص خًؼندثٌص رشوٍ مزدٌس رًون بًـدي خألوضدف‪ً .‬إهٍ ضىَش‬
‫مهٍرص ًٌظطلٌم وًوظدَ مـىنص من )‪ ?? (x,y‬ؤِوخؾ خملىكو رؿًُلص فًًُش من نىنهد (وهٍخ خألمُ‬
‫مىغم غمن ؤوَخق خًزلؽ خًودضص روىخَِمٌص ‪ .)BRIEF‬ػم طظم ملدَنص شًش رهؼ خًزٌؤالض ننً‬
‫هٍه خألِوخؾ‪ .‬نىل ٓزٌٍ خملؼدي‪ًٌ ،‬ون يف خًزًخًص مىغو خألِوخؾ ? و?‪ .‬بٌخ هدنع شًش خًزٌؤٍ ?‬
‫ؤهرب من شًش خًزٌؤٍ ? ننًهد خًنظٌـص ٓظوىن ‪ ،8‬ويًن ًٌى ٓظوىن خًنظٌـص ‪ .5‬وهٍخ ًؿزم نىل‬
‫هٍ مىخغو خألِوخؾ ?? ًنلطٍ نىل ؤرهدي ?? ٌٌٓٔص خًزع‪.‬‬

‫وًىفُ هٍه خًـ ??ٌنون ؤن طوىن ‪ 848‬ؤو ‪ 405‬ؤو ‪ ،084‬وموظزص ‪OpenCv‬طًنم هٍ هٍخ‪ ،‬وًون‬
‫رشوٍ خفرتخيض ٓىف طوىن ‪( 405‬موظزص ‪ OpenCv‬متؼٍ ًٌى يف ردًظدض‪ًًٍ ،‬ى خًلٌمص ٓظوىن ‪85‬‬
‫و‪ 44‬و‪ .)53‬كظى ننًمد طلطٍ نىل هٍخ ٌنونى خٓظوًخَ خملٔدفص خملزدًًص ملؿدرلص هٍه خألوضدف‪.‬‬
‫هندن نلؿص هدمص وهٍ رإن ‪ BRIEF‬وخضف خملٌّخض‪ ،‬ال ًّويند رإي ؾًُلص إلًـدي خملٌّخض‪ًًٍ ،‬ى‬
‫ًـس ؤن نٔظهمٍ ؤي موظشف ًٌمٌّخض مؼٍ ‪.SFIT,SURF‬‬

‫تكنٌلدُمخررصح‪ُ:‬بنُ‪ُ BRIEF‬هىُؤرسعُػشًلخُمؽعبةُمٌضحُامىصفُواملؼبتلخ‪ُ.‬وًىفشُمنبُ‬
‫نعثخُمتٌٌضُوذػشفُغبمٌخُمبملًُكنُامععمُذمُذذوًش ُتشكهُكثري‪ُ .‬‬
289 ‫ ببساطة‬OpenCv

ُ
ُ :OpenCv‫ُيف‬BRIEF 
‫ (ًًنى‬CenSurE ‫ مبٔدنًش هدشف خألوضدف‬BRIEF ‫خًوىي خًظديل ًىغم كٔدذ خألوضدف ي‬
.)OpenCv ‫ يف‬STAR ‫ رودشف خًنـمص‬CenSurE ‫خًودشف‬
import numpy as np ‫ذ‬
import cv2
from matplotlib import pyplot as plt

img = cv2.imread('car.jpg')

# Initiate STAR detector
star = cv2.FeatureDetector_create("STAR")

# Initiate BRIEF extractor
brief = cv2.DescriptorExtractor_create("BRIEF")

# find the keypoints with STAR
kp = star.detect(img,None)

# compute the descriptors with BRIEF
kp, des = brief.compute(img, kp)

print brief.getInt('bytes')
print des.shape

img2 = cv2.drawKeypoints(img, kp, color=(255,0,0))

cv2.imshow('BRIEF ',img2)
cv2.waitKey()
cv2.destroyAllWindows()
‫‪290‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًظدرو )'‪ً brief.getInt('bytes‬هؿٍ كٌدْ ?? خملٔظهمٍ يف خًزدًع‪ .‬رشوٍ خفرتخيض ًوىن ‪.44‬‬
‫خملُكٌص خًظدًٌص خًظٍ ٓنلىَ رهد هٍ خملؿدرلص وخًظٍ ٓنظنإوًهد يف خًفطىي خًلديمص‪.‬‬
‫‪291‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪(ُORB‬مىظهُ‪ُFAST‬ومذوسُ‪ُ (Oriented FAST and Rotated BRIEF(ُ)BRIEF‬‬

‫ملذمخ‪ُ:‬‬
‫‪ SIFT‬و ‪ً SURF‬لىمىن رهمٍ ؿًٌ‪ ،‬وًون خملشوٌص رإنهٌل يًن مـدنٌظدن وًـس يفو رػو يوالَخض‬
‫هٍ ٓنص‪ً .‬لٍ هٍه خملشوٌص وفُض ًند موظزص ‪OpenCv‬رًًٍ نن ‪ SIFT‬و ‪SURF‬وهى ‪.ORB‬‬

‫امهذف‪ُ:‬‬
‫يف هٍخ خًفطٍ ٓنظهٌم ؤٓدٌٓدض ‪.ORB‬‬
‫ُ‬
‫مػنىمبدُنظشًخ‪ُ:‬‬
‫‪ ORB‬رشوٍ ؤٓديس نزدَش نن يمف ملوظشف خًنلدؽ خًُثٌٌٔص ‪ FAST‬مو خًىخضف ‪ BRIEF‬مو‬
‫خًهًًً من خًظهًًالض ًظلٍٔن خأليخء‪ .‬يف خًزًخًص طٔظهمٍ ‪ FAST‬إلًـدي خًنلدؽ خًُثٌٌٔص ػم ًظم‬
‫طؿزٌم ملٌدْ ِوخًد هدًَٕ ًٌهؼىَ نىل ؤفػٍ خًنلدؽ ‪ N‬رٌنهم‪ .‬هم ؤنهد طٔظوًَ خًهَُ ًٌلطىي‬
‫نىل خملٌّخض(خًّوخًد) مو ؤكـدَ موظٌفص ًٌطىَش‪ .‬وًون هندن مشوٌص وخكًش وهٍ ؤن ‪ FAST‬ال‬
‫طلٔس خًظىؿه‪ .‬فٌلٌخ نفهٍ بٌخ ًنلطٍ نىل مٌّخض ػدرظص كظى وًى كمند رظًوًُ خًطىَش (ػزدض يف‬
‫خًًوَخن)؟‬

‫كدَ خملؿىَ ردًظهًًٍ خًظديل‪ ،‬كٌؽ كدَ رلٔدذ هؼدفص خًىِن خملظىٓـ ًٌزلهص مو خًّؤوًص خًلدًٌص‬
‫خطـده خًشهدم من نلؿص خًّؤوًص بىل خملُهّ ًهؿٍ خًظىؿه‪ً .‬ظلٍٔن ػزدض خًًوَخن‪،‬‬ ‫ننً خملُهّ‪.‬‬
‫نلٔس خًهّوَ ردًنٔزص ًٌملىًَن ‪ x‬و‪ y‬وخًظٍ ًـس ؤن طوىن يف منؿلص يخثًُص نطف كؿُهد ‪،r‬‬
‫كٌؽ ‪ r‬هى كـم خًزلهص‪.‬‬

‫خآلن ردًنٔزص ًٌىضف فةن ‪ ORB‬طٔظوًَ خًىخضف ‪ .BRIEF‬وًون هٌل شدهًند يف خًفلُش خًٔدرلص‬
‫فةن ‪ BRIEF‬ؤيخءه غهٌف ننً يوَخن خًطىَش‪ًًٍ .‬ى مد ٓظفهٌه ‪ ORB‬هٍ طىؿٌه"‪BRIEF "steer‬‬
‫‪292‬‬ ‫‪ OpenCv‬ببساطة‬

‫وفلد ًظىؿهدض خًنلدؽ خًُثٌٌٔص‪ًٌ .‬لطىي نىل ؤي مٌّش ملـمىنص ‪ n‬من خالهظزدَخض خًؼندثٌص‬
‫‪ ،‬نهُف مطفىفص رلـم ‪ S .2×n‬طلىي نىل بكًخػٌدض هٍه‬ ‫‪binary test‬ننً خملىغو‬
‫خًزٌؤالض‪ .‬ػم ردٓظوًخَ خًظىؿٌه ًهٍه خًزلهص‪ً ، ?،‬ظم بًـدي يوَخن خملطفىفص وخإلكًخػٌدض ‪S‬‬
‫ًًٌوَخن‪ً ،‬نلطٍ نىل خًظىؿٌه (خًًوَخن) ضًٌص ??‪.‬‬

‫(‪ 84‬يَؿص) ‪ ،‬وًنشإ ؿًوي رلؽ من مندٌؾ ‪BRIEF‬‬ ‫‪ ORB‬طلًَ ملًخَ ًِديش خًّؤوًص رـ‬
‫?‬
‫خمللٔىرص ٓدرلد‪ .‬ؾدملد ؤن طىؿه خًنلدؽ خًُثٌٌٔص ? مظندٓلص ننً خًهُع‪ ،‬ومـمىنص نلدؽ‬
‫خًظطلٌم ?? ٓىف طٔظوًَ ًلٔدذ خًىضف‪.‬‬

‫‪ٌBRIEF‬نٌى هدضٌص هدمص وهٍ ؤن هٍ مٌّش رع ًًًهد طزدًن (فُق) هزًن ومظىٓـ طلًُزد ‪ .5.0‬وًون‬
‫مبـُي ؤنهد مىؿهص ؿنزد بىل ؿنس مو ؤرهدي خًنلدؽ خألٓدٌٓص‪ ،‬طفلً هٍه خًودضٌص وططزم ؤهًت‬
‫طىًِهدً‪ .‬خًظزدًن خًهديل ًـهٍ خملٌّش ؤهًت وغىكدً‪ ،‬ألن خٓظـدرظه طظًًن رشوٍ موظٌفد طزهد‬
‫ًٌمًهالض‪.‬‬

‫هدضٌص ؤهُي مُيىرص وهٍ ؤن طوىن خالهظزدَخض يًن مرتخرؿص رلٌؽ هٍ خهظزدَ ًٔدهم يف‬
‫خًنظٌـص‪ً .‬لٍ هٍ هٍه‪ً ORB ،‬لىَ رظشًٌٍ خًزلؽ خًشـو رٍن ؿمٌو خالهظزدَخض خًؼندثٌص خملمونص‬
‫إلًـدي خهظزدَ ػنديئ وخكً ٌنٌى طزدًن نديل وطوىن كًُزص من ‪ 5.0‬ردإلغدفص بال هىنهد يًن مرتخرؿص‪،‬‬
‫وهٍه خًنظٌـص طًنى ‪.rBRIEF‬‬

‫ردًنٔزص ًىخضف خملؿدرلص‪ LSH ،‬مظهًيش خالهظزدَ طلٔن من ‪ LSH‬خًظلًٌٌي‪ ،‬وطٔظوًَ‪ .‬ؤوَخق‬
‫خًزلؽ طلىي بن ‪ ORB‬ؤرسم روؼًن من ‪ SURF‬و‪ ،SIFT‬ووخضف ‪ً ORB‬همٍ رشوٍ ؤفػٍ من‬
‫‪ ORB .SURF‬هى هٌدَ ؿًٌ يف خألؿهّش خملنوفػص خالٓظهالن ًٌؿدكص‪.‬‬

‫ذ‬

‫ذ‬

‫ذ‬
293 ‫ ببساطة‬OpenCv

ُ :OpenCvُ‫ُيف‬ORB 
‫ ؤو‬cv2.ORB () ‫ من هالي خًظدرو‬ORB ‫هٌل يف خًهديش ًـس ؤوال بنشدء خًـٔم ًٍخ ٓننشإ ؿٔم‬
.‫ هٍخ خًظدرو ًلىي نىل نًي من خًزدَخمرتخض خالهظٌدًَص‬.feature2d ‫خًىخؿهص خًشدثهص‬
ٍ‫ (نًي خملٌّخض) ؤهًت ردَخمرت مفًٌ وهى ًًي نىل ؤهرب نًي من خملٌّخض خًظ‬:nFeature 
.)055 ‫ٌٓظم خالكظفدف رهد (خفرتخغٌد طوىن‬
‫ ًظطنٌف‬FAST ‫ (نىم خًنلدؽ) ًًي نىل مد بٌخ هدن ملطٌص خًنلدؽ ًهدًَٕ ؤو‬:scoreType 
.)ًَٕ‫خملٌّخض (خفرتخغٌد طوىن ملطٌص خًنلدؽ ًهد‬
.BRIEF ‫ ًظلًًً نًي خًنلدؽ خًظٍ طهؿٍ طىؿٌه هٍ ننرص من نندرص خًىخضف‬: WTA_K 
.)‫(خفرتخغٌد طوىن نلؿظٍن ؤي ًوظدَ نلؿظٍن يف هٍ مُش‬
‫ فةٌخ هدنع‬،‫ خملٔدفص رٍن خًنلدؽ خًظٍ طٔظوًَ من ؤؿٍ خملؿدرلص‬:NORM_HAMMING 
‫ ػم ًظم طهًُف‬.BRIEF ‫ نلدؽ إلنظدؾ خًىخضف‬3 ‫ ؤو‬4 ‫ هٍخ ًهنٍ رإنهد‬،3 ‫ ؤو‬4 WTA_K
.NORM_HAMMING2 ‫مٔدفص خملؿدرلص رـ‬
.ORB َ‫خًوىي خًظديل ًىغم خٓظوًخ‬
import numpy as np ‫ذ‬
import cv2
from matplotlib import pyplot as plt
‫ذ‬
img = cv2.imread('car.jpg')
‫ذ‬
# Initiate STAR detector
orb = cv2.ORB()
‫ذ‬
# find the keypoints with ORB
kp = orb.detect(img,None) ‫ذ‬

‫ذ‬
# compute the descriptors with ORB
kp, des = orb.compute(img, kp)

‫ ذ‬size and orientation
# draw only keypoints location,not
img2 = cv2.drawKeypoints(img,kp,color=(0,255,0), flags=0)
‫ذ‬

cv2.imshow('ORB ',img2)
cv2.waitKey()
cv2.destroyAllWindows() ‫ ذ‬:‫اؾـتقجة‬
294 ‫ ببساطة‬OpenCv

‫ذ‬

‫ذ‬

ُ :‫مشاظؼُبطبفٌخ‬
 Ethan Rublee, Vincent Rabaud, Kurt Konolige, Gary R. Bradski: ORB: An efficient
alternative to SIFT or SURF. ICCV 2011: 2564-2571.
‫‪295‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذؼبتمُاملٌضادُ‪Feature Matching‬‬

‫ملذمخ‪ُ :‬‬
‫ًلً طهٌمند هؼًنخ نن مٌّش خًوشف وخًىضف‪ ،‬وخآلن كدن خًىكع ًنظهٌم هٌف نؿدرم موظٌف‬
‫خألوضدف‪ .‬موظزص ‪ OpenCv‬طىفُ ًند طلنٌظٍن ًهٍخ خألمُ وهٌل‪:‬‬
‫مؼبتلخُ‪ُBrute-Force‬ومؼبتلخُ‪ُ .FLANN based‬‬
‫امهذف‪ُ :‬‬
‫ٓنظهٌم هٌف ٓنؿدرم خملٌّخض رٍن ضىَطٍن‪.‬‬
‫ٓنٔظوًَ مؿدرلص ‪ Brute-Force‬ومؿدرلص ‪.FLANN based‬‬

‫أدادقاتذادلطابؼةذ‪ :Brute-Force‬ذ‬

‫خملؿدرلص ‪ Brute-Force‬هٍ مؿدرلص رٌٔؿص‪ ،‬فهٍ طإهٍ خًىخضف ملٌّش وخكًش يف خملـمىنص خألوىل‬
‫وطؿدرلهد مو مٌّخض ؤهُي يف مـمىنص ػدنٌص رةؿُخء رهؼ خًلٔدردض نىل خملٔدفص‪ ،‬وؤكُذ وخكًش‬
‫ًظم خهٍهد (ؤنديطهد ‪.)return‬‬
‫ردًنٔزص ًٌمؿدرلص ‪ً ،BF‬ـس نٌٌند يف خًزًخًص بنشدء ؿٔم مؿدرلص ‪ BF‬ردٓظوًخَ خًظدروذ‬
‫)(‪ .cv2.BFMatcher‬هٍخ خًظدرو ًإهٍ ردَخمرتًن خهظٌدًٍَن‪ ،‬خًزدَخمرت خألوي هى ‪ ،normType‬وقٌفظه‬
‫طلًًً كٌدْ خملٔدفص خًظٍ ٌٓظم خٓظوًخمهد (رشوٍ خفرتخيض طوىن ‪ ،(cv2.NORM_L2‬هٍخ‬
‫خًزدَخمرت ؿًٌ ردًنٔزص ي ‪ SFIT‬و‪ SURF‬ؤمد ردًنٔزص ًٌٌٌٔٔص خًؼندثٌص خًظٍ طزنٍ خًىخضف مؼٍ‬
‫‪ً ORB,BRIEF,RBISK‬نزًٍ ؤن منَُ خًلٌمص‪ ،cv2.NORM_HAMMING‬وخًظٍ طٔظوًَ‬
‫‪296‬‬ ‫‪ OpenCv‬ببساطة‬

‫خملٔدفص خملزدًًص ًٌلٌدْ‪ .‬بٌخ ‪ ORB‬خٓظوًمع ‪ VTA_K ==3 or 4‬ننًهد ًـس ؤن منَُ خًلٌمص‬
‫‪.cv2.NORM_HAMMING2‬‬
‫ػدين ردَخمرت هى خملظًًن خملنؿلٍ ‪ crossCheck‬وطوىن كٌمظه رشوٍ خفرتخيض‪ . FALSE‬بٌخ ؿهٌند‬
‫كٌمظه ‪ TRUE‬ننًهد خملؿدرم ٌٓهًٌ فلـ هٍه خملؿدرلص مو خًلٌمص )‪ (i,j‬من خًنىم خًىخضف ‪i-th‬‬
‫يف خملـمىنص ‪ ،A‬وخًىخضف ‪ j-th‬يف خملـمىنص ‪ B‬هإفػٍ مؿدرلص‪ ،‬وخًهوٕ ردًهوٕ‪.‬‬
‫بن خملٌّطٍن يف هال خملـمىنظٍن ًـس ؤن طظؿدرم مو خألهُي‪.‬‬

‫‪BFMatcher.match() and‬‬ ‫رهً بنشدء خًـٔم‪ ،‬هندن ؾًُلظدن هدمظدن هٌل‬
‫)(‪ ،BFMatcher.knnMatch‬ؤوي ؾًُلص طهًٌ ؤفػٍ مؿدرلص‪ ،‬وػدين ؾًُلص طهًٌ ‪ k‬مؿدرلص ؤكٍ‪،‬‬
‫كٌؽ ‪ k‬طظلًي من كزٍ خملٔظوًَ‪ٌ .‬نون ؤن طوىن مفًٌش ننًمد نلظدؾ رإن نلىَ رهمٍ بغديف‬
‫نىل ًٌى‪.‬‬
‫هٌل هند نٔظوًَ خًظدرو )(‪ًُٓ cv2.drawKeypoints‬م خًنلدؽ‪ٓ ،‬نٔظوًَ خًظدرو‬
‫)(‪ cv2.drawMatches‬خًٍي ًٔدنًند نىل َٓم خملؿدرلدض‪ .‬فهى ًػو خًطىَطٍن رشوٍ ؤفلٍ وًُٓم‬
‫خًوؿىؽ من ؤوي ضىَش ًؼدين ضىَش ًٌكهُ ؤفػٍ خملؿدرلدض‪ .‬هندن ؤًػد خًظدرو‬
‫‪ cv2.drawMatchesKnn‬وخًٍي ًُٓم هٍ ‪ K‬ألفػٍ خملؿدرلدض‪ .‬بٌخ ‪ٓ k=2‬ىف ًُٓم هؿٍن‬
‫مؿدرلص ًوٍ نلؿص ؤٓدٌٓص‪ًًٍ .‬ى ًـس ؤن منَُ كندم بٌخ ؤَيند ؤن نُٓم رشوٍ خنظلديئ‪.‬‬
‫ينند نإهٍ مؼدي وخكً نىل هٍ من ‪ SURF‬و‪( ORB‬هٍ وخكً منهم ًٔظهمٍ كٌدٓدض مٔدفص‬
‫موظٌفص)‪.‬‬

‫مالككص‪ :‬يف هٍ خًزلؽ كم رظنطٌس ‪ opencv3.0‬وغو رًي خًظدرو )( ‪ ORB‬خًظدرو )( ‪.ORB_create‬‬
‫خًظدرو ‪ drawMatches‬يًن مىؿىي يف موظزص ‪ OpenCv‬خإلضًخَ ‪.4‬‬
‫ًًٍى بٌخ ؤَيض خٓظهٌلي خإلضًخَ ‪ 4‬من ‪ OpenCv‬كم روظدرص خًظدرو ‪ drawMatches‬رشوٍ ًًوي‬
‫هٌل هى مٍسوق يف خًُخرـ خًظديل‪:‬‬
‫‪https://www.codementor.io/tips/5193438072/module-object-has-no-attribute-‬‬
‫‪ drawmatches-opencv-python‬ذ‬

‫ذ‬
‫‪297‬‬ ‫‪ OpenCv‬ببساطة‬

‫ؿطابؼةذاؾؼوةذادلدقطرةذؿعذاؾواصفذ‪ :ORB‬ذ‬

‫هند ٓنشدهً ؤرٔـ مؼدي وهى هٌف نؿدرم خملٌّخض رٍن ضىَطٍن‪ .‬يف هٍه خًلدًص‪ًًً .‬ند‬
‫‪ queryImage‬و‪ٓ .trainImage‬نلإوي بًـدي ‪ queryImage‬يف ‪ trainImage‬ردٓظوًخَ مٌّش‬
‫خملؿدرلص‪( .‬خًطىَ هٍ ‪ box.png‬و ‪.)box_in_scene.png‬‬
‫(‪ queryimage‬هٍ ضىَش خًـٔم خملؿٌىذ‪ ،‬و‪ trainImage‬هٍ خًطىَش خًظٍ ٓنزلؽ غمنهد نن خًـٔم‬
‫خملؿٌىذ)‪.‬‬
‫ٓنٔظوًَ خًىخضف ‪ SFIT‬ملؿدرلص خملٌّخض‪ًًٍ ،‬ى ينند نزًؤ رظلمٌٍ خًطىَش وبًـدي خألوضدف‪.‬‬
‫‪import numpy as np‬‬
‫‪import cv2‬‬
‫‪from matplotlib import pyplot as plt‬‬

‫‪img1 = cv2.imread('carr.png') # queryImage‬‬
‫‪img2 = cv2.imread('car.jpg') # trainImage‬‬

‫‪# Initiate SIFT detector‬‬
‫)(‪orb = cv2.ORB_create‬‬

‫‪# find the keypoints and descriptors with SIFT‬‬
‫)‪kp1, des1 = orb.detectAndCompute(img1,None‬‬
‫)‪kp2, des2 = orb.detectAndCompute(img2,None‬‬
‫ذ‬

‫ػم ٓنلىَ رةنشدء ؿٔم مؿدرلص ‪ BF‬مو مٔدفص كٌدْ ‪( cv2.NORM_HAMMING‬ألنند‬
‫نٔظهمٍ ‪ )ORB‬و نلىَ رظفهٌٍ ‪ًٌ crossCheck‬لطىي نىل نظدثف ؤفػٍ‪ ،‬ػم نٔظهمٍ‬
‫ؾًُلص)(‪ً match‬نلطٍ نىل ؤفػٍ مؿدرلص رٍن ًطىَطٍن‪ .‬ػم نلىَ ررتطٌس مٔدفدطهد رشوٍ‬
‫ططدنًي ألن خملؿدرلص ٓظطزم ؤفػٍ ‪ .‬ػم ٓرنٓم ؤوي نٍس مؿدرلدض (فلـ من خؿٍ وغىق خًظؿدرم‬
‫يف خًُٓم)‪ٌ .‬نونى ًِديش نًي خملؿدرلدض هٌل طًًُ‪.‬‬
298 ‫ ببساطة‬OpenCv

# create BFMatcher object
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)

# Match descriptors.
matches = bf.match(des1,des2)

# Sort them in the order of their distance.
matches = sorted(matches, key = lambda x:x.distance)

# Draw first 10 matches.
img3 = cv2.drawMatches(img1,kp1,img2,kp2,matches[:10],None, flags=2)

cv2.imshow('Matches ',img3)
cv2.waitKey()
cv2.destroyAllWindows()
‫ذ‬

:‫شدهً خًنظٌـص خًظٍ كطٌند نٌٌهد‬
‫ذ‬

‫ذ‬
‫‪299‬‬ ‫‪ OpenCv‬ببساطة‬

‫مبُهىُظعمُاملؼبتلخ؟ ُ‬
‫خًندطف من )‪ matches = bf.match(des1,des2‬هـ من كدمئص خألؿٔدَ ‪.DMatch‬‬
‫خًـٔم ‪ٌ DMatch‬نٌى خًطفدض خًظدًٌص‪:‬‬
‫‪ :DMatch.distance .8‬خملٔدفص رٍن نلدؽ خًىضف‪ ،‬هٌٌل هدنع ؤكٍ هٌٌل هدن ؤفػٍ‪.‬‬
‫‪ :DMatch.trainIdx .4‬كدمئص رنلدؽ خًىضف ملؿدرلص خًطىَش ‪( train‬خًطىَش خًظٍ ٓنزلؽ‬
‫فٌهد نن خًـٔم)‪.‬‬
‫‪ :DMatch.queryIdx .4‬كدمئص رنلدؽ خًىضف ملؿدرلص خًطىَش ‪( query‬ضىَش خًـٔم‬
‫خملؿٌىذ)‪.‬‬
‫‪ :DMatch.imgIdx .3‬كدمئص رنلدؽ خًىضف ًٌطىَش ‪... img‬‬

‫‪ ‬مؼبتلخُ‪ُ :FLANN based‬‬
‫مؿدرلص ‪ FLANN‬طٔظنً نىل موظزص ‪ً FAST‬ظلًُس خًنلدؽ خملـإوَش‪ ،‬وطلىي نىل مـمىنص من‬
‫خًوىخَِمٌدض خملؼدًٌص ًظرسًو خًزلؽ نن خًنلؿص خألكُذ يف كىخنً خًزٌدندض خًوزًنش‪ ،‬وخملٌّخض‬
‫وخألرهدي خًؼدنىًص‪ .‬هٍه خملؿدرلص طهمٍ ررسنص ؤهرب من ‪ BFMatcher‬ردًنٔزص ًلىخنً خًزٌدندض‬
‫خًوزًنش‪.‬‬
‫شدهً خملؼدي خًظديل خًٍي ٓنٔظهمٍ فٌه خملؿدرلص ‪.FLANN based‬‬
‫ردًنٔزص ملؿدرلص ‪ FLANN based‬نلن رلدؿص ًظمًُُ مرتؿمٍن وخًًٍن ًلًيخن خًوىخَِمٌص خًظٍ‬
‫ًـس ؤن طٔظهمٍ‪ .‬ردَومرتخطه مرتخرؿص مو رهػهد‪ .‬ؤوي ردَخمرت هى ‪ .IndexParams‬ردًنٔزص‬
‫ملوظٌف خًوىخَِمٌدض‪ً ،‬ظم ٌسق خملهٌىمدض خًظٍ ًظم متًُُهد يف ورؼةذاؾبحثذ‪.FLANN‬‬
‫مٌوظ‪:‬‬
‫ردًنٔزص ًوىخَِمٌدض مؼٍ ‪ SFIT‬و‪ً SURF‬ظم متًُُ خًلٌم خًظدًٌص‪:‬‬

‫)‪index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5‬‬

‫ذ‬
‫‪300‬‬ ‫‪ OpenCv‬ببساطة‬

‫ؤمد ردًنٔزص ًوىخَِمٌص مؼٍ ‪ ORB‬منَُ خًلٌم خًظدًٌص (ًفػٍ ؤن متَُ خًلٌم خملىؿىيش يف وَكص‬
‫خًزلؽ‪ .‬وًون يف رهؼ خألكٌدن كً ال طهؿٌند خًنظٌـص خملُيىرص ًًٍى ٓنمَُ كٌم ؤهُي طهمٍ رشوٍ‬
‫ؿًٌ)‪.‬‬
‫‪index_params= dict(algorithm = FLANN_INDEX_LSH,‬‬
‫‪table_number = 6, # 12‬‬
‫‪key_size = 12, # 20‬‬
‫‪multi_probe_level = 1) #2‬‬
‫ذ‬

‫ػدين مرتؿم هى ‪ ،SearchParams‬هٍخ خملرتؿم ًلًي نًي مُخض شـُش خًفهُْ خًظٍ ًنزًٍ‬
‫خؿظٌدِ طوُخَهد‪ .‬ؤنىل خًلٌم طهؿٍ يكص ؤفػٍ‪ ،‬وًون ًإهٍ ؤًػد خملًًّ من خًىكع‪ .‬بٌخ هنع طًًُ‬
‫طًًن خًلٌمص مَُ‪:‬‬
‫)‪ search_params = dict(checks=100‬ذ‬

‫مو هٍه خملهٌىمدض نلن نىل مد ًُخَ‪.‬‬
301 ‫ ببساطة‬OpenCv

import numpy as np
import cv2

img1 = cv2.imread('carr.png') # queryImage
img2 = cv2.imread('car.jpg') # trainImage

# Initiate SIFT detector
orb = cv2.ORB_create()

# find the keypoints and descriptors with SIFT
kp1, des1 = orb.detectAndCompute(img1,None)
kp2, des2 = orb.detectAndCompute(img2,None)

# FLANN parameters
FLANN_INDEX_LSH = 6
#help(dict)
index_params= dict(algorithm = FLANN_INDEX_LSH,
table_number = 6, # 12
key_size = 12, # 20
multi_probe_level = 1) #2

search_params = dict(checks=50) # or pass empty dictionary

flann = cv2.FlannBasedMatcher(index_params,search_params)

matches = flann.knnMatch(des1,des2,k=2)

# Need to draw only good matches, so create a mask
matchesMask = [[0,0] for i in xrange(len(matches))]

# ratio test as per Lowe's paper
for i,(m,n) in enumerate(matches):
if m.distance < 0.7*n.distance:
matchesMask[i]=[1,0]

draw_params = dict(matchColor = (0,255,0),
singlePointColor = (255,0,0),
matchesMask = matchesMask,
flags = 0)

img3 = cv2.drawMatchesKnn(img1,kp1,img2,kp2,matches,None,**draw_params)

cv2.imshow('MatchesKnn ',img3)
cv2.waitKey()
cv2.destroyAllWindows()
‫ذ‬
‫‪302‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪:‬‬

‫رشػُامكىد‪ُ :‬‬
‫خألٓؿُ خألوىل يف خًوىي طم ٌسكهد مٔزلدً‪ ،‬كٌؽ كمند رةنشدء ؿٔم خملؿدرلص ‪ ORB‬ػم كمند رةًـدي‬
‫خًنلدؽ خألٓدٌٓص وخًىضف ًوٍ من خًطىَطٍن‪.‬‬
‫‪# FLANN parameters‬‬
‫‪FLANN_INDEX_LSH = 6‬‬
‫‪index_params= dict(algorithm = FLANN_INDEX_LSH,‬‬
‫‪table_number = 6, # 12‬‬
‫‪key_size = 12, # 20‬‬
‫‪multi_probe_level = 1) #2‬‬
‫ذ‬

‫‪ٌ index_params‬نؼٍ كٌمص خًزدَخمرت خألوي ًٌظدرو )(‪ ،FlannBasedMatcher‬وقٌفظه بنشدء فهُْ‬
‫ًٌزلؽ نن خًزٌدندض خألوًٌص ًوٍ نلؿص‪ .‬بن بنشدء ماٌس (فهُْ) ًوٍ نلؿص ٌٓٔهٍ نٌٌند نمٌٌص‬
‫خًزلؽ‪.‬‬
‫خملظًًن خألوي ًٌفهُْ هى ‪ algorithm‬وقٌفظه طلًًً خًوىخَِمٌص خملٔظهمٌص ًزندء خًفهُْ‪ ،‬وًإهٍ‬
‫ؤكً ًلٌم خًظدًٌص‪.'linear', 'kdtree', 'kmeans', 'composite' or 'autotuned' :‬‬
‫‪ ‬خًوٌدَ ‪ linear‬ال ًنشإ ؤي فهُْ‪ ،‬وبمند ًٔظوًَ خملؿدرلص ‪ًٌ BF‬زلؽ نن خًنلدؽ خألٓدٌٓص‪.‬‬
‫‪ ‬خًوٌدَ ‪ً kdtree‬نشإ فهُْ وخكً ؤو ؤهًت رشوٍ موؿـ شـُي وًظم ًٌى رشوٍ نشىخيئ‪.‬‬
‫‪ ‬خًوٌدَ ‪ً kmeans‬نشإ فهُْ نىل شوٍ طٌٍٔٔ هُمٍ‪ .‬ردكٍ خًوٌدَخض مٍسوكص يف ورؼةذ‬
‫اؾبحثذ‪.FLANN‬غمن خًفلُش ‪3.3.1‬‬
‫‪303‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬وخملظًًن خًؼدين هى ‪ table_number‬نًي ؤكٔدَ خًـًؤوي خًظٍ ٓنٔظهمٌهد (نديش طوىن‬
‫رٍن ‪ 85‬و‪.)45‬‬
‫‪ ‬خملظًًن خًؼدًؽ ‪ٌ key_size‬نؼٍ كٌدْ مفظدق خًظلٌٔم ردًزظدض (‪.)bit‬‬

‫ؾالرالعذعؾىذذرحذفذهذادلتغرياتذاـتؼلذدلوؼعذؾوقبذاخلاصذبشرحذتوابعذ‪OpenCV‬ذ‬
‫‪ http://docs.opencv.org‬ذ‬
‫ذ‬

‫‪search_params = dict(checks=50) # or pass empty dictionary‬‬
‫ذ‬

‫‪ ،‬هٍخ خًٔؿُ ًلًي نًي مُخض شـُش خًفهُْ خًظٍ ًنزًٍ خؿظٌدِ طوُخَهد‪ .‬هٌٌل هدنع خًلٌمص ؤنىل‬
‫هٌٌل هدنع خًًكص ؤفػٍ‪ ،‬وًون ٓظإهٍ ؤًػد خملًًّ من خًىكع‪ًًٍ .‬ى كم رًّديطهد فلـ ننً خًلدؿص‬
‫ًًٍى‪.‬‬
‫ذ‬

‫)‪flann = cv2.FlannBasedMatcher(index_params,search_params‬‬
‫ذ‬

‫خًظدرو خملٔاي نن طلًًً مهدًًن خملؿدرلص‪ .‬منَُ ًهٍخ خًظدرو خًلٌم خًظٍ نُفندهد وهٌل‬
‫‪ index_params‬و‪.search_params‬‬
‫)‪matches = flann.knnMatch(des1,des2,k=2‬‬
‫ذ‬

‫بًـدي ؤفػٍ مؿدرلص رٍن هٍ وخضف ًٌطىَطٌٍن‪.‬‬
‫ذ‬
‫‪304‬‬ ‫‪ OpenCv‬ببساطة‬

‫مٌضحُاملؼبتلخُ‪ُHomographyُ+‬إلًعبدُاألظعبو ُ‬

‫ملذمخ‪ُ :‬‬
‫خآلن ؤضزلند نهُف مد هٍ مؿدرلص خملٌّخض‪ ،‬ينند خآلن نًمـهد مو خًنمـ ‪ calib3d‬إلًـدي خألؿٔدَ‬
‫يف خًطىَش خملهلًش‪.‬‬
‫ذ‬

‫امهذف‪ُ :‬‬
‫ٓنًمف رٍن مٌّش خملؿدرلص و‪ findHomography‬من خًنمـ ‪ calib3d‬إلًـدي خألؿٔدَ‬
‫خملهُوفص يف خًطىَش خملهلًش‪.‬‬
‫ؤظبظٌبد‪ُ :‬‬
‫نفهٍ مد فهٌنده يف خًفطٍ خًٔدرم‪ .‬نىؿً رهؼ خًنلدؽ خملمٌّش يف خًطىَش ‪ ،query‬ونىؿً ؤًػدً‬
‫خًنلدؽ خملمٌّش يف خًطىَش ‪ ،train‬ونىؿً ؤفػٍ مؿدرلص رٌنهم‪ .‬روٌٌلض موظرصش ٓنىؿً رهؼ‬
‫ؤؿّخء ؿٔم مد يف ضىَش ؤهُي مشىشص‪ .‬هٍه خملهٌىمدض يًن هدفٌص إلًـدي خًـٔم ردًػزـ يف‬
‫خًطىَش ‪.query‬‬
‫ًًٍى ٓنٔظوًَ خًنمـ ‪ calib3d‬ؤي )(‪ .cv2.findHomography‬بٌخ مَُند مـمىنص من خًنلدؽ‬
‫من هال خًطىَطٍن‪ٓ ،‬ىف ًىؿً خًظلىًٍ مزظًده يف ًٌى خًـٔم‪ .‬رهً ًٌى ٌنونند خٓظوًخَ خًظدرو‬
‫)(‪ cv2.perspectiveTransform‬إلًـدي خًـٔم‪ .‬بنهد طلظدؾ فهُْ رإَرو نلدؽ ضلٌلص إلًـدي‬
‫هٍخ خًظلىي‪.‬‬
‫ًلً شدهًند هٌف ؤنه ٌنون ؤن ًلطٍ رهؼ خألهؿدء خمللظمٌص ننً نمٌٌص خملؿدرلص وخًظٍ كً طاػُ‬
‫نىل خًنظٌـص‪ً .‬لٍ هٍه خملشوٌص نٔظوًَ هىخَِمٌص ‪ RANSAC‬ؤو ‪( LEAST_MEDIAN‬وًٌى‬
‫نن ؾًُم خألنالَ)‪ .‬كٌؽ نٔمٍ خملؿدرلص خًـًٌش خًظٍ طلًَ طلًًُخض ضلٌلص ‪ inliers‬وخملظزلٌص‬
‫طٔمى رـ ‪.outliers‬‬
305 ‫ ببساطة‬OpenCv

‫ ينىند‬.outliers َ‫ ؤ‬inliers ‫ ًهًٌ خًلندم خًٍي ًلًي هٍ خًنلدؽ‬cv2.findHomography() ‫خًظدرو‬
!!‫نلم رًٍى‬
ُ :‫امكىد‬
ٍ‫) إلًـدي ؤفػ‬ratio test( َ‫ يف خًطىَش ونؿزم نٔزص خالهظزد‬SFIT ‫نىؿً يف خًزًخًص هٌل خنظًند ٓمص‬
.‫مؿدرلص‬
import numpy as np
import cv2
from matplotlib import pyplot as plt

MIN_MATCH_COUNT = 10

img1 = cv2.imread('box.png',0) # queryImage
img2 = cv2.imread('box_in_scene.png',0) # trainImage

# Initiate SIFT detector
sift = cv2.SIFT()

# find the keypoints and descriptors with SIFT
kp1, des1 = sift.detectAndCompute(img1,None)
kp2, des2 = sift.detectAndCompute(img2,None)

FLANN_INDEX_KDTREE = 0
index_params = dict(algorithm = FLANN_INDEX_KDTREE, trees = 5)
search_params = dict(checks = 50)

flann = cv2.FlannBasedMatcher(index_params, search_params)
matches = flann.knnMatch(des1,des2,k=2)

# store all the good matches as per Lowe's ratio test.
good = []
for m,n in matches:
if m.distance < 0.7*n.distance:
good.append(m)

‫ذ‬

)MIN_MATCH_COUNT ‫خآلن نػزـ نىل خألكٍ ٌسوؽ ؤَرو مؿدرلدض (ط ُ َلً ْي من كزٍ خًهٌم‬
‫ وبال روٍ رٔدؾص نهُع َٓدًص طلىي بن خملؿدرلدض خملىؿىيش‬.‫ًـس ؤن طوىن مىؿىيش إلًـدي خًـٔم‬
.‫كدًٌد يًن هدفٌص‬
306 ‫ ببساطة‬OpenCv

‫بٌخ طم خًهؼىَ نىل مد ًوفٍ من خملؿدرلدض نٔظوُؾ مىخغو خًنلدؽ خألٓدٌٓص ًٌمؿدرلدض يف هال‬
،3×3 ًٍ‫ كدملد نلطٍ نىل مطفىفص خًظلى‬.‫ خًظٍ طم متًُُهد ًٌـً خًظلىًٍ مزظًده‬.‫خًطىَطٍن‬
‫ ػم‬.train ‫ بىل مد ًلدرٌهد من خًنلدؽ يف خًطىَش‬query ‫نٔظوًمه ًظلىًٍ خًّوخًد من خًطىَش‬
.‫نُٓمهد‬

if len(good)>MIN_MATCH_COUNT:
src_pts = np.float32([ kp1[m.queryIdx].pt for m in good ]).reshape(-1,1,2)
dst_pts = np.float32([ kp2[m.trainIdx].pt for m in good ]).reshape(-1,1,2)

M, mask = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC,5.0)
matchesMask = mask.ravel().tolist()

h,w = img1.shape
pts = np.float32([ [0,0],[0,h-1],[w-1,h-1],[w-1,0] ]).reshape(-1,1,2)
dst = cv2.perspectiveTransform(pts,M)

img2 = cv2.polylines(img2,[np.int32(dst)],True,255,3, cv2.LINE_AA)
else:
print "Not enough matches are found - %d/%d" % (len(good),MIN_MATCH_COUNT)
matchesMask = None

‫ (بٌخ طم رنـدق بًـدي خًـٔم) ؤو نلدؽ خملؿدرلص خألٓدٌٓص (بٌخ فشٍ يف بًـدي‬inliers ‫وؤهًنخ نُٓم‬
)‫خًـٔم‬

draw_params = dict(matchColor = (0,255,0), # draw matches in green color
singlePointColor = None,
matchesMask = matchesMask, # draw only inliers
flags = 2)

img3 = cv2.drawMatches(img1,kp1,img2,kp2,good,None,**draw_params)

plt.imshow(img3, 'gray'),plt.show()
‫‪307‬‬ ‫‪ OpenCv‬ببساطة‬

‫شبهذُامنرٌعخُامربمٌخ‪ُ :‬‬

‫ذ‬

‫ذ‬

‫ذ‬
‫الفصل الثامن‬

‫”الرجل الذي يستخدم مهاراته وخياله البناء لمعرفة أقصى ما يمكن أن‬
‫يقدمه مقابل دولار واحد بدلا ً من التفكير في أقل ما يمكن أي يقدمه‬
‫مقابل نفس الدولار‪ ،‬حتما ً سينجح‟‬

‫هنري فورد – مؤسس شركة فورد للسيارات‬
‫‪309‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُامصبمن‪ُ:‬ذؽنٌهُامفٌذًىُ‪ُ Video Analysis‬‬

‫شدهًند يف خألمؼٌص خًٔدرلص ؾًُلص خًظهلس خنظٌليخ ً نىل خًٌىن‪ ،‬وهٍه خًؿًُلص‬
‫رٌٔؿص ؿًخ ً‪ .‬ؤمد خآلن ٓنشدهً هىخَِمٌص ؤفػٍ مؼٍ ‪ Meanshift‬وخًنٔوص‬
‫خملؿىَش منهد ‪Camshift‬إلًـدي خًٌىن وطهلزه‪.‬‬

‫خآلن ٓنندكش مفهىَ هدَ وهى "‪( " Optical Flow‬خًظًفم خًزرصي) وخًٍي ًه نالكص‬
‫مو خًفًًٌى وطؿزٌلدض نًًًش‪.‬‬

‫نلظدؾ يف نًش طؿزٌلدض ؤن نٔظوُؾ خًوٌفٌص ًظنفٌٍ نًش نمٌٌدض مؼٍ طهلس‬
‫هدثن‪.‬‬

‫ذ‬

‫ذ‬
‫‪310‬‬ ‫‪ OpenCv‬ببساطة‬

‫خىاسصمٌخُ‪ُMeanshift‬و‪ُ :Camshift‬‬

‫ملذمخ‪ُ :‬‬
‫شدهًند يف خألمؼٌص خًٔدرلص ؾًُلص خًظهلس خنظٌليخ ً نىل خًٌىن‪ ،‬وهٍه خًؿًُلص رٌٔؿص ؿًخ ً‪ .‬ؤمد خآلن‬
‫ٓنشدهً هىخَِمٌص ؤفػٍ مؼٍ ‪ Meanshift‬وخًنٔوص خملؿىَش منهد ‪Camshift‬إلًـدي خًٌىن‬
‫وطهلزه‪.‬‬
‫امهذف‪ُ :‬‬
‫ٓنظهٌم ؾًُلص بًـدي خألؿٔدَ يف خًفًًٌى ردٓظوًخَ هىخَِمٌظٍ ‪ Meanshift‬و ‪Camshift‬‬

‫‪ ‬خىاسصمٌخُ‪ُ :Meanshift‬‬
‫خنظرب رإنى متٌى مـمىنص من خًنلدؽ (طىِم خًزٌؤالض ًهٍه خًنلدؽ ًوىن هٌل يف خالٓلدؽ خًوٌفٍ‬
‫ًٌموؿـ خًزٌدين)‪ .‬نلىَ رةنشدء ندفٍش ضًًنش (يخثُش) وًـس نٌٌند طلًُى هٍه خًندفٍش بىل خملنؿلص‬
‫خًظٍ طوىن فٌهد شًش خًزٌؤالض ؤنكمٌص (خملنؿلص خًظٍ ًوىن فٌهد نًي خًنلدؽ ؤنكمٍ)‪ ،‬وهٍخ خألمُ‬
‫مىغم يف خًطىَش خًظدًٌص‪:‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪311‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫خًندفٍش خألوًٌص ط ُهُع نىل شوٍ ندفٍش يخثًُص ًىنهد ؤَِق خٓمهد "‪ً ."C1‬ظم وغو نالمص يف مُهّهد‬
‫خألضًل نىل شوٍ مٔظؿٌٍ ردًٌىن خألَِق ًنٔمه "‪ ."C1_o‬وًون بٌخ ؤوؿًند مُهّ هظٌص خًنلدؽ يخهٍ‬
‫هٍه خًندفٍش ٓىف نلطٍ نىل نلؿص ؤٓمهد "‪( "C1_r‬مهٌمص رًخثُش َِكدء ضًًنش) وخًظٍ متؼٍ‬
‫خملُهّ خًللٌلٍ ًهٍه خًندفٍش‪.‬‬
‫من خملاهً ؤن مُهّ ندفٍش خًًخثُش خألضًل ال ًظؿدرم مو مُهّ هظٌص خًنلدؽ (خملُهّ خًللٌلٍ) ًًٍى‬
‫ًظم طلًُى خًندفٍش خًًخثًُص وؿهٍ مُهّهد خألضًل ًظؿدرم مو خملُهّ خًللٌلٍ‪ ،‬ػم نلىَ مُش ؤهُي‬
‫رةًـدي خًنلؿص خملُهًّص خًـًًًش وخملُهّ خًللٌلٍ‪ .‬يف خًًدًس ًن ًظؿدرم خملُهّ خألضًل ًٌندفٍش‬
‫خًًخثًُص مو خملُهّ خًللٌلٍ‪ًًٍ ،‬ى نلُن خًندفٍش خًًخثًُص مُش ؤهُي ًٌؿدرم مُهّهد مو خملُهّ‬
‫خًللٌلٍ‪ ،‬ونٔظمُ يف طوُخَ هٍخ خألمُ كظى ًطزم مُهّ خًندفٍش خًًخثًُص منؿزلد مو خملُهّ‬
‫خًللٌلٍ (مو ؤضًُ هؿإ ملزىي)‪ًًٍ .‬ى ؤهًنخ ً مد نلطٍ نٌٌه هى ندفٍش فٌهد طىِم خًزٌؤالض‬
‫ؤنكمٍ‪ .‬هٍه خًندفٍش خألهًنش مهٌمص رًخثُش ردًٌىن خألهٍص ؤٓمهد "‪ ،”C2‬مبشدهًش خًطىَش خًٔدرلص‬
‫ٓظـً ؤن هٍه خًًخثُش طلىي ؤهرب نًي من خًنلدؽ‪.‬‬
‫ذ‬

‫ذ‬
312 ‫ ببساطة‬OpenCv

‫ وبًـدي‬،‫ ٓنلظدؾ يف خًزًخًص بىل طهٌجص خًهًف‬،OpenCv ‫ يف‬Meanshift ‫الٓظهٌلي هىخَِمٌص‬
ٍ‫) ًٌهًف نىل ه‬backproject( ٍ‫موؿؿه خًزٌدين ًنظمون من خًلٌدَ رهمٌٌص خإلٓلدؽ خًوٌف‬
‫ ردًنٔزص‬.‫ وٓنوىن ؤًػد رلدؿص ًظىفًن خملىكو خألضًل ًٌندفٍش‬.Meanshift ‫ًلٔدذ‬frame َ‫بؾد‬
َ‫ وؤًػد ًظـنس خًلٌم خًودؾجص رٔزس غهف خإلغدءش نلى‬.‫ًٌموؿـ خًزٌدين نإهٍ فلـ خًظًَؾ خًٌىين‬
.cv2.inRange() ‫رةهٌلي كٌم خإلغدءش خملنوفػص نن ؾًُم خًظدرو‬
‫ذ‬
import numpy as np

import cv2 ‫ذ‬

cap = cv2.VideoCapture('slow.flv') ‫ذ‬

# take first frame of the video
ret,frame = cap.read() ‫ذ‬

# setup initial location of window ‫ذ‬
r,h,c,w = 50,100,25,100 # simply hardcoded the values
track_window = (c,r,w,h) ‫ذ‬

# set up the ROI for tracking
roi = frame[r:r+h, c:c+w] ‫ذ‬
hsv_roi = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.))) ‫ذ‬
roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180])
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX) ‫ذ‬

# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1 ) ‫ذ‬
while(1):
ret ,frame = cap.read() ‫ذ‬

if ret == True:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1)

# apply meanshift to get the new location
ret, track_window = cv2.meanShift(dst, track_window, term_crit)

# Draw it on image
x,y,w,h = track_window
cv2.rectangle(frame, (x,y), (x+w,y+h), 255,2)
cv2.imshow('img2',frame)
‫‪313‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪k = cv2.waitKey(60) & 0xff‬‬
‫‪if k == 27:‬‬
‫‪break‬‬
‫‪else:‬‬
‫)‪cv2.imwrite(chr(k)+".jpg",frame‬‬
‫‪else:‬‬
‫‪break‬‬

‫)(‪cv2.destroyAllWindows‬‬
‫)(‪cap.release‬‬
‫ذ‬

‫رشػُامكىد‪ُ :‬‬
‫خنطلى كزٍ كُخءش ٌسق هٍخ خًوىي ؤن طلُؤ ٌسق خًوىي خملىؿىي يف رلؽ خالٓلدؽ خًوٌفٍ ًٌموؿـ‬
‫خًزٌدين يف خًطفلدض ‪ 800،805،807‬كظى طفهم خًوىي خًظديل ؿًٌخ ً‪.‬‬
‫‪# setup initial location of window‬‬
‫‪r,h,c,w = 50,100,25,100 # simply hardcoded the values‬‬
‫)‪track_window = (c,r,w,h‬‬

‫ذ‬

‫هًٍن خًٔؿًُن من خًوىي ًظهٌجص خًندفٍش خًظٍ ٓظظػمن خًـٔم خملؿٌىذ طهلزه‪ .‬هند خهرتند ؤن ًزًؤ‬
‫َٓم خملٔظؿٌٍ من خإلكًخػٌص )‪ (50,100‬رؿىي ونُع ‪ 855‬ؤي خًـٔم خًٍي ٓظم طهلزه ٌٓوىن‬
‫غمن هٍخ خملٔظؿٌٍ‪.‬‬
‫]‪roi = frame[r:r+h, c:c+w‬‬
‫)‪hsv_roi = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV‬‬
‫)))‪mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.‬‬
‫ذ‬

‫كًيند خملنؿلص من خًفًًٌى خًظٍ ٓزًؤ ننًهد ًُٓم ‪ ،roi‬ػم كىًند خًفًًٌى ًٌفػدء خًٌىين ‪HSV‬‬
‫ًٔهىًص طلًًً خملـدي خًٌىين خًٍي ٓنظهلزه‪ ،‬ػم كًيند خملـدي خًٌىين ًٌلندم ‪ mask‬رٍن مـدي‬
‫ًىين مهٍن‪.‬‬
‫)]‪roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180‬‬
‫ذ‬

‫ٓنٔظوًَ خًظدرو )(‪ًٌ cv2.calcHist‬هؿٌنٌد فوُش نن طىِم خًشًش خًٌىنٌص ًزٌؤالض ضىَش خًـٔم‬
‫خملؿٌىذ غمن خًلندم ‪( mask‬مُ مهند مٔزلدً)‬
‫‪314‬‬ ‫‪ OpenCv‬ببساطة‬

‫خملظًًن خألوي ضىَش خًًهٍ‪ ،‬وخًؼدين ًلًي خًلندش خًٌىنٌص خًظٍ ٓنلٔس ًه خملوؿـ خًزٌدين‪ ،‬وخًؼدًؽ‬
‫ٌنؼٍ خًلندم‪ ،‬وخًُخرو ًلًي كٌمص خي‪ BIN‬وخًودمٕ ًلًي خملـدي‪.‬‬
‫)‪cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX‬‬
‫ذ‬

‫ذ‬

‫‪# Setup the termination criteria, either 10 iteration or move by atleast 1 pt‬‬
‫) ‪term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1‬‬
‫ذ‬

‫هٍخ خملظًًن ٓنمَُه ًٌظدرو بًـدي خًـٔم )(‪( cv2.meanShift‬خنكُ ًلٓفٍ)‪ .‬وقٌفظه هٍ غزـ‬
‫مهٌدَ بًلدف ندفٍش خًزلؽ نن طوُخَ خًزلؽ‪ٓ ،‬نلىَ هند رػزـ مهٌدَ طوُخَ خًزلؽ نىل ‪85‬‬
‫طوُخَخض‪ ،‬ومبهٌدَ طلُن ندفٍش خًزلؽ مبد ال ًلٍ نن نلؿص‪.‬‬
‫‪while(1):‬‬
‫)(‪ret ,frame = cap.read‬‬
‫ذ‬

‫ٓنشإ كٌلص )‪ while(1‬طوُخًَص ال نهدثٌص كظى نلُؤ ؿمٌو بؾدَخض خًفًًٌى‪ً ،‬نلىي هدمٍ بؾدَخض‬
‫خًطىَش خملوىنص ًٌفًًٌى من خًفػدء خًٌىين ‪ RGB‬بىل ‪ ، HSV‬ػم ًنؿزم نٌٌهد نمٌٌص خالٓلدؽ‬
‫خًوٌفٍ‪ ،‬ػم ًنؿزم هىخَِمٌص ‪ ،Camshift‬ػم ًرنٓم مٔظؿٌٍ كىي خًـٔم ملؿٌىذ خًٍي نظهلزه‪.‬‬
‫‪if ret == True:‬‬
‫)‪hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV‬‬
‫)‪dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1‬‬
‫ذ‬

‫خملظًًن ‪ٓ ret‬ظوىن كٌمظه ‪ True‬مد يخَ خًفًًٌى مل ًنظهٍ‪ ،‬وننً خنظهدثه ٓظطزم كٌمظه ‪.False‬‬
‫رهً ؤن خهظربند خًٍسؽ رإنه مللم ٓنلىي هٍ بؾدَ ضىَش ًٌفًًٌى بىل خًفػدء ‪ .HSV‬ونؿزم نىل‬
‫منؿلص ضىَش خًـٔم خًٍي ٓنظهلزه نمٌٌص خالٓلدؽ خملوؿـ خًزٌدين نىل خًوٌفٌص‪.‬‬
‫(طم ٌسق خًظدرو ‪ cv2.calcBackProject‬مٔزلدً يف فطٍ خإلٓلدؽ خًوٌفٍ ًٌموؿـ خًزٌدين)‬

‫‪# apply meanshift to get the new location‬‬
‫)‪ret, track_window = cv2.meanShift(dst, track_window, term_crit‬‬
‫ذ‬

‫هند ٓنؿزم هىخَِمٌص ‪Meanshift‬كظى نهُف خملىغو خًٍي ًظلُن بًٌه خًـٔم‪.‬‬
‫‪315‬‬ ‫‪ OpenCv‬ببساطة‬

‫مظًًنخض خًظدرو ‪ cv2.meanShift‬هٍ‪:‬‬
‫‪cv2.meanShift(probImage, window, criteria) → retval, window‬‬
‫‪ ‬خملظًًن خألوي‪ٓ :‬نمَُ ًه نظٌـص خإلٓلدؽ خًوٌفٍ ًٌموؿـ خًزٌدين ًٌـٔم خملؿٌىذ‪.‬‬
‫‪ ‬خملظًًن خًؼدين‪ٓ :‬نمَُ ًه ندفٍش خًزلؽ خألوًٌص (ؤوي مودن يف خًطىَش ٓنزًؤ ننًه خًزلؽ‬
‫نن خًـٔم)‪.‬‬
‫‪ ‬خملظًًن خًؼدًؽ‪ً :‬لًي خًٍسؽ خًٍي ٌٓظم فٌه بًلدف ندفٍش خًزلؽ نن طوُخَ خًزلؽ‪،‬‬
‫ومهٌدَ طلُن خفٍش خًزلؽ (ملًخَ خنًّدكهد)‪.‬‬
‫(انظشُيفُاألغىلُمرشػُهزاُاملرغري) ُ‬
‫ٌٓهًٌ ًند هٍخ خًظدرو خملىكو خًـًًً ًندفٍش خًزلؽ وكـمهد (‪.)track_window‬‬
‫‪# Draw it on image‬‬
‫‪x,y,w,h = track_window‬‬
‫)‪cv2.rectangle(frame, (x,y), (x+w,y+h), 255,2‬‬
‫ذ‬

‫ٓنوّن مىغو ندفٍش خًزلؽ خًـًًًش وكٌمظهد يف ‪ ،x,y,w,h‬ػم ٓرنٓم مٔظؿٌٍ يف مودن ندفٍش‬
‫خًزلؽ‪.‬‬
316 ‫ ببساطة‬OpenCv

ُ :Camshiftُ‫ خىاسصمٌخ‬
‫هٍ شدهًض رًكص خًنظٌـص خملدغٌص؟ هندن مشوٌص وهٍ ؤن خًندفٍش متٌى نفٕ خًلٌدْ ٓىخء هدنع‬
‫ وهٍخ خألمُ يًن ؿًٌ فنلن رلدؿص ألن ًظوٌف خإلؾدَ مو كـم‬.‫خًٌٔدَش ؤرهً ؤو ؤكُذ من خًودمًنخ‬
Continuously Adaptive ( Camshift ‫ ًلٍ هٍه خملشوٌص طم بًـدي هىخَِمٌص‬.‫ويوَخن خًهًف‬
‫ يف وَكص رلؼه طلع ننىخن‬Gary Bradsky ٍ‫) من كز‬Meanshift
‫ " ذ‬Computer Vision Face Tracking for Use in a Perceptual User Interface"

:‫آًٌص نمٍ هٍه خًوىخَِمٌص‬
‫ ًظم طلًًؽ كٌدْ خإلؾدَ وفم‬،Meanshift ‫ ومبـُي ؤن طظؿدرم‬،Meanshift ‫ًُؿًزم ؤوال هىخَِمٌص‬

‫ نلىَ مُش‬.‫ وطلٔس ؤًػد خالطـده ألفػٍ كؿو ندكظ مندٓس ًهد‬. √ ‫خملهديًص‬
?
‫مو خًلٌدْ خًـًًً وطلىَ رنفٕ خًوؿىخض خًٔدرلص كظى طظللم خًًكص‬Meanshift ‫ؤهُي رظؿزٌم‬
.‫خملؿٌىرص‬

‫ وًونهد طهًٌ يوَخن خملٔظؿٌٍ (هٍه هٍ نظٌـظند) وردَخمرتخض خًندفٍش‬،Meanshift ٕ‫هٍ طلًُزد نف‬
.‫ شدهً خًوىي خًظديل‬.)‫(طٔظوًَ ًظمَُ هندفص خًزلؽ نن خًظوُخَ خًظديل‬
import numpy as np
import cv2

cap = cv2.VideoCapture('slow.flv')

# take first frame of the video
ret,frame = cap.read()

# setup initial location of window
r,h,c,w = 50,25,50,25 # simply hardcoded the values
track_window = (c,r,w,h)

# set up the ROI for tracking
roi = frame[r:r+h, c:c+w] ‫ذ‬
hsv_roi = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
mask = cv2.inRange(hsv_roi, np.array((0., 60.,32.)), np.array((180.,255.,255.)))
roi_hist = cv2.calcHist([hsv_roi],[0],mask,[180],[0,180])
cv2.normalize(roi_hist,roi_hist,0,255,cv2.NORM_MINMAX)
317 ‫ ببساطة‬OpenCv

# Setup the termination criteria, either 10 iteration or move by atleast 1 pt
term_crit = ( cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 1, 1 )
while(1):
ret ,frame = cap.read()

if ret == True:
hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
dst = cv2.calcBackProject([hsv],[0],roi_hist,[0,180],1)

# apply meanshift to get the new location
ret, track_window = cv2.meanShift(dst, track_window, term_crit)

# Draw it on image
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
cv2.polylines(frame,[pts],True, 255,2)
cv2.imshow('img2',frame)

k = cv2.waitKey(60) & 0xff
if k == 27:
break
else:
cv2.imwrite(chr(k)+".jpg",frame)
else:
break

cv2.destroyAllWindows()
cap.release()
‫ذ‬
318 ‫ ببساطة‬OpenCv

ُ ‫ذ‬:‫ُامنرٌعخ‬
‫ذ‬

ُ
ُ :‫رشػُامكىد‬
‫نفٕ ٌسق خًوىي خًٔدرم مو خهظالف فلـ يف طدرو خًُٓم‬
# Draw it on image
pts = cv2.boxPoints(ret)
pts = np.int0(pts)
cv2.polylines(frame,[pts],True, 255,2)
cv2.imshow('img2',frame)

Opencv 3.0

boxPoints)...(

‫ذذذذ‬boxPoints(box[, points]) -> points

opencv 2.4.11

BoxPoints(...)

BoxPoints(box) -> points
‫‪319‬‬ ‫‪ OpenCv‬ببساطة‬

‫مشاظؼُبطبفٌخ‪ُ :‬‬
‫‪ ‬ضفلص وًوٌزًًٌد ‪ً( Camshift‬ىؿً فٌه َٓمظٍن طىغٌلٌظٍن مظلُهظٍن)‪.‬‬
‫ذ‬

‫امرذفمُامثرصيُ‪ُ :Optical Flow‬‬

‫ملذمخ‪ُ :‬‬
‫خآلن ٓنندكش مفهىَ هدَ وهى "‪( " Optical Flow‬خًظًفم خًزرصي) خًٍي ًهظم ردًفًًٌى رشوٍ‬
‫هدص‪ ،‬ورهًش طؿزٌلدض ؤهُي‪.‬‬
‫امهذف‪ُ :‬‬
‫فهم مفهىَ خًظًفم خًزرصي وهٌفٌص طلًًُه ردٓظوًخَ ؾًُلص ‪.Kanade method‬‬
‫ٓنظهٌم خٓظوًخَ خًظدرو )(‪ً cv2.calcOpticalFlowPyrLK‬ظهلس خًنلدؽ خملمٌّش يف‬
‫خًفًًٌى‪.‬‬
‫ذ‬

‫خًظًفم خًزرصي هى منـ خًلُهص خًكدهًُص ألؿٔدَ خًطىَش رٍن بؾدًَن ضىَش ‪ frames‬مظظدًٌٍن‬
‫خًندؿم نن كُهص خًـٔم ؤو خًودمًنخ‪ .‬وًوىن نزدَش نن كلٍ من خألشهص ػندثٌص خًزهً‪ ،‬وهٍ شهدم‬
‫نزدَش نن شهدم بِخكص ًزٍن كُهص خًنلدؽ رٍن بؾدَ خًطىَش خألوي وخًؼدين‪ .‬شدهً خًطىَش خًظدًٌص‪.‬‬
‫‪320‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫هٍه خًطىَش طهُع خنظلدي خًوُش يف ‪ 0‬بؾدَخض ًٌطىَش‪ً .‬كهُ خًٔهم خملهُوع شهدم خإلِخكص النًّدق‬
‫خًوُش‪ .‬و ٌنون خٓظوًخَ خًظًفم خًزرصي يف خًهًًً من خًظؿزٌلدض هدملـدالض خًظدًٌص‪:‬‬
‫‪ ‬مهُفص ؾزٌهص خًلُهص‪.‬‬
‫‪ ‬غًـ خًفًًٌى‪.‬‬
‫‪ ‬طللٌم خٓظلُخَ خًفًًٌى (‪.)Video Stabilization‬‬
‫خًظًفم خًزرصي ًهظمً نىل نًش فُغٌدض‬
‫‪ .8‬شًش رٌؤالض خًـٔم ال طظًًن رٍن بؾدَي ضىَش مظظدًٌٍن‪.‬‬
‫‪ .4‬خًزٌؤالض خملظـإوَش ًهد كُهص مٌلػٌص‪.‬‬
‫ًنهظرب خًزٌؤٍ خًٍي يف ؤوي بؾدَ ًٌطىَش هى )? ‪( ?(?, ?,‬هند ٓنفلظ رهً ؿًًً ؤال وهى خًىكع‬
‫‪ ،t‬يف خًٔدرم طهدمٌند مو خًطىَ ومل نظهدمٍ مو خًفًًٌى ًًٍى مل نون رلدؿص ًهنرص خًىكع)‪.‬‬
‫خًزٌؤٍ ًظلُن مٔدفص كًَهد (?? ‪ )??,‬يف خإلؾدَ خًظديل ًٌطىَش وًإهٍ ِمن كًَه ??‪ .‬ومبد ؤن‬
‫هٍخ خًزٌؤٍ هى نفٔه فشًش خًزٌؤٍ مل طظًًن‪ ،‬ننًهد ٌنونند خًلىي رإن‪:‬‬

‫ٓنإهٍ منشىَ طدًٌىَ خًظلًُزٍ ًٌلٔم خًٌمٌنٍ من خملهديًص‪ ،‬ونًٍّ خًهىخمٍ خملشرتهص‪ ،‬ونلٔم نىل‬
‫وطٔمى هٍه خملهديًص مبهديًص‬ ‫?? فنلطٍ نىل خملهديًص خًظدًٌص‪:‬‬
‫خًظًفم خًزرصي ‪.Optical Flow‬‬

‫كٌؽ‪:‬‬
‫ذذ ;ذ‬
‫‪321‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذذ ;ذ‬

‫فهٌل ٌنؼالن خًظًَؿدض خًٌىنٌص خًظٍ خًطىَش‪ .‬ورشوٍ‬ ‫و‬ ‫يف هٍه خملهديًص ٌنونند بًـدي‬
‫مٌلػٍ فةن متؼٍ كٌمص خًظًَؾ خًٌىين رهً فرتش من خًىكع‪ .‬وًون )‪ (u,v‬يًن مهُوفص ًًٍى ال‬
‫ٌنونند كٍ هٍه خملهديًص مو وؿىي مظًًنًن يًن مهُوفٍن‪ًًٍ .‬ى طم طىفًن نًش ؾُق ًلٍ هٍه‬
‫خملشوٌص‪ ،‬وبكًي هٍه خًؿُق هٍ ًىهدْ هدنًي ‪.Lucas-Kanade‬‬
‫ررقؼةذؾوؽاسذؽاـدي‪ :‬ذ‬

‫ًلً شدهًند هٍه خًفُغٌص من كزٍ‪ .‬بن هٍ خًزٌؤالض خملـإوَش ٓىف متٌى نفٕ خًلُهص‪.‬‬
‫بن ؾًُلص ًىهدْ طلىَ رإهٍ رلهص رلـم ‪ 3x3‬كىي هٍه خًنلؿص‪ًًٍ .‬ى هٍ ‪ 9‬نلدؽ ٓظمٌى نفٕ‬
‫ًهٍه خًنلدؽ خًظٔهص‪ .‬كظى خآلن طزلى خملشوٌص رلٍ ‪9‬‬ ‫خًلُهص‪ ،‬ننًهد ٌنونند بًـدي‬
‫مهديالض مو مظًًنًن يًن مهُوفٍن‪ .‬خملهديًص خًظدًٌص هٍ خًلٍ خًنهديئ ًلٍ مشوٌص ؿمٌص مهًًظٍن‬
‫مو مـهىًٍن بػنٍن‪ ،‬ورلٍ هٍه خملهديًص نلطٍ نىل خًلٍ‪.‬‬
‫∑‬ ‫∑‬ ‫∑‬
‫] [‬
‫∑‬ ‫∑‬ ‫∑‬
‫[‬ ‫]‬ ‫[‬ ‫]‬

‫(موظشف ِوخًد هدًَٕ ًلىي ًن ؤن ؤفػٍ نلدؽ خًظهلس هٍ خًّوخًد)‪.‬‬
‫ذ‬

‫‪ ‬ػشًلخُمىكبطُكبنذي‪ -‬منرذفمُامثرصيُيفُ‪ُ :OpenCv‬‬
‫طىفُ ًند موظزص ‪OpenCv‬كٍ ؿمٌو خملهديالض خًٔدرلص يف طدرو وخكً وهى‬
‫)(‪.cv2.calcOpticalFlowPyrLK‬‬
‫ٓنلىَ رةنشدء طؿزٌم رٌٔـ ًظهلس رهؼ نلدؽ يف خًفًًٌى‪ً .‬ظلًًً هٍه خًنلدؽ نٔظوًَ خًظدرو‬
‫)(‪ .cv2.goodFeaturesToTrack‬نإهٍ ؤوي بؾدَ ًٌطىَش‪ ،‬ونلًي رهؼ نلدؽ ِوخًد ‪،Shi-Tomasi‬‬
‫ػم رشوٍ مظوَُ نظظزو هٍه خًنلدؽ ردٓظوًخَ ؾًُلص ًىهدْ هدنًي ًٌظًفم خًزرصي‪.‬‬
‫ردًنٔزص ًٌظدرو )(‪ cv2.calcOpticalFlowPyrLK‬فةنند منَُ ًه بؾدَ خًطىَش خًٔدرم وخًنلدؽ خًٔدرلص‬
‫وبؾدَ خًطىَش خًظديل‪ .‬وًهًٌ ًند هٍخ خًظدرو خًنلدؽ خًظدًٌص(خًلديمص) ؿنزد بىل ؿنس مو َكم ًزٍن كدًص‬
322 ‫ ببساطة‬OpenCv

.5 ‫ وبال ٌٓهًٌ كٌمص‬،8 ‫ فةٌخ طم بًـدي خًنلؿص خًظدًٌص ًوىن َكم خًلدًص خمل ُ َزٍن ًىغو خًنلؿص‬،‫هٍ نلؿص‬
:‫ شدهً خًوىي خًظديل‬.‫ونوَُ متًُُ خًنلدؽ خًظدًٌص هٌل مَُند خًنلدؽ خًٔدرلص يف خًوؿىش خًظدًٌص‬
‫ذ‬
import numpy as np
import cv2
cap = cv2.VideoCapture('slow.mp4')

# params for ShiTomasi corner detection
feature_params = dict( maxCorners = 100,
qualityLevel = 0.3,
minDistance = 7,
blockSize = 7 )

# Parameters for lucas kanade optical flow
lk_params = dict( winSize = (15,15),
maxLevel = 2,
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))

# Create some random colors
color = np.random.randint(0,255,(100,3))

# Take first frame and find corners in it
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
p0 = cv2.goodFeaturesToTrack(old_gray, mask = None, **feature_params)

# Create a mask image for drawing purposes
mask = np.zeros_like(old_frame)

while(True):
ret,frame = cap.read()
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

# calculate optical flow
p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)

# Select good points
good_new = p1[st==1]
good_old = p0[st==1]

# draw the tracks
for i,(new,old) in enumerate(zip(good_new,good_old)):
a,b = new.ravel()
c,d = old.ravel()
cv2.line(mask, (a,b),(c,d), color[i].tolist(), 2)
cv2.circle(frame,(a,b),5,color[i].tolist(),-1)
‫‪323‬‬ ‫‪ OpenCv‬ببساطة‬

‫)‪img = cv2.add(frame,mask‬‬

‫)‪cv2.imshow('frame',img‬‬
‫‪k = cv2.waitKey(30) & 0xff‬‬
‫‪if k == 27:‬‬
‫‪break‬‬
‫‪# Now update the previous frame and previous points‬‬
‫)(‪old_gray = frame_gray.copy‬‬
‫)‪p0 = good_new.reshape(-1,1,2‬‬

‫)(‪cv2.destroyAllWindows‬‬
‫)(‪cap.release‬‬
‫ذ‬

‫هٍخ خًوىي ال ًظللم فٌٌل بٌخ هدنع خًنلدؽ خألٓدٌٓص ضلٌلص ؤَ ال‪ .‬وكظى بٌخ خهظفع ؤي نلؿص‬
‫ممٌّش يف خًطىَش‪ ،‬هندن فُضص إلًـدي خًظًفم خًزرصي يف خًنلؿص خًلديمص خًظٍ طزًو كًُزص منهد‪.‬‬
‫ًًٍى ًهظرب هٍخ طهلس كىي‪ ،‬ونلدؽ خًّؤوًص ًـس ؤن ًظم خًزلؽ ننهد هالي فرتخض مهٌنص‪ .‬موظزص‬
‫‪ OpenCV‬وفُض ًند مندٌؾ ؿدهّش ًهٍخ خألمُ مؼٍ بًـدي خًنلدؽ خملمٌّش هٍ ‪ 0‬بؾدَخض ًٌطىَش‪،‬‬
‫وطشًٌٍ خًفلظ خًوٌفٍ ًنلدؽ خًظًفم خًزرصي ًنلطٍ فلـ نىل خًنلدؽ خًـًٌش منهد فلـ‪.‬‬
‫"‪"C:\opencv\sources\samples\python2\lk_track.py‬‬

‫شدهً خًنظٌـص خًظٍ كطٌند نٌٌهد‪:‬‬

‫ذ‬

‫ذ‬

‫ذ‬
324 ‫ ببساطة‬OpenCv

ُ :‫رشػُامكىد‬
# params for ShiTomasi corner detection
feature_params = dict( maxCorners = 100,
qualityLevel = 0.3,
minDistance = 7,
blockSize = 7 )
‫ذ‬

َ‫ ورًالً من خٓظوًخَ خألَكد‬.‫ وقٌفظه طوًّن خًزٌدندض هلدمئص هٌل يف كىخنً خملهؿٌدض‬dic ‫خًظدرو‬
)dict( ‫ فهٍخ ًظٌم ًى خًظهدمٍ مو خًًًوع‬.‫فلـ ًٌىضىي ًٌزٌدندض ٌنونى خٓظوًخَ ؤي شٌح طلًُزد‬
.‫هلدنًش رٌدندض ًظوًّن خًزٌدندض وطنكٌمهد‬
maxCorners ‫ وهّند رًخهٌهد خًهندرص‬feature_params ‫هند نُفند كدنًش مهؿٌدض ردٓم‬
.‫ وؤنؿٌند ًوٍ ننرص كٌمص مهٌنص‬blockSize‫ و‬minDistance‫ و‬qualityLevel‫و‬
# Parameters for lucas kanade optical flow
lk_params = dict( winSize = (15,15),
maxLevel = 2,
criteria = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))
‫ذ‬

winSize ‫ وهّند رًخهٌه خًهندرص‬lk_params ‫ؤًػد هند كمند رظهًُف كدنًش مهؿٌدض ردٓم‬
.criteria‫ و‬maxLevel‫و‬
# Create some random colors
color = np.random.randint(0,255,(100,3))
‫ذ‬

‫ و‬low ‫ رٍن خًلٌمص‬integer ‫ ًهًٌ كٌمص مظًًن نشىخيئ من خًنىم‬numpy.random.randint() ‫خًظدرو‬
numpy.random.randint(low, high, size, dtype)ٍ‫ ًإهٍ خًشو‬hight
‫ذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذذ‬

# Take first frame and find corners in it
ret, old_frame = cap.read()
old_gray = cv2.cvtColor(old_frame, cv2.COLOR_BGR2GRAY)
p0 = cv2.goodFeaturesToTrack(old_gray, mask = None, **feature_params)
‫ذ‬

‫ ذاؾذيذ‬cv2.goodFeaturesToTrack()‫ ذوذؾكذعنذررققذاؾتابعذ‬frame‫اآلنذدـوجدذـؼاطذاؾزواقاذاؾؼوقةذيفذؽلذ‬
‫ ذ‬:‫قلخذذادلتغرياتذاؾتاؾقة‬
325 ‫ ببساطة‬OpenCv

cv2.goodFeaturesToTrack(image, maxCorners, qualityLevel, minDistance[, corners[, mask[,
blockSize[, useHarrisDetector[, k]]]]]) → corners

.‫ خًطىَش خملؿٌىذ كٔدذ نلدؽ خًّوخًص خًلىًص فٌهد‬:Image 
‫ (هٌدَي) بٌخ ؤَيض خهظشدف نلدؽ خًّوخًص ملنؿلص ملًيش من خًطىَش ننًهد ٌنونى‬:Mask 
.None ‫ هند ًن نٔظهمٌه ًًٍى ٓنمَُ خًلٌمص‬،‫متًُُ كٌمص خًلندم خملؿٌىذ‬
‫خملظًًنخض خًزلٌص كمند رظهًُفهد يف رًخًص خًوىي نىل شوٍ كدنًش مهؿٌدض ردٓم‬
:ٍ‫ وهٍه خملظًًنخض ه‬feature_params
‫ بٌخ وؿً نًي ؤهرب من ؤكىص كٌمص‬.‫ ؤكىص نًي ًٌّوخًد خًظٍ ٌٓهًٌهد‬:maxCorners 
.‫ٌٓظم بَؿدم نلدؽ خًّوخًد خألكىي منهد‬
.‫ هٍخ خًزدَخمرت ًلًي نىنٌص خًلً خأليىن خمللزىي ًٌّؤوًص‬:qualityLevel 
‫ ؤكٍ مٔدفص مٔمىكص رٍن خًّوخًد‬:minDistance 
:blockSize 
# Create a mask image for drawing purposes
mask = np.zeros_like(old_frame)
‫ذ‬

‫ خًظدرو‬.‫يف هٍخ خًٔؿُ ٓننشإ كندم ًٌطىَش وخًٍي ٌٓٔدنًند يف نمٌٌص خًُٓم‬
. ‫ ًهًٌ مطفىفص ضفًُص (ؤي ضىَش ٓىيخء) رنفٕ شوٍ ونىم خًطىَش خملهؿدش‬numpy.zeros_like
while(True):
ret,frame = cap.read()
frame_gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
‫ذ‬

.‫مد يخَ خًفًًٌى مل ًنظهٍ ٓنلىي هٍ بؾدَ ضىَش فٌه بىل خملٔظىي خًُمديي‬
‫ذ‬

# calculate optical flow
p1, st, err = cv2.calcOpticalFlowPyrLK(old_gray, frame_gray, p0, None, **lk_params)

‫ذ‬

‫ ذاؾذي ذقلخذذ‬cv2.calcOpticalFlowPyrLK‫اآلن ذدـؼوم ذحبداب ذاؾتدػق ذاؾبصري ذوذؾك ذعن ذررقق ذاؾتابع ذ‬
:‫ادلتغرياتذاؾتاؾقة‬
cv2.calcOpticalFlowPyrLK(prevImg, nextImg, prevPts[, nextPts[, status[, err[, winSize[,
maxLevel[, criteria[, flags[, minEigThreshold]]]]]]]]) → nextPts, status, err
‫‪326‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ :prevImg ‬خًطىَش خًٔدرلص‪( .‬خًفًُم خًٔدرم)‬
‫‪ :nextImg ‬خًطىَش خًظدًٌص‪( .‬خًفًُم خًظديل)‬
‫‪ :prevPts ‬مظـهدض (ؤشهص) بكًخػٌدض خًنلدؽ خًظٍ نلظدؾ ؤن نىؿً خًظًفم ًهد (ٓنمَُ ًه‬
‫بكًخػٌدض نلدؽ خًّوخًد خًلىًص)‪ً .‬ـس ؤن طوىن بكًخػٌدض خًنلدؽ ردًطًٌص ‪.float‬‬

‫‪ً :winSize‬لًي كٌدْ ندفٍش خًزلؽ ننً هٍ مٔظىي هُمٍ‪.‬‬ ‫‪‬‬
‫‪ :maxLevel‬ؤكىص نًي ملٔظىًدض خًهَُ‪ .‬بٌخ مَُند ًه خًلٌمص ‪ 5‬ننًهد ًن ًٔظوًَ‬ ‫‪‬‬
‫خألهُخمدض (مٔظىي وخكً فلـ)‪ ،‬وبٌخ مُنند خًلٌمص ‪ٌٔٓ 8‬ظوًَ مٔظىًٍن هُمٌٍن‪.‬‬
‫‪ً :criteria‬لًي مهٌدَ بنهدء هىخَِمٌص خًزلؽ خملظوَُش‪.‬‬ ‫‪‬‬
‫وًهًٌ ًند هٍخ خًظدرو خًلٌم خًظدًٌص‪:‬‬ ‫‪‬‬
‫‪ً :nextPts‬هؿٌند خملىغو خًـًًً ًٌمٌّخض خملًهٌص (خًّوخًد) يف خًطىَش خًـًًًش (خًظدًٌص)‬ ‫‪‬‬
‫‪ :Status‬كدًص وغو مظـهدض خًوُؾ‪ .‬هٍ مظـهص طإهٍ خًلٌمص ‪ 8‬بٌخ وؿً طًفم يف خًنلؿص‬ ‫‪‬‬
‫خملمٌّش‪ ،‬وبال ٓظإهٍ خًلٌمص ‪ٌٓ( .5‬فًٌند هٍخ خملظًًن يف طلًًً نلدؽ خًّوخًد خممٌّش خًظٍ‬
‫ًظم فٌهد خًظًفم (نلؿص مظلُهص) من طٌى خًظٍ خًظٍ ال ًىؿً فٌهد طًفم (نلؿص ٓدهنص))‪.‬‬
‫‪ :Err‬خألهؿدء خًندؿمص نن خملظـهص‪.‬‬ ‫‪‬‬

‫‪# Select good points‬‬
‫]‪good_new = p1[st==1‬‬
‫]‪good_old = p0[st==1‬‬

‫هند كمند رإهٍ نلدؽ خًظًفم خًـًٌش وكٍفند خًنلدؽ خًظٍ طىكف فٌه خًظًفم (خًنلدؽ خًظٍ طوىن‬
‫كدًظهد طٔإوي خًطفُ ‪ Status=0‬طم كٍفهد)‪ .‬وًلً نُفند خًنلدؽ خملمٌّش خًظٍ كدًص خًظًفم فٌهد‬
‫ؿًٌش ؤَ ال نن ؾًُم طدرو خًظًفم )(‪ cv2.calcOpticalFlowPyrLK‬خًٍي ًهًٌ ًند كٌمص خًـ ‪status‬‬
‫بمد ‪ 8‬بن هدن هندن طًفم يف خًنلؿص خملمٌّش وبال ‪ 5‬بن مل ًون هندن طًفم‪( .‬هند خملظًًن ‪ status‬هى‬
‫‪.)st‬‬
‫‪327‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪# draw the tracks‬‬
‫‪for i,(new,old) in enumerate(zip(good_new,good_old)):‬‬
‫)(‪a,b = new.ravel‬‬
‫)(‪c,d = old.ravel‬‬
‫)‪cv2.line(mask, (a,b),(c,d), color[i].tolist(), 2‬‬
‫)‪cv2.circle(frame,(a,b),5,color[i].tolist(),-1‬‬
‫ذ‬

‫يف هٍخ خألمُ ٓنلىَ رُٓم نلدؽ خًظهلس ومٔدَخض كُهظهد‪.‬‬
‫‪ ‬خًظدرو )(‪ً enumerate‬هًٌ نًي خألؿٔدَ ( نًي خملـمىندض)‪.‬‬
‫‪ ‬خًظدرو )(‪ً zip‬هًٌ هٍخ خًظدرو كدمئص ردملـمىندض‪.‬‬
‫‪ ‬خًظدرو )(‪ًٔ ravel‬ظوًَ ًظلىًٍ خملطفىفص ٓىخء هدنع ‪ 3D‬ؤو ‪ 2D‬بىل مطفىفص ؤكديرص‬
‫خًزهً ‪.1D‬‬
‫ٓنلىَ هند رظوًّن خإلكًخػٌدض خًـًًًش ًٌنلدؽ خملمٌّش )‪(x,y‬يف خملظًًنًن ‪ ،a,b‬وخإلكًخػٌدض‬
‫خًلًٌنص يف خملظًًنًن ‪ .c,d‬ػم ٓنمَُ خإلكًخػٌدض خًلًٌنص وخًـًًًش ًظدرو َٓم خًوـ ًًنطٔم نىل‬
‫خًفًًٌى مٔدَ طًفم خإلكًخػٌص‪ ،‬ومنَُ خإلكًخػٌص خًـًًًش ًظدرو َٓم خًًخثُش كظى ًُٓم يخثُش يف‬
‫مودن خإلكًخػٌص خًـًًًش ًٌنلؿص خملمٌّش‪.‬‬
‫)‪img = cv2.add(frame,mask‬‬
‫ذ‬

‫هٍخ خًٔؿُ ًفًٌند فلـ يف نمٌٌص خًُٓم‪.‬‬
‫ذ‬

‫‪ ‬كصبفخُامرذفمُامثرصيُيفُ‪ُ :OpenCv‬‬
‫ؾًُلص ًىهدْ هدنًي طلٔس خًظًفم خًزرصي ملـمىنص مٌّخض مظفُكص (يف مؼدًند‪ ،‬خهظشدف خًّوخًد‬
‫ردٓظوًخَ هىخَِمٌص ‪ .)Shi-Tomasi‬موظزص ‪ OpenCv‬طىفُ هىخَِمٌص ؤهُي إلًـدي هؼدفص خًظًفم‬
‫خًزرصي‪ .‬طلىَ هٍه خًوىخَِمٌص نىل كٔدذ خًظًفم خًزرصي ًوٍ خًنلدؽ يف بؾدَ ضىَش‪ .‬فهٍ طزنى‬
‫نىل هىخَِمٌص ‪( Gunner Farneback’s‬ملهُفص مد هٍ هىخَِمٌص ‪ Gunner Farneback’s‬خؾٌو‬
‫نىل وَكص خًزلؽ خًظٍ هظزهد ‪ Gunner Farneback‬رهنىخن " ‪Two-Frame Motion Estimation Based‬‬
‫‪.)"on Polynomial Expansion‬‬
‫خملؼدي خًظديل ًهُع هٌفٌص بًـدي هؼدفص خًظًفم خًزرصي ردٓظوًخَ خًوىخَِمٌص ‪.Farneback‬‬
‫ٓنلطٍ نىل مطفىفص رـ ‪ 4‬كندش مو شهدم خًظًفم خًزرصي )‪ٓ .(u,v‬نىؿً كـمهد وخطـدههد‪ٓ .‬نلىَ‬
328 ‫ ببساطة‬OpenCv

‫ خالطـده‬.ٍ‫رظٌىًن نظٌـص خًوىي هٌل هى وخغم يف خًطىَش خًظدًٌص ًنلطٍ نىل نظٌـص ططىَ ؤفػ‬
:‫ شدهً خًوىي خًظديل‬.‫ خًلـم ًظىخفم مو كٌمص خملٔظىي‬.‫ ًٌطىَش‬Hue ‫ًظىخفم مو كٌم‬
import cv2
import numpy as np

cap = cv2.VideoCapture("vtest.avi")

ret, frame1 = cap.read()
prvs = cv2.cvtColor(frame1,cv2.COLOR_BGR2GRAY)
hsv = np.zeros_like(frame1)
hsv[...,1] = 255

while(1):
ret, frame2 = cap.read()
next = cv2.cvtColor(frame2,cv2.COLOR_BGR2GRAY)

flow = cv2.calcOpticalFlowFarneback(prvs,next, 0.5, 3, 15, 3, 5, 1.2, 0)

mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)
cv2.imshow('frame2',rgb)
k = cv2.waitKey(30) & 0xff
if k == 27:
break
elif k == ord('s'):
cv2.imwrite('opticalfb.png',frame2)
cv2.imwrite('opticalhsv.png',rgb)
prvs = next

cap.release() , cv2.destroyAllWindows()

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪329‬‬ ‫‪ OpenCv‬ببساطة‬

‫امنرٌعخ‪ُ :‬‬

‫ذ‬

‫رشػُامكىد‪ُ :‬‬
‫)(‪ret, frame1 = cap.read‬‬
‫)‪prvs = cv2.cvtColor(frame1,cv2.COLOR_BGR2GRAY‬‬
‫)‪hsv = np.zeros_like(frame1‬‬
‫‪hsv[...,1] = 255‬‬
‫ذ‬

‫يف خًزًخًص نلىَ رلُخءش خًفًًٌى‪ ،‬ػم نلىًه ًٌمٔظىي خًُمديي‪ ،‬رهً ًٌى نلىَ رظهًُف مطفىفص‬
‫ضفًُص (ؤي ضىَش ٓىيخء) ردٓم ‪ hsv‬رنفٕ ؤرهدي خًفًًٌى‪ ،‬ومبد ؤن هٍ بؾدَ ضىَش يف خًفًًٌى مٌىن‬
‫فهى ًإهٍ ػالغ كنىخض (ؤي مطفىفص ػالػٌص خًزهً ‪)3D‬‬
‫بٌخ ٓظوىن ؤًػد خملطفىفص خًطفًُص ‪ hsv‬خًظٍ نُفندهد‬
‫موىنص من ػالغ كنىخض‪ ،‬وهٍ هٍه خًلنىخض طإهٍ خًلٌمص‬
‫‪ .5‬يف خألمُ ‪ٓ hsv[...,1] = 255‬نلىَ رىغو خًلٌمص ‪400‬‬
‫ًٌلندش خًؼدنٌص (ٌٓطزم ًًرند رًي خًطىَش خًٔىيخء ضىَش‬
‫هٍصخء)‪.‬‬
‫‪330‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪while(1):‬‬
‫)(‪ret, frame2 = cap.read‬‬
‫)‪next = cv2.cvtColor(frame2,cv2.COLOR_BGR2GRAY‬‬
‫ذ‬

‫ذ‬

‫)‪flow = cv2.calcOpticalFlowFarneback(prvs,next, 0.5, 3, 15, 3, 5, 1.2, 0‬‬

‫خًظدرو )(‪ً cv2.calcOpticalFlowFarneback‬لٔس ًند هؼدفص خًظًفم خًزرصي ردٓظوًخَ‬
‫هىخَِمٌص يىَندَ فدَرٌندن (‪ )Gunnar Farneback’s‬وًإهٍ خًشوٍ خًظديل‪:‬‬
‫‪cv2.calcOpticalFlowFarneback(prev, next, pyr_scale, levels, winsize, iterations, poly_n,‬‬
‫‪poly_sigma, flags[, flow]) → flow‬‬

‫‪ :prev‬ضىَش خًًهٍ ًـس ؤن طوىن رلندش وخكًش‪.‬‬ ‫‪‬‬
‫‪ :Next‬ػدين ضىَش يهٍ‪ً .‬ـس ؤن طوىن رنفٕ كـم ونىم خًطىَش خألوىل )‪.(prev‬‬ ‫‪‬‬
‫‪ :pyr_scale‬هٍخ خًزدَمرت ًلًي كـم خًطىَش فةٌخ هدنع كٌمظه (‪ً )<1‬هنٍ ٌٓزنٍ‬ ‫‪‬‬
‫خألهُخمدض ًوٍ ضىَش‪ ،‬ؤمد بٌخ هدنع كٌمظه ‪ pyr_scale=0.5‬هٍخ ًهنٍ خًهَُ ٌٓوىن‬
‫طلًٌٌي ؤي ٌٓوىن هٍ مٔظىي ؤضًُ مبُطٍن من خملٔظىي خًٍي كزٌه‪.‬‬
‫‪ :Levels‬نًي مٔظىًدض خًهَُ مبد يف ًٌى خًطىَش خألوىل‪ .‬بٌخ مُنند ًهٍخ خًزدَمرت خًلٌمص ‪8‬‬ ‫‪‬‬
‫هٍخ ًهنٍ رإنه ال ًىؿً مٔظىًدض بغدفٌص ٌٓظم بنشدئهد وفلـ ٌٓٔظوًَ خًطىَش خألضٌٌص‪.‬‬
‫‪ :Winsize‬كـم خًندفٍش‪ .‬هٌٌل هدنع خًلٌمص ؤهرب ٓظوىن كىي خًوىخَِمٌص ؤكىي ًٌظًٌس‬ ‫‪‬‬
‫نىل طشىًش خًطىَش‪ ،‬وبنؿدء فُضص ؤهرب ًٌوشف نن خًلُهدض خًرسًهص‪ ،‬وًونهد طهؿٍ‬
‫(‪.)blurred motion field‬‬ ‫كُهص ؤهًت غزدرٌص‬
‫‪ :Iterations‬نًي مُخض طوُخَ خًوىخَِمٌص ننً هٍ مٔظىي هُمٍ‪.‬‬ ‫‪‬‬
‫‪ :poly_n‬كـم خًزٌؤالض خملـإوَش خًظٍ طٔظوًَ ًٌزلؽ نن متًي مظهًي خًلًوي‬ ‫‪‬‬
‫(‪ً )polynomial‬وٍ رٌؤٍ‪ .‬بٌخ مُنند ؤهرب كٌمص هٍخ ًهنٍ ؤن خًطىَش ٌٓطزم ٓؿلهد‬
‫خنهم (‪ )smoother‬وطًًّ مُونص خًوىخَِمٌص مٌل ًهؿٌهد كىي‪ ،‬وًون طًًّ ؤًػد غزدرزص كلٍ‬
‫خًلُهص‪ ،‬رشوٍ ندَ طوىن كٌمظه ‪ 0‬ؤو ‪.7‬‬
‫‪ :poly_sigma‬منَُ ًه خًلٌمص ‪ 8.8‬بٌ هدن ‪ ،poly_n=5‬وخًلٌمص ‪ 8.0‬بٌخ هدن ‪.poly_n=7‬‬ ‫‪‬‬
331 ‫ ببساطة‬OpenCv

:‫ ًظوىن مٌل ًًل‬.ًٌٍ‫ نٌم خًظش‬:flags 
OPTFLOW_USE_INITIAL_FLOW 
‫ ًٔظوًَ خًفٌرت خًًىيس رًي خًفٌرت‬:OPTFLOW_FARNEBACK_GAUSSIAN 
‫ هٍخ خًوٌدَ ًهؿٌند يكص ؤفػٍ ًٌظًفم من‬.‫خًطنًوكٍ ًنفٕ كـم خًظًفم خًزرصي خملهظرب‬
‫ ننً خهظٌدَ خًندفٍش خًًإوٌٓص ًـس ؤن‬.‫ وًون نىل كٔدذ خًرسنص نديش‬،ٍ‫خًفٌرت خًطنًوك‬
.‫ كٌمص هزًنش ًنلطٍ نىل نفٕ خملٔظىي من خًشًش‬Winsize ‫نهؿٍ خملظًًن‬
‫) وخًنىم‬prev( ‫ ًلٔس طًفم خًطىَش خًظٍ متٌى نفٕ كٌدْ خًطىَش خألوىل‬:flow 
.None ‫ ؤكٌدند بن مل نٔظوًمه ًـس ؤن متَُ مودنه خًلٌمص‬.‫ ًن نٔظوًمه‬.CV_32FC2

mag, ang = cv2.cartToPolar(flow[...,0], flow[...,1])
‫ذ‬

cv2.cartToPolar

cv2.cartToPolar(x, y[, magnitude[, angle[, angleInDegrees]]]) → magnitude, angle

hsv[...,0] = ang*180/np.pi/2
hsv[...,2] = cv2.normalize(mag,None,0,255,cv2.NORM_MINMAX)
rgb = cv2.cvtColor(hsv,cv2.COLOR_HSV2BGR)
‫ذ‬

‫ ملهُفص هٍه خًنٌلٌؾ شدهً خًنمىٌؾ‬،‫ طىفُ مندٌؾ مظلًمص نن خًظًفم خًزرصي‬OpenCv ‫موظزص‬
‫ يف خملٌف خًٍي مٔدَه‬OpenCv ‫خملىؿىي غمن موظزص‬
"C:\opencv\sources\samples\python2\opt_flow.py"
ُ :‫ؤمصنخُبطبفٌخ‬
"C:\opencv\sources\samples\python2\lk_track.py" 
"C:\opencv\sources\samples\python2\opt_flow.py" 

‫ذ‬

‫ذ‬
‫‪332‬‬ ‫‪ OpenCv‬ببساطة‬

‫ػشػُامخنفٌخُ‪ُ :Background Subtraction‬‬

‫ملذمخ‪ُ :‬‬
‫نلظدؾ يف نًش طؿزٌلدض ؤن نٔظوُؾ خًوٌفٌص ًظنفٌٍ نمٌٌدض نًش مؼٍ طهلس هدثن‪.‬‬
‫ُ ُ‬ ‫امهذف‪:‬‬
‫ٓنظهُف نىل ؾُق ؾُق خًوٌفٌص خًظٍ طىفُهد موظزص ‪.OpenCv‬‬
‫ؤظبظٌبد‪ُ :‬‬
‫ؾًُلص ؾُق خًوٌفٌص هٍ هؿىش ؤٓدٌٓص يف خًهًًً من خًظؿزٌلدض خًظٍ طهظمً رشوٍ َثًٌس نىل‬
‫مهدًـص خًُئًص خًلدٓىرٌص‪ .‬نىل ٓزٌٍ خملؼدي‪ ،‬يف كدًص نً خًّوخَ نن ؾًُم خًودمًنخ ًظم نً خًّوخَ‬
‫خًًخهٌٍن وخًودَؿٍن من خًًُفص‪ ،‬ؤو بكطدء كُهص خملُوَ ؤو مهُفص خملهٌىمدض نن خملُهزدض خًظٍ‬
‫متُ ؤمدَ خًودمًنخ‪ .‬يف هٍ هٍه خًلدالض نلظدؾ خٓظوُخؾ شوظ ؤو مُهزص ًىكًه‪ .‬فإنع رلدؿص‬
‫ًهٍه خًظلنٌص الٓظوُخؾ خًلُهص خألمدمٌص من خًوٌفٌص (هشوظ ؤو مُهزص) وفطٌهد نن خًوٌفٌص‪.‬‬
‫بٌخ هدن ًًًى ضىَش خًوٌفٌص ًىكًهد مؼٍ ضىَش خًًُفص رًون خألشودص ؤو ضىَش ًٌؿًُم يون‬
‫خملُهزدض‪ٌ ،‬نون فهٍ هٍخ رٔهىًص نن ؾًُم ؾُق خًطىَش خًـًًًش من هٌفٌظهد‪ ،‬ننًهد ٓظلطٍ‬
‫نىل خًـٔم خألمدمٍ ًىكًه‪.‬‬
‫وًون يف مهكم خًلدالض ال منٌى خًوٌفٌص ًىكًهد كظى نٔظؿٌو خًلٌدَ رهمٌٌص خًؿُق‪ًًٍ ،‬ى‬
‫ٓنلظدؾ الٓظوُخؾ خًوٌفٌص من ؤي ضىَش ًًًند‪ .‬نمٌٌص خٓظوُخؾ خًوٌفٌص ططزم ؤهًت طهلًٌخ ننً‬
‫وؿىي قٍ (مؼٍ قٍ خملُهزص)‪ ،‬ألن خًكٍ ؤًػد ًظلُن مو خًـٔم‪ .‬خًؿُق خًزٌٔـ ٌٓلًي خًوٌفٌص‬
‫خألمدمٌص (خًـٔم ‪ +‬خًكٍ)‪ .‬ؤن طٔظوُؾ خًـٔم ًىكًه هٍخ يشء مهلً‪.‬‬
‫ًلً طم بًـدي نًش هىخَِمٌدض ًلٍ هٍه خملشوٌص‪ ،‬كٌؽ كدمع موظزص ‪ OpenCv‬رؿُق ػالغ‬
‫هىخَِمٌدض من خًٔهٍ نىل خملٔظوًَ خٓظوًخمهد‪ٓ ،‬نلىَ رٍسق هٍه خًوىخَِمٌدض خًؼالغ هٍ‬
‫وخكًش ًىكًهد‪.‬‬
333 ‫ ببساطة‬OpenCv

‫ وكً طم نُع هٍخ‬.‫هٍه خًوىخَِمٌص طلىَ رفطٍ خملًّف هٌفٌص\ؤمدمٌص نن ؾًُم خملّخثف خًًإوٌٓص‬
An improved adaptive background mixture model for real-time " ‫يف وَكص خًزلؽ‬
‫ يف‬R. Bowden ‫ و‬P. KadewTraKuPong ‫" ًٌمؿىًَن‬tracking with shadow detection
.4558 َ‫ند‬
k=3 to ( K ‫فهٍه خًؿًُلص طهظمً نىل مّؾ هٍ رٌؤٍ يف خًوٌفٌص ومّؿه مو خًظىًِهدض خًًإويس‬
‫ خًوٌفٌص خمللظمٌص هٍ طٌى‬.ً‫شًش خملًّف متؼٍ مًش خًىكع ًلدًص خألًىخن خًظٍ طزلى يف خملشه‬.)5
.‫خًظٍ ؤًىخنهد طزلى ًفرتش ؤؾىي يون طًًن‬
‫ننً هظدرص خًوىي ٓنلظدؾ إلنشدء ؿٔم خًوٌفٌص وًٌى ردٓظوًخَ خًظدرو‬
.cv2.createBackgroundSubtractorMOG()
‫ وخًهظزص‬،‫ ونًي خألمّؿص‬،)‫هٍخ خًظدرو ٌنٌى رهؼ خًزدَخمرتض خالهظٌدًَص مؼٍ مًش خًزلدء (ًٌىن‬
.)number of gaussian mixtures ،threshold ،history(
‫ ردًنٔزص ًًخهٍ كٌلص خًفًًٌى‬.‫بٌخ مل ًظم طهًُف هٍه خًلٌم فةنهد طإهٍ كٌم خفرتخغٌص رشوٍ طٌلديئ‬
.‫ ًٌلطىي نىل كندم ًلؿٔدَ خألمدمٌص‬backgroundsubtractor.apply() ‫فةنند ٓنٔظوًَ خًظدرو‬
:‫شدهً خًوىي خًظديل‬
import numpy as np ‫ذ‬
import cv2

cap = cv2.VideoCapture('vtest.avi')
fgbg = cv2. BackgroundSubtractorMOG()
while(1):
ret, frame = cap.read()
fgmask = fgbg.apply(frame)
cv2.imshow('frame',fgmask)
k = cv2.waitKey(30) & 0xff
if k == 27: ‫ذ‬
break

cap.release()
cv2.destroyAllWindows() ‫ذ‬

‫ رًي‬cv2.createBackgroundSubtractorMOG() ‫ خٓظوًَ خًظدرو‬4 َ‫ خإلضًخ‬OpenCV ‫ يف‬:‫مالككص‬
.cv2. BackgroundSubtractorMOG() ‫خًظدرو‬
334 ‫ ببساطة‬OpenCv

.‫ مىؿىيش يف خألٓفٍ كٌؽ ٓنلدَن رٍن ؿمٌو هىخَِمٌدض ؾُق خًوٌفٌص‬:‫خًنظٌـص‬
ُ :‫رشػُامكىد‬
fgbg = cv2. BackgroundSubtractorMOG()
‫ذ‬

‫ وًٌى نن ؾًُم خًظدرو‬fgbg ‫يف خًزًخًص كمند رظهًُف ؿٔم خًوٌفٌص وطوًّنه يف خملظًًن‬
:‫ خًٍي ًإهٍ خملظًًنخض خًظدًٌص‬cv2.BackgroundSubtractorMOG()
cv2.BackgroundSubtractorMOG([history, nmixtures, backgroundRatio[, noiseSigma]]) →
<BackgroundSubtractorMOG object>

.)‫ ؾىي مًش خًلفل (خقن مًش رلدء خًٌىن يف مودنه‬:history 
.‫ نًي خًوالثـ(خملّخثف) خًًإوٌٓص‬:nmixtures 
.‫ نٔزص خًوٌفٌص‬:backgroundRatio 
.‫ شًش خًػـٌف‬:noiseSigma 
while(1):
ret, frame = cap.read()
fgmask = fgbg.apply(frame)
cv2.imshow('frame',fgmask)

ٍ‫ يف ه‬.‫ ًنلىَ رهمٌٌص ؾُق خًوٌفٌص ًـمٌو بؾدَخض خًطىَش خملوىنص ًٌفًًٌى‬while ‫كمند رفظم كٌلص‬
‫طوُخَ ًٌلٌلص نلطٍ نىل خملنؿلص خألمدمٌص من خًـٔم مٌىنص ردألرٌؼ وًٌى نن ؾًُم طؿزٌم طدرو‬
.apply () ‫ؾُق خًوٌفٌص من خألؿٔدَ خألمدمٌص نىل هٍ بؾدَ يف خًفًٌو نن ؾًُم خًظهٌٌمص‬
‫ذ‬

‫ طم وغو هٍه‬.‫ؤًػد خملّخثف خًًإوٌٓص طهظمً نىل هىخَِمٌص فطٍ خملنؿلص خألمدمٌص نن خًوٌفٌص‬
Improved adaptive " ‫ رهنىخن‬Z. Zivkovic َ‫خًوىخَِمٌص رند ًء نىل وَكظٍ خًزلؽ ًٌمؿى‬
Efficient " ‫ و‬،4553 َ‫" هظزع ند‬Gausian mixture model for background subtraction
Adaptive Density Estimation per Image Pixel for the Task of Background
.4555 َ‫" هظزع ند‬Subtraction
‫‪335‬‬ ‫‪ OpenCv‬ببساطة‬

‫بكًي خملٌّخض خًهدمص ًهٍه خًوىخَِمٌص رإنهد طوظدَ خًهًي خملندٓس ًٌظىِم خًًإويس ًوٍ رٌؤٍ‬
‫(طٍهُ رإنه يف ؤهُ كدًص ؤهٍند ‪ًٌ K‬ظىِم خًًإويس نىل هدمٍ خًوىخَِمٌص وًٌٕ ًوٍ رؤٍ)‪ ،‬وهٍخ‬
‫ًىفُ خًلًَش نىل خًظوٌف رشوٍ ؤفػٍ مو خملشدهً خملوظٌفص خًظٍ طًًٌن فٌهد شًش خإلغدءش‪.‬‬

‫يف خًلدًص خًٔدرلص‪ ،‬ؤنشإند ؿٔم ؾُق خًوٌفٌص‪ .‬هند منٌى خًوٌدَ فٌٌل بٌخ هند نًًُ طلًًً خًكٍ‬
‫ًهُغه ؤَ ال‪ً .‬ظلًًً خًكٍ نوظس ‪( detectShadows = True‬خًلٌمص خالفرتخغٌص طوىن ‪،)True‬‬
‫وهٍخ ًلًي وًهٌم خًكالي‪ ،‬وًون ًوفف من رسنص خًظنفٌٍ‪ .‬خًكالي ٓىف طهٌم ردًٌىن خًُمديي‪.‬‬

‫‪import numpy as np‬‬
‫‪import cv2‬‬
‫)'‪cap = cv2.VideoCapture('vtest.avi‬‬

‫)(‪fgbg = cv2. createBackgroundSubtractorMOG2‬‬

‫‪while(1):‬‬
‫)(‪ret, frame = cap.read‬‬

‫)‪fgmask = fgbg.apply(frame‬‬

‫)‪cv2.imshow('frame',fgmask‬‬
‫‪k = cv2.waitKey(30) & 0xff‬‬
‫‪if k == 27:‬‬
‫‪break‬‬

‫)(‪cap.release‬‬
‫)(‪cv2.destroyAllWindows‬‬
‫ذ‬

‫(خًنظٌـص ٓظهؿى يف خألٓفٍ)‬
‫مالككص‪ :‬يف بضًخَ ‪ OpenCv V2‬كم ردٓظوًخَ خًظدرو )(‪ BackgroundSubtractorMOG2‬رًال من خًظدرو‬
‫)(‪.createBackgroundSubtractorMOG2‬‬
‫امنربئغ‪ُ :‬‬
‫‪336‬‬ ‫‪ OpenCv‬ببساطة‬

‫بؾدَ خًطىَش خألضًل‬

‫خًطىَش خًظدًٌص طهُع بؾدَ خًطىَش َكم ‪ 455‬من خًفًًٌى‪.‬‬
‫ُنرٌعخُامؼشػُامخنفٍُمخىاسصمٌخُ‪ُ :MOG‬‬

‫ذ‬

‫نرٌعخُامؼشػُامخنفٍُمخىاسصمٌخُ‪ُ :MOG2‬‬
‫خملنؿلص خملٌىنص ردًٌىن خًُمديي هٍ منؿلص خًكالي‪.‬‬

‫ذ‬
‫الفصل التاسع‬

‫” أن تتعثر فهذا يعني أنك تسير في الطر يق‪ ،‬فلم أسمع‬
‫بأحد يتعثر وهو لا يتحرك ‟‬
‫تشارلز كيترينج ‪ -‬مهندس ومخخترع أمريكي‬
‫‪338‬‬ ‫‪ OpenCv‬ببساطة‬

‫امفصهُامربظؼ‪ُ:‬اكرشبفُاألظعبوُ ‪Object‬‬
‫‪ُ Detection‬‬
‫ذ‬

‫اكرشبفُاألظعبوُتبظرخذاوُخىاسمٌخُ‪:Haar Cascades‬‬
‫ٓنظهٌم طلًًً خًىؿه ردٓظوًخَ هىخَِمٌص هدٓوًٌ هدَ (‪.)Haar Cascades‬‬
‫ذ‬

‫امهذف‪ُ :‬‬
‫ٓنظهٌم ؤٓدٌٓدض خهظشدف خًىؿه خنظٌليخ نىل مّخًد هدَ ‪.... Haar‬‬
‫وٓنلىَ رنفٕ خًشٌح الهظشدف خًهٍن‪.‬‬
‫ملذمخُنظشًخ‪ُ :‬‬
‫ٓنوظشف خألؿٔدَ ردٓظوًخَ هىخَِمٌص ‪ Haar‬وخًظٍ طهظمً نىل خٓظوًخَ نًش مطنفدض‪ ،‬وطهظرب‬
‫هٍه خًؿًُلص نمٌٌص الهظشدف خألؿٔدَ‪ .‬طم خكرتخق هٍه خًوىخَِمٌص من كزٍ ‪ Paul Viola‬و‬
‫‪ Michael Jones‬غمن كٌلص رلؼهم " ‪Rapid Object Detection using a Boosted Cascade‬‬
‫‪ "of Simple Features‬خًظٍ هظزىهد ندَ ‪ .4558‬هٍه خًوىخَِمٌص طهظمً نىل طًًَس خًـهدِ نىل‬
‫خًظهٌم خنظٌليخ نىل خمللدَرص‪ ،‬كٌؽ ًظم طًًَس خًظدرو نىل نًش ضىَ بًـدرٌص وٌٓزٌص‪ .‬ػم نٔظوًَ‬
‫هٍخ خًظدرو خملًَذ ًٌوشف نن خألؿٔدَ يف ضىَ ؤهُي‪.‬‬
‫هند ٓىف نٔظهمٌه الهظشدف خًىؿه‪ٓ .‬نلظدؾ يف خًزًخًص ًهًش ضىَ بًـدرٌص (ضىَ ًىؿىه) وضىَ‬
‫ٌٓزٌص (ضىَ رًون وؿىه) ًنًَذ خملطنف (‪ )classifier‬نىل خهظشدف خًىؿه‪ .‬ػم ٓنلظدؾ الٓظوُخؾ‬
‫خملٌّخض منهد‪ًًٍ .‬ى ٓنٔظوًَ مٌّخض ‪ Haar‬هٌل هى مزٍن يف خًطىَش خًظٍ يف خألٓفٍ‪ .‬هٍ مٌّش‬
‫طلطٍ نىل كٌمص وخكًش من هالي ؾُق مـمىنص خًزٌؤالض خًظٍ طلع خملٔظؿٌٍ خألرٌؼ من‬
‫مـمىم خًزٌؤالض خًظٍ طلع خملٔظؿٌٍ خألٓىي‪.‬‬
‫ذ‬
‫‪339‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذ‬

‫خآلن ٌٓظم خٓظوًخَ هٍ خألكـدَ وخألمدهن خملمونص ًٌلندم ًلٔدذ خًهًًً من خملٌّخض (طوٌٍ هم‬
‫نًي خًلٔدردض خًظٍ ٓنلظدؿهد؟ فلظى ننً خٓظوًخَ ندفٍش كندم رلـم ‪ٌٓ 24x24‬هؿٌند نظٌـص‬
‫ألهًت من ‪ 855555‬مٌّش)‪ً .‬لٔدذ هٍ مٌّش ٓنلظدؾ إلًـدي مـمىم خًزٌؤالض خًظٍ طلع‬
‫خملٔظؿٌٍ خألرٌؼ وخألٓىي‪ً .‬لٍ هٍه خملشوٌص نُغىخ ضىَش مظودمٌص (يًن مظـّثص)‪ ،‬هٍخ خألمُ‬
‫ًزٔـ كٔدذ مـمىم خًزٌؤالض‪ ،‬نًي خًزٌؤالض كً ًوىن هزًن ًًٍى ٓظشدَن يف هٍه خًهمٌٌص‬
‫‪ 3‬رٌؤالض فلـ‪ .‬ؤًٌٕ هٍخ خألمُ ؤفػٍ؟ فهى ًـهٍ خألمُ ًظم ررسنص هدثٌص‪.‬‬

‫ًون من رٍن هٍ هٍه خملٌّخض كٔزند نًي من خًزٌؤالض ًٌٕ ًهد نالكص‪ .‬نىل ٓزٌٍ خملؼدي‬
‫ًنفُع ًًًند خًطىَش خًظٍ يف خألٓفٍ‪ .‬خًطف خًهٌىي ًكهُ مًٌّظٍن ؿًٌطٍن‪ .‬ؤوي مٌّش طزًو ؤنهد‬
‫طُهّ نىل هدضٌص منؿلص خًهٌنٍن وخًظٍ طوىن يدًزد ؤيمم من منؿلص خألنف وخًوًًن‪ .‬ؤمد خملٌّش‬
‫خًؼدنٌص طُهّ نىل هدضٌص منؿلص خًهٌنٍن طوىن ؤيمم من ؿرس خًنكدَطٍن وخألنف‪ .‬وًون خًنىخفٍ خًظٍ‬
‫ًظم طؿزٌلهد نىل خًوًًن ؤو ؤي منؿلص ؤهُي ال طهمند‪ .‬فوٌف ٓنظوظدَ ؤفػٍ خملٌّخض من رٍن‬
‫‪ 855,555‬مٌّش؟‬

‫ذ‬
‫‪340‬‬ ‫‪ OpenCv‬ببساطة‬

‫ًهٍخ خألمُ ٓنؿزم هٍ مٌّش نىل ؿمٌو ضىَ خًظًًَس‪ً .‬وٍ مٌّش ٓظىؿً ؤفػٍ نظزص خًظٍ ٓىف‬
‫ططنف خًىؿىه خإلًـدرٌص وخًٌٔزٌص‪ .‬وًون من خملهٌىَ رإنه ٌٓوىن هندن ؤهؿدء ؤو ٓىء يف خًظطنٌف‪.‬‬
‫نٌٌند طلًًً خملٌّخض مو ؤيىن مهًي ًٌوؿإ‪ ،‬وهٍخ ًهنٍ رإنهد ٓظوظدَ ؤفشٍ خملٌّخض ًظطنف‬
‫خًىؿه من نًَ خًىؿه يف خًطىَش‪( .‬خًهمٌٌص ًٌٔع رهٍه خًزٔدؾص‪ .‬فوٍ ضىَش ٓظإهٍ وِند مظٔإوًد‬
‫يف خًزًخًص‪ .‬وًهً هٍ ططنٌف ٌٓظم ًِديش ؤوِخن خًطىَ خملطنفص رشوٍ هدؾح‪ .‬ػم طظم مُش ؤهُي‬
‫نفٕ خًهمٌٌص‪ ،‬وًظم كٔدذ مهًي خألهؿدء خًـًًًش‪ ،‬وخألوِخن خًـًًًش ؤًػدً‪ .‬طٔظمُ هٍه خًهمٌٌص‬
‫كظى ًظم خًظللم من مهًي خًًكص ؤو خًوؿإ خملؿٌىذ بًـديه ًهًي من خملٌّخض)‬
‫خًظطنٌف خًنهديئ ًهؿٌند مـمىم ؤوِخن خًظطنٌفدض خًػهٌفص‪ .‬طًنى غهٌفص ألنه ًىكًهد ال‬
‫طٔظؿٌو ططنٌف خًطىَش‪ ،.‬وًون مو خًظطدنٌف خألهُي ٌٓظشوٍ ًًًند مطنف كىي‪ .‬طوربند وَكص‬
‫خًزلؽ رإنه ننً طىفُ مٌّخض كظى ‪ 455‬مٌّش ٓنلطٍ نىل يكص خهظشدف ‪ .95%‬خًهًي خًنهديئ خٌي‬
‫كطٌند نٌٌه هدن ‪ 5555‬مٌّش (طوٌٍ هٌف هفػند رهٍه خًهمٌٌص خًظٍ كمند رهد نًي خملٌّخض من‬
‫‪ 855,555‬بىل ‪ ،5555‬وهٍخ مؤس هزًن ًند ردًٍخض من ندكٌص رسنص خًظنفٌٍ)‪.‬‬
‫ٌنونى خألن ؤهٍ خًطىَ‪ .‬وطٔظهمٍ هٍ ندفٍش رلـم ‪ .24x24‬وطؿزم ‪ 5555‬مٌّش نٌٌهد‪ .‬طللم فٌٌل‬
‫بٌخ هدن وؿه ؤَ ال‪ .‬ؤًٌٔع هٍه خًؿًُلص يًن نمٌٌص ومػٌهص ًٌىكع؟ نهم هٍ يًن فهدًص ًًٍى ؤوؿً‬
‫خًودطس كٍ ًًٍى‪.‬‬
‫يف خًطىَش مهكم خملندؾم هٍ ًٌٔع منؿلص وؿه‪ًًٍ ،‬ى ؤفػٍ ؾًُلص رإن طفلظ خًندفٍش هٍ هٍ‬
‫منؿلص وؿه فةٌخ مل طون ًظم كٍفهد فىَخ وال ًظم مهدًـظهد مُش ؤهُي‪ .‬رهٍه خًؿًُلص نىفُ خًىكع‬
‫ًٌظللم من بمودنٌص وؿىي وؿه يف منؿلص مهٌنص‪.‬‬
‫ًًٍى خألمُ طم بًـدي مفهىَ ‪( Cascade of Classifiers‬طٌٍٔٔ خملطنفدض)‪ .‬فزًال من طؿزٌم ‪5555‬‬
‫مٌّش نىل ندفٍش‪ ،‬نـمو هٍه ملٌّخض نىل مُخكٍ(‪ )stages‬موظٌفص من خملطنف (‪)Classifiers‬‬
‫ونؿزم مٌّش طٌى خألهُي‪( .‬نديش خملُخكٍ خألوىل ٓظلىي ؤكٍ نًي من خملٌّخض)‪ .‬بٌخ ؤهفلع خًندفٍش‬
‫خملُكٌص خألوىل ًظم خٓظزهديهد‪.‬‬
‫خملاًف كً خهظشف ؤهًت من ‪ 5555‬مٌّش هالي ‪ 48‬مُكٌص كٌؽ طم خهظشدف نًي من خملٌّخض يف‬
‫ؤوي ‪ 0‬مُخكٍ وًٌى هٌل يف خًرتطٌس خًظديل‪1,10,25,25,50 :‬‬
‫‪ ‬خىاسصمٌخُ ‪Harr Cascade‬يفُ‪ُ :OpenCv‬‬
‫طىفُ ًند موظزص ‪ OpenCv‬خملًَذ (‪ )trainer‬خًٍي ًهؿٌند خًلًَش نىل طًًَس خًوىخَِمٌص إلنشدء‬
‫مطنف (‪ )classifier‬خًٍي ٌٓظظػمن خملهٌىمدض (خًطفدض خملمٌّش) خًظٍ ٓظفًٌند يف خًظهُف نىل‬
‫خًـٔم خًٍي طم طًًَس خًوىخَِمٌص ًٌظهُف نٌٌه‪ ،‬وطىفُ ًند ‪ OpenCv‬ؤًػد خملوظشف (‪)detector‬‬
341 ‫ ببساطة‬OpenCv

classifier ‫ ٓنظهُف نىل مطؿٌم ؿًًً خٓمه خملطنف‬.َ‫خًٍي ٌنونند من خهظشدف وؿىي خألؿٔد‬
ٍ‫ فمؼال بٌخ هدن ننًند مطنف ًٌٌٔدَش فهٍخ ًهن‬،‫وهى ًظظػمن مـمىنص ضفدض ًظمٌٌّ ؿٔم مهٍن‬
.‫رإنه ًلىي نىل خًطفدض خملمٌّش خًظٍ طًًند نىل ؤن خًـٔم هى ٌٓدَش‬
،‫ نىل ؤي ؿٔم مؼٍ خًٌٔدَش‬classifier ‫ طىفُ ًى خًلًَش نىل طًًَس مطنفى‬OpenCv ‫موظزص‬
ٌٍ‫ ملهُفص هٍ طفدض‬.‫ رلٌؽ ٌنونى بنشدء خملطنف خًودص رى‬.‫ خًلٌىخندض‬،‫ خًلٍسخض‬،‫خًؿدثُش‬
‫ وخآلن‬.Cascade Classifier Training ‫ ًٌـٔم خًٍي طًًُ خطزو خًُخرـ‬classifier ‫بنشدء خملطنف‬
.ٍ‫ ورهً ًٌى ٓإٌسق ؾًُلص طًًَس خًوىخَِمٌص رإٌٓىذ ٓه‬detector ‫ٓنظهدمٍ مو خملوظشف‬
.‫) مًَرص وؿدهّش هدًىؿه وخًهٍن وخًفم‬classifier(‫ طلظىي نىل نًش مطنفدض‬OpenCv ‫موظزص‬

‫ خًظديل‬OpenCv ًٌ‫ غمن مٔدَ مـ‬OpenCv ًٌ‫ غمن مـ‬XML ‫هٍه خملطنفدض مىؿىيش رطًٌص‬
.OpenCv ‫ ينند خآلن ننشإ موظشف ًٌىؿه وخًهٍن مو‬.opencv\sources\data\haarcascades
‫ ػم نلمٍ ضىَش خًًهٍ (ؤو خًفًًٌى) يف‬،‫ خملؿٌىذ‬classifier ‫يف خًزًًص ٓنلظدؾ طلمٌٍ خًـ‬
.grayscale ‫خملٔظىي خًٌىين خًُمديي‬
import numpy as np
import cv2
face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
img = cv2.imread('sachin.jpg')
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

faces = face_cascade.detectMultiScale(gray, 1.3, 5)
for (x,y,w,h) in faces:
img = cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
roi_gray = gray[y:y+h, x:x+w]
roi_color = img[y:y+h, x:x+w]
eyes = eye_cascade.detectMultiScale(roi_gray)
for (ex,ey,ew,eh) in eyes:
cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)

cv2.imshow('img',img)
cv2.waitKey(0)
cv2.destroyAllWindows()
‫‪342‬‬ ‫‪ OpenCv‬ببساطة‬

‫خآلن ٓنىؿً خًىؿه يف خًطىَش‪ .‬بٌخ هدن خًىؿه مىؿىي ٌٓظم بنديش مىغو خهظشدف خًىؿه همٔظؿٌٍ‬
‫ردًطًٌص )‪ .Rect(x,y,w,h‬وننًمد نلطٍ نىل خملىغو ٌنونند بنشدء ‪( ROI‬خملنؿلص خملهمص) ‪،‬‬
‫ونزلؽ غمن هٍه خًزلهص خًظٍ طم خهظشدف خًىؿه فٌهد نن خًهٍن (ألن خًهٍن يخمئد مىؿىيش يف‬
‫خًىؿه‪ ،‬مٌل ًهؿٌند يكص يف خًزلؽ)‪.‬‬
‫شبهذُامنرٌعخ‪ُ :‬‬

‫ذ‬

‫رشػُامكىد‪ُ :‬‬
‫)'‪face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml‬‬
‫)'‪eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml‬‬

‫نلمٍ خملطنف خًٍي ًلظىي نىل مـمىنص خًطفدض خملمٌّش ًىؿه خألنٔدن (من خألمدَ) ونوّنه يف‬
‫خًظدرو خًٍي ؤنشإنده وهى ‪ ،face_cascade‬ونلمٍ ؤًػد خملطنف خًٍي ًلظىي نىل مـمىندض‬
‫خًطفدض خملمٌّش ًٌهٍن ونوّنهد يف خًظدرو ‪.eye_cascade‬‬
‫)‪faces = face_cascade.detectMultiScale(gray, 1.3, 5‬‬

‫كظى نوظشف خًىؿه يف ‪ OpenCV‬نٔظوًَ ؾًُلص ‪ method‬طًنى ‪detectMultiScale‬‬
‫وخًظٍ طٔظوًَ الهظشدف خألؿٔدَ يف خًطىَش‪ .‬الهظشدف وؿىي خًىؿه يف خًطىَش ٓنمَُ ًٌظدرو‬
‫)( ‪ detectMultiScale‬ؤَرو مظًًنخض وهٍ‪:‬‬
‫‪343‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ :Image‬خًطىَش خًظٍ ٓنزلؽ غمنهد نن خًىؿه (‪.)gray‬‬ ‫‪‬‬
‫‪ :scaleFactor‬ندمٍ خًلٌدْ ًٌهَُ خملٔظوًَ الهظشدف وؿه خإلنٔدن ( ‪image‬‬ ‫‪‬‬
‫‪.)pyramid‬‬
‫بٌخ ِيند كٌمص خًـ ‪ٓ scaleFactor‬ظّيخي رسنص خملوظشف‪ ،‬وًون ٌنون ؤن طىػُ نىل يكص‬
‫خالهظشدف‪.‬‬
‫(‪)could harm our true-positive detection accuracy‬‬ ‫‪‬‬
‫وهٌٌل ؤنلطند من من كٌمص ندمٍ كٌدْ خًهَُ (‪ٓ )scaleFactor‬ظنوفؼ رسنص خملوظشف‪،‬‬ ‫‪‬‬
‫وًون ٓظًًّ يكص خملوظشف‪َ .‬مبد ؤًػد ًًًّ مهًي خهظشدف خًطىَ خًودٌرص‪ .‬ملًًّ من‬
‫‪ sA note on Haar cascade‬خملىؿىيش نىل خًُخرـ خًظديل‬ ‫خملهٌىمدض َخؿو فلُش‬
‫‪http://www.pyimagesearch.com/2016/06/20/detecting-cats-in-images-‬‬ ‫‪‬‬
‫‪/with-opencv‬‬

‫‪ًٌ :minNeighbors ‬ظلوم رإكٍ نًي من خملٔظؿٌالض خمللٌؿص خملوظشفص يف منؿلص‬
‫مهٌنص ردًنٔزص ًٌمنؿلص خًظٍ ٌنون خن طهظرب وؿه خنٔدن‪ .‬هٍخ خًزدَمرت مفًٌ ؿًخ ًٌظوفٌف‬
‫من مهًي خهظشدف خًطىَ خًودٌرص‪.‬‬
‫‪)pruning false-positive detections) ‬‬
‫‪ :minSize ‬ؤكٍ ؾىي ونُع مٔمىق ًٌمٔظؿٌٍ خمللٌـ خملوظشف ًٌىؿه (مؼدي ‪)75 x 75‬‬
‫(يف خًوىي خًٔدرم مل نٔظهمٍ هٍخ خملظًًن)‪.‬‬

‫خًظدرو )( ‪ً detectMultiScale‬هًٌ مٔظؿٌٍ ردًشوٍ (بكًػٌدض ‪ًٌّ x,y‬ؤوًص خًهٌٌد خًٌرسي‬
‫ًٌمٔظؿٌٍ‪ ،‬وؾىًه ونُغه)‪.‬‬

‫بعضذادلالحظاتذعؾىذخوارزؿقةذ‪ :Haar cascades‬ذ‬

‫هٍه خًوىخَِمٌص كديَش نىل خهظشدف خألؿٔدَ يف خًطىَش رًؼ خًنكُ نن مىكههد وكـمهد‪ ،‬وؤًػد‬
‫ٌنونهد خًوشف نن خألؿٔدَ يف خًىكع خًللٌلٍ يف خألؿهّش خًلًًؼص‪.‬‬
‫ذ‬

‫ذ‬
‫‪344‬‬ ‫‪ OpenCv‬ببساطة‬

‫ؿشاؽلذؿصـفذفارذ‪ :Haar cascades‬ذ‬

‫هندن مشوٌص يف مطنفدض هدَ (‪ )Haar cascades‬فهنً طوزًن كٌمص ‪ٓ scaleFactor‬ظطزم ؤرسم‬
‫نمٌٌص خهظشدف خًـٔم وًون خملشوٌص رإن خًًكص طنوفؼ‪ ،‬وخملشوٌص خألهُي ننً طلٌٌٍ كٌمص‬
‫‪ً scaleFactor‬طزم موظشف خًلٌدْ ؤرؿإ وطًًّ خًًكص وًون ردمللدرٍ طًًّ نًي خًطىَ خًودٌرص‬
‫خملوظشفص (ؤي خًطىَش خًظٍ ال متؼٍ وؿه)‪.‬‬

‫ًًٍى ننً غزـ خًزدَمرتخض ًٌظدرو )( ‪ٓ detectMultiScale‬نلظدؾ خًوؼًن من خًىكع‪ ،‬وكً طلظدؾ‬
‫ًػزـ ؿًًً ننً خهظالف خًطىَش‪ .‬رٔزس هٍه خملشدهٍ ًظم طؿزٌم ‪Histogram of Oriented‬‬
‫‪ Gradients + Linear SVM detection‬رًال منهد‪.‬‬

‫‪ HOG + Linear SVM‬ؤٓهٍ يف غزـ خملظًًنخض وؤفػٍ‪ ،‬وطظمٌّ رإن نٔزص خهظشدف خًطىَ‬
‫خًودٌرص كٌٌٍ ؿًخ‪ .‬وًون هندن ٌٓجص وخكًش فٌهد وهٍ ضهىرص خًلطىي نىل خًنظٌـص يف خًىكع‬
‫خًللٌلٍ (‪ )Real-time‬رٔزس طؿزٌم ‪ HOG +Linear SVM‬مهد‪.‬‬
‫ذ‬

‫مشاظؼُبطبفٌخ‪ُ :‬‬
‫‪1. Video Lecture on Face Detection and Tracking‬‬
‫‪2. An interesting interview regarding Face Detection by Adam Harvey‬‬
‫‪3. http://www.pyimagesearch.com/2016/06/20/detecting-cats-in-images-with-opencv/‬‬
‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬

‫ذ‬
‫‪345‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ ‬خؼىادُذذسًجُامخىاسصمٌخُمنرػشفُغىلُامشكهُاملؼنىة‪ُ :‬‬
‫يف خًوؿىخض خًظدًٌص ٓإٌسق ؾًُلص بنشدء ٌٌٓٔص من خملطنفدض (‪ )classifiers‬خنظٌليخ نىل‬
‫خملٌّخض مؼٍ مٌّش هدَ ‪ ،Haar‬وخًظٍ طهً خًظلنزص خألهًت شٌىند يف خًُئًص خًلدٓىرٌص الهظشدف‬
‫خًىؿه وخًهٍن‪.‬هٍ خأليوخض خملؿٌىرص وخًطىَ خملىؿزص وخًٔدًزص مىؿىيش نىل خًُخرـ‪:‬‬

‫‪ https://www.cs.auckland.ac.nz/~m.rezaei/Tutorials/Haar -Training.zip‬ذ‬

‫هؿىخض طًًَس خًوّخَِمٌص إلنشدء ‪:classifier‬‬
‫‪ ‬ؿمو ضىَ خًظًًَس خملىؿزص وخًٔدًزص‪.‬‬
‫‪ ‬طهٌٌم خًطىَ خملىؿزص ردٓظوًخَ خأليخش ‪ objectmarker.exe‬ؤو ‪.ImageClipper‬‬
‫‪ ‬بنشدء مٌف ‪ )vector( .vev‬خنظٌليخ نىل خًطىَ خملىؿزص خملهٌمص خنظٌلي نىل خأليخش‬
‫‪.createsamples.exe‬‬
‫‪ ‬طًًَس خملطنف ردٓظوًخَ ‪.haartraining.exe‬‬
‫‪ ‬طشًٌٍ خملطنف ردٓظوًخَ خأليخش )(‪.cvHaarDetectObjects‬‬
‫امخؼىحُ‪ُ:1‬ظمؼُكبغذحُتٌبنبدُامصىس ُ‬
‫ٓنلىَ رـمو كىخيل ‪ 455‬ضىَش بًـدرٌص (مىؿىي فٌهد خًـٔم خملؿٌىذ) و‪ 455‬ضىَش ٌٓزٌص (ال ًىؿً‬
‫فٌهد خًـٔم)‪ٌ .‬نوظى خًلطىي نىل خًطىَ بمد من خألنرتنع ؤو من هالي ططىًُ نًش فًًٌىخض‬
‫وطلٌٔمهد ًطىَ‪.‬‬
‫خًطىَ خملىؿزص طهنٍ خًطىَش خًطىَش خًظٍ طلىي نىل خًـٔم (نىل ٓزٌٍ خملؼدي خًىؿه ؤو خًهٍن)‪،‬‬
‫وخًطىَ خًٌٔزٌص هٍ خًظٍ ال طظػمن خًـٔم‪.‬وؿىي نًي هزًن من خًطىَ خإلًـدرٌص وخًٌٔزٌص (خًوٌفٌص)‬
‫ًهؿٌند يكص ؤهرب يف خملطنف(‪.)classifier‬‬
‫امخؼىحُ‪ُ:2‬ذشذٌجُامصىسُامعنثٌخ ُ‬
‫غو ضىَ خًوٌفٌص غمن مـًٌ ‪ Haar Training\training\negative‬وشًٍ خملٌف‬
‫‪create_list.bat‬‬
‫‪dir /b *.jpg >bg.txt‬‬
‫رهً طشًٌٍ هٍخ خملٌف ٓنلطٍ نىل مٌف نًص ردٓم ‪ً bg.txt‬لىي نىل ؤٌٓلء خًطىَ هٌل ًًل‪:‬‬
‫‪image1200.jpg‬‬
‫‪image1201.jpg‬‬
‫‪image1202.jpg‬‬
‫‪...‬‬
‫‪346‬‬ ‫‪ OpenCv‬ببساطة‬

‫ٓنلظدؾ هٍخ خملٌف خًنًص خًٍي ًلىي نىل رٌدندض خًطىَ خًٌٔزٌص ًظًًَس خملطنف‪.‬‬
‫امخؼىحُ‪ُ:3‬املصُ&ُذػنٌمُامصىسُاملىظثخ ُ‬
‫يف هٍه خًوؿىش ٓنلظدؾ إلنشدء مٌف رٌدندض (‪ً )vector file‬لىي نىل ؤٌٓلء خًطىَ خملىؿزص‬
‫ردإلغدفص ملىغو خًـٔم يف هٍ ضىَش‪ٌ .‬نونند بنشدء هٍخ خملٌف نن ؾًُم ؤيخطٍن هٌل‪:‬‬
‫‪ Objectmarker‬ؤو ‪.Image Clipper‬‬
‫ؤيخش ‪ Objectmarker‬ؤهًت رٔدؾص وؤرسم ؤمد خأليخش خًؼدنٌص ‪ Image Clipper‬نىند مد ؤهًت مُونص‬
‫وًون ٓظإهٍ مهى وكع ؤهرب ننً طهٌٌم خألؿٔدَ يف خًطىَ‪.‬‬
‫هند ٓنٔظوًَ ؤيخش ‪.Objectmarker‬‬
‫غو خًطىَ خملىؿزص غمن خملـًٌ ‪...\training\positive\rawdata‬‬
‫غمن خملـًٌ ‪ ....\training\positive‬هندن مٌف ؤٓمه ‪ٓ objectmaker.exe‬نلظدؿه ًظهٌٌم‬
‫خألؿٔدَ يف خًطىَخملىؿزص‪.‬‬
‫ًيك ًهمٍ خملٌف ‪ objectmaker.exe‬طإهً من وؿىي خملٌفٍن ‪ cv.dll‬و ‪ highgui.dll‬غمن مٔدَ‬
‫خملٌف‪.‬‬
‫كزٍ طشًٌٍ ‪ objectmaker.exe‬طإهً رإنى مُطدق وًًًى وكع هديف ًظهٌم رهندًص خألؿٔدَ ًهٍسخض‬
‫ؤو مجدض خًطىَ خملىؿزص‪.‬‬
‫هٌف ٓظهٌم خًـٔم؟ شًٍ خملٌف ‪ٓ objectmaker.exe‬ظشدهً ندفٍطٍن هٌل يف خألٓفٍ‪ :‬ندفٍش‬
‫ًهُع خًطىَش وندفٍش ًهُع خٓم خًطىَش‪.‬‬

‫ذ‬

‫ذ‬
‫‪347‬‬ ‫‪ OpenCv‬ببساطة‬

‫‪ )8‬خنلُ نىل خًّؤوًص خًهٌٌد ملنؿلص خًـٔم (مؼٍ خًىؿه) وؤمٔى خملإوْ كظى طهٌم منؿلص خًـٔم‪.‬‬
‫‪ٓ )4‬ظشدهً مٔظؿٌٍ كىي خًـٔم‪ .‬بٌخ مل ًهـزى خًظلًًً خغًـ ؤي َِ إلِخًص خًظلًًً (مد نًخ‬
‫َِ ‪ Space‬و‪)Enter‬‬

‫ذ‬

‫مالككص هدمص‪ :‬ننً َٓم خملٔظؿٌٍ خمللٌـ ردًـٔم خهظم ؤن طزًؤ رُٓم خملُرو بمد من خًّؤوًص خًٌرسي خًهٌٌد ؤو من‬
‫خًّؤوًد خًٔفىل خًٌمنى‪ .‬بٌخ رًؤض خًُٓم من خًّؤوًظٍن خألهًُظٍن فٌن ًوظس بكًخػٌدض خًـٔم خمللًي غمن خملٌف‬
‫‪ info.txt‬ؤي هإنى مل طلًي خًـٔم‪.‬‬

‫بٌخ َٓمع خملٔظؿٌٍ رشوٍ ضلٌم ؤغًـ نىل خًَّ ‪ . SPACE‬نن ًٌى ٌٓكهُ مىغو خملٔظؿٌٍ‬
‫وكٌدٓه نىل خًندفٍش خًٔىيخء (هٌل هى وخغم يف خًطىَش)‬

‫ؤنً خًوؿىخض من ‪ a‬بىل ‪ c‬بٌخ هدن هندن نًش ؤؿٔدَ يف خًطىَش (مؼٍ نًش وؿىه)‪.‬‬
‫‪348‬‬ ‫‪ OpenCv‬ببساطة‬

‫ننًمد طنظهٍ من طلًًً خألؿٔدَ يف خًطىَش خًلدًٌص ؤغًـ خًَّ ‪.Enter‬‬
‫هَُ خًوؿىخض من ‪ a‬بىل ‪ e‬كظى طنظهٍ من طهٌٌم ؿمٌو خألؿٔدَ يف خًطىَ خملىؿزص‪.‬‬
‫بٌخ شهُض رإنى طهزع وطًًُ خًظىكف نن طهٌٌم خًطىَ خغًـ َِ ‪ ESC‬ننًهد ٌٓظم بنشدء مٌف نًص‬
‫ردٓم ‪.info.txt‬‬
‫طلًٍُ‪ :‬ننًمد طوُؾ من خأليخش ‪ ojectmaker‬وطًًُ بهٌلي طهٌٌم خًطىَ خملىؿزص فٌٌل رهً كم رللل خملٌف‬
‫‪ info.txt‬خًلديل خًٍي ؤنشإطه يف مـًٌ ؤهُ ؤو يًن ؤٓمه (يف هٍ مُش طوُؾ منهد من خأليخش كم رظًًٌن خٓم خملٌف‬
‫بىل ‪ .)info1.txt, info2.txt‬ألنه يف هٍ مُش ٓظشًٍ فٌهد خأليخش ‪ٌٓ ojectmaker.exe‬ظم خًوظدرص فىق خملٌف‬
‫‪ info.txt‬خًلديل وٓظٍهس هٍ خًزٌدندض خًظٍ نمٌظهد‪ .‬ورهً خألنظهدء من طهٌٌم ؿمٌو خًطىَ كم رًمف ؿمٌو‬
‫رٌدندض خملٌفدض خًنطٌص خًظٍ ؤنشإطهد غمن مٌف نًص وخكً ردٓم ‪.info.txt‬‬
‫يخهٍ خملٌف خًنًص ‪ٓ info.txt‬ظشدهً رهؼ خملهٌىمدض مؼٍ‪:‬‬

‫‪rawdata\image1200.bmp 1 34 12 74 24‬‬
‫‪rawdata\image1201.bmp 3 35 25 70 39 40 95 80 92 120 40 45 36‬‬
‫‪ rawdata\image1202.bmp 2 10 24 90 90 45 68 99 82‬ذ‬

‫ؤوي َكم ٌنؼٍ نًي خألؿٔدَ خملىؿىيش يف خًطىَش خملهؿدش‪ ،‬فهىل ٓزٌٍ خملؼدي يف خًٔؿُ خًؼدين‬
‫خًُكم ‪ًً 4‬ي نىل ؤن هندن ػالػص ؤؿٔدَ يف هٍه خًطىَش (هؼالػص وؿىه)‪ .‬خألَكم خألَرهص خًظدًٌص خملٌىنص‬
‫ردألهٍص طهؿٌند مىغو ؤوي ؿٔم يف خًطىَش (بكًخػٌدض خًّؤوًد خًهٌٌد خًٌرسي ًٌمٔظؿٌٍ ‪x= 35 ,‬‬
‫‪ y=25‬وؾىي ونُع خملٔظؿٌٍ ‪ )Width=70 ,Hight=39‬وخألَكدَ خألَرهص خًظدًٌص خملىنص ردألخكمُ‬
‫متؼٍ مىكو ًـٔم خًؼدين‪ ،‬وخألَكدَ خملٌىنص ردألَِق متؼٍ خًـٔم خًؼدًؽ‪ ،‬وهوٍخ ‪...‬‬

‫وؿىي هؿإ نىل ٓزٌٍ خملؼدي هٌل يف هٍخ خًٔؿُ‪ٌ rawdata/d19.bmp 3 83 119 185 183 :‬نون‬
‫ؤن ًايي بىل كًوغ هؿإ هزًن يًن مٌلىف ننًمد طًَذ خملطنف ًٌظهُف نىل خًشوٍ (فهنً كطىي خًوؿإ يف‬
‫ٓؿُ مهٍن ٌنون ؤن ًايي ًهًَ كُخءش خألٓؿُ خًظٍ طًل خًوؿإ)‪ .‬كزٍ خًزًء يف خًوؿىش خًظٍ طٌٌهد طإهً ؤن هٍ ؤٓؿُ‬
‫خملٌف ‪ info.txt‬ضلٌلص‪.‬‬

‫خًوؿإ يف خملؼدي خًٔدرم هى ردًهًي ‪ 4‬فٌـس ؤن ًوىن خًهًي ‪ .8‬هٍخ خًنىم من خًوؿإ ٌنون ؤن‬
‫ًلًغ ننًمد طًمف مٌفدض ‪ info.txt‬مهد‪.‬‬
349 ‫ ببساطة‬OpenCv

ُ ‫ُمنصىسُاملىظثخ‬vectorُ‫ُبنشبءُمنف‬:4ُ‫امخؼىح‬
‫) خٓمه‬batch(‫ هندن مٌف ردطش‬..\training\ ًٌ‫غمن خملـ‬
samples_creation.bat

:‫ًوظىي هٍخ خملٌف نىل خألوخمُ خًظدًٌص‬
createsamples.exe -info positive/info.txt -vec vector/facevector.vec -num 200 -w 24 -h 24

:ٍ‫خًزدَمرتخض خًُثٌٌٔص ه‬

-info positive/info.txt Path for positive info file
-vec vector/facevector.vec Path for the output vector file
-num 200 Number of positive files to be packed in a vector file
-w 24 Width of objects
-h 24 Height of objects
‫ ردٓم‬vector ‫ وًلَّ ضىَ خألؿٔدَ يف مٌف‬info.txt ‫مٌف خًزدطش هٍخ ًلمٍ خملٌف خًنًص‬
‫ رهً طشًٌٍ مٌف خالرظش ٓىف طلطٍ نىل مٌف ردٓم‬.facevector.vec ‫ مؼال‬،‫نوظدَه‬
..\training\vector ًٌ‫ يخهٍ خملـ‬facevector.vec
‫ٓظلظدؾ ألن ًوىن غمن مٔدَ خملـًٌ خملٌفدض خًظدًٌص‬creatsample.exe ‫ ًظشًٌٍ خملٌف‬:‫الكل‬
cv097.dll, cxcore097.dll, highgui097.dll, and libguide40.dll

ُ )Haar-Training(ُHarrُ‫ُذذسًج‬:5ُ‫امخؼىح‬
: haartraining.bat ‫ ٌنونى طهًًٍ خًزدطش‬..\training ًٌ‫غمن خملـ‬
haartraining.exe -data cascades -vec vector/vector.vec -bg negative/bg.txt -npos 200 -nneg
200 -nstages 15 -mem 1024 -mode ALL -w 24 -h 24 –nonsym

-data cascades Path and for storing the cascade of classifiers
-vec data/vector.vec Path which points the location of vector file
-bg negative/bg.txt Path which points to background file
-npos 200 Number of positive samples ≤ no. positive bmp files
-nneg 200 Number of negative samples (patches) ≥ npos
-nstages 15 Number of intended stages for training
-mem 1024 Quantity of memory assigned in MB
-mode ALL Look literatures for more info about this parameter
-w 24 -h 24 Sample size
-nonsym Use this if your subject is not horizontally symmetrical
‫‪350‬‬ ‫‪ OpenCv‬ببساطة‬

‫خًلٌدْ ‪ -W‬و ‪ -H‬يف خًزدطش ‪ً harrtraining.bat‬نزًٍ ؤن ًوىن نفٔه يف خًزدطش ‪sample-‬‬
‫‪.creation.bat‬‬
‫ذ‬
‫‪ً Harrtraining.exe‬لى َ رـمو مـمىنص ؿًًًش من خًهٌندض خًٌٔزٌص يف هٍ مُكٌص‪ ،‬و ‪-nneg‬‬
‫ًلًي خًلً خألكىص ًلـم خملـمىنص‪ .‬بنه ًٔظوًَ مهٌىمدض خملُكٌص خًٔدرلص ًٌلًي ؤي خًهٌندض‬
‫مُشلص "‪ "candidate samples‬كظى ًظم ططنٌفهد رشوٍ ضلٌم‪ .‬يف نهدًص خًظًًَس ننًمد ططزم‬
‫نٔزص خًهٌندض خًظٍ طم ططنٌفهد رشوٍ ضلٌم من خًهٌندض خملُشلص ؤكٍ من‬
‫ًًٍى ‪:‬‬

‫ًًٍى مهٌل هدن نًي خملُخكٍ (‪ )nstages‬خمللًيش يف ‪ .haartraining.bat‬خًربندمف كً ًنظهٍ‬
‫ردهُخ (ؤي كزٍ نهدًص نًي خملُخكٍ خمللًيش) بٌخ وضٍ ًٌٍسؽ خًٔدرم‪ .‬نديش بنهد بشدَش ؿًٌش ًًكص‬
‫نمٌٌص خًظًًَس ًًًند‪ ،‬وًون ؤًػإ ٌنون ؤن ًلًغ ننًمد طوىن نًي خًطىَ خملىؿزص ًٌٕ هديف‬
‫(مؼال ؤكٍ من ‪.)055‬‬
‫الكل‪ً :‬ظشًٍ خملٌف ‪ٓ haartaining.exe‬ظلظدؾ ألن ًوىن غمن مٔدَ خملـًٌ خملٌفدض خًظدًٌص‪:‬‬
‫‪cv097.dll, cxcore097.dll, and highgui097.dll‬‬
‫ننًمد طشًٍ ‪ٓ haartraning.bat‬ظشدهً رهؼ خملهٌىمدض خملشدرهص ًٌطىَش خًظدًٌص‪:‬‬

‫ذ‬
351 ‫ ببساطة‬OpenCv

.‫خملهؿٌدض خًظٍ يف خًطىَش هٍ ًٌمُكٌص خألوىل من خًظًًَس‬
Parent node: Defines the current stage under training process
N: Number of used features in this stage
%SMP: Sample Percentage (Percentage of sample used for this feature)
F: "+" if flipped (when symmetry applied) and "– "if not
ST.THR: Stage Threshold
HR: Hit Rate based on the stage threshold
FA: False Alarm based on the stage threshold
EXP. ERR: Exponential Error of strong classifier
.‫من مُخكٍ طًًَس خملطنف‬ ‫خًطىَش خًظدًٌص طهُع خملُكٌص خًهدٌسش‬

‫ذ‬
‫‪352‬‬ ‫‪ OpenCv‬ببساطة‬

‫امخؼىحُ‪ُ:6‬بنشبءُمنفُامـُ‪ُ XML‬‬
‫رهً خالنظهدء من مُخكٍ طًًَس ‪ٓ Harr‬ظـً غمن خملـًٌ ‪ ../training/cascades/‬مـمىنص من‬
‫خملـًٌخض مُكمص من خًُكم ‪ 5‬بىل َكم خملُخكٍ خًظٍ طم طلًًًهد غمن خملٌف ‪.haartraining.bat‬‬
‫يف هٍ مـًٌ من خملـًٌخض خًٔدرلص ًـس ؤن ًوىن هندن مٌف نًص ردٓم‬
‫‪ .AdaBoostCARTHaarClassifier.txt‬كم رنٔى ؿمٌو خملـًٌخض بىل خملـًٌ ‪../cascade2xml/data/‬‬
‫خألن ًـس نٌٌند ؿمٌو خملُخكٍ خًظٍ طم بنشدثهد (خملطنفدض) غمن مٌف وخكً ‪ XML‬وخًٍي ٌٓوىن‬
‫خملٌف خًنهديئ‪.‬‬
‫شًٍ مٌف خًزدطش ‪ convert.bat‬خملىؿىي غمن خملـًٌ ‪../cascade2xml/‬‬
‫ًظػمن مٌف خًزدطش هٍخ خًظهٌٌٌلض خًظدًٌص‪:‬‬
‫‪haarconv.exe data myfacedetector.xml 24 24‬‬
‫‪ myfacedetecor.xml‬هى خٓم مٌف خًوُؾ وخًُكمٍن ‪ً 24 24‬لًيخن ‪ W‬و ‪H.‬‬
‫خألن ؤضزم ًًًند مٌف خي ‪ XML‬خًودص رند‪ ،‬وخًٍي ٌنونى من هالًه خهظشدف خألؿٔدَ‪.‬‬
‫‪353‬‬ ‫‪ OpenCv‬ببساطة‬

‫ذؼثٌلبدُغمنٌخ ُ‬
‫كً ًٔإي ؤكًهم رإنند طهٌمند مهدًـص خًطىَ فوٌف نٔظؿٌو خآلن َرؿهد مو خألؿهّش خإلًورتونٌص؟‬
‫هندن فوُش ًـس ؤن طفهمهد كظى طٔظؿٌو ؤن طُرـ ؤي مٍسوم مهدًـص ضىَش مو خًهندرص وخألؿهّش‬
‫خألًورتونٌص وهٍ‪:‬‬

‫ننًمد طٔظؿٌو َٓم مٔظؿٌٍ ؤو يخثُش يف مودن خًـٔم خملؿٌىذ خًزلؽ ننه فإنع طهُف بٌخ‬
‫بكًخػٌدض )‪ (X,Y‬ملودن وؿىي خًـٔم نىل خًشدشص‪ ،‬فةٌخ هٍ مد طلظدؿه هى متًُُ هٍه خإلكًخػٌدض‬
‫ًٌـهدِ خًوهُرديئ ؤو خإلًورتوين هملُن خًًٔنفى مؼال‪ ،‬فٌظم طلًُى خًًٔنفى رندءخ ً نىل هٍه‬
‫خإلكًخػٌدض‪ .‬خًظؿزٌلدض خًظدًٌص طىغم رهػد من هٍه خألفودَ‪.‬‬

‫ؿثال‪:‬ذذؿالحؼةذؽرة‬

‫ذ‬

‫ٓنظهٌم يف هٍخ خًظؿزٌم ؾًُلص خًظلوم مبلُهٍن ًظلوٌلن رودمًنخ ملالكلص هُش نن ؾًُم ًىنهد‪.‬‬
‫خًهًف من خًظؿزٌم هى فهم هٌفٌص خٓظوًخَ موظزص ‪ًٌ OpenCv‬ظلوم ردًهندرص خًوهُردثٌص‬
‫وخإلًورتونٌص‪ .‬موؿؿدض خملٍسوم وخًوىي وخًطىَ مظىفُش نىل خًُخرـ‪:‬‬

‫‪https://github.com/MicrocontrollersAndMore/Raspberry_Pi_2_and_OpenCV_3_Tutori‬‬
‫‪al_Part_1‬‬
354 ‫ ببساطة‬OpenCv

:‫خًوىي مظىفُ نىل خًُخرـ‬
https://github.com/MicrocontrollersAndMore/Raspberry_Pi_2_and_OpenCV_3_Tutorial
_Part_1/blob/master/pan_and_tilt_tracker.py

ُ :‫املىكؼُامربيلًُؽرىيُغىلُامػذًذُمنُؤفكبسُاملشبسًؼُامرٍُميكنكُذنفٌزهب‬
/https://www.intorobotics.com/20-hand-picked-raspberry-pi-tutorials-in-computer-vision

ُ ‫املشاظؼُامشئٌعٌخ‬
 https://opencv-python-
tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html
 http://docs.opencv.org/master/d6/d00/tutorial_py_root.html ‫ذذذذ‬

 http://docs.opencv.org/2.4/index.html
 http://docs.opencv.org/3.0-beta/modules/refman.html
 http://opencvpython.blogspot.com/
 http://www.pyimagesearch.com/
 http://coding-robin.de/2013/07/22/train-your-own-opencv-haar-
classifier.html
 http://alereimondo.no-ip.org/OpenCV/34
 https://pythonprogramming.net/haar-cascade-object-detection-python-
opencv-tutorial/
 http://breakinpointteam.blogspot.com/2015/12/opencv.html
 http://destovskyson.blogspot.com/
 ‫ذذؽتابذرادبرييذبايذببدارةذؾؾؿفـدسذعبدذاهللذعؾيذعبدذاهلل‬
 http://breakinpointteam.blogspot.com/2015/12/opencv.html
 https://www.youtube.com/playlist?list=PLd3hlSJsX_Imk_BPmB_H3A
QjFKZS9XgZm
 https://www.youtube.com/user/UCFCRCV/featured

http://destovskyson.blogspot.com

Sign up to vote on this title
UsefulNot useful