Trang 1 trên tổng số 2 12 Cuối cùngCuối cùng
Từ 1 tới 10 trên tổng số 17 kết quả

Đề tài: Thuật toán xử lý ảnh trong C#?

  1. #1
    Ngày gia nhập
    08 2010
    Bài viết
    76

    Mặc định Thuật toán xử lý ảnh trong C#?

    Mình đang làm về xử lí ảnh trong C# để viết lại một số ứng dụng của photoshop ,cụ thể là phần mềm của mình sẽ xử lí ảnh RGB.Hiện tại mình chưa sưu tầm đc đáng bao nhiêu thuật toán để làm cả!Mong bạn nào có hiểu biết về vấn đề này hay có tài liệu chỉ cho mình thêm về các thuật toán trong việc xử lí ảnh RGB!

  2. #2
    Ngày gia nhập
    04 2009
    Nơi ở
    Gầm cầu
    Bài viết
    2,230

    Xử lý ảnh

    - Thông thường xử lý ảnh được lập trình trên các ngôn ngữ thuộc họ C…, lý do đơn giản vì các ngôn ngữ này hỗ trợ con trỏ (pointer) nhằm truy cập trực tiếp và các ô nhớ, giúp quá trình xử lý ảnh được nhanh hơn thay vì truy cập một cách gián tiếp.

    - Mục đích của xử lý ảnh:

    + Tăng cường, phục hồi, nâng cao chất lượng ảnh

    + Trích lọc thông tin từ ảnh

    - Các phép xử lý thường áp dụng trên ảnh nhị phân, hoặc ảnh mức xám

    - Có 2 miền xử lý chính:

    + Không gian

    + Tần số

    - Có 3 loại xử lý chính:

    + Xử lý trên điểm ảnh

    + Xử lý lân cận

    + Xử lý toàn cục (thường được xử lý trên miền tần số)

    - Những kiến thức cơ bản liên quan:

    + Không gian màu RGB

    + Cơ bản về ảnh số

    + Cách biểu diễn ảnh số

    + Độ phân giải ảnh, màu

    + Ngôn ngữ lập trình

    PHẦN XỬ LÝ TRÊN MIỀN KHÔNG GIAN

    1. Chuyển đổi cơ bản

    1.1 Sử dụng phương thức Set-GetPixel

    - Thông thường ảnh được xử lý trên ảnh mức xám (một lớp màu), ảnh trắng đen (ảnh nhị -phân)

    - Vậy làm sao để chuyển một ảnh màu về ảnh mức xám hay ảnh nhị phân? …

    - Như các bạn đã biết

    + Một ảnh mức xám có nghĩa là: một điểm ảnh trong ảnh này được biểu diễn bằng một số 8 bit = 2^8=256 giá trị từ tối tới sáng

    + Một ảnh nhị phân: một điểm ảnh được biểu diễn bằng số một bit = 2^1=2 giá trị tối và sáng

    + Ảnh màu đương nhiên được tổng hợp từ 3 màu R-G-B

    Ví dụ:
    - Để chuyển ảnh màu về ảnh xám chúng ta có công thức sau:

    a. O(x,y)=( IR(x,y) + IG(x,y) + IB(x,y)) /3

    Với:

    x,y là tạo độ của điểm ảnh
    IR thành phân màu đỏ tại màu I(x,y)
    IG thành phân màu xanh lá tại màu I(x,y)
    IB thành phân màu xanh dương tại màu I(x,y)
    O(x,y): mà đầu ra, I(x,y) màu đầu vào

    b. O(x,y)= IR(x,y) * 0.287 + IG(x,y) * 0.599 + IB(x,y) * 0.114

    Ví dụ 1: Sử dụng công thức b cho ví dụ 1 như sau:
    Code:
    private Bitmap ToGray(Bitmap bm)
            {
                Bitmap bitmap = new Bitmap(bm);
                int x, y;
                Color c;
                Byte gray;
                for (y = 0; y < bm.Height - 1; y++)
                {
                    for (x = 0; x < bm.Width - 1; x++)
                    {
                        c = bm.GetPixel(x, y);
                        gray =Convert.ToByte(c.R * 0.287 + c.G * 0.599 + c.B * 0.114);
                        bitmap.SetPixel(x, y, Color.FromArgb(gray, gray, gray));
                    }
                }
                return bitmap;
            }
    Kết quả thử nghiệm như sau:

    - Đối với ảnh nhị phân ta kiểm tra giá trị màu nếu <128 thì set lại giá trị là 0 ngược lại set giá trị là 255. Ta có công thức sau:

    O(x,y)= 0 nếu I(x,y) < C
    BeerO(x,y)= 255 ngược lại

    Với C là ngưởng (-1 < C < 256) cần phân ngưỡng

    Ví dụ 2:
    Code:
     private Bitmap ToBinary(Bitmap bm, Byte band)
            {
                Bitmap bitmap = new Bitmap(bm);
                int x, y;
                Color c;
                for (y = 0; y < bm.Height - 1; y++)
                {
                    for (x = 0; x < bm.Width - 1; x++)
                    {
                        c = bm.GetPixel(x, y);
                        if (c.R < band)
                            bitmap.SetPixel(x, y, Color.FromArgb(0, 0, 0));
                        else
                            bitmap.SetPixel(x, y, Color.FromArgb(255, 255, 255));
                    }
                }
                return bitmap;
            }
    - Ở hàm trên nếu c.R < band chúng ta sử dụng là c.R vì đối với ảnh mức xám thì 3 thành phần màu bằng nhau nên không cần phân biệt c.R, c.G hay C.B.

    - Bạn hãy tạo 1 project rồi kiểm thử nó.

    1.2 Sử dụng LockBits

    - Nhìn lại ví dụ 2, chuyện gì đã xảy ra…: Chạy tốt, nhưng vấn đề là thời gian

    - Hai hàm trên đều sử dụng 2 phương thức set và get, về mặt thuật toán có lẻ bạn nghĩ 2 vòng lặp đó đã làm cho chương trình trở nên quá rùa đồng thời nếu sử dụng ảnh có độ phân giải hơi lớn tí là có thể treo luôn.

    - Vấn đề không phải giải thuật mà chính do 2 phương thức set và getpixel gây nên, khi bạn gọi 2 phương thức này hệ điều hành Win sẽ Lock ảnh lại đến khi kết thúc phương thức vừa goi tự động sẽ UnLock ảnh đó cho việt truy cập lần sau. Chính việc Lock rồi Unlock liên tục đã làm đã làm cho hàm trên xử lý chậm rãi từ tốn.

    - Giải thuật sau dùng kỹ thuật LockBits
    Code:
    private Bitmap ToBinaryLocBits(Bitmap bm, Byte band)
            {
                Bitmap bitmap = new Bitmap(bm);
                Rectangle rec = new Rectangle(0, 0, bitmap.Width, bitmap.Height);
                System.Drawing.Imaging.BitmapData bmpData = bitmap.LockBits(rec, System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmap.PixelFormat);
                IntPtr ptr = bmpData.Scan0;
                Int32 bytes = bmpData.Stride * bitmap.Height;
                Byte[ rgbValues = new Byte[bytes - 1];
                System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);
                Byte color;
                for (int counter = 0; counter < rgbValues.Length - 1; counter += 4)
                {
                    color = rgbValues[counter];
                    if (color < band)
                    {
                        rgbValues[counter + 0] = 0;
                        rgbValues[counter + 1] = 0;
                        rgbValues[counter + 2] = 0;
                    }
                    else
                    {
                        rgbValues[counter + 0] = 255;
                        rgbValues[counter + 1] = 255;
                        rgbValues[counter + 2] = 255;
                    }
                }
                System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
                bitmap.UnlockBits(bmpData);
                return bitmap;
            }
    - Giải thuật trên chủ yêu dựa trên 2 phương thức:
    Code:
       
     System.Runtime.InteropServices.Marshal.Copy(ptr, rgbValues, 0, bytes);  
     System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, ptr, bytes);
    - Nhiệm vụ của chúng là sao chép các ô nhớ từ ptr vào mảng byte và ngược lại.

    - Tại sao lại có step là 4 (counter+=4) ? Đối với lớp Bitmap, khi ta khai báo khởi tạo bằng phương thức new sẽ nhận được đầu vào là một bitmap định dạng 32bit.
    Code:
        Bitmap bitmap = new Bitmap(bm);
    Nếu chỉ gán bằng thì PixelFormat sẽ nhận định dạng bằng chính ảnh đầu vào
    Code:
      
    Bitmap bitmap;  
        bitmap = bm;
    Do đó, để tổng quát chúng ta dùng phương thức new:

    Bạn hãy thử viết lại ví dụ 1 với LockBits rồi so sánh với get-set.

    1.3 Tổ Chức Đồ (Histogram)

    Định Nghĩa: Là đồ thị mô tả mối quan hệ giữa mức xám và số điểm ảnh có chung mức xám

    Ví dụ:


    - Tổ chức đồ được xử lý trên điểm ảnh, thường được xử lý để nâng cao chất lượng ảnh có thể dùng để nhận dạng ảnh

    - Cánh tính:

    + Tính h[x] là số lượng điểm ảnh có cùng mức xám x

    + Chạy i từ 0 -> 255 đếm số điểm ảnh có cùng mức xám i

    Ví dụ: Tính H[x] cho ảnh xám
    Code:
    int x,y;
    int [ H=new int[255];
    for(y = 0;y<bm.Height - 1;y++)
                {
                    for( x = 0;x<bm.Width - 1;x++)
                    {
                        H[bm.GetPixel(x, y).R] += 1;
                    }
                }
    Sau khi thoát khỏi vòng lặp, mỗi phần tử trong mảng H là giá trị số lượng điểm ảnh tại mức xám của vị trí phần tử đó
    Ví dụ: H[113] = 720, suy ra mức xám thứ 113 có 720 điểm ảnh


    Nhận Xét: với hình trên, chúng ta thấy rằng trong ảnh góc cường độ sáng của ảnh là trung bình (không tối, không sáng) , so với tổ chức đồ tương ứng nơi cao nhất tập trung ở giữa đồ thị và tương đương với mức xám 128.

    - Nếu thực sự bạn đã hiểu mới quan hệ giữa ảnh và tổ chức đồ hãy xem ví dụ sau:


    - Bạn có thấy sự khác biệt giữa 2 ảnh? Rõ ràng ảnh sau có cường độ sáng cao hơn ảnh trước và điều đó tương đương với tổ chức đồ của 2 ảnh, chân của tổ chức đồ sau lệch về phải hơn so với tổ chức đồ trước.

    Vậy dựa vào tổ chức đồ của ảnh ta có thể nhận dạng ảnh tối hay sáng.

    + Nếu ảnh tối => ảnh sáng : Kéo tổ chức đồ về phải

    + Nếu ảnh sáng => ảnh tối : Kéo tổ chức đồ về trái

    (Các phép toán trên tổ chức đồ ta sẽ tìm hiểu ở phần sau)

    - Vẽ tổ chức đồ:
    Code:
    private Bitmap HistogramGray(Bitmap bm, int[ h)
            {
                //Tinh H[x]
                int x, y;
                for (y = 0; y < bm.Height - 1; y++)
                {
                    for (x = 0; x < bm.Width - 1; x++)
                        h[bm.GetPixel(x, y).R] += 1;
                }
                //Phân bố lại khích với pictureBox
                int max = h[0];
                for (int j = 1; j < 255; j++)
                    if (max < h[j])
                        max = h[j];
                //'Vẽ
                int Height=100;
                Bitmap bmHistogram = new Bitmap(256, 100);
                Graphics gp = Graphics.FromImage(bmHistogram);
                gp.FillRectangle(new Pen(Color.Black).Brush, new Rectangle(0, 0, bmHistogram.Width, bmHistogram.Height));
                int n;
                for (int i = 0; i < 255; i++)
                {
                    n = (h<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" /> * Height) / max;
                    gp.DrawLine(new Pen(Color.Gray), i, 100, i, 100 - n);
                }
                return bmHistogram;
            }
    - Chép code trên vào project để kiểm tra. Bạn cũng có thể cải tiến giải thuật trên cho ảnh màu và tốc độ xử lý.

    2. Một số phép toán trên tổ chức đồ

    - Trong phần này chúng ta đi vào các phép xử lý tổ chức đồ cơ bản.

    - Như đã biết, tổ chức đồ là một đặt trưng quan trọng của ảnh, dựa vào tổ chức đồ chúng ta có thể nhận dạng sơ về ảnh, có kết luận cơ bản về ảnh: ảnh sáng, tối, độ tương phản thấp, cao…. Với lý do đó, chúng ta có một số phép xử lý sau:

    + Trượt tổ chức đồ

    + Căng tổ chức đồ

    + Sửa chữa tổ chức đồ

    + San lấp tổ chức đồ

    2.1 Trượt tổ chức đồ

    Mục đích: làm tăng hoặc giảm cường độ xám của ảnh

    O(x,y) = I(x,y) + n
    n < 0 : trượt ảnh về bên trái => ảnh tối hơn
    n > 0 : trượt ảnh về bên phải => ảnh sáng hơn

    Chú ý: Kết quả của O(x,y) có thể > 255 hoặc < 0 vì vậy bạn cần chú ý để set lại 2 giá trị này
    Code:
    private Bitmap HisToGramStep(Bitmap bm, int n)
            {
                Bitmap bitmap=new Bitmap(bm);
                int x, y;
               Color c;
                for( y = 0;y<bitmap.Height - 1;y++)
                {
                    for( x = 0;x<bitmap.Width - 1;x++)
                    {
                c = bitmap.GetPixel(x, y);
                if ((c.R + n) <= 255 && (c.R + n) >= 0 )
                    bitmap.SetPixel(x, y, Color.FromArgb(c.R + n, c.R + n, c.R + n));
                else if ((c.R + n) > 255)
                    bitmap.SetPixel(x, y, Color.FromArgb(255, 255, 255));
               else if ((c.R + n) < 0)
                    bitmap.SetPixel(x, y, Color.FromArgb(0, 0, 0));
                    }
                }
                return bitmap;
            }
    Kết quả:


    2.2 Căng tổ chức đồ

    Mục đích: làm thay đổi độ tương phản của ảnh (bạn tự tìm hiểu độ tương phản là gì?)

    O(x,y) = I(x,y) x n (với n > 0)
    n < 1 : thu hẹp chân tổ chức đồ => giảm độ tương phản của ảnh
    n > 1 : mở rộng chân tổ chức đồ => tăng độ tương phản của ảnh
    Code:
    private Bitmap HisToGramStretch(Bitmap bm, int n) 
            {
                if (n <= 0)
                    return null;
                 Bitmap bitmap =new Bitmap(bm);
                int x, y;
                Color c;
                for (y = 0 ;y<bitmap.Height - 1;y++)
                {
                    for( x = 0;x<bitmap.Width - 1;x++)
                    {
                c = bitmap.GetPixel(x, y);
                        if ((c.R * n) <= 255 && (c.R * n) >= 0 )
                    bitmap.SetPixel(x, y, Color.FromArgb(c.R * n, c.R * n, c.R * n));
                        else if ((c.R * n) > 255 )
                            bitmap.SetPixel(x, y, Color.FromArgb(255, 255, 255));
                        else if  ((c.R * n) < 0 )
                            bitmap.SetPixel(x, y, Color.FromArgb(0, 0, 0));
                    }
                }
                return bitmap;
            }
    Kết quả sau khi căng, tổ chức đồ đã được phân bố đều từ mức xám 0 đến 255.

    2.3 Sửa chữa tổ chức đồ

    Mục đích: nhằm có một tổ chức đồ tối ưu => nâng cao chất lượng ảnh

    - Kết hợp giữa trượt và căng tổ chức đồ.

    + Trượt tổ chức đồ về bên trái sao cho mức xám nhỏ nhất (có giá trị) về 0.

    + Căng tổ chức đồ sao cho mức xám lớn nhất (có giá trị) bằng 255.

    O(x,y) = I(x,y) * 255 / max(h())

    Ví dụ minh họa:


    Bước 1: tính h[x] cho mỗi mức xám
    Code:
     private void GetH(Bitmap bm , int[ toH)
            {
                int x, y;
                for(y = 0;y<bm.Height - 1;y++)
                {
                    for( x = 0;x<bm.Width - 1;x++)
                    {
                        toH[bm.GetPixel(x, y).R] += 1;
                    }
                }
            }
    Bước 2: xác định mức xám nhỏ và mức xám lớn nhất có giá trị
    Code:
    private Byte HistogramLeft(int [ h)
            {
                for(int i= 0;i<h.Length - 1;i++)
                {
                    if( h<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" /> != 0)
                        return (byte)i;
                }
                return 0;
            }
            private Byte HistogramRight(int [ h)
            {
                for(int i = h.Length - 1;i>0;i--)
                {
                    if (h<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" />!=0)
                        return (byte)i;
                }
                return 0;
            }
    Bước 3: ráp lại theo thứ tự giải thuật
    Code:
     private Bitmap HistogramEdit(Bitmap bm)
            {
                Bitmap bitmap = new Bitmap(bm);
                //Tinh  h(x)
                int[ hL = new int[255];
                int[ hR = new int[255];
                GetH(bitmap, hL);
                //Tim Trai & truot trai
                int left = HistogramLeft(hL);
                bitmap = new Bitmap(HisToGramStep(bm, -left));
                //Tinh tien ve 0 va copy hL qua hR
                Array.Copy(hL, left, hR, 0, hL.Length - left);
                int x, y;
                Byte c;
                Byte max = HistogramRight(hR);
    
                for (y = 0; y < bitmap.Height - 1; y++)
                {
                    for (x = 0; x < bitmap.Width - 1; x++)
                    {
                        c = bitmap.GetPixel(x, y).R;
                        c = (byte)(c / max * 255);
                        bitmap.SetPixel(x, y, Color.FromArgb(c, c, c));
                    }
                } return bitmap;
            }
    Chú ý: tìm left cho hL[x] trước khi trượt về trái, tìm right khi đã trượt về trái đồng thời đã tính hR[x], lợi dụng tính trượt của tổ chức đồ vì thế tôi không cần phải tính lại hR[x] mà chỉ thông qua hàm copy của lớp Array:

    Code:
    //'Tinh tien ve 0 va copy hL qua hR
     Array.Copy(hL, left, hR, 0, hL.Length - left);
    Xong! Chỉ có thế, giờ thì bạn có thể kiểm tra…

    2.4 San lấp tổ chức đồ

    Mục đích: phân bố lại các mức xám => tăng độ tương phản của ảnh

    - Tổ chức đồ của ảnh kết quả sẽ ít lõm hơn ảnh ban đầu


    Từ đó ta có một số công thức sau cho việc san lấp:

    Code:
    private Bitmap HistogramEqualization(Bitmap bm)
            {
                Bitmap bitmap = new Bitmap(bm);
                int w = bitmap.Width * bitmap.Height;
                //Tinh to chuc do
                int[ h = new int[255];
                int[ hN = new int[255];
                GetH(bm, h);
                //Chuan hoa to chuc do
                for (int i = 0; i < 255; i++)
                {
                    hN<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" /> = h<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" /> / w;
                }
                //Tinh ham mat do xac Suat
                int[ Z = new int[255];
                Z[0] = hN[0];
                for (int i = 1; i < 255; i++)
                {
                    Z<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" /> = Z[i - 1] + hN<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" />;
                }
                int x, y;
                Byte c;
                for (y = 0; y < bitmap.Height - 1; y++)
                {
                    for (x = 0; x < bitmap.Width - 1; x++)
                    {
                        c = bitmap.GetPixel(x, y).R;
                        c = Convert.ToByte(Math.Round(Z<img src="http://hp-aptech.edu.vn/emoticons/emotion-44.gif" alt="Coffee" /> * 255));
                        bitmap.SetPixel(x, y, Color.FromArgb(c, c, c));
                    }
                } return bitmap;
            }
    Chú ý:
    - Nếu dựa theo công thức tính hàm mật độ xác suất thì cách tính sau có lẽ hay hơn vì rút ngắn thời gian tính toán
    Code:
    //Tinh ham mat do xac Suat
                int[ Z = new int[255];
                Z[0] = hN[0];
                for (int i = 1; i < 255; i++)
                {
                    Z<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" /> = Z[i - 1] + hN<img src="http://hp-aptech.edu.vn/emoticons/emotion-55.gif" alt="Idea" />;
                }
    Kết quả:

    Kết luận về tổ chức đồ:

    - Dựa vào tổ chức đồ ta có thể kết luận về ảnh tương đối chính xác mà từ đó có thể xử lý chúng để được một ảnh tốt hơn.

    - Việc san lấp xảy ra khi căng và trượt không có tác dụng nâng cao chất lượng ảnh.

    - Trên thực tế, việc xử lý không phải lúc nào cũng xảy ra trên toàn bộ ảnh nên việc xử lý toàn cục như trên là không có tác dụng. Vì thế các giải thuật trên các bạn cần sửa lại một cách hợp lý để việc xử lý ảnh có kết quả tốt nhất.

    3. Các phép toán trên ảnh

    3.1 And

    - Ở phần này, các phép toán tuơng đối cơ bản, vì thế các bạn có thể tự code mà cũng chả cần xem code của ai

    - Để minh họa các bạn xem hình dưới đây:

    Ví dụ đơn giản về phép toán AND
    Code:
    for (y = 0; y < bitmap.Height - 1; y++)
                {
                    for (x = 0; x < bitmap.Width - 1; x++)
                    {
      r = bm1.GetPixel(x, y).R && bm2.GetPixel(x, y).R;
          g = bm1.GetPixel(x, y).G && bm2.GetPixel(x, y).G;
           b = bm1.GetPixel(x, y).B && bm2.GetPixel(x, y).B;
           bitmap.SetPixel(x, y, Color.FromArgb(r, g, b));
     }
                  }

  3. #3
    Ngày gia nhập
    08 2010
    Bài viết
    76

    Cảm ơn bạn đã chia sẻ!bài này mình cũng đã đọc qua rồi!!không biết bạn có bài nào hay có cách nào chỉnh độ trong suốt của ảnh hay tài liệu gì về các thuật toán lồng ảnh như texture bên photoshop ko??

  4. #4
    Ngày gia nhập
    04 2009
    Nơi ở
    Gầm cầu
    Bài viết
    2,230

    bạn tham khảo cái này nhé , có chỉnh độ sáng , độ tuơng phản....
    http://www.codeproject.com/KB/GDI-pl...filters11.aspx

  5. #5
    Ngày gia nhập
    08 2010
    Bài viết
    76

    cảm ơn bạn:d.....

  6. #6
    Ngày gia nhập
    08 2008
    Nơi ở
    Hanoi, Vietnam, Vietnam
    Bài viết
    191

    Red face Thuật toán xử lý ảnh trong C#?

    hjjj. Rất cám ơn nha. một bài viết rất chi tiết.
    Đã được chỉnh sửa lần cuối bởi leemanhj916 : 14-09-2010 lúc 03:29 PM.

    Fb-Skype-Mail : leemanhj916 [@gmail.com]

  7. #7
    Ngày gia nhập
    08 2010
    Bài viết
    76

    xin hỏi các bạn quen dùng picture box,Hiện nay mình load ảnh lên picture box nhưng trong trường hợp kích thước của mình lớn hơn kích thước của pb thì mình muốn có thanh scrool bar thì phải làm sao??Mình đã search nhiều bài của các diễn đàn nhưng thấy chung chung quá!Có bạn nào biết rõ về vấn đề này thì giải đáp hộ mình với!

  8. #8
    Ngày gia nhập
    09 2010
    Nơi ở
    Quận 7, HCM
    Bài viết
    1

    có phải vũ trần đạt ko???

  9. #9
    Ngày gia nhập
    03 2010
    Bài viết
    5

    có phải vũ trần đạt ko???

  10. #10
    Ngày gia nhập
    11 2008
    Bài viết
    27

    a. O(x,y)=( IR(x,y) + IG(x,y) + IB(x,y)) /3

    Với:

    x,y là tạo độ của điểm ảnh
    IR thành phân màu đỏ tại màu I(x,y)
    IG thành phân màu xanh lá tại màu I(x,y)
    IB thành phân màu xanh dương tại màu I(x,y)
    O(x,y): mà đầu ra, I(x,y) màu đầu vào

    b. O(x,y)= IR(x,y) * 0.287 + IG(x,y) * 0.599 + IB(x,y) * 0.114

    Làm sao để từ cái công thức a ra công thức b vậy bác ơi.
    http://i454.photobucket.com/albums/qq268/cotragiang/izt1u8.gif

Các đề tài tương tự

  1. Các thuật toán sắp xếp trong lập trình C | Cấu trúc dữ liệu và giải thuật
    Gửi bởi iamvtn trong diễn đàn Thủ thuật, Tutorials CTDL & Giải thuật
    Trả lời: 8
    Bài viết cuối: 11-02-2017, 04:44 PM
  2. Lập trình C++ Thắc mắc về thuật toán trong giao thức thoả thuận khoá Station to station?
    Gửi bởi luongthienaz trong diễn đàn Nhập môn lập trình C/C++
    Trả lời: 1
    Bài viết cuối: 05-12-2012, 09:56 AM
  3. Kỹ thuật in - Vai trò của kỹ thuật in trong thiết kế, in ấn
    Gửi bởi thongthanhhungland trong diễn đàn Giới thiệu website, sản phẩm của bạn
    Trả lời: 0
    Bài viết cuối: 18-11-2011, 01:04 PM
  4. Thuật toán trong C | Cẩm nang thuật toán | "Algorithims In C" của Robert Sedgewick
    Gửi bởi clementboy03 trong diễn đàn Tài liệu, ebooks và công cụ
    Trả lời: 3
    Bài viết cuối: 20-05-2009, 07:50 PM
  5. Trả lời: 6
    Bài viết cuối: 04-05-2008, 08:04 AM

Quyền hạn của bạn

  • Bạn không thể gửi đề tài mới
  • Bạn không thể gửi bài trả lời
  • Bạn không thể gửi các đính kèm
  • Bạn không thể chỉnh sửa bài viết của bạn