Recortar y redimensionar EPS

Solución API nativa de C++ para gestionar el tamaño de imágenes EPS.

¡Transformar su imagen EPS ahora es más fácil! Con Aspose.Page para C++ puede recortar o cambiar el tamaño de los archivos EPS a sus especificaciones exactas en unas pocas líneas de código. ¿Quiere hacerlo más grande? No hay problema. ¿Lo necesita más pequeño? Lo tenemos cubierto. Nuestra API para C++ le permite escalar su imagen con precisión, asegurando que se adapte a su visión como un guante. Pero, ¿por qué querría recortar o redimensionar una imagen EPS?

Si está diseñando un diseño para un documento impreso o digital, es posible que deba redimensionar la imagen EPS para que encaje dentro de dimensiones específicas.
Al reducir el tamaño de la imagen, puede disminuir el tamaño del archivo, lo que facilita compartirlo, subirlo o imprimirlo. Los archivos de imagen más pequeños también se cargan más rápido en sitios web y en documentos digitales, mejorando la experiencia del usuario.
El recorte puede ayudar a eliminar partes de la imagen que distraen o que son irrelevantes, enfocando la atención en los elementos clave, y también puede cambiar la relación de aspecto de la imagen para que se adapte mejor a las necesidades de su diseño. Así que un recorte cuidadoso puede mejorar la composición general y el atractivo visual de la imagen.
Recortar y redimensionar puede ayudar a optimizar la imagen para su uso en la web, asegurando que se cargue rápidamente y se vea bien en diferentes tamaños de pantalla.

Aspose.Page le proporciona la funcionalidad para administrar los bordes de los archivos EPS fácilmente. Con esta API, puede escalar o recortar imágenes utilizando C#. Para obtener más información sobre cómo lidiar con archivos EPS , siga la documentación. Para ver la versión en vivo de la funcionalidad, pruebe las aplicaciones multiplataforma EPS Crop y EPS Resize .

Para utilizar la funcionalidad, primero necesita obtener la solución:

Abra el administrador de paquetes NuGet, busque Aspose.Page e instálelo. También puede utilizar el siguiente comando desde la Consola del Administrador de Paquetes.

Package Manager Console Command

    PM> Install-Package Aspose.Page

Pasos para cambiar el tamaño de la imagen EPS.

El siguiente ejemplo muestra el proceso de redimensionar .eps con las unidades elegidas: puntos (points). El orden es:

Inicialice el objeto PsDocument con un flujo de entrada que contenga un archivo EPS.
Defina el tamaño existente de la imagen utilizando el método estático ExtractEpsSize() .
Cree un flujo de salida para el archivo EPS resultante.
Redimensione el objeto PsDocument con un nuevo tamaño en puntos con el método estático ResizeEps() .
Guarde el archivo EPS redimensionado.

Redimensionar EPS    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithEPS();
    
    //Create an input stream for EPS file
    {
        System::SharedPtr<System::IO::Stream> inputEpsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"input.eps", System::IO::FileMode::Open, System::IO::FileAccess::Read);
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_1({ inputEpsStream});
        // ------------------------------------------
        
        try
        {
            //Initialize PsDocument object with input stream
            System::SharedPtr<PsDocument> doc = System::MakeObject<PsDocument>(inputEpsStream);
            
            //Get size of EPS image
            System::Drawing::Size oldSize = doc->ExtractEpsSize();
            
            //Create an output stream for resized EPS
            {
                System::SharedPtr<System::IO::Stream> outputEpsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"output/" + u"output_resize_points.eps", System::IO::FileMode::Create, System::IO::FileAccess::Write);
                // Clearing resources under 'using' statement
                System::Details::DisposeGuard<1> __dispose_guard_0({ outputEpsStream});
                // ------------------------------------------
                
                try
                {
                    //Increase EPS size in 2 times and save to the output stream
                    doc->ResizeEps(outputEpsStream, System::Drawing::SizeF(static_cast<float>(oldSize.get_Width() * 2), static_cast<float>(oldSize.get_Height() * 2)), Aspose::Page::Units::Points);
                }
                catch(...)
                {
                    __dispose_guard_0.SetCurrentException(std::current_exception());
                }
            }
        }
        catch(...)
        {
            __dispose_guard_1.SetCurrentException(std::current_exception());
        }
    }

El siguiente ejemplo muestra el proceso de recorte en lugar de redimensionar .eps con las unidades elegidas: puntos. El orden es:

Inicialice el objeto PsDocument con un flujo de entrada que contenga un archivo EPS.
Defina el cuadro delimitador (bounding box) existente de la imagen utilizando el método estático ExtractEpsBoundingBox() .
Cree un flujo de salida para el archivo EPS resultante.
Recorte el objeto PsDocument con un nuevo cuadro delimitador con el método estático CropEps() .
Guarde el archivo EPS recortado.

Recortar EPS    // The path to the documents directory.
    System::String dataDir = RunExamples::GetDataDir_WorkingWithEPS();
    
    //Create an input stream for EPS file
    {
        System::SharedPtr<System::IO::Stream> inputEpsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"input.eps", System::IO::FileMode::Open, System::IO::FileAccess::Read);
        // Clearing resources under 'using' statement
        System::Details::DisposeGuard<1> __dispose_guard_1({ inputEpsStream});
        // ------------------------------------------
        
        try
        {
            //Initialize PsDocument object with input stream
            System::SharedPtr<PsDocument> doc = System::MakeObject<PsDocument>(inputEpsStream);
            
            //Get initial bounding box of EPS image
            System::ArrayPtr<int32_t> initialBoundingBox = doc->ExtractEpsBoundingBox();
            
            //Create an output stream for resized EPS
            {
                System::SharedPtr<System::IO::Stream> outputEpsStream = System::MakeObject<System::IO::FileStream>(dataDir + u"output/" + u"output_crop.eps", System::IO::FileMode::Create, System::IO::FileAccess::Write);
                // Clearing resources under 'using' statement
                System::Details::DisposeGuard<1> __dispose_guard_0({ outputEpsStream});
                // ------------------------------------------
                
                try
                {
                    //Create new bounding box
                    //Bounding box is represented by 4 numbers: x0, y0, x, y, where x0 - left margin, y0 - top margin, x - (x0 + width), y - (y0 + height)
                    System::ArrayPtr<float> newBoundingBox = System::MakeArray<float>({260, 300, 480, 432});
                    
                    //Crop EPS image and save to the output stream                    
                    //Croping of image is changing of its bounding box so that new values of bounding box will be within initial bounding box, that is
                    //initialBoundingBox[0] <= newBoundingBox[0] <= initialBoundingBox[2]
                    //initialBoundingBox[1] <= newBoundingBox[1] <= initialBoundingBox[3]
                    //initialBoundingBox[0] <= newBoundingBox[2] <= initialBoundingBox[2]
                    //initialBoundingBox[1] <= newBoundingBox[3] <= initialBoundingBox[3]
                    doc->CropEps(outputEpsStream, newBoundingBox);
                }
                catch(...)
                {
                    __dispose_guard_0.SetCurrentException(std::current_exception());
                }
            }
        }
        catch(...)
        {
            __dispose_guard_1.SetCurrentException(std::current_exception());
        }
    }

EPS Qué es EPS Formato de archivo

EPS (Encapsulated PostScript) es un formato basado en PostScript que describe una sola página. Ideal para gráficos vectoriales y combinaciones vector‑raster. Tras importarlo el archivo no es editable; se recomienda convertirlo a un formato editable como SVG o PDF.