diff --git a/Sources/Imaging/Microsoft.Psi.Imaging/ImageExtensions.cs b/Sources/Imaging/Microsoft.Psi.Imaging/ImageExtensions.cs
index feecf6468..142ee54ec 100644
--- a/Sources/Imaging/Microsoft.Psi.Imaging/ImageExtensions.cs
+++ b/Sources/Imaging/Microsoft.Psi.Imaging/ImageExtensions.cs
@@ -1375,6 +1375,142 @@ public static void DrawCircle(this Image image, Point p0, int radius, Color colo
             drawFormat.FormatFlags = 0;
             graphics.DrawString(str, drawFont, drawBrush, p0.X, p0.Y, drawFormat);
         }
+
+        /// <summary>
+        /// Renders text on the image at the specified pixel (p0).
+        /// </summary>
+        /// <param name="image">Image to draw on.</param>
+        /// <param name="str">Text to render.</param>
+        /// <param name="p0">Pixel coordinates for upper-left corner of the text.</param>
+        /// <param name="backgroundColor">Background color to use when drawing text.</param>
+        /// <param name="textColor">Color to use to draw the text.</param>
+        /// <param name="font">Name of font to use. Optional.</param>
+        /// <param name="fontSize">Size of font. Optional.</param>
+        public static void DrawText(this Image image, string str, Point p0, Color backgroundColor, Color textColor, string font = "Arial", float fontSize = 24.0f)
+        {
+            if (image.PixelFormat == PixelFormat.Gray_16bpp || image.PixelFormat == PixelFormat.RGBA_64bpp)
+            {
+                throw new InvalidOperationException(
+                    "Drawing on 16bpp and 64bpp images is not currently supported. " +
+                    "Convert to a supported format such as 8bpp grayscale or 24/32bpp color first.");
+            }
+
+            // If our image is 8bpp we won't be able to call Graphics.FromImage because
+            // that call doesn't support the 8bpp pixel format. See:
+            // https://docs.microsoft.com/en-us/dotnet/api/system.drawing.graphics.fromimage?view=dotnet-plat-ext-3.1
+            // for details.
+            //
+            // Additionally, there is no corresponding System pixel format for RGB 24bpp.
+            //
+            // To work around these issues, we will convert the image to 24bpp, perform the operation,
+            // and then convert back to the original format.
+            if (image.PixelFormat == PixelFormat.Gray_8bpp || image.PixelFormat == PixelFormat.RGB_24bpp)
+            {
+                int stride = 4 * ((image.Width * 3 + 3) / 2); // Rounding to nearest word boundary
+                using var tmpImage = new Image(image.Width, image.Height, stride, PixelFormat.BGR_24bpp);
+                image.CopyTo(tmpImage);
+                tmpImage.DrawText(str, p0, backgroundColor, textColor, font, fontSize);
+                image.CopyFrom(tmpImage);
+                return;
+            }
+
+            font ??= "Arial";
+            using Bitmap bm = image.ToBitmap(false);
+            using var graphics = Graphics.FromImage(bm);
+            using Font drawFont = new Font(font, fontSize);
+            using SolidBrush textBrush = new SolidBrush(textColor);
+            using SolidBrush backgroundBrush = new SolidBrush(backgroundColor);
+            using StringFormat drawFormat = new StringFormat();
+            drawFormat.FormatFlags = 0;
+
+            SizeF textSize = graphics.MeasureString(str, drawFont);
+
+            // Drawing the background before drawing the text
+            var bg = new RectangleF(p0.X, p0.Y, textSize.Width, textSize.Height);
+            graphics.FillRectangle(backgroundBrush, bg);
+            graphics.DrawString(str, drawFont, textBrush, p0.X, p0.Y, drawFormat);
+        }
+
+        /// <summary>
+        /// Fills a rectangle at the specified pixel coordinates on the image.
+        /// </summary>
+        /// <param name="image">Image to draw on.</param>
+        /// <param name="rect">Pixel coordinates for rectangle.</param>
+        /// <param name="color">Color to use for drawing.</param>
+        public static void FillRectangle(this Image image, Rectangle rect, Color color)
+        {
+            if (image.PixelFormat == PixelFormat.Gray_16bpp || image.PixelFormat == PixelFormat.RGBA_64bpp)
+            {
+                throw new InvalidOperationException(
+                    "Drawing on 16bpp and 64bpp images is not currently supported. " +
+                    "Convert to a supported format such as 8bpp grayscale or 24/32bpp color first.");
+            }
+
+            // If our image is 8bpp we won't be able to call Graphics.FromImage because
+            // that call doesn't support the 8bpp pixel format. See:
+            // https://docs.microsoft.com/en-us/dotnet/api/system.drawing.graphics.fromimage?view=dotnet-plat-ext-3.1
+            // for details.
+            //
+            // Additionally, there is no corresponding System pixel format for RGB 24bpp.
+            //
+            // To work around these issues, we will convert the image to 24bpp, perform the operation,
+            // and then convert back to the original format.
+            if (image.PixelFormat == PixelFormat.Gray_8bpp || image.PixelFormat == PixelFormat.RGB_24bpp)
+            {
+                int stride = 4 * ((image.Width * 3 + 3) / 2); // Rounding to nearest word boundary
+                using var tmpImage = new Image(image.Width, image.Height, stride, PixelFormat.BGR_24bpp);
+                image.CopyTo(tmpImage);
+                tmpImage.FillRectangle(rect, color);
+                image.CopyFrom(tmpImage);
+                return;
+            }
+
+            using Bitmap bm = image.ToBitmap(false);
+            using var graphics = Graphics.FromImage(bm);
+            using var drawingBrush = new SolidBrush(color);
+            graphics.FillRectangle(drawingBrush, rect);
+        }
+
+        /// <summary>
+        /// Fills a circle centered at the specified pixel (p0) with the specified radius.
+        /// </summary>
+        /// <param name="image">Image to draw on.</param>
+        /// <param name="p0">Pixel coordinates for center of circle.</param>
+        /// <param name="radius">Radius of the circle.</param>
+        /// <param name="color">Color to use for drawing.</param>
+        public static void FillCircle(this Image image, Point p0, int radius, Color color)
+        {
+            if (image.PixelFormat == PixelFormat.Gray_16bpp || image.PixelFormat == PixelFormat.RGBA_64bpp)
+            {
+                throw new InvalidOperationException(
+                    "Drawing on 16bpp and 64bpp images is not currently supported. " +
+                    "Convert to a supported format such as 8bpp grayscale or 24/32bpp color first.");
+            }
+
+            // If our image is 8bpp we won't be able to call Graphics.FromImage because
+            // that call doesn't support the 8bpp pixel format. See:
+            // https://docs.microsoft.com/en-us/dotnet/api/system.drawing.graphics.fromimage?view=dotnet-plat-ext-3.1
+            // for details.
+            //
+            // Additionally, there is no corresponding System pixel format for RGB 24bpp.
+            //
+            // To work around these issues, we will convert the image to 24bpp, perform the operation,
+            // and then convert back to the original format.
+            if (image.PixelFormat == PixelFormat.Gray_8bpp || image.PixelFormat == PixelFormat.RGB_24bpp)
+            {
+                int stride = 4 * ((image.Width * 3 + 3) / 2); // Rounding to nearest word boundary
+                using var tmpImage = new Image(image.Width, image.Height, stride, PixelFormat.BGR_24bpp);
+                image.CopyTo(tmpImage);
+                tmpImage.FillCircle(p0, radius, color);
+                image.CopyFrom(tmpImage);
+                return;
+            }
+
+            using Bitmap bm = image.ToBitmap(false);
+            using var graphics = Graphics.FromImage(bm);
+            using var drawingBrush = new SolidBrush(color);
+            graphics.FillEllipse(drawingBrush, p0.X - radius, p0.Y - radius, 2 * radius, 2 * radius);
+        }
     }
 
     /// <summary>
