예제 #1
0
        private WriteableBitmap _applyShader(BitmapFrame img, Func <byte, byte, byte, byte, Color> shader)
        {
            const double DPI = 96;

            if (Methods.CanUseIndexed8 || img.Format != PixelFormats.Indexed8)
            {
                int width  = img.PixelWidth;
                int height = img.PixelHeight;

                int    stride    = (int)Math.Ceiling(width * img.Format.BitsPerPixel / 8f);
                byte[] pixelData = new byte[stride * height];
                img.CopyPixels(pixelData, stride, 0);
                _darkTheme(pixelData, img.Format, null, shader);
                var wBitmap = new WriteableBitmap(BitmapSource.Create(width, height, DPI, DPI, img.Format, img.Palette, pixelData, stride));
                wBitmap.Freeze();
                return(wBitmap);
            }
            else
            {
                List <Color> colors    = new List <Color>(img.Palette.Colors);
                byte[]       pixelData = new byte[img.PixelWidth * img.PixelHeight * img.Format.BitsPerPixel / 8];
                img.CopyPixels(pixelData, img.PixelWidth * img.Format.BitsPerPixel / 8, 0);
                _darkTheme(pixelData, img.Format, colors, shader);
                var wBitmap = WpfImaging.ToBgra32FromIndexed8(pixelData, colors, img.PixelWidth, img.PixelHeight);
                wBitmap.Freeze();
                return(wBitmap);
            }
        }
예제 #2
0
        private static byte[] ApplyColoring(Color templateColor, BitmapFrame frame, int iWidth, int iHeight)
        {
            byte[] iPixel = new byte[iWidth * iHeight * 8];
            Int32  stride = (frame.PixelWidth * frame.Format.BitsPerPixel + 7) / 8;

            if (frame.Format == PixelFormats.Rgba64)
            {
                // PNG images for my vocabulary.zip file are typically in the RGBA64 format
                frame.CopyPixels(iPixel, stride, 0);

                for (int i = 0; i < iPixel.Length; i += 8)
                {
                    int  weightThreshold = 1000;
                    uint pixelContent    = (((uint)iPixel[i]) << 8) + iPixel[i + 1] + (((uint)iPixel[i + 2]) << 8) + iPixel[i + 3] + (((uint)iPixel[i + 4]) << 8) + iPixel[i + 5];

                    if (pixelContent > weightThreshold)
                    {
                        iPixel[i]     = (byte)((((UInt16)(templateColor.ScR * 65535)) & 0xFF00) >> 8);
                        iPixel[i + 1] = (byte)((((UInt16)(templateColor.ScR * 65535)) & 0xFF));

                        iPixel[i + 2] = (byte)((((UInt16)(templateColor.ScG * 65535)) & 0xFF00) >> 8);
                        iPixel[i + 3] = (byte)((((UInt16)(templateColor.ScG * 65535)) & 0xFF));

                        iPixel[i + 4] = (byte)((((UInt16)(templateColor.ScB * 65535)) & 0xFF00) >> 8);
                        iPixel[i + 5] = (byte)((((UInt16)(templateColor.ScB * 65535)) & 0xFF));

                        iPixel[i + 6] = (byte)((((UInt16)(templateColor.ScA * 65535)) & 0xFF00) >> 8);;
                        iPixel[i + 7] = (byte)((((UInt16)(templateColor.ScA * 65535)) & 0xFF));;
                    }
                }
            }
            else if (frame.Format == PixelFormats.Pbgra32)
            {
                iPixel = new byte[iHeight * stride];
                frame.CopyPixels(iPixel, stride, 0);

                for (int i = 0; i < iPixel.Length; i += 4)
                {
                    int  weightThreshold = 2;                                                                                   // if pixel RGB add up to more than 2 we treat it as a 'black' pixel that can be colorized based on templatecolor
                    uint pixelContent    = (uint)iPixel[i] + (uint)iPixel[i + 1] + +(uint)iPixel[i + 2] + +(uint)iPixel[i + 3]; //+ (uint)iPixel[i + 2] + (uint)iPixel[i + 3];//(((uint)iPixel[i]) << 8) + iPixel[i + 1] + (((uint)iPixel[i + 2]) << 8) + iPixel[i + 3] + (((uint)iPixel[i + 4]) << 8) + iPixel[i + 5];

                    if (pixelContent > weightThreshold)
                    {
                        iPixel[i + 0] = (byte)(templateColor.ScB * 255);
                        iPixel[i + 1] = (byte)(templateColor.ScG * 255);
                        iPixel[i + 2] = (byte)(templateColor.ScR * 255);
                        iPixel[i + 3] = (byte)(templateColor.ScA * 255);
                    }
                }
            }
            else
            {
                System.Diagnostics.Debug.WriteLine("Unsupported format applying color to image: " + frame.Format);
                throw new ArgumentException("Unsupported format applying color to image: " + frame.Format);
            }
            return(iPixel);
        }
