Аналоги для GetPixel/SetPixel

            var bmp = pictureBox1.Image as Bitmap;
            for (int i = 0; i < bmp.Width; i++)
            {
                for (int j = 0; j < bmp.Height; j++)
                {
                    if (bmp.GetPixel(i, j) == Color.Blue)
                    {
                        bmp.SetPixel(i, j, Color.Red);
                    }
                    else
                    {
                        bmp.SetPixel(i, j, Color.White);
                    }
                }
            }

// Использование
using ( var bmp = (Bitmap)Image.FromFile( @"i:\0.png" ) ) {
    ImageProcess( bmp );
    bmp.Save( @"i:\some0.png", ImageFormat.Png );
}
 
// Метод обработки
unsafe static void ImageProcess ( Bitmap bmp ) {
    // Только 24 битные изображения
    if ( bmp.PixelFormat != PixelFormat.Format24bppRgb )
        throw new ArgumentException();
 
    var bd = bmp.LockBits(
        new Rectangle( 0, 0, bmp.Width, bmp.Height ),
        ImageLockMode.ReadWrite,
        bmp.PixelFormat
    );
 
    var pStart = (byte*)bd.Scan0;
    var pEnd = (byte*)( pStart + bd.Stride * bd.Height );
 
    while ( pStart != pEnd ) {
        // BGR
        if ( *pStart == 255 && *( pStart + 1 ) == 0 && *( pStart + 2 ) == 0 ) {
            *pStart = *( pStart + 1 ) = 0;
            *( pStart + 2 ) = 255;
        } else {
            *pStart = *( pStart + 1 ) = *( pStart + 2 ) = 255;
        }
 
        pStart += 3;
    }
 
    bmp.UnlockBits( bd );
}

int r = (bmp.GetPixel(i, j).R + bmp.GetPixel(i + 1, j + 1).R + bmp.GetPixel(i + 1, j).R + bmp.GetPixel(i, j + 1).R) / 4;

   public unsafe class UnsafeBitmap
    {
        Bitmap bitmap;
 
  // three elements used for MakeGreyUnsafe
  int width;
  BitmapData bitmapData = null;
  Byte* pBase = null;
 
  public UnsafeBitmap(Bitmap bitmap)
  {
     this.bitmap = new Bitmap(bitmap);
  }
 
        public UnsafeBitmap(int width, int height)
        {
            this.bitmap = new Bitmap(width, height, PixelFormat.Format24bppRgb);
        }
 
  public void Dispose()
  {
     bitmap.Dispose();
  }
 
  public Bitmap Bitmap
  {
     get
     {
    return(bitmap);
     }
  }
 
  private Point PixelSize
  {
     get
     {
    GraphicsUnit unit = GraphicsUnit.Pixel;
    RectangleF bounds = bitmap.GetBounds(ref unit);
 
    return new Point((int) bounds.Width, (int) bounds.Height);
     }
  }
 
  public void LockBitmap()
  {
     GraphicsUnit unit = GraphicsUnit.Pixel;
     RectangleF boundsF = bitmap.GetBounds(ref unit);
     Rectangle bounds = new Rectangle((int) boundsF.X,
    (int) boundsF.Y,
    (int) boundsF.Width,
    (int) boundsF.Height);
 
     // Figure out the number of bytes in a row
     // This is rounded up to be a multiple of 4
     // bytes, since a scan line in an image must always be a multiple of 4 bytes
     // in length. 
     width = (int) boundsF.Width * sizeof(PixelData);
     if (width % 4 != 0)
     {
    width = 4 * (width / 4 + 1);
     }
     bitmapData = 
    bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
 
     pBase = (Byte*) bitmapData.Scan0.ToPointer();
  }
 
  public PixelData GetPixel(int x, int y)
  {
            PixelData returnValue = *PixelAt(x, y);
     return returnValue;
  }
 
        public void SetPixel(int x, int y, PixelData colour)
        {
            PixelData* pixel = PixelAt(x, y);
            *pixel = colour;
        }
 
  public void UnlockBitmap()
  {
     bitmap.UnlockBits(bitmapData);
     bitmapData = null;
     pBase = null;
  }
        public PixelData* PixelAt(int x, int y)
        {
            return (PixelData*)(pBase + y * width + x * sizeof(PixelData));
        }
    }
    public struct PixelData
    {
        public byte blue;
        public byte green;
        public byte red;
    }

