C#

Doof369 wrote:

I am having difficulty in keeping the alpha channels in my images when I open them into a c# pictureBox.

Doof369 wrote:

I gather that a pictureBox doesn't actually keep the alpha channel

Doof369 wrote:

I need to store the info in memory and work on the data there, pre-multiplying the alpha channels and doing any other calculations I need to with the raw data and then display the result when all is done.

Doof369 wrote:

Basically what I want to do is take two images, both with an alpha layer in them. Overlay the second one onto the first one, using its alpha layer for transparency, and finally save out a new 32bpp image from the result.

public static void ArgbOverlay(Bitmap bm2, Bitmap bm1, out Bitmap bm3)
        {
            //Create Manipulation Arrays
            int[,] a1 = new int[bm1.Width, bm1.Height];
            int[,] a2 = new int[bm2.Width, bm2.Height];
            int[,] a3 = new int[bm2.Width, bm2.Height];

            int[,] r1 = new int[bm1.Width, bm1.Height];
            int[,] r2 = new int[bm2.Width, bm2.Height];
            int[,] r3 = new int[bm2.Width, bm2.Height];

            int[,] g1 = new int[bm1.Width, bm1.Height];
            int[,] g2 = new int[bm2.Width, bm2.Height];
            int[,] g3 = new int[bm2.Width, bm2.Height];

            int[,] b1 = new int[bm1.Width, bm1.Height];
            int[,] b2 = new int[bm2.Width, bm2.Height];
            int[,] b3 = new int[bm2.Width, bm2.Height];


            //Copy Images into arrays
            Rectangle rect1 = new Rectangle(0, 0, bm1.Width, bm1.Height);
            BitmapData bd1 = bm1.LockBits(rect1, ImageLockMode.ReadWrite, bm1.PixelFormat);
            int bytes1 = bd1.Stride * bd1.Height;
            byte[] argbValues1 = new byte[bytes1];
            IntPtr ptr1 = bd1.Scan0;
            Marshal.Copy(ptr1, argbValues1, 0, bytes1);

            Rectangle rect2 = new Rectangle(0, 0, bm2.Width, bm2.Height);
            BitmapData bd2 = bm2.LockBits(rect2, ImageLockMode.ReadWrite, bm2.PixelFormat);
            int bytes2 = bd2.Stride * bd2.Height;
            byte[] argbValues2 = new byte[bytes2];
            IntPtr ptr2 = bd2.Scan0;
            Marshal.Copy(ptr2, argbValues2, 0, bytes2);

            //Create Array for result
            // Create the bitmap
            bm3 = new Bitmap(bm1.Width, bm1.Height, PixelFormat.Format32bppArgb);
            // Create a byte array to match the bitmap
            Rectangle rect3 = new Rectangle(0, 0, bm3.Width, bm3.Height);
            BitmapData bd3 = bm3.LockBits(rect3, ImageLockMode.ReadWrite, bm3.PixelFormat);
            int bytes3 = bd3.Stride * bd3.Height;  // not bm.Width * bm.Height * 3;  
            byte[] argbValues3 = new byte[bytes3];


            //Separate a, r, g & b components
            for (int x = 0; x < bm1.Width; x++)
            {
                for (int y = 0; y < bm1.Height; y++)
                {
                    int BitPos1 = (x * 4) + (y * bd1.Stride);
                    b1[x, y] = (int)argbValues1[BitPos1];
                    g1[x, y] = (int)argbValues1[BitPos1 + 1];
                    r1[x, y] = (int)argbValues1[BitPos1 + 2];
                    a1[x, y] = (int)argbValues1[BitPos1 + 3];

                    b2[x, y] = (int)argbValues2[BitPos1];
                    g2[x, y] = (int)argbValues2[BitPos1 + 1];
                    r2[x, y] = (int)argbValues2[BitPos1 + 2];
                    a2[x, y] = (int)argbValues2[BitPos1 + 3];


                    //Test Transform (Overlay 2nd bitmap over the 1st using alpha layer)
                    r3[x, y] = (r2[x, y] * a2[x, y]) / 256 + ((r1[x, y] * (256 - a2[x, y])) / 256);
                    g3[x, y] = (g2[x, y] * a2[x, y]) / 256 + ((g1[x, y] * (256 - a2[x, y])) / 256);
                    b3[x, y] = (b2[x, y] * a2[x, y]) / 256 + ((b1[x, y] * (256 - a2[x, y])) / 256);

                    if (a1[x, y] < a2[x, y])
                    {
                        a3[x, y] = a2[x, y];
                    }
                    else
                    {
                        a3[x, y] = a1[x, y];
                    }


                    argbValues3[BitPos1] = (byte)b3[x, y];
                    argbValues3[BitPos1 + 1] = (byte)g3[x, y];
                    argbValues3[BitPos1 + 2] = (byte)r3[x, y];
                    argbValues3[BitPos1 + 3] = (byte)a3[x, y];
                }
            }


            // Copy the resulting byte array into the bitmap and unlock it
            IntPtr ptr3 = bd3.Scan0;
            Marshal.Copy(argbValues3, 0, ptr3, bytes3);
            bm3.UnlockBits(bd3);

            return;
        }

// Form1.cs
using System;
using System.Windows.Forms;
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
        Shown += new EventHandler(Form1_Shown);
    }
    void Form1_Shown(object sender, EventArgs e)
    {
        Form2 form2 = new Form2();
        form2.TextUpdated += new EventHandler<TextUpdatedEventArgs>(form2_TextUpdated);
        form2.Show();
    }
    void form2_TextUpdated(object sender, TextUpdatedEventArgs e)
    {
        // Do your thing here
        Console.WriteLine(e.Text);
    }
}

// Form2.cs
using System;
using System.Windows.Forms;
public partial class Form2 : Form
{
    public event EventHandler<TextUpdatedEventArgs> TextUpdated;
    public Form2()
    {
        InitializeComponent();
    }
    private void textBox1_TextChanged(object sender, EventArgs e)
    {
        OnTextUpdated(new TextUpdatedEventArgs(textBox1.Text));
    }
    protected virtual void OnTextUpdated(TextUpdatedEventArgs e)
    {
        EventHandler<TextUpdatedEventArgs> eh = TextUpdated;
        if (eh != null)
            eh(this, e);
    }
}

// TextUpdatedEventArgs.cs
using System;
public class TextUpdatedEventArgs : EventArgs
{
    private string m_Text;
    public TextUpdatedEventArgs(string text)
    {
        m_Text = text;
    }
    public string Text
    {
        get { return m_Text; }
    }
}