SciChart.Drawing

EventArgs raised when the event is raised, which occurs at the start of the render pass

Initializes a new instance of the class.

The render surface.

Gets the instance which raised the Draw event

identifies cached rendered character

Defines the interface to a 2D Brush used to paint fills on the

Gets whether fills painted with this brush should be alpha blended or not

Defines the interface to a Extreme 2D RenderContext

Gets the current size of the viewport.

Blits the sprite onto the with colors provided by vertices

The sprite to draw The vertices to draw sprite at The start index in vertices array The amount of vertices to draw

Draws colored line strip with colors provided by vertice

The pen to draw line strip with The vertices to draw line strip The start index in vertices array The amount of vertices to draw

A base interface for and . Used by the to draw fills and lines

Gets the color of the pen. Supports transparency

Used internally by the renderer, gets the integer color-code that represents the Pen color

Gets a value indicating whether this pen is transparent.

true if this instance is transparent; otherwise, false.

Creates instances, e.g. to draw lines, points, polygon outlines depending on the final implementation.

Begins drawing at the specified X,Y pixel coordinate, with the specified color.

Creates instances, e.g. to draw points (ellipses, squares, triangles).

Begins drawing at the specified X,Y pixel coordinate, with the specified color.

Returns an to draw a polyline, or collection of PointMarkers

The following example shows how to create a PathDrawingContext, move it and dispose to complete the path


            var lineContext = renderContext.BeginLine(pen, 0, 0);
            lineContext.LineTo(1, 2);
            lineContext.LineTo(3, 4);
            lineContext.Dispose();

Starts the context at the specified X,Y coordinate with a specified Pen

The pen or brush for the drawing operation The x-coordinate in pixels The y-coordinate in pixels The instance, to allow fluent API

Moves the Context to the specified X,Y coordinate.

The x-coordinate in pixels The y-coordinate in pixels The instance, to allow fluent API

Ends the segment, flushing to render target

Returns an to draw a polyline, or collection of PointMarkers


            var lineContext = renderContext.BeginPoints(pen, 0, 0, 0);
            lineContext.LineTo(1, 2, 1);
            lineContext.LineTo(3, 4, 2);
            lineContext.Dispose();

Starts the context at the specified X,Y coordinate with a specified Pen

The pen or brush for the drawing operation The x-coordinate in pixels The y-coordinate in pixels The index to the data. The instance, to allow fluent API

Moves the Context to the specified X,Y coordinate.

The x-coordinate in pixels The y-coordinate in pixels The index to the data. The instance, to allow fluent API

Ends the segment, flushing to render target

Defines the interface to a 2D pen, used to draw lines on the

Gets the stroke thickness

Gets if antialiasing should be used

Gets a value that describes a shape at the end of line

Defines interface to context of splitting line into dashes

When true, this instance has dashes

Optional array with lengths of dash pattern items

Current index in StrokeDashArray

Already passed length of current item in StrokeDashArray

Defines the interface to a 2D RenderContext, allowing drawing, blitting and creation of pens and brushes on the

The is a graphics context valid for the current render pass. in which an is passed in. Use this to draw penned lines, fills, rectangles, ellipses and blit graphics to the screen.

