Gerenciar Quadros de Imagem em Apresentações usando C++

Introdução

Um quadro de imagem é uma forma que contém uma imagem — é como uma foto dentro de uma moldura.

Você pode adicionar uma imagem a um slide por meio de um quadro de imagem. Dessa forma, você formata a imagem formatando o quadro de imagem.

Criar um Quadro de Imagem

  1. Crie uma instância da classe Presentation.
  2. Obtenha a referência de um slide através do seu índice.
  3. Crie um objeto IPPImage adicionando uma imagem à IImagescollection associada ao objeto de apresentação que será usado para preencher a forma.
  4. Especifique a largura e a altura da imagem.
  5. Crie um PictureFrame baseado na largura e altura da imagem através do método AddPictureFrame exposto pelo objeto de forma associado ao slide referenciado.
  6. Adicione um quadro de imagem (contendo a foto) ao slide.
  7. Grave a apresentação modificada como um arquivo PPTX.

Este código C++ mostra como criar um quadro de imagem:

// O caminho para o diretório de documentos.
const String outPath = u"../out/PictureFrameFormatting_out.pptx";
const String filePath = u"../templates/Tulips.jpg";

// Carrega a apresentação desejada
SharedPtr<Presentation> pres = MakeObject<Presentation>();

// Acessa o primeiro slide
SharedPtr<ISlide> slide = pres->get_Slide(0);

// Carrega a imagem que será adicionada à coleção de imagens da apresentação
// Obtém a imagem
auto image = Images::FromFile(filePath);

// Adiciona uma imagem à coleção de imagens da apresentação
SharedPtr<IPPImage> imgx = pres->get_Images()->AddImage(image);

// Adiciona um quadro de imagem ao slide
SharedPtr<IPictureFrame> pf = slide->get_Shapes()->AddPictureFrame(ShapeType::Rectangle, 50, 50, 100, 100, imgx);

// Define a largura e altura da escala relativa
pf->set_RelativeScaleHeight(0.8);
pf->set_RelativeScaleWidth(1.35);
// Aplica alguma formatação ao Quadro de Imagem
pf->get_LineFormat()->get_FillFormat()->set_FillType(FillType::Solid);
pf->get_LineFormat()->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Blue());
pf->get_LineFormat()->set_Width ( 20);
pf->set_Rotation( 45);

// Grava o arquivo PPTX no disco
pres->Save(outPath, Aspose::Slides::Export::SaveFormat::Pptx);

Criar um Quadro de Imagem com Escala Relativa

Alterando a escala relativa de uma imagem, você pode criar um quadro de imagem mais complexo.

  1. Crie uma instância da classe Presentation.
  2. Obtenha a referência de um slide através do seu índice.
  3. Adicione uma imagem à coleção de imagens da apresentação.
  4. Crie um objeto IPPImage adicionando uma imagem à IImagescollection associada ao objeto de apresentação que será usado para preencher a forma.
  5. Especifique a largura e altura relativas da imagem no quadro de imagem.
  6. Grave a apresentação modificada como um arquivo PPTX.

Este código C++ mostra como criar um quadro de imagem com escala relativa:

// O caminho para o diretório de documentos.
const String outPath = u"../out/AddRelativeScaleHeightPictureFrame_out.pptx";
const String filePath = u"../templates/Tulips.jpg";

// Carrega a apresentação desejada
SharedPtr<Presentation> pres = MakeObject<Presentation>();

// Acessa o primeiro slide
SharedPtr<ISlide> slide = pres->get_Slide(0);

// Carrega a imagem a ser adicionada à coleção de imagens da apresentação
// Obtém a imagem
auto image = Images::FromFile(filePath);

// Adiciona uma imagem à coleção de imagens da apresentação
SharedPtr<IPPImage> imgx = pres->get_Images()->AddImage(image);

// Adiciona um quadro de imagem ao slide
SharedPtr<IPictureFrame> pf = slide->get_Shapes()->AddPictureFrame(ShapeType::Rectangle, 50, 50, 100, 100, imgx);

// Define a largura e altura da escala relativa
pf->set_RelativeScaleHeight (0.8);
pf->set_RelativeScaleWidth(1.35);

// Grava o arquivo PPTX no disco
pres->Save(outPath, Aspose::Slides::Export::SaveFormat::Pptx);