diff --git a/Sources/Imaging/Microsoft.Psi.Imaging/StreamOperators.cs b/Sources/Imaging/Microsoft.Psi.Imaging/StreamOperators.cs
index 0d96c8a36..ac7dca888 100644
--- a/Sources/Imaging/Microsoft.Psi.Imaging/StreamOperators.cs
+++ b/Sources/Imaging/Microsoft.Psi.Imaging/StreamOperators.cs
@@ -368,6 +368,77 @@ public static IProducer<Shared<Image>> DrawText(this IProducer<Shared<Image>> so
                     drawTextSharedImage.Resource.DrawText(text, p0, color, font, fontSize);
                     emitter.Post(drawTextSharedImage, envelope.OriginatingTime);
                 }, deliveryPolicy);
+        }
+
+        /// <summary>
+        /// Draws a piece of text with background over a shared image.
+        /// </summary>
+        /// <param name="source">Image to draw text on.</param>
+        /// <param name="text">Text to render.</param>
+        /// <param name="p0">Coordinates for start of text (in pixels).</param>
+        /// <param name="backgroundColor">Background color to use when drawing text.</param>
+        /// <param name="textColor">Color to use to draw the text.</param>
+        /// <param name="font">Name of font to use. Optional.</param>
+        /// <param name="fontSize">Size of font. Optional.</param>
+        /// <param name="deliveryPolicy">An optional delivery policy.</param>
+        /// <param name="sharedImageAllocator">Optional image allocator to create new shared image.</param>
+        /// <returns>Returns a producer that generates images overdrawn with text.</returns>
+        public static IProducer<Shared<Image>> DrawText(this IProducer<Shared<Image>> source, string text, Point p0, Color backgroundColor, Color textColor, string font = null, float fontSize = 24.0f, DeliveryPolicy<Shared<Image>> deliveryPolicy = null, Func<int, int, PixelFormat, Shared<Image>> sharedImageAllocator = null)
+        {
+            sharedImageAllocator ??= ImagePool.GetOrCreate;
+            return source.Process<Shared<Image>, Shared<Image>>(
+                (sharedImage, envelope, emitter) =>
+                {
+                    using var drawTextSharedImage = sharedImageAllocator(sharedImage.Resource.Width, sharedImage.Resource.Height, sharedImage.Resource.PixelFormat);
+                    drawTextSharedImage.Resource.CopyFrom(sharedImage.Resource);
+                    drawTextSharedImage.Resource.DrawText(text, p0, backgroundColor, textColor, font, fontSize);
+                    emitter.Post(drawTextSharedImage, envelope.OriginatingTime);
+                }, deliveryPolicy);
+        }
+
+        /// <summary>
+        /// Fills a rectangle over a shared image.
+        /// </summary>
+        /// <param name="source">Image to draw rectangle on.</param>
+        /// <param name="rect">Pixel coordinates for rectangle.</param>
+        /// <param name="color">Color to use when drawing the rectangle.</param>
+        /// <param name="deliveryPolicy">An optional delivery policy.</param>
+        /// <param name="sharedImageAllocator">Optional image allocator to create new shared image.</param>
+        /// <returns>Returns a producer that generates images overdrawn with a rectangle.</returns>
+        public static IProducer<Shared<Image>> FillRectangle(this IProducer<Shared<Image>> source, Rectangle rect, Color color, DeliveryPolicy<Shared<Image>> deliveryPolicy = null, Func<int, int, PixelFormat, Shared<Image>> sharedImageAllocator = null)
+        {
+            sharedImageAllocator ??= ImagePool.GetOrCreate;
+            return source.Process<Shared<Image>, Shared<Image>>(
+                (sharedImage, envelope, emitter) =>
+                {
+                    using var drawRectSharedImage = sharedImageAllocator(sharedImage.Resource.Width, sharedImage.Resource.Height, sharedImage.Resource.PixelFormat);
+                    drawRectSharedImage.Resource.CopyFrom(sharedImage.Resource);
+                    drawRectSharedImage.Resource.FillRectangle(rect, color);
+                    emitter.Post(drawRectSharedImage, envelope.OriginatingTime);
+                }, deliveryPolicy);
+        }
+
+        /// <summary>
+        /// Fills a circle over a shared image.
+        /// </summary>
+        /// <param name="source">Image to draw circle on.</param>
+        /// <param name="p0">Center of circle (in pixels).</param>
+        /// <param name="radius">Radius of circle (in pixels).</param>
+        /// <param name="color">Color to use when drawing the circle.</param>
+        /// <param name="deliveryPolicy">An optional delivery policy.</param>
+        /// <param name="sharedImageAllocator">Optional image allocator to create new shared image.</param>
+        /// <returns>Returns a producer that generates images overdrawn with a circle.</returns>
+        public static IProducer<Shared<Image>> FillCircle(this IProducer<Shared<Image>> source, Point p0, int radius, Color color, DeliveryPolicy<Shared<Image>> deliveryPolicy = null, Func<int, int, PixelFormat, Shared<Image>> sharedImageAllocator = null)
+        {
+            sharedImageAllocator ??= ImagePool.GetOrCreate;
+            return source.Process<Shared<Image>, Shared<Image>>(
+                (sharedImage, envelope, emitter) =>
+                {
+                    using var drawCircleSharedImage = sharedImageAllocator(sharedImage.Resource.Width, sharedImage.Resource.Height, sharedImage.Resource.PixelFormat);
+                    drawCircleSharedImage.Resource.CopyFrom(sharedImage.Resource);
+                    drawCircleSharedImage.Resource.FillCircle(p0, radius, color);
+                    emitter.Post(drawCircleSharedImage, envelope.OriginatingTime);
+                }, deliveryPolicy);
         }
 
         /// <summary>
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/ImageTester.cs b/Sources/Imaging/Test.Psi.Imaging.Windows/ImageTester.cs
index 7149f4c59..4a54faced 100644
--- a/Sources/Imaging/Test.Psi.Imaging.Windows/ImageTester.cs
+++ b/Sources/Imaging/Test.Psi.Imaging.Windows/ImageTester.cs
@@ -20,6 +20,9 @@ public class ImageTester
         private Image testImage_GrayDrawLine = Image.FromBitmap(Properties.Resources.TestImage_GrayDrawLine);
         private Image testImage_GrayDrawRect = Image.FromBitmap(Properties.Resources.TestImage_GrayDrawRect);
         private Image testImage_GrayDrawText = Image.FromBitmap(Properties.Resources.TestImage_GrayDrawText);