Gets a collection of , which allow rendering operations to be posted to a layered queue for later execution in order (and correct Z-ordering).


            RenderOperationLayers layers = renderContext.Layers;
             
            // Enqueue some operations in the layers in any order
            layers[RenderLayer.AxisMajorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
            layers[RenderLayer.AxisBands].Enqueue(() => renderContext.DrawRectangle(/* .. */));
            layers[RenderLayer.AxisMinorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
             
            // Processes all layers by executing enqueued operations in order of adding, 
            // and in Z-order of layers
            layers.Flush();

Gets the current size of the viewport.

enables/disables primitves chaching optimization ( Direct3D renderer only )

Creates a valid for the current render pass. Use this to draw rectangles, polygons and shaded areas

The color of the brush, supports transparency The opacity of the brush If true, use alphablending when shading. If null, auto-detect The instance

Creates a from WPF Brush valid for the current render pass. Use this to draw rectangles, polygons and shaded areas

The WPF Brush to use as a source, e.g. this can be a , or it can be a . Note that solid colors support transparency and are faster than gradient brushes The opacity of the brush Defines a , e.g. brushes share a texture per viewport or a new texture per primitive drawn The instance

Creates a valid for the current render pass. Use this to draw outlines, quads and lines

The color of the pen, supports transparency If true, use antialiasing The strokethickness, default=1.0 The opecity of the pen The instance

Creates a Sprite from FrameworkElement by rendering to bitmap. This may be used in the method to draw to the screen repeatedly

The FrameworkElement to render The sprite which may be drawn in SciChart

Creates a Sprite from WriteableBitmap. This may be used in the method to draw to the screen repeatedly

The WriteableBitmap containing the sprite content The sprite which may be drawn in SciChart

Clears the

Blits the source image onto the

The source sprite to render The source rectangle The destination point, which will be the top-left coordinate of the sprite after blitting

Batch draw of the source sprite onto the

The sprite to render The source rectangle The points to draw sprites at

Batch draw of the source sprite onto the

The sprite to render The destination rectangles to draw sprites at

Fills a rectangle on the using the specified

The brush The top-left point of the rectangle The bottom-right point of the rectangle The angle which the brush is rotated by, default is zero

Fills a rectangle on the using the specified

The brush The top-left point of the rectangle The bottom-right point of the rectangle

Fills a polygon on the using the specifie

The brush The list of points defining the closed polygon, where X,Y coordinates in clockwise direction

Fills an area defined the the Points and Heights, e.g. as in a mountain chart, using the specifie

The brush Value, indicates whether chart is vertical The angle which the brush is rotated by

Draws a Quad on the using the specified

The Pen Left-top point in the quad Bottom-right point in the quad

Draws an Ellipse on the using the specified outline Pen and fill Brush

The stroke pen The fill brush The center of the ellipse in pixels The width of the ellipse in pixels The height of the ellipse in pixels

Draws 0..N Ellipses at the points passed in with the same width, height, pen and brush

The points to draw ellipses at The common width for all ellipses The common height for all ellipses

Draws a single line on the using the specified . Note for a faster implementation in some rasterizers, use DrawLines passing in an IEnumerable

The pen The start of the line in pixels The end of the line in pixels

Draws a multi-point line on the using the specified

The pen The points The last point in the polyline drawn

Call this method, passing in instance to dispose after the render pass completes. Called internally by SciChart to lazy-dispose of Direct2D and Direct3D brushes and textures

Draws vertical scan line for heatmap from bottom to top, from yStart to yEnd

Screen X coordinate where to draw pixels Screen X coordinate where to draw pixels Screen Y coordinate of vertical scan line's bottom. Can be located outdide of visible area, in this case not all pixels in list are rendered Screen Y coordinate of vertical scan line's top. Can be located outdide of visible area, in this case not all pixels in list are rendered The list of pixel colors to draw The Opacity of the line from 0.0 to 1.0 if set to true then y axis is flipped.

Draws text if it does not go outside

Begins a Polyline segment, returning the . This is the fastest way to draw lines and simply a proxy to method.

The pen for the line segment The start X coordinate (pixel coord) The start Y coordinate (pixel coord) The to continue the line

Begins a filled Polygon segment, returning the . This is the fastest way to draw polygon and simply a proxy to method.

The brush for the polygon fill The start X coordinate (pixel coord) The start Y coordinate (pixel coord) The angle which the is rotated by The to continue the polygon

Begins a Sprite Batch, returning the . This is the fastest way to draw sprites and simply a proxy to method.

The sprite for the Sprite Batch The start X coordinate (pixel coord) The start Y coordinate (pixel coord) An optional width override for the sprite. Defaults to Sprite.Width An optional height override for the sprite. Defaults to Sprite.Height The to continue the sprite batch

Creates a Texture with the specified width, height and format. This texture may be modified, and drawn repeatedly using

The width of the texture in pixels The height of the texture in pixels The texture format. A new Texture2D object, which must be disposed when no longer required

Draws the to the specified viewport rect

The texture. The viewport rect. The sampling mode.

Draws contours for a height texture the texture.

The float texture. The viewport rect.

Gets from this render context

Determines whether the primitive type T is compatible with this instance

The object.

Draws vertical scan line for heatmap from bottom to top, from yStart to yEnd

Screen X coordinate where to draw pixels Screen X coordinate where to draw pixels An array of yCoordinates on YAxis The list of pixel colors to draw The Opacity of the line from 0.0 to 1.0 if set to true then X values are to each other and the same is for Y values. if set to true then y axis is flipped.

Defines enumeration constants to describe how textures are mapped. If textures are mapped , then a single large texture is shared for all elements that use this texture. Else, if then individual primitives have separate textures.

with this mode texture coordinates equal to screen coordinates

with this mode entire texture is fit into single primitive

Common interface for a RenderSurface,

Raised each time the render surface is to be drawn. Handle this event to paint to the surface

Raised immediately after a render operation has completed

Returns True if the size has changed and the viewport needs resizing

Returns true if the size is valid for drawing

Gets or sets a to apply to the

Gets or sets the instance

The services.

Clears all Visual Children on the

Clears the viewport

Recreates the elements required by the Viewport, called once at startup and when the surface is resized

Defines the interface to a RenderSurface, which is a viewport used to draw 2D graphics in a fast manner. The renderer architecture is plugin based, meaning we have build multiple implementations of .

Gets the ChildSeries in this instance.

Creates an instance to perform drawing operations. Note this is only valid for the current render pass

Returns True if the contains the instance

the RenderableSeries instance as

Adds the instance as a visual child to the

Adds the instances as visual children to the

Removes the from the

Creates a , a class which schedules rendering. There are default implementations built in to SciChart including which uses DispatcherTimer and which uses System.Timers.Timer.

The current application dispatcher Maximum frame rate. If null, chooses the default value (60 FPS). Else, uses the provided value Callback function for when the render timer elapses

Default implementation of

Defines the interface to a 2D Sprite, a small fixed-size bitmap which is rendered repeatedly to the viewport

Gets the width of the Spite in pixels

Gets the height of the Sprite in pixels

Defines TextureFormats for derived types

Texture pixel format is Blue Green Red Alpha (8 bit per channel)

Defines the texture filtering mode. Texture filtering is the method used to determine the texture color for a texture mapped pixel, using the colors of nearby texels (pixels of the texture)

Point filtering samples a texture without considering values from nearby texels. Final image looks sharp.

Linear filtering samples a texture by linear interpolation of values from nearby texels. Final image looks smoothed. Supported only by DirectX render context.

Defines the interface to a 2D texture, used to draw images on the

Gets the width of the texture

Gets the height of the texture

Gets the texture format for this texture

Sets int[] pixel data on the Texture. Assumes

The color data for pixels.

Sets int[] pixel data on the Texture. Assumes

The color data for pixels.

Defines the interface to a GPU vertex buffer

USED INTERNALLY: Locks GPU vertex buffer for direct memory access

USED INTERNALLY: Unlocks GPU vertex buffer before rendering

USED INTERNALLY: Locks GPU vertex buffer for direct memory access

USED INTERNALLY: Unlocks GPU vertex buffer before rendering

USED INTERNALLY: Locks GPU vertex buffer for direct memory access

USED INTERNALLY: Unlocks GPU vertex buffer before rendering

Defines the interface to a Twister 2D RenderContext, allowing drawing, blitting and creation of pens and brushes on the

Draws lines from array as a single batched call.

The array containing data to draw. The number of points to draw. The default line pen. If set to false draw a line in segments. If set to true draw a digital, stepped line. If set to true double.NaN gaps are rendered as gaps, otherwise as closed lines. Null means regular line. The optional per-vertex transform to apply to each point during rendering. Null means identity matrix.

Draws sprites defined by the from an array as a single batched call.

The array containing data to draw. The number of points to draw. The sprite to draw at each point The sprite to draw stroke at each point The optional per-vertex transform to apply to each point during rendering. Null means identity matrix.

Draws two lines and a band polygon between the Y0 and Y1 points on each , as a single batched call.

The array containing data to draw. The number of points to draw. The pen to draw the Y0 line. The pen to draw the Y1 line. The brush used to fill the band when Y0 > Y1. The brush used to fill the band when Y0 < Y1. If set to true draw a digital line/band. The optional per-vertex transform to apply to each point during rendering. Null means identity matrix. The optional colors to apply to each point during rendering. Null means default colors.

Draws a mountain or area between Y0 and Y1 in the array, as a single batched draw call.

The array containing data to draw. The number of points to draw. The pen to draw the Y0 line. The brush used to fill the area when Y0 > Y1. If set to true draw a digital line/mountain. The optional per-vertex transform to apply to each point during rendering. Null means identity matrix. The optional colors to apply to each point during rendering. Null means default colors.

Draws candlesticks from the array, as a single batched draw call.

The array containing data to draw. The number of points to draw. The width of each candle in pixels The pen to paint wicks if the candle is an UP candle The pen to paint wicks if the candle is a DOWN candle The brush to fill candles if the candle is UP The brush to fill candles if the candle is DOWN The optional per-vertex transform to apply to each point during rendering. Null means identity matrix.

Draws OHLC bars from the array, as a single batched draw call.

The array containing data to draw. The number of points to draw. The width of each bar in pixels The pen to paint wicks if the bar is an UP bar The pen to paint wicks if the bar is a DOWN bar The optional per-vertex transform to apply to each point during rendering. Null means identity matrix.

Draws columns from the array, as a single batched draw call.

The array containing data to draw. The number of points to draw. The pen to draw the stroke line. The brush used to fill the area. The optional per-vertex transform to apply to each point during rendering. Null means identity matrix.

Draws rectangles from the array, as a single batched draw call.

The array containing data to draw. The number of points to draw. The sprite to draw at each point The optional per-vertex transform to apply to each point during rendering. Null means identity matrix.

Sets a viewport rectangle for all subsequent draw calls.

The viewport rectangle to draw.

Gets a unique Id for Vx engine instance

Defines the base class for implementors, allowing drawing, blitting and creation of pens and brushes on the

Gets a collection of layers, which allow rendering operations to be posted to a layered queue for later execution in order (and correct Z-ordering).


            RenderOperationLayers layers = renderContext.Layers;
             
            // Enqueue some operations in the layers in any order
            layers[RenderLayer.AxisMajorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
            layers[RenderLayer.AxisBands].Enqueue(() => renderContext.DrawRectangle(/* .. */));
            layers[RenderLayer.AxisMinorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
             
            // Processes all layers by executing enqueued operations in order of adding, 
            // and in Z-order of layers
            layers.Flush();

Gets the size of the current viewport for this render operation

enables/disables primitves chaching optimization ( Direct3D renderer only )

Creates a valid for the current render pass. Use this to draw rectangles, polygons and shaded areas

The color of the brush, supports transparency The opacity of the brush If true, use alphablending when shading. If null, auto-detect from the Color The instance

Creates a from WPF Brush valid for the current render pass. Use this to draw rectangles, polygons and shaded areas

The WPF Brush to use as a source, e.g. this can be a , or it can be a . Note that solid colors support transparency and are faster than gradient brushes The opacity of the brush The instance

Creates a valid for the current render pass. Use this to draw outlines, quads and lines

The color of the pen, supports transparency If true, use antialiasing The strokethickness, default=1.0 The opecity of the pen The instance

Creates a Sprite from FrameworkElement by rendering to bitmap. This may be used in the method to draw to the screen repeatedly

The FrameworkElement to render The sprite which may be drawn in SciChart

Creates a Sprite from WriteableBitmap. This may be used in the method to draw to the screen repeatedly

The WriteableBitmap containing the sprite content The sprite which may be drawn in SciChart

Clears the

Blits the source image onto the

The source sprite to render The source rectangle The destination point, which will be the top-left coordinate of the sprite after blitting

Batch draw of the source sprite onto the

The sprite to render The source rectangle The points to draw sprites at

Batch draw of the source sprite onto the

The sprite to render The destination rectangles to draw sprites at

Fills a rectangle on the using the specified

The brush The angle which the brush is rotated by

Fills a rectangle on the using the specified

The brush The angle which the brush is rotated by

Fills an area, limited by two line segments, e.g. as in a stacked mountain chart, using the specified

The brush The list of lines representing polygon segments Value, indicates whether chart is vertical The angle which the brush is rotated by

Draws an Ellipse on the using the specified outline Pen and fill Brush

The stroke pen The fill brush The center of the ellipse in pixels The width of the ellipse in pixels The height of the ellipse in pixels

Draws 0..N Ellipses at the points passed in with the same width, height, pen and brush

The points to draw ellipses at The common width for all ellipses The common height for all ellipses

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Call this method, passing in instance to dispose after the render pass completes. Called internally by SciChart to lazy-dispose of Direct2D and Direct3D brushes and textures

Draws vertical scan line for heatmap from bottom to top, from yStart to yEnd

Screen X coordinate where to draw pixels Screen X coordinate where to draw pixels Screen Y coordinate of vertical scan line's bottom. Can be located outdide of visible area, in this case not all pixels in list are rendered Screen Y coordinate of vertical scan line's top. Can be located outdide of visible area, in this case not all pixels in list are rendered The colors to apply to the vertical scanline The opacity of the vertical scaline, from 0.0 to 1.0 if set to true then y axis is flipped.

Draws vertical scan line for heatmap from bottom to top, from yStart to yEnd

Draws a Quad on the using the specified

The Pen

Draws a single line on the using the specified . Note for a faster implementation in some rasterizers, use DrawLines

The pen The start of the line in pixels The end of the line in pixels

Draws a multi-point line on the using the specified

The pen The points.

Fills a polygon on the using the specifie

The brush The list of points defining the closed polygon, where X,Y coordinates in clockwise direction

Draws text if it does not go outside

Begins a Polyline segment, returning the . This is the fastest way to draw lines and simply a proxy to method.

The pen for the line segment The start X coordinate (pixel coord) The start Y coordinate (pixel coord) The to continue the line

Begins a filled Polygon segment, returning the . This is the fastest way to draw polygon and simply a proxy to method.

The brush for the polygon fill The start X coordinate (pixel coord) The start Y coordinate (pixel coord) The angle which the is rotated by The to continue the polygon

Begins a Sprite Batch, returning the . This is the fastest way to draw sprites and simply a proxy to method.

Used internally: Clips the zero line (e.g. in mountain fills) to the viewport

Used internally to clip a polygon or line-segment to the viewport

Returns true if the point is inside the viewport

Used internally to clip the area of a StackedMountainSeries to the viewport

Collection of lines, which represent bounds of a polygon segment

Event args used when the event is raised

Initializes a new instance of the class.

The duration of the last render operation in milliseconds

Gets the duration of the last render operation in milliseconds

Stores a queue of operations to perform, intended to be used to queue rendering operations and re-arrange Z-order


            RenderOperationLayers layers = renderContext.Layers;
             
            // Enqueue some operations in the layers in any order
            layers[RenderLayer.AxisMajorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
            layers[RenderLayer.AxisBands].Enqueue(() => renderContext.DrawRectangle(/* .. */));
            layers[RenderLayer.AxisMinorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
             
            // Processes all layers by executing enqueued operations in order of adding, 
            // and in Z-order of layers
            layers.Flush();

Enqueues an operation to the layer

The operation to queue

Flushes, the layer, which processes all operations and clears the queue

Enumeration Constants to define the layers in

The Axis Bands render layer, Z-order = 0

The Axis Minor Gridlines render layer, Z-order = 1

The Axis Major Gridlines render layer, Z-order = 2

The RenderableSeries render layer, Z-order = 3

A collection of layers, which allow rendering operations to be posted to a layered queue for later execution in order (and correct Z-ordering).


            RenderOperationLayers layers = renderContext.Layers;
             
            // Enqueue some operations in the layers in any order
            layers[RenderLayer.AxisMajorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
            layers[RenderLayer.AxisBands].Enqueue(() => renderContext.DrawRectangle(/* .. */));
            layers[RenderLayer.AxisMinorGridlines].Enqueue(() => renderContext.DrawLine(/* .. */));
             
            // Processes all layers by executing enqueued operations in order of adding, 
            // and in Z-order of layers
            layers.Flush();

Gets the with the specified .

The . The layer to get.

Returns an enumerator that iterates through a collection.

An object that can be used to iterate through the collection.

Returns an enumerator that iterates through a collection.

An object that can be used to iterate through the collection.

Flushes the collection, processing and executing all render operations according to the Z-order defined by the enumeration

An abstract base class for the RenderSurface, which is a viewport used within the a SciChartSurface to render RenderableSeries types in a fast manner. The renderer architecture is plugin based, meaning we have build multiple implementations of .

Defines the MaxFrameRate DependencyProperty

Defines the UseResizeThrottle DependencyProperty

Defines the ResizeThrottleMs DependencyProperty

Defines the ShowLicensingWarnings DependencyProperty

Defines the IsPolarChart DependencyProperty

Raised each time the render surface is to be drawn. Handle this event to paint to the surface

Raised immediately after a render operation has completed

A GUID to identify the hit-test rect on this RenderSurface

The WriteableBitmap instance used by this RenderSurface

Gets whether an instance of the class is disposed or not.

Initializes a new instance of the class.

Finalizes an instance of the class.

Returns the FontCache (for drawing font characters) of the current RenderSurface

Gets or sets the instance

The services.

Experimental. Switches the RenderTimer using CompositionTarget.Rendering for a ThreadedRenderScheduler which uses background thread to initiate drawing at high priority

For fine grained control over render scheduling, create a class which implements IRenderTimerFactory. Default value is DefaultRenderTimerFactory

Gets whether the SciChartSurface is a polar chart or not

When True, Licensing warnings such as missing Runtime Keys, or invalid license tokens, are displayed on the SciChart UI. Set this property to false to hide such warnings.

Gets the root element which hosts components in the

Gets the SeriesPanel which hosts RenderableSeries, allowing them to participate in binding and visual tree operations

Gets or sets the Maximum Frame Rate of this RenderSurface. By default this is bound to the parent SciChartSurface.MaxFrameRate

Gets or sets a timeout for resizing, e.g. 100ms means that the RenderSurface will batch up all Resize events received within a 100ms window. This reduces the CPU usage on resize. Also see dependency property, which must be true

If true, uses the value to batch up Resize Events received within a certain time window, reducing the CPU load on resize

Returns True if the size has changed and the viewport needs resizing

Returns true if the size is valid for drawing

Gets the child RenderableSeries in this instance

Invalidates the RenderSurface, causing a repaint to occur

Clears the viewport

Returns True if the contains the instance

the instance true if the specified renderable series contains series; otherwise, false.

Adds the instance to the

The renderable series.

Removes the from the

The renderable series.

Clears all on the

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Releases unmanaged and - optionally - managed resources.

true to release both managed and unmanaged resources; false to release only unmanaged resources.

Recreates the elements required by the Viewport, called once at startup and when the surface is resized

Publishes with actual viewport size

When overridden in a derived class, returns a RenderContext valid for the current render pass

Derived classes may override this method to be notified when to dispose of unmanaged resources. Called when the is disposed

Called when the event is raised

Raises the Draw event which precedes the render operation

Raises the Rendered event with the specified duration

The duration.

Called when the is loaded into the visual tree

The sender. The instance containing the event data.

Called when the is Unloaded from the visual tree

The sender. The instance containing the event data.

Translates the point relative to the other element

The input point relative to this The other to use when transforming the point The transformed Point

Returns true if the Point is within the bounds of the current element

The point to test true if the Point is within the bounds

Gets the bounds of the current element relative to another element

A timer which uses either event (in case of maxFrameRate supplied as null to Constructor) or DispatcherTimer. Used by derived types to trigger drawing

Initializes a new instance of the class.

The maximum frame rate. When null, uses event. Else, uses a dispatcher timer The dispatcher. The operation to invoke on timer tick.

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

A timer which uses to signal when rendering should occur. This can be used to solve problems with WinForms / WPF message loops and priority in certain high performance scenarios Used by derived types to trigger drawing

Initializes a new instance of the class.

The maximum frame rate. When null, uses event. Else, uses a dispatcher timer The dispatcher. The operation to invoke on timer tick.

Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

Extension methods for FrameworkElements

Databinds the source property to the destination property

The destination object. The destination property. The source object. The source path. The Binding mode.

Renders a FrameworkElement to bitmap

The element.

Renders a FrameworkElement to bitmap at the requested width, height

The element. The width. The height.

Provides a implementation that uses a High-Quality software rasterizer, capable of rendering with sub-pixel accuracy. The downside is, the uses a more accurate floating-point math rendering engine which is slower than the counterpart

An empty row, used to fast clear bitmaps

Initializes a new instance of the class.

Recreates the WriteableBitmap used by the Viewport

When overridden in a derived class, returns a RenderContext valid for the current render pass

Provides a implementation that uses a High-Speed software rasterizer, capable of outputting many millions of points (line-series) at interactive framerates. The downside is, the uses integer fixed-point math which results in jagged lines.

Initializes a new instance of the class.

When overridden in a derived class, returns a RenderContext valid for the current render pass

The TextureCache is used by the to cache frequently used textures, such as Sprites or Gradient Brushes. The maximum memory size is set by (default 32MBytes), and maximum number of items held is set by (default 2048).

The maximum memory size that the TextureCache can hold

The maximum items count that the TextureCache can hold

Adds the texture to the Texturecache

The size of the texture in pixels. The brush used as a key for texture cache. The texture.

Gets the Texture of Size N and keyed by Brush

The size. The brush.

Gets the WriteableBitmap Texture keyed by FrameworkElement

The fe.

Adds a texture keyed by Size and Brush to the cache

The size. The brush. The texture.

Gets the Texture keyed by Size and Brush

The size. The brush.

Provides helper methods for manipulations with points

Represents a straight line between two points

The X coord of the first point

The Y coord of the first point

The X coord of the second point

The Y coord of the second point

Creates a new instance of the type

Looks for the intersection point for the two lines passed in

The first line The second line If the lines intersect, holds the intersection point The value indicating whether an intersection occurs See http://paulbourke.net/geometry/lineline2d/Helpers.cs

Looks for the intersection point for the two lines passed in

The first line The second line If the lines intersect, holds the intersection point The value indicating whether an intersection occurs See http://paulbourke.net/geometry/lineline2d/Helpers.cs

Get whether the coordinate mouse point is on the polygon

Mouse point polygon points

Distance between two Points

The point1. The point2.

Distance between two Points in polar coordinates

The point1. The point2.

Compute the distance from AB to C

The pt. The start. The end. if isSegment is true, AB is a segment, not a line..

Determines whether the point is in bounds for the viewport size.

The point. Size of the viewport.

Sutherland–Hodgman polygon clipping algorithm

https://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman_algorithm

This clips the subject polygon against the clip polygon (gets the intersection of the two polygons)

Based on the psuedocode from: http://en.wikipedia.org/wiki/Sutherland%E2%80%93Hodgman Can be concave or convex Must be convex The intersection of the two polygons (or null)

Provides methods to convert a to a single 32-bit value and back, a single 32-bit value to a

Converts a to UInt32 returning all four color components A,R,G,B in a single 32-bit value

Converts a to UInt32 returning all four color components A,B,G,R in a single 32-bit value

Converts a UInt32 ARGB Color to struct

Enumeration constants to define the usage of DirectX in SciChart

Auto-detects DirectX mode for D3D Chart Rendering

Force using DirectX9c for D3D Chart Rendering

Force using DirectX11 for D3D Chart Rendering

Enumeration constants to define the Full Screen AntiAliasing mode on the SciChartSurface and SciChart3DSurface

No Antialiasing

Enables Multi-Sample AntiAliasing x2

Enables Multi-Sample AntiAliasing x4

Enables Multi-Sample AntiAliasing x8

Provides a implementation that uses The Visual Xccelerator Engine

The render pipeline of the

Initializes a new instance of the class.

Internal access for testing.

Determines if the code is being run under Remote Desktop.

When True (default), uses software method to FillSource (avoiding use of D3DImage). This can help compatibility on certain systems When False, uses for hardware accelerated texture sharing.

To enable compatibility mode for SciChart3DSurface, set this property once, statically, in your application

        
            void Foo()
            {
               Direct3D11RenderSurface.UseAlternativeFillSource = true;
            }

When false (default), there is no waiting for the gpu to finish rendering, and the frame buffer is copied immediately when true, we force the application to stall until the gpu is idle, this fixes flicker issues that can happen on older hardware

To enable waiting for gpu to finish

        
            void Foo()
            {
               Viewport3D.ForceStallUntilGPUIsIdle = true;
            }

Returns a RenderContext valid for the current render pass.

Should be called to fill a bitmap with the pixels from the undelrying buffer

writeable bitmap should be precreated with same size prior calling

Should be called to fill the WPF Image from the Direct3D Render Target at the end of drawing.

Alternative method for filling a WriteableBitmap with DirectX content, avoiding D3DImage (does not work over RDP due to bug in .NET4.0 implementation of D3DImage)

Should be called to fill the WPF Image from the Direct3D Render Target at the end of drawing.

Recreates the elements required by the Viewport, called once at startup and when the surface is resized.

Called when the is disposed.

Restarts 3D Engine with configuration flags.

Called when the elements required by the Viewport have been recreated.

Called when the is disposed.

For smooth appearance of non-digital anti-aliased line, the stroke thickness should be greater than 1 pixel

Provides a implementation that uses a High-Quality software rasterizer, capable of rendering with sub-pixel accuracy. The downside is, the uses a more accurate vector-based rendering engine which is slower than the counterpart.

Initializes a new instance of the class.

Recreates the elements required by the Viewport, called once at startup and when the surface is resized

When overridden in a derived class, returns a RenderContext valid for the current render pass

Collection of draw extension methods for the Silverlight WriteableBitmap class.

Collection of extension methods for the WriteableBitmap class.

Collection of blit (copy) extension methods for the WriteableBitmap class.

Collection of interchange extension methods for the WriteableBitmap class.

Collection of extension methods for the WriteableBitmap class.

Collection of filter / convolution extension methods for the WriteableBitmap class.

Collection of draw extension methods for the WriteableBitmap class.

Collection of draw spline extension methods for the WriteableBitmap class.

Collection of transformation extension methods for the WriteableBitmap class.

Draws a filled rectangle. x2 has to be greater than x1 and y2 has to be greater than y1.

The WriteableBitmap. The x-coordinate of the bounding rectangle's left side. The y-coordinate of the bounding rectangle's top side. The x-coordinate of the bounding rectangle's right side. The y-coordinate of the bounding rectangle's bottom side. The color. The blend mode.

A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf Uses a different parameter representation than DrawEllipse().

The BitmapContext. The x-coordinate of the ellipses center. The y-coordinate of the ellipses center. The radius of the ellipse in x-direction. The radius of the ellipse in y-direction. The color for the line. The blend mode. BlendMode.Alpha is the default mode.

Draws a filled polygon. Add the first point also at the end of the array if the line should be closed.

The WriteableBitmap. The points of the polygon in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn). The color for the fill. The blend mode. Default is Alpha

Draws a colored line by connecting two points using the Bresenham algorithm.

The BitmapContext. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf Uses a different parameter representation than DrawEllipse().

Sets the color of the pixel. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The BitmapContext. The width of the bitmap. The height of the bitmap. The x coordinate (row). The y coordinate (column). The color.

Fills the whole WriteableBitmap with a color.

The WriteableBitmap. The color used for filling.

Fills the whole WriteableBitmap with an empty color (0).

The WriteableBitmap.

Clones the specified WriteableBitmap.

The WriteableBitmap. A copy of the WriteableBitmap.

Applies the given function to all the pixels of the bitmap in order to set their color.

The WriteableBitmap. The function to apply. With parameters x, y and a color as a result

Applies the given function to all the pixels of the bitmap in order to set their color.

The WriteableBitmap. The function to apply. With parameters x, y, source color and a color as a result

Gets the color of the pixel at the x, y coordinate as integer. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The x coordinate of the pixel. The y coordinate of the pixel. The color of the pixel at x, y.

Gets the color of the pixel at the x, y coordinate as a Color struct. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The x coordinate of the pixel. The y coordinate of the pixel. The color of the pixel at x, y as a Color struct.

Gets the brightness / luminance of the pixel at the x, y coordinate as byte.

The WriteableBitmap. The x coordinate of the pixel. The y coordinate of the pixel. The brightness of the pixel at x, y.

Sets the color of the pixel using a precalculated index (faster). For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The coordinate index. The red value of the color. The green value of the color. The blue value of the color.

Sets the color of the pixel. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The x coordinate (row). The y coordinate (column). The red value of the color. The green value of the color. The blue value of the color.

Sets the color of the pixel including the alpha value and using a precalculated index (faster). For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The coordinate index. The alpha value of the color. The red value of the color. The green value of the color. The blue value of the color.

Sets the color of the pixel including the alpha value. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The x coordinate (row). The y coordinate (column). The alpha value of the color. The red value of the color. The green value of the color. The blue value of the color.

Sets the color of the pixel using a precalculated index (faster). For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The coordinate index. The color.

Sets the color of the pixel. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The x coordinate (row). The y coordinate (column). The color.

Sets the color of the pixel using an extra alpha value and a precalculated index (faster). For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The coordinate index. The alpha value of the color. The color.

Sets the color of the pixel using an extra alpha value. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The x coordinate (row). The y coordinate (column). The alpha value of the color. The color.

Sets the color of the pixel using a precalculated index (faster). For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The coordinate index. The color.

Sets the color of the pixel. For best performance this method should not be used in iterative real-time scenarios. Implement the code directly inside a loop.

The WriteableBitmap. The x coordinate (row). The y coordinate (column). The color.

The blending mode.

Alpha blendiing uses the alpha channel to combine the source and destination.

Additive blending adds the colors of the source and the destination.

Subtractive blending subtracts the source color from the destination.

Uses the source color as a mask.

Multiplies the source color with the destination color.

Ignores the specified Color

No blending just copies the pixels from the source.

Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).

The destination WriteableBitmap. The rectangle that defines the destination region. The source WriteableBitmap. The rectangle that will be copied from the source to the destination. The blending mode .

Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).

The destination WriteableBitmap. The rectangle that defines the destination region. The source WriteableBitmap. The rectangle that will be copied from the source to the destination.

Copies (blits) the pixels from the WriteableBitmap source to the destination WriteableBitmap (this).

The destination WriteableBitmap. The destination position in the destination bitmap. The source WriteableBitmap. The rectangle that will be copied from the source to the destination. If not Colors.White, will tint the source image. A partially transparent color and the image will be drawn partially transparent. The blending mode .

Copies the Pixels from the WriteableBitmap into a ARGB byte array starting at a specific Pixels index.

The WriteableBitmap. The starting Pixels index. The number of Pixels to copy, -1 for all The color buffer as byte ARGB values.

Copies the Pixels from the WriteableBitmap into a ARGB byte array.

The WriteableBitmap. The number of pixels to copy. The color buffer as byte ARGB values.

Copies all the Pixels from the WriteableBitmap into a ARGB byte array.

The WriteableBitmap. The color buffer as byte ARGB values.

Copies color information from an ARGB byte array into this WriteableBitmap starting at a specific buffer index.

The WriteableBitmap. The starting index in the buffer. The number of bytes to copy from the buffer. The color buffer as byte ARGB values. The WriteableBitmap that was passed as parameter.

Copies color information from an ARGB byte array into this WriteableBitmap.

The WriteableBitmap. The number of bytes to copy from the buffer. The color buffer as byte ARGB values. The WriteableBitmap that was passed as parameter.

Copies all the color information from an ARGB byte array into this WriteableBitmap.

The WriteableBitmap. The color buffer as byte ARGB values. The WriteableBitmap that was passed as parameter.

Writes the WriteableBitmap as a TGA image to a stream. Used with permission from Nokola: http://nokola.com/blog/post/2010/01/21/Quick-and-Dirty-Output-of-WriteableBitmap-as-TGA-Image.aspx

The WriteableBitmap. The destination stream.

Loads an image from the applications resource file and returns a new WriteableBitmap. The passed WriteableBitmap is not used.

The WriteableBitmap. Only the relative path to the resource file. The assembly name is retrieved automatically. A new WriteableBitmap containing the pixel data.

Loads an image from the applications content and returns a new WriteableBitmap. The passed WriteableBitmap is not used.

The WriteableBitmap. Only the relative path to the content file. A new WriteableBitmap containing the pixel data.

Loads the data from an image stream and returns a new WriteableBitmap. The passed WriteableBitmap is not used.

The WriteableBitmap. The stream with the image data. A new WriteableBitmap containing the pixel data.

Draws a filled rectangle using . x2 has to be greater than x1 and y2 has to be greater than y1.

Draws a filled rectangle with the specified . x2 has to be greater than x1 and y2 has to be greater than y1.

A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf x2 has to be greater than x1 and y2 has to be greater than y1.

A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf Uses a different parameter representation than DrawEllipse().

The WriteableBitmap. The x-coordinate of the ellipses center. The y-coordinate of the ellipses center. The radius of the ellipse in x-direction. The radius of the ellipse in y-direction. The color for the line.

A Fast Bresenham Type Algorithm For Drawing filled ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf Uses a different parameter representation than DrawEllipse().

Draws a filled polygon. Add the first point also at the end of the array if the line should be closed.

The WriteableBitmap. The points of the polygon in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn). The color for the line.

Draws a filled polygon. Add the first point also at the end of the array if the line should be closed.

The WriteableBitmap. The points of the polygon in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn). The color for the line.

Draws a filled polygon. Add the first point also at the end of the array if the line should be closed.

The WriteableBitmap. The points of the polygon in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn). The color for the line. The blend mode. Default is Alpha

Draws a filled quad.

The WriteableBitmap. The x-coordinate of the 1st point. The y-coordinate of the 1st point. The x-coordinate of the 2nd point. The y-coordinate of the 2nd point. The x-coordinate of the 3rd point. The y-coordinate of the 3rd point. The x-coordinate of the 4th point. The y-coordinate of the 4th point. The color.

Draws a filled quad.

Draws a filled triangle.

Draws a series of filled, cubic Bezier splines each defined by start, end and two control points. The ending point of the previous curve is used as starting point for the next. Therfore the inital curve needs four points and the subsequent 3 (2 control and 1 end point).

The WriteableBitmap. The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, cx1, cy1, cx2, cy2, x2, y2, cx3, cx4 ..., xn, yn). The color for the spline.