Extrair Imagens Rasterizadas de Quadros de Imagem

Você pode extrair imagens rasterizadas de objetos PictureFrame e salvá-las em PNG, JPG e outros formatos. O exemplo de código abaixo demonstra como extrair uma imagem do documento “sample.pptx” e salvá-la no formato PNG.

auto presentation = MakeObject<Presentation>(u"sample.pptx");
auto firstSlide = presentation->get_Slide(0);
auto firstShape = firstSlide->get_Shape(0);
    
if (ObjectExt::Is<IPictureFrame>(firstShape))
{
    auto pictureFrame = ExplicitCast<IPictureFrame>(firstShape);
    auto image = pictureFrame->get_PictureFormat()->get_Picture()->get_Image()->get_SystemImage();

    image->Save(u"slide_1_shape_1.png", ImageFormat::get_Png());
}

presentation->Dispose();

Extrair Imagens SVG de Quadros de Imagem

Quando uma apresentação contém gráficos SVG colocados dentro de formas PictureFrame, o Aspose.Slides para C++ permite recuperar as imagens vetoriais originais com total fidelidade. Percorrendo a coleção de formas do slide, você pode identificar cada PictureFrame, verificar se o IPPImage subjacente contém conteúdo SVG e então salvar essa imagem no disco ou em um fluxo no formato SVG nativo.

O exemplo de código a seguir demonstra como extrair uma imagem SVG de um quadro de imagem:

auto presentation = MakeObject<Presentation>(u"sample.pptx");

auto slide = presentation->get_Slide(0);
auto shape = slide->get_Shape(0);

if (ObjectExt::Is<IPictureFrame>(shape))
{
    auto pictureFrame = ExplicitCast<IPictureFrame>(shape);
    auto svgImage = pictureFrame->get_PictureFormat()->get_Picture()->get_Image()->get_SvgImage();
    if (svgImage != nullptr)
    {
        File::WriteAllText(u"output.svg", svgImage->get_SvgContent());
    }
}

presentation->Dispose();

Obter Transparência de uma Imagem

Aspose.Slides permite obter o efeito de transparência aplicado a uma imagem. Este código C++ demonstra a operação:

auto presentation = System::MakeObject<Presentation>(u"Test.pptx");
auto pictureFrame = System::ExplicitCast<IPictureFrame>(presentation->get_Slide(0)->get_Shape(0));
auto imageTransform = pictureFrame->get_PictureFormat()->get_Picture()->get_ImageTransform();
for (auto&& effect : imageTransform)
{
    if (System::ObjectExt::Is<IAlphaModulateFixed>(effect))
    {
        float transparencyValue = 100.0f - (System::ExplicitCast<IAlphaModulateFixed>(effect))->get_Amount();
        System::Console::WriteLine(System::String(u"Picture transparency: ") + transparencyValue);
    }
}

Obter Brilho e Contraste de uma Imagem

Aspose.Slides permite obter o efeito de brilho e contraste aplicado a uma imagem. A interface ILuminance representa esse efeito de transformação de imagem.

Este código C++ demonstra como obter as configurações de brilho e contraste de um quadro de imagem:

auto presentation = System::MakeObject<Presentation>(u"sample.pptx");
auto slide = presentation->get_Slide(0);

auto shape = slide->get_Shape(0);
auto pictureFrame = System::ExplicitCast<IPictureFrame>(shape);

auto imageTransform = pictureFrame->get_PictureFormat()->get_Picture()->get_ImageTransform();
for (auto&& effect : imageTransform)
{
    if (System::ObjectExt::Is<ILuminance>(effect))
    {
        auto luminance = System::ExplicitCast<ILuminance>(effect)->GetEffective();
        auto brightness = luminance->get_Brightness();
        auto contrast = luminance->get_Contrast();

        Console::WriteLine(System::String(u"Brightness: ") + brightness);
        Console::WriteLine(System::String(u"Contrast: ") + contrast);
    }
}

presentation->Dispose();

Formatação de Quadro de Imagem