예제 #3
0
        private void LoadTifImages(string file)
        {
            _fileName = System.IO.Path.GetFileName(file);
            _frame    = BitmapDecoder.Create(new Uri(file), BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad).Frames.First();
            int pixelSize = _frame.Format.BitsPerPixel / 8;
            int stride    = _frame.PixelWidth * pixelSize;
            int size      = _frame.PixelHeight * stride;

            _imagePixels = new byte[size];
            _frame.CopyPixels(_imagePixels, stride, 0);
            _tips.Clear();
            _nodes.Clear();
            _vVNodes.Clear();
            _edges.Clear();
            _erosionDilatationValue  = 0;
            tbErosionDilatation.Text = $"{_erosionDilatationValue}";
            _openingClosingValue     = 0;
            tbOpeningClosing.Text    = $"{_openingClosingValue}";
            int NodeCounter = 0;

            // Take every four pixel of the image
            for (int x = 0; x < _frame.PixelWidth; x = x + 12)
            {
                for (int y = 0; y < _frame.PixelHeight; y = y + 12)
                {
                    int pixelIndex     = y * stride + pixelSize * x;
                    int pixelGrayScale = (int)((_imagePixels[pixelIndex] * .21) + (_imagePixels[pixelIndex + 1] * .71) + (_imagePixels[pixelIndex + 2] * .071));

                    if (pixelGrayScale <= _grayScaleValue)
                    {
                        _nodes.Add(new Node("", x, y, 1));
                        _tips.Add($"Node_{NodeCounter}", NodeCounter);
                        NodeCounter++;
                    }
                    else if (pixelGrayScale > _grayScaleValue && pixelGrayScale < 220)
                    {
                        _nodes.Add(new Node("", x, y, 0));
                        _tips.Add($"Node_{NodeCounter}", NodeCounter);
                        NodeCounter++;
                    }
                }
            }
            _vVNodes     = _nodes;
            _boundingBox = new double[]
            {
                -50, -20, _frame.PixelWidth + 50, _frame.PixelHeight + 20
            };
            Title = $"Pattern Analyser - Voronoi Diagramm ({_fileName}) - Status: wird berechnet...";
            Stopwatch stopWatch = new Stopwatch();

            stopWatch.Start();
            _voronoiGraph     = Fortune.ComputeVoronoiGraph(_nodes.MapNodeToVector());
            _voronoiGraphCopy = _voronoiGraph;
            stopWatch.Stop();
            _edges = _voronoiGraph.Edges.MapEdgeHashSetToEdgeList(ActualHeight, true, _scaled).ToList();
            this.MyDotViewer.LoadPlain(_nodes, _edges, _fileName, _boundingBox, _frame, 1);

            Title = $"Pattern Analyser - Voronoi Diagramm ({_fileName}) - Dauer: {stopWatch.ElapsedMilliseconds.ToString()} ms";
            //this.MyDotViewer.LoadSourceImage(_frame, System.IO.Path.GetFileName(file));
        }
예제 #4
0
        public static IntPtr GetHIcon(ImageSource source)
        {
            BitmapFrame frame = source as BitmapFrame;

            if (frame != null && frame.Decoder.Frames.Count > 0)
            {
                frame = frame.Decoder.Frames[0];

                int width  = frame.PixelWidth;
                int height = frame.PixelHeight;
                int stride = width * ((frame.Format.BitsPerPixel + 7) / 8);

                byte[] bits = new byte[height * stride];

                frame.CopyPixels(bits, stride, 0);

                // pin the bytes in memory (avoids using unsafe context)
                GCHandle gcHandle = GCHandle.Alloc(bits, GCHandleType.Pinned);

                Bitmap bitmap = new Bitmap(
                    width,
                    height,
                    stride,
                    System.Drawing.Imaging.PixelFormat.Format32bppPArgb,
                    gcHandle.AddrOfPinnedObject());

                IntPtr hIcon = bitmap.GetHicon();

                gcHandle.Free();

                return(hIcon);
            }

            return(IntPtr.Zero);
        }
