اب، ہم اوپر دیے گئے تمام امیج پروسیسنگ کے موضوعات کو تفصیل سے بیان کریں گے۔
1. تصویری ترجمہ
تصویری ترجمہ تصویری پروسیسنگ کا ایک طریقہ ہے جو تصویر کو x اور y-axes کے ساتھ منتقل کرنے میں ہماری مدد کرتا ہے۔ ہم تصویر کو اوپر، نیچے، دائیں، بائیں، یا کسی بھی مرکب کو منتقل کر سکتے ہیں۔
ہم ٹرانسلیشن میٹرکس کو علامت M کے ساتھ بیان کر سکتے ہیں، اور ہم اسے ریاضی کی شکل میں پیش کر سکتے ہیں، جیسا کہ ذیل میں دکھایا گیا ہے:
ہم اس پروگرام کے ذریعے ترجمے کی تصویر کے تصور کو سمجھ سکتے ہیں۔
ازگر کوڈ: ہم مندرجہ ذیل پروگرام کا نام رکھیں گے۔ translate.py .
# مطلوبہ پیکجز درآمد کریں۔درآمد بے حس کے طور پر جیسے
درآمد argparse
درآمد imutil
درآمد cv2
# ہم دلیل تجزیہ کار کو نافذ کرتے ہیں۔
ap_obj = argparse. آرگومنٹ پارسر ( )
ap_obj add_argument ( '-k' ، '--تصویر' ، مطلوبہ = سچ ہے۔ ،
مدد = 'تصویر فائل کا مقام' )
args = جس کا ( ap_obj parse_args ( ) )
# تصویر لوڈ کریں اور اسکرین پر دکھائیں۔
تصویر = cv2. imread ( args [ 'تصویر' ] )
cv2. imshow ( 'اصل_تصویر' ، تصویر )
# تصویر کا ترجمہ ایک NumPy میٹرکس ہے جو ذیل میں دیا گیا ہے:
# [[1, 0, shiftX], [0, 1, shiftY]]
# ہم اوپر NumPy میٹرکس کو استعمال کرنے جا رہے ہیں تاکہ تصاویر کو ساتھ میں منتقل کیا جا سکے۔
# x-axis اور y-axis کی سمتیں۔ اس کے لیے ہمیں صرف پکسل ویلیوز کو پاس کرنا ہوگا۔
# اس پروگرام میں، ہم تصویر 30 پکسلز کو دائیں طرف لے جائیں گے۔
# اور نیچے کی طرف 70 پکسلز۔
ترجمہ_چیٹ = جیسے float32 ( [ [ 1 ، 0 ، 30 ] ، [ 0 ، 1 ، 70 ] ] )
تصویر_ترجمہ = cv2. warpAffine ( تصویر ، ترجمہ_چیٹ ،
( تصویر. شکل [ 1 ] ، تصویر. شکل [ 0 ] ) )
cv2. imshow ( 'تصویر کا ترجمہ نیچے اور دائیں' ، تصویر_ترجمہ )
# اب، ہم اوپر NumPy میٹرکس کو استعمال کرنے جا رہے ہیں تاکہ تصاویر کو ساتھ میں منتقل کیا جا سکے۔
# x-axis (بائیں) اور y-axis (اوپر) سمتیں۔
# یہاں، ہم تصاویر کو 50 پکسلز بائیں طرف منتقل کرنے جا رہے ہیں۔
# اور 90 پکسلز اوپر کی طرف۔
ترجمہ_چیٹ = جیسے float32 ( [ [ 1 ، 0 ، - پچاس ] ، [ 0 ، 1 ، - 90 ] ] )
تصویر_ترجمہ = cv2. warpAffine ( تصویر ، ترجمہ_چیٹ ،
( تصویر. شکل [ 1 ] ، تصویر. شکل [ 0 ] ) )
cv2. imshow ( 'تصویر کا ترجمہ اوپر اور بائیں' ، تصویر_ترجمہ )
cv2. waitKey ( 0 )
سطریں 1 سے 5: ہم اس پروگرام کے لیے تمام مطلوبہ پیکجز درآمد کر رہے ہیں، جیسے OpenCV، argparser، اور NumPy۔ براہ کرم نوٹ کریں کہ ایک اور لائبریری ہے جو imutils ہے۔ یہ OpenCV کا پیکج نہیں ہے۔ یہ صرف ایک لائبریری ہے جو آسانی سے وہی تصویری پروسیسنگ دکھائے گی۔
جب ہم OpenCV انسٹال کرتے ہیں تو لائبریری امیوٹلز خود بخود شامل نہیں ہوں گے۔ لہذا imutils کو انسٹال کرنے کے لئے، ہمیں مندرجہ ذیل طریقہ استعمال کرنا ہوگا:
pip imutils انسٹال کریں۔
سطر 8 سے 15: ہم نے اپنا agrparser بنایا اور اپنی تصویر کو لوڈ کیا۔
سطر 24 سے 25: یہ پروگرام سیکشن ہے جہاں ترجمہ ہوتا ہے۔ ترجمہ میٹرکس ہمیں بتاتا ہے کہ تصویر کو کتنے پکسلز اوپر یا نیچے یا بائیں یا دائیں منتقل کیا جائے گا۔ چونکہ OpenCV کا تقاضہ ہے کہ میٹرکس ویلیو فلوٹنگ پوائنٹ اری میں ہو، ترجمہ میٹرکس فلوٹنگ پوائنٹ اری میں قدریں لیتا ہے۔
ترجمہ میٹرکس کی پہلی قطار اس طرح نظر آتی ہے:
میٹرکس کی یہ قطار ایکس محور کے لیے ہے۔ ٹی کی قدر ایکس فیصلہ کرے گا کہ تصویر کو بائیں یا دائیں طرف منتقل کیا جائے گا۔ اگر ہم منفی قدر کو پاس کرتے ہیں، تو اس کا مطلب ہے کہ تصویر بائیں جانب منتقل ہو جائے گی، اور اگر قدر مثبت ہے، تو اس کا مطلب ہے کہ تصویر دائیں طرف منتقل ہو جائے گی۔
اب ہم میٹرکس کی دوسری قطار کی وضاحت اس طرح کریں گے:
میٹرکس کی یہ قطار y-axis کے لیے ہے۔ ٹی کی قدر Y فیصلہ کرے گا کہ تصویر کو اوپر یا نیچے کی طرف منتقل کیا جائے گا۔ اگر ہم منفی قدر کو پاس کرتے ہیں، تو اس کا مطلب ہے کہ تصویر کو اوپر کی طرف منتقل کر دیا جائے گا، اور اگر قدر مثبت ہے، تو اس کا مطلب ہے کہ تصویر کو نیچے کی طرف منتقل کر دیا جائے گا۔
لائن 24 پر پچھلے پروگرام میں، ہم t کی وضاحت کرتے ہیں۔ ایکس = 30 اور ٹی Y = 70۔ لہذا ہم تصویر کو 30 پکسلز دائیں طرف اور 70 پکسلز نیچے کی طرف لے جا رہے ہیں۔
لیکن تصویری ترجمے کا مرکزی عمل لائن 25 پر ہوتا ہے، جہاں ہم ترجمہ میٹرکس کی وضاحت کرتے ہیں۔ cv2.warpAffine . اس فنکشن میں، ہم تین پیرامیٹرز کو پاس کر رہے ہیں: پہلا پیرامیٹر امیج ہے، دوسرا پیرامیٹر ٹرانسلیشن میٹرکس ہے، اور تیسرا پیرامیٹر امیج ڈائمینشن ہے۔
لائن 27: لائن 27 آؤٹ پٹ میں نتیجہ دکھائے گی۔
اب، ہم بائیں اور اوپر کے لیے ایک اور ترجمہ میٹرکس نافذ کریں گے۔ اس کے لیے ہمیں اقدار کو منفی میں بیان کرنا ہوگا۔
لائن 33 سے 34: لائن 33 پر پچھلے پروگرام میں، ہم t کی وضاحت کرتے ہیں۔ ایکس = -50 اور ٹی Y = -90۔ لہذا ہم تصویر کو 50 پکسلز بائیں طرف اور 90 پکسلز اوپر کی طرف لے جا رہے ہیں۔ لیکن تصویری ترجمے کا مرکزی عمل لائن 34 پر ہوتا ہے، جہاں ہم ترجمہ میٹرکس کی وضاحت کرتے ہیں۔ cv2.warpAffine .
لائن 36 : لائن 36 نتیجہ ظاہر کرے گی جیسا کہ آؤٹ پٹ میں دکھایا گیا ہے۔
پچھلے کوڈ کو چلانے کے لیے ہمیں تصویر کا راستہ دینا ہوگا جیسا کہ نیچے دیا گیا ہے۔
آؤٹ پٹ: python translate.py -image squirrel.jpg
اب، ہم اسی تصویری ترجمہ پروگرام کو استعمال کرتے ہوئے لاگو کریں گے۔ imutil کتب خانہ. یہ لائبریری امیج پروسیسنگ کے لیے استعمال میں بہت آسان ہے۔ اس لائبریری میں، ہمیں اس کے بارے میں سوچنے کی ضرورت نہیں ہے۔ cv2.warpAffine کیونکہ یہ لائبریری اس کا خیال رکھے گی۔ تو آئیے imutils لائبریری کا استعمال کرتے ہوئے اس تصویری ترجمہ کے پروگرام کو لاگو کریں۔
ازگر کوڈ: ہم مندرجہ ذیل پروگرام کا نام رکھیں گے۔ translate_imutils.py .
# ضروری پیکیجز درآمد کریں۔درآمد بے حس کے طور پر جیسے
درآمد argparse
درآمد imutil
درآمد cv2
# یہ فنکشن تصویری ترجمہ کو نافذ کرتا ہے اور
# ترجمہ شدہ تصویر کو کالنگ فنکشن میں واپس کرتا ہے۔
def ترجمہ ( تصویر ، ایکس , Y ) :
ترجمہ_میٹرکس = جیسے float32 ( [ [ 1 ، 0 , ایکس ] ، [ 0 ، 1 , Y ] ] )
تصویر_ترجمہ = cv2. warpAffine ( تصویر , ترجمہ_میٹرکس ,
( تصویر. شکل [ 1 ] , تصویر. شکل [ 0 ] ) )
واپسی تصویر_ترجمہ
# دلیل کا تجزیہ کار بنائیں اور دلائل کو پارس کریں۔
اے پی = argparse. آرگومنٹ پارسر ( )
اے پی add_argument ( '-میں' ، '--تصویر' ، کی ضرورت ہے = سچ ہے۔ ، مدد = 'تصویر کا راستہ' )
args = جس کا ( اے پی parse_args ( ) )
# تصویر لوڈ کریں اور اسکرین پر ڈسپلے کریں۔
تصویر = cv2. imread ( args [ 'تصویر' ] )
cv2. imshow ( 'اصل_تصویر' , تصویر )
تصویر_ترجمہ = imutil ترجمہ ( تصویر , 10 ، 70 )
cv2. imshow ( 'تصویر کا دائیں اور نیچے کی طرف ترجمہ' ،
تصویر_ترجمہ )
cv2. waitKey ( 0 )
لائن 9 سے 13: پروگرام کا یہ حصہ وہ جگہ ہے جہاں ترجمہ ہوتا ہے۔ ترجمہ میٹرکس ہمیں بتاتا ہے کہ تصویر کو کتنے پکسلز اوپر یا نیچے یا بائیں یا دائیں منتقل کیا جائے گا۔
ان لائنوں کی وضاحت پہلے ہی ہو چکی ہے، لیکن اب ہم translate () نامی فنکشن بنانے جا رہے ہیں اور اس میں تین الگ الگ پیرامیٹر بھیجیں گے۔ تصویر خود پہلے پیرامیٹر کے طور پر کام کرتی ہے۔ ترجمہ میٹرکس کی x، اور y کی قدریں دوسرے اور تیسرے پیرامیٹرز سے مطابقت رکھتی ہیں۔
نوٹ : پروگرام کے اندر اس ٹرانسلیٹ فنکشن کی وضاحت کرنے کی ضرورت نہیں ہے کیونکہ یہ پہلے سے ہی imutils لائبریری پیکج میں شامل ہے۔ میں نے اسے پروگرام کے اندر براہ راست وضاحت کی خاطر استعمال کیا ہے۔ ہم اس فنکشن کو براہ راست imutils کے ساتھ کال کر سکتے ہیں، جیسا کہ لائن 24 میں دکھایا گیا ہے۔
لائن 24: پچھلا پروگرام دکھائے گا کہ لائن 24 پر، ہم tx = 10 اور ty = 70 کی وضاحت کرتے ہیں۔ لہذا ہم تصویر کو 10 پکسلز دائیں طرف اور 70 پکسلز نیچے کی طرف لے جا رہے ہیں۔
اس پروگرام میں، ہمیں کسی بھی cv2.warpAffine فنکشن کی پرواہ نہیں ہے کیونکہ وہ پہلے سے ہی imutils لائبریری پیکیج کے اندر موجود ہیں۔
پچھلے کوڈ کو چلانے کے لیے ہمیں تصویر کا راستہ دینا ہوگا، جیسا کہ ذیل میں دیا گیا ہے۔
آؤٹ پٹ:
python imutils. py --تصویری گلہری۔ jpg 
2. تصویری گردش
ہم نے پچھلے سبق (یا کسی بھی مجموعہ) میں تصویر کو اوپر، نیچے، بائیں اور دائیں ترجمہ کرنے کا طریقہ (یعنی شفٹ) دیکھا۔ اگلا، ہم گردش پر بات کریں گے کیونکہ اس کا تعلق امیج پروسیسنگ سے ہے۔
ایک تصویر کو ایک زاویہ، تھیٹا سے گھمایا جاتا ہے، اس عمل میں جسے گردش کہا جاتا ہے۔ جس زاویے سے ہم تصویر کو گھما رہے ہیں اسے تھیٹا سے ظاہر کیا جائے گا۔ مزید برآں، میں بعد میں گھومنے والی تصاویر کو آسان بنانے کے لیے روٹیٹ کنویئنس فنکشن فراہم کروں گا۔
ترجمہ کی طرح، اور شاید حیرت کی بات نہیں، ایک زاویے سے گردش، تھیٹا کا تعین درج ذیل فارمیٹ میں میٹرکس M بنا کر کیا جاتا ہے:
یہ میٹرکس دی گئی اصل (x, y)-کارٹیشین ہوائی جہاز کے گرد ویکٹر تھیٹا ڈگری (کلاک وائز) کو گھما سکتا ہے۔ عام طور پر، اس منظر نامے میں، اصل تصویر کا مرکز ہو گا، لیکن حقیقت میں، ہم کسی بھی بے ترتیب (x، y) نقطہ کو اپنے گردشی مرکز کے طور پر نامزد کر سکتے ہیں۔
پھر گھمائی گئی تصویر R کو اصل تصویر I سے براہ راست میٹرکس ضرب کا استعمال کرتے ہوئے بنایا جاتا ہے: R = IM
دوسری طرف، OpenCV اضافی طور پر (1) ایک تصویر کو پیمانہ (یعنی سائز تبدیل کرنے) اور (2) ارد گرد گردش کرنے کے لیے ایک صوابدیدی گردشی مرکز کی پیشکش کرتا ہے۔
ہمارا ترمیم شدہ گردش میٹرکس M ذیل میں دکھایا گیا ہے:
آئیے ایک نئی فائل کو کھولنے اور تیار کرکے شروع کرتے ہیں جسے کہتے ہیں۔ rotate.py :
# مطلوبہ پیکجز درآمد کرنادرآمد بے حس کے طور پر جیسے
درآمد argparse
درآمد imutil
درآمد cv2
# argumentparser آبجیکٹ بنانا اور دلیل کو پارس کرنا
apobj = argparse. آرگومنٹ پارسر ( )
apobj add_argument ( '-k' , '--تصویر' , کی ضرورت ہے = سچ ہے۔ , مدد = 'تصویر کا راستہ' )
دلائل = جس کا ( apobj parse_args ( ) )
تصویر = cv2. imread ( دلائل [ 'تصویر' ] )
cv2. imshow ( 'اصل_تصویر' , تصویر )
# تصویر کے طول و عرض کا استعمال کرتے ہوئے تصویر کے مرکز کا حساب لگائیں۔
( اونچائی ، چوڑائی ) = تصویر. شکل [ : 2 ]
( سینٹر ایکس , مرکز وائی ) = ( چوڑائی / 2 , اونچائی / 2 )
# اب، cv2 کا استعمال کرتے ہوئے، ہم تصویر کو 55 ڈگری تک گھمائیں گے۔
# getRotationMatrix2D() کا استعمال کرتے ہوئے گردش میٹرکس کا تعین کریں
گردش میٹرکس = cv2. روٹیشن میٹرکس 2 ڈی حاصل کریں۔ ( ( سینٹر ایکس ، مرکز وائی ) ، 55 ، 1.0 )
گھمائی گئی تصویر = cv2. warpAffine ( تصویر , گردش میٹرکس , ( چوڑائی , اونچائی ) )
cv2. imshow ( 'تصویر کو 55 ڈگری گھمایا' ، گھمائی گئی تصویر )
cv2. waitKey ( 0 )
# تصویر کو اب -85 ڈگری گھمایا جائے گا۔
گردش میٹرکس = cv2. روٹیشن میٹرکس 2 ڈی حاصل کریں۔ ( ( سینٹر ایکس , مرکز وائی ) , - 85 ، 1.0 )
گھمائی گئی تصویر = cv2. warpAffine ( تصویر , گردش میٹرکس , ( چوڑائی ، اونچائی ) )
cv2. imshow ( 'تصویر کو -85 ڈگری گھمایا' , گھمائی گئی تصویر )
cv2. waitKey ( 0 )
سطریں 1 سے 5: ہم اس پروگرام کے لیے تمام مطلوبہ پیکجز درآمد کر رہے ہیں، جیسے OpenCV، argparser، اور NumPy۔ براہ کرم نوٹ کریں کہ ایک اور لائبریری ہے جو imutils ہے۔ یہ OpenCV کا پیکج نہیں ہے۔ یہ صرف ایک لائبریری ہے جو ایک ہی تصویری پروسیسنگ کو آسانی سے دکھانے کے لیے استعمال کی جائے گی۔
جب ہم OpenCV انسٹال کرتے ہیں تو لائبریری امیوٹلز خود بخود شامل نہیں ہوں گے۔ OpenCV imutils انسٹال کرتا ہے۔ ہمیں مندرجہ ذیل طریقہ استعمال کرنا ہوگا:
pip imutils انسٹال کریں۔
سطر 8 سے 14: ہم نے اپنا agrparser بنایا اور اپنی تصویر کو لوڈ کیا۔ اس آرگ پارسر میں، ہم صرف ایک تصویری دلیل استعمال کرتے ہیں، جو ہمیں تصویر کا راستہ بتائے گا جسے ہم اس پروگرام میں گردش کو ظاہر کرنے کے لیے استعمال کریں گے۔
کسی تصویر کو گھمانے پر، ہمیں گردش کے محور نقطہ کی وضاحت کرنی چاہیے۔ زیادہ تر وقت، آپ کسی تصویر کو اس کے مرکز کے بارے میں گھمانا چاہتے ہیں، لیکن OpenCV آپ کو اس کے بجائے کسی بھی بے ترتیب نقطہ کو منتخب کرنے کی اجازت دیتا ہے۔ آئیے صرف تصویر کو اس کے مرکز کے گرد گھمائیں۔
لائنیں 17 سے 18 تصویر کی چوڑائی اور اونچائی کو بالترتیب لیں، اور پھر تصویر کا مرکز قائم کرنے کے لیے ہر جہت کو دو سے تقسیم کریں۔
ہم تصویر کو گھمانے کے لیے ایک میٹرکس بناتے ہیں جس طرح ہم نے تصویر کا ترجمہ کرنے کے لیے میٹرکس کی تعریف کی تھی۔ ہم صرف کال کریں گے۔ cv2.getRotationMatrix2D NumPy کا استعمال کرتے ہوئے میٹرکس کو دستی طور پر بنانے کے بجائے لائن 22 پر فنکشن (جو تھوڑا بوجھل ہو سکتا ہے)۔
دی cv2.getRotationMatrix2D فنکشن کو تین پیرامیٹرز کی ضرورت ہے۔ پہلا ان پٹ مطلوبہ گردشی زاویہ ہے (اس صورت میں، تصویر کا مرکز)۔ اس کے بعد تھیٹا کا استعمال یہ بتانے کے لیے کیا جاتا ہے کہ ہم تصویر کو کتنی (کلاک وائز) ڈگریوں پر گھمائیں گے۔ یہاں، ہم تصویر کو 45 ڈگری گھمائیں گے۔ حتمی آپشن تصویر کے سائز سے متعلق ہے۔
اس حقیقت سے قطع نظر کہ ہم نے ابھی تک کسی تصویر کو اسکیل کرنے پر بات نہیں کی ہے، آپ یہاں 1.0 کے ساتھ ایک فلوٹنگ پوائنٹ نمبر فراہم کر سکتے ہیں جس سے یہ ظاہر ہوتا ہے کہ تصویر کو اس کے اصل تناسب میں استعمال کیا جانا چاہیے۔ تاہم، اگر آپ 2.0 کی قدر ٹائپ کرتے ہیں، تو تصویر کا سائز دوگنا ہو جائے گا۔ 0.5 کی تعداد اس طرح تصویر کے سائز کو کم کرتی ہے۔
لائن 22 سے 23: سے ہمارے گردش میٹرکس M حاصل کرنے کے بعد cv2.getRotationMatrix2D فنکشن، ہم اپنی تصویر کو استعمال کرتے ہوئے گھماتے ہیں۔ cv2.warpAffine لائن 23 پر تکنیک۔ فنکشن کا پہلا ان پٹ وہ امیج ہے جسے ہم گھمانا چاہتے ہیں۔ پھر ہماری آؤٹ پٹ امیج کی چوڑائی اور اونچائی کی وضاحت کی جاتی ہے، ہمارے گردش میٹرکس M کے ساتھ مل کر لائن 23 پر، تصویر کو پھر 55 ڈگری گھمایا جاتا ہے۔
آپ دیکھ سکتے ہیں کہ ہماری تصویر کو گھمایا گیا ہے۔
لائنیں 28 سے 30 دوسری گردش تشکیل دیں. کوڈ کی 22-23 لائنیں ایک جیسی ہیں، سوائے اس کے کہ اس بار ہم 55 کے مقابلے میں -85 ڈگری تک گھوم رہے ہیں۔
ہم نے اس مقام تک اس کے مرکز کے گرد صرف ایک تصویر کو گھمایا ہے۔ کیا ہوگا اگر ہم تصویر کو کسی بے ترتیب نقطہ کے گرد گھمانا چاہتے ہیں؟
آئیے ایک نئی فائل کو کھولنے اور تیار کرکے شروع کرتے ہیں جسے کہتے ہیں۔ rotate.py:
# مطلوبہ پیکجز درآمد کرنادرآمد بے حس کے طور پر جیسے
درآمد argparse
درآمد imutil
درآمد cv2
# argumentparser آبجیکٹ بنانا اور دلیل کو پارس کرنا
ap_obj = argparse. آرگومنٹ پارسر ( )
ap_obj add_argument ( '-k' ، '--تصویر' ، مطلوبہ = سچ ہے۔ ، مدد = 'تصویر کا راستہ' )
دلیل = جس کا ( ap_obj parse_args ( ) )
# تصویر لوڈ کریں اور اسکرین پر ڈسپلے کریں۔
تصویر = cv2. imread ( دلیل [ 'تصویر' ] )
cv2. imshow ( 'اصل_تصویر' ، تصویر )
# تصویر کے طول و عرض کا استعمال کرتے ہوئے تصویر کے مرکز کا حساب لگائیں۔
( اونچائی ، چوڑائی ) = تصویر. شکل [ : 2 ]
( سینٹر ایکس ، مرکز وائی ) = ( چوڑائی / 2 ، اونچائی / 2 )
# اب، cv2 کا استعمال کرتے ہوئے، ہم تصویر کو 55 ڈگری تک گھمائیں گے۔
# getRotationMatrix2D() کا استعمال کرتے ہوئے گردش میٹرکس کا تعین کریں
گردش میٹرکس = cv2. روٹیشن میٹرکس 2 ڈی حاصل کریں۔ ( ( سینٹر ایکس ، مرکز وائی ) ، 55 ، 1.0 )
گھمائی گئی تصویر = cv2. warpAffine ( تصویر ، گردش میٹرکس ، ( چوڑائی ، اونچائی ) )
cv2. imshow ( 'تصویر کو 55 ڈگری گھمایا' ، گھمائی گئی تصویر )
cv2. waitKey ( 0 )
# تصویر کو اب -85 ڈگری گھمایا جائے گا۔
گردش میٹرکس = cv2. روٹیشن میٹرکس 2 ڈی حاصل کریں۔ ( ( سینٹر ایکس ، مرکز وائی ) ، - 85 ، 1.0 )
گھمائی گئی تصویر = cv2. warpAffine ( تصویر ، گردش میٹرکس ، ( چوڑائی ، اونچائی ) )
cv2. imshow ( 'تصویر کو -85 ڈگری گھمایا' ، گھمائی گئی تصویر )
cv2. waitKey ( 0 )
# تصویر کی گردش کسی صوابدیدی نقطہ سے، مرکز سے نہیں۔
گردش میٹرکس = cv2. روٹیشن میٹرکس 2 ڈی حاصل کریں۔ ( ( سینٹر ایکس - 40 ، مرکز وائی - 40 ) ، 55 ، 1.0 )
گھمائی گئی تصویر = cv2. warpAffine ( تصویر ، گردش میٹرکس ، ( چوڑائی ، اونچائی ) )
cv2. imshow ( 'صوابدیدی پوائنٹس سے تصویر کی گردش' ، گھمائی گئی تصویر )
cv2. waitKey ( 0 )
لائن 34 سے 35: اب، یہ کوڈ کسی چیز کو گھومنے کے لیے کافی عام معلوم ہونا چاہیے۔ تصویر کو ایک پوائنٹ کے ارد گرد 40 پکسلز بائیں اور 40 پکسلز اس کے مرکز سے اوپر گھمانے کے لیے، ہم ہدایت دیتے ہیں cv2.getRotationMatrix2D اس کے پہلے پیرامیٹر پر توجہ دینے کے لیے فنکشن۔
جب ہم اس گردش کو لاگو کرتے ہیں تو جو تصویر تیار ہوتی ہے وہ ذیل میں دکھائی گئی ہے:
ہم واضح طور پر دیکھ سکتے ہیں کہ گردش کا مرکز اب (x, y) کوآرڈینیٹ ہے، جو تصویر کے حسابی مرکز سے 40 پکسلز بائیں طرف اور 40 پکسلز اوپر ہے۔
3. تصویری ریاضی
درحقیقت، تصویری ریاضی ڈیٹا کی اقسام پر چند اضافی پابندیوں کے ساتھ صرف میٹرکس کا اضافہ ہے جس کا ہم بعد میں احاطہ کریں گے۔
آئیے لکیری الجبرا کے کچھ خوبصورت بنیادی اصولوں پر جانے کے لیے ایک لمحہ نکالیں۔
اگلے دو میٹرکس کو یکجا کرنے پر غور کریں:
میٹرکس کا اضافہ کیا نتیجہ پیدا کرے گا؟ سادہ جواب میٹرکس اندراجات کا مجموعہ ہے، عنصر بہ عنصر:
کافی سادہ، ٹھیک ہے؟
ہم سب اس وقت جمع اور گھٹاؤ کے بنیادی کاموں کو سمجھتے ہیں۔ تاہم، ہمیں تصاویر کے ساتھ کام کرتے وقت اپنی رنگ کی جگہ اور ڈیٹا کی قسم کی طرف سے لگائی گئی پابندیوں کا خیال رکھنا چاہیے۔
مثال کے طور پر، آر جی بی امیجز میں پکسلز [0، 255] کے درمیان آتے ہیں۔ اگر ہم اسے دیکھتے ہوئے 250 کی شدت کے ساتھ پکسل میں 10 کا اضافہ کرنے کی کوشش کریں تو کیا ہوگا؟
اگر ہم معیاری ریاضی کے اصولوں کو لاگو کرتے ہیں تو ہم 260 کی قدر پر پہنچ جائیں گے۔ 260 ایک درست قدر نہیں ہے، کیونکہ RGB امیجز کو 8 بٹ کے بغیر دستخط شدہ عدد کے طور پر دکھایا جاتا ہے۔
تو کیا ہونا چاہئے؟ کیا ہمیں یہ یقینی بنانے کے لیے ایک چیک چلانا چاہیے کہ کوئی پکسل [0، 255] کی حد سے باہر نہیں ہے، ہر پکسل کو 0 اور 255 کے درمیان قدر رکھنے کے لیے تراشنا چاہیے؟
یا کیا ہم 'لپٹتے ہیں' اور ماڈیولس آپریشن کرتے ہیں؟ ماڈیولس کے اصولوں کے مطابق، 10 سے 255 کا اضافہ کرنے سے صرف 9 کی قدر ہوگی۔
[0، 255] کی حد سے باہر کی تصاویر میں اضافے اور گھٹاؤ کو کیسے ہینڈل کیا جانا چاہئے؟
سچ یہ ہے کہ کوئی صحیح یا غلط تکنیک نہیں ہے۔ یہ سب اس بات پر منحصر ہے کہ آپ اپنے پکسلز کے ساتھ کیسے کام کر رہے ہیں اور آپ کو کیا حاصل کرنے کی امید ہے۔
لیکن یاد رکھیں کہ OpenCV میں اضافے اور NumPy میں اضافے کے درمیان فرق ہے۔ ماڈیولس ریاضی اور 'ریپ ارد گرد' NumPy کے ذریعہ کیا جائے گا۔ اس کے برعکس، OpenCV کلپنگ کو انجام دے گا اور اس بات کو یقینی بنائے گا کہ پکسل کی قدریں کبھی بھی حد سے باہر نہ نکلیں [0, 255]۔
آئیے ایک نئی فائل بنا کر شروع کریں۔ arithmetic.py اور اسے کھولنا:
# python arithmetic.py --image squirrel.jpg# مطلوبہ پیکجز درآمد کرنا
درآمد بے حس کے طور پر جیسے
درآمد argparse
درآمد imutil
درآمد cv2
# argumentparser آبجیکٹ بنانا اور دلیل کو پارس کرنا
apObj = argparse. آرگومنٹ پارسر ( )
apObj add_argument ( '-k' ، '--تصویر' ، مطلوبہ = سچ ہے۔ ، مدد = 'تصویر کا راستہ' )
دلائل = جس کا ( apObj parse_args ( ) )
تصویر = cv2. imread ( دلائل [ 'تصویر' ] )
cv2. imshow ( 'اصل_تصویر' ، تصویر )
'''
ہمارے پکسلز کی قدریں رینج میں ہوں گی [0, 255]
چونکہ امیجز NumPy arrays ہیں، جو بغیر دستخط شدہ 8 بٹ انٹیجرز کے طور پر محفوظ ہیں۔
cv2.add اور cv2.subtract جیسے فنکشنز کا استعمال کرتے وقت، قدریں تراشی جائیں گی۔
اس رینج میں یہاں تک کہ اگر وہ اس کے باہر سے شامل یا گھٹا دیے جائیں۔
[0، 255] حد۔ یہاں ایک مثال ہے:
'''
پرنٹ کریں ( 'زیادہ سے زیادہ 255: {}' . فارمیٹ ( str ( cv2. شامل کریں ( جیسے uint8 ( [ 201 ] ) ،
جیسے uint8 ( [ 100 ] ) ) ) ) )
پرنٹ کریں ( 'کم از کم 0: {}' . فارمیٹ ( str ( cv2. گھٹائیں ( جیسے uint8 ( [ 60 ] ) ،
جیسے uint8 ( [ 100 ] ) ) ) ) )
'''
NumPy کا استعمال کرتے ہوئے ان صفوں کے ساتھ ریاضی کے آپریشن کرتے وقت،
قیمت پر کلپ ہونے کے بجائے لپیٹ دی جائے گی۔
[0، 255]رینج۔ تصاویر کا استعمال کرتے وقت، اسے رکھنا ضروری ہے۔
ذہن میں.
'''
پرنٹ کریں ( 'ارد گرد لپیٹنا: {}' . فارمیٹ ( str ( جیسے uint8 ( [ 201 ] ) + جیسے uint8 ( [ 100 ] ) ) ) )
پرنٹ کریں ( 'ارد گرد لپیٹنا: {}' . فارمیٹ ( str ( جیسے uint8 ( [ 60 ] ) --.جیسے uint8 ( [ 100 ] ) ) ) )
'''
آئیے اپنی تصویر میں ہر پکسل کی چمک کو 101 سے ضرب دیں۔
ایسا کرنے کے لیے، ہم ایک NumPy سرنی تیار کرتے ہیں جس سائز کا ہمارے میٹرکس،
والوں سے بھرا ہوا ہے، اور اس کو 101 سے ضرب دیں تاکہ بھری ہوئی صف پیدا ہو۔
101s کے ساتھ۔ آخر میں، ہم دونوں تصاویر کو ضم کرتے ہیں۔
آپ نوٹ کریں گے کہ تصویر اب 'روشن' ہے۔
'''
میٹرکس = جیسے والے ( تصویر. شکل ، dtype = 'uint8' ) * 101
image_added = cv2. شامل کریں ( تصویر ، میٹرکس )
cv2. imshow ( 'تصویر کا نتیجہ شامل کیا گیا' ، image_added )
# اسی طرح، ہم لے کر اپنی تصویر کو گہرا بنا سکتے ہیں۔
# 60 تمام پکسلز سے دور۔
میٹرکس = جیسے والے ( تصویر. شکل ، dtype = 'uint8' ) * 60
image_subtracted = cv2. گھٹائیں ( تصویر ، میٹرکس )
cv2. imshow ( 'منقطع تصویری نتیجہ' ، image_subtracted )
cv2. waitKey ( 0 )
لائنیں 1 سے 16 تک ہمارے عام عمل کو انجام دینے کے لیے استعمال کیا جائے گا، جس میں ہمارے پیکجز کو درآمد کرنا، ہمارے آرگومنٹ پارسر کو ترتیب دینا، اور ہماری تصویر کو لوڈ کرنا شامل ہے۔
یاد کریں کہ میں نے پہلے کیسے OpenCV اور NumPy اضافے کے درمیان فرق پر تبادلہ خیال کیا تھا؟ اب جب کہ ہم نے اسے اچھی طرح سے ڈھانپ لیا ہے، آئیے ایک مخصوص کیس کو دیکھتے ہیں تاکہ یہ یقینی بنایا جا سکے کہ ہم اسے سمجھ سکتے ہیں۔
دو 8 بٹ غیر دستخط شدہ عدد NumPy صفوں کی وضاحت کی گئی ہے۔ لائن 26 . 201 کی قدر پہلی صف میں واحد عنصر ہے۔ اگرچہ صرف ایک رکن دوسری صف میں ہے، اس کی قیمت 100 ہے۔ پھر اقدار کو OpenCV کے cv2.add فنکشن کا استعمال کرتے ہوئے شامل کیا جاتا ہے۔
آپ کو نتیجہ کیا ہونے کی توقع ہے؟
روایتی ریاضی کے اصولوں کے مطابق، جواب 301 ہونا چاہیے۔ لیکن یاد رکھیں کہ ہم 8 بٹ کے غیر دستخط شدہ عدد کے ساتھ کام کر رہے ہیں، جو صرف حد [0، 255] میں ہو سکتے ہیں۔ چونکہ ہم cv2.add طریقہ استعمال کر رہے ہیں، OpenCV کلپنگ کو سنبھالتا ہے اور اس بات کو یقینی بناتا ہے کہ اضافہ صرف 255 کا زیادہ سے زیادہ نتیجہ دیتا ہے۔
ذیل کی فہرست کی پہلی سطر اس کوڈ کو چلانے کے نتائج کو ظاہر کرتی ہے:
ریاضی. pyزیادہ سے زیادہ 255 : [ [ 255 ] ]
اس رقم نے واقعی 255 کی تعداد پیدا کی۔
اس کے بعد، لائن 26 گھٹاؤ کو پورا کرنے کے لیے cv2.subtract استعمال کرتا ہے۔ ایک بار پھر، ہم دو 8 بٹ غیر دستخط شدہ عدد NumPy صفوں کی وضاحت کرتے ہیں جس میں ہر ایک میں ایک عنصر ہے۔ پہلی صف کی قدر 60 ہے، جب کہ دوسری صف کی قدر 100 ہے۔
ہمارا ریاضی حکم دیتا ہے کہ گھٹاؤ کے نتیجے میں -40 کی قدر ہونی چاہیے، لیکن OpenCV ہمارے لیے ایک بار پھر کلپنگ کو ہینڈل کرتا ہے۔ ہمیں پتہ چلا کہ قدر کو 0 کر دیا گیا ہے۔ ذیل میں ہمارا نتیجہ یہ ظاہر کرتا ہے:
ریاضی. pyکم از کم 0 : [ [ 0 ] ]
cv2 کا استعمال کرتے ہوئے، 100 کو 60 سے گھٹائیں، قدر 0 پیدا کریں۔
لیکن کیا ہوگا اگر ہم حسابات کو انجام دینے کے لیے OpenCV کی جگہ NumPy استعمال کریں؟
لائنیں 38 اور 39 اس مسئلے کو حل کریں.
سب سے پہلے، دو 8 بٹ غیر دستخط شدہ عدد NumPy صفوں میں ایک ایک عنصر کے ساتھ ہر ایک کی وضاحت کی گئی ہے۔ پہلی صف کی قدر 201 ہے، جب کہ دوسری صف کی قدر 100 ہے۔ ہمارے اضافے کو تراش دیا جائے گا، اور اگر ہم cv2.add فنکشن استعمال کریں گے تو 255 کی قدر واپس آئے گی۔
NumPy، دوسری طرف، 'لپٹ جاتا ہے' اور تراشنے کی بجائے ماڈیولو ریاضی کرتا ہے۔ NumPy 255 کی قدر تک پہنچنے کے بعد صفر پر لپیٹ دیتا ہے اور پھر 100 قدموں تک پہنچنے تک دوبارہ گنتی شروع کر دیتا ہے۔ اس کی تصدیق آؤٹ پٹ کی پہلی لائن سے ہوتی ہے، جو نیچے دکھائی گئی ہے۔
ریاضی. pyارد گرد لپیٹنا: [ چار پانچ ]
اس کے بعد، دو اور NumPy اریوں کی وضاحت کی گئی ہے، ایک کی قدر 50 اور دوسری 100۔ ماڈیولو ریاضی اس کے بجائے، ماڈیولو کے طریقہ کار کو گھیر لیا جاتا ہے اور گھٹاؤ کے دوران 0 تک پہنچنے کے بعد 255 سے پیچھے کی طرف گننا شروع کر دیا جاتا ہے۔ ہم اسے درج ذیل آؤٹ پٹ سے دیکھ سکتے ہیں:
ریاضی. pyارد گرد لپیٹنا: [ 207 ]
ایک بار پھر، ہمارا ٹرمینل آؤٹ پٹ کلپنگ اور ریپنگ کے درمیان فرق کو ظاہر کرتا ہے:
عددی ریاضی کو انجام دیتے وقت اپنے مطلوبہ نتائج کو ذہن میں رکھنا بہت ضروری ہے۔ کیا آپ چاہتے ہیں کہ رینج [0, 255] سے باہر کی کوئی قدر تراشی جائے؟ اس کے بعد OpenCV کی بلٹ ان امیج ریاضی کی تکنیک استعمال کریں۔
کیا آپ چاہتے ہیں کہ اگر اقدار [0, 255] اور ماڈیولس ریاضی کی کارروائیوں کی حد سے باہر ہیں تو ان کو لپیٹ دیا جائے؟ اس کے بعد NumPy صفوں کو حسب معمول شامل اور گھٹا دیا جاتا ہے۔
لائن 48 ایک جہتی NumPy سرنی کی وضاحت کرتا ہے جس کی جہت ہماری تصویر ہے۔ ایک بار پھر، ہم اس بات کو یقینی بناتے ہیں کہ ہمارے ڈیٹا کی قسم 8 بٹ غیر دستخط شدہ عدد ہے۔ ہم اپنے میٹرکس کو صرف 101 سے ضرب دیتے ہیں تاکہ اسے 1 کی بجائے 101 کی قدروں سے پُر کیا جاسکے۔ آخر میں، ہم اپنے 100s کے میٹرکس کو اصل تصویر میں شامل کرنے کے لیے cv2.add فنکشن کا استعمال کرتے ہیں۔ یہ ہر پکسل کی شدت کو 101 تک بڑھاتا ہے جبکہ یہ بھی یقینی بناتا ہے کہ کوئی بھی قدر جو 255 سے تجاوز کرنے کی کوشش کرتی ہے اسے حد [0, 255] میں تراش لیا جاتا ہے۔
مشاہدہ کریں کہ تصویر کس طرح نمایاں طور پر روشن ہے اور اصل سے زیادہ 'دھلائی ہوئی' دکھائی دیتی ہے۔ اس کی وجہ یہ ہے کہ ہم پکسلز کو ان کی پکسل کی شدت کو 101 تک بڑھا کر روشن رنگوں کی طرف لے جا رہے ہیں۔
تصویر کے ہر پکسل کی شدت سے 60 کو کم کرنے کے لیے، ہم سب سے پہلے لائن 54 پر ایک دوسری NumPy سرنی قائم کرتے ہیں جو 60s سے بھری ہوئی ہے۔
اس گھٹاؤ کے نتائج کو درج ذیل تصویر میں دکھایا گیا ہے:
ہمارے آس پاس کی اشیاء پہلے کی نسبت نمایاں طور پر گہری نظر آتی ہیں۔ اس کی وجہ یہ ہے کہ ہر پکسل سے 60 کو گھٹا کر، ہم RGB کلر اسپیس میں پکسلز کو گہرے علاقوں میں منتقل کر رہے ہیں۔
4. تصویر پلٹنا
گردش کی طرح، کسی تصویر کو اس کے x یا y-axis پر پلٹنا OpenCV کی طرف سے پیش کردہ ایک اور آپشن ہے۔ یہاں تک کہ اگر فلپنگ آپریشنز کو کثرت سے استعمال نہیں کیا جاتا ہے، تو ان کو جاننا مختلف وجوہات کی بناء پر ناقابل یقین حد تک فائدہ مند ہے جو شاید آپ کو فوری طور پر نظر نہ آئے۔
ہم ایک چھوٹی اسٹارٹ اپ کمپنی کے لیے مشین لرننگ کلاسیفائر تیار کر رہے ہیں جو تصاویر میں چہروں کی شناخت کرنا چاہتی ہے۔ ہمارے سسٹم کے لیے 'سیکھنے' کے لیے کہ چہرہ کیا ہے، ہمیں نمونے والے چہروں کے ساتھ کسی قسم کے ڈیٹاسیٹ کی ضرورت ہوگی۔ بدقسمتی سے، کمپنی نے ہمیں صرف 40 چہروں کا ایک چھوٹا ڈیٹا سیٹ دیا ہے، اور ہم مزید معلومات اکٹھا کرنے سے قاصر ہیں۔
تو پھر ہم کیا کریں؟
چونکہ ایک چہرہ ایک چہرہ ہی رہتا ہے چاہے وہ آئینہ دار ہو یا نہ ہو، اس لیے ہم چہرے کی ہر تصویر کو افقی طور پر پلٹ سکتے ہیں اور عکس والے ورژن کو اضافی تربیتی ڈیٹا کے طور پر استعمال کر سکتے ہیں۔
یہ مثال احمقانہ اور مصنوعی لگ سکتی ہے، لیکن ایسا نہیں ہے۔ پلٹنا ایک دانستہ حکمت عملی ہے جسے تربیت کے مرحلے کے دوران مزید ڈیٹا تیار کرنے کے لیے مضبوط گہری سیکھنے والے الگورتھم استعمال کرتے ہیں۔
پچھلے سے یہ واضح ہے کہ امیج پروسیسنگ کے طریقے جو آپ اس ماڈیول میں سیکھتے ہیں وہ بڑے کمپیوٹر ویژن سسٹم کی بنیاد کے طور پر کام کرتے ہیں۔
مقاصد:
کا استعمال کرتے ہوئے cv2.flip فنکشن، آپ اس سیشن میں ایک تصویر کو افقی اور عمودی طور پر پلٹانے کا طریقہ سیکھیں گے۔
پلٹنا اگلی تصویری ہیرا پھیری ہے جس کا ہم مطالعہ کریں گے۔ تصویر کے x اور y-axes کو پلٹایا جا سکتا ہے یا دونوں کو بھی۔ اس سے پہلے کہ ہم کوڈنگ میں غوطہ لگائیں، بہتر ہے کہ پہلے کسی تصویر کے پلٹ جانے کے نتائج کو دیکھیں۔ مندرجہ ذیل تصویر میں ایک تصویر دیکھیں جو افقی طور پر پلٹ گئی ہے:
نوٹ کریں کہ ہماری اصل تصویر بائیں طرف کیسے ہے اور تصویر کو کیسے دائیں طرف افقی طور پر عکس بنایا گیا ہے۔
آئیے ایک نئی فائل بنا کر شروع کریں۔ flipping.py .
آپ نے تصویر پلٹنے کی ایک مثال دیکھی ہے، تو آئیے کوڈ کا جائزہ لیں:
# python flipping.py --image quirrel.jpg# مطلوبہ پیکجز درآمد کرنا
درآمد argparse
درآمد cv2
# دلیل پارسر کی آبجیکٹ بنانا اور دلیل کو پارس کرنا
apObj = argparse. آرگومنٹ پارسر ( )
apObj add_argument ( '-میں' ، '--تصویر' ، مطلوبہ = سچ ہے۔ ، مدد = 'تصویر کا راستہ' )
دلیل = جس کا ( apObj parse_args ( ) )
تصویر = cv2. imread ( دلیل [ 'تصویر' ] )
cv2. imshow ( 'اصل' ، تصویر )
# تصویر کو افقی طور پر پلٹائیں۔
تصویر پلٹ گئی۔ = cv2. پلٹائیں ( تصویر ، 1 )
cv2. imshow ( 'تصویر کو افقی طور پر پلٹایا گیا' ، تصویر پلٹ گئی۔ )
# تصویر کو عمودی طور پر پلٹائیں۔
تصویر پلٹ گئی۔ = cv2. پلٹائیں ( تصویر ، 0 )
cv2. imshow ( 'تصویر عمودی طور پر پلٹائی گئی' ، تصویر پلٹ گئی۔ )
# تصویر دونوں محوروں کے ساتھ پلٹیں۔
تصویر پلٹ گئی۔ = cv2. پلٹائیں ( تصویر ، - 1 )
cv2. imshow ( 'افقی اور عمودی طور پر پلٹا' ، تصویر پلٹ گئی۔ )
cv2. waitKey ( 0 )
ہم اپنے پیکجز کو درآمد کرنے، اپنے ان پٹس کو پارس کرنے، اور اپنی تصویر کو ڈسک سے لوڈ کرنے کے لیے جو اقدامات کرتے ہیں وہ l میں سنبھالے جاتے ہیں۔ انیس 1 سے 12 .
cv2.flip فنکشن کو آن کرکے لائن 15 ، تصویر کو افقی طور پر پلٹنا آسان ہے۔ جس تصویر کو ہم پلٹنا چاہتے ہیں اور ایک مخصوص کوڈ یا جھنڈا جو اس بات کی وضاحت کرتا ہے کہ تصویر کو کیسے پلٹایا جائے cv2.flip طریقہ کے لیے درکار دو دلائل ہیں۔
1 کی فلپ کوڈ ویلیو کا مطلب ہے کہ ہم تصویر کو y-axis کے گرد گھمائیں گے تاکہ اسے افقی طور پر پلٹایا جا سکے۔ لائن 15 )۔ اگر ہم 0 کا فلپ کوڈ بتاتے ہیں، تو ہم تصویر کو x-axis ( لائن 19 )۔ ایک منفی فلپ کوڈ ( لائن 23 ) تصویر کو دونوں محوروں پر گھماتا ہے۔
اس موضوع میں سب سے آسان مثالوں میں سے ایک تصویر کو پلٹنا ہے، جو بنیادی ہے۔
اگلا، ہم تصویروں کو تراشنے پر بات کریں گے اور تصویر کے مخصوص حصوں کو نکالنے کے لیے NumPy اری سلائسز کا استعمال کریں گے۔
5. تصویر کی کٹائی
کٹائی، جیسا کہ نام سے ظاہر ہے، دلچسپی کے علاقے (یا محض ROI) کو منتخب کرنے اور ہٹانے کا عمل ہے، جو تصویر کا وہ علاقہ ہے جس میں ہماری دلچسپی ہے۔
چہرے کا پتہ لگانے کی ایپلی کیشن کے لیے چہرے کو تصویر سے کاٹا جانا ہوگا۔ مزید برآں، اگر ہم تصویروں میں کتوں کو تلاش کرنے کے لیے ازگر کا اسکرپٹ بنا رہے تھے، تو جب ہم اسے تلاش کرتے ہیں تو ہم اسے تصویر سے باہر نکالنا چاہیں گے۔
مقاصد: ہمارا بنیادی مقصد NumPy اری سلائسنگ کو کسی تصویر سے کراپ ایریاز کے ساتھ آسانی سے واقف ہونا ہے۔
فصل کاٹنا : جب ہم کسی تصویر کو تراشتے ہیں تو ہمارا مقصد ان بیرونی عناصر کو ختم کرنا ہوتا ہے جو ہماری دلچسپی نہیں رکھتے۔ ہمارے ROI کو منتخب کرنے کے عمل کو اکثر ہماری دلچسپی کے علاقے کا انتخاب کہا جاتا ہے۔
نامی ایک نئی فائل بنائیں crop.py ، اسے کھولیں، اور درج ذیل کوڈ شامل کریں:
# python crop.py# مطلوبہ پیکجز درآمد کرنا
درآمد cv2
# تصویر لوڈ اور اسکرین پر ڈسپلے
تصویر = cv2. imread ( 'squirrel.jpg' )
پرنٹ کریں ( تصویر. شکل )
cv2. imshow ( 'اصل' ، تصویر )
# NumPy سرنی سلائسس کو تیزی سے تصویر تراشنے کے لیے استعمال کیا جاتا ہے۔
# ہم تصویر سے گلہری کے چہرے کو تراشنے جا رہے ہیں۔
گلہری = تصویر [ 35 : 90 ، 35 : 100 ]
cv2. imshow ( 'گلہری چہرہ' ، گلہری )
cv2. waitKey ( 0 )
# اور اب، یہاں ہم پورے جسم کو کاٹنے جا رہے ہیں
#گلہری کا
گلہری = تصویر [ 35 : 148 ، 23 : 143 ]
cv2. imshow ( 'گلہری جسم' ، گلہری )
cv2. waitKey ( 0 )
ہم Python اور OpenCV میں ایک تصویر کا استعمال کرتے ہوئے کراپنگ دکھائیں گے جسے ہم ڈسک سے لوڈ کرتے ہیں۔ لائنیں 5 اور 6 .
اصل تصویر جسے ہم تراشنے جا رہے ہیں۔
صرف بنیادی تراکیب کا استعمال کرتے ہوئے، ہمارا مقصد گلہری کے چہرے اور گلہری کے جسم کو آس پاس کے علاقے سے الگ کرنا ہے۔
ہم تصویر کے بارے میں اپنی پیشگی معلومات کا استعمال کریں گے اور دستی طور پر NumPy سرنی کے سلائسس فراہم کریں گے جہاں جسم اور چہرہ موجود ہے۔ عام حالات میں، ہم تصویر میں چہرے اور جسم کو پہچاننے کے لیے عام طور پر مشین لرننگ اور کمپیوٹر ویژن الگورتھم استعمال کریں گے۔ لیکن آئیے وقتی طور پر چیزوں کو سیدھا رکھیں اور کسی بھی پتہ لگانے والے ماڈل کو استعمال کرنے سے گریز کریں۔
ہم تصویر میں موجود چہرے کو کوڈ کی صرف ایک لائن سے پہچان سکتے ہیں۔ لائن 13 ، تصویر کے مستطیل حصے کو نکالنے کے لیے، (35، 35) سے شروع ہو کر، ہم NumPy سرنی سلائسس (90، 100) فراہم کرتے ہیں۔ یہ مبہم معلوم ہو سکتا ہے کہ ہم فصل کو اونچائی-پہلے اور چوڑائی-دوسرے ترتیب میں اشاریہ جات کے ساتھ کھلاتے ہیں، لیکن یہ بات ذہن میں رکھیں کہ OpenCV تصاویر کو NumPy arrays کے طور پر ذخیرہ کرتا ہے۔ نتیجے کے طور پر، ہمیں y-axis کے لیے x-axis سے پہلے قدریں فراہم کرنی چاہیے۔
ہماری کٹائی کو انجام دینے کے لیے NumPy کو درج ذیل چار اشاریہ جات کی ضرورت ہے۔
شروع کریں: شروع میں y کوآرڈینیٹ۔ اس مثال کے لیے، ہم y=35 سے شروع کرتے ہیں۔
اختتام y: اختتام پر y کوآرڈینیٹ۔ ہماری فصل رک جائے گی جب y = 90۔
شروع کریں x: سلائس کا آغاز x کوآرڈینیٹ۔ فصل x=35 پر شروع ہوتی ہے۔
اختتام x: سلائس کا اختتام ایکس محور کوآرڈینیٹ۔ x=100 پر، ہمارا سلائس ختم ہو گیا ہے۔
اسی طرح، ہم اصل تصویر سے خطوں (23، 35) اور (143، 148) کو تراشتے ہیں تاکہ تصویر سے مکمل باڈی نکالی جا سکے۔ لائن 19 .
آپ دیکھ سکتے ہیں کہ تصویر کو صرف جسم اور چہرے کی نمائش کے لیے کاٹا گیا ہے۔
6. تصویر کا سائز تبدیل کرنا
کسی تصویر کی چوڑائی اور اونچائی کو بڑھانے یا کم کرنے کے عمل کو اسکیلنگ یا صرف سائز تبدیل کرنے کے نام سے جانا جاتا ہے۔ پہلو کا تناسب، جو کسی تصویر کی چوڑائی اور اس کی اونچائی کا تناسب ہے، تصویر کا سائز تبدیل کرتے وقت غور کیا جانا چاہیے۔ پہلو کے تناسب کو نظر انداز کرنے کے نتیجے میں ایسی تصاویر پیدا ہو سکتی ہیں جن کو سکیل کیا گیا ہے جو کمپریسڈ اور مسخ شدہ دکھائی دیتی ہیں:
ہماری ابتدائی تصویر بائیں طرف ہے۔ دائیں طرف، آپ کو دو امیجز نظر آئیں گی جو اسپیکٹ ریشو کو برقرار رکھے بغیر اسکیل کی گئی ہیں، تصویر کی چوڑائی کے تناسب کو اس کی اونچائی تک مسخ کرتی ہیں۔ اپنی تصاویر کا سائز تبدیل کرتے وقت، آپ کو عام طور پر پہلو کے تناسب پر غور کرنا چاہیے۔
ہمارے سائز تبدیل کرنے والے الگورتھم کے ذریعہ استعمال کی جانے والی انٹرپولیشن تکنیک کو تصویر کے سائز کو بڑھانے یا کم کرنے کے لئے پکسلز کے ان محلوں کو استعمال کرنے کے لئے انٹرپولیشن فنکشن کے مقصد پر بھی غور کرنا چاہئے۔
عام طور پر، تصویر کے سائز کو سکڑنا کہیں زیادہ مؤثر ہے۔ اس کی وجہ یہ ہے کہ تصویر سے پکسلز کو ہٹانا تمام انٹرپولیشن فنکشن کو کرنے کی ضرورت ہے۔ دوسری طرف، انٹرپولیشن کے طریقہ کار کو ان پکسلز کے درمیان 'خالی جگہوں کو پُر کرنے' کی ضرورت ہوگی جو پہلے موجود نہیں تھے اگر تصویر کا سائز بڑھایا جائے۔
ہماری اصل تصویر بائیں طرف ہے۔ تصویر کو مرکز میں اس کے اصل سائز سے آدھا کر دیا گیا ہے، لیکن اس کے علاوہ، تصویر کے 'معیار' میں کوئی کمی نہیں ہوئی ہے۔ بہر حال، تصویر کے سائز کو دائیں جانب کافی حد تک بڑھا دیا گیا ہے۔ یہ اب 'اڑا ہوا' اور 'پکسلیٹڈ' دکھائی دیتا ہے۔
جیسا کہ میں نے پہلے کہا، آپ عام طور پر کسی تصویر کا سائز بڑھانے کے بجائے اسے کم کرنا چاہیں گے۔ تصویر کے سائز کو کم کر کے، ہم کم پکسلز کا تجزیہ کرتے ہیں اور ہمیں کم 'شور' سے نمٹنا پڑتا ہے، جو تصویر کی پروسیسنگ الگورتھم کو تیز اور زیادہ درست بناتا ہے۔
ترجمہ اور گردش دو تصویری تبدیلیاں ہیں جن پر ابھی تک توجہ دی گئی ہے۔ اب ہم جائزہ لیں گے کہ تصویر کا سائز کیسے تبدیل کیا جائے۔
حیرت کی بات نہیں، ہم cv2.resize طریقہ استعمال کرکے اپنی تصاویر کا سائز تبدیل کریں گے۔ جیسا کہ میں نے پہلے اشارہ کیا، ہمیں اس طریقہ کو استعمال کرتے وقت تصویر کے پہلو تناسب پر غور کرنا چاہیے۔ لیکن اس سے پہلے کہ ہم تفصیلات میں بہت گہرائی میں داخل ہوں، مجھے آپ کو ایک مثال دینے کی اجازت دیں:
# python resize.py --image squirrel.jpg# مطلوبہ پیکجز درآمد کرنا
درآمد argparse
درآمد cv2
# دلیل پارسر کی آبجیکٹ بنانا اور دلیل کو پارس کرنا
apObj = argparse. آرگومنٹ پارسر ( )
apObj add_argument ( '-k' ، '--تصویر' ، مطلوبہ = سچ ہے۔ ، مدد = 'تصویر کا راستہ' )
دلائل = جس کا ( apObj parse_args ( ) )
# تصویر لوڈ کریں اور اسکرین پر ڈسپلے کریں۔
تصویر = cv2. imread ( دلائل [ 'تصویر' ] )
cv2. imshow ( 'اصل' ، تصویر )
# تصویر کو ترچھا ظاہر ہونے سے روکنے کے لیے، پہلو کا تناسب
# غور کرنا یا درست کرنا ضروری ہے؛ لہذا، ہم کیا سمجھتے ہیں
# نئی تصویر کا موجودہ تصویر کا تناسب۔
# آئیے اپنی نئی تصویر کی چوڑائی 160 پکسلز بنائیں۔
پہلو = 160.0 / تصویر. شکل [ 1 ]
طول و عرض = ( 160 ، int ( تصویر. شکل [ 0 ] * پہلو ) )
# یہ لائن اصل سائز تبدیل کرنے کے عمل کو دکھائے گی۔
تصویر کا سائز تبدیل کریں۔ = cv2. سائز تبدیل کریں ( تصویر ، طول و عرض ، انٹرپولیشن = cv2. INTER_AREA )
cv2. imshow ( 'تصویر کی چوڑائی کا سائز تبدیل کریں' ، تصویر کا سائز تبدیل کریں۔ )
# اگر ہم تصویر کی اونچائی کو تبدیل کرنا چاہتے ہیں تو کیا ہوگا؟ - کا استعمال کرتے ہوئے
# ایک ہی اصول، ہم پہلو تناسب کی بنیاد پر حساب کر سکتے ہیں۔
# چوڑائی کے بجائے اونچائی پر۔ آئیے پیمانہ بناتے ہیں۔
# تصویر کی اونچائی 70 پکسلز۔
پہلو = 70.0 / تصویر. شکل [ 0 ]
طول و عرض = ( int ( تصویر. شکل [ 1 ] * پہلو ) ، 70 )
# سائز تبدیل کریں۔
تصویر کا سائز تبدیل کریں۔ = cv2. سائز تبدیل کریں ( تصویر ، طول و عرض ، انٹرپولیشن = cv2. INTER_AREA )
cv2. imshow ( 'تصویر کی اونچائی کا سائز تبدیل کیا گیا' ، تصویر کا سائز تبدیل کریں۔ )
cv2. waitKey ( 0 )
لائنیں 1-14 ، ہمارے پیکجز کو درآمد کرنے اور اپنے آرگومنٹ پارسر کو ترتیب دینے کے بعد، ہم اپنی تصویر کو لوڈ اور ڈسپلے کریں گے۔
لائنز 20 اور 21: متعلقہ کوڈنگ ان لائنوں میں شروع ہوتی ہے۔ . تصویر کا سائز تبدیل کرتے وقت اس کے اسپیکٹ ریشو کو دھیان میں رکھنا چاہیے۔ تصویر کی چوڑائی اور اونچائی کے درمیان تناسب کو پہلو کا تناسب کہا جاتا ہے۔
اونچائی چوڑائی پہلو تناسب ہے.
اگر ہم پہلو کے تناسب کو مدنظر نہیں رکھتے ہیں، تو ہمارے سائز تبدیل کرنے کے نتائج مسخ ہو جائیں گے۔
پر لائن 20 ، دوبارہ سائز کے تناسب کا حساب کتاب کیا جاتا ہے۔ ہم کوڈ کی اس لائن میں اپنی نئی تصویر کی چوڑائی 160 پکسلز فراہم کرتے ہیں۔ ہم اپنے تناسب (اسپیکٹرٹیو) کو نئی چوڑائی (160 پکسلز) پرانی چوڑائی سے تقسیم کرتے ہیں، جس تک ہم تصویر کا استعمال کرتے ہوئے رسائی حاصل کرتے ہیں، نئی اونچائی اور پرانی اونچائی کے تناسب کا حساب لگانے کے لیے۔ شکل[1]۔
تصویر کی نئی جہتیں آن ہیں۔ لائن 21 اب حساب لگایا جا سکتا ہے کہ ہمیں اپنا تناسب معلوم ہے۔ ایک بار پھر، نئی تصویر کی چوڑائی 160 پکسلز ہوگی۔ پرانی اونچائی کو ہمارے تناسب سے ضرب دینے اور نتیجہ کو عدد میں تبدیل کرنے کے بعد، اونچائی کا حساب لگایا جاتا ہے۔ ہم اس آپریشن کو انجام دے کر تصویر کے اصل پہلو تناسب کو برقرار رکھ سکتے ہیں۔
لائن 24 وہ جگہ ہے جہاں تصویر کا واقعی سائز تبدیل کیا گیا ہے۔ ہم جس تصویر کا سائز تبدیل کرنا چاہتے ہیں وہ پہلی دلیل ہے، اور دوسری وہ ڈائمینشنز ہیں جو ہم نے نئی تصویر کے لیے گنی ہیں۔ ہمارا انٹرپولیشن طریقہ، جو کہ اصل تصویر کا سائز تبدیل کرنے کا الگورتھم ہے، آخری پیرامیٹر ہے۔
آخر میں، پر لائن 25 ، ہم اپنی اسکیل کردہ تصویر دکھاتے ہیں۔
ہم اپنے تناسب (اسپیکٹرٹیو) کو آن کی نئی وضاحت کرتے ہیں۔ لائن 31 . ہماری نئی تصویر کی اونچائی 70 پکسلز ہوگی۔ نئی اونچائی سے اصل اونچائی کا تناسب حاصل کرنے کے لیے ہم 70 کو اصل اونچائی سے تقسیم کرتے ہیں۔
اگلا، ہم نئی تصویر کے طول و عرض قائم کرتے ہیں۔ نئی تصویر کی اونچائی 70 پکسلز ہوگی، جو پہلے ہی معلوم ہے۔ ہم نئی چوڑائی پیدا کرنے کے لیے پرانی چوڑائی کو تناسب سے ضرب دے کر تصویر کے اصل پہلو تناسب کو ایک بار پھر برقرار رکھ سکتے ہیں۔
اس کے بعد تصویر کا اصل سائز تبدیل کیا جاتا ہے۔ لائن 35 ، اور اس پر ظاہر ہوتا ہے۔ لائن 36۔
یہاں، ہم دیکھ سکتے ہیں کہ ہم نے پہلو کے تناسب کو برقرار رکھتے ہوئے اپنی اصل تصویر کی چوڑائی اور اونچائی کو کم کیا ہے۔ اگر پہلو کا تناسب برقرار نہ رکھا گیا تو ہماری تصویر مسخ شدہ دکھائی دے گی۔
نتیجہ
اس بلاگ میں، ہم نے تصویری پروسیسنگ کے بنیادی مختلف تصورات کا مطالعہ کیا ہے۔ ہم نے OpenCV پیکیج کی مدد سے تصویری ترجمہ دیکھا ہے۔ ہم نے تصویر کو اوپر، نیچے، دائیں اور بائیں منتقل کرنے کے طریقے دیکھے ہیں۔ جب ہم تربیتی ڈیٹاسیٹ کے طور پر دینے کے لیے ملتی جلتی تصاویر کا ڈیٹا سیٹ بناتے ہیں تو یہ طریقے بہت کارآمد ہوتے ہیں، اس لیے مشین مختلف تصاویر دیکھے گی چاہے وہ ایک جیسی ہوں۔ اس مضمون نے آپ کو یہ بھی سکھایا ہے کہ گردش میٹرکس کا استعمال کرتے ہوئے کارٹیشین اسپیس میں کسی بھی نقطہ کے گرد تصویر کو کیسے گھمایا جائے۔ پھر آپ نے دریافت کیا کہ OpenCV کس طرح اس میٹرکس کا استعمال کرتے ہوئے تصاویر کو گھماتا ہے اور گھومتی ہوئی تصاویر کی کچھ مثالیں دیکھیں۔
اس حصے میں جمع اور گھٹاؤ کے دو بنیادی (لیکن اہم) تصویری ریاضی کی کارروائیوں کا جائزہ لیا گیا۔ جیسا کہ آپ دیکھ سکتے ہیں، بنیادی میٹرکس کو شامل کرنا اور گھٹانا تمام تصویری ریاضی کے عمل میں شامل ہے۔
مزید برآں، ہم نے تصویری ریاضی کی خصوصیات کی چھان بین کے لیے OpenCV اور NumPy کا استعمال کیا۔ ان پابندیوں کو ذہن میں رکھنا ضروری ہے، ورنہ آپ کو اپنی تصاویر پر ریاضی کی کارروائیوں کو انجام دیتے وقت غیر متوقع نتائج حاصل ہونے کا خطرہ ہے۔
یہ یاد رکھنا ضروری ہے کہ اگرچہ NumPy ایک ماڈیولس آپریشن کرتا ہے اور 'لپٹ جاتا ہے'، لیکن رینج کے اندر فٹ ہونے کے لیے OpenCV کا اضافہ اور گھٹاؤ قدروں کو رینج [0, 255] سے باہر کرتا ہے۔ اپنے کمپیوٹر ویژن ایپلی کیشنز کو تیار کرتے وقت، اسے یاد رکھنے سے آپ کو مشکل کیڑوں کا شکار کرنے سے بچنے میں مدد ملے گی۔
امیج فلپ کرنا بلاشبہ ان آسان خیالات میں سے ایک ہے جسے ہم اس کورس میں دریافت کریں گے۔ فلپنگ کو اکثر مشین لرننگ میں استعمال کیا جاتا ہے تاکہ مزید تربیتی ڈیٹا کے نمونے تیار کیے جا سکیں، جس کے نتیجے میں زیادہ طاقتور اور قابل اعتماد امیج کلاسیفائر ہوتے ہیں۔
ہم نے یہ بھی سیکھا کہ تصویر کا سائز تبدیل کرنے کے لیے اوپن سی وی کا استعمال کیسے کریں۔ اس کا سائز تبدیل کرتے وقت آپ جس انٹرپولیشن طریقہ کو استعمال کر رہے ہیں اور اپنی اصل تصویر کے پہلوی تناسب دونوں پر غور کرنا بہت ضروری ہے تاکہ نتیجہ مسخ نہ ہو۔
آخر میں، یہ یاد رکھنا بہت ضروری ہے کہ اگر تصویر کی کوالٹی ایک مسئلہ ہے، تو یہ ہمیشہ بہتر ہوتا ہے کہ بڑی سے چھوٹی تصویر پر سوئچ کریں۔ زیادہ تر معاملات میں، تصویر کو بڑا کرنے سے نمونے بنتے ہیں اور اس کے معیار کو گرا دیتے ہیں۔