Ali Haidar Ahmad

الحل كالتالي:
from matplotlib.ticker import PercentFormatter import matplotlib.pyplot as plt import numpy as np from matplotlib import colors # إنشاء بيانات عشوائية N_points = 98 n_bins = 15 # إنشاء توزيع يمثل بيانات أول هيستوغرام x1 = np.random.randn(N_points) # إنشاء توزيع يمثل بيانات الهستوغرام لثاني x2 = np.random.randn(N_points) # تعريف الحاوية fig, axs = plt.subplots(1, 1, figsize =(10, 7), tight_layout = True) # ticks حذف العلامات axs.xaxis.set_ticks_position('none') axs.yaxis.set_ticks_position('none') # إضافة شبكة إلى الخلفية axs.grid(b = True, color ='y', linestyle ='-.', linewidth = 0.5, alpha = 0.6) # plot حذف خطوط حاويةال for s in ['top', 'bottom', 'left', 'right']: axs.spines[s].set_visible(False) #وضع مسافة بين التسميات وبين المحاور axs.xaxis.set_tick_params(pad = 4) axs.yaxis.set_tick_params(pad = 8) # إنشاء الهستوغرامين معاً axs.hist([x1,x2], bins = n_bins,label=[x1,x2],color=["red","black"]) # تسمية للمحاور plt.xlabel("X-axis") plt.ylabel("y-axis") legend = ['File1','File2'] plt.legend(legend) # عنوان plt.title('Hsoub') # عرض plt.show() الخرج:

حيث قمنا بتمريرهم إلى نفس دالة hist كما فعلت، حيث تقوم الدالة برسم الأعمدة التي تحدد تكرار نفس القيم بجانب بعضها بدل أن تقوم بجعلها فوق بعضها من خلال استخدام دالتين لرسم كل هيستوغرام وبالتالي يصبح المخطط غير مقروء أو صعب القراءة كما في الكود التالي (بنهاية الأمر اختر ماتراه مناسباً لك):
from matplotlib.ticker import PercentFormatter import matplotlib.pyplot as plt import numpy as np from matplotlib import colors # إنشاء بيانات عشوائية N_points = 98 n_bins = 15 # إنشاء توزيع يمثل بيانات أول هيستوغرام x1 = np.random.randn(N_points) # إنشاء توزيع يمثل بيانات الهستوغرام لثاني x2 = np.random.randn(N_points) # تعريف الحاوية fig, axs = plt.subplots(1, 1, figsize =(10, 7), tight_layout = True) # ticks حذف العلامات axs.xaxis.set_ticks_position('none') axs.yaxis.set_ticks_position('none') # إضافة شبكة إلى الخلفية axs.grid(b = True, color ='y', linestyle ='-.', linewidth = 0.5, alpha = 0.6) # plot حذف خطوط حاويةال for s in ['top', 'bottom', 'left', 'right']: axs.spines[s].set_visible(False) #وضع مسافة بين التسميات وبين المحاور axs.xaxis.set_tick_params(pad = 4) axs.yaxis.set_tick_params(pad = 8) # إنشاء الهستوغرام الأول axs.hist(x1, bins = n_bins,alpha=0.8) # إنشاء الهستوغرام الثاني axs.hist(x2, bins = n_bins,color="red",alpha=0.7) # تسمية للمحاور plt.xlabel("X-axis") plt.ylabel("y-axis") legend = ['File1','File2'] plt.legend(legend) # عنوان plt.title('Hsoub') # عرض plt.show() الخرج:

يمكنك استخدام الدالة putText:
cv2.putText(image, text, org, font, fontScale, color, thickness, lineType, bottomLeftOrigin) الوسيط الأول هو الصورة المطلوب وضع النص عليها، أما الوسيط الثاني فهو النص المطلوب وضعه، أما الوسيط الثاني فهي إحداثيات الركن الأيسر السفلي من السلسلة النصية في الصورة. يتم تمثيل الإحداثيات على شكل مجموعات من قيمتين، أي (قيمة إحداثي x، قيمة إحداثي y). أما font فيشير إلى نوع الخط. بعض أنواع الخطوط: FONT_HERSHEY_SIMPLEX, FONT_HERSHEY_PLAIN. أما الوسيط fontScale فهو عامل مقياس الخط الذي يتم ضربه في الحجم الأساسي الخاص بالخط. أما الوسيط color فهو يمثل لونها. أما الوسيط thickness فيمثل سماكة الخط بالبكسل. أما lineType فهذه معلمة اختيارية تعطي نوع الخط الذي سيتم استخدامه. أما آخر وسيط فهو وسيطة اختيارية. عندما تفعله True، يكون أصل بيانات الصورة في الزاوية اليسرى السفلية. خلاف ذلك ، يكون في الزاوية العلوية اليسرى. مثال:
import cv2 # قراءة الصورة image = cv2.imread(r'C:\Users\Windows.10\Desktop\All\test5 openeye.jpg') # اسم النافذة التي يتم عرض الصورة فيها window_name = 'Image' # الخط font = cv2.FONT_HERSHEY_SIMPLEX # الإحداثيات org = (100, 50) # fontScale fontScale = 1 # red color in BGR color = (0, 0, 255) # السماكة thickness = 2 # استخدام cv2.putText() image = cv2.putText(image, 'OpenCV', org, font, fontScale, color, thickness, cv2.LINE_AA) # عرض cv2.imshow(window_name, image) cv2.waitKey(0) cv2.destroyAllWindows()

تقوم بإيقاف تنفيذ الكود لمدة زمنية معين تقدر بالميلي ثانية وتوضع بين قوسين بالشكل(). أي في حال قمت بكتابة:
import cv2 as cv I=cv.imread("rose.jpg") cv.imshow(“imag”,I) cv2.waitKey(1000) # statment1 # statment2 . . . # statmentn فهذا يعني أن الصورة سيتم عرضها في نافذة منبثقة وسيتوقف تنفيذ باقي تعليمات الكود لمدة 1000 ميلي ثانية، وبعد انقضاء المدة يستكمل بايثون في تنفيذ باقي التعليمات (لكن الصورة تبقى معروضة في النافذة المنبثقة ولاتحاول إغلاقها لأنك إن قمت بذلك سوف ينهار البرنامج) ولجعلها تختفي لابد من إضافة التعليمة cv2.destroyAllWindows بعدها مباشرةً. أما في حال كانت القيمة الممررة أصغر أو تساوي 0 عندها سوف يتم عرض الصورة وبعد عرضها سوف يتم إيقاف تنفيذ الكود إلى ما لانهاية، ويتم استكمال تنفيذ الكود عند قيامك بالضغط على زر معين (وأيضاً هنا ستبقى الصورة في النافذة مالم تكن التعليمة التالية هي destroyAllWindows ). كما يجب أن تعلم أنه إذا لم تقم باستخدام التعليمة ()cv2.waitKey لن يتم إظهار الصورة.
وفي حالة أردت استخدامه مع الفيديو فأنصحك بالاطلاع على السؤال التالي:

يمكنك استخدام التابع rectangle الذي يقوم برسم مستطيل على الصورة عن طريق المتغيرات التالية:
cv2.rectangle(image, start_point, end_point, color, thickness) x1,y1 ------ | | | | | | --------x2,y2 الوسيط الأول هو الصورة التي تريد الرسم عليها، أما الثاني فهو نقطة بداية المستطيل حيث يمثل إحداثيات الزاوية العليا اليسارية من المستطيل، أما الوسيط الثالث فيمثل الزاويا السفلى اليمينية للصورة وبالتالي عن طريق تحديد هذين الإحداثيين يتم رسم المستطيل على الصورة. والوسيط الرابع هو لون حدود المستطيل. أما الوسيط الأخير فهو سماكة خط حدود المستطيل بالبكسل. على سبيل المثال لنفرض أن ال ROI لدي هي صورة الوجه، وبالتالي يكون:
import numpy as np import cv2 from matplotlib import pyplot as plt from google.colab.patches import cv2_imshow img = cv.imread('/content/٢٠٢٠٠٧٣١_١٦٢٨٠٥.jpg') # رسم مستطيل يحدد الوجه cv2.rectangle(img,(405,370),(320,275),(0,255,0),3) cv2_imshow(img) الخرج:

يمكنك القيام بذلك من خلال invert_xaxis كالتالي:
x = [1, 6, 9, 5,7] y = [3,8,4,15,9] plt.scatter(x,y) # عكس المحور plt.gca().invert_xaxis() plt.title('Matplotlib Reverse Example') plt.show() الخرج:

