Obtener Resolución y Dimensiones de Imágenes

El siguiente fragmento de código también funciona con la biblioteca Aspose.PDF.Drawing.

Este tema explica cómo usar las clases de operadores en el espacio de nombres Aspose.PDF que proporcionan la capacidad de obtener información sobre la resolución y dimensiones de las imágenes sin tener que extraerlas.

Hay diferentes formas de lograr esto. Este artículo explica cómo usar un arraylist y clases de colocación de imágenes.

1. Primero, cargue el archivo PDF de origen (con imágenes).
2. Luego, cree un objeto ArrayList para contener los nombres de cualquier imagen en el documento.
3. Obtenga las imágenes utilizando la propiedad Page.Resources.Images.
4. Cree un objeto de pila para mantener el estado gráfico de la imagen y úselo para hacer un seguimiento de diferentes estados de imagen.
5. Cree un objeto ConcatenateMatrix que define la transformación actual. También admite escalar, rotar y sesgar cualquier contenido. Concatena la nueva matriz con la anterior. Tenga en cuenta que no podemos definir la transformación desde cero, sino solo modificar la transformación existente.
6. Debido a que podemos modificar la matriz con ConcatenateMatrix, también puede que necesitemos volver al estado original de la imagen. Use los operadores GSave y GRestore. Estos operadores están emparejados, por lo que deben ser llamados juntos. Por ejemplo, si realiza algún trabajo gráfico con transformaciones complejas y finalmente devuelve las transformaciones al estado inicial, el enfoque será algo como esto:

// Draw some text
GSave

ConcatenateMatrix  // rotate contents after the operator

// Some graphics work

ConcatenateMatrix // scale (with previous rotation) contents after the operator

// Some other graphics work

GRestore

// Draw some text

Como resultado, el texto se dibuja en forma regular, pero se realizan algunas transformaciones entre los operadores de texto. Para mostrar la imagen o dibujar objetos de forma e imágenes, necesitamos usar el operador Do.

También tenemos una clase llamada XImage que proporciona dos propiedades, Width y Height, que se pueden usar para obtener las dimensiones de la imagen.

1. Realice algunos cálculos para computar la resolución de la imagen.
2. Muestre la información en un símbolo del sistema junto con el nombre de la imagen.

El siguiente fragmento de código le muestra cómo obtener las dimensiones y resolución de una imagen sin extraer la imagen del documento PDF.

// For complete examples and data files, visit https://github.com/aspose-pdf/Aspose.PDF-for-.NET
private static void ExtractImageInformationFromPDF()
{
    // The path to the documents directory
    var dataDir = RunExamples.GetDataDir_AsposePdf_Images();

    // Open PDF document
    using (var document = new Aspose.Pdf.Document(dataDir + "ImageInformation.pdf"))
    {
        // Define the default resolution for image
        int defaultResolution = 72;
        var graphicsState = new Stack();

        // Define list which will hold image names
        var imageNames = new List<string>(document.Pages[1].Resources.Images.Names);

        // Insert an object to stack
        graphicsState.Push(new System.Drawing.Drawing2D.Matrix(1, 0, 0, 1, 0, 0));

        // Get all the operators on first page of document
        foreach (var op in document.Pages[1].Contents)
        {
            // Use GSave/GRestore operators to revert the transformations back to previously set
            var opSaveState = op as Aspose.Pdf.Operators.GSave;
            var opRestoreState = op as Aspose.Pdf.Operators.GRestore;
            var opCtm = op as Aspose.Pdf.Operators.ConcatenateMatrix;
            var opDo = op as Aspose.Pdf.Operators.Do;

            if (opSaveState != null)
            {
                // Save previous state and push current state to the top of the stack
                graphicsState.Push(((System.Drawing.Drawing2D.Matrix)graphicsState.Peek()).Clone());
            }
            else if (opRestoreState != null)
            {
                // Throw away current state and restore previous one
                graphicsState.Pop();
            }
            else if (opCtm != null)
            {
                var cm = new System.Drawing.Drawing2D.Matrix(
                   (float)opCtm.Matrix.A,
                   (float)opCtm.Matrix.B,
                   (float)opCtm.Matrix.C,
                   (float)opCtm.Matrix.D,
                   (float)opCtm.Matrix.E,
                   (float)opCtm.Matrix.F);

                // Multiply current matrix with the state matrix
                ((System.Drawing.Drawing2D.Matrix)graphicsState.Peek()).Multiply(cm);

                continue;
            }
            else if (opDo != null)
            {
                // In case this is an image drawing operator
                if (imageNames.Contains(opDo.Name))
                {
                    var lastCTM = (System.Drawing.Drawing2D.Matrix)graphicsState.Peek();
                    // Create XImage object to hold images of first pdf page
                    var image = document.Pages[1].Resources.Images[opDo.Name];

                    // Get image dimensions
                    double scaledWidth = Math.Sqrt(Math.Pow(lastCTM.Elements[0], 2) + Math.Pow(lastCTM.Elements[1], 2));
                    double scaledHeight = Math.Sqrt(Math.Pow(lastCTM.Elements[2], 2) + Math.Pow(lastCTM.Elements[3], 2));
                    // Get Height and Width information of image
                    double originalWidth = image.Width;
                    double originalHeight = image.Height;

                    // Compute resolution based on above information
                    double resHorizontal = originalWidth * defaultResolution / scaledWidth;
                    double resVertical = originalHeight * defaultResolution / scaledHeight;

                    // Display Dimension and Resolution information of each image
                    Console.Out.WriteLine(
                            string.Format(dataDir + "image {0} ({1:.##}:{2:.##}): res {3:.##} x {4:.##}",
                                         opDo.Name, scaledWidth, scaledHeight, resHorizontal,
                                         resVertical));
                }
            }
        }
    }
}