public Form1 ( ) {
    InitializeComponent();
 
    using ( var bmp = (Bitmap)Image.FromFile( @"i:\0.png" ) ) {
        var bb = new BufferedBitmap( bmp );
        var clr = Color.Empty;
 
        for ( int y = 0; y < bb.Height; ++y )
            for ( int x = 0; x < bb.Width; ++x ) {
                clr = bb.GetPixel( x, y );
                if ( clr.R == 0 && clr.G == 0 && clr.B == 128 )
                    bb.SetPixel( x, y, Color.FromArgb( 127, 255, 0, 0 ) );
                else
                    bb.SetPixel( x, y, Color.White );
            }
 
        bb.Unlock();
        bmp.Save( @"i:\some0.png", ImageFormat.Png );
    }
}
 
unsafe class BufferedBitmap
{
    Bitmap _bmp;
    BitmapData _bd;
    bool _locked;
    byte *pStart;
 
    public BufferedBitmap ( Bitmap bmp, bool @lock ) {
        _bmp = bmp;
 
        if ( @lock )
            Lock();
    }
 
    public BufferedBitmap ( Bitmap bmp )
        : this( bmp, true ) {
 
    }
 
    public void Lock ( ) {
        if ( !_locked ) {
            _bd = _bmp.LockBits(
                new Rectangle( 0, 0, _bmp.Width, _bmp.Height ),
                ImageLockMode.ReadWrite,
                _bmp.PixelFormat
            );
 
            pStart = (byte*)_bd.Scan0;
            _locked = true;
        }
    }
 
    public void Unlock ( ) {
        if ( !_locked )
            return;
 
        _bmp.UnlockBits( _bd );
 
        _locked = false;
    }
 
    public Bitmap Bitmap {
        get {
            return ( _locked ? null : _bmp );
        }
        set {
            if ( _locked )
                throw new Exception( "Image locked!" );
            if ( value == null )
                throw new NullReferenceException();
 
            _bmp = value;
        }
    }
 
    public int Width {
        get {
            return _bmp.Width;
        }
    }
 
    public int Height {
        get {
            return _bmp.Height;
        }
    }
 
    public void SetPixel ( int x, int y, Color clr ) {
        if ( !_locked )
            throw new Exception();
 
        switch ( _bd.PixelFormat ) {
        case PixelFormat.Format24bppRgb:
            SetPixel24( x, y, clr );
            break;
        case PixelFormat.Format32bppArgb:
            SetPixel32( x, y, clr );
            break;
        }
    }
 
    void SetPixel24 ( int x, int y, Color clr ) {
        var pMem = pStart + x * 3 + y * _bd.Stride;
 
        *pMem = clr.B;
        *( pMem + 1 ) = clr.G;
        *( pMem + 2 ) = clr.R;
    }
 
    void SetPixel32 ( int x, int y, Color clr ) {
        var pMem = pStart + x * 4 + y * _bd.Stride;
 
        *pMem = clr.B;
        *( pMem + 1 ) = clr.G;
        *( pMem + 2 ) = clr.R;
        *( pMem + 3 ) = clr.A;
    }
 
    public Color GetPixel ( int x, int y ) {
        if ( !_locked )
            throw new Exception();
 
        switch ( _bd.PixelFormat ) {
        case PixelFormat.Format24bppRgb:
            return GetPixel24( x, y );
        case PixelFormat.Format32bppArgb:
            return GetPixel32( x, y );
        default:
            throw new NotImplementedException();
        }
    }
 
    Color GetPixel24 ( int x, int y ) {
        var pMem = pStart + x * 3 + y * _bd.Stride;
 
        return Color.FromArgb(
            *( pMem + 2 ),
            *( pMem + 1 ),
            *pMem
        );
    }
 
