In this article, we will learn about generating images in C# using ImageMagick.
Let’s dive in.
What is ImageMagick?
ImageMagick is a free and open-source cross-platform library for displaying, creating, converting, modifying, and editing raster images. It is a popular choice for a wide range of image-related tasks, including web development, graphic design, scientific research, medical imaging, and astronomy.
We will use this library to create an image and draw a green circle in the middle of the image.
To start, let’s navigate to the project directory on the terminal to import the ImageMagick NuGet package into our project:
dotnet add package Magick.NET-Q8-AnyCPU
This version of Magick.NET package has a Quantum Depth of 8 (Q8). Thus, it uses 8 bits per channel for color representation. This means that it uses 256 levels of color intensity for each channel (red, green, blue). AnyCPU implies this package is compiled to be compatible with both 32-bit and 64-bit systems.
We use the Magick.NET-Q8-AnyCPU NuGet package because it’s a good balance between color precision and memory usage. This is in comparison to the other Magick.NET packages: Magick.NET-Q16-AnyCPU and Magick.NET-Q16-HDRI-AnyCPU.
Creating a Blank Image
Next, let’s create a static ImageService class in which we define static methods for creating an image, drawing a circle on it, and finally saving the image to a file.
First, let’s define a method to create a blank image:
public static MagickImage CreateBlankImage(int width, int height, MagickColor color)
{
return new MagickImage(color, width, height);
}
In our CreateBlankImage() method, we create a blank image with a specified width, height, and color using the MagickImage class from the ImageMagick library. We then return the newly createdMagickImage object.
Drawing on Images in ImageMagick
Rendering a shape onto an image in ImageMagick is a two-step process. First, we need to define a Drawables object that we desire to render onto a MagickImage. Second, using the MagickImage.Draw() we render the Drawables object on the image.
Creating Our Drawables Object
So let’s first define a method to create a circle Drawables:
public static Drawables CreateCircle(
int centerX,
int centerY,
int radius,
int strokeWidth,
MagickColor strokeColor,
MagickColor fillColor)
{
if (centerX <= 0 || centerY <= 0 || radius <= 0 || strokeWidth <= 0)
{
throw new ArgumentException(
"The values for the circle's center, radius, and stroke width must be greater than zero."
);
}
var drawables = new Drawables();
drawables.StrokeColor(strokeColor);
drawables.FillColor(fillColor);
drawables.StrokeWidth(strokeWidth);
drawables.Circle(centerX, centerY, centerX, centerY - radius);
return drawables;
}
The CreateCircle() method accepts six parameters:
- X and Y coordinates of the circle’s center:
centerXandcenterY - The radius of the circle:
radius - Width of the circle’s outline:
strokeWidth - Color of the circle’s outline:
strokeColor - Interior color of the circle:
fillColor
We check and throw an ArguementException if the int parameter values are less than or equal to zero.
Next, using the Drawables class from ImageMagick, we create a drawables object. We then set the stroke color, fill color, and stroke width of our drawables object using the respective methods. Lastly, we call the Circle() method to create a circle using the provided properties. The circle’s center is set at (centerX, centerY) and the circle extends to (centerX, centerY - radius), defining its radius.
Finally, we return drawables object which represents the circle we desire to render onto a MagickImage.
Rendering Our Drawables Object
Now that we have a Drawables object representing the circle we wish to render onto our image, let’s create a new helper method to draw the circle:
public static void DrawOnImage(MagickImage image, Drawables drawables)
{
image.Draw(drawables);
}
Our DrawOnImage() method takes a MagickImage and a Drawables object as parameters.
Then we simply call the image.Draw() method with our drawables object as an argument. Draw() renders the provided drawable object onto the image.
Essentially, we modify the image by superimposing the drawable object onto it.
Saving Images in ImageMagick
We have seen how to both create and modify an image, but all of that would be in vain if we didn’t have a way to actually save the image:
public static void SaveImage(MagickImage image, string outputPath)
{
image.Write(outputPath, MagickFormat.Png);
}
Here we define our SaveImage() method. We provide both a MagickImage to save and an outputPath defining the destination for our saved image.
Next, with image.Write(outputPath, MagickFormat.png), we write the image to our specified output path, in our desired png format.
Putting It All Together
Finally, let’s bring our previously created methods into our Program class and test them out:
string outputPath = @"outputImage.png";
var image = ImageService.CreateBlankImage(480, 300, MagickColors.AliceBlue);
var strokeColor = MagickColors.YellowGreen;
var fillColor = MagickColors.Transparent;
var circle = ImageService.CreateCircle(image.Width / 2, image.Height / 2, 100, 5, strokeColor, fillColor);
ImageService.DrawOnImage(image, circle);
ImageService.SaveImage(image, outputPath);
Console.WriteLine("Image generated and saved successfully.");
First, we define the path where our generated image outputImage.png will be saved.
Next, we create a blank image with a width of 480 pixels and a height of 300 pixels. We set the fill color to MagickColors.AliceBlue using one of the predefined colors from the MagickColors class. MagickColors is a class within the ImageMagick library that provides predefined color objects.
As we prepare to draw our circle, we again use the MagickColors class to define our strokeColor as YellowGreen and our fillColor as Transparent.
Next, we call our CreateCircle() static method to generate a circle. We perform a simple calculation to place the circle at the center of our image and set the radius to 100 pixels. We set the strokeWidth at 5, and finally pass in our previously defined strokeColor and fillColor values.
With our circle created, we invoke our DrawOnImage() method to complete our image generation and modification.
Finally, we save our modified image to our earlier defined outputPath, with an affirmative message printed on the console:
Image generated and saved successfully.
Next, let’s have a look at our image:
Conclusion
In this article, we have looked at generating images in C# by using the ImageMagick library.
