C# WriteableBitmap.Clone方法代码示例

 public static WriteableBitmap Overlay(WriteableBitmap bmp, WriteableBitmap overlay, Point location)
 {
     var result = bmp.Clone();
     var size = new Size(overlay.PixelWidth, overlay.PixelHeight);
     result.Blit(new Rect(location, size), overlay, new Rect(new Point(0, 0), size), WriteableBitmapExtensions.BlendMode.Alpha);
     return result;
 }

        /// <summary>
        /// Applies a watermark bitmap and returns a new processed WriteabelBitmap.
        /// </summary>
        /// <param name="input">The input bitmap.</param>
        /// <returns>The result WriteableBitmap with the watermark.</returns>
        public WriteableBitmap Apply(WriteableBitmap input)
        {
            // Resize watermark
            var w = Watermark.PixelWidth;
            var h = Watermark.PixelHeight;
            var ratio = (float)w / h;
            if (ratio > 1)
            {
                w = (int)(input.PixelWidth * RelativeSize);
                h = (int)(w / ratio);
            }
            else
            {
                h = (int)(input.PixelHeight * RelativeSize);
                w = (int)(h * ratio);
            }
            var watermark = Watermark.Resize(w, h, WriteableBitmapExtensions.Interpolation.Bilinear);

            // Blit watermark into copy of the input
            // Bottom right corner
            var result = input.Clone();
            var position = new Rect(input.PixelWidth - w, input.PixelHeight - h, w, h);
            result.Blit(position, watermark, new Rect(0, 0, w, h));

            return result;
        }

 public Image(WriteableBitmap img)
 {
     this.image = img.Clone();
     formatName = "jpg";
     width = img.PixelWidth;
     height = img.PixelHeight;
     //img.Dispatcher.BeginInvoke(() =>
        // {
         destImage = new WriteableBitmap(width, height);
     //});
     updateColorArray();
 }

        public Octree(WriteableBitmap wbm)
        {
            LoadedBitmap = wbm.Clone();

            InitializeAllLevelsArray();
            GenerateOctreeForBitmap(wbm);

            if(Root != null)
            {
                Root.Parent = null;
            }
        }

        /// <summary>
        /// 画像に遺影を重ねます。
        /// </summary>
        /// <param name="bitmap"></param>
        /// <returns></returns>
        private WriteableBitmap ApplyYey(WriteableBitmap bitmap)
        {
            var wb = bitmap.Clone();
            var file = Application.GetResourceStream(new Uri("photoframe.png", UriKind.Relative));

            var yey = new WriteableBitmap(wb.PixelWidth, wb.PixelHeight);
            yey.LoadJpeg(file.Stream);

            for (int i = 0; i < yey.Pixels.Length; i++)
            {
                var oPx = yey.Pixels[i];
                var a2 = Convert.ToByte((oPx >> 24) & 0xff);
                var ax2 = (double)a2 / 255;

                if (a2 == 0)
                {
                    // 透明なので下地を描画
                }
                else if (a2 == 255)
                {
                    // 不透明なので上に書き込み
                    wb.Pixels[i] = yey.Pixels[i];
                }
                else
                {
                    // 下地の画像の色を取り出す
                    var a = Convert.ToByte((wb.Pixels[i] >> 24) & 0xff);
                    var r = Convert.ToByte((wb.Pixels[i] >> 16) & 0xff);
                    var g = Convert.ToByte((wb.Pixels[i] >> 8) & 0xff);
                    var b = Convert.ToByte((wb.Pixels[i]) & 0xff);
                    // 枠の色を取り出す
                    var r2 = Convert.ToByte((oPx >> 16) & 0xff);
                    var g2 = Convert.ToByte((oPx >> 8) & 0xff);
                    var b2 = Convert.ToByte((oPx) & 0xff);

                    // アルファ値を元に合成
                    var a3 = Convert.ToByte((a * (1.0 - ax2) + a2 * ax2));
                    var r3 = Convert.ToByte((r * (1.0 - ax2) + r2 * ax2));
                    var g3 = Convert.ToByte((g * (1.0 - ax2) + g2 * ax2));
                    var b3 = Convert.ToByte((b * (1.0 - ax2) + b2 * ax2));

                    wb.Pixels[i] = a3 << 24 | r3 << 16 | g3 << 8 | b3;
                }
            }

            wb.Invalidate();
            return wb;
        }

        public void LoadImage(WriteableBitmap bitmap, Action<WriteableBitmap, short, short> drawer)
        {
            Image.Source = bitmap;
            MinSlider.ValueChanged += (o, e) =>
            {
                drawer(bitmap, (short)MinSlider.Value, (short)MaxSlider.Value);
            };
            MaxSlider.ValueChanged += (o, e) =>
            {
                drawer(bitmap, (short)MinSlider.Value, (short)MaxSlider.Value);
            };
            drawer(bitmap, (short)MinSlider.Value, (short)MaxSlider.Value);
            SaveRangeButton.Click += (o, e) =>
            {
                SaveFileDialog sfd = new SaveFileDialog();
                sfd.AddExtension = true;
                sfd.FileName = DateTime.Now.ToString("ddMMyyhhmm");
                sfd.DefaultExt = "png";
                sfd.Filter = "Image files (*.png)|*.png";
                if (sfd.ShowDialog() == true)
                {
                    for (short i = 1000; i <= 18000; i += 500)
                    {
                        var clone = bitmap.Clone();
                        short from = (short)(i - 1000);
                        short to = i;
                        drawer(clone, from, to);
                        using (FileStream stream5 = new FileStream(System.IO.Path.GetDirectoryName(sfd.FileName) + "\\" + System.IO.Path.GetFileNameWithoutExtension(sfd.FileName) + string.Format("{0}-{1}", from, to) + ".png", FileMode.Create))
                        {
                            PngBitmapEncoder encoder5 = new PngBitmapEncoder();
                            encoder5.Frames.Add(BitmapFrame.Create(clone));
                            encoder5.Save(stream5);
                            stream5.Close();
                        }
                    }

                }
            };
        }

        /// <summary>
        /// 画像をグレースケールにします。
        /// </summary>
        /// <param name="bitmap"></param>
        /// <returns></returns>
        private WriteableBitmap Grayscare(WriteableBitmap bitmap)
        {
            var edit = bitmap.Clone();

            edit.ToGrayScale();

            return edit;

            //using (var s = PictureExtension.PhotoStreamToMemoryStream(bitmap))
            //{
            //    var size = PictureExtension.GetOriginalSize(s);
            //    WriteableBitmap edit = null;

            //    this.originBitmap = new WriteableBitmap((int)size.Width, (int)size.Height);
            //    edit = new WriteableBitmap((int)size.Width, (int)size.Height);

            //    // WriteableBitmapに画像を読み込ませる
            //    s.Seek(0, SeekOrigin.Begin);
            //    this.originBitmap.LoadJpeg(s);
            //    // editableの方にも同じのをコピー
            //    edit = this.originBitmap.Clone();

            //    // グレスケ化
            //    edit = this.originBitmap.ToGrayScale();

            //    return edit;
            //}
        }

        public static WriteableBitmap UniformQuantization(WriteableBitmap wbm, byte nR, byte nG, byte nB)
        {
            var result = wbm.Clone();

            unsafe
            {
                using (var context = result.GetBitmapContext())
                {
                    for (int i = 0; i < wbm.PixelWidth; i++)
                    {
                        for (int j = 0; j < wbm.PixelHeight; j++)
                        {
                            var c = context.Pixels[j * context.Width + i];
                            byte a = (byte)(c >> 24);

                            // Prevent division by zero
                            int ai = a;
                            if (ai == 0)
                            {
                                ai = 1;
                            }

                            ai = ((255 << 8) / ai);

                            var color = Color.FromArgb(
                                a,
                                (byte)((((c >> 16) & 0xFF) * ai) >> 8),
                                (byte)((((c >> 8) & 0xFF) * ai) >> 8),
                                (byte)((((c & 0xFF) * ai) >> 8)));

                            var r = ReducePixelUq(nR, color.R);
                            var g = ReducePixelUq(nG, color.G);
                            var b = ReducePixelUq(nB, color.B);

                            context.Pixels[j * context.Width + i] = (a << 24) | (r << 16) | (g << 8) | b;
                        }
                    }
                }

                return result;
            }
        }

        public static WriteableBitmap PopularityAlgorithm(WriteableBitmap wbm, int k)
        {
            var clone = wbm.Clone();

            unsafe
            {
                using (var context = clone.GetBitmapContext())
                {
                    var colorsArray = GetMostPopularColors(context, k).ToArray();

                    if (colorsArray != null)
                    {
                        for (int i = 0; i < context.Width; i++)
                        {
                            for (int j = 0; j < context.Height; j++)
                            {
                                var c = context.Pixels[j * context.Width + i];
                                var a = (byte)(c >> 24);

                                int ai = a;
                                if (ai == 0)
                                {
                                    ai = 1;
                                }

                                ai = ((255 << 8) / ai);
                                var color = Color.FromArgb(a,
                                    (byte)((((c >> 16) & 0xFF) * ai) >> 8),
                                    (byte)((((c >> 8) & 0xFF) * ai) >> 8),
                                    (byte)((((c & 0xFF) * ai) >> 8)));

                                var closestColor = GetTheClosestPixel(color, colorsArray);

                                context.Pixels[j * context.Width + i] = (255 << 24) | (closestColor.R << 16) | (closestColor.G << 8) | closestColor.B;
                            }
                        }
                    }
                }

                return clone;
            }
        }

        public static WriteableBitmap OctreeAlgorithm(WriteableBitmap wbm, int k)
        {
            var clone = wbm.Clone();

            Octree o = new Octree(clone);

            return o.GenerateBitmapFromOctree(k);
        }

 private void RenderWorldFinish(WriteableBitmap img)
 {
     if (img != null) WorldImage.Image = img.Clone();
     RaisePropertyChanged("WorldZoomedHeight");
     RaisePropertyChanged("WorldZoomedWidth");
     CommandManager.InvalidateRequerySuggested();
 }

        /// <summary>
        /// Takes a bitmap whites out all the pixels of a color not of the given color
        /// </summary>
        /// <param name="bitmap">The bitmap to start with</param>
        /// <param name="color">The color to keep</param>
        /// <returns>A bitmap that only has the given color remaining</returns>
        public static WriteableBitmap EraseAllButCertainColor( WriteableBitmap bitmap, Color color )
        {
            int stride = ( bitmap.PixelWidth * bitmap.Format.BitsPerPixel + 7 ) / 8;

             byte[] pixelByteArray = new byte[bitmap.PixelHeight * stride];
             byte[] newPixelByteArray = new byte[bitmap.PixelHeight * stride];
             bitmap.CopyPixels( pixelByteArray, stride, 0 );

             for ( int i = 0; i < bitmap.PixelWidth; i++ )
             {
            for ( int j = 0; j < bitmap.PixelHeight; j++ )
            {
               int index = j * stride + 4 * i;
               if ( GetPixelColor( pixelByteArray, index ) != color )
               {
                  newPixelByteArray[index] = 255;
                  newPixelByteArray[index + 1] = 255;
                  newPixelByteArray[index + 2] = 255;
               }
               else
               {
                  newPixelByteArray[index] = color.B;
                  newPixelByteArray[index + 1] = color.G;
                  newPixelByteArray[index + 2] = color.R;
               }
            }
             }
             var newBitmap = bitmap.Clone();
             newBitmap.WritePixels( new Int32Rect( 0, 0, bitmap.PixelWidth, bitmap.PixelHeight ), newPixelByteArray, stride, 0 );

             return newBitmap;
        }

 public WriteableBitmap Apply(WriteableBitmap input)
 {
     int width = this.Watermark.PixelWidth;
     int height = this.Watermark.PixelHeight;
     float num3 = ((float)width) / ((float)height);
     if (num3 > 1f)
     {
         width = (int)(input.PixelWidth * this.RelativeSize);
         height = (int)(((float)width) / num3);
     }
     else
     {
         height = (int)(input.PixelHeight * this.RelativeSize);
         width = (int)(height * num3);
     }
     WriteableBitmap source = this.Watermark.Resize(width, height, WriteableBitmapExtensions.Interpolation.Bilinear);
     WriteableBitmap bmp = input.Clone();
     Rect destRect = new Rect((double)(input.PixelWidth - width), (double)(input.PixelHeight - height), (double)width, (double)height);
     bmp.Blit(destRect, source, new Rect(0.0, 0.0, (double)width, (double)height));
     return bmp;
 }

        /// <summary>
        /// Returns a copy of the given bitmap eroded by 1 pixel
        /// </summary>
        /// <param name="bitmap">The bitmap to be eroded</param>
        /// <returns>The eroded bitmap</returns>
        public static WriteableBitmap GetErodedBitmap( WriteableBitmap bitmap )
        {
            int stride = ( bitmap.PixelWidth * bitmap.Format.BitsPerPixel + 7 ) / 8;

             byte[] pixelArray = new byte[bitmap.PixelHeight * stride];
             byte[] newPixelArray = new byte[bitmap.PixelHeight * stride];
             bitmap.CopyPixels( pixelArray, stride, 0 );

             for ( int column = 0; column < bitmap.PixelWidth; column++ )
             {
            for ( int row = 0; row < bitmap.PixelHeight; row++ )
            {
               int index = row * stride + 4 * column;

               // If we are on the boundry just put white in the new image
               if ( column == 0 || row == 0 || column == bitmap.PixelWidth - 1 || row == bitmap.PixelHeight - 1 )
               {
                  newPixelArray[index] = 255;
                  newPixelArray[index + 1] = 255;
                  newPixelArray[index + 2] = 255;
                  continue;
               }

               var currentPixel = Pixel.GetPixel( pixelArray, index );
               var topPixel = Pixel.GetPixel( pixelArray, index - stride );
               var leftPixel = Pixel.GetPixel( pixelArray, index - 4 );
               var rightPixel = Pixel.GetPixel( pixelArray, index + 4 );
               var bottomPixel = Pixel.GetPixel( pixelArray, index + stride );

               // If the current pixel and all of its neighbored pixels are colored (not white), the new pixel is black
               if ( topPixel.Color != Colors.White &&
                    leftPixel.Color != Colors.White &&
                    rightPixel.Color != Colors.White &&
                    bottomPixel.Color != Colors.White &&
                    currentPixel.Color != Colors.White )
               {
                  newPixelArray[index] = 0;
                  newPixelArray[index + 1] = 0;
                  newPixelArray[index + 2] = 0;
               }
               else
               {
                  // Otherwise we make the pixel white
                  newPixelArray[index] = 255;
                  newPixelArray[index + 1] = 255;
                  newPixelArray[index + 2] = 255;
               }
            }
             }
             var erodedBitmap = bitmap.Clone();
             erodedBitmap.WritePixels( new Int32Rect( 0, 0, bitmap.PixelWidth, bitmap.PixelHeight ), newPixelArray, stride, 0 );

             return erodedBitmap;
        }

        /// <summary>
        /// Calculates the differences between the two bitmap and returns a bitmap where those differences
        /// are black and the rest of the bitmap is white
        /// </summary>
        /// <param name="firstBitmap">The first bitmap to compare</param>
        /// <param name="secondBitmap">The second bitmap to compare</param>
        /// <returns>A bitmap where all the black pixels represent where the two bitmaps were different
        /// and the white pixels represent where they were the same</returns>
        private static WriteableBitmap ExclusiveOrBitmaps( WriteableBitmap firstBitmap, WriteableBitmap secondBitmap )
        {
            int stride = ( firstBitmap.PixelWidth * firstBitmap.Format.BitsPerPixel + 7 ) / 8;

             byte[] firstPixelArray = new byte[firstBitmap.PixelHeight * stride];
             byte[] secondPixelArray = new byte[secondBitmap.PixelHeight * stride];
             byte[] ordPixelArray = new byte[secondBitmap.PixelHeight * stride];
             firstBitmap.CopyPixels( firstPixelArray, stride, 0 );
             secondBitmap.CopyPixels( secondPixelArray, stride, 0 );

             for ( int i = 0; i < firstBitmap.PixelWidth; i++ )
             {
            for ( int j = 0; j < firstBitmap.PixelHeight; j++ )
            {
               int index = j * stride + 4 * i;

               var firstBitmapPixel = Pixel.GetPixel( firstPixelArray, index );
               var secondBitmapPixel = Pixel.GetPixel( secondPixelArray, index );

               // If the pixels are the same, they are white in the exclusive or bitmap
               if ( firstBitmapPixel.Color == secondBitmapPixel.Color )
               {
                  ordPixelArray[index] = 255;
                  ordPixelArray[index + 1] = 255;
                  ordPixelArray[index + 2] = 255;
               }
               else
               {
                  // Otherwise black
                  ordPixelArray[index] = 0;
                  ordPixelArray[index + 1] = 0;
                  ordPixelArray[index + 2] = 0;
               }
            }
             }
             var ordBitmap = firstBitmap.Clone();
             ordBitmap.WritePixels( new Int32Rect( 0, 0, firstBitmap.PixelWidth, firstBitmap.PixelHeight ), ordPixelArray, stride, 0 );

             return ordBitmap;
        }