Draws a filled Cardinal spline (cubic) defined by a point collection. The cardinal spline passes through each point in the collection.

The WriteableBitmap. The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, x3, y3, x4, y4, x1, x2 ..., xn, yn). The tension of the curve defines the shape. Usually between 0 and 1. 0 would be a straight line. The color for the spline.

Draws a filled Cardinal spline (cubic) defined by a point collection. The cardinal spline passes through each point in the collection.

Draws a filled, closed Cardinal spline (cubic) defined by a point collection. The cardinal spline passes through each point in the collection.

Gaussian blur kernel with the size 5x5

Gaussian blur kernel with the size 3x3

Sharpen kernel with the size 3x3

Creates a new filtered WriteableBitmap.

The WriteableBitmap. The kernel used for convolution. A new WriteableBitmap that is a filtered version of the input.

Creates a new filtered WriteableBitmap.

The WriteableBitmap. The kernel used for convolution. The factor used for the kernel summing. The offset used for the kernel summing. A new WriteableBitmap that is a filtered version of the input.

Creates a new inverted WriteableBitmap and returns it.

The WriteableBitmap. The new inverted WriteableBitmap.

Alpha blends 2 premultiplied colors with each other

Source alpha color component Premultiplied source red color component Premultiplied source green color component Premultiplied source blue color component Premultiplied destination color Premultiplied blended color value