وبشكل مشابه بالنسبة للمحور العمودي يمكنك استخدام invert_yaxis:
plt.gca().invert_yaxis() أو من خلال set_xlim لضبط الحدود بالشكل الذي نريده كالتالي:
x = [1, 6, 9, 5,7] y = [3,8,4,15,9] plt.scatter(x,y) ax = plt.gca() ax.set_xlim(ax.get_xlim()[::-1]) plt.title('Matplotlib Reverse Example') plt.show() حيث نمرر لها get_xlim للحصول على الامتداد الحالي للمحور ثم نقوم بعكسه من خلال [::-1].
أما بالنسبة للمحور العمودي ففقط نبدل إلى set_ylim و get_ylim.

لتغيير حجمها يمكنك استخدام tick_params كالتالي:
import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 10, 1000) y = np.sin(x) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine', color="r",ls='solid') # x تغيير حجم الخط للمحور الأفقي ax.tick_params(axis='x', which='major', labelsize=20) plt.title('Matplotlib xticklabels Example') plt.show() والخرج:

حيث أن axis تمثل المحاور التي نريد تطبيق التغيرات عليها ويأخذ القيم {'x', 'y', 'both'}. أما which فكما نعلم قد يكون هناك ticks أساسية وثانوية فهنا من خلال هذا الوسيط أنت تحدد فيما إذا كنت تريد تطبيق التغيرات على العلامات الريسية أم الثانوية أم كلاهما {'major', 'minor', 'both'}. والأهم labelsize الذي يحدد الحجم.
أما بالنسبة لتدوير ال tick_params  فيمكنك استخدام plt.setp التي تمنحك التحكم الكامل بعملية التدوير وبالدرجة التي تريدها من خلال الوسيط rotation كالتالي:
import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 10, 1000) y = np.sin(x) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine', color="r",ls='solid') # x تغيير حجم الخط للمحور الأفقي ax.tick_params(axis='x', which='major', labelsize=20) # عملية التدوير plt.setp(ax.xaxis.get_majorticklabels(), rotation=270) # تدوير 270 درجة plt.title('Matplotlib xticklabels Example') plt.show() الخرج:

حيث نقوم بتمرير درجة التدوير التي نحتاجها مثلاً قمنا بتدويرها 270 درجة لجعلها عمودية، وأيضاً يجب أن نمرر ax.xaxis.get_majorticklabels كوسيط أول للدالة والتي تمثل كل ال ticklabels للمحور الأفقي.
أما إذا أردنا تطبيق ذلك على المحور y ففقط نبدل المحور الذي سيتم تطبيق التدوير عليه أي تصبح القيمة الممررة لأول وسيط في الدالة هي ax.yaxis.get_majorticklabels. أي:
import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 10, 1000) y = np.sin(x) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine', color="r",ls='solid') # x تغيير حجم الخط للمحور الأفقي ax.tick_params(axis='x', which='major', labelsize=20) # عملية التدوير plt.setp(ax.yaxis.get_majorticklabels(), rotation=270) # تدوير 270 درجة plt.title('Matplotlib xticklabels Example') plt.show() وأخيراً إذا كان لديك ticklabels  ثانوية نمرر للوسيط الأول القيمة ax.youraxix.get_minorticklabels. أي:
import matplotlib.pyplot as plt import numpy as np x = np.linspace(0, 10, 1000) y = np.sin(x) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine', color="r",ls='solid') # x تغيير حجم الخط للمحور الأفقي ax.tick_params(axis='x', which='major', labelsize=20) # عملية التدوير plt.setp(ax.yaxis.get_minorticklabels(), rotation=270) # تدوير 270 درجة plt.title('Matplotlib xticklabels Example') plt.show() وكذلك يمكنك تدويرها من خلال set_rotation كالتالي:
for tick in ax.get_xticklabels(): tick.set_rotation(270) كذلك بالنسبة للحجم:
for tick in ax.xaxis.get_major_ticks(): tick.label.set_fontsize(20)  

للقيام بذلك يمكنك استخدام الوسيط fontsize مع كل من هذه الدوال، أي يمكنك استخدام هذه الخاصية مع الدالة التي تحدد العنوان والدوال التي تحدد أسماء المحاور:
import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 10, 1000) fig = plt.figure() plt.plot(x, np.sin(x), '--b', label ='Sine') plt.plot(x, np.cos(x), c ='r', label ='Cosine') fig.suptitle('test title', fontsize=22) # تحديد حجم العنوان plt.xlabel('x-label', fontsize=15) # حجم تسمية المحور plt.ylabel('y-label', fontsize=15) # حجم تسمية المحور الثاني plt.show() الخرج:

كما يمكنك القيام بتحديد ذلك بشكل globally بالشكل التالي:
import matplotlib.pylab as pylab params = {'figure.figsize': (12, 6), # حجم الشكل 'axes.titlesize':30, # حجم عنوان الشكل 'axes.labelsize':20, # حجم اسم المحور الأفقي والعمودي 'ytick.labelsize': 16, # حجم علامات المحور العمودي 'xtick.labelsize':16} # .. الأفقي pylab.rcParams.update(params) import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 10, 1000) plt.plot(x, np.sin(x), '--b', label ='Sine') plt.plot(x, np.cos(x), c ='r', label ='Cosine') plt.title('test title') plt.xlabel('xlabel') plt.ylabel('ylabel') plt.show() الخرج:

للتحكم بذلك نستخدم الوسيطين loc  و bbox_to_anchor:
loc='best', bbox_to_anchor=(x, y) لذا بدايةً دعنا نتعرف على الوسيط loc  الذي يأخذ القيم التالية:
Location String 'best' 'upper right' 'upper left' 'lower left' 'lower right' 'right' 'center left' 'center right' 'lower center' 'upper center' 'center' فالقيمة "best" تعني أنه سيضعه في أفضل مكان ممكن تلقائياً وهي الحالة الافتراضية. أما  "upper right" تعني أنه سيقوم بوضعه في أعلى اليمين وهكذا... أما الوسيط bbox_to_anchor فهو يستخدم لتغيير موضعه بالنسبة ل loc بحيث أن x و y هما إحداثيات الصندوق مثلاً القيمة  (0.0, 0.0)  تعني أنك تريد وضعه خارجاً عند مبدأ الإحداثيات. انظر للأمثلة التالية:
مثال1:
import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 10, 1000) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine') ax.plot(x, np.cos(x), c ='r', label ='Cosine') ax.axis('equal') # هنا قمنا بتعريف صندوق لتوضيح البيانات #في أسفل اليمين legend سنضع ال leg = ax.legend(loc ="lower right"); الخرج:

مثال2: هنا سنضعه في الخارج على اليمين (أنت تتحكم بالإحداثيات-عن طريق التجريب-).
import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 10, 1000) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine') ax.plot(x, np.cos(x), c ='r', label ='Cosine') ax.axis('equal') # هنا قمنا بتعريف صندوق لتوضيح البيانات # في أسفل اليمين legend سنضع ال # وسنقوم أيضاً بوضعه في الخارج leg = ax.legend(loc ="lower right",bbox_to_anchor =(1.3, 0.0)) الخرج:

مثال3: سنضعه في الخارج عند مبدأ الإحداثيات:
import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 10, 1000) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine') ax.plot(x, np.cos(x), c ='r', label ='Cosine') ax.axis('equal') leg = ax.legend(bbox_to_anchor =(0.0, 0.0)) الخرج:

أما بالنسبة لحجم الخط فنستخدم الوسيط fontsize حيث نمرر له حجم الخط مثلاً 11 أو نوع الخط الذي تحتاجه من خلال الكلاس FontProperties أو مباشرةً من خلال ذكر اسمه كما يلي:
import numpy as np import matplotlib.pyplot as plt x = np.linspace(0, 10, 1000) fig, ax = plt.subplots() ax.plot(x, np.sin(x), '--b', label ='Sine') ax.plot(x, np.cos(x), c ='r', label ='Cosine') ax.axis('equal') # لتعديل الخط from matplotlib.font_manager import FontProperties # نقوم بتعريف الخط الذي نحتاجه fontP = FontProperties() fontP.set_size('xx-small') # مثلاً هنا تريد أن يكون الخط صغيراً جداً # fontsize اللآن نمرر كائن الخط إلى الوسيط # leg = ax.legend(bbox_to_anchor =(0.6, -0.2), fontsize=fontP) # أو نقوم بتمرير نوع الخط مباشرةً كالتالي # leg = ax.legend(bbox_to_anchor =(0.6, -0.2), fontsize='xx-small') # أو من خلال ذكر الحجم leg = ax.legend(bbox_to_anchor =(0.7, -0.2), fontsize=20) الخرج:

يمكنك معرفة أبعاد وحجم الصورة وأكبر قيمة فيها بالشكل التالي:
import cv2 as cv # قراءة الصورة mat = cv2.imread('/content/closedeye1.jpg') # أبعادها height, width, channel = mat.shape[:3] # عدد عناصرها size = mat.size print("Height= ",height) print("Width= ",width) print("Size= ",size) maxElement = np.amax(mat) print('Max element from Numpy Array : ', maxElement) # الخرج """ Height= 186 Width= 271 Size= 151218 Max element from Numpy Array : 255 """

كما تعلم فإن مرشحات الحدَ هدفها الأساسي هو العمل المعاكس لمرشحات التنعيم، حيث أن مرشحات التنعيم تقوم بعمل تشويش للصورة وأهم تطبيقاتها هي إزالة الضجيج أو تنعيم الصورة، أما مرشحات الحدَ، فهي بالعكس، حيث أنها تقوم بتوضيح الحواف. كما أنه كنصيحة مني فإنه في حالة كانت الصورة الخاصة بك تحوي بعض الضجيج فلابد من أن تقوم أولاً بتطبيق مرشح تنعيم على الصورة لإزالة الضجيج منها، فالضجيج هو حافة في نهاية الأمر وبالتالي تطبيق مرشح تعزيز (حدَ) سيؤدي إلى تعزيز الضجيج وهذا أمر غير مرغوب فيه.
هناك تقنيات عدة تقنيات لزيادة حدة الصورة وتعتمد كلها على تقنيات الحد sharpening Spatial Filters، وتعتمد على نوعين من المشتقات، مشتقات الدرجة الأولى مثل مرشح سوبل أو الثانية مثل مرشح لابلاسيان، ثم نستخدم المعادلة التالية -مثلاً في حالة استخدام لابلاسيان تكون:
g(x,y)=f(x,y)+c[∇2f(x,y)] g(x,y): الصورة المعززة f(x,y): الصورة الأصلية ∇2f(x,y): الصورة بعد تطبيق مرشح الحد(لابلاسيان) حيث أن قيمة المعامل c هي إما 1 أو -1 وتعتمد على الكيرنل التي استخدمتها في تطبيق لابلاسيان وتساوي إما 1 أو -1 بحيث:
laplacian1=np.array( [[0,1,0], [1,-4,1], [0,1,0]]) # تكون قيمة c=1- laplacian2=np.array( [[1,1,1], [1,-8,1], [1,1,1]]) # c=1- laplacian3=np.array([[0,-1,0], [-1,4,-1], [0,-1,0]]) # c=+1 laplacian4=np.array([[-1,-1,-1], [-1,+8,-1], [-1,-1,-1]]) # c=+1 في المثال التالي سنقوم بتطبيق الفكرة السابقة وهي أفضل طريقة لزيادة حدة الصورة بالاعتماد على مشتقات الدرجة الثانية (لابلاسيان) والمعادلة السابقة:
import cv2 as cv import matplotlib.pyplot as plt # قراءة الصورة image = cv2.imread('/content/closedeye1.jpg',1) # matplotlib هنا فقط سأقوم بتحويل فضاء الألوان لأنني سأقوم بعرض الصورة باستخدام image=cv2.cvtColor(image, cv2.COLOR_BGR2RGB) plt.imshow(image) # سنجرب فلاتر لابلاسيان المختلفة laplacian1=np.array([[0,1,0],[1,-4,1],[0,1,0]]) # c=-1 laplacian2=np.array([[1,1,1],[1,-8,1],[1,1,1]]) # c=-1 laplacian3=np.array([[0,-1,0],[-1,4,-1],[0,-1,0]]) # c=1 laplacian4=np.array([[-1,-1,-1],[-1,8,-1],[-1,-1,-1]]) # c=1 # تطبيق الفلاتر لنرى نتيجة كل واحد على الصورة image_laplacian1=cv.filter2D(src=image, kernel=laplacian1, ddepth=-1) image_laplacian2=cv.filter2D(src=image, kernel=laplacian2, ddepth=-1) image_laplacian3=cv.filter2D(src=image, kernel=laplacian3, ddepth=-1) image_laplacian4=cv.filter2D(src=image, kernel=laplacian4, ddepth=-1) # تعزيز الصور image_sharping_1=cv2.subtract(image,image_laplacian1) image_sharping_2=cv2.subtract(image,image_laplacian2) image_sharping_3=cv2.add(image,image_laplacian3) image_sharping_4=cv2.add(image,image_laplacian4) # عرض النتائج import matplotlib.pyplot as plt plt.figure(figsize=(15,30)) plt.subplot(521) plt.imshow(image) plt.title("original image") plt.subplot(522) plt.imshow(image_sharping_1) plt.title("sharpenend_image 1") plt.subplot(523) plt.imshow(image_sharping_2) plt.title("sharpenend_image 2") plt.subplot(524) plt.imshow(image_sharping_3) plt.title("sharpenend_image 3") plt.subplot(525) plt.imshow(image_sharping_4) plt.title("sharpenend_image 4") الخرج:

لرسم هيستوغرام يمكنك استخدام الدالة hist في Matplotlib:
matplotlib.pyplot.hist(x, bins=None, range=None, density=False, histtype='bar',align='mid', orientation='vertical', color=None, label=None, stacked=False, data=None, **kwargs) ولإنشاء هيستوغرام (مدرج تكراري)، فإن الخطوة الأولى هي إنشاء حاوية للنطاقات أو المجالات " bin of the ranges "، ثم توزيع النطاق الكامل للقيم في سلسلة من الفواصل الزمنية، وإحصاء القيم التي تقع في كل من الفواصل الزمنية. أي بمعنى أوضح مثلاً في حالة لديك صورة رمادية فإن السويات اللونية والتي تمثل المحور الأفقي تكون من 0 ل255 وتريد معرفة عدد مرات تكرار كل سوية لونية في الصورة (كم بكسل في الصورة يحمل هذه القيمة) ولسبب ما تريد أن تقسم هذا السويات إلى نطاقات (مجالات) مثلاً تريد تقسيمها إلى 64 مجال بحيث كل مجال يحوي 4 سويات لونية. وبالتالي نكون هنا قد حددنا الحاويات وتبقى لنا أن نقوم بإحصاء البكسلات التي تنتمي إلى كل حاوية من هذه الحاويات.
الآن بالعودة للوسطاء فإن أول وسيط يمثل المصفوفة التي نريد حساب هستوغرامها (قد تمثل صورة أو أياً كان)، والوسيط الثاني bins هو عدد صحيح يمثل عدد الحاويات، أما range فيحدد القيمة الدنيا والعليا لل bins. أما density   فهي قيمة منطقية، ويؤدي تفعيلها لرسم كثافة احتمالية وسيتم إرجاعها من الدالة، وهنا ستعرض كل حاوية العدد الأولي للحاوية مقسوماً على العدد الإجمالي للأعداد وعرض الحاوية:
(density = counts / (sum(counts) * np.diff(bins))) بحيث تتكامل المنطقة الموجودة أسفل المدرج التكراري مع 1:
(np.sum(density * np.diff(bins)) == 1) وإذا كان stacked مفعلاً أيضاً، فسيتم تسوية (normalized) مجموع الرسوم البيانية إلى 1.  أما الوسيط histtype فهو يحدد نوع الرسم البياني المراد رسمه {'bar', 'barstacked', 'step', 'stepfilled'} وافتراضياً يكون bar، وهو الرسم بياني التقليدي (أشرطة أو أعمدة). بحيث  يتم ترتيب الأشرطة جنباً إلى جنب.  والنوع الثاني barstacked وهو مدرج تكراري من نوع شريط bar حيث يتم تكديس العديد من البيانات فوق بعضها البعض.أما النوع step مخطط خطي غير معبأ بشكل افتراضي. وأخيراً stepfilled يولد مخطط خطي معبأ بشكل افتراضي.  أما الوسيط align فيحدد المحاذاة الأفقية لأشرطة الرسم البياني. "left": تتركز الأشرطة على حواف الحاوية اليسرى. "mid": تتمركز الأشرطة بين حواف الحاوية. "right": تتركز الأشرطة على حواف الحاوية اليمنى. أما orientation فقيمه هي {'vertical', 'horizontal'}، فإذا كان "أفقياً" ، فسيتم استخدام barh -أي bar لكن معكوس- للمخططات البيانية من النوع الشريطي وسيكون kwarg السفلي هو الحواف اليسرى. أما ال color فهو لتحديد اللون. وأخيراً ففي حالة التغعيل True فسيتم تكديس بيانات فوق بعضها البعض. أما في حال عدم التفعيل False فيتم ترتيب البيانات المتعددة جنباً إلى جنب إذا كان نوع هيست هو "bar" أو فوق بعضها البعض إذا كان النوع هو "step".
مثال 1: سنقوم بتوليد بيانات عشوائية ثم سنقوم بعرض هستوغرامها:
import matplotlib.pyplot as plt import numpy as np x = np.random.normal(170, 10, 250) plt.hist(x) plt.show() الخرج:

