Personalizar formas de presentación en C++

De qué trata esta página

Crear y personalizar formas en presentaciones de PowerPoint con Aspose.Slides para C++: rutas de geometría, esquinas curvas, formas compuestas.

Visión general

Este artículo explica cómo personalizar las formas de presentación en Aspose.Slides editando la geometría de la forma mediante puntos de edición y rutas de geometría. Muestra cómo trabajar con GeometryPath y IGeometryPath para modificar formas existentes, realizar operaciones básicas de edición de rutas, añadir o eliminar puntos y aplicar la geometría actualizada a una forma.

También demuestra cómo crear formas personalizadas y compuestas, construir formas con esquinas curvas y determinar si la geometría de una forma está cerrada.

Cambiar una forma usando puntos de edición

En PowerPoint, puedes usar Edit Points para modificar un cuadrado:

Mover una esquina hacia dentro o hacia fuera.
Ajustar la curvatura en un punto.
Añadir nuevos puntos.

Editar puntos te permite modificar el contorno de una forma o usar una forma existente como base para una nueva.

Consejos para la edición de formas

overview_image

Al editar formas de PowerPoint, ten en cuenta estos conceptos:

Una forma (o su ruta) puede ser cerrada o abierta.
La ruta de una forma está compuesta por puntos de anclaje conectados por segmentos.
Un segmento puede ser recto o curvo. Los puntos de anclaje y los manejadores de control determinan su forma.
Los puntos de anclaje pueden ser puntos de esquina, puntos rectos o puntos suaves:
- En un punto de esquina, los segmentos adyacentes pueden encontrarse en un ángulo.
- En un punto suave, los dos manejadores de control están alineados y a la misma distancia del punto de anclaje.
- En un punto recto, los dos manejadores de control están alineados pero pueden estar a diferentes distancias del punto de anclaje.
Mover los puntos de anclaje o ajustar sus manejadores cambia el contorno de la forma.

Para editar formas de PowerPoint mediante puntos de edición, Aspose.Slides proporciona la clase GeometryPath y la interfaz IGeometryPath.

Una instancia de GeometryPath representa una ruta de geometría del objeto IGeometryShape.
Para obtener el GeometryPath de la instancia IGeometryShape, puedes usar el método IGeometryShape::GetGeometryPaths.
Para establecer el GeometryPath de una forma, puedes usar estos métodos: IGeometryShape::SetGeometryPath para formas con una sola ruta y IGeometryShape::SetGeometryPaths para formas con múltiples rutas.
Para añadir segmentos, puedes usar los métodos bajo IGeometryPath.
Usando los métodos IGeometryPath::set_Stroke y IGeometryPath::set_FillMode puedes establecer la apariencia de una ruta de geometría.
Usando el método IGeometryPath::get_PathData puedes recuperar la ruta de geometría de un GeometryShape como una matriz de segmentos de ruta.

Operaciones de edición simples

Utiliza los siguientes métodos para editar una ruta de geometría. Las sobrecargas que aceptan un índice insertan un segmento en esa posición basada en cero en la matriz de segmentos de la ruta.

Operación	Método
Añadir o insertar una línea recta.	GeometryPath::LineTo
Añadir o insertar una curva Bézier cúbica con dos puntos de control y un punto final.	GeometryPath::CubicBezierTo
Añadir o insertar una curva Bézier cuadrática con un punto de control y un punto final.	GeometryPath::QuadraticBezierTo
Añadir un arco elíptico con las dimensiones y ángulos especificados en grados.	GeometryPath::ArcTo
Cerrar la figura actual conectando su punto final con su punto inicial.	GeometryPath::CloseFigure
Establecer el punto inicial de una figura.	GeometryPath::MoveTo
Eliminar un segmento en un índice basado en cero.	GeometryPath::RemoveAt

Añadir puntos personalizados a una forma

Este ejemplo inserta dos puntos en una forma rectangular usando GeometryPath::LineTo y aplica la ruta editada con IGeometryShape::SetGeometryPath. Las coordenadas son locales a la forma: ambos puntos nuevos están en su centro, a 100 puntos del lado izquierdo y 50 puntos de la parte superior. Los índices de segmento 1 y 4 los colocan en los bordes superior e inferior, tirando esos bordes hacia adentro.

#include <DOM/IAutoShape.h>
#include <DOM/IGeometryPath.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/Presentation.h>
#include <DOM/ShapeType.h>
#include <system/smart_ptr.h>

using namespace Aspose::Slides;
using namespace System;

auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto shape = slide->get_Shapes()->AddAutoShape(ShapeType::Rectangle, 100.0f, 100.0f, 200.0f, 100.0f);

auto geometryPath = shape->GetGeometryPaths()->idx_get(0);
geometryPath->LineTo(100.0f, 50.0f, 1);
geometryPath->LineTo(100.0f, 50.0f, 4);