Draws an anti-aliased, alpha blended, colored line by connecting two points using Wu's antialiasing algorithm Uses the pixels array and the width directly for best performance.

An array containing the pixels as int RGBA value. The width of one scanline in the pixels array. The height of the bitmap. The x0. The y0. The x1. The y1. Alpha color component Premultiplied red color component Premultiplied green color component Premultiplied blue color component

Draws a colored line by connecting two points using the Bresenham algorithm.

The WriteableBitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

Draws a colored line by connecting two points using the Bresenham algorithm.

The WriteableBitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

Draws a colored line by connecting two points using a DDA algorithm (Digital Differential Analyzer).

The WriteableBitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

Draws a colored line by connecting two points using a DDA algorithm (Digital Differential Analyzer).

The WriteableBitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

Draws a colored line by connecting two points using an optimized DDA.

The WriteableBitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

Draws a colored line by connecting two points using an optimized DDA.

The WriteableBitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

Draws a colored line by connecting two points using an optimized DDA. Uses the pixels array and the width directly for best performance.

The context containing the pixels as int RGBA value. The width of one scanline in the pixels array. The height of the bitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the end point. The y-coordinate of the end point. The color for the line.

Draws an anti-aliased line, using an optimized version of Gupta-Sproull algorithm From http://nokola.com/blog/post/2010/10/14/Anti-aliased-Lines-And-Optimizing-Code-for-Windows-Phone-7e28093First-Look.aspx The WriteableBitmap.The x-coordinate of the start point.The y-coordinate of the start point.The x-coordinate of the end point.The y-coordinate of the end point.The color for the line.