Aspose.Slides oferece muitas opções de formatação que podem ser aplicadas a um quadro de imagem. Usando essas opções, você pode alterar um quadro de imagem para que atenda a requisitos específicos.

  1. Crie uma instância da classe Presentation.
  2. Obtenha a referência de um slide através do seu índice.
  3. Crie um objeto IPPImage adicionando uma imagem à IImagescollection associada ao objeto de apresentação que será usado para preencher a forma.
  4. Especifique a largura e a altura da imagem.
  5. Crie um PictureFrame baseado na largura e altura da imagem através do método AddPictureFrame exposto pelo objeto IShapes associado ao slide referenciado.
  6. Adicione o quadro de imagem (contendo a foto) ao slide.
  7. Defina a cor da linha do quadro de imagem.
  8. Defina a espessura da linha do quadro de imagem.
  9. Gire o quadro de imagem atribuindo-lhe um valor positivo ou negativo.
    • Um valor positivo gira a imagem no sentido horário.
    • Um valor negativo gira a imagem no sentido anti-horário.
  10. Adicione o quadro de imagem (contendo a foto) ao slide.
  11. Grave a apresentação modificada como um arquivo PPTX.

Este código C++ demonstra o processo de formatação de quadro de imagem:

// O caminho para o diretório de documentos.
const String outPath = u"../out/AddRelativeScaleHeightPictureFrame_out.pptx";
const String filePath = u"../templates/Tulips.jpg";

// Carrega a apresentação desejada
SharedPtr<Presentation> pres = MakeObject<Presentation>();

// Acessa o primeiro slide
SharedPtr<ISlide> slide = pres->get_Slides()->idx_get(0);

// Carrega a imagem a ser adicionada à coleção de imagens da apresentação
// Obtém a imagem
auto image = Images::FromFile(filePath);

// Adiciona uma imagem à coleção de imagens da apresentação
SharedPtr<IPPImage> imgx = pres->get_Images()->AddImage(image);

// Adiciona um quadro de imagem ao slide
SharedPtr<IPictureFrame> pf = slide->get_Shapes()->AddPictureFrame(ShapeType::Rectangle, 50, 50, 100, 100, imgx);

// Define a largura e altura da escala relativa
pf->set_RelativeScaleHeight (0.8);
pf->set_RelativeScaleWidth(1.35);

//Grava o arquivo PPTX no disco
pres->Save(outPath, Aspose::Slides::Export::SaveFormat::Pptx);

Para evitar tamanhos grandes de apresentação, você pode adicionar imagens (ou vídeos) por meio de links em vez de incorporar os arquivos diretamente nas apresentações. Este código C++ mostra como adicionar uma imagem e um vídeo em um marcador de posição:

auto presentation = System::MakeObject<Presentation>(u"input.pptx");
auto shapesToRemove = System::MakeObject<System::Collections::Generic::List<System::SharedPtr<IShape>>>();
auto shapes = presentation->get_Slides()->idx_get(0)->get_Shapes();

for (auto& autoShape : shapes)
{
    if (autoShape->get_Placeholder() == nullptr)
        continue;

    switch (autoShape->get_Placeholder()->get_Type())
    {
        case Aspose::Slides::PlaceholderType::Picture:
        {
            auto pictureFrame = shapes->AddPictureFrame(Aspose::Slides::ShapeType::Rectangle, autoShape->get_X(), autoShape->get_Y(), autoShape->get_Width(), autoShape->get_Height(), nullptr);
            pictureFrame->get_PictureFormat()->get_Picture()->set_LinkPathLong(u"https://upload.wikimedia.org/wikipedia/commons/3/3a/I.M_at_Old_School_Public_Broadcasting_in_October_2016_02.jpg");
            shapesToRemove->Add(autoShape);
            break;
        }

        case Aspose::Slides::PlaceholderType::Media:
        {
            auto videoFrame = shapes->AddVideoFrame(autoShape->get_X(), autoShape->get_Y(), autoShape->get_Width(), autoShape->get_Height(), u"");
            videoFrame->get_PictureFormat()->get_Picture()->set_LinkPathLong(u"https://upload.wikimedia.org/wikipedia/commons/3/3a/I.M_at_Old_School_Public_Broadcasting_in_October_2016_02.jpg");
            videoFrame->set_LinkPathLong(u"https://youtu.be/t_1LYZ102RA");
            shapesToRemove->Add(autoShape);
            break;
        }
    }
}

for (auto& shape : shapesToRemove)
{
    shapes->Remove(shape);
}

presentation->Save(u"output.pptx", Aspose::Slides::Export::SaveFormat::Pptx);

Recortar Imagens

Este código C++ mostra como recortar uma imagem existente em um slide:

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System::Drawing;
    
