private static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, Bitmap.CompressFormat imageFormat) { var colors = pixelBuffers[0].GetPixels<int>(); using (var bitmap = Bitmap.CreateBitmap(description.Width, description.Height, Bitmap.Config.Argb8888)) { var pixelData = bitmap.LockPixels(); var sizeToCopy = colors.Length * sizeof(int); unsafe { fixed (int* pSrc = colors) { // Copy the memory if (description.Format == PixelFormat.R8G8B8A8_UNorm || description.Format == PixelFormat.R8G8B8A8_UNorm_SRgb) { CopyMemoryBGRA(pixelData, (IntPtr)pSrc, sizeToCopy); } else if (description.Format == PixelFormat.B8G8R8A8_UNorm || description.Format == PixelFormat.B8G8R8A8_UNorm_SRgb) { Utilities.CopyMemory(pixelData, (IntPtr)pSrc, sizeToCopy); } else { throw new NotSupportedException(string.Format("Pixel format [{0}] is not supported", description.Format)); } } } bitmap.UnlockPixels(); bitmap.Compress(imageFormat, 100, imageStream); } }
private static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, ImageFormat imageFormat) { using (var bitmap = new Bitmap(description.Width, description.Height)) { var sourceArea = new Rectangle(0, 0, bitmap.Width, bitmap.Height); // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.WriteOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); try { // Copy memory if (description.Format == PixelFormat.R8G8B8A8_UNorm || description.Format == PixelFormat.R8G8B8A8_UNorm_SRgb) CopyMemoryBGRA(bitmapData.Scan0, pixelBuffers[0].DataPointer, pixelBuffers[0].BufferStride); else if (description.Format == PixelFormat.B8G8R8A8_UNorm || description.Format == PixelFormat.B8G8R8A8_UNorm_SRgb) Utilities.CopyMemory(bitmapData.Scan0, pixelBuffers[0].DataPointer, pixelBuffers[0].BufferStride); else throw new NotSupportedException(string.Format("Pixel format [{0}] is not supported", description.Format)); } finally { bitmap.UnlockBits(bitmapData); } // Save bitmap.Save(imageStream, imageFormat); } }
public virtual void AlphaBlend(int x, int y, int width, int height, PixelBuffer bitmap, int srcX, int srcY, int srcWidth, int srcHeight, byte alpha) { if (null != AlphaBlendHandler) AlphaBlendHandler(x, y, width, height, bitmap, srcX, srcY, srcWidth, srcHeight, alpha); }
private static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, Bitmap.CompressFormat imageFormat) { var colors = pixelBuffers[0].GetPixels<int>(); using (var bitmap = Bitmap.CreateBitmap(colors, description.Width, description.Height, Bitmap.Config.Argb8888)) { bitmap.Compress(imageFormat, 0, imageStream); } }
protected UISurface(string title, int x, int y, int width, int height, Guid uniqueID) { fTitle = title; fFrame = new RECT(x, y, width, height); fBackingBuffer = new PixelBuffer(width, height); fGraphDelegate = new GraphPortDelegate(); fGraphDelegate.AddGraphPort(fBackingBuffer.GraphPort); fUniqueID = uniqueID; UISurface.gSurfaces.Add(uniqueID, this); }
public PassiveSpace(string title, RECT aframe) : base(title, aframe) { fBackingBuffer = new PixelBuffer(Frame.Width, aframe.Height); fWrappedGraphPort = new GraphPortDelegate(); fWrappedGraphPort.AddGraphPort(fBackingBuffer.GraphPort); fWrappedGraphPort.AddGraphPort(base.GraphPort); // Add the channel for commands fSessionManager = new SessionManager(); fControlChannel = new SpaceControlChannel(fSessionManager, fSessionManager.UniqueSessionName, this); }
public MyTileTexture <byte> GetTerrainBlendTexture(MyPlanetMaterialBlendSettings settings) { MyTileTexture <byte> tex; string path = settings.Texture; int cellSize = settings.CellSize; if (!m_ditherTilesets.TryGetValue(path, out tex)) { string fullPath = Path.Combine(MyFileSystem.ContentPath, path) + ".png"; if (!File.Exists(fullPath)) { fullPath = Path.Combine(MyFileSystem.ContentPath, path) + ".dds"; } SharpDXImage image = null; try { image = SharpDXImage.Load(fullPath); } catch (Exception e) { MyLog.Default.WriteLine(e.Message); } if (image == null) { return(MyTileTexture <byte> .Default); } PixelBuffer buffer = image.GetPixelBuffer(0, 0, 0); Debug.Assert(buffer.Format == Format.R8_UNorm); if (buffer.Format != Format.R8_UNorm) { return(MyTileTexture <byte> .Default); } tex = new MyTileTexture <byte>(buffer, cellSize); image.Dispose(); } return(tex); }
/// <summary> /// Ensures that the given <see cref="PixelBuffer"/> object is unbound. /// </summary> /// <param name="pbo">The <see cref="PixelBuffer"/> object to ensure is unbound.</param> public void UnbindPixelBuffer(PixelBuffer pbo) { if (pbo == null) { throw new ArgumentNullException(nameof(pbo)); } if (PixelBufferHandle != pbo.Handle) { return; } GL.BindBuffer(BufferTarget.PixelUnpackBuffer, GLHandle.Zero); PixelBufferHandle = GLHandle.Zero; PixelBuffer.BoundContext = null; PixelBuffer = null; }
private unsafe void DrawPixels(PixelBuffer pixelBuffer, SKCanvas canvas, SKPaint paint, Rectangle r, int x, int y) { if (!Monitor.IsEntered(_syncRoot)) { throw new InvalidOperationException(); } r.Offset(-x, -y); Rectangle bitmapRect = new Rectangle(0, 0, pixelBuffer.Width, pixelBuffer.Height); r.Intersect(bitmapRect); if (r.Width == 0 || r.Height == 0) { return; } canvas.DrawBitmap(pixelBuffer.Source, new SKPoint(r.X + x, r.Y + y), paint); }
public PixelBuffer Execute(int width, int height) { var pixelBuffer = new PixelBuffer(width, height); for (int j = height - 1; j >= 0; j--) { for (int i = 0; i < width; i++) { var color = new ColorVector( Convert.ToSingle(i) / Convert.ToSingle(width), Convert.ToSingle(j) / Convert.ToSingle(height), 0.2f); pixelBuffer.SetPixelColor(i, j, color); } } return(pixelBuffer); }
public override void BitBlt(int x, int y, PixelBuffer pixBuff) { // Create a buffer // It has to be big enough for the bitmap data, as well as the x,y, and command int dataSize = pixBuff.Pixels.Stride * pixBuff.Pixels.Height; BufferChunk chunk = new BufferChunk(dataSize + 128); // now put the basic command and simple components in chunk += SpaceControlChannel.SC_BitBlt; CodecUtils.Pack(chunk, x, y); CodecUtils.Pack(chunk, pixBuff.Pixels.Width, pixBuff.Pixels.Height); chunk += dataSize; // Finally, copy in the data chunk.CopyFrom(pixBuff.Pixels.Data, dataSize); PackCommand(chunk); }
// Generalized bit block transfer // Can transfer from any device context to this one. public override void BitBlt(int x, int y, PixelBuffer pixBuff) { // Create a buffer // It has to be big enough for the bitmap data, as well as the x,y, and command int dataSize = pixBuff.Pixels.Stride * pixBuff.Pixels.Height; BufferChunk chunk = new BufferChunk(dataSize + 128); // now put the basic command and simple components in chunk += GDI32.EMR_BITBLT; Pack(chunk, x, y); Pack(chunk, pixBuff.Pixels.Width, pixBuff.Pixels.Height); chunk += dataSize; // Finally, copy in the data chunk.CopyFrom(pixBuff.Pixels.Data, dataSize); PackCommand(chunk); }
public void PixelBufferAssign() { tlog.Debug(tag, $"PixelBufferAssign START"); using (PixelBuffer pixelBuffer = new PixelBuffer(100, 50, PixelFormat.BGR8888)) { var testingTarget = pixelBuffer.Assign(pixelBuffer); Assert.IsNotNull(testingTarget, "Can't create success object PixelData"); Assert.IsInstanceOf <PixelBuffer>(testingTarget, "Should be an instance of PixelData type."); var result = testingTarget.GetPixelFormat(); Assert.AreEqual(PixelFormat.BGR8888, result, "Should be equal!"); testingTarget.Dispose(); } tlog.Debug(tag, $"PixelBufferAssign END (OK)"); }
public void PixelBufferRotate() { tlog.Debug(tag, $"PixelBufferRotate START"); using (Degree degree = new Degree(30)) { var testingTarget = new PixelBuffer(100, 50, PixelFormat.BGR8888); Assert.IsNotNull(testingTarget, "Can't create success object PixelData"); Assert.IsInstanceOf <PixelBuffer>(testingTarget, "Should be an instance of PixelData type."); var result = testingTarget.Rotate(degree); Assert.IsTrue(result); testingTarget.Dispose(); } tlog.Debug(tag, $"PixelBufferRotate END (OK)"); }
public PixelBuffer Execute(int width, int height) { var pixelBuffer = new PixelBuffer(width, height); float aperture = 0.01f; var lookFrom = new Vector3(24.0f, 2.0f, 6.0f); var lookAt = Vector3.UnitY; float distanceToFocus = (lookFrom - lookAt).Length(); var camera = new Camera( lookFrom, lookAt, Vector3.UnitY, 15.0f, Convert.ToSingle(width) / Convert.ToSingle(height), aperture, distanceToFocus); var world = CreateRandomScene(); for (int j = height - 1; j >= 0; j--) { for (int i = 0; i < width; i++) { ColorVector color = new ColorVector(0.0f, 0.0f, 0.0f); for (int sample = 0; sample < _numSamples; sample++) { float u = Convert.ToSingle(i + GetRandom()) / Convert.ToSingle(width); float v = Convert.ToSingle(j + GetRandom()) / Convert.ToSingle(height); var r = camera.GetRay(u, v); color += GetRayColor(r, world, 0); } color /= Convert.ToSingle(_numSamples); color = color.ApplyGamma2(); pixelBuffer.SetPixelColor(i, j, color); } Console.Write("."); } Console.WriteLine(); return(pixelBuffer); }
private void onCaptureFinished(object sender, CaptureFinishedEventArgs e) { log.Debug(tag, $"onCaptureFinished() statue={e.Success} \n"); if (sender is Capture) { log.Debug(tag, $"sender is Capture \n"); PixelBuffer pixelBuffer = capture.GetCapturedBuffer(); PixelData pixelData = PixelBuffer.Convert(pixelBuffer); var url = pixelData.Url;//capture.GetNativeImageSource().Url; capturedImage = new ImageView(url); log.Debug(tag, $"url={url} \n"); capturedImage.Size = new Size(510, 510); capturedImage.Position = new Position(10, 10); root.Add(capturedImage); done = false; } }
public void PaletteGenerateAsync() { tlog.Debug(tag, $"PaletteGenerateAsync START"); try { using (PixelBuffer buffer = new PixelBuffer(2, 2, PixelFormat.A8)) { _ = Palette.GenerateAsync(buffer); } } catch (Exception e) { tlog.Debug(tag, e.Message.ToString()); Assert.Fail("Caught Exception: Failed!"); } tlog.Debug(tag, $"PaletteGenerateAsync END (OK)"); }
private static void PrepareHeightMap8Bit(MyHeightmapFace map, PixelBuffer imageData) { int y = 0; while (y < map.Resolution) { int x = 0; while (true) { if (x >= map.Resolution) { y++; break; } map.SetValue(x, y, (ushort)(imageData.GetPixel <byte>(x, y) * 0x100)); x++; } } }
public void PixelBufferCrop() { tlog.Debug(tag, $"PixelBufferCrop START"); var testingTarget = new PixelBuffer(100, 50, PixelFormat.BGR8888); Assert.IsNotNull(testingTarget, "Can't create success object PixelData"); Assert.IsInstanceOf <PixelBuffer>(testingTarget, "Should be an instance of PixelData type."); Assert.AreEqual(100, testingTarget.GetWidth(), "Shoule be equal!"); Assert.AreEqual(50, testingTarget.GetHeight(), "Shoule be equal!"); testingTarget.Crop(150, 100, 50, 100); Assert.AreEqual(50, testingTarget.GetWidth(), "Shoule be equal!"); Assert.AreEqual(100, testingTarget.GetHeight(), "Shoule be equal!"); testingTarget.Dispose(); tlog.Debug(tag, $"PixelBufferCrop END (OK)"); }
private void LoadFromBitmap(Drawing.Bitmap sourceImage) { mSourceRect.Size = Interop.Convert(sourceImage.Size); Size newSize = GetOGLSize(sourceImage); // create a new bitmap of the size OpenGL expects, and copy the source image to it. Drawing.Bitmap textureImage = new Drawing.Bitmap(newSize.Width, newSize.Height); Drawing.Graphics g = Drawing.Graphics.FromImage(textureImage); g.Transform = new System.Drawing.Drawing2D.Matrix(); g.Clear(Drawing.Color.FromArgb(0, 0, 0, 0)); g.DrawImage(sourceImage, new Drawing.Rectangle(new Drawing.Point(0, 0), sourceImage.Size)); g.Dispose(); mTextureSize = Interop.Convert(textureImage.Size); mTexCoord = GetTextureCoords(mSourceRect); // Rectangle For Locking The Bitmap In Memory Rectangle rectangle = new Rectangle(0, 0, textureImage.Width, textureImage.Height); // Get The Bitmap's Pixel Data From The Locked Bitmap BitmapData bitmapData = textureImage.LockBits(Interop.Convert(rectangle), ImageLockMode.ReadOnly, Drawing.Imaging.PixelFormat.Format32bppArgb); // use a pixelbuffer to do format conversion. PixelBuffer buffer = new PixelBuffer(PixelFormat.RGBA8888, mTextureSize, bitmapData.Scan0, PixelFormat.BGRA8888, bitmapData.Stride); // Create The GL Texture object int textureID; GL.GenTextures(1, out textureID); AddTextureRef(textureID); WritePixels(buffer); textureImage.UnlockBits(bitmapData); // Unlock The Pixel Data From Memory textureImage.Dispose(); // Dispose The Bitmap }
/// <summary> /// Binds the given <see cref="PixelBuffer"/> object to the <see cref="RenderContext"/>. /// </summary> /// <param name="pbo">The <see cref="PixelBuffer"/> object to bind.</param> public void BindPixelBuffer(PixelBuffer pbo) { if (pbo == null) { throw new ArgumentNullException(nameof(pbo)); } pbo.EnsureUndisposed(); if (_pixelBufferHandle == pbo.Handle) { return; } GL.BindBuffer(BufferTarget.PixelUnpackBuffer, pbo.Handle); _pixelBufferHandle = pbo.Handle; _pixelBuffer = pbo; _pixelBuffer.BoundContext = this; }
public SwapChain(byte chainSize, int bufferSize) { if (chainSize < 2) { throw new System.ArgumentException("Chain size must be 2 or higher"); } buffers = new PixelBuffer[chainSize]; for (int i = 0; i < chainSize; i++) { buffers[i] = new PixelBuffer(bufferSize); } writeCount = new int[bufferSize]; readIndex = 0; writeIndex = 1; swapIndex = 1; }
/// <inheritdoc /> public IHitable GetWorld() { var globe = PixelBuffer.FromFile(_globeImagePath); var list = new HitableList() { new Sphere( new Vector3(0.0f, -1000.0f, 0.0f), 1000.0f, new LambertianMaterial(new VectorNoiseTexture(VectorNoiseMode.Marble, 3.0f))), new Sphere( new Vector3(0.0f, 2.0f, 0.0f), 2.0f, new LambertianMaterial(new ImageTexture(globe))), new Sphere(new Vector3(0.0f, 7.0f, 0.0f), 2.0f, new DiffuseLight(new ColorTexture(4.0f, 4.0f, 4.0f))), new XyRect(3.0f, 5.0f, 1.0f, 3.0f, -2.0f, new DiffuseLight(new ColorTexture(4.0f, 4.0f, 4.0f))) }; return(new BvhNode(list, 0.0f, 1.0f)); }
public static PixelBuffer Render(RendererParameters textParameters, ref EmbeddedItemInfo[] embeddedItemLayout) { int count = 0; int length = 0; global::System.IntPtr returnItem = IntPtr.Zero; PixelBuffer ret = new PixelBuffer(Interop.TextUtils.TextUtils_Render(RendererParameters.getCPtr(textParameters), ref returnItem, ref count, ref length), true); embeddedItemLayout = new EmbeddedItemInfo[count]; for (int i = 0; i < count; i++) { IntPtr p = new IntPtr((returnItem.ToInt32() + i * length)); embeddedItemLayout[i] = new EmbeddedItemInfo(p, false); } if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public Image(BinaryReader bin) { offset = bin.ReadUInt32(); unknown4 = bin.ReadBytes(12); //Read actual image data long co = bin.BaseStream.Position; bin.BaseStream.Seek(offset, SeekOrigin.Begin); pixelBuffer = new PixelBuffer(bin); clutBuffer = null; if (pixelBuffer.HasClut) { clutBuffer = new ClutBuffer(bin); } bin.BaseStream.Seek(co, SeekOrigin.Begin); }
public static void Main(string[] args) { int numThreads = Environment.ProcessorCount / 2; const int RayTraceDepth = 50; const int NumSamples = 1000; var renderConfig = new RenderConfig(numThreads, RayTraceDepth, NumSamples); string globeImagePath = Path.Combine(OutputDirectory, "globetex.jpg"); // var scene = new ManySpheresScene(); // var scene = new NoiseSpheresScene(); // var scene = new ImageTextureScene(globeImagePath); // var scene = new LightsScene(globeImagePath); var scene = new CornellBoxScene(); // var scene = new CornellBoxWithSmokeScene(); IRenderer renderer = new PerPixelRenderer(); var pixelBuffer = new PixelBuffer(Width, Height); string name = scene.GetType().Name.ToLowerInvariant(); Console.WriteLine($"Executing {name} at resolution ({pixelBuffer.Width},{pixelBuffer.Height})"); Console.WriteLine($" Num Threads = {numThreads}"); Console.WriteLine($" RayTraceDepth = {RayTraceDepth}"); Console.WriteLine($" Num Samples = {NumSamples}"); var sw = Stopwatch.StartNew(); var rendererData = renderer.Render(pixelBuffer, scene, renderConfig); sw.Stop(); Console.WriteLine(); Console.WriteLine($"Render complete: {sw.ElapsedMilliseconds}ms"); Console.WriteLine($"Total Pixel Color Time: {rendererData.GetTotalPixelColorMilliseconds()}ms"); Console.WriteLine($"Per Pixel Avg Time: {rendererData.GetAveragePixelColorMilliseconds()}ms"); string outputPath = Path.Combine(OutputDirectory, $"{name}.png"); Console.WriteLine($"Saving image to {outputPath}"); pixelBuffer.SaveAsFile(outputPath); // RunExecutors(); }
private void VerifyCopyResult(PixelBuffer result, PixelBuffer srcBuffer, Point destPt) { for (int j = 0; j < srcBuffer.Height; j++) { for (int i = 0; i < srcBuffer.Width; i++) { int x = i + destPt.X; int y = j + destPt.Y; var resultPx = result.GetPixel(x, y); var srcPx = srcBuffer.GetPixel(i, j); if (resultPx.A == 0 && srcPx.A == 0) { continue; } Assert.AreEqual(srcPx, resultPx); } } }
public void ColorCutQuantizerFromBitmapWithMaxColorLessThan1() { tlog.Debug(tag, $"ColorCutQuantizerFromBitmapWithMaxColorLessThan1 START"); using (PixelBuffer pixelBuffer = new PixelBuffer(100, 200, PixelFormat.RGBA8888)) { using (Rectangle region = new Rectangle()) { try { ColorCutQuantizer.FromBitmap(pixelBuffer, region, 0); } catch (ArgumentNullException e) { tlog.Debug(tag, e.Message.ToString()); tlog.Debug(tag, $"ColorCutQuantizerFromBitmapWithMaxColorLessThan1 END (OK)"); Assert.Pass("Caught ArgumentNullException : Passed!"); } } } }
public unsafe void Render(DrawingContext drawingContext) { lock (_syncRoot) { if (ViewPixels != null) { WriteableBitmap surface; surface = GetSurface(ViewPixels); drawingContext.DrawImage(surface, new Rect(0, 0, surface.Width, surface.Height)); PixelBuffer pixelBuffer = PopupPixels; if (pixelBuffer == null) { return; } surface = GetSurface(pixelBuffer); drawingContext.DrawImage(surface, new Rect(_popupBounds.X, _popupBounds.Y, surface.Width, surface.Height)); } } }
public void PaletteGenerate() { tlog.Debug(tag, $"PaletteGenerate START"); try { using (PixelBuffer buffer = ImageLoader.LoadImageFromFile(image_path)) { var testingTarget = Palette.Generate(buffer); Assert.IsNotNull(testingTarget, "Can't create success object Palette"); Assert.IsInstanceOf <Palette>(testingTarget, "Should be an instance of Palette type."); } } catch (Exception e) { tlog.Debug(tag, e.Message.ToString()); Assert.Fail("Caught Exception: Failed!"); } tlog.Debug(tag, $"PaletteGenerate END (OK)"); }
public void PixelBufferApplyGaussianBlur() { tlog.Debug(tag, $"PixelBufferApplyGaussianBlur START"); var testingTarget = new PixelBuffer(100, 50, PixelFormat.BGR8888); Assert.IsNotNull(testingTarget, "Can't create success object PixelData"); Assert.IsInstanceOf <PixelBuffer>(testingTarget, "Should be an instance of PixelData type."); try { testingTarget.ApplyGaussianBlur(1.0f); } catch (Exception e) { Assert.Fail("Fail!"); } testingTarget.Dispose(); tlog.Debug(tag, $"PixelBufferApplyGaussianBlur END (OK)"); }
private MyHeightmapFace GetHeightMap(string folderName, string faceName, MyModContext context) { string path = this.GetPath(folderName, faceName, context); MyHeightmapFace map = null; try { using (Image image = this.LoadTexture(path)) { if (image == null) { object[] args = new object[] { path }; MyLog.Default.Error("Could not load texture {0}, no suitable format found. ", args); } else { PixelBuffer imageData = image.GetPixelBuffer(0, 0, 0); map = new MyHeightmapFace(imageData.Height); if (imageData.Format == Format.R16_UNorm) { PrepareHeightMap(map, imageData); } else if (imageData.Format == Format.R8_UNorm) { PrepareHeightMap8Bit(map, imageData); } else { MyLog.Default.Error($"Heighmap texture {path}: Invalid format {imageData.Format} (expecting R16_UNorm or R8_UNorm).", Array.Empty <object>()); } image.Dispose(); } } } catch (Exception exception) { MyLog.Default.WriteLine(exception.Message); } return(map); }
public PixelBuffer Execute(int width, int height) { var pixelBuffer = new PixelBuffer(width, height); var lowerLeftCorner = new Vector3(-2.0f, -1.0f, -1.0f); var horizontal = new Vector3(4.0f, 0.0f, 0.0f); var vertical = new Vector3(0.0f, 2.0f, 0.0f); var origin = Vector3.Zero; for (int j = height - 1; j >= 0; j--) { for (int i = 0; i < width; i++) { float u = Convert.ToSingle(i) / Convert.ToSingle(width); float v = Convert.ToSingle(j) / Convert.ToSingle(height); var r = new Ray(origin, lowerLeftCorner + (u * horizontal) + (v * vertical)); var color = GetRayColor(r); pixelBuffer.SetPixelColor(i, j, color); } } return(pixelBuffer); }
public override PixelBuffer ReadPixels(PixelFormat format, Geometry.Rectangle rect) { BitmapData data = mImage.LockBits(Interop.Convert(rect), ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb); if (format == PixelFormat.Any) { format = PixelFormat.BGRA8888; } PixelBuffer buffer = new PixelBuffer(format, rect.Size); byte[] bytes = new byte[4 * rect.Width * rect.Height]; Marshal.Copy(data.Scan0, bytes, 0, bytes.Length); mImage.UnlockBits(data); buffer.SetData(bytes, PixelFormat.BGRA8888); return(buffer); }
public void Draw(CefPaintEventArgs e) { lock (_syncRoot) { PixelBuffer pixelBuffer; if (e.PaintElementType == CefPaintElementType.View) { if (ViewPixels == null || ViewPixels.Width != e.Width || ViewPixels.Height != e.Height) { if (ViewPixels != null) { ViewPixels.Dispose(); } ViewPixels = new PixelBuffer(e.Width, e.Height); } pixelBuffer = ViewPixels; } else if (e.PaintElementType == CefPaintElementType.Popup) { if (PopupPixels == null || PopupPixels.Width != e.Width || PopupPixels.Height != e.Height) { if (PopupPixels != null) { PopupPixels.Dispose(); } PopupPixels = new PixelBuffer(e.Width, e.Height); } pixelBuffer = PopupPixels; } else { return; } Marshal.Copy(e.Buffer, pixelBuffer.DIB, 0, pixelBuffer.Size); pixelBuffer.AddDirtyRects(e.DirtyRects); } }
public void PaletteGenerateAsyncWithRectangle() { tlog.Debug(tag, $"PaletteGenerateAsyncWithRectangle START"); try { using (PixelBuffer buffer = new PixelBuffer(2, 2, PixelFormat.A8)) { using (Rectangle region = new Rectangle(1, 1, 1, 1)) { _ = Palette.GenerateAsync(buffer, region); } } } catch (Exception e) { tlog.Debug(tag, e.Message.ToString()); Assert.Fail("Caught Exception: Failed!"); } tlog.Debug(tag, $"PaletteGenerateAsyncWithRectangle END (OK)"); }
private unsafe void DrawPixels(PixelBuffer pixelBuffer, Graphics g, Rectangle r, int x, int y) { if (!Monitor.IsEntered(_syncRoot)) { throw new InvalidOperationException(); } r.Offset(-x, -y); Rectangle bitmapRect = new Rectangle(0, 0, pixelBuffer.Width, pixelBuffer.Height); r.Intersect(bitmapRect); if (r.Width == 0 || r.Height == 0) { return; } //g.DrawImage(pixelBuffer.Source, new Point(r.X + x, r.Y + y)); IntPtr hdc = g.GetHdc(); try { BitmapData DIB = pixelBuffer.Source.LockBits(new Rectangle(0, 0, pixelBuffer.Width, pixelBuffer.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); try { NativeMethods.SetDIBitsToDevice(hdc, r.X + x, r.Y + y, r.Width, r.Height, r.X, bitmapRect.Height, r.Bottom, bitmapRect.Height, DIB.Scan0, ref pixelBuffer.DIBInfo, 0); } finally { pixelBuffer.Source.UnlockBits(DIB); } } finally { g.ReleaseHdc(hdc); } }
public static void SaveFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, System.IO.Stream imageStream) { var stream = new BinarySerializationWriter(imageStream); // Write magic code stream.Write(MagicCode); // Write image header imageDescriptionSerializer.Serialize(ref description, ArchiveMode.Serialize, stream); // Write total size int totalSize = 0; foreach (var pixelBuffer in pixelBuffers) totalSize += pixelBuffer.BufferStride; stream.Write(totalSize); // Write buffers contiguously foreach (var pixelBuffer in pixelBuffers) { stream.Serialize(pixelBuffer.DataPointer, pixelBuffer.BufferStride); } }
public virtual void OnCopyPixels(int x, int y, int width, int height, PixelBuffer pixBuff) { if (null != OnCopyPixelsEvent) OnCopyPixelsEvent(x, y, width, height, pixBuff); }
public virtual PixelBuffer CreateBitmap(int width, int height) { PixelBuffer newOne = new PixelBuffer(width, height); return newOne; }
// Generalized bit block transfer // Can transfer from any device context to this one. public virtual void BitBlt(int x, int y, PixelBuffer bitmap) { bool retValue = BitBlt(x, y, bitmap.Width, bitmap.Height, bitmap.DCHandle, 0, 0, TernaryRasterOps.SRCCOPY); }
public virtual void DrawBitmap(PixelBuffer img, Rectangle srcRect, Rectangle dstRect) { AlphaBlend(dstRect.Left, dstRect.Top, dstRect.Width, dstRect.Height, img.DCHandle, srcRect.Left, srcRect.Top, srcRect.Width, srcRect.Height, img.Alpha); }
/// <summary> /// DrawImage, will draw the supplied image graphic on the screen. It will use /// the Image's frame and size to determine where to display it. /// </summary> /// <param name="img"></param> public virtual void DrawBitmap(PixelBuffer img, Point origin) { DrawBitmap(img, new Rectangle(0, 0, img.Width, img.Height), new Rectangle(origin.x, origin.y, img.Width, img.Height)); }
public static void SavePngFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream) { SaveFromMemory(pixelBuffers, count, description, imageStream, Bitmap.CompressFormat.Png); }
/// <summary> /// Saves this instance to a stream. /// </summary> /// <param name="pixelBuffers">The buffers to save.</param> /// <param name="count">The number of buffers to save.</param> /// <param name="description">Global description of the buffer.</param> /// <param name="imageStream">The destination stream.</param> /// <param name="fileType">Specify the output format.</param> /// <remarks>This method support the following format: <c>dds, bmp, jpg, png, gif, tiff, wmp, tga</c>.</remarks> internal static void Save(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream, ImageFileType fileType) { foreach (var loadSaveDelegate in loadSaveDelegates) { if (loadSaveDelegate.FileType == fileType) { loadSaveDelegate.Save(pixelBuffers, count, description, imageStream); return; } } throw new NotSupportedException("This file format is not yet implemented."); }
private static void PrepareHeightMap8Bit(MyHeightmapFace map, PixelBuffer imageData) { for (int y = 0; y < map.Resolution; y++) { for (int x = 0; x < map.Resolution; x++) { map.SetValue(x, y, (ushort)(imageData.GetPixel<byte>(x, y) * 256)); } } }
private static void SaveToWICMemory(PixelBuffer[] pixelBuffer, int count, WICFlags flags, ImageFileType fileType, Stream stream) { if (count > 1) EncodeMultiframe(pixelBuffer, count, flags, GetContainerFormatFromFileType(fileType), stream); else EncodeSingleFrame(pixelBuffer[0], flags, GetContainerFormatFromFileType(fileType), stream); }
private bool SetShaderParameters(DeviceContext deviceContext, Matrix worldMatrix, Matrix viewMatrix, Matrix projectionMatrix, ShaderResourceView texture, Vector4 pixelColor) { try { DataStream mappedResource; #region Matrix Constant Buffer // Transpose the matrices to prepare them for shader. worldMatrix.Transpose(); viewMatrix.Transpose(); projectionMatrix.Transpose(); // Lock the constant buffer so it can be written to. deviceContext.MapSubresource(ConstantMatrixBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource); // Copy the matrices into the constant buffer. var matrixBuffer = new MatrixBuffer() { world = worldMatrix, view = viewMatrix, projection = projectionMatrix }; mappedResource.Write(matrixBuffer); // Unlock the constant buffer. deviceContext.UnmapSubresource(ConstantMatrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. var bufferNumber = 0; // Finally set the constant buffer in the vertex shader with the updated values. deviceContext.VertexShader.SetConstantBuffer(bufferNumber, ConstantMatrixBuffer); // Set shader resource in the pixel shader. deviceContext.PixelShader.SetShaderResource(0, texture); #endregion #region Pixel Constant Shader // Lock the pixel constant buffer so it can be written to. deviceContext.MapSubresource(ConstantPixelBuffer, MapMode.WriteDiscard, SharpDX.Direct3D11.MapFlags.None, out mappedResource); // Copy the matrices into the constant buffer. var pixelBuffer = new PixelBuffer() { pixelColor = pixelColor }; mappedResource.Write(pixelBuffer); // Unlock the constant buffer. deviceContext.UnmapSubresource(ConstantPixelBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Finally set the constant buffer in the vertex shader with the updated values. deviceContext.PixelShader.SetConstantBuffer(bufferNumber, ConstantPixelBuffer); #endregion return true; } catch (Exception) { return false; } }
public virtual void OnAlphaBlend(int x, int y, int width, int height, PixelBuffer bitmap, int srcX, int srcY, int srcWidth, int srcHeight, byte alpha) { if (null != OnAlphaBlendEvent) OnAlphaBlendEvent(x, y, width, height, bitmap, srcX, srcY, srcWidth, srcHeight, alpha); }
public static void SaveWmpFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream) { throw new NotImplementedException(); }
public virtual void ScaleBitmap(PixelBuffer aBitmap, RECT aFrame) { AlphaBlend(aFrame.Left, aFrame.Top, aFrame.Width, aFrame.Height, aBitmap, 0, 0, aBitmap.Width, aBitmap.Height, aBitmap.Alpha); }
public void DisplayUpdateHandler(uint sessionId, int sample) { if (Session.IsPaused()) return; // after first 10 frames have been rendered only update every third. if (sample > 10 && sample < (Settings.Samples-2) && sample % 3 != 0) return; if (CancelRender) return; if (State != State.Rendering) return; lock (DisplayLock) { if (Session.Scene.TryLock()) { // copy display buffer data into ccycles pixel buffer Session.DrawNogl(RenderDimension.Width, RenderDimension.Height); // copy stuff into renderwindow dib using (var channel = RenderWindow.OpenChannel(RenderWindow.StandardChannels.RGBA)) { if (CancelRender) return; if (channel != null) { if (CancelRender) return; var pixelbuffer = new PixelBuffer(CSycles.session_get_buffer(Client.Id, sessionId)); var size = RenderDimension; var rect = new Rectangle(0, 0, RenderDimension.Width, RenderDimension.Height); if (CancelRender) return; channel.SetValues(rect, size, pixelbuffer); } } SaveRenderedBuffer(sample); //PassRendered?.Invoke(this, new PassRenderedEventArgs(sample, View)); if(CancelRender || sample >= maxSamples) Session.Cancel("done"); Session.Scene.Unlock(); //sdd.WriteLine(string.Format("display update, sample {0}", sample)); // now signal whoever is interested } } }
private static void EncodeSingleFrame( PixelBuffer pixelBuffer, WICFlags flags, Guid guidContainerFormat, Stream stream ) { using (var encoder = new BitmapEncoder(Factory, guidContainerFormat, stream)) { using (var frame = new BitmapFrameEncode(encoder)) { if (guidContainerFormat == ContainerFormatGuids.Bmp) { try { frame.Options.Set("EnableV5Header32bppBGRA", true); } catch { } } EncodeImage(pixelBuffer, flags, frame); encoder.Commit(); } } }
public static void SavePngFromMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream) { WICHelper.SavePngToWICMemory(pixelBuffers, count, description, imageStream); }
/// <summary> /// Allocates PixelBuffers /// </summary> /// <param name="buffer"></param> /// <param name="pixelSize"></param> /// <param name="imageDesc"></param> /// <param name="pitchFlags"></param> /// <param name="output"></param> private static unsafe void SetupImageArray(IntPtr buffer, int pixelSize, int rowStride, ImageDescription imageDesc, PitchFlags pitchFlags, PixelBuffer[] output) { int index = 0; var pixels = (byte*)buffer; for (uint item = 0; item < imageDesc.ArraySize; ++item) { int w = imageDesc.Width; int h = imageDesc.Height; int d = imageDesc.Depth; for (uint level = 0; level < imageDesc.MipLevels; ++level) { int rowPitch, slicePitch; int widthPacked; int heightPacked; ComputePitch(imageDesc.Format, w, h, out rowPitch, out slicePitch, out widthPacked, out heightPacked, pitchFlags); if (rowStride > 0) { // Check that stride is ok if (rowStride < rowPitch) throw new InvalidOperationException(string.Format("Invalid stride [{0}]. Value can't be lower than actual stride [{1}]", rowStride, rowPitch)); if (widthPacked != w || heightPacked != h) throw new InvalidOperationException("Custom strides is not supported with packed PixelFormats"); // Override row pitch rowPitch = rowStride; // Recalculate slice pitch slicePitch = rowStride * h; } for (uint zSlice = 0; zSlice < d; ++zSlice) { // We use the same memory organization that Direct3D 11 needs for D3D11_SUBRESOURCE_DATA // with all slices of a given miplevel being continuous in memory output[index] = new PixelBuffer(w, h, imageDesc.Format, rowPitch, slicePitch, (IntPtr)pixels); ++index; pixels += slicePitch; } if (h > 1) h >>= 1; if (w > 1) w >>= 1; if (d > 1) d >>= 1; } } }
//------------------------------------------------------------------------------------- // Encodes an image array //------------------------------------------------------------------------------------- private static void EncodeMultiframe( PixelBuffer[] images, int count, WICFlags flags, Guid guidContainerFormat, Stream stream ) { if ( images.Length < 2 ) throw new ArgumentException("Cannot encode to multiple frame. Image doesn't have multiple frame"); using (var encoder = new BitmapEncoder(Factory, guidContainerFormat)) { using (var eInfo = encoder.EncoderInfo) { if (!eInfo.IsMultiframeSupported) throw new NotSupportedException("Cannot encode to multiple frame. Format is not supporting multiple frame"); } encoder.Initialize(stream); for (int i = 0; i < Math.Min(images.Length, count); i++) { var pixelBuffer = images[i]; using (var frame = new BitmapFrameEncode(encoder)) EncodeImage(pixelBuffer, flags, frame); } encoder.Commit(); } }
private static void PrepareHeightMap(MyHeightmapFace map, PixelBuffer imageData) { IntPtr mapData = imageData.DataPointer; var rowStride = imageData.RowStride; for (int y = 0; y < map.Resolution; y++) { Utilities.Read(mapData, map.Data, map.GetRowStart(y), imageData.Width); //imageData.GetPixels<ushort>(map.Data, y, map.GetRowStart(y), imageData.Width); this has a bug, see sharpdx source and be amused mapData += rowStride; } }
public static void SaveTiffToWICMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream) { SaveToWICMemory(pixelBuffers, count, WICFlags.AllFrames, ImageFileType.Tiff, imageStream); }
private unsafe void ReadChannelsFromImage(byte[][] streams, PixelBuffer buffer) { byte* data = (byte*)buffer.DataPointer.ToPointer(); int dim = buffer.Width; for (int i = 0; i < 4; ++i) { if (streams[i] != null) { int j = 0, k = dim + 3; for (int y = 0; y < dim; y++) { for (int x = 0; x < dim; x++) { streams[i][k] = data[j * 4 + i]; ++j; ++k; } k += 2; } } } }
public static void SaveWmpToWICMemory(PixelBuffer[] pixelBuffers, int count, ImageDescription description, Stream imageStream) { SaveToWICMemory(pixelBuffers, 1, WICFlags.None, ImageFileType.Wmp, imageStream); }