We're sorry Aspose doesn't work properply without JavaScript enabled.

Free Support Forum - aspose.com

Exporting Document Fragments as Images

Hi,


This might be a bit of a weird scenario, but is it possible to export headers and footers as images using Aspose. The case being I would like to use a sample word document as a template and then using the header/footer in there, save them as an image in a temporary location so that they can be used as watermarks or image stamps later on.

I’ve been able to extract the footers as HTML strings but when I try and use SaveFormat.Png (or any other image file) I catch an exception telling me that saving the document fragment in this format isn’t supported.

Would anyone be able to shed some light on if this is possible or not?

Many thanks!
Hi there,

Thanks for your inquiry. There is no direct way to export Header/Footer of MS Word document to image. However, you can convert header/footer to image using following workaround. Hope this helps you.

Please let us know if you have any more queries.


Document doc = new Document(MyDir + "in.docx");

HeaderFooter hf = doc.FirstSection.HeadersFooters[HeaderFooterType.HeaderPrimary];

Image image = RenderNode(hf, new ImageSaveOptions(SaveFormat.Png));

image.Save(MyDir + "Out.png");

///

/// Renders any node in a document to the path specified using the image save options.

///

public static Image RenderNode(Node node, ImageSaveOptions imageOptions)

{

// Run some argument checks.

if (node == null)

throw new ArgumentException("Node cannot be null");

// If no image options are supplied, create default options.

if (imageOptions == null)

imageOptions = new ImageSaveOptions(SaveFormat.Png);

// Store the paper color to be used on the final image and change to transparent.

// This will cause any content around the rendered node to be removed later on.

Color savePaperColor = imageOptions.PaperColor;

imageOptions.PaperColor = Color.Transparent;

// There a bug which affects the cache of a cloned node. To avoid this we instead clone the entire document including all nodes,

// find the matching node in the cloned document and render that instead.

Document doc = (Document)node.Document.Clone(true);

node = doc.GetChild(NodeType.Any, node.Document.GetChildNodes(NodeType.Any, true).IndexOf(node), true);

// Create a temporary shape to store the target node in. This shape will be rendered to retrieve

// the rendered content of the node.

Shape shape = new Shape(doc, ShapeType.TextBox);

Section parentSection = (Section)node.GetAncestor(NodeType.Section);

// Assume that the node cannot be larger than the page in size.

shape.Width = parentSection.PageSetup.PageWidth;

shape.Height = parentSection.PageSetup.PageHeight;

shape.FillColor = Color.Transparent; // We must make the shape and paper color transparent.

// Don't draw a surronding line on the shape.

shape.Stroked = false;

Node currentNode = node;

// If the node contains block level nodes then just add a copy of these nodes to the shape.

if (currentNode is InlineStory || currentNode is Story)

{

CompositeNode composite = (CompositeNode)currentNode;

foreach (Node childNode in composite.ChildNodes)

{

shape.AppendChild(childNode.Clone(true));

}

}

else

{

// Move up through the DOM until we find node which is suitable to insert into a Shape (a node with a parent can contain paragraph, tables the same as a shape).

// Each parent node is cloned on the way up so even a descendant node passed to this method can be rendered.

// Since we are working with the actual nodes of the document we need to clone the target node into the temporary shape.

while (!(currentNode.ParentNode is InlineStory || currentNode.ParentNode is Story || currentNode.ParentNode is ShapeBase || currentNode.NodeType == NodeType.Paragraph))

{

CompositeNode parent = (CompositeNode)currentNode.ParentNode.Clone(false);

currentNode = currentNode.ParentNode;

parent.AppendChild(node.Clone(true));

node = parent; // Store this new node to be inserted into the shape.

}

// Add the node to the shape.

shape.AppendChild(node.Clone(true));

}

// We must add the shape to the document tree to have it rendered.

parentSection.Body.FirstParagraph.AppendChild(shape);

// Render the shape to stream so we can take advantage of the effects of the ImageSaveOptions class.

// Retrieve the rendered image and remove the shape from the document.

MemoryStream stream = new MemoryStream();

shape.GetShapeRenderer().Save(stream, imageOptions);

shape.Remove();

Bitmap croppedImage;

// Load the image into a new bitmap.

using (Bitmap renderedImage = new Bitmap(stream))

{

// Extract the actual content of the image by cropping transparent space around

// the rendered shape.

Rectangle cropRectangle = FindBoundingBoxAroundNode(renderedImage);

croppedImage = new Bitmap(cropRectangle.Width, cropRectangle.Height);

croppedImage.SetResolution(imageOptions.Resolution, imageOptions.Resolution);

// Create the final image with the proper background color.

using (Graphics g = Graphics.FromImage(croppedImage))

{

g.Clear(savePaperColor);

g.DrawImage(renderedImage, new Rectangle(0, 0, croppedImage.Width, croppedImage.Height), cropRectangle.X, cropRectangle.Y, cropRectangle.Width, cropRectangle.Height, GraphicsUnit.Pixel);

}

}

return croppedImage;

}

///

/// Finds the minimum bounding box around non-transparent pixels in a Bitmap.

///

public static Rectangle FindBoundingBoxAroundNode(Bitmap originalBitmap)

{

Point min = new Point(int.MaxValue, int.MaxValue);

Point max = new Point(int.MinValue, int.MinValue);

for (int x = 0; x < originalBitmap.Width; ++x)

{

for (int y = 0; y < originalBitmap.Height; ++y)

{

// Note that you can speed up this part of the algorithm by using LockBits and unsafe code instead of GetPixel.

Color pixelColor = originalBitmap.GetPixel(x, y);

// For each pixel that is not transparent calculate the bounding box around it.

if (pixelColor.ToArgb() != Color.Empty.ToArgb())

{

min.X = Math.Min(x, min.X);

min.Y = Math.Min(y, min.Y);

max.X = Math.Max(x, max.X);

max.Y = Math.Max(y, max.Y);

}

}

}

// Add one pixel to the width and height to avoid clipping.

return new Rectangle(min.X, min.Y, (max.X - min.X) + 1, (max.Y - min.Y) + 1);

}

Hi Tahir,


That’s worked perfectly! Would never have come up with that on my own so thank you very much indeed, much appreciated!

Hi there,

Thanks for your feedback. Please feel
free to ask if you have any question about Aspose.Words, we will be
happy to help you.