    Color GetPixel32 ( int x, int y ) {
        var pMem = pStart + x * 4 + y * _bd.Stride;
 
        return Color.FromArgb(
            *( pMem + 3 ),
            *( pMem + 2 ),
            *( pMem + 1 ),
            *pMem
        );
    }
 
    public bool IsLocked {
        get {
            return _locked;
        }
    }
}

using System;
using System.Drawing;
using System.Drawing.Imaging;
 
namespace Helpers
{
    public static class BitmapHelper
    {
        struct Pixel : IEquatable<Pixel>
        {
            
// ReSharper disable UnassignedField.Compiler
            public byte Blue;
            public byte Green;
            public byte Red;
 
            public bool Equals(Pixel other)
            {
                return Red == other.Red && Green == other.Green && Blue == other.Blue;
            }
        }
 
        public static Color[,] GetPixels(this Bitmap bmp)
        {
            return ProcessBitmap(bmp, pixel => Color.FromArgb(pixel.Red, pixel.Green, pixel.Blue));
        }
 
        public static float[,] GetBrightness(this Bitmap bmp)
        {
            return ProcessBitmap(bmp, pixel => Color.FromArgb(pixel.Red, pixel.Green, pixel.Blue).GetBrightness());
        }
 
        public static unsafe T[,] ProcessBitmap<T>(this Bitmap bitmap, Func<Pixel, T> func)
        {
            var lockBits = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly,
                                       bitmap.PixelFormat);
            int padding = lockBits.Stride - (bitmap.Width*sizeof (Pixel));
 
            int width = bitmap.Width;
            int height = bitmap.Height;
 
            var result = new T[height, width];
 
            var ptr = (byte*) lockBits.Scan0;
 
            for (int i = 0; i < height; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    var pixel = (Pixel*) ptr;
                    result[i, j] = func(*pixel);
                    ptr += sizeof (Pixel);
                }
                ptr += padding;
            }
 
            bitmap.UnlockBits(lockBits);
 
            return result;
        }
    }
}

Application.Run(new MainForm());

        void Button1Click(object sender, EventArgs e)
        {
            Image img;
            using ( var bmp = (Bitmap)SreenShot())
            {
                var bb = new BufferedBitmap( bmp );
                var clr = Color.Empty;
                for ( int y = 0; y < bb.Height; ++y )
                    for ( int x = 0; x < bb.Width; ++x )
                {
                    clr = bb.GetPixel( x, y );
                    if ( clr.R == 0 && clr.G == 0 && clr.B == 128 )
                        bb.SetPixel( x, y, Color.FromArgb( 127, 255, 0, 0 ) );
                    else
                        bb.SetPixel( x, y, Color.Blue );
                }
                bb.Unlock();
                bmp.Save( @"some0.png", ImageFormat.Png );
                img = (Image)bmp;
            }
            pictureBox1.BackgroundImage = img;          
        }       
        public Image SreenShot()
        {
            Graphics gr;
            Bitmap bmp = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height,
                                    PixelFormat.Format32bppRgb);
            gr = Graphics.FromImage(bmp);
            gr.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y,
                              0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
            Image img = (Image)bmp;
            return img;
        }

var rand = new Random();
            
            var massive = new int [1600,900];
            var bmp = new Bitmap(900,1600);
            var Draw = new FastBitmap(bmp);
            for (int i = 0; i < 1600; i++) 
            {
                for (int j = 0; j < 900; j++)
                {
                    massive[i,j]= 255;
                }
            }
           int maxvalue = massive.Cast<int>().Max();
           
        for (int i = 0; i < 1600; i++) 
            {
                for (int j = 0; j < 900; j++)
                {
                    Draw.SetColor(j,i, Color.FromArgb((int)(massive[i,j]*255/maxvalue),(int)(massive[i,j]*255/maxvalue),(int)(massive[i,j]*255/maxvalue)));
                }
            }
        pictureBox1.Image=bmp;