Draws an anti-aliased line, using an optimized version of Gupta-Sproull algorithm From http://nokola.com/blog/post/2010/10/14/Anti-aliased-Lines-And-Optimizing-Code-for-Windows-Phone-7e28093First-Look.aspx The context containing the pixels as int RGBA value.The width of one scanline in the pixels array.The height of the bitmap.The x-coordinate of the start point.The y-coordinate of the start point.The x-coordinate of the end point.The y-coordinate of the end point.The color for the line.

The context. Width of the pixel. Height of the pixel. The x1. The y1. The x2. The y2. The color. if set to true skip first pixel.

Draws a polyline. Add the first point also at the end of the array if the line should be closed.

The WriteableBitmap. The points of the polyline in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn). The color for the line.

Draws a polyline. Add the first point also at the end of the array if the line should be closed.

The WriteableBitmap. The points of the polyline in x and y pairs, therefore the array is interpreted as (x1, y1, x2, y2, ..., xn, yn). The color for the line.

Draws a triangle.

Draws a quad.

Draws a rectangle. x2 has to be greater than x1 and y2 has to be greater than y1.

A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf x2 has to be greater than x1 and y2 has to be greater than y1.

A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf Uses a different parameter representation than DrawEllipse().

A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf x2 has to be greater than x1 and y2 has to be greater than y1.

