Merge pull request #298 from aspose-pdf/examples/3c85dbb5-working-with-images

Add 70 new working-with-images code examples

Author: fahadadeel

working-with-images/add-background-image-opacity-to-pdf-pages.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using Aspose.Pdf;               // Core API
+using Aspose.Pdf.Facades;      // For any facade usage if needed (not used here)
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPath  = "input.pdf";
+        const string outputPath = "output_with_background.pdf";
+        const string imagePath  = "background.png";   // Path to the background image
+
+        if (!File.Exists(inputPath))
+        {
+            Console.Error.WriteLine($"Input PDF not found: {inputPath}");
+            return;
+        }
+
+        if (!File.Exists(imagePath))
+        {
+            Console.Error.WriteLine($"Background image not found: {imagePath}");
+            return;
+        }
+
+        // Load the existing PDF document (using the lifecycle rule for disposal)
+        using (Document doc = new Document(inputPath))
+        {
+            // Iterate pages using 1‑based indexing (global rule)
+            for (int i = 1; i <= doc.Pages.Count; i++)
+            {
+                Page page = doc.Pages[i];
+
+                // Create a background artifact, set the image and opacity (30 %)
+                BackgroundArtifact bgArtifact = new BackgroundArtifact();
+                bgArtifact.SetImage(imagePath);   // Load image from file
+                bgArtifact.Opacity = 0.3;         // 30 % opacity (range 0..1)
+                bgArtifact.IsBackground = true;  // Ensure it is placed behind page content
+
+                // Add the artifact to the page
+                page.Artifacts.Add(bgArtifact);
+            }
+
+            // Save the modified PDF (using the lifecycle rule)
+            doc.Save(outputPath);
+        }
+
+        Console.WriteLine($"PDF saved with background image to '{outputPath}'.");
+    }
+}

working-with-images/add-background-image-to-pdf.cs

@@ -0,0 +1,56 @@
+using System;
+using System.IO;
+using Aspose.Pdf;
+using Aspose.Pdf.Facades; // for potential future extensions
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPdf  = "input.pdf";
+        const string outputPdf = "output_with_background.pdf";
+        const string bgImagePath = "background.png";
+
+        if (!File.Exists(inputPdf))
+        {
+            Console.Error.WriteLine($"Input PDF not found: {inputPdf}");
+            return;
+        }
+        if (!File.Exists(bgImagePath))
+        {
+            Console.Error.WriteLine($"Background image not found: {bgImagePath}");
+            return;
+        }
+
+        // Load the existing PDF document
+        using (Document doc = new Document(inputPdf))
+        {
+            // Iterate over all pages to add the background image
+            foreach (Page page in doc.Pages)
+            {
+                // Create a BackgroundArtifact – this places content behind page elements
+                BackgroundArtifact bgArtifact = new BackgroundArtifact
+                {
+                    IsBackground = true,          // ensure it is rendered behind page content
+                    Opacity = 0.5f               // subtle shading; blend mode "multiply" is not directly exposed
+                };
+
+                // Load the image into the artifact
+                bgArtifact.SetImage(bgImagePath);
+
+                // Optionally position the artifact (full‑page coverage)
+                // If Position is not set, the artifact will fill the page automatically.
+                // For explicit positioning you could use:
+                // bgArtifact.Position = new Aspose.Pdf.Rectangle(0, 0, page.PageInfo.Width, page.PageInfo.Height);
+
+                // Add the artifact to the page
+                page.Artifacts.Add(bgArtifact);
+            }
+
+            // Save the modified PDF
+            doc.Save(outputPdf);
+        }
+
+        Console.WriteLine($"PDF saved with background image: {outputPdf}");
+    }
+}

working-with-images/add-background-pattern-image-to-pdf-pages.cs

