internal InteropBitmap(IntPtr hbitmap, IntPtr hpalette, Int32Rect sourceRect, BitmapSizeOptions sizeOptions, WICBitmapAlphaChannelOption alphaOptions) : base(true) // Use virtuals { _bitmapInit.BeginInit(); using (FactoryMaker myFactory = new FactoryMaker()) { HRESULT.Check(UnsafeNativeMethods.WICImagingFactory.CreateBitmapFromHBITMAP( myFactory.ImagingFactoryPtr, hbitmap, hpalette, alphaOptions, out _unmanagedSource)); Debug.Assert (_unmanagedSource != null && !_unmanagedSource.IsInvalid); } _unmanagedSource.CalculateSize(); _sizeOptions = sizeOptions; _sourceRect = sourceRect; _syncObject = _unmanagedSource; _bitmapInit.EndInit(); FinalizeCreation(); }
public static Int32Rect ToInt32Rect(this Rect rect) { Int32Rect intRect = new Int32Rect( (int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height); return intRect; }
/// <summary> /// Construct a CroppedBitmap /// </summary> /// <param name="source">BitmapSource to apply to the crop to</param> /// <param name="sourceRect">Source rect of the bitmap to use</param> public CroppedBitmap(BitmapSource source, Int32Rect sourceRect) : base(true) // Use base class virtuals { if (source == null) { throw new ArgumentNullException("source"); } _bitmapInit.BeginInit(); Source = source; SourceRect = sourceRect; _bitmapInit.EndInit(); FinalizeCreation(); }
private unsafe void BackgroundBlockRenderer() { #if DEBUG Debug.WriteLine("BackgroundBlockRenderer: Started"); #endif if (_graphicBuffer == null) { #if DEBUG Debug.WriteLine("BackgroundBlockRenderer: Aborted (graphic = null)"); #endif return; } IsRendering = true; try { while (true) { TilesetEntryModel dirtyBlock = null; try { dirtyBlock = _blocks.First(p => p.Dirty); } catch (InvalidOperationException) { break; } RenderProgress = 100 - (int)((100f / (float)_blocks.Count) * (float)_blocks.Count(p => p.Dirty)); //targets for tile copies WriteableBitmap newBlockImage = new WriteableBitmap(16, 16, 96, 96, PixelFormats.Bgra32, null); WriteableBitmap newBlockImageOverlay = new WriteableBitmap(16, 16, 96, 96, PixelFormats.Bgra32, null); newBlockImage.Lock(); byte *blockData = (byte *)newBlockImage.BackBuffer; newBlockImageOverlay.Lock(); byte *blockDataOverlay = (byte *)newBlockImageOverlay.BackBuffer; //copy tiles for (int k = 0; k < 5; k += 4) { for (int i = 0; i < 4; i++) { //TODO hflip and vflip Int32Rect pos = new Int32Rect((i == 1 || i == 3) ? 8 : 0, (i == 2 || i == 3) ? 8 : 0, 8, 8); WriteableBitmap tile = GetTile(dirtyBlock.Tilemap[i + k].TileID); IList <Color> currentPalette = _palettes[dirtyBlock.Tilemap[i + k].PalIndex].Value.Colors.Select(p => p.Color).ToList(); currentPalette[0] = Color.FromArgb(0, 0, 0, 0); //color 0 = transparent ChangePalette(ref tile, new BitmapPalette(currentPalette)); WriteableBitmap fbitmap = new WriteableBitmap(new FormatConvertedBitmap(tile, PixelFormats.Bgra32, null, 0)); fbitmap.Lock(); byte *fbData = (byte *)fbitmap.BackBuffer; ((k == 0) ? newBlockImage : newBlockImageOverlay).WritePixels(pos, (IntPtr)fbData, 256, 32); fbitmap.Unlock(); } } newBlockImageOverlay.AddDirtyRect(new Int32Rect(0, 0, 16, 16)); newBlockImageOverlay.Unlock(); newBlockImage.AddDirtyRect(new Int32Rect(0, 0, 16, 16)); newBlockImage.Unlock(); //merge targets AddTransparentBlock(newBlockImage, newBlockImageOverlay); newBlockImage.Freeze(); Application.Current.Dispatcher.Invoke(DispatcherPriority.Background, new Action(() => { dirtyBlock.Graphic = newBlockImage; dirtyBlock.Dirty = false; })); } } catch (ThreadAbortException) { #if DEBUG Debug.WriteLine("BackgroundBlockRenderer: Aborted"); #endif } #if DEBUG Debug.WriteLine("BackgroundBlockRenderer: Ended"); #endif IsRendering = false; }
/// <summary> /// Renders the specified media block. /// This needs to return immediately so the calling thread is not disturbed. /// </summary> /// <param name="mediaBlock">The media block.</param> /// <param name="clockPosition">The clock position.</param> public void Render(MediaBlock mediaBlock, TimeSpan clockPosition) { var block = mediaBlock as VideoBlock; if (block == null) { return; } if (IsRenderingInProgress) { return; } IsRenderingInProgress = true; Utils.UIEnqueueInvoke( DispatcherPriority.Render, new Action <VideoBlock, TimeSpan>((b, cP) => { try { if (TargetBitmap == null || TargetBitmap.PixelWidth != b.PixelWidth || TargetBitmap.PixelHeight != b.PixelHeight) { InitializeTargetBitmap(b); } var updateRect = new Int32Rect(0, 0, b.PixelWidth, b.PixelHeight); TargetBitmap.WritePixels(updateRect, b.Buffer, b.BufferLength, b.BufferStride); MediaElement.RaiseRenderingVideoEvent(TargetBitmap, MediaElement.Container.MediaInfo.Streams[b.StreamIndex], b.StartTime, b.Duration, cP); var scaleTransform = MediaElement.ViewBox.LayoutTransform as ScaleTransform; // Process Aspect Ratio according to block. if (b.AspectWidth != b.AspectHeight) { var scaleX = b.AspectWidth > b.AspectHeight ? (double)b.AspectWidth / b.AspectHeight : 1d; var scaleY = b.AspectHeight > b.AspectWidth ? (double)b.AspectHeight / b.AspectWidth : 1d; if (scaleTransform == null) { scaleTransform = new ScaleTransform(scaleX, scaleY); MediaElement.ViewBox.LayoutTransform = scaleTransform; } if (scaleTransform.ScaleX != scaleX || scaleTransform.ScaleY != scaleY) { scaleTransform.ScaleX = scaleX; scaleTransform.ScaleY = scaleY; } } else { if (scaleTransform != null && (scaleTransform.ScaleX != 1d || scaleTransform.ScaleY != 1d)) { scaleTransform.ScaleX = 1d; scaleTransform.ScaleY = 1d; } } } catch (Exception ex) { Utils.Log(MediaElement, MediaLogMessageType.Error, $"{nameof(VideoRenderer)} {ex.GetType()}: {ex.Message}. Stack Trace:\r\n{ex.StackTrace}"); } finally { IsRenderingInProgress = false; } }), block, clockPosition); }
public override WriteableBitmap Draw(DrawingArgs args) { int scale = (int)args.Scale; var h = args.CanvasHeight; var w = h; var fractalBitmap = new WriteableBitmap(w * scale, h * scale, 96.0, 96.0, PixelFormats.Bgra32, null); h = h * scale; w = w * scale; var stride = w * 4; var pixelData = new byte[h * stride]; double xMin = double.NaN; double yMin = double.NaN; double xMax = double.NaN; double yMax = double.NaN; double r = CalculateR(C); if (Double.IsNaN(xMin) || Double.IsNaN(xMax) || Double.IsNaN(yMin) || Double.IsNaN(yMax)) { xMin = -r; yMin = -r; xMax = r; yMax = r; } double xStep = Math.Abs(xMax - xMin) / w; double yStep = Math.Abs(yMax - yMin) / h; var xyIdx = new Dictionary <int, IDictionary <int, int> >(); int maxIdx = 0; for (int i = 0; i < w; i++) { xyIdx.Add(i, new Dictionary <int, int>()); for (int j = 0; j < h; j++) { double x = xMin + i * xStep; double y = yMin + j * yStep; var z = new Complex(x, y); var zIter = SqPolyIteration(z, C, args.IterationsCount, r); int idx = zIter.Count - 1; if (maxIdx < idx) { maxIdx = idx; } xyIdx[i].Add(j, idx); } } for (int i = 0; i < w; i++) { for (int j = 0; j < h; j++) { int idx = xyIdx[i][j]; double x = xMin + i * xStep; double y = yMin + j * yStep; var z = new Complex(x, y); var color = ComplexHeatMap(idx, 0, maxIdx, z, r); pixelData[j * stride + (w - i - 1) * 4 + 0] = color.R; pixelData[j * stride + (w - i - 1) * 4 + 1] = color.G; pixelData[j * stride + (w - i - 1) * 4 + 2] = color.B; pixelData[j * stride + (w - i - 1) * 4 + 3] = color.A; } } var rect = new Int32Rect(0, 0, w - 1, h - 1); var rawStride = (w * PixelFormats.Bgra32.BitsPerPixel + 7) / 8; fractalBitmap.WritePixels(rect, pixelData, rawStride, 0); return(fractalBitmap); }
/// <summary> /// Draw qrCode dark modules at given position. (It will also include quiet zone area. Set it to zero to exclude quiet zone) /// </summary> /// <exception cref="ArgumentNullException">Bitmatrix, wBitmap should not equal to null</exception> /// <exception cref="ArgumentOutOfRangeException">wBitmap's pixel width or height should not equal to zero</exception> public void DrawDarkModule(WriteableBitmap wBitmap, BitMatrix matrix, int offsetX, int offsetY) { if (matrix == null) { throw new ArgumentNullException("Bitmatrix"); } DrawingSize size = ISize.GetSize(matrix.Width); if (wBitmap == null) { throw new ArgumentNullException("wBitmap"); } else if (wBitmap.PixelHeight == 0 || wBitmap.PixelWidth == 0) { throw new ArgumentOutOfRangeException("wBitmap", "WriteableBitmap's pixelHeight or PixelWidth are equal to zero"); } int padding = (size.CodeWidth - size.ModuleSize * matrix.Width) / 2; int preX = -1; int moduleSize = size.ModuleSize; if (moduleSize == 0) { return; } for (int y = 0; y < matrix.Width; y++) { for (int x = 0; x < matrix.Width; x++) { if (matrix[x, y]) { if (preX == -1) { preX = x; } if (x == matrix.Width - 1) { Int32Rect moduleArea = new Int32Rect(preX * moduleSize + padding + offsetX, y * moduleSize + padding + offsetY, (x - preX + 1) * moduleSize, moduleSize); wBitmap.FillRectangle(moduleArea, DarkColor); preX = -1; } } else if (preX != -1) { Int32Rect moduleArea = new Int32Rect(preX * moduleSize + padding + offsetX, y * moduleSize + padding + offsetY, (x - preX) * moduleSize, moduleSize); wBitmap.FillRectangle(moduleArea, DarkColor); preX = -1; } } } }
[FriendAccessAllowed] // Built into Core, also used by Framework. unsafe internal void CriticalCopyPixels(Int32Rect sourceRect, Array pixels, int stride, int offset) { ReadPreamble(); _bitmapInit.EnsureInitializedComplete(); CompleteDelayedCreation(); if (pixels == null) throw new System.ArgumentNullException("pixels"); if (pixels.Rank != 1) throw new ArgumentException(SR.Get(SRID.Collection_BadRank), "pixels"); if (offset < 0) { HRESULT.Check((int)WinCodecErrors.WINCODEC_ERR_VALUEOVERFLOW); } int elementSize = -1; if (pixels is byte[]) elementSize = 1; else if (pixels is short[] || pixels is ushort[]) elementSize = 2; else if (pixels is int[] || pixels is uint[] || pixels is float[]) elementSize = 4; else if (pixels is double[]) elementSize = 8; if (elementSize == -1) throw new ArgumentException(SR.Get(SRID.Image_InvalidArrayForPixel)); int destBufferSize = checked(elementSize * (pixels.Length - offset)); if (pixels is byte[]) { fixed (void* pixelArray = &((byte[])pixels)[offset]) CriticalCopyPixels(sourceRect, (IntPtr)pixelArray, destBufferSize, stride); } else if (pixels is short[]) { fixed (void* pixelArray = &((short[])pixels)[offset]) CriticalCopyPixels(sourceRect, (IntPtr)pixelArray, destBufferSize, stride); } else if (pixels is ushort[]) { fixed (void* pixelArray = &((ushort[])pixels)[offset]) CriticalCopyPixels(sourceRect, (IntPtr)pixelArray, destBufferSize, stride); } else if (pixels is int[]) { fixed (void* pixelArray = &((int[])pixels)[offset]) CriticalCopyPixels(sourceRect, (IntPtr)pixelArray, destBufferSize, stride); } else if (pixels is uint[]) { fixed (void* pixelArray = &((uint[])pixels)[offset]) CriticalCopyPixels(sourceRect, (IntPtr)pixelArray, destBufferSize, stride); } else if (pixels is float[]) { fixed (void* pixelArray = &((float[])pixels)[offset]) CriticalCopyPixels(sourceRect, (IntPtr)pixelArray, destBufferSize, stride); } else if (pixels is double[]) { fixed (void* pixelArray = &((double[])pixels)[offset]) CriticalCopyPixels(sourceRect, (IntPtr)pixelArray, destBufferSize, stride); } }
private void CreateOrUpdateBitmap(bool isPopup, Rect dirtyRect, IntPtr buffer, int width, int height, Image image, ref Size currentSize, ref MemoryMappedFile mappedFile, ref MemoryMappedViewAccessor viewAccessor) { if (image.Dispatcher.HasShutdownStarted) { return; } var createNewBitmap = false; lock (lockObject) { int pixels = width * height; int numberOfBytes = pixels * BytesPerPixel; createNewBitmap = mappedFile == null || currentSize.Height != height || currentSize.Width != width; if (createNewBitmap) { ReleaseMemoryMappedView(ref mappedFile, ref viewAccessor); mappedFile = MemoryMappedFile.CreateNew(null, numberOfBytes, MemoryMappedFileAccess.ReadWrite); viewAccessor = mappedFile.CreateViewAccessor(); currentSize.Height = height; currentSize.Width = width; } //TODO: Performance analysis to determine which is the fastest memory copy function //NativeMethodWrapper.CopyMemoryUsingHandle(viewAccessor.SafeMemoryMappedViewHandle.DangerousGetHandle(), buffer, numberOfBytes); CopyMemory(viewAccessor.SafeMemoryMappedViewHandle.DangerousGetHandle(), buffer, (uint)numberOfBytes); //Take a reference to the backBufferHandle, once we're on the UI thread we need to check if it's still valid var backBufferHandle = mappedFile.SafeMemoryMappedFileHandle; //Invoke on the WPF UI Thread image.Dispatcher.BeginInvoke((Action)(() => { lock (lockObject) { if (backBufferHandle.IsClosed || backBufferHandle.IsInvalid) { return; } if (createNewBitmap) { if (image.Source != null) { image.Source = null; //TODO: Is this still required in newer versions of .Net? GC.Collect(1); } var stride = width * BytesPerPixel; var bitmap = (InteropBitmap)Imaging.CreateBitmapSourceFromMemorySection(backBufferHandle.DangerousGetHandle(), width, height, PixelFormat, stride, 0); image.Source = bitmap; } else { if (image.Source != null) { var sourceRect = new Int32Rect(dirtyRect.X, dirtyRect.Y, dirtyRect.Width, dirtyRect.Height); var bitmap = (InteropBitmap)image.Source; bitmap.Invalidate(sourceRect); } } } }), dispatcherPriority); } }
// AddZone // Adds the specified Zone to the end of the Zones list, and fires a property changed notification for the Zones property public void AddZone(Int32Rect zone) { Zones.Add(zone); TemplateZoneCount = Zones.Count; UpdateLayout(); }
private void SaveFrame(SafeMILHandle frameEncodeHandle, SafeMILHandle encoderOptions, BitmapFrame frame) { SetupFrame(frameEncodeHandle, encoderOptions); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeInitialized; // Set the size HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.SetSize( frameEncodeHandle, frame.PixelWidth, frame.PixelHeight )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeSizeSet; // Set the resolution double dpiX = frame.DpiX; double dpiY = frame.DpiY; if (dpiX <= 0) { dpiX = 96; } if (dpiY <= 0) { dpiY = 96; } HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.SetResolution( frameEncodeHandle, dpiX, dpiY )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeResolutionSet; if (_supportsFrameThumbnails) { // Set the thumbnail. BitmapSource thumbnail = frame.Thumbnail; if (thumbnail != null) { SafeMILHandle thumbnailHandle = thumbnail.WicSourceHandle; lock (thumbnail.SyncObject) { HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.SetThumbnail( frameEncodeHandle, thumbnailHandle )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeThumbnailSet; } } } // if the source has been color corrected, we want to use a corresponding color profile if (frame._isColorCorrected) { ColorContext colorContext = new ColorContext(frame.Format); IntPtr[] colorContextPtrs = new IntPtr[1] { colorContext.ColorContextHandle.DangerousGetHandle() }; int hr = UnsafeNativeMethods.WICBitmapFrameEncode.SetColorContexts( frameEncodeHandle, 1, colorContextPtrs ); // It's possible that some encoders may not support color contexts so don't check hr if (hr == HRESULT.S_OK) { // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeColorContextsSet; } } // if the caller has explicitly provided color contexts, add them to the encoder else { IList<ColorContext> colorContexts = frame.ColorContexts; if (colorContexts != null && colorContexts.Count > 0) { int count = colorContexts.Count; // Marshal can't convert SafeMILHandle[] so we must { IntPtr[] colorContextPtrs = new IntPtr[count]; for (int i = 0; i < count; ++i) { colorContextPtrs[i] = colorContexts[i].ColorContextHandle.DangerousGetHandle(); } int hr = UnsafeNativeMethods.WICBitmapFrameEncode.SetColorContexts( frameEncodeHandle, (uint)count, colorContextPtrs ); // It's possible that some encoders may not support color contexts so don't check hr if (hr == HRESULT.S_OK) { // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeColorContextsSet; } } } } // Set the pixel format and palette lock (frame.SyncObject) { SafeMILHandle outSourceHandle = new SafeMILHandle(); SafeMILHandle bitmapSourceHandle = frame.WicSourceHandle; SafeMILHandle paletteHandle = new SafeMILHandle(); // Set the pixel format and palette of the bitmap. // This could (but hopefully won't) introduce a format converter. HRESULT.Check(UnsafeNativeMethods.WICCodec.WICSetEncoderFormat( bitmapSourceHandle, paletteHandle, frameEncodeHandle, out outSourceHandle )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeFormatSet; _writeSourceHandles.Add(outSourceHandle); // Set the metadata if (_supportsFrameMetadata) { BitmapMetadata metadata = frame.Metadata as BitmapMetadata; // If the frame has metadata associated with a different container format, then we ignore it. if (metadata != null && metadata.GuidFormat == ContainerFormat) { SafeMILHandle /* IWICMetadataQueryWriter */ metadataHandle = new SafeMILHandle(); HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.GetMetadataQueryWriter( frameEncodeHandle, out metadataHandle )); PROPVARIANT propVar = new PROPVARIANT(); try { propVar.Init(metadata); lock (metadata.SyncObject) { HRESULT.Check(UnsafeNativeMethods.WICMetadataQueryWriter.SetMetadataByName( metadataHandle, "/", ref propVar )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeMetadataSet; } } finally { propVar.Clear(); } } } Int32Rect r = new Int32Rect(); HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.WriteSource( frameEncodeHandle, outSourceHandle, ref r )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeSourceWritten; HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.Commit( frameEncodeHandle )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeCommitted; } }
private unsafe void InitializeNewResultImage(ManagedImage mImg) { //byte* managedImageDataPtr = mImg.data; IntPtr dataPtr = new IntPtr(managedImageDataPtr); m_pixelsFormat = mImg.pixelFormat; ManagedImage manImg = new ManagedImage(); if (m_pixelsFormat == PixelFormat.PixelFormatMono12 || m_pixelsFormat == PixelFormat.PixelFormatMono16 || m_pixelsFormat == PixelFormat.PixelFormatMono8 || m_pixelsFormat == PixelFormat.PixelFormatSignedMono16) { mImg.Convert(PixelFormat.PixelFormatMono8, manImg); } else { mImg.Convert(PixelFormat.PixelFormatBgr, manImg); } int height = (int)manImg.rows, width = (int)manImg.cols, stride = (int)manImg.stride, dataSize = height * stride, bpp = (int)manImg.bitsPerPixel / 8; byte *imageData = manImg.data; //byte[] imgData = new byte[dataSize]; //Marshal.Copy(dataPtr, imgData, 0, dataSize); Point cursorPosition = this.CurrentCursorPosition; int xRec = (int)(cursorPosition.X / this.VideoStreamAreaActualWidth * width), yRec = (int)(cursorPosition.Y / this.VideoStreamAreaActualHeight * height); Int32Rect rec = GetValidRectangle(xRec, yRec, width, height); m_currentRec = rec; byte[] currBytes = new byte[rec.Height * rec.Width * bpp]; ManagedImage managImgForWrbmp = new ManagedImage(); manImg.ConvertToWriteAbleBitmap(managImgForWrbmp); WriteableBitmap bmpTemp = managImgForWrbmp.writeableBitmap; bmpTemp.CopyPixels(rec, currBytes, rec.Width * bpp, 0); m_currentBytes = currBytes; OnSetNeededCameraProperty(); OnCurrentBytesUpdated(); int xBegin = rec.X, xEnd = rec.X + rec.Width, yBegin = rec.Y, yEnd = rec.Y + rec.Height; for (int xPix = xBegin; xPix <= xEnd; xPix++) { for (int yPix = yBegin; yPix <= yEnd; yPix++) { if (yPix == yBegin || yPix == yEnd || xPix == xBegin || xPix == xEnd) { int pixelPosition = yPix * stride + xPix * bpp; if (manImg.pixelFormat == PixelFormat.PixelFormatBgr) { imageData[pixelPosition] = 0; imageData[pixelPosition + 1] = 0; imageData[pixelPosition + 2] = 0; } else { imageData[pixelPosition] = 0; } } } } ManagedImage temp = new ManagedImage(); manImg.ConvertToBitmapSource(temp); temp.bitmapsource.Freeze(); this.NewResultImage = temp.bitmapsource; OnNewResultImageIsReady(); }
public ErrorCode ReadFrom(Uri requestUri, IEnumerable <KeyValuePair <string, string> > queryNameValuePairs) { foreach (var item in queryNameValuePairs) { switch (item.Key) { case "s": { var s = item.Value; if (s.StartsWith("//")) { s = requestUri.Scheme + ":" + s; } if (!Uri.TryCreate(s, UriKind.Absolute, out Source)) { return(ErrorCode.SourceUriFormatError); } } break; case "q": int quality; if (!TryConvert(item.Value, out quality)) { return(ErrorCode.QualityParseError); } if (!(0 <= quality && quality <= 100)) { return(ErrorCode.QualityOutOfRange); } Quality = quality; break; case "w": int pixelWidth; if (!TryConvert(item.Value, out pixelWidth)) { return(ErrorCode.PixelWidthParseError); } if (pixelWidth < 0) { return(ErrorCode.PixelWidthOutOfRange); } PixelWidth = pixelWidth; break; case "h": int pixelHeight; if (!TryConvert(item.Value, out pixelHeight)) { return(ErrorCode.PixelHeightParseError); } if (pixelHeight < 0) { return(ErrorCode.PixelHeightOutOfRange); } PixelHeight = pixelHeight; break; case "t": ImageType type; if (!Enum.TryParse(item.Value, true, out type)) { return(ErrorCode.ImageTypeParseError); } if (type == 0) { return(ErrorCode.ImageTypeOutOfRange); } Type = type; break; case "c": if (item.Value == "smart") { CropSmart = true; break; } // the crop rectange is in percentages, // based on the source image dimension // we use this to get the actual crop Int32Rect crop; try { crop = Int32Rect.Parse(item.Value); } catch (Exception) { return(ErrorCode.CropRectParseError); } if (!((0 <= (crop.X + crop.Width)) & (crop.X + crop.Width) <= 100)) { return(ErrorCode.CropRectOutOfRange); } if (!((0 <= (crop.Y + crop.Height)) & (crop.Y + crop.Height) <= 100)) { return(ErrorCode.CropRectOutOfRange); } Crop = crop; break; case "f": FittingType fit; if (!Enum.TryParse(item.Value, true, out fit)) { return(ErrorCode.FittingTypeParseError); } Fit = fit; break; case "bg-color": try { if (HexPattern.IsMatch(item.Value)) { var s = item.Value; if (s.Length == 3) { // shorthand #fc0 -> #ffcc00 s = s.Substring(0, 1) + s.Substring(0, 1) + s.Substring(1, 1) + s.Substring(1, 1) + s.Substring(2, 1) + s.Substring(2, 1) ; } BackgroundColor = (Color)ColorConverter.ConvertFromString("#" + item.Value); } else { BackgroundColor = (Color)ColorConverter.ConvertFromString(item.Value); } } catch (Exception) { return(ErrorCode.BackgroundColorParseError); } break; case "debug": { IsDebug = item.Value == "1"; break; } } } if (Source == null) { return(ErrorCode.SourceIsRequired); } return(ErrorCode.None); }
public virtual void CopyPixels(Int32Rect sourceRect, Array pixels, int stride, int offset) { throw new NotImplementedException(); }
public virtual void CopyPixels(Int32Rect sourceRect, IntPtr butter, int bufferSize, int stride) { throw new NotImplementedException(); }
private void WriteObjectImage(VPort cameraPort, Bitmap image, Rectangle rectSrc, bool center) { Rectangle rectTarget = rectSrc; int srcPixelShiftX = 0; int srcPixelShiftY = 0; if (rectSrc.Width == 0 && rectSrc.Height == 0) { logger.Log("Write Object Image Called with Rect with zero height and width!"); return; } if (center) { rectTarget.X = (int)((image.Width - rectSrc.Width) / 2.0); rectTarget.Y = (int)((image.Height - rectSrc.Height) / 2.0); srcPixelShiftX = rectTarget.X - rectSrc.X; srcPixelShiftY = rectTarget.Y - rectSrc.Y; } // create the destination based upon layer one BitmapData bmpData = image.LockBits(new Rectangle(0, 0, image.Width, image.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); int stride = bmpData.Stride; image.UnlockBits(bmpData); WriteableBitmap composite = new WriteableBitmap(image.Width, image.Height, 96, 96, System.Windows.Media.PixelFormats.Rgb24, null); Int32Rect sourceRect = new Int32Rect(0, 0, (int)image.Width, (int)image.Height); byte[] pixels = new byte[stride * image.Height]; for (int x = 0; x < image.Width; ++x) { for (int y = 0; y < image.Height; ++y) { if (rectSrc.Contains(x, y)) { Color clr = image.GetPixel(x, y); pixels[stride * (y + srcPixelShiftY) + 3 * (x + srcPixelShiftX)] = clr.R; pixels[stride * (y + srcPixelShiftY) + 3 * (x + srcPixelShiftX) + 1] = clr.G; pixels[stride * (y + srcPixelShiftY) + 3 * (x + srcPixelShiftX) + 2] = clr.B; } else if (!rectTarget.Contains(x, y)) { pixels[stride * y + 3 * x] = 0x00; pixels[stride * y + 3 * x + 1] = 0x00; pixels[stride * y + 3 * x + 2] = 0x00; } } } composite.WritePixels(sourceRect, pixels, stride, 0); // encode the bitmap to the output file JpegBitmapEncoder encoder = new JpegBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(composite)); string filepath = GetMediaFileName(cameraPort.GetInfo().GetFriendlyName(), MediaType.MediaType_Image_JPEG); if (null == filepath) { logger.Log("GetMediaFileName failed to get a file name, are there more than 10 files of the same name?"); return; } using (var stream = new FileStream(filepath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read)) { encoder.Save(stream); } }
public void Invalidate(Int32Rect? dirtyRect) { SecurityHelper.DemandUnmanagedCode(); // A null dirty rect indicates the entire bitmap should be // invalidated, while a value indicates that only a dirty rect // should be invalidated. if (dirtyRect.HasValue) { dirtyRect.Value.ValidateForDirtyRect("dirtyRect", _pixelWidth, _pixelHeight); if (!dirtyRect.Value.HasArea) { // Nothing needs done. return; } } WritePreamble(); if (_unmanagedSource != null) { if(UsableWithoutCache) { // For bitmap sources that do not require caching on the // UI thread, we can just add a dirty rect to the // CWICWrapperBitmap. The render thread will respond by // updating the affected realizations by copying from this // bitmap. Since this bitmap is not cached, it will get // the most current bits. unsafe { for (int i = 0, numChannels = _duceResource.GetChannelCount(); i < numChannels; ++i) { DUCE.Channel channel = _duceResource.GetChannel(i); DUCE.MILCMD_BITMAP_INVALIDATE data; data.Type = MILCMD.MilCmdBitmapInvalidate; data.Handle = _duceResource.GetHandle(channel); bool useDirtyRect = dirtyRect.HasValue; if(useDirtyRect) { data.DirtyRect.left = dirtyRect.Value.X; data.DirtyRect.top = dirtyRect.Value.Y; data.DirtyRect.right = dirtyRect.Value.X + dirtyRect.Value.Width; data.DirtyRect.bottom = dirtyRect.Value.Y + dirtyRect.Value.Height; } data.UseDirtyRect = (uint)(useDirtyRect ? 1 : 0); channel.SendCommand((byte*)&data, sizeof(DUCE.MILCMD_BITMAP_INVALIDATE)); } } } else { // For bitmap sources that require caching on the // UI thread, we can't just add a dirty rect to the // CWICWrapperBitmap because it will just read the cached // contents again. We really need a caching bitmap // implementation that understands dirty rects and will // update its cache. Unfortunately, today the caching // bitmap is a standard WIC implementation, and does not // support this functionality. // // For now, we just recreate the caching bitmap. Setting // _needsUpdate to true will cause BitmapSource to throw // away the old DUCECompatiblePtr, and create a new caching // bitmap to send to the render thread. Since the render // thread sees a brand new bitmap, it will copy the bits out. _needsUpdate = true; RegisterForAsyncUpdateResource(); } } WritePostscript(); }
public static byte[] ExtractPixelSection(byte[] sourcePixels, int sourceBitsPerPixel, int sourceStride, Int32Rect sectionRect, System.Drawing.Color[] transparentColors) { int length = sectionRect.Width * sectionRect.Height * 4; int num1 = sourceBitsPerPixel / 8; bool flag = false; if (sourceBitsPerPixel == 32) { flag = true; int num2 = 0; while (num2 < sourcePixels.Length) { if (sourcePixels[num2 + 3] != 0) { flag = false; break; } num2 += 4; } } byte[] numArray = new byte[length]; for (int index1 = 0; index1 < sectionRect.Height; ++index1) { for (int index2 = 0; index2 < sectionRect.Width; ++index2) { var cDisplayClass50 = new ColorClass(); int index3 = (index2 + sectionRect.X) * num1 + (index1 + sectionRect.Y) * sourceStride; int index4 = index2 * 4 + index1 * (sectionRect.Width * 4); byte num2 = sourcePixels[index3]; byte num3 = sourcePixels[index3 + 1]; byte num4 = sourcePixels[index3 + 2]; byte num5 = sourceBitsPerPixel == 32 ? sourcePixels[index3 + 3] : byte.MaxValue; cDisplayClass50.C = System.Drawing.Color.FromArgb(num4, num3, num2); if (Array.FindIndex(transparentColors, cDisplayClass50.IsEquals) != -1) { num5 = 0; } else if (flag) { num5 = byte.MaxValue; } if (num5 == 0) { num2 = 0; num3 = 0; num4 = 0; } numArray[index4] = num2; numArray[index4 + 1] = num3; numArray[index4 + 2] = num4; numArray[index4 + 3] = num5; } } return(numArray); }
public void imageMode(object sender, RoutedEventArgs e) { var screen = new OpenFileDialog(); screen.Filter = "Image files (*.jpg, *.jpeg, *.jpe, *.jfif, *.png) | *.jpg; *.jpeg; *.jpe; *.jfif; *.png"; screen.InitialDirectory = @"C:\"; screen.Title = "Please select an image file to encrypt."; if (screen.ShowDialog() == true) { filePath = screen.FileName; var source = new BitmapImage( new Uri(screen.FileName, UriKind.Absolute)); previewImage.Width = 300; previewImage.Height = 240; previewImage.Source = source; // Bat dau cat thanh 9 manh int count = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (!((i == 2) && (j == 2))) { TransformedBitmap mybitmapIMG; if (source.Height > source.Width) { double scaleTransfH = 300 / source.Height; mybitmapIMG = new TransformedBitmap(source, new ScaleTransform(scaleTransfH, scaleTransfH)); imgWidth = (int)(mybitmapIMG.PixelWidth / 3); imgHeight = (int)(mybitmapIMG.PixelHeight / 3); } else { double scaleTransfW = 300 / source.Width; mybitmapIMG = new TransformedBitmap(source, new ScaleTransform(scaleTransfW, scaleTransfW)); imgWidth = (int)(mybitmapIMG.PixelWidth / 3); imgHeight = (int)(mybitmapIMG.PixelHeight / 3); } drawLines(startX, startY, imgWidth, imgHeight); var rect = new Int32Rect(j * imgWidth, i * imgHeight, imgWidth, imgHeight); var cropBitmap = new CroppedBitmap(mybitmapIMG, rect); var cropImage = new Image(); cropImage.Stretch = Stretch.Fill; cropImage.Width = imgWidth; cropImage.Height = imgHeight; cropImage.Source = cropBitmap; canvas.Children.Add(cropImage); Canvas.SetLeft(cropImage, startX + j * (imgWidth + 2)); Canvas.SetTop(cropImage, startY + i * (imgHeight + 2)); cropImage.MouseLeftButtonDown += CropImage_MouseLeftButtonDown; cropImage.PreviewMouseLeftButtonUp += CropImage_MouseLeftButtonUp; cropImage.Tag = new Tuple <int, int>(i, j); cropImage.Name = $"s{count}"; listCropImg.Add(cropImage); count++; } } } Image nullImage = new Image(); listCropImg.Add(nullImage); } else { this.Window_Loaded(sender, e); } }
public static byte[] ExtractPixelSection(byte[] sourcePixels, int sourceBitsPerPixel, int sourceStride, Int32Rect sectionRect) { System.Drawing.Color[] transparentColors = { System.Drawing.Color.FromArgb(0, 254, 0), System.Drawing.Color.FromArgb(byte.MaxValue, 0, byte.MaxValue) }; return(ExtractPixelSection(sourcePixels, sourceBitsPerPixel, sourceStride, sectionRect, transparentColors)); }
public virtual void CopyPixels(Int32Rect sourceRect, Array pixels, int stride, int offset) { EnsureShouldUseVirtuals(); // Demand Site Of origin on the URI if it passes then this information is ok to expose CheckIfSiteOfOrigin(); CriticalCopyPixels(sourceRect, pixels, stride, offset); }
// UpdateLayoutModels // Update the five default layouts based on the new ZoneCount private void UpdateLayoutModels() { // Update the "Focus" Default Layout _focusModel.Zones.Clear(); // Sanity check for imported settings that may have invalid data if (ZoneCount < 1) { ZoneCount = 3; } // If changing focus layout zones size and/or increment, // same change should be applied in ZoneSet.cpp (ZoneSet::CalculateFocusLayout) Int32Rect focusZoneRect = new Int32Rect(100, 100, (int)(WorkArea.Width * 0.4), (int)(WorkArea.Height * 0.4)); int focusRectXIncrement = (ZoneCount <= 1) ? 0 : 50; int focusRectYIncrement = (ZoneCount <= 1) ? 0 : 50; for (int i = 0; i < ZoneCount; i++) { _focusModel.Zones.Add(focusZoneRect); focusZoneRect.X += focusRectXIncrement; focusZoneRect.Y += focusRectYIncrement; } // Update the "Rows" and "Columns" Default Layouts // They can share their model, just transposed _rowsModel.CellChildMap = new int[ZoneCount, 1]; _columnsModel.CellChildMap = new int[1, ZoneCount]; _rowsModel.Rows = _columnsModel.Columns = ZoneCount; _rowsModel.RowPercents = _columnsModel.ColumnPercents = new List <int>(ZoneCount); for (int i = 0; i < ZoneCount; i++) { _rowsModel.CellChildMap[i, 0] = i; _columnsModel.CellChildMap[0, i] = i; // Note: This is NOT equal to _multiplier / ZoneCount and is done like this to make // the sum of all RowPercents exactly (_multiplier). // _columnsModel is sharing the same array _rowsModel.RowPercents.Add(((_multiplier * (i + 1)) / ZoneCount) - ((_multiplier * i) / ZoneCount)); } // Update the "Grid" Default Layout int rows = 1; while (ZoneCount / rows >= rows) { rows++; } rows--; int cols = ZoneCount / rows; if (ZoneCount % rows == 0) { // even grid } else { cols++; } _gridModel.Rows = rows; _gridModel.Columns = cols; _gridModel.RowPercents = new List <int>(rows); _gridModel.ColumnPercents = new List <int>(cols); _gridModel.CellChildMap = new int[rows, cols]; // Note: The following are NOT equal to _multiplier divided by rows or columns and is // done like this to make the sum of all RowPercents exactly (_multiplier). for (int row = 0; row < rows; row++) { _gridModel.RowPercents.Add(((_multiplier * (row + 1)) / rows) - ((_multiplier * row) / rows)); } for (int col = 0; col < cols; col++) { _gridModel.ColumnPercents.Add(((_multiplier * (col + 1)) / cols) - ((_multiplier * col) / cols)); } int index = ZoneCount - 1; for (int col = cols - 1; col >= 0; col--) { for (int row = rows - 1; row >= 0; row--) { _gridModel.CellChildMap[row, col] = index--; if (index < 0) { index = 0; } } } // Update the "Priority Grid" Default Layout if (ZoneCount <= _priorityData.Length) { _priorityGridModel.Reload(_priorityData[ZoneCount - 1]); } else { // same as grid; _priorityGridModel.Rows = _gridModel.Rows; _priorityGridModel.Columns = _gridModel.Columns; _priorityGridModel.RowPercents = _gridModel.RowPercents; _priorityGridModel.ColumnPercents = _gridModel.ColumnPercents; _priorityGridModel.CellChildMap = _gridModel.CellChildMap; } }
static void ErasePixel(MouseEventArgs e) { byte[] ColorData = { 0, 0, 0, 0 }; // B G R Int32Rect rect = new Int32Rect( (int)(e.GetPosition(i).X), (int)(e.GetPosition(i).Y), 1, 1); writeableBitmap.WritePixels(rect, ColorData, 4, 0); }
public byte[] GetRectangle(Int32Rect rect) { return(GetRectangle(rect, _buffer)); }
private async void Window_Loaded(object sender, RoutedEventArgs e) { int count = 0; var title = default(string); while (running) { using (var transformedDepth = new Image(ImageFormat.Depth16, colorWidth, colorHeight, colorWidth * sizeof(UInt16))) using (var capture = await Task.Run(() => { return(this.kinect.GetCapture()); })) { count++; this.transform.DepthImageToColorCamera(capture, transformedDepth); this.bitmap.Lock(); var color = capture.Color; var region = new Int32Rect(0, 0, color.WidthPixels, color.HeightPixels); unsafe { using (var pin = color.Memory.Pin()) { this.bitmap.WritePixels(region, (IntPtr)pin.Pointer, (int)color.Size, color.StrideBytes); } if (boundingBox != null) { int y = (boundingBox.Y + boundingBox.H / 2); int x = (boundingBox.X + boundingBox.W / 2); this.StatusText = $"The {title} is: {transformedDepth.GetPixel<ushort>(y, x)} mm away"; this.Outline.Width = boundingBox.W; this.Outline.Height = boundingBox.H; this.Outline.SetValue(Canvas.LeftProperty, boundingBox.X / this.CompositeImage.ActualWidth * this.ImageView.ActualWidth); this.Outline.SetValue(Canvas.TopProperty, boundingBox.Y / this.CompositeImage.ActualHeight * this.ImageView.ActualHeight); } } this.bitmap.AddDirtyRect(region); this.bitmap.Unlock(); if (count % 30 == 0) { running = false; var stream = StreamFromBitmapSource(this.bitmap); var text = await computerVision.RecognizePrintedTextInStreamAsync(true, stream, OcrLanguages.En); if (text != null) { foreach (var textRegion in text.Regions) { if (textRegion.Lines != null && textRegion.Lines.Any()) { foreach (var line in textRegion.Lines) { Console.WriteLine(string.Join(" ", line.Words.Select(w => w.Text))); } } } } // title = await AnalyzeImage().ConfigureAwait(false); running = true; } } } }
private void SaveFrame(SafeMILHandle frameEncodeHandle, SafeMILHandle encoderOptions, BitmapFrame frame) { SetupFrame(frameEncodeHandle, encoderOptions); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeInitialized; // Set the size HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.SetSize( frameEncodeHandle, frame.PixelWidth, frame.PixelHeight )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeSizeSet; // Set the resolution double dpiX = frame.DpiX; double dpiY = frame.DpiY; if (dpiX <= 0) { dpiX = 96; } if (dpiY <= 0) { dpiY = 96; } HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.SetResolution( frameEncodeHandle, dpiX, dpiY )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeResolutionSet; if (_supportsFrameThumbnails) { // Set the thumbnail. BitmapSource thumbnail = frame.Thumbnail; if (thumbnail != null) { SafeMILHandle thumbnailHandle = thumbnail.WicSourceHandle; lock (thumbnail.SyncObject) { HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.SetThumbnail( frameEncodeHandle, thumbnailHandle )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeThumbnailSet; } } } // if the source has been color corrected, we want to use a corresponding color profile if (frame._isColorCorrected) { ColorContext colorContext = new ColorContext(frame.Format); IntPtr[] colorContextPtrs = new IntPtr[1] { colorContext.ColorContextHandle.DangerousGetHandle() }; int hr = UnsafeNativeMethods.WICBitmapFrameEncode.SetColorContexts( frameEncodeHandle, 1, colorContextPtrs ); // It's possible that some encoders may not support color contexts so don't check hr if (hr == HRESULT.S_OK) { // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeColorContextsSet; } } // if the caller has explicitly provided color contexts, add them to the encoder else { IList <ColorContext> colorContexts = frame.ColorContexts; if (colorContexts != null && colorContexts.Count > 0) { int count = colorContexts.Count; // Marshal can't convert SafeMILHandle[] so we must { IntPtr[] colorContextPtrs = new IntPtr[count]; for (int i = 0; i < count; ++i) { colorContextPtrs[i] = colorContexts[i].ColorContextHandle.DangerousGetHandle(); } int hr = UnsafeNativeMethods.WICBitmapFrameEncode.SetColorContexts( frameEncodeHandle, (uint)count, colorContextPtrs ); // It's possible that some encoders may not support color contexts so don't check hr if (hr == HRESULT.S_OK) { // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeColorContextsSet; } } } } // Set the pixel format and palette lock (frame.SyncObject) { SafeMILHandle outSourceHandle = new SafeMILHandle(); SafeMILHandle bitmapSourceHandle = frame.WicSourceHandle; SafeMILHandle paletteHandle = new SafeMILHandle(); // Set the pixel format and palette of the bitmap. // This could (but hopefully won't) introduce a format converter. HRESULT.Check(UnsafeNativeMethods.WICCodec.WICSetEncoderFormat( bitmapSourceHandle, paletteHandle, frameEncodeHandle, out outSourceHandle )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeFormatSet; _writeSourceHandles.Add(outSourceHandle); // Set the metadata if (_supportsFrameMetadata) { BitmapMetadata metadata = frame.Metadata as BitmapMetadata; // If the frame has metadata associated with a different container format, then we ignore it. if (metadata != null && metadata.GuidFormat == ContainerFormat) { SafeMILHandle /* IWICMetadataQueryWriter */ metadataHandle = new SafeMILHandle(); HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.GetMetadataQueryWriter( frameEncodeHandle, out metadataHandle )); PROPVARIANT propVar = new PROPVARIANT(); try { propVar.Init(metadata); lock (metadata.SyncObject) { HRESULT.Check(UnsafeNativeMethods.WICMetadataQueryWriter.SetMetadataByName( metadataHandle, "/", ref propVar )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeMetadataSet; } } finally { propVar.Clear(); } } } Int32Rect r = new Int32Rect(); HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.WriteSource( frameEncodeHandle, outSourceHandle, ref r )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeSourceWritten; HRESULT.Check(UnsafeNativeMethods.WICBitmapFrameEncode.Commit( frameEncodeHandle )); // Helpful for debugging stress and remote dumps _encodeState = EncodeState.FrameEncodeCommitted; } }
private async void Window_Loaded(object sender, RoutedEventArgs e) { Tracker tracker = Tracker.Create(this.kinect.GetCalibration(), new TrackerConfiguration() { ProcessingMode = TrackerProcessingMode.Gpu, SensorOrientation = SensorOrientation.Default }); while (running) { using (Capture capture = await Task.Run(() => { return(this.kinect.GetCapture()); })) { this.StatusText = "Received Capture: " + capture.Depth.DeviceTimestamp; this.bitmap.Lock(); var color = capture.Color; var region = new Int32Rect(0, 0, color.WidthPixels, color.HeightPixels); unsafe { using (var pin = color.Memory.Pin()) { this.bitmap.WritePixels(region, (IntPtr)pin.Pointer, (int)color.Size, color.StrideBytes); var bmpSource = BitmapSource.Create(color.WidthPixels, color.HeightPixels, 96.0, 96.0, PixelFormats.Bgr32, null, color.Memory.ToArray(), color.StrideBytes); // JpegBitmapEncoder to save BitmapSource to file // imageSerial is the serial of the sequential image JpegBitmapEncoder encoder = new JpegBitmapEncoder(); encoder.Frames.Add(BitmapFrame.Create(bmpSource)); using (var fs = new FileStream("./img/" + (imageSerial++) + ".jpeg", FileMode.Create, FileAccess.Write)) { encoder.Save(fs); } } } this.bitmap.AddDirtyRect(region); this.bitmap.Unlock(); tracker.EnqueueCapture(capture); } // Try getting latest tracker frame. using (Frame lastFrame = tracker.PopResult(TimeSpan.Zero, throwOnTimeout: false)) { if (lastFrame == null) { continue; } lock (lockObject) { List <Vector3> joints = new List <Vector3>(); for (uint i = 0; i < lastFrame.NumberOfBodies; ++i) { Skeleton skeleton = lastFrame.GetBodySkeleton(i); var bodyId = lastFrame.GetBodyId(i); for (int jointId = 0; jointId < (int)JointId.Count; ++jointId) { var joint = skeleton.GetJoint(jointId); joints.Add(joint.Position / 1000); } } jointsList.Add(joints); } } } }
protected override void CreateOrUpdateBitmap(bool isPopup, Rect dirtyRect, IntPtr buffer, int width, int height, Image image, ref Size currentSize, ref MemoryMappedFile mappedFile, ref MemoryMappedViewAccessor viewAccessor) { bool createNewBitmap = false; lock (lockObject) { int pixels = width * height; int numberOfBytes = pixels * BytesPerPixel; createNewBitmap = mappedFile == null || currentSize.Height != height || currentSize.Width != width; if (createNewBitmap) { //If the MemoryMappedFile is smaller than we need then create a larger one //If it's larger then we need then rather than going through the costly expense of //allocating a new one we'll just use the old one and only access the number of bytes we require. if (viewAccessor == null || viewAccessor.Capacity < numberOfBytes) { ReleaseMemoryMappedView(ref mappedFile, ref viewAccessor); mappedFile = MemoryMappedFile.CreateNew(null, numberOfBytes, MemoryMappedFileAccess.ReadWrite); viewAccessor = mappedFile.CreateViewAccessor(); } currentSize.Height = height; currentSize.Width = width; } NativeMethodWrapper.MemoryCopy(viewAccessor.SafeMemoryMappedViewHandle.DangerousGetHandle(), buffer, numberOfBytes); //Take a reference to the sourceBuffer that's used to update our WritableBitmap, //once we're on the UI thread we need to check if it's still valid var sourceBuffer = viewAccessor.SafeMemoryMappedViewHandle; image.Dispatcher.BeginInvoke((Action)(() => { lock (lockObject) { if (sourceBuffer.IsClosed || sourceBuffer.IsInvalid) { return; } if (createNewBitmap) { if (image.Source != null) { image.Source = null; GC.Collect(1); } image.Source = new WriteableBitmap(width, height, dpiX, dpiY, PixelFormat, null); } var stride = width * BytesPerPixel; var noOfBytes = stride * height; var bitmap = (WriteableBitmap)image.Source; //By default we'll only update the dirty rect, for those that run into a MILERR_WIN32ERROR Exception (#2035) //it's desirably to either upgrade to a newer .Net version (only client runtime needs to be installed, not compiled //against a newer version. Or invalidate the whole bitmap if (invalidateDirtyRect) { // Update the dirty region var sourceRect = new Int32Rect(dirtyRect.X, dirtyRect.Y, dirtyRect.Width, dirtyRect.Height); bitmap.Lock(); bitmap.WritePixels(sourceRect, sourceBuffer.DangerousGetHandle(), noOfBytes, stride, dirtyRect.X, dirtyRect.Y); bitmap.Unlock(); } else { // Update whole bitmap var sourceRect = new Int32Rect(0, 0, width, height); bitmap.Lock(); bitmap.WritePixels(sourceRect, sourceBuffer.DangerousGetHandle(), noOfBytes, stride); bitmap.Unlock(); } } }), dispatcherPriority); } }
public TileTextureItem(int textureId, Int32Rect rect, BitmapSource bitmap) { TextureId = textureId; Bitmap = bitmap; Rectangle = rect; }
// UpdateLayoutModels // Update the five default layouts based on the new ZoneCount private void UpdateLayoutModels() { int previousZoneCount = _focusModel.Zones.Count; // Update the "Focus" Default Layout _focusModel.Zones.Clear(); Int32Rect focusZoneRect = new Int32Rect((int)(_focusModel.ReferenceWidth * 0.1), (int)(_focusModel.ReferenceHeight * 0.1), (int)(_focusModel.ReferenceWidth * 0.6), (int)(_focusModel.ReferenceHeight * 0.6)); int focusRectXIncrement = (ZoneCount <= 1) ? 0 : (int)(_focusModel.ReferenceWidth * 0.2) / (ZoneCount - 1); int focusRectYIncrement = (ZoneCount <= 1) ? 0 : (int)(_focusModel.ReferenceHeight * 0.2) / (ZoneCount - 1); for (int i = 0; i < ZoneCount; i++) { _focusModel.Zones.Add(focusZoneRect); focusZoneRect.X += focusRectXIncrement; focusZoneRect.Y += focusRectYIncrement; } // Update the "Rows" and "Columns" Default Layouts // They can share their model, just transposed _rowsModel.CellChildMap = new int[ZoneCount, 1]; _columnsModel.CellChildMap = new int[1, ZoneCount]; _rowsModel.Rows = _columnsModel.Columns = ZoneCount; _rowsModel.RowPercents = _columnsModel.ColumnPercents = new int[ZoneCount]; for (int i = 0; i < ZoneCount; i++) { _rowsModel.CellChildMap[i, 0] = i; _columnsModel.CellChildMap[0, i] = i; _rowsModel.RowPercents[i] = c_multiplier / ZoneCount; // _columnsModel is sharing the same array } // Update the "Grid" Default Layout int rows = 1; int cols = 1; int mergeCount = 0; while (ZoneCount / rows >= rows) { rows++; } rows--; cols = ZoneCount / rows; if (ZoneCount % rows == 0) { // even grid } else { cols++; mergeCount = rows - (ZoneCount % rows); } _gridModel.Rows = rows; _gridModel.Columns = cols; _gridModel.RowPercents = new int[rows]; _gridModel.ColumnPercents = new int[cols]; _gridModel.CellChildMap = new int[rows, cols]; for (int row = 0; row < rows; row++) { _gridModel.RowPercents[row] = c_multiplier / rows; } for (int col = 0; col < cols; col++) { _gridModel.ColumnPercents[col] = c_multiplier / cols; } int index = 0; for (int col = cols - 1; col >= 0; col--) { for (int row = rows - 1; row >= 0; row--) { _gridModel.CellChildMap[row, col] = index++; if (index == ZoneCount) { index--; } } } // Update the "Priority Grid" Default Layout if (ZoneCount <= s_priorityData.Length) { _priorityGridModel.Reload(s_priorityData[ZoneCount - 1]); } else { // same as grid; _priorityGridModel.Rows = _gridModel.Rows; _priorityGridModel.Columns = _gridModel.Columns; _priorityGridModel.RowPercents = _gridModel.RowPercents; _priorityGridModel.ColumnPercents = _gridModel.ColumnPercents; _priorityGridModel.CellChildMap = _gridModel.CellChildMap; } }
/// <summary> /// Crops a given image. /// </summary> /// <param name="source">The BitmapSource.</param> /// <param name="rect">The crop rectangle.</param> /// <returns>The Cropped image.</returns> public static BitmapFrame CropImage(BitmapSource source, Int32Rect rect) { var croppedImage = new CroppedBitmap(source, rect); return(BitmapFrame.Create(croppedImage)); }
private void UpdateTiles(object sender, object e) { updateTimer.Stop(); var zoom = (int)Math.Floor(zoomLevel + zoomLevelSwitchDelta); var transform = GetTileIndexMatrix(1 << zoom); // tile indices of visible rectangle var p1 = transform.Transform(new Point(0d, 0d)); var p2 = transform.Transform(new Point(viewportSize.Width, 0d)); var p3 = transform.Transform(new Point(0d, viewportSize.Height)); var p4 = transform.Transform(new Point(viewportSize.Width, viewportSize.Height)); // index ranges of visible tiles var x1 = (int)Math.Floor(Math.Min(p1.X, Math.Min(p2.X, Math.Min(p3.X, p4.X)))); var y1 = (int)Math.Floor(Math.Min(p1.Y, Math.Min(p2.Y, Math.Min(p3.Y, p4.Y)))); var x2 = (int)Math.Floor(Math.Max(p1.X, Math.Max(p2.X, Math.Max(p3.X, p4.X)))); var y2 = (int)Math.Floor(Math.Max(p1.Y, Math.Max(p2.Y, Math.Max(p3.Y, p4.Y)))); var grid = new Int32Rect(x1, y1, x2 - x1 + 1, y2 - y1 + 1); if (tileZoomLevel != zoom || tileGrid != grid || tileRotation != rotation) { tileZoomLevel = zoom; tileGrid = grid; tileRotation = rotation; UpdateRenderTransform(); foreach (TileLayer tileLayer in InternalChildren) { tileLayer.UpdateTiles(tileZoomLevel, tileGrid, (int)rotation); } } }
internal InteropBitmap(IntPtr hicon, Int32Rect sourceRect, BitmapSizeOptions sizeOptions) : base(true) // Use virtuals { SecurityHelper.DemandUnmanagedCode(); _bitmapInit.BeginInit(); using (FactoryMaker myFactory = new FactoryMaker()) { HRESULT.Check(UnsafeNativeMethods.WICImagingFactory.CreateBitmapFromHICON( myFactory.ImagingFactoryPtr, hicon, out _unmanagedSource)); Debug.Assert (_unmanagedSource != null && !_unmanagedSource.IsInvalid); } _unmanagedSource.CalculateSize(); _sourceRect = sourceRect; _sizeOptions = sizeOptions; _syncObject = _unmanagedSource; _bitmapInit.EndInit(); FinalizeCreation(); }
protected void UpdateTileRect() { updateTimer.Stop(); if (parentMap != null) { var zoomLevel = (int)Math.Round(parentMap.ZoomLevel + ZoomLevelOffset); var transform = GetTileIndexMatrix(zoomLevel); // tile indices of visible rectangle var p1 = transform.Transform(new Point(0d, 0d)); var p2 = transform.Transform(new Point(parentMap.RenderSize.Width, 0d)); var p3 = transform.Transform(new Point(0d, parentMap.RenderSize.Height)); var p4 = transform.Transform(new Point(parentMap.RenderSize.Width, parentMap.RenderSize.Height)); // index ranges of visible tiles var x1 = (int)Math.Floor(Math.Min(p1.X, Math.Min(p2.X, Math.Min(p3.X, p4.X)))); var y1 = (int)Math.Floor(Math.Min(p1.Y, Math.Min(p2.Y, Math.Min(p3.Y, p4.Y)))); var x2 = (int)Math.Floor(Math.Max(p1.X, Math.Max(p2.X, Math.Max(p3.X, p4.X)))); var y2 = (int)Math.Floor(Math.Max(p1.Y, Math.Max(p2.Y, Math.Max(p3.Y, p4.Y)))); var rect = new Int32Rect(x1, y1, x2 - x1 + 1, y2 - y1 + 1); if (TileZoomLevel != zoomLevel || TileRect != rect) { TileZoomLevel = zoomLevel; TileRect = rect; SetRenderTransform(); UpdateTiles(false); } } }
/// <summary> /// BitmapSourceをMatに変換する. /// </summary> /// <param name="src">変換するBitmapSource</param> /// <param name="dst">出力先のMat</param> #else /// <summary> /// Converts BitmapSource to Mat /// </summary> /// <param name="src">Input BitmapSource</param> /// <param name="dst">Output Mat</param> #endif public static void ToMat(this BitmapSource src, Mat dst) { if (src == null) { throw new ArgumentNullException(nameof(src)); } if (dst == null) { throw new ArgumentNullException(nameof(dst)); } if (src.PixelWidth != dst.Width || src.PixelHeight != dst.Height) { throw new ArgumentException("size of src must be equal to size of dst"); } if (dst.Dims > 2) { throw new ArgumentException("Mat dimensions must be 2"); } int w = src.PixelWidth; int h = src.PixelHeight; int bpp = src.Format.BitsPerPixel; int channels = WriteableBitmapConverter.GetOptimumChannels(src.Format); if (dst.Channels() != channels) { throw new ArgumentException("nChannels of dst is invalid", nameof(dst)); } bool submat = dst.IsSubmatrix(); bool continuous = dst.IsContinuous(); unsafe { byte *p = (byte *)(dst.Data); long step = dst.Step(); // 1bppは手作業でコピー if (bpp == 1) { if (submat) { throw new NotImplementedException("submatrix not supported"); } // BitmapImageのデータを配列にコピー // 要素1つに横8ピクセル分のデータが入っている。 int stride = (w / 8) + 1; byte[] pixels = new byte[h * stride]; src.CopyPixels(pixels, stride, 0); int x = 0; for (int y = 0; y < h; y++) { int offset = y * stride; // この行の各バイトを調べていく for (int bytePos = 0; bytePos < stride; bytePos++) { if (x < w) { // 現在の位置のバイトからそれぞれのビット8つを取り出す byte b = pixels[offset + bytePos]; for (int i = 0; i < 8; i++) { if (x >= w) { break; } p[step * y + x] = ((b & 0x80) == 0x80) ? (byte)255 : (byte)0; b <<= 1; x++; } } } // 次の行へ x = 0; } } // 8bpp /*else if (bpp == 8) * { * int stride = w; * byte[] pixels = new byte[h * stride]; * src.CopyPixels(pixels, stride, 0); * for (int y = 0; y < h; y++) * { * for (int x = 0; x < w; x++) * { * p[step * y + x] = pixels[y * stride + x]; * } * } * }*/ // 24bpp, 32bpp, ... else { int stride = w * ((bpp + 7) / 8); if (!submat && continuous) { long imageSize = dst.DataEnd.ToInt64() - dst.Data.ToInt64(); if (imageSize < 0) { throw new OpenCvSharpException("The mat has invalid data pointer"); } if (imageSize > int.MaxValue) { throw new OpenCvSharpException("Too big mat data"); } src.CopyPixels(Int32Rect.Empty, dst.Data, (int)imageSize, stride); } else { // 高さ1pxの矩形ごと(≒1行ごと)にコピー var roi = new Int32Rect { X = 0, Y = 0, Width = w, Height = 1 }; IntPtr dstData = dst.Data; for (int y = 0; y < h; y++) { roi.Y = y; src.CopyPixels(roi, dstData, stride, stride); dstData = new IntPtr(dstData.ToInt64() + stride); } } } } }
public void Load(object sender, RoutedEventArgs e) { const string filename = "save.txt"; try { var reader = new StreamReader(filename); string firstLine = reader.ReadLine(); string secondLine = reader.ReadLine(); timeCountdown = int.Parse(firstLine); CountdownTime.Text = firstLine; var source = new BitmapImage( new Uri(secondLine, UriKind.RelativeOrAbsolute)); previewImage.Width = 300; previewImage.Height = 300; previewImage.Source = source; // Bat dau cat thanh 9 manh int count = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (!((i == 2) && (j == 2))) { TransformedBitmap mybitmapIMG; if (source.Height > source.Width) { double scaleTransfH = 300 / source.Height; mybitmapIMG = new TransformedBitmap(source, new ScaleTransform(scaleTransfH, scaleTransfH)); imgWidth = (int)(mybitmapIMG.PixelWidth / 3); imgHeight = (int)(mybitmapIMG.PixelHeight / 3); } else { double scaleTransfW = 300 / source.Width; mybitmapIMG = new TransformedBitmap(source, new ScaleTransform(scaleTransfW, scaleTransfW)); imgWidth = (int)(mybitmapIMG.PixelWidth / 3); imgHeight = (int)(mybitmapIMG.PixelHeight / 3); } drawLines(startX, startY, imgWidth, imgHeight); var rect = new Int32Rect(j * imgWidth, i * imgHeight, imgWidth, imgHeight); var cropBitmap = new CroppedBitmap(mybitmapIMG, rect); var cropImage = new Image(); cropImage.Stretch = Stretch.Fill; cropImage.Width = imgWidth; cropImage.Height = imgHeight; cropImage.Source = cropBitmap; canvas.Children.Add(cropImage); Canvas.SetLeft(cropImage, startX + j * (imgWidth + 2)); Canvas.SetTop(cropImage, startY + i * (imgHeight + 2)); cropImage.MouseLeftButtonDown += CropImage_MouseLeftButtonDown; cropImage.PreviewMouseLeftButtonUp += CropImage_MouseLeftButtonUp; cropImage.Tag = new Tuple <int, int>(i, j); cropImage.Name = $"s{count}"; listCropImg.Add(cropImage); count++; } } } Image nullImage = new Image(); listCropImg.Add(nullImage); int i2 = 0; int j2 = 0; int irndIMG = 0; int jrndIMG = 0; int rndIMG; for (int a = 0; a < 9; a++) { string nameIMG = reader.ReadLine(); if (nameIMG != "") { rndIMG = int.Parse(nameIMG.Substring(nameIMG.Length - 1, 1)); } else { rndIMG = 8; } if (j2 == 3) { j2 = 0; i2++; } switch (rndIMG) { case 0: irndIMG = 0; jrndIMG = 0; break; case 1: irndIMG = 0; jrndIMG = 1; break; case 2: irndIMG = 0; jrndIMG = 2; break; case 3: irndIMG = 1; jrndIMG = 0; break; case 4: irndIMG = 1; jrndIMG = 1; break; case 5: irndIMG = 1; jrndIMG = 2; break; case 6: irndIMG = 2; jrndIMG = 0; break; case 7: irndIMG = 2; jrndIMG = 1; break; case 8: irndIMG = 2; jrndIMG = 2; iFree = i2; jFree = j2; break; } Canvas.SetLeft(listCropImg[rndIMG], startX + j2 * imgWidth + 2 * j2); Canvas.SetTop(listCropImg[rndIMG], startY + i2 * imgHeight + 2 * i2); Canvas.SetLeft(listCropImg[a], startX + jrndIMG * imgWidth + 2 * jrndIMG); Canvas.SetTop(listCropImg[a], startY + irndIMG * imgHeight + 2 * irndIMG); listCropImg[a].Tag = new Tuple <int, int>(irndIMG, jrndIMG); listCropImg[rndIMG].Tag = new Tuple <int, int>(i2, j2); Image imgtemp = new Image(); imgtemp = listCropImg[a]; listCropImg[a] = listCropImg[rndIMG]; listCropImg[rndIMG] = imgtemp; j2++; } MessageBox.Show("Game đã được load!!!"); dt.Start(); _isGamePLaying = true; } catch { MessageBox.Show("Không thể load game gần nhất!!!\nBạn chưa lưu game hoặc file ảnh đã bị thay đổi!"); this.Window_Loaded(sender, e); } }
internal void UpdateTiles(int zoomLevel, Int32Rect grid, int rotation) { this.grid = grid; this.zoomLevel = zoomLevel; this.rotation = SupportsRotation ? rotation : 0; if (tileSource != null) { tileImageLoader.CancelGetTiles(); SelectTiles(); RenderTiles(); tileImageLoader.BeginGetTiles(this, tiles.Where(t => !t.HasImageSource)); } }
public static extern bool GetClientRect(IntPtr hWnd, out Int32Rect lpRect);
internal static extern bool GetClientRect(IntPtr windowHandle, out Int32Rect clientRect);
internal static extern bool ClientToScreen(IntPtr windowHandle, ref Int32Rect point);
int IWICBitmapSource.CopyPixels(IntPtr prc, int cbStride, int cbPixels, IntPtr pvPixels) { if (cbStride < 0) { return NativeMethods.E_INVALIDARG; } if (pvPixels == IntPtr.Zero) { return NativeMethods.E_INVALIDARG; } BitmapSource bitmapSource; if(_bitmapSource.TryGetTarget(out bitmapSource)) { Int32Rect rc; if (prc == IntPtr.Zero) { rc = new Int32Rect(0, 0, bitmapSource.PixelWidth, bitmapSource.PixelHeight); } else { rc = (Int32Rect)Marshal.PtrToStructure(prc, typeof(Int32Rect)); } int rectHeight, rectWidth; rectHeight = rc.Height; rectWidth = rc.Width; if (rc.Width < 1 || rc.Height < 1) { return NativeMethods.E_INVALIDARG; } // assuming cbStride can't be negative, but that prc.Height can PixelFormat pfStruct = bitmapSource.Format; if (pfStruct.Format == PixelFormatEnum.Default || pfStruct.Format == PixelFormatEnum.Extended) { return (int)(WinCodecErrors.WINCODEC_ERR_UNSUPPORTEDPIXELFORMAT); } int rectRowSize = checked((rectWidth * pfStruct.InternalBitsPerPixel + 7) / 8); if (cbPixels < checked((rectHeight - 1) * cbStride + rectRowSize)) { return (int)(WinCodecErrors.WINCODEC_ERR_INSUFFICIENTBUFFER); } // Need to marshal int arraySize = checked(rectHeight * rectRowSize); byte[] managedArray = new byte[arraySize]; // perform the copy bitmapSource.CopyPixels(rc, managedArray, rectRowSize, 0); { // transfer the contents of the relevant rect from the managed array to pvPixels long rowPtr = pvPixels.ToInt64(); for (int y = 0; y < rectHeight; y++) { Marshal.Copy(managedArray, y * rectRowSize, new IntPtr(rowPtr), rectRowSize); rowPtr += cbStride; } } return NativeMethods.S_OK; } else { return NativeMethods.E_FAIL; } }
private static void copyBitmap(BitmapSource source, WriteableBitmap target, bool dispatcher, int spacing, bool freezeBitmap) { int width = source.PixelWidth; int height = source.PixelHeight; int stride = width * ((source.Format.BitsPerPixel + 7) / 8); byte[] bits = new byte[height * stride]; source.CopyPixels(bits, stride, 0); source = null; //original code. //writeBitmap.Dispatcher.Invoke(DispatcherPriority.Background, // new ThreadStart(delegate // { // //UI Thread // Int32Rect outRect = new Int32Rect(0, (int)(writeBitmap.Height - height) / 2, width, height); // writeBitmap.WritePixels(outRect, bits, stride, 0); // })); //Bugfixes by h32 if (dispatcher) { target.Dispatcher.BeginInvoke(DispatcherPriority.Background, new ThreadStart(delegate { //UI Thread var delta = target.Height - height; var newWidth = width > target.Width ? (int)target.Width : width; var newHeight = height > target.Height ? (int)target.Height : height; Int32Rect outRect = new Int32Rect((int)((target.Width - newWidth) / 2), (int)(delta >= 0 ? delta : 0) / 2 + spacing, newWidth - (spacing * 2), newWidth - (spacing * 2)); try { target.WritePixels(outRect, bits, stride, 0); if (freezeBitmap) { target.Freeze(); } } catch (Exception e) { System.Diagnostics.Debugger.Break(); } })); } else { var delta = target.Height - height; var newWidth = width > target.Width ? (int)target.Width : width; var newHeight = height > target.Height ? (int)target.Height : height; Int32Rect outRect = new Int32Rect(spacing, (int)(delta >= 0 ? delta : 0) / 2 + spacing, newWidth - (spacing * 2), newWidth - (spacing * 2)); try { target.WritePixels(outRect, bits, stride, 0); if (freezeBitmap) { target.Freeze(); } } catch (Exception e) { System.Diagnostics.Debugger.Break(); } } }
public virtual void CopyPixels(Int32Rect sourceRect, IntPtr buffer, int bufferSize, int stride) { ReadPreamble(); EnsureShouldUseVirtuals(); _bitmapInit.EnsureInitializedComplete(); CompleteDelayedCreation(); // Demand Site Of origin on the URI if it passes then this information is ok to expose CheckIfSiteOfOrigin(); CriticalCopyPixels(sourceRect, buffer, bufferSize, stride); }
public MainWindow() { InitializeComponent(); // Open Device device = K4A.Device.Open(); // Start Cameras device.StartCameras(new K4A.DeviceConfiguration { ColorFormat = K4A.ImageFormat.ColorBGRA32, ColorResolution = K4A.ColorResolution.R720p, DepthMode = K4A.DepthMode.NFOV_2x2Binned, SynchronizedImagesOnly = true }); // Get Calibration calibration = device.GetCalibration(K4A.DepthMode.NFOV_2x2Binned, K4A.ColorResolution.R720p); // Create Tracker tracker = K4ABT.Tracker.Create( calibration, new K4ABT.TrackerConfiguration { SensorOrientation = K4ABT.SensorOrientation.Default, ProcessingMode = K4ABT.TrackerProcessingMode.Gpu } ); // Create Buffer int color_width = calibration.ColorCameraCalibration.ResolutionWidth; int color_height = calibration.ColorCameraCalibration.ResolutionHeight; const int color_channles = 4; color_stride = color_width * sizeof(byte) * color_channles; color_rect = new Int32Rect(0, 0, color_width, color_height); color_bitmap = new WriteableBitmap(color_width, color_height, 96.0, 96.0, PixelFormats.Bgra32, null); // Generate Color LUT colors = new Color[6]; colors[0] = new Color() { B = 255, G = 0, R = 0, A = 128 }; colors[1] = new Color() { B = 0, G = 255, R = 0, A = 128 }; colors[2] = new Color() { B = 0, G = 0, R = 255, A = 128 }; colors[3] = new Color() { B = 255, G = 255, R = 0, A = 128 }; colors[4] = new Color() { B = 0, G = 255, R = 255, A = 128 }; colors[5] = new Color() { B = 255, G = 0, R = 255, A = 128 }; // Bined Image Control Color_Image.Source = color_bitmap; Color_Image.Width = color_width; Color_Image.Height = color_height; // Set Cnvas Size Canvas_Body.Width = color_width; Canvas_Body.Height = color_height; }
internal void CriticalCopyPixels(Int32Rect sourceRect, IntPtr buffer, int bufferSize, int stride) { if (buffer == IntPtr.Zero) throw new ArgumentNullException("buffer"); if (stride <= 0) throw new ArgumentOutOfRangeException("stride", SR.Get(SRID.ParameterMustBeGreaterThanZero)); if (sourceRect.Width <= 0) sourceRect.Width = PixelWidth; if (sourceRect.Height <= 0) sourceRect.Height = PixelHeight; if (sourceRect.Width > PixelWidth) throw new ArgumentOutOfRangeException("sourceRect.Width", SR.Get(SRID.ParameterCannotBeGreaterThan, PixelWidth)); if (sourceRect.Height > PixelHeight) throw new ArgumentOutOfRangeException("sourceRect.Height", SR.Get(SRID.ParameterCannotBeGreaterThan, PixelHeight)); int minStride = checked(((sourceRect.Width * Format.BitsPerPixel) + 7) / 8); if (stride < minStride) throw new ArgumentOutOfRangeException("stride", SR.Get(SRID.ParameterCannotBeLessThan, minStride)); int minRequiredDestSize = checked((stride * (sourceRect.Height - 1)) + minStride); if (bufferSize < minRequiredDestSize) throw new ArgumentOutOfRangeException("buffer", SR.Get(SRID.ParameterCannotBeLessThan, minRequiredDestSize)); lock (_syncObject) { HRESULT.Check(UnsafeNativeMethods.WICBitmapSource.CopyPixels( WicSourceHandle, ref sourceRect, (uint)stride, (uint)bufferSize, buffer )); } }
public static WriteableBitmap ResizeWritableBitmap(this WriteableBitmap wBitmap, int reqWidth, int reqHeight) { int Stride = wBitmap.PixelWidth * ((wBitmap.Format.BitsPerPixel + 7) / 8); int NumPixels = Stride * wBitmap.PixelHeight; ushort[] ArrayOfPixels = new ushort[NumPixels]; wBitmap.CopyPixels(ArrayOfPixels, Stride, 0); int OriWidth = (int)wBitmap.PixelWidth; int OriHeight = (int)wBitmap.PixelHeight; double nXFactor = (double)OriWidth / (double)reqWidth; double nYFactor = (double)OriHeight / (double)reqHeight; double fraction_x, fraction_y, one_minus_x, one_minus_y; int ceil_x, ceil_y, floor_x, floor_y; ushort pix1, pix2, pix3, pix4; int nStride = reqWidth * ((wBitmap.Format.BitsPerPixel + 7) / 8); int nNumPixels = reqWidth * reqHeight; ushort[] newArrayOfPixels = new ushort[nNumPixels]; /*Core Part*/ /* Code project article : Image Processing for Dummies with C# and GDI+ Part 2 - Convolution Filters By Christian Graus</a> href=<a href="http://www.codeproject.com/KB/GDI-plus/csharpfilters.aspx"></a> */ for (int y = 0; y < reqHeight; y++) { for (int x = 0; x < reqWidth; x++) { // Setup floor_x = (int)Math.Floor(x * nXFactor); floor_y = (int)Math.Floor(y * nYFactor); ceil_x = floor_x + 1; if (ceil_x >= OriWidth) ceil_x = floor_x; ceil_y = floor_y + 1; if (ceil_y >= OriHeight) ceil_y = floor_y; fraction_x = x * nXFactor - floor_x; fraction_y = y * nYFactor - floor_y; one_minus_x = 1.0 - fraction_x; one_minus_y = 1.0 - fraction_y; pix1 = ArrayOfPixels[floor_x + floor_y * OriWidth]; pix2 = ArrayOfPixels[ceil_x + floor_y * OriWidth]; pix3 = ArrayOfPixels[floor_x + ceil_y * OriWidth]; pix4 = ArrayOfPixels[ceil_x + ceil_y * OriWidth]; ushort g1 = (ushort)(one_minus_x * pix1 + fraction_x * pix2); ushort g2 = (ushort)(one_minus_x * pix3 + fraction_x * pix4); ushort g = (ushort)(one_minus_y * (double)(g1) + fraction_y * (double)(g2)); newArrayOfPixels[y * reqWidth + x] = g; } } /*End of Core Part*/ WriteableBitmap newWBitmap = new WriteableBitmap(reqWidth, reqHeight, 96, 96, PixelFormats.Gray16, null); Int32Rect Imagerect = new Int32Rect(0, 0, reqWidth, reqHeight); int newStride = reqWidth * ((PixelFormats.Gray16.BitsPerPixel + 7) / 8); newWBitmap.WritePixels(Imagerect, newArrayOfPixels, newStride, 0); return newWBitmap; }