مثال2:
import matplotlib.pyplot as plt import numpy as np from matplotlib import colors from matplotlib.ticker import PercentFormatter # إنشاء بيانات عشوائية N_points = 984 n_bins = 15 # إنشاء توزيع x = np.random.randn(N_points) y = .8 ** x + np.random.randn(984) + 25 legend = ['distribution'] # إنشاء الهيستوغرام fig, axs = plt.subplots(1, 1, figsize =(10, 7), tight_layout = True) #ticks حذف العلامات axs.xaxis.set_ticks_position('none') axs.yaxis.set_ticks_position('none') # إضافة شبكة إلى الخلفية axs.grid(b = True, color ='grey', linestyle ='-.', linewidth = 0.5, alpha = 0.6) # إضافة نص للشكل fig.text(0.9, 0.15, 'Ali Haidar Ahmad', fontsize = 13,color ='red',ha ='right', va ='top',alpha = 0.7) # plot حذف خطوط حاويةال for s in ['top', 'bottom', 'left', 'right']: axs.spines[s].set_visible(False) #وضع مسافة بين التسميات وبين المحاور axs.xaxis.set_tick_params(pad = 4) axs.yaxis.set_tick_params(pad = 8) # إنشاء الهستوغرام N, bins, patches = axs.hist(x, bins = n_bins) # تحديد الألوان fracs = ((N**(9)) / N.max()) norm = colors.Normalize(fracs.min(), fracs.max()) for thisfrac, thispatch in zip(fracs, patches): color = plt.cm.viridis(norm(thisfrac)) thispatch.set_facecolor(color) # تسمية للمحاور plt.xlabel("X-axis") plt.ylabel("y-axis") plt.legend(legend) # عنوان plt.title('Hsoub') # عرض plt.show() الخرج:

مثال 3:
import matplotlib.pyplot as plt import cv2 # قراءة صورة im = cv2.imread('/content/closedeye1.jpg') # نقوم بتسطيح الصورة لتصبح أحادية الأبعاد vals = im.flatten() # هنا كونك تريد أن تقوم برسم هيستوغرام صورة فيجب أن تضع عدد الحاويات على 255 إلا إذا كنت تريد شيئاً آخر # 255 = bins plt.hist(vals, 255) plt.xlim([0,255]) plt.show() الخرج:

في OpenCV لتطبيق انزياح على الصورة (نقل) نحتاج إلى تحديد مقدار الانزياح على المحور الأفقي والرأسي للصورة (tx ، ty)  لإنشاء مصفوفة التحويل:
حيث يشير tx إلى التحول على طول المحور x و ty يشير إلى التحول على طول المحور y ، أي عدد البكسلات التي نحتاجها للتحول بها في هذا الاتجاه. ثم نستخدم الدالة  cv2.wrapAffine لتطبيق هذا التحويل، وهذه الدالة تحتاج إلى مصفوفة  2×3 كما أنها تتطلب مصفوفة بقيم np. float32 لذا يجب تحويل مصفوفتك إلى هذا النمط قبل تمريرها إلى الدالة. في المثال التالي سنقوم بتطبيق إزاحة للصورة التالية بمقدار معين:

import cv2 from google.colab.patches import cv2_imshow import numpy as np # قراءة الصورة img = cv2.imread("/content/closedeye1.jpg") # تحديد عدد أسطر وأعمدة الصورة rows,cols,_ = img.shape # مصفوفة التحويل # سنقوم بتطبيق تحويل بمقدار 60 على المحور الأفقي و 20 للعمودي M = np.float32([[1,0,90],[0,1,60]]) # 3*2 مصفوفة dst = cv2.warpAffine(img,M,(cols,rows)) # عرض الصورة cv2_imshow(dst) والصورة الناتجة بعد التحويل:

يمكنك استخدام التابع cv2.resize لإنجاز ما أنت بحاجةٍ إليه، حيث يقوم بتقليصها أو توسيع نطاقها لتلبية متطلبات الحجم. كما بوفر العديد من طرق الاستيفاء (التوليد) لتغيير حجم الصورة، وأهمها:
- cv2.INTER_AREA: يستخدم عندما نحتاج إلى تقليص الصورة. أو cv2.INTER_CUBIC لكنه أبطأ لكن أكثر كفاءة.
- cv2.INTER_LINEAR: يستخدم  عندما نحتاج تكبير الصورة (الحالة الافتراضية عندما نطلب زيادة حجم الصورة).  وبشكل أساسي يأخذ هذا التابع 3 وسطاء:
cv2.resize(src, size,interpolation) الوسيط الأول هو الصورة المطلوب تعديلها، أما الثاني فهو الحجم المطلوب تعديل حجم الصورة إليه. أما الثالث فهو طريقة الاستيفاء المطلوبة. مثال:
import cv2 from google.colab.patches import cv2_imshow # قراءة الصورة img = cv2.imread("/content/closedeye1.jpg", cv2.IMREAD_UNCHANGED) # طباعة حجم الصورة print('Original Dimensions : ',img.shape) # تحديد أبعاد الحجم الجديد dim = (100, 120) # resize تطبيق التابع # resize image resized = cv2.resize(img, dim, interpolation = cv2.INTER_AREA) # عرض حجم الصورة بعد التعديل print('Resized Dimensions : ',resized.shape) # عرض الصورة cv2_imshow(resized) ######################### الخرج ##################### # Original Dimensions : (186, 271, 3) # Resized Dimensions : (120, 100, 3) والصورة الناتجة:
3*100*120
مثال لزيادة حجم الصورة:
import cv2 from google.colab.patches import cv2_imshow # قراءة الصورة img = cv2.imread("/content/closedeye1.jpg", cv2.IMREAD_UNCHANGED) # طباعة حجم الصورة print('Original Dimensions : ',img.shape) # تحديد أبعاد الحجم الجديد dim = (400, 400) # resize تطبيق التابع # resize image resized = cv2.resize(img, dim, interpolation = cv2.INTER_LINEAR) # عرض حجم الصورة بعد التعديل print('Resized Dimensions : ',resized.shape) # عرض الصورة cv2_imshow(resized) ######################### الخرج ##################### # Original Dimensions : (186, 271, 3) # Resized Dimensions : (400, 400, 3) والصورة الناتجة:
3*400*400

في مكتبة Matplotlib يمكنك استخدام ال bar blot للقيام بكل ما تحتاجه. فكما نعلم أن المخطط الشريطي (Bar chart) هو رسم بياني يمثل فئة البيانات ذات الأشرطة المستطيلة ذات الأطوال والارتفاعات التي تتناسب مع القيم التي تمثلها. ويمكن رسم مخططات الشريط أفقياً أو رأسياً. ويصف المخطط الشريطي المقارنات بين الفئات المنفصلة. حيث تمثل أحد محاور المخطط الفئات المحددة التي تتم مقارنتها، بينما يمثل المحور الآخر القيم المقاسة المقابلة لتلك الفئات. 
matplotlib.pyplot.bar(x, height, width=0.8, bottom=None, data=None, **kwargs) حيث أن الوسيط الأول يمثل إحداثيات x للأشرطة (قيم المحور الأفقي -الفئات-). أما الوسيط الثاني فيمثل ارتفاع كل فئة (ارتفاع الأشرطة bars). أما الوسيط الثالث فيمثل عرضها، والرابع يمثل أدنى قيمة في المحور العمودي (مثلاً لو وضعت 10 ستبدأ قيم المحور العمودي من ال10) والرابع يأخذ قيمتين إما center أو edge ويحدد محاذاة الشريط bar. وهناك وسطاء يمكنك أن تقوم بإضافتهم مثل اللون color ولون الحدود للأشرطة edgecolor و linewidth لتغيير عرضه و tick_label في حال أردت وضع أسماء محددة للفئات أو القيم.
مثال1: فيما يلي مثال بسيط على مخطط شريط Matplotlib. يوضح عدد الطلاب المسجلين في الدورات المختلفة المقدمة من أكاديمية حسوب:
import matplotlib.pyplot as plt import numpy as np # الفئات x = np.array(["CS", "UI", "JavaScript", "PHP"]) # ارتفاعها أو تكرارها أو سمها حسب نوع بياناتك y = np.array([307, 466, 674, 539]) # bar تمرير القيم للدالة plt.bar(x,y) # عرض النتائج plt.show() الخرج:

مثال2: نفس المثال السابق لكن بشكل احترافي أكثر.
import pandas as pd from matplotlib import pyplot as plt # البيانات نفسها name = ["CS", "UI", "JavaScript", "PHP"] freq = [307, 466, 674, 539] # اعديل حجم الشكل fig, ax = plt.subplots(figsize =(10, 9)) # تعريف مخطط شريطي معكوس ax.barh(name, price,color="m") # حذف حدود الشكل for s in ['top', 'bottom', 'left', 'right']: ax.spines[s].set_visible(False) # ticks حذف علامات المحاور ax.xaxis.set_ticks_position('none') ax.yaxis.set_ticks_position('none') # إضافة مسافة بين اسماء الفئات والمحور ax.xaxis.set_tick_params(pad = 5) ax.yaxis.set_tick_params(pad = 10) # إضافة شبكة للخلفية ax.grid(b = True, color ='grey', linestyle ='-.', linewidth = 0.5, alpha = 0.2) # إضافة تعليقات على الأشرطة for i in ax.patches: plt.text(i.get_width()+0.2, i.get_y()+0.5, str(round((i.get_width()), 2)), fontsize = 10, fontweight ='bold', color ='grey') # عنوان المخطط ax.set_title('Classes at Hsoub Academy', loc ='left', ) fig.text(0.9, 0.15, 'Jeeteshgavande30', fontsize = 12, color ='grey', ha ='right', va ='bottom', alpha = 0.7) # عرض الرسم plt.show() الخرج:

نعم يمكنك استخدام ال Pie Chart (نسميها الكعكة) وهو المخطط الدائري في Matplotlib  وهو مخطط إحصائي دائري يمكنه عرض سلسلة من البيانات. تكون مساحة الرسم البياني هي النسبة المئوية الإجمالية للبيانات المعطاة، وتمثل مساحة شرائح الكعكة "Pie " النسبة المئوية لأجزاء البيانات، وشرائح الكعكة "Pie " تسمى "wedges"، و يتم تحديد مساحتها بطول قوس ال wedge، وتمثل مساحته النسبة المئوية لذلك الجزء بالنسبة للبيانات كاملةً. الشكل العام لهذا التابع:
matplotlib.pyplot.pie(data, explode=None, labels=None, colors=None, autopct=None, shadow=False) بحيث أن الوسيط الأول يمثل البيانات الخاصة بك، بينما يمثل الوسيط الثاني قائمة (أو set أو tuble.. لامشكلة) من القيم (float) بحيث تمثل مدى ابتعاد ال wedge (يقابل عينة من data) عن باقي ال wedges (ستفهم أكثر في المثال). أما الوسيط الثالث فهو لوضع أسماء لهذه ال wedges ، والرابع لتحديد اللون، أما الخامس فهو لإضافة نص label يحمل القيمة العددية لل wedge مع إضافة أشياء مثل النسبة المئوية. أما الوسيط الأخير فهو يستخدم لإضافة ظل لل wedges. مثال1:
import matplotlib.pyplot as plt import numpy as np # تعريف قائمة تحوي بيانات y = np.array([35, 25, 25, 15]) # تسميتها mylabels = ["Apples", "Bananas", "Cherries", "Dates"] myexplode = [0.2, 0, 0, 0] # إنشاء المخطط plt.pie(y, labels = mylabels,explode = myexplode) # عرضه plt.show() الخرج:

مثال2:
import numpy as np import matplotlib.pyplot as plt # إنشاء بيانات cars = ['JAGUAR', 'MERCEDES','BMW','AUDI', 'FORD'] data = [22, 100, 42, 30, 25] # مثلاً أريد أن تكون الشريحة الخاصة بسيارات أودي بارزة # وبالتالي سأجعل قيمتها أكبر explode = (0.0, 0.12, 0.2, 0.25, 0.0) # تحديد ألوان مختلفة للشرائح colors = ( "black", "cyan", "red","grey", "yellow") # إضافة بعض الخصائص الخاصة للشرائح wp = { 'linewidth' : 1, 'edgecolor' : "red" } fig, ax = plt.subplots(figsize =(10, 7)) wedges, texts, autotexts = ax.pie(data, autopct = "%1.1f%%", explode = explode, labels = cars, shadow = True, colors = colors, startangle = 90, wedgeprops = wp, textprops = dict(color ="magenta")) # legend إضافة ax.legend(wedges, cars, title ="Cars", loc ="center left", bbox_to_anchor =(1, 0, 0.5, 1)) plt.setp(autotexts, size = 8, weight ="bold") ax.set_title("Customizing pie chart") # عرض البيانات plt.show() الخرج:

يمكنك استخدام الدالة ()matplotlib.pyplot.axvline لإضافة خطوط عمودية لل plot الخاص بك:
matplotlib.pyplot.axvline(x=0, ymin=0, ymax=1, **kwargs) حيث أن الوسيط الأول يستخدم لتحديد الإحداثي x الذي تريد رسم الخط العمودي عنده. أما الوسيط الثاني فيحدد موضع بدء الخط العمودي على المحور y، حيث يأخذ قيم بين 0 و 1، بحيث 0 يكون أسفل المحور ،  أما 1 يكون أعلى المحور. أما الوسيط الثالث، فيحدد موضع نهاية الخط العمودي على المحور y ، حيث يأخذ قيم بين 0 و 1، بحيث 0 يكون أسفل المحور ، و 1 يكون أعلى المحور. وأخيراً **kwargs تمثل وسطاء أخرى مثل عرض الخط linewidth واللون color. مثال:
import matplotlib.pyplot as plt # تحديد بيانات x =[0, 3, 7, 12, 17] y =[1, 4, 6, 7, 10] # رسم البيانات plt.plot(x, y) # بحيث يبدأ من منتصف المحور العيني x = 3.2 رسم خط عمودي باللون الأحمر عند الإحداثي # وينتهي في نهاية المحور العيني plt.axvline(x = 3.2, ymin = 0.5, ymax = 1, color ='r') plt.show() الخرج:

كما يمكنك رسم عدة خطوط عمودية كالتالي:
import matplotlib.pyplot as plt # تحديد بيانات x =[0, 3, 7, 12, 17] y =[1, 4, 6, 7, 10] # رسم البيانات plt.plot(x, y) # بحيث يبدأ من منتصف المحور العيني x = 3.2 رسم خط عمودي باللون الأحمر عند الإحداثي # وينتهي في نهاية المحور العيني plt.axvline(x = 3.2, ymin = 0.5, ymax = 1, color ='r') # خط آخر مع تغيير بعض القيم plt.axvline(x = 4.0, ymin = 0.3, ymax = 0.7, color ='black') # خط آخر plt.axvline(x = 5.0, ymin = 0.1, ymax = 0.9, color ='y') plt.show() الخرج:

أو من خلال حلقة for:
import matplotlib.pyplot as plt # تحديد بيانات x =[0, 3, 7, 12, 17] y =[1, 4, 6, 7, 10] # رسم البيانات plt.plot(x, y) xcoords = [2.22058956, 0.03088437, 4.20589566] for xc in xcoords: plt.axvline(x = xc, ymin = 0.5, ymax = 1, color ='r') plt.show() الخرج:

يقصد بالتعتيب إنشاء قناع (Mask)، لمجال لوني محدد من الصورة بحيث يظهر هذا المجال اللوني بالأبيض (غالباً) وأي لون خارج هذا المجال سيكون أسود (غالباً) وذلك لإظهاره وتحديده بغاية القيام بعمليات معينة على الصورة. وللقيام بعملية التعتيب نستخدم التابع cv2.threshold حيث يتم مقارنة كل بكسل في الصورة مع قيمة محددة نسميها  العتبة (threshold) في حال كانت قيمة البكسل أكبر أو تساوي العتبة يتم استبدال قيمة البكسل ب 255 وإلا تستبدل بالرقم 0 (يمثل اللون الأسود). للقيام بعملية التعتيب نستخدم التابع threshould والذي يأخذ 5 وسطاء، الأول الصورة الأصلية التي نريد تعتيبها مقروءة بالصيغة الرمادية، أما الثاني فهو مصفوفة الخرج(التي نريد وضع الناتج فيها -اختياري-)، أما الثالث فهو قيمة العتبة. ويمثل الرابع القيمة التي يجب تحويل البكسل إليها في حال كانت قيمة البكسل أكبر من العتبة. أما الوسيط الخامس هو نوع العتبة المراد تطبيقها وهناك 6 أنواع مختلفة:
cv2.THRESH_BINARY # تعتيب ثنائي الحالة الافتراضية التي نستخدمها cv2.THRESH_BINARY_INV # نفس السابق لكن بشكل معكوس cv2.THRESH_TRUNC # القيم الأعلى من العتبة يتم ضبطها لتصبح مساوية لقيمة العتبة أما باقي البكسلات تبقى كما هي cv2.THRESH_TOZERO # ضبط كثافة البكسل على 0 ، لكل كثافة بكسل ، أقل من الحد الأدنى cv2.THRESH_TOZERO_INV # معكوس السابق والصورة التالية توضح الفروقات بين هذه الأنواع:

وهنا المعادلات التي تعتمد عليها هذه الأنواع:

ويعيد هذا التابع قيمة على شكل Tuple،  بحيث القيمة الأولى تمثل قيمة العتبة التي قمت بتحديدها، في حين القيمة الثانية تمثل المصفوفة الناتجة.
cv2.threshold(src, dst, thresh, maxval, type) في المثال التالي سنقوم بتعتيب صورة واستخدام كل أنواع التعتيب البسيط:
import cv2 import numpy as np from matplotlib import pyplot as plt # قراءة الصورة بالصيغة الرمادية img = cv2.imread(r'C:\Users\Windows.10\Desktop\Safedrive\images.jpg',0) # THRESH_BINARY تطبيق أول نوع _,thresh1 = cv2.threshold(img,127,255,cv2.THRESH_BINARY) # THRESH_BINARY_INV _,thresh2 = cv2.threshold(img,127,255,cv2.THRESH_BINARY_INV) # THRESH_TRUNC _,thresh3 = cv2.threshold(img,127,255,cv2.THRESH_TRUNC) # THRESH_TOZERO _,thresh4 = cv2.threshold(img,127,255,cv2.THRESH_TOZERO) # THRESH_TOZERO_INV _,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 range(6): #من مكتببة ماتبلوتليب لرسم أكثر من شكل ضمن نفس النافذة subplot أستخدام التابع plt.subplot(2,3,i+1),plt.imshow(images[i],'gray') plt.title(titles[i]) plt.xticks([]),plt.yticks([]) fig =plt.gcf() fig.set_size_inches(20.0, 20.0) plt.show() والخرج:

111 تعني شبكة 1x1 وأول subplot. بينما 112 تعني شبكة 1x1 وثاني subplot. بينما 232 تعني شبكة 2x3 وثاني subplot. وهكذا.. وهذه الأرقام هي اختصار ل hwi أي الارتفاع والعرض والفهرس (رقم ال plot). حيث أن الدالة subplot تقوم بتشكيل شبكة "Grid" عن طريق تقسيم ال figure إلى عدة أقسام على أساس تقسيم محدد (مثل 111 أو 232 أو 542 ..إلخ) ويتم وضع ال plots ضمن خلايا هذه الشبكة. انظر للصورة التالية:

هنا لدينا شبكة 2x2 وقمنا بوضع 4 رسوم بيانية هم 221 و 222 و 223 و 224. والكود الموافق:
import matplotlib.pyplot as plt f = plt.figure() #top left f.add_subplot(221) # الأول #top right f.add_subplot(222) # الثاني #bottom left f.add_subplot(223) # الثالث #bottom right f.add_subplot(224) # الرابع plt.show() كذلك بدلاً من كتابة add_subplot(hwi) يمكن كتابة (height,width,index) add_subplot (وهي الصيغة الأساسية) حيث أن hwi هي الصيغة المختصرة (أو المشفرة).

يمكنك استخدام التابع cvtColor ولكن هنا بدلاً من تمرير قيمة الصورة للتابع نمرر له القيمة اللونية التي نريدها في BGR (الخطوة الأولى). ثم نقوم بتحديد أعلى وأدنى قيمة لمجال اللون المطلوب عن طريق اتباع القاعدة (الخطوة الثانية):
الدنيا: [H-10, 100,100] العليا: [H+10, 255, 255] لكن هذا ليس أفضل خيار دائماً (أقصد القاعدة) لذا لدقة أكبر يفضل أن تختار مجال القيم بشكل يدوي عن طريق تمرير أعلى وأدنى قيمة لعتبة اللون المطلوب في BGR.
مثال على ما سبق،  مثلاً لو أردنا إيجاد اللون الأحمر في HSV:
red = numpy.uint8([[[0,0,255]]]) hsv_red = cv2.cvtColor(red,cv2.COLOR_BGR2HSV) print(hsv_red) # [[[ 0 255 255]]] ثم نطبق القاعدة أعلاه وهذا سيعطينا مجالين:
Low: [0, 100,100] High: [10, 255, 255] لكن لو قمت بتجريب ذلك بشكل يدوي سينتج معك أن المجال الأفضل للون الأحمر هو:
Low: [0, 100,100] High: [20, 255, 255] مثال آخر لإيجاد اللون الأخضر في HSV:
green = np.uint8([[[0,255,0 ]]]) hsv_green = cv2.cvtColor(green,cv2.COLOR_BGR2HSV) print (hsv_green) # [[[ 60 255 255]]] ثم ينتج لدينا المجالات المطلوبة حسب القاعدة:
Low: [50, 100,100] High: [70, 255, 255]

نعم يمكنك استخدام الدالة Scatter في Matplotlib لعرض وتمثيل نقاط البيانات. فيما يلي سأشرح كيف يمكنك استخدامه لتمثيل نقاط البيانات:
matplotlib.pyplot.scatter(x_axis_data, y_axis_data, s=None, c=None, marker=None, cmap=None,alpha=None, linewidths=None, edgecolors=None) يتم استخدام الدالة plot من الموديول pyplot لرسم نقاط البيانات. بشكل أساسي تأخذ هذه الدالة وسيطين الأول يمثل المحور الأفقي x-axis والثاني يمثل المحور العمودي y-axis،  ويمكن أن تكون قيمهما ممثلة ضمن array أو list أو tuble . على سبيل المثال إذا كانت نقاط المحور الأفقي هي الأعداد ممثلة في القائمة التالية xp ونقاط المحور العمودي هي الأعداد من 15 إلى 22 والممثلة في yp، يمكننا رسم نقاط البيانات هذه بالشكل التالي:
import matplotlib.pyplot as plt xp = [3,4,5,2,7,4,3,1] #بحيث تتضمن القيم tuble تعريف مصفوفة أو قائمة أو yp = [15,16,17,18,19,20,21,22] plt.scatter(xp, yp) plt.show()
وكذلك يمكنك تمثيل أكثر من plot ضمن نفس ال figure:
import matplotlib.pyplot as plt import numpy as np x = np.array([4,5,8,7,2]) y = np.array([22,20,58,33,11]) plt.scatter(x, y) x = np.array([1,3,6,7,15,8,12]) y = np.array([13,66,44,42,36,62,44]) plt.scatter(x, y) plt.show()
كذلك يمكنك تغيير حجم نقاط البيانات من خلال الوسيط s (ويمكن أن تمرر له قيمة float لتغيير الحجم أو يمكنك تمرير مصفوفة حجمها بحجم نقاط البيانات لديك في حال أردت أن تجعل نقاط بيانات محددة تظهر بشكل أكبر | أصغر من غيرها). أما الوسيط c فلتحديد لون تسلسل الألوان لنقاط البيانات. أما الوسيط linewidths فلتحديد حجم محيط النقطة، و edgecolor لتحديد لون حدودها. أما alpha لتحديد شفافية النقطة (قيمة بين 0 (شفاف) و 1 (بدون شفافية)). والوسيط marker  لتحديد الشكل الذي تظهر به نقطة البيانات وافتراضياً يكون دائرة "o" ويمكنك اختيار أشكل أخرى مثل مثلث "^" أو "+" إلخ.. أما cmap فهي لتحديد خريطة الألوان.
أنظر للمثال التالي:
import matplotlib.pyplot as plt # مجموعة البيانات الأولى x1 = [89, 43, 36, 36, 95, 10, 66, 34, 38, 20] y1 = [21, 46, 3, 35, 67, 95, 53, 72, 58, 10] plt.scatter(x1, y1, c ="black", # لون النقطة linewidths = 1, # عرض الحدود marker ="*", # شكل النقطة edgecolor ="y", # لون الحدود s = 150) # حجم النقطة # الثانية x2 = [26, 29, 48, 64, 6, 5, 36, 66, 72, 40] y2 = [26, 34, 90, 33, 38, 20, 56, 2, 47, 15] plt.scatter(x2, y2, c ="blue", # لون النقطة linewidths = 3, # عرض الحدود marker ="^", # شكل النقطة edgecolor ="red", # لون الحدود s = 150)#حجمها plt.xlabel("X-axis") plt.ylabel("Y-axis") plt.show()
قد ترغب أيضاً في الاطلاع على الدالة plot:
وتختلف scatter عن هذه الدالة في أنها تقوم بتمثيل البيانات نقطيَاً أي بدون خطوط تصل بين هذه النقاط  وبما أنك تريد رؤية توزع البيانات لديك فأنت تحتاج Scatter.