+        private Image testImage_GrayFillRect = Image.FromBitmap(Properties.Resources.TestImage_GrayFillRect);
+        private Image testImage_GrayFillCircle = Image.FromBitmap(Properties.Resources.TestImage_GrayFillCircle);
+        private Image testImage_GrayDrawTextWithBackground = Image.FromBitmap(Properties.Resources.TestImage_GrayDrawTextWithBackground);
         private Image testImage_GrayFlip = Image.FromBitmap(Properties.Resources.TestImage_GrayFlip);
         private Image testImage_GrayResized = Image.FromBitmap(Properties.Resources.TestImage_GrayResized);
         private Image testImage_GrayRotate = Image.FromBitmap(Properties.Resources.TestImage_GrayRotate);
@@ -44,6 +47,9 @@ public class ImageTester
         private Image testImage2_DrawLine = Image.FromBitmap(Properties.Resources.TestImage2_DrawLine);
         private Image testImage2_DrawCircle = Image.FromBitmap(Properties.Resources.TestImage2_DrawCircle);
         private Image testImage2_DrawText = Image.FromBitmap(Properties.Resources.TestImage2_DrawText);
+        private Image testImage2_FillRect = Image.FromBitmap(Properties.Resources.TestImage2_FillRect);
+        private Image testImage2_FillCircle = Image.FromBitmap(Properties.Resources.TestImage2_FillCircle);
+        private Image testImage2_DrawTextWithBackground = Image.FromBitmap(Properties.Resources.TestImage2_DrawTextWithBackground);
         private Image testImage2_AbsDiff = Image.FromBitmap(Properties.Resources.TestImage2_AbsDiff);
         private Image testImage_0_0_200_100 = Image.FromBitmap(Properties.Resources.TestImage_Crop_0_0_200_100);
         private Image testImage_153_57_103_199 = Image.FromBitmap(Properties.Resources.TestImage_Crop_153_57_103_199);