shape->SetGeometryPath(geometryPath);

example1_image

Eliminar puntos de una forma

Este ejemplo cambia el contorno de una forma en forma de corazón eliminando el segmento en el índice basado en cero 2 con GeometryPath::RemoveAt. Aplicar la ruta modificada con IGeometryShape::SetGeometryPath actualiza el contorno de la forma.

#include <DOM/IAutoShape.h>
#include <DOM/IGeometryPath.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/Presentation.h>
#include <DOM/ShapeType.h>
#include <system/smart_ptr.h>

using namespace Aspose::Slides;
using namespace System;

auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto shape = slide->get_Shapes()->AddAutoShape(ShapeType::Heart, 100.0f, 100.0f, 300.0f, 300.0f);

auto path = shape->GetGeometryPaths()->idx_get(0);
path->RemoveAt(2);

shape->SetGeometryPath(path);

example2_image

Crear una forma personalizada

Este ejemplo construye una estrella de cinco puntas con GeometryPath. Los radios exteriores e interiores alternados de 100 y 50 puntos definen las puntas y las hendiduras; un paso de 72 grados distribuye uniformemente las cinco puntas. La ruta se cierra con GeometryPath::CloseFigure y se aplica a una forma rectangular usando IGeometryShape::SetGeometryPath, reemplazando su contorno.

#include <DOM/GeometryPath.h>
#include <DOM/IAutoShape.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/Presentation.h>
#include <DOM/ShapeType.h>
#include <drawing/point_f.h>
#include <system/collections/list.h>
#include <system/math.h>
#include <system/smart_ptr.h>

using namespace Aspose::Slides;
using namespace System;
using namespace System::Collections::Generic;
using namespace System::Drawing;

auto points = System::MakeObject<List<PointF>>();

auto outerRadius = 100.0f;
auto innerRadius = 50.0f;
auto angleStep = 72;

for (auto angle = -90; angle < 270; angle += angleStep)
{
    auto radians = angle * (Math::PI / 180.f);
    auto x = outerRadius * Math::Cos(radians);
    auto y = outerRadius * Math::Sin(radians);
    points->Add(PointF((float)x + outerRadius, (float)y + outerRadius));

    radians = Math::PI * (angle + angleStep / 2) / 180.0;
    x = innerRadius * Math::Cos(radians);
    y = innerRadius * Math::Sin(radians);
    points->Add(PointF((float)x + outerRadius, (float)y + outerRadius));
}

auto starPath = System::MakeObject<GeometryPath>();
starPath->MoveTo(points->idx_get(0));

for (auto i = 1; i < points->get_Count(); i++)
{
    starPath->LineTo(points->idx_get(i));
}

starPath->CloseFigure();

auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto shape = slide->get_Shapes()->AddAutoShape(ShapeType::Rectangle, 100.0f, 100.0f, outerRadius * 2, outerRadius * 2);
shape->SetGeometryPath(starPath);

example3_image

Crear una forma personalizada compuesta

Este ejemplo define dos objetos GeometryPath cerrados para el tercio superior e inferior de una forma. Aplicar ambas rutas con IGeometryShape::SetGeometryPaths crea una única forma compuesta con una abertura a lo largo de su tercio medio.

#include <DOM/GeometryPath.h>
#include <DOM/IAutoShape.h>
#include <DOM/IGeometryPath.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/Presentation.h>
#include <DOM/ShapeType.h>
#include <system/smart_ptr.h>

using namespace Aspose::Slides;
using namespace System;

auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto shape = slide->get_Shapes()->AddAutoShape(ShapeType::Rectangle, 100.0f, 100.0f, 200.0f, 100.0f);

auto topPath = System::MakeObject<GeometryPath>();
topPath->MoveTo(0.0f, 0.0f);
topPath->LineTo(shape->get_Width(), 0.0f);
topPath->LineTo(shape->get_Width(), shape->get_Height() / 3);
topPath->LineTo(0.0f, shape->get_Height() / 3);
topPath->CloseFigure();

auto bottomPath = System::MakeObject<GeometryPath>();
bottomPath->MoveTo(0.0f, shape->get_Height() / 3 * 2);
bottomPath->LineTo(shape->get_Width(), shape->get_Height() / 3 * 2);
bottomPath->LineTo(shape->get_Width(), shape->get_Height());
bottomPath->LineTo(0.0f, shape->get_Height());
bottomPath->CloseFigure();

auto paths = System::MakeArray<SharedPtr<IGeometryPath>>({ topPath, bottomPath });

shape->SetGeometryPaths(paths);

example4_image

Crear una forma personalizada con esquinas curvas

