‡ المحتويات‡

الرسم (الجزء الثانى)

فى هذا الجزء سوف نكمل حديثنا عن السم.

Donut

فى المثال التالى سوف ننشأ شكل معقد عن طريق تلفيف فروع من القاعات الناقصة.

donut.py

#!/usr/bin/ipy

import clr

clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")

from System.Windows.Forms import Application, Form
from System.Drawing import Size, Color, SolidBrush, Pen

class IForm(Form):

    def __init__(self):
        self.Text = 'Donut'
        self.Size = Size(350, 300)

        self.Paint += self.OnPaint
        self.CenterToScreen()

    def OnPaint(self, event):

        g = event.Graphics
        pen = Pen(Color.Gray, 1)
        
        size = self.ClientSize
        g.TranslateTransform(size.Width/2, size.Height/2)
        g.DrawEllipse(pen, -125, -125, 250, 250)
        
        for i in range(0, 36):
            g.DrawEllipse(pen, 0, 0, 120, 50)
            g.RotateTransform(10)
            
        g.Dispose()

Application.Run(IForm())

رسمنا خمسة خطوط على النافذة و كل خط له شكل DashStyle نقطى مختلف.

 size = self.ClientSize
 g.TranslateTransform(size.Width/2, size.Height/2)
 g.DrawEllipse(pen, -125, -125, 250, 250)

رسمنا دائرو وسط النافذة.

 for i in range(0, 36):
     g.DrawEllipse(pen, 0, 0, 120, 50)
     g.RotateTransform(10)

عنا رسمنا ستة و ثلاثين فطعاً ناقصاً كل يلف أو يبعد عن الآخر بزاوية قدرها عشر درجات.و هنا نحصل على الشكل المطلوب.

Figure: Donut

مستطيلات شفافة Transparent rectangles

النفاذية او الشفافية هى القدرة على الرؤية خلال المادة و أفضل طريقة لفهم الشفافية هى تخيل قطعة زجاج أو بعض الماء و تقنياً فإن أِعة الضوء تمر خلال الزجاج مما يسمح لنا برؤية ما وراءه.

و فى الواجهات الرسومية على الكمبيوتر يمكنك الوصول إلى تأثير الشفافية عن طريق استخدام alpha compositing و هى عبارة عن عملية لدمج الصورة بالخلفية لخلق المظهر الشفاف.و هذه العملية تستخدم قناة ألفت alpha channel . راجع الموسوعة الحرة Wikipedia.org و answers.com

transparentrectangles.py

#!/usr/bin/ipy

import clr

clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")

from System.Windows.Forms import Application, Form
from System.Drawing import Size, Color, SolidBrush

class IForm(Form):

    def __init__(self):
        self.Text = 'Transparent rectangles'
        self.Size = Size(590, 110)

        self.Paint += self.OnPaint
        
        self.CenterToScreen()


    def OnPaint(self, event):

        g = event.Graphics

        for i in range(1, 11):
            color = Color.FromArgb(i*25, 0, 0, 255)
            brush = SolidBrush(color)
            g.FillRectangle(brush, 50*i, 20, 40, 40)
            

Application.Run(IForm())

فى المثال سوف نرسم عشرة مستطيلات على درجات مختلفة من الشفافية.

 color = Color.FromArgb(i*25, 0, 0, 255)

فى هذا اسطر أنشأنا كائن لون و القيمة الأولى هى فيمة نفاذية الألفا alpha transparency.

 brush = SolidBrush(color)

هنا ننشأ فرشة من اللون.

 g.FillRectangle(brush, 50*i, 20, 40, 40)

هنا نرسم المستطيل.

Figure: Transparent rectangles

صورة رمادية (أبيض و أسود) Grayscale image

المثال التالى ينشأ صورة رمادية.

grayscale.py

#!/usr/bin/ipy

import clr
import sys

clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")

from System.Windows.Forms import Application, Form
from System.Drawing import Size, Rectangle
from System.Drawing import Bitmap, Color

