CodecsRasterPdfInfo Structure

using Leadtools;
using Leadtools.Codecs;
using Leadtools.ImageProcessing;
using Leadtools.ImageProcessing.Color;

      
public async Task CodecsRasterPdfInfoExample()
{
   string multiPageRasterPdfFileName = @"MultiPageRasterPdf.pdf";
   string pagesPdfFileNames = "Page{0}.pdf";
   try
   {
      // Create a 4 pages PDF file
      await CreateMultiPageRasterPdfFile(multiPageRasterPdfFileName);

      // Without prior information, we will split this multi-page PDF file into
      // multiple single page PDF files with original size, resolution, bit-depth and compression
      using (RasterCodecs codecs = new RasterCodecs())
      {
         int pagesSaved = 0;

         // Get the file information
         StorageFile loadFile = await Tools.AppLocalFolder.GetFileAsync(multiPageRasterPdfFileName);
         using (CodecsImageInfo imageInfo = await codecs.GetInformationAsync(LeadStreamFactory.Create(loadFile), true, 1))
         {
            Debug.WriteLine(
               "Information: Format:\n Format: {0}\n Pages: {1}\n Bits/Pixel: {2}\n Size: {3} by {4}\n Resolution: {5} by {6}",
               imageInfo.Format, imageInfo.TotalPages, imageInfo.BitsPerPixel, imageInfo.Width, imageInfo.Height, imageInfo.XResolution, imageInfo.YResolution);
            Debug.WriteLine("-----------------------");

            // Now show the PDF specific information
            // Notice: GetInformation will return RasPdf as the format for all PDF files
            // regardless of the actual compression
            if (imageInfo.Format == RasterImageFormat.RasPdf)
            {
               Debug.WriteLine("Image is PDF, getting the specific info for each page");

               for (int i = 0; i < imageInfo.TotalPages; i++)
               {
                  int pageNumber = i + 1;

                  CodecsRasterPdfInfo pdfInfo = await codecs.GetRasterPdfInfoAsync(LeadStreamFactory.Create(loadFile), i + 1);
                  if (pageNumber == 1)
                  {
                     Debug.WriteLine(" LEAD PDF?: {0}", pdfInfo.IsLeadPdf);
                     Debug.WriteLine(" Version: {0}", pdfInfo.Version);
                  }

                  if (pdfInfo.IsLeadPdf)
                  {
                     Debug.WriteLine(
                        "Page {0} of {1} info:\n Bits/Pixel: {2}\n Size: {3} by {4}\n Resolution: {5} by {6}\n Format: {7}",
                        pageNumber, imageInfo.TotalPages, pdfInfo.BitsPerPixel, pdfInfo.Width, pdfInfo.Height, pdfInfo.XResolution, pdfInfo.YResolution, pdfInfo.Format);
                     Debug.WriteLine("-----------------------");

                     // Load this page with its original parameters
                     codecs.Options.RasterizeDocument.Load.XResolution = pdfInfo.XResolution;
                     codecs.Options.RasterizeDocument.Load.YResolution = pdfInfo.YResolution;
                     codecs.Options.Pdf.Load.DisplayDepth = pdfInfo.BitsPerPixel;

                     using (RasterImage pageImage = await codecs.LoadAsync(LeadStreamFactory.Create(loadFile), 0, CodecsLoadByteOrder.BgrOrGray, pageNumber, pageNumber))
                     {
                        Debug.WriteLine(
                           "Page {0} of {1} loaded:\n Bits/Pixel: {2}\n Size: {3} by {4}\n Resolution: {5} by {6}",
                           pageNumber, imageInfo.TotalPages, pageImage.BitsPerPixel, pageImage.Width, pageImage.Height, pageImage.XResolution, pageImage.YResolution);
                        Debug.WriteLine("-----------------------");

                        // Setup the PDF save options
                        codecs.Options.Pdf.Save.UseImageResolution = true;
                        codecs.Options.Pdf.Save.Version = pdfInfo.Version;

                        // Save this page to a separate file
                        string pagePdfFileName = string.Format(pagesPdfFileNames, pageNumber);
                        StorageFile saveFile = await Tools.AppLocalFolder.CreateFileAsync(pagePdfFileName);
                        await codecs.SaveAsync(pageImage, LeadStreamFactory.Create(saveFile), pdfInfo.Format, pdfInfo.BitsPerPixel);
                        pagesSaved++;
                     }
                  }
               }
            }
         }

         // We are done, now show the info of the generated files
         for (int i = 0; i < pagesSaved; i++)
         {
            int pageNumber = i + 1;
            string pagePdfFileName = string.Format(pagesPdfFileNames, pageNumber);

            StorageFile saveFile = await Tools.AppLocalFolder.GetFileAsync(pagePdfFileName);
            CodecsRasterPdfInfo pdfInfo = await codecs.GetRasterPdfInfoAsync(LeadStreamFactory.Create(saveFile), 1);
            Debug.WriteLine(
               "Page {0} of {1} info:\n Bits/Pixel: {2}\n Size: {3} by {4}\n Resolution: {5} by {6}\n Format: {7}",
               pageNumber, pagesSaved, pdfInfo.BitsPerPixel, pdfInfo.Width, pdfInfo.Height, pdfInfo.XResolution, pdfInfo.YResolution, pdfInfo.Format);
            Debug.WriteLine("-----------------------");
         }
      }
   }
   catch (Exception ex)
   {
      string error="";
      RasterException rasterException = RasterException.FromHResult(ex.HResult);
      if (rasterException != null)
         error = rasterException.Message;
      else
         error = ex.Message;
      Debug.WriteLine(error);
      Assert.Fail(error);
   }
}

public async Task CreateMultiPageRasterPdfFile(string pdfFileName)
{
   string sourceFile = @"Assets\Image1.cmp";

   using (RasterCodecs codecs = new RasterCodecs())
   {
      // Save to PDF v1.4
      codecs.Options.Pdf.Save.Version = CodecsRasterPdfVersion.V14;
      // Save using image resolution
      codecs.Options.Pdf.Save.UseImageResolution = true;

      // Load the source file to use for each page
      StorageFile loadFile = await Tools.AppInstallFolder.GetFileAsync(sourceFile);
      using (RasterImage pageImage = await codecs.LoadAsync(LeadStreamFactory.Create(loadFile), 0, CodecsLoadByteOrder.BgrOrGray, 1, 1))
      {
         Debug.WriteLine(
            "Original image dimension:\n Size: {0} by {1}\n Resolution: {2} by {3}",
            pageImage.Width, pageImage.Height, pageImage.XResolution, pageImage.YResolution);

         // Array of bits/pixel and compression to use when saving the pages
         int[] bitsPerPixel =
           {
              1,
              8,
              24
           };
         RasterImageFormat[] formats =
           {
              RasterImageFormat.RasPdfG4,
              RasterImageFormat.RasPdfLzw,
              RasterImageFormat.RasPdfJpeg422
           };

         int pageCount = bitsPerPixel.Length;
         StorageFile saveFile = await Tools.AppLocalFolder.CreateFileAsync(pdfFileName);
         ILeadStream stream = LeadStreamFactory.Create(saveFile);
         for (int i = 0; i < pageCount; i++)
         {
            // Append this page with given format
            Debug.WriteLine("Saving page {0} of {1} using {2} at {3}", i + 1, pageCount, bitsPerPixel[i], formats[i]);
            await codecs.SaveAsync(pageImage, stream, formats[i], bitsPerPixel[i], 1, 1, -1, CodecsSavePageMode.Append);
         }
      }

      Debug.WriteLine("-----------------------");
   }
}