auto presentation = System::MakeObject<Presentation>();
// Cria novo objeto de imagem
auto newImage = presentation->get_Images()->AddImage(Images::FromFile(imagePath));

// Adds a PictureFrame to a Slide
auto picFrame = presentation->get_Slides()->idx_get(0)->get_Shapes()->AddPictureFrame(Aspose::Slides::ShapeType::Rectangle, 100.0f, 100.0f, 420.0f, 250.0f, newImage);

// Crops the image (percentage values)
picFrame->get_PictureFormat()->set_CropLeft(23.6f);
picFrame->get_PictureFormat()->set_CropRight(21.5f);
picFrame->get_PictureFormat()->set_CropTop(3.0f);
picFrame->get_PictureFormat()->set_CropBottom(31.0f);

// Saves the result
presentation->Save(outPptxFile, Aspose::Slides::Export::SaveFormat::Pptx);

Excluir Áreas Recortadas de uma Imagem

Se você quiser excluir as áreas recortadas de uma imagem contida em um quadro, pode usar o método IPictureFillFormat::DeletePictureCroppedAreas(). Este método devolve a imagem recortada ou a imagem original se o recorte for desnecessário.

Este código C++ demonstra a operação:

System::SharedPtr<Presentation> presentation = System::MakeObject<Presentation>(u"PictureFrameCrop.pptx");
System::SharedPtr<ISlide> slide = presentation->get_Slide(0);

// Obtém o PictureFrame do primeiro slide
System::SharedPtr<IPictureFrame> picFrame = System::AsCast<IPictureFrame>(slide->get_Shape(0));

// Exclui áreas recortadas da imagem do PictureFrame e retorna a imagem recortada
System::SharedPtr<IPPImage> croppedImage = picFrame->get_PictureFormat()->DeletePictureCroppedAreas();

// Salva o resultado
presentation->Save(u"PictureFrameDeleteCroppedAreas.pptx", SaveFormat::Pptx);

Compactar Imagens

Você pode compactar uma imagem em uma apresentação usando o método IPictureFillFormat::CompressImage().
Ele ajusta o tamanho e a resolução da imagem de forma semelhante ao recurso Picture Format -> Compress Pictures -> Resolution do PowerPoint.

Os exemplos C++ a seguir demonstram como compactar uma imagem em uma apresentação especificando uma resolução-alvo e, opcionalmente, removendo áreas recortadas:

auto presentation = System::MakeObject<Presentation>(u"demo.pptx");
auto slide = presentation->get_Slide(0);
auto pictureFrame = System::AsCast<IPictureFrame>(slide->get_Shape(0));

// Compacta a imagem com uma resolução-alvo de 150 DPI (resolução da Web) e remove áreas recortadas.
bool result = pictureFrame->get_PictureFormat()->CompressImage(true, PicturesCompression::Dpi150);

// Verifica o resultado da compactação.
if (result)
{
    System::Console::WriteLine(u"Image successfully compressed.");
}
else
{
    System::Console::WriteLine(u"Image compression failed or no changes were necessary.");
}

presentation->Save(u"CompressedImage.pptx", SaveFormat::Pptx);
presentation->Dispose();

Ou usando diretamente um valor DPI personalizado:

auto presentation = System::MakeObject<Presentation>(u"demo.pptx");
auto slide = presentation->get_Slide(0);
auto pictureFrame = System::AsCast<IPictureFrame>(slide->get_Shape(0));

// Compacta a imagem para 150 DPI (resolução web), removendo áreas recortadas.
pictureFrame->get_PictureFormat()->CompressImage(true, 150.0f);

presentation->Save(u"CompressedImage.pptx", SaveFormat::Pptx);
presentation->Dispose();

Bloquear Proporção de Aspecto

Se você quiser que uma forma contendo uma imagem mantenha sua proporção de aspecto mesmo após alterar as dimensões da imagem, pode usar o método set_AspectRatioLocked() para definir a configuração Lock Aspect Ratio.

Este código C++ mostra como bloquear a proporção de aspecto de uma forma:

System::SharedPtr<Presentation> pres = System::MakeObject<Presentation>(u"pres.pptx");

System::SharedPtr<ILayoutSlide> layout = pres->get_LayoutSlides()->GetByType(SlideLayoutType::Custom);
System::SharedPtr<ISlide> emptySlide = pres->get_Slides()->AddEmptySlide(layout);