@@ -0,0 +1,53 @@
+using System;
+using System.IO;
+using Aspose.Pdf;
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPdf  = "input.pdf";          // source PDF
+        const string outputPdf = "output_with_bg.pdf"; // result PDF
+        const string patternImg = "pattern.png";       // background pattern image
+
+        if (!File.Exists(inputPdf))
+        {
+            Console.Error.WriteLine($"Input file not found: {inputPdf}");
+            return;
+        }
+
+        if (!File.Exists(patternImg))
+        {
+            Console.Error.WriteLine($"Pattern image not found: {patternImg}");
+            return;
+        }
+
+        // Load the PDF document
+        using (Document doc = new Document(inputPdf))
+        {
+            // Iterate over all pages (1‑based indexing)
+            foreach (Page page in doc.Pages)
+            {
+                // Create a background artifact
+                BackgroundArtifact bgArtifact = new BackgroundArtifact();
+
+                // Set the image for the artifact (path to the pattern file)
+                bgArtifact.SetImage(patternImg);
+
+                // Set opacity to 10 percent (range 0..1)
+                bgArtifact.Opacity = 0.1;
+
+                // Ensure the artifact is placed behind page contents
+                bgArtifact.IsBackground = true;
+
+                // Add the artifact to the page
+                page.Artifacts.Add(bgArtifact);
+            }
+
+            // Save the modified PDF
+            doc.Save(outputPdf);
+        }
+
+        Console.WriteLine($"PDF saved with background pattern: {outputPdf}");
+    }
+}

working-with-images/add-background-pattern-to-pdf-pages.cs

@@ -0,0 +1,43 @@
+using System;
+using System.IO;
+using Aspose.Pdf;
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPath  = "input.pdf";
+        const string outputPath = "output.pdf";
+        const string patternPath = "pattern.png";
+
+        if (!File.Exists(inputPath) || !File.Exists(patternPath))
+        {
+            Console.Error.WriteLine("Input PDF or pattern image not found.");
+            return;
+        }
+
+        // Load the PDF document (using rule: document-disposal-with-using)
+        using (Document doc = new Document(inputPath))
+        {
+            // Pages are 1‑based (rule: page-indexing-one-based)
+            for (int i = 1; i <= doc.Pages.Count; i++)
+            {
+                Page page = doc.Pages[i];
+
+                // Create a background artifact, set the image and opacity
+                BackgroundArtifact bg = new BackgroundArtifact();
+                bg.SetImage(patternPath);   // load image from file
+                bg.Opacity = 0.05;          // 5 percent opacity
+                bg.IsBackground = true;    // place behind page contents
+
+                // Add the artifact to the page
+                page.Artifacts.Add(bg);
+            }
+
+            // Save the modified PDF (rule: document-disposal-with-using)
+            doc.Save(outputPath);
+        }
+
+        Console.WriteLine($"Background pattern applied and saved to '{outputPath}'.");
+    }
+}

working-with-images/add-company-logo-to-first-page.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using Aspose.Pdf;               // Core API for Document, Page, ImageStamp
+using Aspose.Pdf.Facades;      // For ImageStamp (if needed, otherwise core namespace suffices)
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPdf  = "input.pdf";   // source PDF
+        const string outputPdf = "output.pdf";  // result PDF
+        const string logoPath  = "logo.png";    // company logo image
+
+        // Verify files exist
+        if (!File.Exists(inputPdf))
+        {
+            Console.Error.WriteLine($"Input PDF not found: {inputPdf}");
+            return;
+        }
+        if (!File.Exists(logoPath))
+        {
+            Console.Error.WriteLine($"Logo image not found: {logoPath}");
+            return;
+        }
+
+        // Load the PDF document (lifecycle rule: use using for deterministic disposal)
+        using (Document pdfDoc = new Document(inputPdf))
+        {
+            // Create an ImageStamp for the logo
+            ImageStamp logoStamp = new ImageStamp(logoPath)
+            {
+                // Center the stamp horizontally and vertically on the page
+                HorizontalAlignment = HorizontalAlignment.Center,
+                VerticalAlignment   = VerticalAlignment.Center,
+
+                // Optional visual settings
+                Background = false,   // place over page content
+                Opacity    = 1.0f     // fully opaque
+            };
+
+            // Add the stamp only to the first page (pages are 1‑based)
+            pdfDoc.Pages[1].AddStamp(logoStamp);
+
+            // Save the modified PDF (lifecycle rule: save inside using block)
+            pdfDoc.Save(outputPdf);
+        }
+
+        Console.WriteLine($"Logo added to first page and saved as '{outputPdf}'.");
+    }
+}