class IForm(Form):

    def __init__(self):
        self.Text = 'Grayscale'
        self.Size = Size(290, 150)

        self.Paint += self.OnPaint

        self.rotunda = self.loadImage()
        self.gs = self.grayScale(self.rotunda.Clone())

        self.CenterToScreen()

    def loadImage(self):
        try:
            rotunda = Bitmap("rotunda.jpg")
            return rotunda
        except Exception, e:
            print e.msg
            sys.exit(1)

    def grayScale(self, image):
        
        w = image.Width
        h = image.Height

        for i in range(w):
            for j in range(h):
                c = image.GetPixel(i, j)
                lum = 0.299*c.R + 0.587*c.G + 0.114*c.B
                image.SetPixel(i, j, Color.FromArgb(lum, lum, lum))
          
        return image


    def OnPaint(self, event):

        g = event.Graphics

        r1 = Rectangle(15, 15, self.rotunda.Width, self.rotunda.Height)
        g.DrawImage(self.rotunda, r1)

        r2 = Rectangle(150, 15, self.gs.Width, self.gs.Height)
        g.DrawImage(self.gs, r2)
        
        g.Dispose()

Application.Run(IForm())

لدينا صورتين فى المثال. ثورة ملونة و صورة رمادية.

 self.rotunda = self.loadImage()

الدالة loadImage() تحمل الصورة من ملف العمل على القرص الصلب.

 self.gs = self.grayScale(self.rotunda.Clone())

الدالة grayScale() تشأ صورة رمادية من الصورة الملونة و هنا أعطينا نسخة من الصورة كمعامل لهذه الدالة.

 c = image.GetPixel(i, j)

هنا نحصل على كل البكسل من الصورة

 lum = 0.299*c.R + 0.587*c.G + 0.114*c.B

الناتج عبارة عن حساب السطوع للصورة الرمادية فإذا عدلنا الأجزاء باللون الأخضر و الأحمر و الأزرق بهذه العوامل فسوف تراها العين البشرية باللون الرمادى.

 image.SetPixel(i, j, Color.FromArgb(lum, lum, lum))

نعدل البكسل.

Figure: Grayscale image

تدريجات Gradients

فى الواجهات الرسومية تعتبر التدريجات هى تدريج للظلال من الأبيض إلى الأسود أو من لون إلى لون و فى برامج الرسم الثنائى الأبعاد أو الرسم النقطى يستخدم التدريج لعمل خلفيات و تأثيرات خاصة و محاكاة الضوء و الظل (راجع answers.com).

gradients.py

#!/usr/bin/ipy

import clr

clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")

from System.Windows.Forms import Application, Form
from System.Drawing import Size, Color, Point
from System.Drawing.Drawing2D import LinearGradientBrush

class IForm(Form):

    def __init__(self):
        self.Text = 'Gradients'
        self.Size = Size(350, 350)
        self.Paint += self.OnPaint

        self.CenterToScreen()

    def OnPaint(self, event):

        g = event.Graphics

        pt1 = Point(5, 5)
        pt2 = Point(25, 25)
        lg =  LinearGradientBrush(pt1, pt2, Color.Red, Color.Black)
        g.FillRectangle(lg, 20, 20, 300, 40)

        pt1 = Point(5, 25)
        pt2 = Point(20, 2)
        lg = LinearGradientBrush(pt1, pt2, Color.Yellow, Color.Black)
        g.FillRectangle(lg, 20, 80, 300, 40)

        pt1 = Point(5, 25)
        pt2 = Point(2, 2)
        lg = LinearGradientBrush(pt1, pt2, Color.Green, Color.Black)
        g.FillRectangle(lg, 20, 140, 300, 40)

        pt1 = Point(25, 25)
        pt2 = Point(15, 25)
        lg =  LinearGradientBrush(pt1, pt2, Color.Blue, Color.Black)
        g.FillRectangle(lg, 20, 200, 300, 40)

        pt1 = Point(0, 10)
        pt2 = Point(0, 20)
        lg = LinearGradientBrush(pt1, pt2, Color.Orange, Color.Black)
        g.FillRectangle(lg, 20, 260, 300, 40)

        lg.Dispose()
        g.Dispose()


Application.Run(IForm())

رسمنا خمسة مستطيلات مليئه بتدريجات خطية.

 pt1 = Point(5, 5)
 pt2 = Point(25, 25)