بالنسبة لقياس الأداء فهناك التابع getTickCount الذي يعطينا عدد دورات الساعة CK التي استغرقناها لتنفيذ عملية أو مجموعة عمليات ضمن الكود. وأيضاً التابع getTickFrequency الذي يعطينا تردد دورات الساعة، أو عدد دورات الساعة في الثانية. ولإيجاد زمن تنفيذ المقطع البرمجي الخاص بك بالثواني:
import cv2 e1 = cv2.getTickCount() # البداية # الكود الخاص بك يكون هنا e2 = cv2.getTickCount() # النهاية time = (e2 - e1)/ cv2.getTickFrequency() مثال:
import cv2 as cv import numpy as np image = cv.imread("im.jpg") t1 = cv.getTickCount() # سنقوم بتجريب فلتر بقيم مختلفة للكيرنل for i in range(3,30,2): img1 = cv.medianBlur(image,i) t2 = cv.getTickCount() time = (t2 - t1)/cv.getTickFrequency() print(time) # 0.432018214 seconds أما بالنسبة لتحسين الأداء فهناك ما يسمى ب "الحل المثالي" حيث يمكنك تشغيل العديد من التوابع في OpenCV في هذا الوضع، لذا إذا كان لديك نظام يدعم خاصية "الحل المثالي" فيمكنك استخدام هذه الخاصية (حالياً جميع المعالجات تدعم ذلك).
لتفعيل هذه الخاصية نستخدم cv2.setUseOptimized حيث نمرر له True لتفعيلها و False لإلغاء التفعيل، ولمعرفة فيما إذا كان الكود ينفذ مع المحسَن optimizer أم لا، نقوم باستدعاء التابع cv2.useOptimized حيث يعيد True  إذا كانت الخاصية مفعلة وإلا False:
cv2.useOptimized() # False # أي أنها معطلة %timeit cv.medianBlur(image,33) # 10 loops, best of 3:66.3 ms per loop # الآن سنقوم بتفعيلها cv2.setUseOptimized(True) cv2.useOptimized() # TRUE %timeit cv.medianBlur(image,33) # 10 loops, best of 3:30.3 ms per loop  لاحظ أن الزمن قد تحسن بمقدار الضعف.