Este ejemplo combina segmentos rectos con GeometryPath::ArcTo para crear una forma con esquinas curvadas hacia adentro. Cada tamaño de esquina establece el ancho y la altura del arco en puntos, y el barrido de -90 grados dibuja un cuarto de elipse en sentido antihorario. La ruta completada se aplica con IGeometryShape::SetGeometryPath, y la presentación se guarda en formato PPTX.

#include <DOM/GeometryPath.h>
#include <DOM/IAutoShape.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/ISlideCollection.h>
#include <DOM/Presentation.h>
#include <DOM/ShapeType.h>
#include <Export/SaveFormat.h>
#include <drawing/point_f.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System::Drawing;

auto shapeX = 20.f;
auto shapeY = 20.f;
auto shapeWidth = 300.f;
auto shapeHeight = 200.f;

auto leftTopSize = 50.f;
auto rightTopSize = 20.f;
auto rightBottomSize = 40.f;
auto leftBottomSize = 10.f;

auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto shape = slide->get_Shapes()->AddAutoShape(ShapeType::Custom, shapeX, shapeY, shapeWidth, shapeHeight);

auto topLeft = PointF(leftTopSize, 0.0f);
auto topRight = PointF(shapeWidth - rightTopSize, 0.0f);
auto rightBottom = PointF(shapeWidth, shapeHeight - rightBottomSize);
auto bottomLeft = PointF(leftBottomSize, shapeHeight);
auto leftTop = PointF(0.0f, leftTopSize);

auto geometryPath = System::MakeObject<GeometryPath>();
geometryPath->MoveTo(topLeft);
geometryPath->LineTo(topRight);
geometryPath->ArcTo(rightTopSize, rightTopSize, 180.0f, -90.0f);
geometryPath->LineTo(rightBottom);
geometryPath->ArcTo(rightBottomSize, rightBottomSize, -90.0f, -90.0f);
geometryPath->LineTo(bottomLeft);
geometryPath->ArcTo(leftBottomSize, leftBottomSize, 0.0f, -90.0f);
geometryPath->LineTo(leftTop);
geometryPath->ArcTo(leftTopSize, leftTopSize, 90.0f, -90.0f);
geometryPath->CloseFigure();

shape->SetGeometryPath(geometryPath);

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

Descubrir si la geometría de una forma está cerrada

El siguiente asistente verifica si cada ruta de geometría no vacía termina con un segmento de cierre. Lee IGeometryPath::get_PathData y compara el IPathSegment::get_PathCommand del segmento final con PathCommandType::Close. Devuelve false cuando no hay rutas no vacías. Esto comprueba el comando final de cada ruta; no inspecciona cada subfigura dentro de una ruta. El ejemplo imprime True para un rectángulo.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/IAutoShape.h>
#include <DOM/IGeometryShape.h>
#include <DOM/IGeometryPath.h>
#include <DOM/ShapeType.h>
#include <system/array.h>
#include <system/smart_ptr.h>
#include <system/console.h>
#include <DOM/IPathSegment.h>
#include <DOM/PathCommandType.h>

using namespace Aspose::Slides;
using namespace System;

auto isGeometryClosed = [](SharedPtr<IGeometryShape> geometryShape)
{
    auto hasNonemptyPath = false;
    for (auto&& geometryPath : geometryShape->GetGeometryPaths())
    {
        auto segments = geometryPath->get_PathData();
        if (segments->get_Length() == 0)
        {
            continue;
        }

        hasNonemptyPath = true;
        auto lastSegment = segments->idx_get(segments->get_Length() - 1);
        if (lastSegment->get_PathCommand() != PathCommandType::Close)
        {
            return false;
        }
    }
    return hasNonemptyPath;
};

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto shape = slide->get_Shapes()->AddAutoShape(ShapeType::Rectangle, 100, 100, 200, 100);
Console::WriteLine(isGeometryClosed(shape));

Extraer e inspeccionar elementos de forma

Utiliza IGeometryShape::CreateShapeElements para inspeccionar una forma existente como elementos que contienen puntos de ruta y tipos de punto. Convierte cada IShapeElement devuelto a ShapeElement para leer las matrices devueltas por get_PathPoints y get_PathTypes. Esta representación es útil para el análisis de contornos o para pasar la geometría a herramientas de dibujo personalizadas.

El ejemplo abre una presentación, encuentra la primera forma de geometría directamente en la primera diapositiva y muestra sus segmentos de ruta. Usa una presentación que contenga una forma con segmentos rectos y curvos para ver ambos tipos de salida. No busca dentro de los grupos.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/IAutoShape.h>
#include <DOM/IGeometryShape.h>
#include <DOM/IGeometryPath.h>
#include <DOM/ShapeType.h>
#include <system/array.h>
#include <system/smart_ptr.h>
#include <system/console.h>
#include <DOM/IShapeElement.h>
#include <DOM/ShapeElement.h>

using namespace Aspose::Slides;
using namespace System;

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