A Fast Bresenham Type Algorithm For Drawing Ellipses http://homepage.smc.edu/kennedy_john/belipse.pdf Uses a different parameter representation than DrawEllipse().

Draws a cubic Beziér spline defined by start, end and two control points.

The WriteableBitmap. The x-coordinate of the start point. The y-coordinate of the start point. The x-coordinate of the 1st control point. The y-coordinate of the 1st control point. The x-coordinate of the 2nd control point. The y-coordinate of the 2nd control point. The x-coordinate of the end point. The y-coordinate of the end point. The color.

Draws a cubic Beziér spline defined by start, end and two control points.

Draws a series of cubic Beziér splines each defined by start, end and two control points. The ending point of the previous curve is used as starting point for the next. Therfore the inital curve needs four points and the subsequent 3 (2 control and 1 end point).

The WriteableBitmap. The points for the curve in x and y pairs, therefore the array is interpreted as (x1, y1, cx1, cy1, cx2, cy2, x2, y2, cx3, cx4 ..., xn, yn). The color for the spline.

Draws a Cardinal spline (cubic) defined by a point collection. The cardinal spline passes through each point in the collection.

Draws a closed Cardinal spline (cubic) defined by a point collection. The cardinal spline passes through each point in the collection.

The interpolation method.

The nearest neighbor algorithm simply selects the color of the nearest pixel.