System::SharedPtr<IImage> image = Images::FromFile(u"image.png");
System::SharedPtr<IPPImage> presImage = pres->get_Images()->AddImage(image);

System::SharedPtr<IPictureFrame> pictureFrame = emptySlide->get_Shapes()->AddPictureFrame(ShapeType::Rectangle, 50.0f, 150.0f, static_cast<float>(presImage->get_Width()), static_cast<float>(presImage->get_Height()), presImage);

// define que a forma deve preservar a proporção ao redimensionar
pictureFrame->get_PictureFrameLock()->set_AspectRatioLocked(true);

Usar a Propriedade StretchOff

Usando as propriedades StretchOffsetLeft, StretchOffsetTop, StretchOffsetRight e StretchOffsetBottom da interface IPictureFillFormat e da classe PictureFillFormat, você pode especificar um retângulo de preenchimento.

Quando o alongamento de uma imagem é especificado, um retângulo de origem é dimensionado para caber no retângulo de preenchimento especificado. Cada borda do retângulo de preenchimento é definida por um deslocamento percentual a partir da borda correspondente da caixa delimitadora da forma. Um percentual positivo indica um recuo. Um percentual negativo indica um afastamento.

  1. Crie uma instância da classe Presentation.
  2. Obtenha a referência de um slide através do seu índice.
  3. Adicione um retângulo AutoShape.
  4. Crie uma imagem.
  5. Defina o tipo de preenchimento da forma.
  6. Defina o modo de preenchimento de imagem da forma.
  7. Adicione uma imagem definida para preencher a forma.
  8. Especifique os deslocamentos da imagem a partir da borda correspondente da caixa delimitadora da forma
  9. Grave a apresentação modificada como um arquivo PPTX.

Este código C++ demonstra um processo em que a propriedade StretchOff é usada:

auto pres = System::MakeObject<Presentation>();
auto ppImage = pres->get_Images()->AddImage(Images::FromFile(u"image.png"));
auto slide = pres->get_Slide(0);
auto pictureFrame = slide->get_Shapes()->AddPictureFrame(ShapeType::Rectangle, 10.0f, 10.0f, 400.0f, 400.0f, ppImage);

// Define a imagem esticada a partir de cada lado no corpo da forma
auto pictureFormat = pictureFrame->get_PictureFormat();
pictureFormat->set_PictureFillMode(PictureFillMode::Stretch);
pictureFormat->set_StretchOffsetLeft(24.0f);
pictureFormat->set_StretchOffsetRight(24.0f);
pictureFormat->set_StretchOffsetTop(24.0f);
pictureFormat->set_StretchOffsetBottom(24.0f);

pres->Save(u"imageStretch.pptx", SaveFormat::Pptx);

FAQ

Como posso descobrir quais formatos de imagem são suportados para PictureFrame?

Aspose.Slides suporta tanto imagens raster (PNG, JPEG, BMP, GIF, etc.) quanto imagens vetoriais (por exemplo, SVG) por meio do objeto de imagem atribuído a um PictureFrame. A lista de formatos suportados geralmente se sobrepõe às capacidades do motor de conversão de slides e imagens.

Como a adição de dezenas de imagens grandes afetará o tamanho e o desempenho do PPTX?

Incorporar imagens grandes aumenta o tamanho do arquivo e o uso de memória; vincular imagens ajuda a reduzir o tamanho da apresentação, mas exige que os arquivos externos permaneçam acessíveis. Aspose.Slides oferece a capacidade de adicionar imagens por link para reduzir o tamanho do arquivo.

Como posso bloquear um objeto de imagem para evitar movimentos/redimensionamentos acidentais?

Use shape locks para um PictureFrame (por exemplo, desabilitar mover ou redimensionar). O mecanismo de bloqueio é descrito para formas em um artigo de proteção separado e é suportado para vários tipos de forma, incluindo PictureFrame.

A fidelidade vetorial do SVG é preservada ao exportar uma apresentação para PDF/imagens?

Aspose.Slides permite extrair um SVG de um PictureFrame como o vetor original. Ao exportar para PDF ou formatos raster, o resultado pode ser rasterizado dependendo das configurações de exportação; o fato de o SVG original ser armazenado como vetor é confirmado pelo comportamento de extração.