@@ -93,6 +99,36 @@ public void Image_GrayDrawText()
             this.AssertAreImagesEqual(this.testImage_GrayDrawText, sharedImage.Resource);
         }
 
+        [TestMethod]
+        [Timeout(60000)]
+        public void Image_GrayDrawTextWithBackground()
+        {
+            using var sharedImage = ImagePool.GetOrCreate(this.testImage_Gray.Width, this.testImage_Gray.Height, this.testImage_Gray.PixelFormat);
+            this.testImage_Gray.CopyTo(sharedImage.Resource);
+            sharedImage.Resource.DrawText("Test", new System.Drawing.Point(0, 20), System.Drawing.Color.Red, System.Drawing.Color.White);
+            this.AssertAreImagesEqual(this.testImage_GrayDrawTextWithBackground, sharedImage.Resource);
+        }
+
+        [TestMethod]
+        [Timeout(60000)]
+        public void Image_GrayFillRect()
+        {
+            using var sharedImage = ImagePool.GetOrCreate(this.testImage_Gray.Width, this.testImage_Gray.Height, this.testImage_Gray.PixelFormat);
+            this.testImage_Gray.CopyTo(sharedImage.Resource);
+            sharedImage.Resource.FillRectangle(new System.Drawing.Rectangle(0, 0, 20, 20), System.Drawing.Color.White);
+            this.AssertAreImagesEqual(this.testImage_GrayFillRect, sharedImage.Resource);
+        }
+
+        [TestMethod]
+        [Timeout(60000)]
+        public void Image_GrayFillCircle()
+        {
+            using var sharedImage = ImagePool.GetOrCreate(this.testImage_Gray.Width, this.testImage_Gray.Height, this.testImage_Gray.PixelFormat);
+            this.testImage_Gray.CopyTo(sharedImage.Resource);
+            sharedImage.Resource.FillCircle(new System.Drawing.Point(this.testImage_Gray.Width / 2, this.testImage_Gray.Height / 2), 100, System.Drawing.Color.White);
+            this.AssertAreImagesEqual(this.testImage_GrayFillCircle, sharedImage.Resource);
+        }
+
         [TestMethod]
         [Timeout(60000)]
         public void Image_GrayFlip()