Linear interpolation in 2D using the average of 3 neighboring pixels.

The mode for flipping.

Flips the image vertical (around the center of the y-axis).

Flips the image horizontal (around the center of the x-axis).

Creates a new cropped WriteableBitmap.

The WriteableBitmap. The x coordinate of the rectangle that defines the crop region. The y coordinate of the rectangle that defines the crop region. The width of the rectangle that defines the crop region. The height of the rectangle that defines the crop region. A new WriteableBitmap that is a cropped version of the input.

Creates a new cropped WriteableBitmap.

The WriteableBitmap. The rectangle that defines the crop region. A new WriteableBitmap that is a cropped version of the input.

Creates a new resized WriteableBitmap.

The WriteableBitmap. The new desired width. The new desired height. The interpolation method that should be used. A new WriteableBitmap that is a resized version of the input.

Creates a new resized bitmap.

The source context. The width of the source pixels. The height of the source pixels. The new desired width. The new desired height. The interpolation method that should be used. A new bitmap that is a resized version of the input.

Creates a new resized bitmap.

The source pixels. The width of the source pixels. The height of the source pixels. The new desired width. The new desired height. The interpolation method that should be used. A new bitmap that is a resized version of the input.

Rotates the bitmap in 90° steps clockwise and returns a new rotated WriteableBitmap.