working-with-images/add-decorative-footer-image-to-pdf-pages.cs

@@ -0,0 +1,55 @@
+using System;
+using System.IO;
+using Aspose.Pdf;
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPath  = "input.pdf";          // source PDF
+        const string outputPath = "output_footer.pdf";  // result PDF
+        const string footerImgPath = "footer.png";      // decorative footer image
+
+        if (!File.Exists(inputPath))
+        {
+            Console.Error.WriteLine($"Input file not found: {inputPath}");
+            return;
+        }
+
+        if (!File.Exists(footerImgPath))
+        {
+            Console.Error.WriteLine($"Footer image not found: {footerImgPath}");
+            return;
+        }
+
+        // Load the PDF document (using rule: create/load with using)
+        using (Document doc = new Document(inputPath))
+        {
+            // Iterate through all pages (1‑based indexing)
+            foreach (Page page in doc.Pages)
+            {
+                // Ensure a Footer object exists for the page
+                if (page.Footer == null)
+                    page.Footer = new HeaderFooter();
+
+                // Create an Image object for the footer
+                Image footerImage = new Image
+                {
+                    File = footerImgPath,
+                    // Scale the image proportionally to 80% of the page width
+                    FixWidth = page.PageInfo.Width * 0.8,
+                    FixHeight = 0,                     // 0 preserves aspect ratio
+                    HorizontalAlignment = HorizontalAlignment.Center
+                };
+
+                // Add the image to the footer's paragraph collection
+                page.Footer.Paragraphs.Add(footerImage);
+            }
+
+            // Save the modified PDF (using rule: save within using block)
+            doc.Save(outputPath);
+        }
+
+        Console.WriteLine($"Footer image added to each page. Saved as '{outputPath}'.");
+    }
+}

working-with-images/add-diagonal-image-watermark-to-pdf.cs

@@ -0,0 +1,51 @@
+using System;
+using System.IO;
+using Aspose.Pdf;               // Core PDF API
+using Aspose.Pdf.Facades;      // For ImageStamp (inherits from Stamp)
+
+class Program
+{
+    static void Main()
+    {
+        const string inputPath  = "input.pdf";          // source PDF
+        const string watermarkPath = "watermark.png";   // image to use as watermark
+        const string outputPath = "watermarked.pdf";    // result PDF
+
+        if (!File.Exists(inputPath))
+        {
+            Console.Error.WriteLine($"Input file not found: {inputPath}");
+            return;
+        }
+
+        if (!File.Exists(watermarkPath))
+        {
+            Console.Error.WriteLine($"Watermark image not found: {watermarkPath}");
+            return;
+        }
+
+        // Load the PDF document (create/load rule)
+        using (Document doc = new Document(inputPath))
+        {
+            // Create an image stamp with the watermark image
+            ImageStamp imgStamp = new ImageStamp(watermarkPath);
+
+            // Set arbitrary rotation angle (45 degrees) for diagonal placement
+            imgStamp.RotateAngle = 45;          // Stamp.RotateAngle property
+
+            // Optional: make the watermark semi‑transparent and place it over content
+            imgStamp.Background = false;       // false = overlay (on top of page content)
+            imgStamp.Opacity    = 0.5;          // 0..1 range
+
+            // Apply the stamp to every page in the document
+            foreach (Page page in doc.Pages)
+            {
+                page.AddStamp(imgStamp);        // Page.AddStamp method
+            }
+
+            // Save the modified PDF (save rule)
+            doc.Save(outputPath);
+        }
+
+        Console.WriteLine($"Watermarked PDF saved to '{outputPath}'.");
+    }
+}