يمكنك استخدام plt.tick_params التي تمكننا من التحكم بأمور مثل تغيير مظهر العلامات ticks، وعلامات التجزئة tick labels، وخطوط الشبكة gridlines. ولها الشكل التالي:
matplotlib.pyplot.tick_params( axis='both',bottom=True, top=True, left=True, right=True,labelbottom=True, labeltop=True, labelleft=True, labelright=True,direction="out", length=None,width =None,color=None,which="major" labelsize=None,labelcolor=None,pad=None ) حيث أن axis تمثل المحاور التي نريد تطبيق التغيرات عليها ويأخذ القيم {'x', 'y', 'both'}.  والوسطاء bottom, top, left, right يحددون فيما إذا كانت العلامات ticks ستظهر أم لا في الاتجاهات المحدد ويأخذون قيمة منطقية إما True لإظهارها أو False لإخفائها مثلاً  bottom=True تعني أنك تريد إخفاء الticks  من المحور السيني . بالنسبة ل labelbottom, labeltop, labelleft, labelright فهم يحددون فيما إذا كنت تريد عرض الملصقات التي تكون بجانب ال ticks (الأرقام) ويأخذون قيمة منطقية إما True لإظهارها أو False لإخفائها. أما direction فهو يحدد الاتجاه الذي سيتم وضع العلامات فيه {'in', 'out', 'inout'}. أما length فلتحديد طول العلامات و width  لعرضها (قيم float). أما color فلتحديد لونها (مثلاً "r" أي أحمر). أما labelcolor و labelsize لتحديد لون وحجم الملصقات. أما which فكما نعلم قد يكون هناك ticks أساسية وثانوية فهنا من خلال هذا الوسيط أنت تحدد فيما إذا كنت تريد تطبيق التغيرات على العلامات الريسية أم الثانوية أم كلاهما {'major', 'minor', 'both'}. و pad لتحديد مقدار المسافة الفاصلة بين العلامات والملصقات. إليك المثال التالي لحذف العلامات من المحور السيني:
import matplotlib.pyplot as plt import numpy as np x = np.array([0, 1, 2, 3]) y = np.array([3, 8, 1, 10]) plt.subplot(1, 2, 1) plt.title("First Plot") plt.plot(x,y) plt.tick_params( axis='x', # تطبيق التغيرات على المحور السيني فقط which='both', # تطبيق التغيرات على العللامات الرئيسة كونه لاتوجد علامات فرعية bottom=0, # إزالة العلامات من المحور السيني top=0, # .... labelbottom=0) # إخفاء الأرقام plt.show()
مثال آخر بشكل عام لتوضيح عمل الوسيط which وباقي الوسطاء حيث سنقوم بإضافة علامات رئيسية وفرعية وسنقوم بالتعديل عليها (يمكنك أن تجرب باقي الوسطاء وتتلاعب بقيمها):
from matplotlib.ticker import MultipleLocator, ScalarFormatter import matplotlib.pyplot as plt fig, ax = plt.subplots() ax.plot([0, 10, 20, 30], [0, 2, 1, 2]) ax.xaxis.set_minor_locator(MultipleLocator(1)) ax.xaxis.set_minor_formatter(ScalarFormatter()) ax.tick_params(axis ='both', which ='major', labelsize = 16, pad = 102, colors ='r') ax.tick_params(axis ='both', which ='minor', labelsize = 8, colors ='b') plt.show()
كذلك هناك الوسيط grid_color  للتحكم بلون خطوط الشبكة (إن وجدت) و grid_alpha  للتحكم بشفافيتها و grid_linewidth  للتحكم بعرضها (قيم float).

-بالنسبة للسؤال الأول: النظم الخبيرة هي نظم المعرفة، حيث أن النظام الخبير هو برنامج ذكي  يستخدم القواعد المأخوذة من الخبرة الإنسانية (والمنظمة ضمن قواعد بيانات) على هيئة شروط ونتائج في مجال معين ويستخدم طرق الاشتقاق والاستدلال لاستخراج واستنتاج النتائج المعللة بالأسباب والناتجة عن تطابق هذه الشروط أو النتائج مع شرط أو نتيجة ما والخاصة بمشكلة معينة يراد إيجاد حل لها. هذه الأنظمة  لديها قدرات مميزة في مجالات معينة مثل التخطيط و تحليل العوارض وتشخيص الأخطاء diagnostics وتشخيص الأمراض وفي التصميم وفي نظم دعم اتخاذ القرار وغيرها من المجالات المتخصصة التي تم فهم العمليات المطلوبة لها، والتي تتناسب مع القدرات التمثيلية والاستنتاجية لهياكل الأنظمة المستخدمة. ويتم تطوير أي نظام خبير من خلال ثلاثة مراحل أساسية هي :
1. تمثيل المعرفة knowledge representation:
يحتاج المصمم في هذه المرحلة لتحديد الطريقة التي سيمثل بها المعارف والقوانين التي تحكم مجال العمل، واشهرها طريقة الاعتماد على القواعد (Rule based) وهي عبارة عن مجموعة من العبارات المنطقية تسمى بif_then Rules.
2. اكتساب المعرفة knowledge Acquisition:
في هذه المرحلة يتم تجميع القوانين التي تحكم المجال الذي سيعمل فيه النظام الخبير، وعادة ما يكون مصدر هذه القوانين خبير بشري له معرفة شاملة بميدان العمل ومعرفة عميقة بكل تفاصيله.
3. محرك الاستدلال Inference Engine:
يحتاج المصمم بعد اكتساب وتمثيل المعرفة إلى تحديد الطريقة التي يصل بها النظام الخبير إلى النتيجة بناء على مالديه من معلومات، وتعتبر هذه المرحلة أصعب المراحل.
- السؤال الثاني: لا حالياً لاتوجد دورة لكن ربما في وقت لاحق. لكن توجد دورات أخرى في مجالات متنوعة يمكنك تصفحها من هنا.
- السؤال الثالث: يفضل أن تبدأ مع تعلم لغة برولوغ أو LISP وكتاب مثل:
Introduction to Expert Systems, Jackson P. , 3rd edition أو Introduction to Knowledge Systems, Stefik M., Morgan Kaufmann.
يمكنك البدء مع أحد هذين الكتابين وكلاهما يعد نقطة انطلاق مناسبة لهذا الحقل.

لتغيير الفضاء اللوني نستخدم التابع cvtColor الذي له الشكل التالي:
cvtColor(image, code) حيث أن الوسيط الأول يمثل الصورة التي نريد تطبيق التحويل عليها، أما الوسيط الثاني يمثل كود تحويل (أكواد جاهزة في المكتبة فقط نقوم بتحديد اسم كود التحويل). وبالتالي للتحويل من صورة ملونة BGR (أغلب الصور تنتمي لهذا الفضاء اللوني) إلى صورة ملونة HSV نستخدم الكود cv2.COLOR_BGR2HSV كالتالي:
import cv2 import numpy as np # قراءة الصورة img1 = cv2.imread(r'C:\Users\Windows.10\Desktop\Safedrive\me.jpg') # HSV تحويل الصورة إلى imageresult = cv2.cvtColor(img1, cv2.COLOR_BGR2HSV) # عرض الصورة الناتجة وتخزينها cv2.imshow('res',img1) cv2.waitKey(0) cv2.destroyAllWindows() cv2.imwrite('d:\HSV.png',imageresult) وللتحويل من صورة ملونة BGR إلى صورة رمادية Gray نستخدم cv2.COLOR_BGR2GRAY بنفس الطريقة السابقة. وفي الرابط التالي من التوثيق الرسمي ل OpenCV جدول بحوالي 150 كود تحويل لكافة الأنظمة اللونية هنا.

بداية إن لم يكن لديك فكرة عن العمليات على مستوى البت، فأنصحك بالمقالة التالية أكاديمية خسوب.
هذا التابع له الشكل التالي bitwise_and:
bitwise_and(image1, image2, destination_array, mask) الوسيط الأول يمثل الصورة الأولى والوسيط الثاني يمثل الصورة الثانية أما الوسيط الثالث سيمثل المصفوفة التي سيتم وضع الخرج فيها، والوسيط الرابع يمثل القناع. ولهذا التابع فوائد واستخدامات كثيرة جداً على سبيل المثال سأقوم من خلال الكود التالي بتطبيق لوغو (شعار) على صورة. لكن قبل ذلك سنوضح الوسطاء بشكل أكبر:
أولاً: الصورتين image1 و image2 كل منهما يتم تمثيله كمصفوفة ثلاثية الأبعاد من الشكل (height,width,channels) والصورتان يجب أن يكون لهما نفس الأبعاد بالضبط. حيث سيتم تنفيذ عملية bitwise_and بين بكسلات الصورة الأولى والثانية (سيتم دمج الصورتين).
ثانياً: القناع mask يمكن أن تضعه ويمكن أن لاتضعه حسب المهمة التي تعمل عليها، وهذا القناع يكون من بعدين فقط أي (height,width) فقط (بدون قنوات) وأيضاً يجب أن يكون حجمه مطابق لحجم الصورتين. وتكون قيمه ضمن المجال 0 ل 255. هذا القناع يستخدم لتحديد الأماكن التي سيتم تطبيق عملية bitwise_and  عليها والأماكن (البكسلات) التي لن يتم تطبيق عملية bitwise_and عليها بحيث مثلاً من أجل البكسل (x,y) من الصورتين image1 و image2 يتم النظر إلى القيمة الموجودة في ال mask فإذا كانت 0 لايتم تطبيق عملية bitwise_and  وإلا فسيتم تطبيق عملية bitwise_and بين البكسلين. الآن سأقوم بكتابة الكود السابق لتفهم بدقة:
import cv2 import numpy as np # قراءة الصورتين img1 = cv2.imread(r'C:\Users\Windows.10\Desktop\Safedrive\me.jpg') # الصورة img2 = cv2.imread(r'C:\Users\Windows.10\Desktop\Safedrive\car.webp') # اللوغو # نريد وضع اللوغو في الزاوية العليا اليسارية من الصورة img2=cv2.resize(img2,(180,140)) # سنقوم بتحديد حجم اللوغو بالشكل الذي يناسبنا # نقوم الآن بتحديد أبعاد اللوغو rows,cols,channels = img2.shape # نقوم باقتصاص الزاويا العليا اليسارية من اللوغو بحيث يكون الحجم مطابق لحجم اللوغو roi = img1[0:rows, 0:cols ] #هي المنطقة التي نريد وضع اللوغو فيها roi إذاً # نقوم الآن باستخلاص نسخة من الصورة تكون رمادية img2gray = cv2.cvtColor(img2,cv2.COLOR_BGR2GRAY) # img2gray ستمثل النسخة الرمادية من الصورة # النسخة الرمادية:
# نقوم الآن بتعتيب الصورة بحيث نحصل على صورة أبيض وأسود # البكسلات التي تكون قيمتها أكبر من 60 ستصبح 255 أي بيضاء # البكسلات الأقل ستصبح 0 أي سوداء _, mask = cv2.threshold(img2gray, 60, 255, cv2.THRESH_BINARY) # mask ستمثل نسخة الأبيض والأسود من الصورة # mask وهذا هو شكل صورة ال :
# نقوم بعكس القيم # نعلم أن 255 تكافئ 1111 1111 في النظام الثنائي # ونعلم أن 0 تكافئ 0000 0000 في النظام الثنائي كوننا نمثل البكسل ب8 بت # ستؤدي إلى جعل ال 0 تساوي 255 والعكس bitwise_not وبالتالي تنفيذ عملية # أي الأبيض أسود والأسود أبيض mask_inv = cv2.bitwise_not(mask) # mask_inv سيجعل الخلفية بيضاء أي 255 والشعار 0 أي أسود # mask_inv:
#على ال bitwise_and كقناع لتطبيق عملية mask_inv سنقوم باستخدام #وبالتالي المناطق التي تحوي 0 لن تدخل في عملية الدمج roi roi = cv2.bitwise_and(roi,roi,mask = mask_inv) # اي هنا سيتم تعتيم المنطقة التي نريد وضع اللوغو فيها # الآن نكون انتهينا من تحديد المكان الذي سيتم وضع اللوغو ضمنه # roi:
# الآن نقوم ياستخلاص المنطقة التي يكون فيها اللوغو فقط من صورة اللوغو وباقي المناطق يتم تعتيمها أي 0 logo = cv2.bitwise_and(img2,img2,mask = mask) # logo:
# roi الآن نضع اللوغو ضمن ال # ثم نقوم بتعديل الصورة الأصلية # تذكر أن : black+anycolor=anycolor merge = cv2.add(roi,logo) #roi قمنا بإضافة اللوغو الآن إلى ال
img1[0:rows, 0:cols ] = merge cv2.imshow('res',img1) cv2.waitKey(0) cv2.destroyAllWindows()