How to convert an rgb image to yuv using c#

Question

They gave this homework for school. I've been searching for two days but couldn't find it. In my application, The image selected from the computer should be converted from rgb to yuv and converted to gray color.

I did the conversion to yuv below, but there are 2 more missing, so I couldn't convert to double, so I made an int. The color is not grey.

private void btn_piksel_Click(object sender, EventArgs e) { if (pct_goruntu.Image == null) return;

    Bitmap goruntu = (Bitmap)pct_goruntu.Image;
    Color ilkPiksel = goruntu.GetPixel(0, 0);

    int genislik = goruntu.Width;
    int yukseklik = goruntu.Height;                     

    Bitmap yeniGoruntu = new Bitmap(genislik, yukseklik);

    for (int sutun = 0; sutun < genislik; sutun++)
    {
        for (int satir = 0; satir < yukseklik; satir++)
        {
            Color piksel = goruntu.GetPixel(sutun, satir);

            double Y = (0.257 * piksel.R) + (0.504 * piksel.G) + (0.098 * piksel.B) + 16;
            double U = (-0.148 * piksel.R) + (-0.291 * piksel.G) + (0.439 * piksel.B) + 128;
            double V = (0.439 * piksel.R) + (-0.368 * piksel.G) + (-0.071 * piksel.B) + 128;

            Color hedefPiksel = Color.FromArgb(piksel.A, (int)Y, (int)U, (int)V);

            yeniGoruntu.SetPixel(sutun, satir, hedefPiksel);
        }
    }

    pct_hedef.Image = yeniGoruntu;

    lbl_kirmizi.Text = "R: " + ilkPiksel.R.ToString();
    lbl_yesil.Text = "G: " + ilkPiksel.B.ToString();
    lbl_mavi.Text = "B: " + ilkPiksel.G.ToString();
}`

Answer 1

If you want the output to be a grayscale image you are only interested in the Luma (Y) component. So you should just use this for all the RGB color channels:

 Color.FromArgb(piksel.A, (int)Y, (int)Y, (int)Y);

Note that the U and V components are not used, so could be omitted. See also converting a color image to grayscale, and fast work with bitmap

Answer 2

If you want to convert an RGB image to YUV, you can refer to the following code:

public struct RGB
{
    private byte _r;
    private byte _g;
    private byte _b;
    public RGB(byte r, byte g, byte b)
    {
        this._r = r;
        this._g = g;
        this._b = b;
    }
    public byte R
    {
        get { return this._r; }
        set { this._r = value; }
    }
    public byte G
    {
        get { return this._g; }
        set { this._g = value; }
    }
    public byte B
    {
        get { return this._b; }
        set { this._b = value; }
    }
    public bool Equals(RGB rgb)
    {
        return (this.R == rgb.R) && (this.G == rgb.G) && (this.B == rgb.B);
    }
}

public struct YUV
{ 
    private double _y;
    private double _u;
    private double _v;
    public YUV(double y, double u, double v)
    {
        this._y = y;
        this._u = u;
        this._v = v;
    }
    public double Y
    {
        get { return this._y; }
        set { this._y = value; }
    }
    public double U
    {
        get { return this._u; }
        set { this._u = value; }
    }
    public double V
    {
        get { return this._v; }
        set { this._v = value; }
    }
    public bool Equals(YUV yuv)
    {
        return (this.Y == yuv.Y) && (this.U == yuv.U) && (this.V == yuv.V);
    }
}
public static YUV RGBToYUV(RGB rgb)
{
    double y = rgb.R * .299000 + rgb.G * .587000 + rgb.B * .114000;
    double u = rgb.R * -.168736 + rgb.G * -.331264 + rgb.B * .500000 + 128;
    double v = rgb.R * .500000 + rgb.G * -.418688 + rgb.B * -.081312 + 128;
    return new YUV(y, u, v);
}

See this.

Answer 3

You can use ColorHelper library for this:

using ColorHelper;

RGB rgb = new RGB(200, 200, 200);
YUV yuv = ColorConverter.RgbToYuv(rgb);

Links:

• Github
• Nuget