/// <summary>
        /// Implements the operator |.
        /// </summary>
        /// <param name="Image1">The first image.</param>
        /// <param name="Image2">The second image</param>
        /// <returns>The result of the operator.</returns>
        public static SwiftBitmap operator |(SwiftBitmap Image1, SwiftBitmap Image2)
        {
            Contract.Requires <ArgumentNullException>(Image1 != null, "Image1");
            Contract.Requires <ArgumentNullException>(Image2 != null, "Image2");
            Image1.Lock();
            Image2.Lock();
            var Result = new SwiftBitmap(Image1.Width, Image1.Height);

            Result.Lock();
            Parallel.For(0, Result.Width, x =>
            {
                for (int y = 0; y < Result.Height; ++y)
                {
                    var Pixel1 = Image1.GetPixel(x, y);
                    var Pixel2 = Image2.GetPixel(x, y);
                    Result.SetPixel(x, y,
                                    Color.FromArgb(Pixel1.R | Pixel2.R,
                                                   Pixel1.G | Pixel2.G,
                                                   Pixel1.B | Pixel2.B));
                }
            });
            Image2.Unlock();
            Image1.Unlock();
            return(Result.Unlock());
        }
 /// <summary>
 /// Loads an image
 /// </summary>
 /// <param name="ImageUsing">Image to load</param>
 public virtual void LoadImage(SwiftBitmap ImageUsing)
 {
     Contract.Requires <ArgumentNullException>(ImageUsing != null, "ImageUsing");
     Width  = ImageUsing.Width;
     Height = ImageUsing.Height;
     ImageUsing.Lock();
     R.Clear();
     G.Clear();
     B.Clear();
     for (int x = 0; x < ImageUsing.Width; ++x)
     {
         for (int y = 0; y < ImageUsing.Height; ++y)
         {
             var TempColor = ImageUsing.GetPixel(x, y);
             ++R[(int)TempColor.R];
             ++G[(int)TempColor.G];
             ++B[(int)TempColor.B];
         }
     }
     ImageUsing.Unlock();
 }
 /// <summary>
 /// Applies the convolution filter to the image
 /// </summary>
 /// <param name="filter">The filter.</param>
 /// <param name="absolute">if set to <c>true</c> then the absolute value is used</param>
 /// <param name="offset">The offset to use for each pixel</param>
 /// <returns>Returns the image with the filter applied</returns>
 public SwiftBitmap ApplyConvolutionFilter(int[][] filter, bool absolute = false, int offset = 0)
 {
     Contract.Requires <NullReferenceException>(InternalBitmap != null);
     using (SwiftBitmap Result = new SwiftBitmap(Width, Height))
     {
         Lock();
         Result.Lock();
         Parallel.For(0, Width, x =>
         {
             for (int y = 0; y < Height; ++y)
             {
                 int RValue   = 0;
                 int GValue   = 0;
                 int BValue   = 0;
                 int Weight   = 0;
                 int XCurrent = -filter[0].Length / 2;
                 for (int x2 = 0; x2 < filter[0].Length; ++x2)
                 {
                     if (XCurrent + x < Width && XCurrent + x >= 0)
                     {
                         int YCurrent = -filter.Length / 2;
                         for (int y2 = 0; y2 < filter.Length; ++y2)
                         {
                             if (YCurrent + y < Height && YCurrent + y >= 0)
                             {
                                 var Pixel = GetPixel(XCurrent + x, YCurrent + y);
                                 RValue   += filter[x2][y2] * Pixel.R;
                                 GValue   += filter[x2][y2] * Pixel.G;
                                 BValue   += filter[x2][y2] * Pixel.B;
                                 Weight   += filter[x2][y2];
                             }
                             ++YCurrent;
                         }
                     }
                     ++XCurrent;
                 }
                 var MeanPixel = GetPixel(x, y);
                 if (Weight == 0)
                 {
                     Weight = 1;
                 }
                 if (Weight > 0)
                 {
                     if (absolute)
                     {
                         RValue = System.Math.Abs(RValue);
                         GValue = System.Math.Abs(GValue);
                         BValue = System.Math.Abs(BValue);
                     }
                     RValue    = (RValue / Weight) + offset;
                     RValue    = RValue.Clamp(255, 0);
                     GValue    = (GValue / Weight) + offset;
                     GValue    = GValue.Clamp(255, 0);
                     BValue    = (BValue / Weight) + offset;
                     BValue    = BValue.Clamp(255, 0);
                     MeanPixel = Color.FromArgb(RValue, GValue, BValue);
                 }
                 Result.SetPixel(x, y, MeanPixel);
             }
         });
         Unlock();
         Result.Unlock();
         return(Copy(Result));
     }
 }