@@ -529,6 +565,66 @@ public void Image_DrawTextViaOperator(PixelFormat pixelFormat)
             pipeline.Run();
         }
 
+        [TestMethod]
+        [Timeout(60000)]
+        [DataRow(PixelFormat.Gray_8bpp)]
+        [DataRow(PixelFormat.BGR_24bpp)]
+        [DataRow(PixelFormat.BGRX_32bpp)]
+        [DataRow(PixelFormat.BGRA_32bpp)]
+        [DataRow(PixelFormat.RGB_24bpp)]
+        public void Image_DrawTextWithBackgroundViaOperator(PixelFormat pixelFormat)
+        {
+            using var pipeline = Pipeline.Create("DrawTextWithBackgroundViaOperator");
+            using var sharedImage = ImagePool.GetOrCreate(this.testImage2.Width, this.testImage2.Height, pixelFormat);
+            this.testImage2.CopyTo(sharedImage.Resource);
+            Generators.Sequence(pipeline, new[] { sharedImage }, default, null, keepOpen: false).DrawText("Testing", new System.Drawing.Point(100, 100), System.Drawing.Color.Red, System.Drawing.Color.White).Do((img) =>
+            {
+                using var refImage = this.testImage2_DrawTextWithBackground.Convert(pixelFormat);
+                this.AssertAreImagesEqual(refImage, img.Resource);
+            });
+            pipeline.Run();
+        }
+
+        [TestMethod]
+        [Timeout(60000)]
+        [DataRow(PixelFormat.Gray_8bpp)]
+        [DataRow(PixelFormat.BGR_24bpp)]
+        [DataRow(PixelFormat.BGRX_32bpp)]
+        [DataRow(PixelFormat.BGRA_32bpp)]
+        [DataRow(PixelFormat.RGB_24bpp)]
+        public void Image_FillRectangleViaOperator(PixelFormat pixelFormat)
+        {
+            using var pipeline = Pipeline.Create("FillRectangleViaOperator");
+            using var sharedImage = ImagePool.GetOrCreate(this.testImage2.Width, this.testImage2.Height, pixelFormat);
+            this.testImage2.CopyTo(sharedImage.Resource);
+            Generators.Sequence(pipeline, new[] { sharedImage }, default, null, keepOpen: false).FillRectangle(new System.Drawing.Rectangle(20, 20, 255, 255), System.Drawing.Color.White).Do((img) =>
+            {
+                using var refImage = this.testImage2_FillRect.Convert(pixelFormat);
+                this.AssertAreImagesEqual(refImage, img.Resource);
+            });
+            pipeline.Run();
+        }
+
+        [TestMethod]
+        [Timeout(60000)]
+        [DataRow(PixelFormat.Gray_8bpp)]
+        [DataRow(PixelFormat.BGR_24bpp)]
+        [DataRow(PixelFormat.BGRX_32bpp)]
+        [DataRow(PixelFormat.BGRA_32bpp)]
+        [DataRow(PixelFormat.RGB_24bpp)]
+        public void Image_FillCircleViaOperator(PixelFormat pixelFormat)
+        {
+            using var pipeline = Pipeline.Create("FillCircleViaOperator");
+            using var sharedImage = ImagePool.GetOrCreate(this.testImage2.Width, this.testImage2.Height, pixelFormat);
+            this.testImage2.CopyTo(sharedImage.Resource);
+            Generators.Sequence(pipeline, new[] { sharedImage }, default, null, keepOpen: false).FillCircle(new System.Drawing.Point(250, 250), 100, System.Drawing.Color.White).Do((img) =>
+            {
+                using var refImage = this.testImage2_FillCircle.Convert(pixelFormat);
+                this.AssertAreImagesEqual(refImage, img.Resource);
+            });
+            pipeline.Run();
+        }
+
         [TestMethod]
         [Timeout(60000)]
         [DataRow(PixelFormat.Gray_8bpp)]
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.Designer.cs b/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.Designer.cs
index 447a85512..5d0332fa2 100644
--- a/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.Designer.cs
+++ b/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.Designer.cs
@@ -160,6 +160,36 @@ internal static System.Drawing.Bitmap TestImage_GrayDrawText {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap TestImage_GrayDrawTextWithBackground {
+            get {
+                object obj = ResourceManager.GetObject("TestImage_GrayDrawTextWithBackground", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap TestImage_GrayFillCircle {
+            get {
+                object obj = ResourceManager.GetObject("TestImage_GrayFillCircle", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap TestImage_GrayFillRect {
+            get {
+                object obj = ResourceManager.GetObject("TestImage_GrayFillRect", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
@@ -320,6 +350,36 @@ internal static System.Drawing.Bitmap TestImage2_DrawText {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap TestImage2_DrawTextWithBackground {
+            get {
+                object obj = ResourceManager.GetObject("TestImage2_DrawTextWithBackground", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap TestImage2_FillCircle {
+            get {
+                object obj = ResourceManager.GetObject("TestImage2_FillCircle", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized resource of type System.Drawing.Bitmap.
+        /// </summary>
+        internal static System.Drawing.Bitmap TestImage2_FillRect {
+            get {
+                object obj = ResourceManager.GetObject("TestImage2_FillRect", resourceCulture);
+                return ((System.Drawing.Bitmap)(obj));
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized resource of type System.Drawing.Bitmap.
         /// </summary>
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.resx b/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.resx
index abee9760d..5191ce539 100644
--- a/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.resx
+++ b/Sources/Imaging/Test.Psi.Imaging.Windows/Properties/Resources.resx
@@ -232,4 +232,22 @@
   <data name="TestImage_SetPixel" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\TestImage_SetPixel.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
+  <data name="TestImage2_DrawTextWithBackground" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\TestImage2_DrawTextWithBackground.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="TestImage_GrayDrawTextWithBackground" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\TestImage_GrayDrawTextWithBackground.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="TestImage_GrayFillCircle" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\TestImage_GrayFillCircle.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="TestImage_GrayFillRect" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\TestImage_GrayFillRect.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="TestImage2_FillCircle" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\TestImage2_FillCircle.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
+  <data name="TestImage2_FillRect" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\TestImage2_FillRect.bmp;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_DrawTextWithBackground.bmp b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_DrawTextWithBackground.bmp
new file mode 100644
index 000000000..e40dc01c5
Binary files /dev/null and b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_DrawTextWithBackground.bmp differ
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_FillCircle.bmp b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_FillCircle.bmp
new file mode 100644
index 000000000..b8e4a275b
Binary files /dev/null and b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_FillCircle.bmp differ
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_FillRect.bmp b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_FillRect.bmp
new file mode 100644
index 000000000..fe5cbf9f4
Binary files /dev/null and b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage2_FillRect.bmp differ
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayDrawTextWithBackground.bmp b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayDrawTextWithBackground.bmp
new file mode 100644
index 000000000..b8e21a0b1
Binary files /dev/null and b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayDrawTextWithBackground.bmp differ
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayFillCircle.bmp b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayFillCircle.bmp
new file mode 100644
index 000000000..b342b6eb9
Binary files /dev/null and b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayFillCircle.bmp differ
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayFillRect.bmp b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayFillRect.bmp
new file mode 100644
index 000000000..9ada2a3e6
Binary files /dev/null and b/Sources/Imaging/Test.Psi.Imaging.Windows/Resources/TestImage_GrayFillRect.bmp differ
diff --git a/Sources/Imaging/Test.Psi.Imaging.Windows/Test.Psi.Imaging.Windows.csproj b/Sources/Imaging/Test.Psi.Imaging.Windows/Test.Psi.Imaging.Windows.csproj
index 6c8c7b538..b3ad25e6a 100644
--- a/Sources/Imaging/Test.Psi.Imaging.Windows/Test.Psi.Imaging.Windows.csproj
+++ b/Sources/Imaging/Test.Psi.Imaging.Windows/Test.Psi.Imaging.Windows.csproj
@@ -154,6 +154,9 @@
     <Content Include="Resources\TestImage2_DrawLine.bmp" />
     <Content Include="Resources\TestImage2_DrawRect.bmp" />
     <Content Include="Resources\TestImage2_DrawText.bmp" />
+    <Content Include="Resources\TestImage2_DrawTextWithBackground.bmp" />
+    <Content Include="Resources\TestImage2_FillRect.bmp" />
+    <Content Include="Resources\TestImage2_FillCircle.bmp" />
     <Content Include="Resources\TestImage2_FlipHoriz.bmp" />
     <Content Include="Resources\TestImage2_FlipVert.bmp" />
     <Content Include="Resources\TestImage2_GreenChannel.bmp" />
@@ -170,6 +173,9 @@
     <Content Include="Resources\TestImage_GrayDrawLine.bmp" />
     <Content Include="Resources\TestImage_GrayDrawRect.bmp" />
     <Content Include="Resources\TestImage_GrayDrawText.bmp" />
+    <Content Include="Resources\TestImage_GrayDrawTextWithBackground.bmp" />
+    <Content Include="Resources\TestImage_GrayFillRect.bmp" />
+    <Content Include="Resources\TestImage_GrayFillCircle.bmp" />
     <Content Include="Resources\TestImage_GrayFlip.bmp" />
     <Content Include="Resources\TestImage_GrayResized.bmp" />
     <Content Include="Resources\TestImage_GrayRotate.bmp" />