/// <summary> /// Gets a value indicating whether the captured frame contains the specified metadata. /// </summary> /// <param name="metadata">The metadata to be queried.</param> /// <returns> /// <b>true</b> if the captured frame contains the specified metadata; otherwise, <b>false</b>. /// </returns> public bool SupportsMetadata(FrameMetadata metadata) { var result = NativeMethods.rs2_supports_frame_metadata(handle, metadata, out IntPtr error); NativeHelper.ThrowExceptionForRsError(error); return(result != 0); }
private static BitmapSource ClearArea(BitmapSource frame, FrameMetadata metadata) { DrawingVisual visual = new DrawingVisual(); using (var context = visual.RenderOpen()) { var fullRect = new Rect(0, 0, frame.PixelWidth, frame.PixelHeight); var clearRect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height); var clip = Geometry.Combine( new RectangleGeometry(fullRect), new RectangleGeometry(clearRect), GeometryCombineMode.Exclude, null); context.PushClip(clip); context.DrawImage(frame, fullRect); } var bitmap = new RenderTargetBitmap( frame.PixelWidth, frame.PixelHeight, frame.DpiX, frame.DpiY, PixelFormats.Pbgra32); bitmap.Render(visual); var result = new CachedBitmap(bitmap, BitmapCreateOptions.None, BitmapCacheOption.Default); if (result.CanFreeze && !result.IsFrozen) { result.Freeze(); } return(result); }
private static bool IsFullFrame(FrameMetadata metadata, Int32Size fullSize) { return(metadata.Left == 0 && metadata.Top == 0 && metadata.Width == fullSize.Width && metadata.Height == fullSize.Height); }
public static bool IsFullFrame(FrameMetadata metadata, System.Drawing.Size fullSize) { return(metadata.Left == 0 && metadata.Top == 0 && metadata.Width == fullSize.Width && metadata.Height == fullSize.Height); }
private static FrameMetadata GetFrameMetadata(BitmapFrame frame) { var metadata = (BitmapMetadata)frame.Metadata; var delay = TimeSpan.FromMilliseconds(100); var metadataDelay = metadata.GetQueryOrDefault("/grctlext/Delay", 10); if (metadataDelay != 0) { delay = TimeSpan.FromMilliseconds(metadataDelay * 10); } var disposalMethod = (FrameDisposalMethod)metadata.GetQueryOrDefault("/grctlext/Disposal", 0); var frameMetadata = new FrameMetadata { Left = metadata.GetQueryOrDefault("/imgdesc/Left", 0), Top = metadata.GetQueryOrDefault("/imgdesc/Top", 0), Width = metadata.GetQueryOrDefault("/imgdesc/Width", frame.PixelWidth), Height = metadata.GetQueryOrDefault("/imgdesc/Height", frame.PixelHeight), Delay = delay, DisposalMethod = disposalMethod }; return(frameMetadata); }
private static FrameMetadata GetFrameMetadata(GifFrame gifMetadata) { var d = gifMetadata.Descriptor; var frameMetadata = new FrameMetadata { Left = d.Left, Top = d.Top, Width = d.Width, Height = d.Height, Delay = TimeSpan.FromMilliseconds(100), DisposalMethod = FrameDisposalMethod.None }; var gce = gifMetadata.Extensions.OfType <GifGraphicControlExtension>().FirstOrDefault(); if (gce != null) { if (gce.Delay != 0) { frameMetadata.Delay = TimeSpan.FromMilliseconds(gce.Delay); } frameMetadata.DisposalMethod = (FrameDisposalMethod)gce.DisposalMethod; } return(frameMetadata); }
//---------------------------------------------------------------------- #region private helpers private static bool _isNotFullSize(FrameMetadata poMetadata, Size poFullSize) { return(poMetadata.miPositionX != 0 || poMetadata.miPositionY != 0 || poMetadata.moMetadata.miWidth != poFullSize.Width || poMetadata.moMetadata.miHeight != poFullSize.Height); }
/// <summary> /// Implements a function to be used in the Count Frame conversation processor. /// </summary> /// <param name="flowKey"></param> /// <param name="frames"></param> /// <returns></returns> private (string key, int frames, int octets, int ip, int tcp, int udp) CountFrames(FlowKey flowKey, System.Collections.Generic.IEnumerable <Memory <byte> > frames) { (int octets, int ip, int tcp, int udp) GetFrameSize(Memory <byte> memory) { var meta = default(FrameMetadata); var bytes = FrameMetadata.FromBytes(memory.Span, ref meta); var packet = PacketDotNet.Packet.ParsePacket((PacketDotNet.LinkLayers)meta.LinkLayer, bytes.ToArray()); return(meta.OriginalLength, packet.Extract <PacketDotNet.InternetPacket>() != null ? 1 : 0, packet.Extract <PacketDotNet.TcpPacket>() != null ? 1 : 0, packet.Extract <PacketDotNet.UdpPacket>() != null ? 1 : 0 ); } var framesList = frames.ToList(); // intentionally it is computed in this inefficient way to test // the implementated iteration over the input collection return(flowKey.ToString(), framesList.Count, framesList.Sum(x => GetFrameSize(x).octets), framesList.Sum(x => GetFrameSize(x).ip), framesList.Sum(x => GetFrameSize(x).tcp), framesList.Sum(x => GetFrameSize(x).udp) ); }
private static BitmapSource _restoreBackgroundFrame( Size poFullSize, BitmapSource poFrame, FrameMetadata poMetadata) { if (_isNotFullSize(poMetadata, poFullSize)) { var toVisual = new DrawingVisual(); using (var toContext = toVisual.RenderOpen()) { var toFullRect = new Rect(0, 0, poFrame.PixelWidth, poFrame.PixelHeight); var toRect = new Rect(poMetadata.miPositionX, poMetadata.miPositionY, poMetadata.moMetadata.miWidth, poMetadata.moMetadata.miHeight ); var toClip = Geometry.Combine(new RectangleGeometry(toFullRect), new RectangleGeometry(toRect), GeometryCombineMode.Exclude, null ); toContext.PushClip(toClip); toContext.DrawImage(poFrame, toFullRect); } var toRenderer = new RenderTargetBitmap( poFrame.PixelWidth, poFrame.PixelHeight, poFrame.DpiX, poFrame.DpiY, PixelFormats.Pbgra32 ); toRenderer.Render(toVisual); var toFrame = new WriteableBitmap(toRenderer); toFrame.Freeze(); return(toFrame); } return(null); }
public static BitmapSource ClearArea(BitmapSource frame, FrameMetadata metadata) { var visual = new DrawingVisual(); using (var context = visual.RenderOpen()) { var fullRect = new Rect(0, 0, frame.PixelWidth, frame.PixelHeight); var clearRect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height); var clip = Geometry.Combine(new RectangleGeometry(fullRect), new RectangleGeometry(clearRect), GeometryCombineMode.Exclude, null); context.PushClip(clip); context.DrawImage(frame, fullRect); } var bitmap = new RenderTargetBitmap(frame.PixelWidth, frame.PixelHeight, frame.DpiX, frame.DpiY, PixelFormats.Pbgra32); bitmap.Render(visual); if (bitmap.CanFreeze && !bitmap.IsFrozen) { bitmap.Freeze(); } return(bitmap); }
private static FrameMetadata _getFrameMetadata(BitmapFrame poFrame) { if (poFrame.Metadata is BitmapMetadata toMetadata) { var toGrctlext = toMetadata.GetQuery("/grctlext") as BitmapMetadata; var toImgdesc = toMetadata.GetQuery("/imgdesc") as BitmapMetadata; if (toGrctlext != null && toImgdesc != null) { var toFrameMetadata = new FrameMetadata { miPositionX = toImgdesc.GetQueryValue("/Left", 0), miPositionY = toImgdesc.GetQueryValue("/Top", 0), moMetadata = new Metadata { miWidth = toImgdesc.GetQueryValue("/Width", 0), miHeight = toImgdesc.GetQueryValue("/Height", 0) }, moDelay = TimeSpan.FromMilliseconds(toGrctlext.GetQueryValue("/Delay", 10) * 10), meDisposalMethod = (eDisposalMethod)toGrctlext.GetQueryValue("/Disposal", 0) }; // Handle malformed gif delays by setting a minimum delay toFrameMetadata.moDelay = toFrameMetadata.moDelay.Ticks == 0 ? TimeSpan.FromMilliseconds(50) : toFrameMetadata.moDelay; return(toFrameMetadata); } } return(null); }
private FrameMetadata GetMetadata(Capture capture, OutputDuplicateFrameInformation frameInformation) { int totalBufferSize = frameInformation.TotalMetadataBufferSize; if (totalBufferSize == 0) { return(null); } var toReturn = new FrameMetadata(); int actualLength; var moveBuffer = new OutputDuplicateMoveRectangle[totalBufferSize]; capture.OutputDuplication.GetFrameMoveRects(moveBuffer.Length, moveBuffer, out actualLength); Array.Resize(ref moveBuffer, actualLength / Marshal.SizeOf(typeof(OutputDuplicateMoveRectangle))); toReturn.MoveRectangles = moveBuffer; var dirtyBuffer = new RawRectangle[totalBufferSize]; capture.OutputDuplication.GetFrameDirtyRects(dirtyBuffer.Length, dirtyBuffer, out actualLength); Array.Resize(ref dirtyBuffer, actualLength / Marshal.SizeOf(typeof(RawRectangle))); toReturn.DirtyRectangles = dirtyBuffer; return(toReturn); }
/// <summary> /// Gets the specified metadata from the captured frame. /// </summary> /// <param name="metadata">The metadata to retrieve from the captured frame.</param> /// <returns>The metadata value.</returns> public long GetMetadata(FrameMetadata metadata) { var value = NativeMethods.rs2_get_frame_metadata(handle, metadata, out IntPtr error); NativeHelper.ThrowExceptionForRsError(error); return(value); }
void Generate() { void onNextFrame(ref ulong key, ref SpanByte value) { FrameKey frameKey = new FrameKey(key); FrameMetadata frameMetadata = default; var frameBytes = FrameMetadata.FromBytes(value.AsSpan(), ref frameMetadata); _observer.OnNext(_processor(ref frameKey, ref frameMetadata, frameBytes)); } _framesStore.ProcessEntries(onNextFrame, _cancel.Token); _observer.OnCompleted(); }
public TTarget Invoke(FlowKey flowKey, IEnumerable <Memory <byte> > frames) { var firstTicks = _windowStart.Ticks; var lastTicks = firstTicks + _duration.Ticks; bool IsInWindow(Memory <byte> frame) { FrameMetadata frameMetadata = default; FrameMetadata.FromBytes(frame.Span, ref frameMetadata); return(frameMetadata.Ticks >= firstTicks && frameMetadata.Ticks < lastTicks); } return(_processor.Invoke(flowKey, frames.Where(IsInWindow))); }
private static ObjectAnimationUsingKeyFrames GetAnimation(Image imageControl, BitmapSource source) { ObjectAnimationUsingKeyFrames animation = AnimationCache.GetAnimation(source, GetRepeatBehavior(imageControl)); if (animation == null) { GifFile file; GifBitmapDecoder decoder = GetDecoder(source, out file) as GifBitmapDecoder; if ((decoder == null) || (decoder.Frames.Count <= 1)) { return(null); } Int32Size fullSize = GetFullSize(decoder, file); int frameIndex = 0; animation = new ObjectAnimationUsingKeyFrames(); TimeSpan zero = TimeSpan.Zero; BitmapSource baseFrame = null; foreach (BitmapFrame frame in decoder.Frames) { FrameMetadata metadata = GetFrameMetadata(decoder, file, frameIndex); BitmapSource source3 = MakeFrame(fullSize, frame, metadata, baseFrame); DiscreteObjectKeyFrame keyFrame = new DiscreteObjectKeyFrame(source3, zero); animation.KeyFrames.Add(keyFrame); zero += metadata.Delay; FrameDisposalMethod disposalMethod = metadata.DisposalMethod; switch (disposalMethod) { case FrameDisposalMethod.None: case FrameDisposalMethod.DoNotDispose: baseFrame = source3; break; case FrameDisposalMethod.RestoreBackground: baseFrame = !IsFullFrame(metadata, fullSize) ? ClearArea(source3, metadata) : null; break; default: break; } frameIndex++; } animation.Duration = zero; animation.RepeatBehavior = GetActualRepeatBehavior(imageControl, decoder, file); AnimationCache.AddAnimation(source, GetRepeatBehavior(imageControl), animation); AnimationCache.IncrementReferenceCount(source, GetRepeatBehavior(imageControl)); } return(animation); }
public ConversationRecord <TData> Invoke(FlowKey flowKey, IEnumerable <Memory <byte> > frames) { var fwdPackets = new List <MetaPacket>(); var revPackets = new List <MetaPacket>(); var forwardKeyHash = flowKey.GetHashCode64(); var meta = new FrameMetadata(); FlowMetrics fwdMetrics = new FlowMetrics(); FlowMetrics revMetrics = new FlowMetrics(); DateTime? firstTimestamp = null; foreach (var frame in frames) { var buffer = FrameMetadata.FromBytes(frame.Span, ref meta); if (firstTimestamp == null) { firstTimestamp = new DateTime(meta.Ticks); } var packet = Packet.ParsePacket((LinkLayers)meta.LinkLayer, buffer.ToArray()); if (meta.FlowKeyHash == forwardKeyHash) { AddPacket(fwdPackets, ref fwdMetrics, ref meta, packet); } else { AddPacket(revPackets, ref revMetrics, ref meta, packet); } } if (firstTimestamp != null) { // adjust metrics: AdjustMetrics(ref fwdMetrics, firstTimestamp.Value); AdjustMetrics(ref revMetrics, firstTimestamp.Value); } return(new ConversationRecord <TData>() { Key = flowKey, ForwardMetrics = fwdMetrics, ReverseMetrics = revMetrics, Data = Invoke(ref flowKey, ref fwdMetrics, ref revMetrics, fwdPackets, revPackets) }); }
private static BitmapSource MakeFrame( Int32Size fullSize, BitmapSource rawFrame, FrameMetadata metadata, BitmapSource baseFrame) { if (baseFrame == null && IsFullFrame(metadata, fullSize)) { // No previous image to combine with, and same size as the full image // Just return the frame as is return(rawFrame); } DrawingVisual visual = new DrawingVisual(); using (var context = visual.RenderOpen()) { if (baseFrame != null) { var fullRect = new Rect(0, 0, fullSize.Width, fullSize.Height); context.DrawImage(baseFrame, fullRect); } var rect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height); context.DrawImage(rawFrame, rect); } var bitmap = new RenderTargetBitmap( fullSize.Width, fullSize.Height, 96, 96, PixelFormats.Pbgra32); bitmap.Render(visual); var result = new WriteableBitmap(bitmap); bitmap = null; if (result.CanFreeze && !result.IsFrozen) { result.Freeze(); } return(result); }
private string GetTagValues() { FrameMetadata metadata = currentAnimator.Metadata; StringBuilder sb = new StringBuilder(); foreach (string tag in metadata.AnimationTags) { sb.AppendLine(tag); } foreach (var objectEntry in metadata.ObjectTags) { foreach (string tag in objectEntry.Value) { sb.Append(objectEntry.Key).Append(".").AppendLine(tag); } } return(sb.ToString()); }
private static BitmapSource ClearArea(BitmapSource frame, FrameMetadata metadata) { DrawingVisual visual = new DrawingVisual(); using (DrawingContext context = visual.RenderOpen()) { Rect rect = new Rect(0.0, 0.0, (double)frame.PixelWidth, (double)frame.PixelHeight); Rect rect2 = new Rect((double)metadata.Left, (double)metadata.Top, (double)metadata.Width, (double)metadata.Height); context.PushClip(Geometry.Combine(new RectangleGeometry(rect), new RectangleGeometry(rect2), GeometryCombineMode.Exclude, null)); context.DrawImage(frame, rect); } RenderTargetBitmap bitmap = new RenderTargetBitmap(frame.PixelWidth, frame.PixelHeight, frame.DpiX, frame.DpiY, PixelFormats.Pbgra32); bitmap.Render(visual); if (bitmap.CanFreeze && !bitmap.IsFrozen) { bitmap.Freeze(); } return(bitmap); }
private static BitmapSource MakeFrame( BitmapSource fullImage, BitmapSource rawFrame, FrameMetadata metadata, BitmapSource baseFrame) { if (baseFrame == null && rawFrame.PixelWidth == fullImage.PixelWidth && rawFrame.PixelHeight == fullImage.PixelHeight) { // No previous image to combine with, and same size as the full image // Just return the frame as is return(rawFrame); } DrawingVisual visual = new DrawingVisual(); using (var context = visual.RenderOpen()) { if (baseFrame != null) { var fullRect = new Rect(0, 0, fullImage.PixelWidth, fullImage.PixelHeight); context.DrawImage(baseFrame, fullRect); } var rect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height); context.DrawImage(rawFrame, rect); } var bitmap = new RenderTargetBitmap( fullImage.PixelWidth, fullImage.PixelHeight, fullImage.DpiX, fullImage.DpiY, PixelFormats.Pbgra32); bitmap.Render(visual); if (bitmap.CanFreeze && !bitmap.IsFrozen) { bitmap.Freeze(); } return(bitmap); }
private string GetVarValues() { FrameMetadata metadata = currentAnimator.Metadata; StringBuilder sb = new StringBuilder(); foreach (var entry in metadata.AnimationVars) { object value = GetValue(entry.Value); sb.Append(entry.Key).Append(" = ").AppendLine(value.ToString()); } foreach (var objectEntry in metadata.ObjectVars) { foreach (var varEntry in objectEntry.Value) { object value = GetValue(varEntry.Value); sb.Append(objectEntry.Key).Append(".").Append(varEntry.Key).Append(" = ").AppendLine((value ?? string.Empty).ToString()); } } return(sb.ToString()); }
private static FrameMetadata GetFrameMetadata(GifFrame gifMetadata) { GifImageDescriptor descriptor = gifMetadata.Descriptor; FrameMetadata metadata = new FrameMetadata { Left = descriptor.Left, Top = descriptor.Top, Width = descriptor.Width, Height = descriptor.Height, Delay = TimeSpan.FromMilliseconds(100.0), DisposalMethod = FrameDisposalMethod.None }; GifGraphicControlExtension extension = gifMetadata.Extensions.OfType <GifGraphicControlExtension>().FirstOrDefault <GifGraphicControlExtension>(); if (extension != null) { if (extension.Delay != 0) { metadata.Delay = TimeSpan.FromMilliseconds((double)extension.Delay); } metadata.DisposalMethod = (FrameDisposalMethod)extension.DisposalMethod; } return(metadata); }
//---------------------------------------------------------------------- #region private rendering private static BitmapSource _renderFrame( Size poFullSize, BitmapSource poFrame, FrameMetadata poMetadata, BitmapSource poBaseFrame) { if (_isNotFullSize(poMetadata, poFullSize)) { var toVisual = new DrawingVisual(); using (var toContext = toVisual.RenderOpen()) { if (poBaseFrame != null) { var toFullRect = new Rect(0, 0, poFullSize.Width, poFullSize.Height); toContext.DrawImage(poBaseFrame, toFullRect); } var toRect = new Rect( poMetadata.miPositionX, poMetadata.miPositionY, poMetadata.moMetadata.miWidth, poMetadata.moMetadata.miHeight ); toContext.DrawImage(poFrame, toRect); } var toRenderer = new RenderTargetBitmap( Convert.ToInt32(poFullSize.Width), Convert.ToInt32(poFullSize.Height), 96, 96, PixelFormats.Pbgra32 ); toRenderer.Render(toVisual); var toFrame = new WriteableBitmap(toRenderer); toFrame.Freeze(); return(toFrame); } return(poFrame); }
private static CompressedBitmapSource MakeFrame( Int32Size fullSize, CompressedBitmapSource rawFrame, FrameMetadata metadata, CompressedBitmapSource baseFrame) { if (baseFrame == null && IsFullFrame(metadata, fullSize)) { // No previous image to combine with, and same size as the full image // Just return the frame as is return(rawFrame); } WriteableBitmap bitmap; if (baseFrame == null) { bitmap = new WriteableBitmap(fullSize.Width, fullSize.Height, 96, 96, PixelFormats.Pbgra32, null); } else { bitmap = new WriteableBitmap(baseFrame); } var rawBitmap = new WriteableBitmap(rawFrame); bitmap.Blit(new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height), rawBitmap, new Rect(0, 0, rawFrame.Width, rawFrame.Height)); var result = new CompressedBitmapSource((BitmapSource)bitmap); bitmap = null; rawBitmap = null; GC.Collect(); Dispatcher.CurrentDispatcher.Invoke(() => {}, DispatcherPriority.ContextIdle); return(result); }
public static extern Int32 GetVisibleFrame(UInt16 index, UInt16 timeout, IntPtr Buf, UInt32 BufSize, out FrameMetadata Metadata);
private void SelectedFrameChanged(object sender, EventArgs e) { FrameMetadata frame = FrameList.Current; if (frame == null) { CurrentFrameImage = null; return; } InnerNpkFile selectedFile = InnerFileList.Current; DFO.Common.Images.Image image = null; try { image = _editor.GetImage(selectedFile.Path, frame.Index); } catch (Exception) { // TODO: Log this and maybe display something CurrentFrameImage = null; return; } // Adjust position in bounding box according to frame coordinates // go from (0, 0) based coordinates to (_smallestX, _smallestY) based coordinates // (0, 0) -> (45, 50) // (60, 55) -> (15, 5) // frame x - _smallestX = bounding box X // frame y - _smallestY = bounding box y // Paint image in bounding box // RGBA -> BGRA (for little endian platforms), (BGRA for big endian platforms) - seems to not be reversed for little endian??? // TODO: Make NpkReader able to output in variable format so it doesn't need to be converted byte[] frameBytes = new byte[_width * _height * 4]; // Get X in frame // bounding box X + _smallestX = frame x // (5, 0) 5x5 // (3, 1), 10x6 // smallest x: 3 // smallest y: 0 // (0, 0): 0 + 3 for (int boundingBoxY = 0; boundingBoxY < _height; boundingBoxY++) { int frameY = boundingBoxY + _smallestY; int rowOffset = boundingBoxY * _width * 4; // if this row is above or below the current frame, draw a row of transparent pixels if (frameY < image.Attributes.LocationY || frameY > image.Attributes.LocationY + image.Attributes.Height - 1) { for (int boundingBoxX = 0; boundingBoxX < _width; boundingBoxX++) { int pixelOffset = rowOffset + (boundingBoxX * 4); frameBytes[pixelOffset] = 0; frameBytes[pixelOffset + 1] = 0; frameBytes[pixelOffset + 2] = 0; frameBytes[pixelOffset + 3] = 0; } } else { for (int boundingBoxX = 0; boundingBoxX < _width; boundingBoxX++) { int frameX = boundingBoxX + _smallestX; int pixelOffset = rowOffset + (boundingBoxX * 4); // if this column is to the left or right of the current frame, draw a transparent pixel if (frameX < image.Attributes.LocationX || frameX > image.Attributes.LocationX + image.Attributes.Width - 1) { frameBytes[pixelOffset] = 0; frameBytes[pixelOffset + 1] = 0; frameBytes[pixelOffset + 2] = 0; frameBytes[pixelOffset + 3] = 0; } else { // RGBA -> BGRA int zeroBasedFrameY = frameY - image.Attributes.LocationY; int zeroBasedFrameX = frameX - image.Attributes.LocationX; int framePixelOffset = zeroBasedFrameY * image.Attributes.Width * 4 + zeroBasedFrameX * 4; frameBytes[pixelOffset] = image.PixelData[framePixelOffset + 2]; // B frameBytes[pixelOffset + 1] = image.PixelData[framePixelOffset + 1]; // G frameBytes[pixelOffset + 2] = image.PixelData[framePixelOffset]; // R frameBytes[pixelOffset + 3] = image.PixelData[framePixelOffset + 3]; // A } } } } CurrentFrameImage = BitmapSource.Create(_width, _height, dpiX: 96, dpiY: 96, pixelFormat: PixelFormats.Bgra32, palette: null, pixels: frameBytes, stride: 4 * _width); }
private static ObjectAnimationUsingKeyFrames?GetAnimation(Image imageControl, BitmapSource source) { ObjectAnimationUsingKeyFrames?animation = AnimationCache.GetAnimation(source, GetRepeatBehavior(imageControl)); if (animation != null) { return(animation); } GifFile?gifMetadata; var decoder = GetDecoder(source, out gifMetadata) as GifBitmapDecoder; if (decoder != null && decoder.Frames.Count > 1) { Int32Size fullSize = GetFullSize(decoder, gifMetadata); int index = 0; animation = new ObjectAnimationUsingKeyFrames(); TimeSpan totalDuration = TimeSpan.Zero; BitmapSource?baseFrame = null; foreach (BitmapFrame rawFrame in decoder.Frames) { FrameMetadata metadata = GetFrameMetadata(decoder, gifMetadata, index); BitmapSource frame = MakeFrame(fullSize, rawFrame, metadata, baseFrame); var keyFrame = new DiscreteObjectKeyFrame(frame, totalDuration); animation.KeyFrames.Add(keyFrame); totalDuration += metadata.Delay; switch (metadata.DisposalMethod) { case FrameDisposalMethod.None: case FrameDisposalMethod.DoNotDispose: baseFrame = frame; break; case FrameDisposalMethod.RestoreBackground: if (IsFullFrame(metadata, fullSize)) { baseFrame = null; } else { baseFrame = ClearArea(frame, metadata); } break; case FrameDisposalMethod.RestorePrevious: // Reuse same base frame break; } index++; } animation.Duration = totalDuration; animation.RepeatBehavior = GetActualRepeatBehavior(imageControl, decoder, gifMetadata); AnimationCache.AddAnimation(source, GetRepeatBehavior(imageControl), animation); return(animation); } return(null); }
public static BitmapSource MakeFrame(System.Drawing.Size fullSize, BitmapSource rawFrame, FrameMetadata metadata, BitmapSource baseFrame) { //I removed this, so I could save the same as 32bpp //if (baseFrame == null && IsFullFrame(metadata, fullSize)) //{ // // No previous image to combine with, and same size as the full image // // Just return the frame as is // return rawFrame; //} var visual = new DrawingVisual(); using (var context = visual.RenderOpen()) { if (baseFrame != null) { var fullRect = new Rect(0, 0, fullSize.Width, fullSize.Height); context.DrawImage(baseFrame, fullRect); } var rect = new Rect(metadata.Left, metadata.Top, metadata.Width, metadata.Height); context.DrawImage(rawFrame, rect); } //TODO: Test, DPI was hardcoded to 96. var bitmap = new RenderTargetBitmap(fullSize.Width, fullSize.Height, rawFrame.DpiX, rawFrame.DpiY, PixelFormats.Pbgra32); bitmap.Render(visual); if (bitmap.CanFreeze && !bitmap.IsFrozen) { bitmap.Freeze(); } return(bitmap); }
static async Task Main(string[] args) { CvInvoke.Init(); if (!DepthAIInvoke.HaveDepthAI) { Console.WriteLine("The native binary is built without Depth AI support."); return; } String win1 = "Depth AI (Press 'q' to quit)"; //The name of the window CvInvoke.NamedWindow(win1); //Create the window using the specific name MobilenetSsd mobilenet = new MobilenetSsd(); //This download the models and return the default configuration await mobilenet.Init(onDownloadProgressChanged); Config config = mobilenet.ModelConfig; String[] labels = mobilenet.Labels; using (Emgu.CV.DepthAI.Device d = new Device("")) { //String[] availableStreams = d.GetAvailableStreams(); using (CNNHostPipeline pipeline = d.CreatePipeline(JsonConvert.SerializeObject(config))) { if (pipeline.Ptr == IntPtr.Zero) { Console.WriteLine("Failed to create device pipeline."); return; } while (_is_running) { using (NNetAndDataPackets packets = pipeline.GetAvailableNNetAndDataPackets(false)) { HostDataPacket[] dataPackets = packets.HostDataPackets; NNetPacket[] nnetPackets = packets.NNetPackets; for (int i = 0; i < dataPackets.Length; i++) { if (dataPackets[i].GetPreviewOut(_render)) { using (FrameMetadata fmeta = dataPackets[i].GetFrameMetadata()) { if (i < nnetPackets.Length) { NNetPacket nnetPacket = nnetPackets[i]; using (FrameMetadata meta = nnetPacket.GetFrameMetadata()) { _mostRecentDetections = nnetPacket.Detections; } } if (_mostRecentDetections != null) { for (int j = 0; j < _mostRecentDetections.Length; j++) { DrawDetection(_mostRecentDetections[j], _render, labels); } } CvInvoke.Imshow(win1, _render); //Show the image } } else { //failed to get preview image } } } if (CvInvoke.WaitKey(1) > 0) //Press any key to stop { _is_running = false; } } } } CvInvoke.DestroyAllWindows(); //Destroy all windows if key is pressed }