SharedPtr<IGeometryShape> shape;
for (auto&& candidate : slide->get_Shapes())
{
    shape = AsCast<IGeometryShape>(candidate);
    if (shape != nullptr)
    {
        break;
    }
}
if (shape == nullptr)
{
    Console::WriteLine(u"No geometry shape found on the first slide.");
    return;
}

for (auto&& element : shape->CreateShapeElements())
{
    auto shapeElement = ExplicitCast<ShapeElement>(element);
    auto points = shapeElement->get_PathPoints();
    auto types = shapeElement->get_PathTypes();
    Console::WriteLine(u"Shape element:");

    for (auto i = 0; i < points->get_Length(); i++)
    {
        auto pointType = types[i] & 0x07; // Mantener el tipo de segmento, excluyendo banderas.
        switch (pointType)
        {
            case 0:
                Console::WriteLine(u"Start figure at {0}", points[i]);
                break;
            case 1:
                Console::WriteLine(u"Line to {0}", points[i]);
                break;
            case 3:
                Console::WriteLine(u"Cubic Bezier: controls {0}, {1}; end {2}", points[i], points[i + 1], points[i + 2]);
                i += 2; // Consumir ambos puntos de control y el punto final.
                break;
        }
        if ((types[i] & 0x80) != 0)
        {
            Console::WriteLine(u"Close subpath back to its starting point.");
        }
    }
}

Las matrices corresponden por índice: points[i] es un punto y types[i] describe su función. El tipo 0 inicia una figura, y el tipo 1 dibuja una línea desde el punto anterior al punto actual. Un segmento Bézier cúbico comienza en el punto final anterior y utiliza tres entradas consecutivas de tipo 3: dos puntos de control seguidos del nuevo punto final. El bucle consume esas tres entradas conjuntamente y verifica el punto final para el cierre.

Los tipos de punto también contienen banderas. Enmascara con 0x07 para identificar el tipo de segmento, y prueba 0x80 por separado para detectar un subtrazo cerrado. Por ejemplo, 129 (0x81) significa un punto final de línea que cierra un subtrazo, y 131 (0x83) significa un punto final Bézier que lo cierra. Comparar el valor bruto solo con 1 o 3 pasaría por alto estos casos. Otras banderas, como guión (0x10) y marcador (0x20), no cambian el tipo de segmento base.

Coordenadas y transformaciones. Los puntos se miden en puntos (1/72 de pulgada), con X aumentando hacia la derecha e Y aumentando hacia abajo. Para una forma sin agrupar, las coordenadas extraídas ya incluyen la posición devuelta por get_X y get_Y y reflejan su ancho y alto actuales. Por ejemplo, un rectángulo sin rotar en (100, 200) con tamaño 120 × 80 tiene límites de contorno (100, 200)–(220, 280). No añadas de nuevo la posición de la forma. Resta su X y Y para obtener coordenadas relativas a su marco sin rotar.

Los puntos extraídos no aplican la rotación establecida mediante set_Rotation ni los volteos horizontales y verticales. Para reproducir el contorno mostrado, aplica esas transformaciones alrededor del centro de la forma. Para formas agrupadas, también ten en cuenta el mapeo de coordenadas del grupo y sus transformaciones; no asumas que los puntos extraídos son las coordenadas finales renderizadas de la diapositiva ni apliques una traslación o escala dos veces si ya está reflejada en el marco del hijo.

Inspección versus edición. Las matrices extraídas describen el contorno; modificarlas no actualiza la forma original. Elige este enfoque cuando tu análisis o código de dibujo necesite matrices de punto/tipo. Usa GetGeometryPaths cuando necesites comandos de geometría en el sistema de coordenadas local de la forma o quieras editar su geometría. Aplica rutas editadas mediante SetGeometryPath o SetGeometryPaths.

Convertir GeometryPath a GraphicsPath

La API pública actual de Aspose.Slides para C++ no expone conversiones entre rutas de geometría y rutas gráficas. Para inspeccionar un contorno, usa los elementos de forma como se describió anteriormente. Para editar una forma, usa rutas de geometría y aplica las rutas actualizadas a la forma.

FAQ

¿Qué ocurrirá con el relleno y el contorno después de reemplazar la geometría?

El estilo permanece con la forma; solo cambia el contorno. El relleno y el contorno se aplican automáticamente a la nueva geometría.

¿Cómo rotar correctamente una forma personalizada junto con su geometría?

Utiliza el método set_Rotation de la forma; la geometría rota con la forma porque está vinculada al propio sistema de coordenadas de la forma.

¿Puedo convertir una forma personalizada a una imagen para “bloquear” el resultado?

Sí. Exporta la diapositiva o la forma requerida a un formato raster; esto simplifica el trabajo posterior con geometrías complejas.

Administrar conectores en presentaciones usando C++ Agregar elipses a presentaciones en C++