The WriteableBitmap. The angle in degress the bitmap should be rotated in 90° steps clockwise. A new WriteableBitmap that is a rotated version of the input.

Rotates the bitmap in any degree returns a new rotated WriteableBitmap.

The WriteableBitmap. Arbitrary angle in 360 Degrees (positive = clockwise). if true: keep the size, false: adjust canvas to new size A new WriteableBitmap that is a rotated version of the input.

Flips (reflects the image) eiter vertical or horizontal.

The WriteableBitmap. The flip mode. A new WriteableBitmap that is a flipped version of the input.

Read Write Mode for the BitmapContext.

On Dispose of a BitmapContext, do not Invalidate

On Dispose of a BitmapContext, invalidate the bitmap

A disposable cross-platform wrapper around a WriteableBitmap, allowing a common API for Silverlight + WPF with locking + unlocking if necessary

Attempting to put as many preprocessor hacks in this file, to keep the rest of the codebase relatively clean

The Bitmap

Width of the bitmap

Height of the bitmap

Creates an instance of a BitmapContext, with default mode = ReadWrite

Creates an instance of a BitmapContext, with specified ReadWriteMode

The pixels as ARGB integer values, where each channel is 8 bit.

The number of pixels.

Performs a Copy operation from source Bto destination BitmapContext

Equivalent to calling Buffer.BlockCopy in Silverlight, or native memcpy in WPF

Performs a Copy operation from source BitmapContext to destination Array

Equivalent to calling Buffer.BlockCopy in Silverlight, or native memcpy in WPF

Performs a Copy operation from source BitmapContext to destination Array

Equivalent to calling Buffer.BlockCopy in Silverlight, or native memcpy in WPF

Performs a Copy operation from source Array to destination BitmapContext

Equivalent to calling Buffer.BlockCopy in Silverlight, or native memcpy in WPF

Performs a Copy operation from source Array to destination BitmapContext

Equivalent to calling Buffer.BlockCopy in Silverlight, or native memcpy in WPF

Clears the BitmapContext, filling the underlying bitmap with zeros

Disposes the BitmapContext, unlocking it and invalidating if WPF

Cross-platform factory for WriteableBitmaps

Creates a new WriteableBitmap of the specified width and height

For WPF the default DPI is 96x96 and PixelFormat is Pbgra32

Converts the input BitmapSource to the Pbgra32 format WriteableBitmap which is internally used by the WriteableBitmapEx.

The source bitmap.

Provides the WriteableBitmap context pixel data

Gets a BitmapContext within which to perform nested IO operations on the bitmap

For WPF the BitmapContext will lock the bitmap. Call Dispose on the context to unlock

Gets a BitmapContext within which to perform nested IO operations on the bitmap

For WPF the BitmapContext will lock the bitmap. Call Dispose on the context to unlock The bitmap. The ReadWriteMode. If set to ReadOnly, the bitmap will not be invalidated on dispose of the context, else it will

Returns a pointer to the first element of the specified instance.

The instance. A pointer to the first element of v.

Returns a pointer to the first element of the specified instance.

The instance. A pointer to the first element of v.