예제 #5
0
        public static ImageSource ColourImage(string resource, SolidColorBrush brush)
        {
            // Copy pixel colour values from existing image.
            // (This loads them from an embedded resource. BitmapDecoder can work with any Stream, though.)
            //StreamResourceInfo x = Application.GetResourceStream(new Uri(BaseUriHelper.GetBaseUri(this), "Image.png"));
            var uri = new Uri("pack://application:,,,/LightBlue.MultiHost;component/" + resource);
            StreamResourceInfo x     = Application.GetResourceStream(uri);
            BitmapDecoder      dec   = BitmapDecoder.Create(x.Stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
            BitmapFrame        image = dec.Frames[0];

            byte[] pixels = new byte[image.PixelWidth * image.PixelHeight * 4];
            image.CopyPixels(pixels, image.PixelWidth * 4, 0);

            // Modify the alpha pixels
            for (int i = 0; i < pixels.Length / 4; ++i)
            {
                byte a = pixels[i * 4 + 3];

                if (a != 0)
                {
                    pixels[i * 4]     = brush.Color.B;
                    pixels[i * 4 + 1] = brush.Color.G;
                    pixels[i * 4 + 2] = brush.Color.R;
                }
            }

            // Write the modified pixels into a new bitmap and use that as the source of an Image
            var bmp = new WriteableBitmap(image.PixelWidth, image.PixelHeight, image.DpiX, image.DpiY, PixelFormats.Pbgra32, null);

            bmp.WritePixels(new Int32Rect(0, 0, image.PixelWidth, image.PixelHeight), pixels, image.PixelWidth * 4, 0);
            return(bmp);
        }
예제 #6
0
        public Bitmap AsGDI(Profile profile = null)
        {
            bool pop = false;

            try
            {
                if (gdiBitmap != null)
                {
                    return(gdiBitmap);
                }

                if (profile != null)
                {
                    profile.Push("SmartBitmap.AsGDI");
                    pop = true;
                }

                if (wpfBitmap != null)
                {
                    Bitmap gdiBitmap = new Bitmap(wpfBitmap.PixelWidth, wpfBitmap.PixelHeight, System.Drawing.Imaging.PixelFormat.Format32bppRgb);
                    ApplyProperties();

                    BitmapData d      = gdiBitmap.LockBits(new Rectangle(0, 0, gdiBitmap.Width, gdiBitmap.Height), ImageLockMode.WriteOnly, ManagedBitmap32.Format);
                    int *      scan0  = (int *)d.Scan0.ToPointer();
                    int        stride = d.Stride;
                    Debug.Assert(stride > 0);

                    wpfBitmap.CopyPixels(new System.Windows.Int32Rect(0, 0, gdiBitmap.Width, gdiBitmap.Height), new IntPtr(scan0), stride, 0 /*offset*/);

                    gdiBitmap.UnlockBits(d);

                    wpfBitmap = null;

                    return(gdiBitmap);
                }

                if (managedBitmap != null)
                {
                    gdiBitmap = managedBitmap.CloneToGDI();

                    managedBitmap.Dispose();
                    managedBitmap = null;

                    return(gdiBitmap);
                }
            }
            finally
            {
                if ((profile != null) && pop)
                {
                    profile.Pop();
                }
            }

            Debug.Assert(false);
            throw new InvalidOperationException();
        }
예제 #7
0
        /// <summary>
        /// Creates a WinForms <see cref="Bitmap"/> from the <see cref="Image"/>.
        /// </summary>
        /// <param name="image">The <see cref="Image"/> to convert into a <see cref="Bitmap"/>.</param>
        /// <returns>A <see cref="Bitmap"/> that references the data in <see cref="Image"/>.</returns>
        public static System.Drawing.Image CreateBitmap(this Image image)
        {
            if (image is null)
            {
                throw new ArgumentNullException(nameof(image));
            }

            System.Drawing.Imaging.PixelFormat pixelFormat;

            // Take a new reference on the image to ensure that the object
            // cannot be disposed by another thread while we have a copy of its Buffer
            using (Image reference = image.DuplicateReference())
            {
                unsafe
                {
                    switch (reference.Format)
                    {
                    case ImageFormat.ColorBgra32:
                        pixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppArgb;
                        break;

                    case ImageFormat.Depth16:
                    case ImageFormat.IR16:
                        pixelFormat = System.Drawing.Imaging.PixelFormat.Format16bppGrayScale;
                        break;

                    case ImageFormat.ColorMjpg:
                        Byte[] buffer = new byte[image.SizeBytes];
                        System.Runtime.InteropServices.Marshal.Copy(image.Buffer, buffer, 0, image.SizeBytes);
                        JpegBitmapDecoder decoder    = new JpegBitmapDecoder(new MemoryStream(buffer), BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);
                        BitmapFrame       frame      = decoder.Frames[0];
                        Bitmap            lbmpBitmap = new Bitmap(frame.PixelWidth, frame.PixelHeight);
                        Rectangle         lrRect     = new Rectangle(0, 0, lbmpBitmap.Width, lbmpBitmap.Height);
                        BitmapData        lbdData    = lbmpBitmap.LockBits(lrRect, ImageLockMode.WriteOnly, (frame.Format.BitsPerPixel == 24 ? PixelFormat.Format24bppRgb : PixelFormat.Format32bppArgb));
                        frame.CopyPixels(System.Windows.Int32Rect.Empty, lbdData.Scan0, lbdData.Height * lbdData.Stride, lbdData.Stride);
                        lbmpBitmap.UnlockBits(lbdData);
                        return(lbmpBitmap);

                    // pixelFormat = System.Drawing.Imaging.PixelFormat.;
                    // MjpegProcessor.MjpegDecoder()
                    //break;
                    default:
                        throw new Exception($"Pixel format {reference.Format} cannot be converted to a BitmapSource");
                    }

                    using (image)
                    {
                        return(new Bitmap(
                                   image.WidthPixels,
                                   image.HeightPixels,
                                   image.StrideBytes,
                                   pixelFormat,
                                   image.Buffer));
                    }
                }
            }
        }
예제 #8
0
 public ManagedBitmap32(BitmapFrame wpfBitmap)
     : this(wpfBitmap.PixelWidth, wpfBitmap.PixelHeight)
 {
     wpfBitmap.CopyPixels(
         new System.Windows.Int32Rect(0, 0, wpfBitmap.PixelWidth, wpfBitmap.PixelHeight),
         new IntPtr(this.scan0),
         TotalBytes,
         this.stride);
 }
예제 #9
0
 private void UpdateWritableBitmap(BitmapFrame frame)
 {
     Application.Current.Dispatcher.Invoke(() =>
     {
         writableBitmap.Lock();
         frame.CopyPixels(new System.Windows.Int32Rect(0, 0, 3841, 2162), writableBitmap.BackBuffer, (int)writableBitmap.BackBufferStride * (int)writableBitmap.Height, (int)writableBitmap.BackBufferStride);
         writableBitmap.AddDirtyRect(new System.Windows.Int32Rect(0, 0, 3841, 2162));
         writableBitmap.Unlock();
     }, System.Windows.Threading.DispatcherPriority.Background);
 }
예제 #10
0
        public static Bitmap CreateBitmapFromFrame(BitmapFrame frame)
        {
            Bitmap     bitmap     = new Bitmap(frame.PixelWidth, frame.PixelHeight, PixelFormat.Format32bppArgb);
            BitmapData bitmapData = bitmap.LockBits(new Rectangle(System.Drawing.Point.Empty, bitmap.Size), ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

            frame.CopyPixels(Int32Rect.Empty, bitmapData.Scan0, bitmapData.Height * bitmapData.Stride, bitmapData.Stride);
            bitmap.UnlockBits(bitmapData);

            return(bitmap);
        }
예제 #11
0
        private Bitmap JpegToBitmap(Stream jpg)
        {
            JpegBitmapDecoder ldDecoder  = new JpegBitmapDecoder(jpg, BitmapCreateOptions.None, BitmapCacheOption.None);
            BitmapFrame       lfFrame    = ldDecoder.Frames[0];
            Bitmap            lbmpBitmap = new Bitmap(lfFrame.PixelWidth, lfFrame.PixelHeight);
            Rectangle         lrRect     = new Rectangle(0, 0, lbmpBitmap.Width, lbmpBitmap.Height);
            BitmapData        lbdData    = lbmpBitmap.LockBits(lrRect, ImageLockMode.WriteOnly, (lfFrame.Format.BitsPerPixel == 24 ? PixelFormat.Format24bppRgb : PixelFormat.Format32bppArgb));

            lfFrame.CopyPixels(System.Windows.Int32Rect.Empty, lbdData.Scan0, lbdData.Height * lbdData.Stride, lbdData.Stride);
            lbmpBitmap.UnlockBits(lbdData);
            return(lbmpBitmap);
        }
예제 #12
0
        private static BitmapSource Convert(BitmapFrame frame)
        {
            int stride = frame.PixelWidth * (frame.Format.BitsPerPixel / 8);

            byte[] pixels = new byte[frame.PixelHeight * stride];

            frame.CopyPixels(pixels, stride, 0);

            var bmpSource = BitmapSource.Create(frame.PixelWidth, frame.PixelHeight,
                                                frame.DpiX, frame.DpiY, frame.Format, frame.Palette, pixels, stride);

            return(bmpSource);
        }
예제 #13
0
        private BitmapImage TiffFrameToBitmapImage(BitmapFrame frame)
        {
            int stride = (int)frame.PixelWidth * ((frame.Format.BitsPerPixel + 7) / 8);

            byte[]      pixels = new byte[(int)frame.PixelHeight * stride];
            BitmapImage img;;

            frame.CopyPixels(pixels, stride, 0);

            img = new BitmapImage();
            //img.CopyPixels(pixels, stride, 0);


            return(img);
        }
예제 #14
0
        public void Method2()
        {
            Array myPixels = (...);

            while (true)
            {
                // Prepare image
                BitmapFrame bf = BitmapFrame.Create(screen);
                RenderOptions.SetBitmapScalingMode(bf, BitmapScalingMode.LowQuality);
                bf.CopyPixels(new Int32Rect(0, 0, width, height), myPixels, width * 4, 0);
                lock (pixelsLock)
                {
                    // Copy the hard work to shared storage
                    Array.Copy(sourceArray: myPixels, destinationArray: shared, length: myPixels.GetUpperBound(0) - 1);
                }
            }
        }
예제 #15
0
        public string LoadBitmap(string path)
        {
            string text;

            using (FileStream fs = File.Open(path, FileMode.Open))
            {
                BitmapDecoder decoder = PngBitmapDecoder.Create(fs, BitmapCreateOptions.DelayCreation, BitmapCacheOption.Default);
                BitmapFrame   frame   = decoder.Frames[0];

                byte[] bytes = new byte[frame.PixelWidth * frame.PixelHeight];
                frame.CopyPixels(bytes, frame.PixelWidth, 0);

                text = Encoding.Unicode.GetString(bytes);
            }

            return(text);
        }
예제 #16
0
        private Array FileConvertArray(string filename, out PixelFormat format)

        {
            Array arr;

            using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
            {
                BitmapFrame bitmapFrame = BitmapFrame.Create(
                    fs,
                    BitmapCreateOptions.PreservePixelFormat,
                    BitmapCacheOption.Default
                    );

                int width  = bitmapFrame.PixelWidth;
                int height = bitmapFrame.PixelHeight;
                format = bitmapFrame.Format;

                int stride = ((width * format.BitsPerPixel + 31) / 32) * 4;

                if (format == PixelFormats.Gray16)
                {
                    arr = new ushort[width * height];
                }

                else if (format == PixelFormats.Rgb48)
                {
                    arr = new ushort[width * 3 * height];
                }

                else
                {
                    arr = new byte[stride * height];
                }

                // 輝度データを配列へコピー
                bitmapFrame.CopyPixels(arr, stride, 0);

                fs.Dispose();
            }



            GC.Collect();
            return(arr);
        }
예제 #17
0
        private ImageLoaderProxyPixelData GetBitmapImageBytes(string fileName)
        {
            // All of the BitmapSource creation occurs in this method, keeping the calls to
            // MemoryPressure.ProcessAdd() localized to this app domain
            // Load the image from file
            BitmapFrame bmpFrame = BitmapFrame.Create(new Uri(fileName));
            int         stride   = bmpFrame.PixelWidth * bmpFrame.Format.BitsPerPixel;

            byte[] pixels = new byte[bmpFrame.PixelHeight * stride];
            // Construct and return the image information
            bmpFrame.CopyPixels(pixels, stride, 0);
            return(new ImageLoaderProxyPixelData()
            {
                Pixels = pixels,
                Stride = stride,
                Rect = new Int32Rect(0, 0, bmpFrame.PixelWidth, bmpFrame.PixelHeight)
            });
        }
예제 #18
0
        private static Dictionary <char, byte[]> GenerateTypeface(Uri bitmapPath,
                                                                  int glyphWidth, int glyphHeight, int rawStride)
        {
            Dictionary <char, byte[]> toReturn = new Dictionary <char, byte[]>();

            // Assumes bitmap is of proper pixelformat (Indexed1)
            PngBitmapDecoder b = new PngBitmapDecoder(bitmapPath,
                                                      BitmapCreateOptions.IgnoreColorProfile, BitmapCacheOption.Default);
            BitmapFrame sheet      = b.Frames[0];
            int         imageIndex = 0;

            byte[] rawImage = new byte[rawStride * glyphHeight];
            for (int j = 0; j < sheet.PixelHeight; j += glyphHeight)
            {
                for (int i = 0; i < sheet.PixelWidth; i += glyphWidth)
                {
                    sheet.CopyPixels(new Int32Rect(i, j, glyphWidth, glyphHeight), rawImage, rawStride, 0);
                    toReturn[MasterIndexList[imageIndex]] = (byte[])rawImage.Clone();
                    imageIndex++;
                }
            }
            return(toReturn);
        }
예제 #19
0
        public static IconHandle Create(ImageSource imageSource)
        {
            IconHandle result = IconHandle.Invalid;

            if (imageSource != null)
            {
                // Initialize bitmap rectangle and try to cast image source to bitmap frame
                Rect        bitmapRect  = new Rect(new Size(imageSource.Width, imageSource.Height));
                BitmapFrame bitmapFrame = imageSource as BitmapFrame;

                if (bitmapFrame == null || !(bitmapFrame.Decoder is IconBitmapDecoder))
                {
                    // Create drawing visual
                    DrawingVisual drawingVisual = new DrawingVisual();

                    // Open drawing context and draw the image to the visual
                    using (DrawingContext drawingContext = drawingVisual.RenderOpen()) {
                        // Render the image and close drawing context
                        drawingContext.DrawImage(imageSource, bitmapRect);
                    }

                    // Create render target bitmap and render the visual
                    RenderTargetBitmap renderTargetBitmap =
                        new RenderTargetBitmap((Int32)bitmapRect.Width, (Int32)bitmapRect.Height,
                                               96.0d, 96.0d, PixelFormats.Pbgra32);

                    renderTargetBitmap.Render(drawingVisual);
                    renderTargetBitmap.Freeze();

                    // Create bitmap frame from the render target bitmap
                    bitmapFrame = BitmapFrame.Create(renderTargetBitmap);
                }

                // Copy pixels from bitmap frame to pixel array
                Int32  stride     = (bitmapFrame.Format.BitsPerPixel * bitmapFrame.PixelWidth + 31) / 32 * 4;
                Byte[] pixelArray = new Byte[stride * bitmapFrame.PixelHeight];
                bitmapFrame.CopyPixels(pixelArray, stride, 0);

                // Mask & icon bitmap handles
                IntPtr maskBitmapPtr = IntPtr.Zero;
                IntPtr iconBitmapPtr = IntPtr.Zero;

                // Initialize BITMAPINFO/BITMAPINFOHEADER structure
                NativeMethods.BITMAPINFO bmi = new NativeMethods.BITMAPINFO();
                bmi.bmiHeader.biSize     = (UInt32)Marshal.SizeOf(typeof(NativeMethods.BITMAPINFOHEADER));
                bmi.bmiHeader.biWidth    = (Int32)bitmapRect.Width;
                bmi.bmiHeader.biHeight  -= ((Int32)bitmapRect.Height);
                bmi.bmiHeader.biPlanes   = 1;
                bmi.bmiHeader.biBitCount = (UInt16)bitmapFrame.Format.BitsPerPixel;

                // DIB handle
                IntPtr dibPtr = IntPtr.Zero;

                // Create icon bitmap DIB section
                iconBitmapPtr = NativeMethods.CreateDIBSection(IntPtr.Zero, ref bmi, 0, out dibPtr,
                                                               IntPtr.Zero, 0);

                // Validate icon bitmap handle
                if (iconBitmapPtr != IntPtr.Zero && dibPtr != IntPtr.Zero)
                {
                    // Copy pixels to unmanaged memory
                    Marshal.Copy(pixelArray, 0, dibPtr, pixelArray.Length);

                    // Create mask bitmap
                    maskBitmapPtr = NativeMethods.CreateBitmap((Int32)bitmapRect.Width,
                                                               (Int32)bitmapRect.Height,
                                                               1, 1, IntPtr.Zero);

                    if (maskBitmapPtr != IntPtr.Zero)
                    {
                        // Create and initialize ICONINFO structure
                        NativeMethods.ICONINFO iconInfo = new NativeMethods.ICONINFO();
                        iconInfo.fIcon    = true;
                        iconInfo.hbmMask  = maskBitmapPtr;
                        iconInfo.hbmColor = iconBitmapPtr;

                        // Create icon handle
                        IntPtr iconPtr = NativeMethods.CreateIconIndirect(ref iconInfo);

                        if (iconPtr != IntPtr.Zero)
                        {
                            result = new IconHandle(iconPtr);
                        }
                    }
                }

                // Clean up resources
                if (maskBitmapPtr != IntPtr.Zero)
                {
                    NativeMethods.DeleteObject(maskBitmapPtr);
                }

                if (iconBitmapPtr != IntPtr.Zero)
                {
                    NativeMethods.DeleteObject(iconBitmapPtr);
                }
            }

            // Return result
            return(result);
        }
예제 #20
0
        private void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            Dispatcher.BeginInvoke((Action)(() =>
            {
                //foreach (FieldInfo type in typeof(DataFormats).GetFields())
                //{
                //    if (Clipboard.GetDataObject().GetDataPresent(type.GetValue("") as string))
                //    {
                //        Console.WriteLine(type.GetValue("") as string);
                //    }
                //}
                try
                {
                    transfareData IDataTranfare = new transfareData();
                    foreach (string _supported in supportedFormats)
                    {
                        if (!Clipboard.GetDataObject().GetDataPresent(_supported))
                        {
                            continue;
                        }

                        if (_supported == DataFormats.Bitmap)
                        {
                            Image image = new Image();
                            System.Windows.Interop.InteropBitmap interopBitmap = (System.Windows.Interop.InteropBitmap)Clipboard.GetImage();
                            image.Source = interopBitmap;
                            IDataTranfare.copyValue = image;
                            BitmapFrame interopBitmap1 = CreateResizedImage(interopBitmap, Math.Min(interopBitmap.PixelWidth, 100), Math.Min(interopBitmap.PixelHeight, 100), 0);
                            Image image2 = new Image();
                            image2.Source = interopBitmap1;
                            IDataTranfare.contentValue = image2;
                            Int32Rect rect = new Int32Rect(0, 0, interopBitmap1.PixelWidth, interopBitmap1.PixelHeight);
                            int stride = interopBitmap1.PixelWidth * (interopBitmap1.Format.BitsPerPixel + 7) / 8;
                            int arrayLength = stride * interopBitmap1.PixelHeight;
                            int[] arr = new int[arrayLength];
                            interopBitmap1.CopyPixels(rect, arr, stride, 0);

                            unchecked
                            {
                                int sum = 0;
                                for (int i = 0; i < arr.Length; i++)
                                {
                                    sum += arr[i];
                                }
                                IDataTranfare.savedValue = sum / arr.Length;
                            }
                        }
                        else if (_supported == DataFormats.Text)
                        {
                            IDataTranfare.copyValue = Clipboard.GetText().Replace("\n", "").Replace("\r", "");
                            IDataTranfare.savedValue = IDataTranfare.copyValue;
                            IDataTranfare.contentValue = IDataTranfare.copyValue;
                        }

                        IDataTranfare.format = _supported;
                        break;
                    }

                    if (OLD_IData.Contains(IDataTranfare.savedValue) || IDataTranfare.format == null)
                    {
                        return;
                    }
                    OLD_IData.Add(IDataTranfare.savedValue);
                    ListBOX.Items.Insert(0, new itemElement(ListBOX, OLD_IData, IDataTranfare));
                }
                catch (Exception err)
                {
                    Console.WriteLine(err);
                }
            }));
        }
예제 #21
0
파일: DCRaw.cs 프로젝트: daleghent/NINA
        public async Task <IImageData> Convert(
            MemoryStream s,
            int bitDepth,
            string rawType,
            ImageMetaData metaData,
            CancellationToken token = default)
        {
            return(await Task.Run(async() => {
                using (MyStopWatch.Measure()) {
                    var fileextension = ".raw";
                    var filename = Path.GetRandomFileName();
                    var rawfile = Path.Combine(Utility.APPLICATIONTEMPPATH, filename + fileextension);

                    using (var filestream = new System.IO.FileStream(rawfile, System.IO.FileMode.Create)) {
                        s.WriteTo(filestream);
                    }

                    ImageData data = null;
                    var outputFile = Path.Combine(Utility.APPLICATIONTEMPPATH, filename + ".tiff");
                    try {
                        System.Diagnostics.Process process;
                        System.Diagnostics.ProcessStartInfo startInfo;
                        var sb = new StringBuilder();
                        using (MyStopWatch.Measure("DCRawStart")) {
                            process = new System.Diagnostics.Process();
                            startInfo = new System.Diagnostics.ProcessStartInfo();
                            startInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Normal;
                            startInfo.FileName = DCRAWLOCATION;
                            startInfo.UseShellExecute = false;
                            startInfo.RedirectStandardOutput = true;
                            startInfo.RedirectStandardError = true;
                            startInfo.RedirectStandardInput = true;
                            startInfo.CreateNoWindow = true;
                            startInfo.Arguments = "-4 -d -T -t 0 -v \"" + rawfile + "\"";
                            process.StartInfo = startInfo;
                            process.EnableRaisingEvents = true;

                            process.OutputDataReceived += (object sender, System.Diagnostics.DataReceivedEventArgs e) => {
                                sb.AppendLine(e.Data);
                            };

                            process.ErrorDataReceived += (object sender, System.Diagnostics.DataReceivedEventArgs e) => {
                                sb.AppendLine(e.Data);
                            };

                            process.Start();
                            process.BeginOutputReadLine();
                            process.BeginErrorReadLine();

                            await process.WaitForExitAsync(token);

                            Logger.Trace(sb.ToString());
                        }

                        using (MyStopWatch.Measure("DCRawReadIntoImageArray")) {
                            if (File.Exists(outputFile))
                            {
                                TiffBitmapDecoder TifDec = new TiffBitmapDecoder(new Uri(outputFile), BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.OnLoad);
                                BitmapFrame bmp = TifDec.Frames[0];
                                ushort[] pixels = new ushort[bmp.PixelWidth *bmp.PixelHeight];
                                bmp.CopyPixels(pixels, 2 * bmp.PixelWidth, 0);

                                //Due to the settings of dcraw decoding the values will be stretched to 16 bits
                                bitDepth = 16;

                                var imageArray = new ImageArray(flatArray: pixels, rawData: s.ToArray(), rawType: rawType);
                                data = new ImageData(
                                    imageArray: imageArray,
                                    width: (int)bmp.PixelWidth,
                                    height: (int)bmp.PixelHeight,
                                    bitDepth: bitDepth,
                                    isBayered: true,
                                    metaData: metaData);
                            }
                            else
                            {
                                Logger.Error("File not found: " + outputFile);
                                throw new Exception("Error occured during DCRaw conversion." + Environment.NewLine + sb.ToString());
                            }
                        }
                    } catch (Exception ex) {
                        Notification.Notification.ShowError(ex.Message);
                        Logger.Error(ex);
                    } finally {
                        if (File.Exists(rawfile))
                        {
                            File.Delete(rawfile);
                        }
                        if (File.Exists(outputFile))
                        {
                            File.Delete(outputFile);
                        }
                    }
                    return data;
                }
            }));
        }
예제 #22
0
        /// <summary>
        /// Creates an Image with specified adjustments based on an image file on disk.
        /// </summary>
        /// <param name="angle">The angle to rotate the image. One of 0, 90, 180, or 270.</param>
        /// <param name="hueShift">The degrees to rotate the hue.</param>
        /// <param name="saturationAdjust">A value between -100 and 100. Negative values reduce saturation; positive values increase saturation.</param>
        /// <param name="lightnessAdjust">A value between -100 and 100. Negative values darken the color; positive values lighten the color.</param>
        /// <param name="contrast">A value between -100 and 100. Negative values reduce contrast (move more toward the threshold value); positive values increase the contrast (move away from the threshold value).</param>
        /// <param name="scaleX">The horizontal scale of the image.</param>
        /// <param name="scaleY">The vertical scale of the image.</param>
        /// <param name="fileName">The image file to load.</param>
        /// <returns></returns>
        public static Image CreateImage(int angle, double hueShift, double saturationAdjust, double lightnessAdjust, double contrast, double scaleX, double scaleY, string fileName)
        {
            TransformedBitmap transformBmp = new TransformedBitmap();

            BitmapSource bitmapSource;

            if (hueShift == 0 && saturationAdjust == 0 && lightnessAdjust == 0 && contrast == 0)
            {
                BitmapImage bmpImage = new BitmapImage();
                bmpImage.BeginInit();
                bmpImage.UriSource = new Uri(fileName, UriKind.RelativeOrAbsolute);
                bmpImage.EndInit();
                bitmapSource = bmpImage;
            }
            else
            {
                BitmapDecoder dec           = BitmapDecoder.Create(new Uri(fileName), BitmapCreateOptions.None, BitmapCacheOption.Default);
                BitmapFrame   firstFrame    = dec.Frames[0];
                const int     bytesPerPixel = 4;
                int           stride        = firstFrame.PixelWidth * bytesPerPixel;
                byte[]        pixels        = new byte[stride * firstFrame.PixelHeight];
                firstFrame.CopyPixels(pixels, stride, 0);

                for (int i = 0; i < pixels.Length / 4; ++i)
                {
                    int       index       = i * 4;
                    const int blueOffset  = 0;
                    const int greenOffset = 1;
                    const int redOffset   = 2;
                    const int alphaOffset = 3;

                    // Diagnostic pixel testing:
                    //int y = i / firstFrame.PixelWidth;
                    //int x = i - y * firstFrame.PixelWidth;
                    //if (x == 229 && y == 254)
                    //{
                    //	System.Diagnostics.Debugger.Break();
                    //}
                    byte b = pixels[index + blueOffset];
                    byte g = pixels[index + greenOffset];
                    byte r = pixels[index + redOffset];
                    byte a = pixels[index + alphaOffset];

                    if (a == 0)
                    {
                        continue;
                    }

                    HueSatLight hueSatLight = new HueSatLight(Color.FromArgb(a, r, g, b));
                    if (hueShift != 0)
                    {
                        hueSatLight.HueShiftDegrees(hueShift);
                    }
                    if (saturationAdjust != 0)
                    {
                        hueSatLight.AdjustSaturation(saturationAdjust);
                    }
                    if (lightnessAdjust != 0)
                    {
                        hueSatLight.AdjustLightness(lightnessAdjust);
                    }

                    if (contrast != 0)
                    {
                        hueSatLight.AdjustContrast(contrast, (lightnessAdjust + 100) / 200);
                    }
                    Color shifted = hueSatLight.AsRGB;
                    pixels[index + blueOffset]  = shifted.B;
                    pixels[index + greenOffset] = shifted.G;
                    pixels[index + redOffset]   = shifted.R;
                    pixels[index + alphaOffset] = shifted.A;
                }

                bitmapSource = CreateBitmap(firstFrame, stride, pixels);
            }

            transformBmp.BeginInit();
            transformBmp.Source = bitmapSource;
            RotateTransform rotation = null;

            if (angle != 0)
            {
                rotation = new RotateTransform(angle);
            }

            ScaleTransform scaling = null;

            if (scaleX != 1 || scaleY != 1)
            {
                scaling = new ScaleTransform(scaleX, scaleY);
            }

            if (scaling != null || rotation != null)
            {
                TransformGroup group = new TransformGroup();
                if (scaling != null)
                {
                    group.Children.Add(scaling);
                }

                if (rotation != null)
                {
                    group.Children.Add(rotation);
                }

                transformBmp.Transform = group;
            }
            transformBmp.EndInit();

            Image result = new Image();

            result.Source = transformBmp;

            return(result);
        }
예제 #23
0
        public static Image CreateImage(int angle, double hueShift, double saturationAdjust, double lightnessAdjust, double contrast, double scaleX, double scaleY, string fileName)
        {
            TransformedBitmap transformBmp = new TransformedBitmap();

            BitmapSource bitmapSource;

            if (hueShift == 0 && saturationAdjust == 0 && lightnessAdjust == 0 && contrast == 0)
            {
                BitmapImage bmpImage = new BitmapImage();
                bmpImage.BeginInit();
                bmpImage.UriSource = new Uri(fileName, UriKind.RelativeOrAbsolute);
                bmpImage.EndInit();
                bitmapSource = bmpImage;
            }
            else
            {
                BitmapDecoder dec           = BitmapDecoder.Create(new Uri(fileName), BitmapCreateOptions.None, BitmapCacheOption.Default);
                BitmapFrame   firstFrame    = dec.Frames[0];
                const int     bytesPerPixel = 4;
                byte[]        pixels        = new byte[firstFrame.PixelWidth * firstFrame.PixelHeight * bytesPerPixel];
                firstFrame.CopyPixels(pixels, firstFrame.PixelWidth * bytesPerPixel, 0);

                for (int i = 0; i < pixels.Length / 4; ++i)
                {
                    int       index       = i * 4;
                    const int blueOffset  = 0;
                    const int greenOffset = 1;
                    const int redOffset   = 2;
                    const int alphaOffset = 3;

                    byte        b           = pixels[index + blueOffset];
                    byte        g           = pixels[index + greenOffset];
                    byte        r           = pixels[index + redOffset];
                    byte        a           = pixels[index + alphaOffset];
                    HueSatLight hueSatLight = new HueSatLight(Color.FromArgb(a, r, g, b));
                    if (hueShift != 0)
                    {
                        hueSatLight.HueShiftDegrees(hueShift);
                    }
                    if (saturationAdjust != 0)
                    {
                        hueSatLight.AdjustSaturation(saturationAdjust);
                    }
                    if (lightnessAdjust != 0)
                    {
                        hueSatLight.AdjustLightness(lightnessAdjust);
                    }

                    if (contrast != 0)
                    {
                        hueSatLight.AdjustContrast(contrast, (lightnessAdjust + 100) / 200);
                    }
                    Color shifted = hueSatLight.AsRGB;
                    pixels[index + blueOffset]  = shifted.B;
                    pixels[index + greenOffset] = shifted.G;
                    pixels[index + redOffset]   = shifted.R;
                    pixels[index + alphaOffset] = shifted.A;
                }

                // Write the modified pixels into a new bitmap and set that to the source
                var writeableBitmap = new WriteableBitmap(firstFrame.PixelWidth, firstFrame.PixelHeight, firstFrame.DpiX, firstFrame.DpiY, PixelFormats.Pbgra32, null);
                writeableBitmap.WritePixels(new Int32Rect(0, 0, firstFrame.PixelWidth, firstFrame.PixelHeight), pixels, firstFrame.PixelWidth * bytesPerPixel, 0);
                bitmapSource = writeableBitmap;
            }

            transformBmp.BeginInit();
            transformBmp.Source = bitmapSource;
            RotateTransform rotation = new RotateTransform(angle);

            ScaleTransform scaling = new ScaleTransform(scaleX, scaleY);
            TransformGroup group   = new TransformGroup();

            group.Children.Add(scaling);
            group.Children.Add(rotation);
            transformBmp.Transform = group;
            transformBmp.EndInit();

            Image result = new Image();

            result.Source = transformBmp;

            return(result);
        }
예제 #24
0
        internal static (Image Image, ImageMetadata Metadata) FromBitmapFrame(this BitmapFrame bitmapFrame)
        {
            if (bitmapFrame == null)
            {
                throw new ArgumentNullException(nameof(bitmapFrame));
            }

            int?xres = null;
            int?yres = null;

            // load metadata
            ImageMetadata metadata = null;

            if (bitmapFrame.Metadata is BitmapMetadata bitmapMetadata)
            {
                metadata = BitmapExtensions.ReadBitmapMetadata(bitmapMetadata);

                // reset resolution to 200 dpi for images that do not have resolution tag
                if (bitmapFrame.Decoder is TiffBitmapDecoder)
                {
                    if (!metadata.HasPropertyItem((int)TIFFField.XResolution))
                    {
                        xres = 200;
                    }

                    if (!metadata.HasPropertyItem((int)TIFFField.YResolution))
                    {
                        yres = 200;
                    }
                }

                // remove standard tags
                metadata.RemovePropertyItems(x => x.Id == (int)TIFFField.ImageWidth ||
                                             x.Id == (int)TIFFField.ImageLength ||
                                             x.Id == (int)TIFFField.XResolution ||
                                             x.Id == (int)TIFFField.YResolution ||
                                             x.Id == (int)TIFFField.BitsPerSample);
            }

            // verify palette presence
            System.Windows.Media.PixelFormat pixelFormat = bitmapFrame.Format;
            if ((pixelFormat == PixelFormats.Indexed1 ||
                 pixelFormat == PixelFormats.Indexed2 ||
                 pixelFormat == PixelFormats.Indexed4 ||
                 pixelFormat == PixelFormats.Indexed8) &&
                bitmapFrame.Palette?.Colors == null)
            {
                throw new InvalidOperationException(Properties.Resources.E_UnsupportedImageFormat);
            }

            // load image
            Image image = new Image(
                bitmapFrame.PixelWidth,
                bitmapFrame.PixelHeight,
                pixelFormat.BitsPerPixel,
                xres.GetValueOrDefault((int)(bitmapFrame.DpiX + 0.5f)),
                yres.GetValueOrDefault((int)(bitmapFrame.DpiY + 0.5f)));

            int strideInBytes = (((image.Width * image.BitsPerPixel) + 31) & ~31) >> 3;

            uint[] bits = new uint[image.Height * strideInBytes / sizeof(uint)];
            bitmapFrame.CopyPixels(bits, strideInBytes, 0);

            unsafe
            {
                fixed(uint *src = bits)
                {
                    fixed(ulong *dst = image.Bits)
                    {
                        Arrays.CopyStrides(
                            image.Height,
                            new IntPtr(src),
                            strideInBytes,
                            new IntPtr(dst),
                            image.Stride8);
                    }
                }
            }

            if (image.BitsPerPixel < 8)
            {
                Vectors.SwapBits(image.Bits.Length, image.BitsPerPixel, image.Bits, 0);
            }

            // special case for BitmapFrame BlackWhite pixel format
            if (bitmapFrame.Format == PixelFormats.BlackWhite)
            {
                image.Not(image);
                metadata.RemovePropertyItem((int)TIFFField.PhotometricInterpretation);
            }

            return(
                Image.OnLoaded(
                    image,
                    metadata,
                    bitmapFrame.Palette?.Colors?.Select(x => Color.FromArgb(x.A, x.R, x.G, x.B)).ToArray()),
                metadata);
        }
예제 #25
0
        public void CompareImages(bool createDiffImage)
        {
            using (Stream leftStream = new FileStream(leftImagePath, FileMode.Open, FileAccess.Read, FileShare.Read))
            {
                BitmapFrame leftFrame = GetBitmapFrame(leftImagePath, leftStream);

                int leftHeight        = leftFrame.PixelHeight;
                int leftWidth         = leftFrame.PixelWidth;
                int leftBytesPerPixel = (leftFrame.Format.BitsPerPixel + 7) / 8;
                int leftStride        = leftWidth * leftBytesPerPixel;

                byte[] leftBytes = new byte[leftHeight * leftStride];
                leftFrame.CopyPixels(leftBytes, leftStride, 0);

                using (Stream rightStream = new FileStream(rightImagePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                {
                    BitmapFrame rightFrame = GetBitmapFrame(rightImagePath, rightStream);

                    int rightHeight        = rightFrame.PixelHeight;
                    int rightWidth         = rightFrame.PixelWidth;
                    int rightBytesPerPixel = (rightFrame.Format.BitsPerPixel + 7) / 8;
                    int rightStride        = rightWidth * rightBytesPerPixel;

                    byte[] rightBytes = new byte[rightHeight * rightStride];
                    rightFrame.CopyPixels(rightBytes, rightStride, 0);

                    if (rightFrame.Format != leftFrame.Format)
                    {
                        throw new InvalidDataException("Images not the same format(" + leftFrame.Format.ToString() + " != " + rightFrame.Format.ToString());
                    }


                    int diffHeight = Math.Min(leftHeight, rightHeight);
                    int diffWidth  = Math.Min(leftWidth, rightWidth);
                    int diffStride = diffWidth * leftBytesPerPixel;

                    int    pixelCount = diffHeight * diffStride;
                    double totalAbsoluteDifference = 0;
                    double totalSquareDifference   = 0;

                    int[] diffInts = null;
                    if (createDiffImage)
                    {
                        diffInts = new int[leftHeight * leftStride];
                    }
                    int maxDiff = 0;
                    for (int row = 0; row < diffHeight; ++row)
                    {
                        for (int col = 0; col < diffStride; ++col)
                        {
                            int difference = rightBytes[col + row * rightStride] - leftBytes[col + row * leftStride];

                            totalAbsoluteDifference += Math.Abs(difference);
                            totalSquareDifference   += difference * difference;

                            if (createDiffImage)
                            {
                                diffInts[col + row * diffStride] = difference;
                            }
                            if (difference > maxDiff)
                            {
                                maxDiff = difference;
                            }
                            else if (difference < -maxDiff)
                            {
                                maxDiff = (short)-difference;
                            }
                        }
                    }

                    if (createDiffImage)
                    {
                        byte[] diffBytes = new byte[leftHeight * leftStride];
                        double scale     = 1;
                        if (maxDiff != 0)
                        {
                            scale = 127.0 / (double)maxDiff;
                        }
                        for (int i = 0; i < diffInts.Length; ++i)
                        {
                            diffBytes[i] = (byte)((double)diffInts[i] * scale + 128.0);
                        }
                        Result = BitmapSource.Create(diffWidth, diffHeight, leftFrame.DpiX, leftFrame.DpiY, leftFrame.Format, null, diffBytes, diffStride);
                    }

                    AverageAbsoluteDifference = (totalAbsoluteDifference / (double)pixelCount);
                    AverageSquareDifference   = (totalSquareDifference / (double)pixelCount);
                }
            }
        }
예제 #26
0
 public static byte[] ImageToBinary(BitmapFrame frame)
 {
     byte[] data = new byte[frame.PixelWidth * frame.PixelHeight];
     frame.CopyPixels(data, frame.PixelWidth, 0);
     return(data);
 }