السطرين هم نقاط التحكم فى فرشاة التدريج الخطية.

 lg =  LinearGradientBrush(pt1, pt2, Color.Red, Color.Black)

أنشأنا الكائن LinearGradientBrush و استخدمنا النقطتين و لونين.

Figure: Gradients

الإنتظار Waiting

فى هذا المثال سوف نستخدم الشفافية فى صنع تأثير يوحى بالإنتظار فسوف نرسم ثمانية خطوط و سوف تتدرج فى الظهور مما يوؤدى إلى الشكل النهائى الموحى بالإنتظار و هو أن الخط يتحرك و مثل هذه التأثيرات تستخدم للتأكيد من المستخدمين لشىء ما أو شىء ما وراء الكوايس أو مثلاً تشغيل فيديو من الانترنت.

waiting.py

#!/usr/bin/ipy

import clr

clr.AddReference("System.Windows.Forms")
clr.AddReference("System.Drawing")

from System.Windows.Forms import Application, Form, Timer
from System.Drawing import Size, Color, SolidBrush, Pen
from System.Drawing.Drawing2D import SmoothingMode, LineCap
from System.ComponentModel import Container


trs =  (
    ( 0, 35, 70, 100, 150, 180, 210, 250 ),
    ( 250, 0, 35, 70, 100, 150, 180, 210  ),
    ( 210, 250, 0, 35, 70, 100, 150, 180  ),
    ( 180, 210, 250, 0, 35, 70, 100, 150 ),
    ( 150, 180, 210, 250, 0, 35, 70, 100 ),
    ( 100, 150, 180, 210, 250, 0, 35, 70 ),
    ( 70, 100, 150, 180, 210, 250, 0, 35 ),
    ( 35, 70, 100, 150, 180, 210, 250, 0 )
)


class IForm(Form):

    def __init__(self):
        self.Text = 'Waiting'
        self.Size = Size(250, 150)

        self.Paint += self.OnPaint

        self.count = 0
        
        self.timer = Timer(Container())
        self.timer.Enabled = True
        self.timer.Interval = 80
        self.timer.Tick += self.OnTick

        self.CenterToScreen()

    
    def OnTick(self, sender, event):
        self.count = self.count + 1
        self.Refresh()

    def OnPaint(self, event):

        g = event.Graphics
        g.SmoothingMode = SmoothingMode.AntiAlias
        
        size = self.ClientSize
        g.TranslateTransform(size.Width/2, size.Height/2)
        
        for i in range(0, 8):
            color = Color.FromArgb(trs[self.count%8][i], 30, 30, 30)
            pen = Pen(color, 3)
            pen.StartCap = LineCap.Round
            pen.EndCap = LineCap.Round
            g.DrawLine(pen, 0, -10, 0, -40)
            g.RotateTransform(45)
            
        pen.Dispose()    
        g.Dispose()
        

Application.Run(IForm())

رسمنا ثمانية خطوط بقيمة شفافية مختلفة.

 self.timer = Timer(Container())
 self.timer.Enabled = True
 self.timer.Interval = 80
 self.timer.Tick += self.On

سوف نستخدم عداد Timer لإنشاء الشكل المتحرك.

trs =  (
    ( 0, 35, 70, 100, 150, 180, 210, 250 ),
    ...
)

هناك مجموعتين من درجات الشفافية سوف نستخدمها و هناك ثمانية صفوق كل صف لحالة واحدة و سوف تمر كل قيمة على خط من الخطوط الثمانية.

 pen = Pen(color, 3)
 pen.StartCap = LineCap.Round
 pen.EndCap = LineCap.Round

جعلنا الخطوط كثيفة نسبياً لذلك فمظهرهم أوضح و لقد رسمنا الخط بطرف مستدير.

 color = Color.FromArgb(trs[self.count%8][i], 30, 30, 30)

هنا نعرف قيمة الشفافية لخط.

 g.DrawLine(pen, 0, -10, 0, -40)
 g.RotateTransform(45)

رسمنا ثمانية خطوط على شكل ساعة.

Figure: Waiting

فى هذا الجزء من الدرس قمنا ببعض عمليات الرسم المتقدمة فى مكتبات WinForms.

‡ المحتويات‡