Aggiungi Equazioni Matematiche alle Presentazioni PowerPoint in Python

Panoramica

PowerPoint memorizza le equazioni come Office Math Markup Language (OMML). Con Aspose.Slides per Python tramite .NET, è possibile creare lo stesso tipo di contenuto matematico in modo programmatico: frazioni, radici, funzioni, limiti, operatori N-ari, matrici, array e blocchi di matematica formattati.

In PowerPoint, gli utenti normalmente aggiungono le equazioni da Insert > Equation:

Scheda Insert di PowerPoint con il comando Equation selezionato

Il risultato è testo matematico modificabile nella diapositiva:

Una diapositiva PowerPoint contenente un’equazione matematica modificabile

Aspose.Slides costruisce quel testo matematico attraverso tre oggetti principali:

  • Una forma matematica, creata con add_math_shape, è la forma che contiene l’equazione.
  • MathPortion memorizza il contenuto matematico all’interno del riquadro di testo della forma.
  • MathParagraph contiene uno o più oggetti MathBlock.

La maggior parte degli esempi seguenti usa MathematicalText e i metodi fluenti di IMathElement per mantenere il codice breve e leggibile.

Per scenari di esportazione MathML, vedere Esporta equazioni matematiche dalle presentazioni in Python via .NET.

Crea un’equazione

Questo esempio utilizza add_math_shape per creare una forma matematica e aggiunge il teorema di Pitagora:

L’equazione c al quadrato uguale a a al quadrato più b al quadrato

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    equation = (
        math.MathematicalText("c")
        .set_superscript("2")
        .join("=")
        .join(math.MathematicalText("a").set_superscript("2"))
        .join("+")
        .join(math.MathematicalText("b").set_superscript("2"))
    )

    math_paragraph.add(equation)

    presentation.save("pythagorean-theorem.pptx", slides.export.SaveFormat.PPTX)

Aggiungi frazioni

Usa divide per creare una frazione. È possibile scegliere uno stile di frazione con MathFractionTypes.

Una frazione matematica inclinata che mostra 1 diviso x

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    fraction = math.MathematicalText("1").divide("x", math.MathFractionTypes.SKEWED)

    math_paragraph.add(math.MathBlock(fraction))

    presentation.save("fraction.pptx", slides.export.SaveFormat.PPTX)

Per una frazione impilata, usa MathFractionTypes.BAR:

import aspose.slides.mathtext as math

stacked_fraction = math.MathematicalText("x + 1").divide("y - 1", math.MathFractionTypes.BAR)

Aggiungi radici

Usa radical per creare una radice quadrata, radice cubica o altra radice. L’elemento corrente diventa la base e l’argomento diventa il grado.

Un’espressione radicale di radice n-esima con x sotto il segno della radice

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    radical = math.MathematicalText("x").radical("n")

    math_paragraph.add(math.MathBlock(radical))

    presentation.save("radical.pptx", slides.export.SaveFormat.PPTX)

Aggiungi funzioni e limiti

Usa as_argument_of_function o function per funzioni come sin(x), log(x), o nomi di funzioni personalizzate. Per i limiti, inserisci lim in un MathLimit o usa set_lower_limit.

Il limite di x mentre x tende all’infinito

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    limit = (
        math.MathematicalText("lim")
        .set_lower_limit("x\u2192\u221E")
        .function("x")
    )

    math_paragraph.add(math.MathBlock(limit))

    presentation.save("functions-and-limits.pptx", slides.export.SaveFormat.PPTX)

Per un nome di funzione personalizzato, rendi il nome della funzione l’elemento corrente e chiama function con il suo argomento:

import aspose.slides.mathtext as math

custom_function = math.MathematicalText("f").function("x + 1")

Aggiungi operatori N-ari e integrali

Usa nary per somme, unioni, intersezioni e altri operatori di grandi dimensioni. Usa integral per gli integrali. Entrambi i metodi consentono di impostare limiti inferiori e superiori.

Una sommatoria con limiti inferiori e superiori

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    summation_base = (
        math.MathematicalText("x")
        .set_superscript("k")
        .join(math.MathematicalText("a").set_superscript("n-k"))
    )

    summation = summation_base.nary(math.MathNaryOperatorTypes.SUMMATION, "k=0", "n")

    math_paragraph.add(math.MathBlock(summation))

    presentation.save("nary-operators.pptx", slides.export.SaveFormat.PPTX)

Gli operatori N-ari sono per operatori grandi con limiti opzionali. Operatori semplici come +, - e = sono solitamente aggiunti come MathematicalText e uniti nell’espressione.

Per un integrale, usa integral:

import aspose.slides.mathtext as math

integral_base = math.MathematicalText("x").join(math.MathematicalText("dx").to_box())
integral = integral_base.integral(math.MathIntegralTypes.SIMPLE, "0", "1")

Aggiungi matrici

Usa MathMatrix per righe e colonne. Le matrici non includono parentesi quadre per impostazione predefinita, quindi racchiudi la matrice quando sono necessarie parentesi tonde, quadre o graffe.

Una matrice matematica a due righe con una cella vuota

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    matrix = math.MathMatrix(2, 3)

    # Una matrice non ha parentesi proprie, quindi racchiudila tra parentesi tonde.
    math_paragraph.add(math.MathBlock(matrix.enclose("(", ")")))

    presentation.save("matrix.pptx", slides.export.SaveFormat.PPTX)

Aggiungi array di equazioni

Usa to_math_array quando hai bisogno di equazioni allineate o di uno stack verticale di espressioni.

Un array matematico verticale con x sopra y

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 140)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    equation_array = (
        math.MathematicalText("x")
        .join("y")
        .to_math_array()
    )

    math_paragraph.add(math.MathBlock(equation_array))

    presentation.save("equation-array.pptx", slides.export.SaveFormat.PPTX)

Allinea un array con gli elementi circostanti

IMathArray.base_justification controlla l’allineamento verticale di un array rispetto agli elementi matematici accanto. L’esempio seguente confronta l’allineamento con la prima riga, il centro dell’array e l’ultima riga.

Il seguente esempio crea tre array identici, ciascuno con tre righe e gli elementi adiacenti A= e =B. Tutto il testo matematico utilizza Cambria Math a 24 punti. Solo l’allineamento dell’array cambia.

import aspose.slides as slides
import aspose.slides.mathtext as math


def create_text(value):
    text = math.MathematicalText(value)
    text.format.font_height = 24
    text.format.latin_font = slides.FontData("Cambria Math")
    return text


with slides.Presentation() as presentation:
    presentation.slide_size.set_size(780, 200, slides.SlideSizeScaleType.DO_NOT_SCALE)
    slide = presentation.slides[0]
    alignments = [math.MathVerticalAlignment.TOP, math.MathVerticalAlignment.CENTER, math.MathVerticalAlignment.BOTTOM]
    labels = ["Top", "Center", "Bottom"]

    for i, alignment in enumerate(alignments):
        label = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, 20 + i * 260, 10, 240, 30)
        label.fill_format.fill_type = slides.FillType.NO_FILL
        label.line_format.fill_format.fill_type = slides.FillType.NO_FILL
        label.text_frame.text = labels[i]
        label_format = label.text_frame.paragraphs[0].portions[0].portion_format
        label_format.font_height = 16
        label_format.fill_format.fill_type = slides.FillType.SOLID
        label_format.fill_format.solid_fill_color.color = slides.Color.black

        math_shape = slide.shapes.add_math_shape(20 + i * 260, 60, 240, 130)
        math_shape.text_frame.text_frame_format.anchoring_type = slides.TextAnchorType.TOP
        math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph
        math_paragraph.justification = math.MathJustification.LEFT_JUSTIFIED

        rows = [create_text("x+y=3"), create_text("x-y=1"), create_text("x=2")]
        equation_array = math.MathArray(rows)
        equation_array.base_justification = alignment
        left_text = create_text("A=")
        right_text = create_text("=B")
        equation = math.MathBlock(left_text).join(equation_array).join(right_text)
        math_paragraph.add(equation)

    presentation.save("equation-array-alignment.pptx", slides.export.SaveFormat.PPTX)

Il confronto seguente mostra la presentazione salvata in PowerPoint. Nota la posizione di A= e =B accanto a ogni array.

Array di equazioni in PowerPoint con allineamento Superiore, Centrale e Inferiore e elementi adiacenti identici

Configura la spaziatura delle righe

row_spacing_rule seleziona la regola di spaziatura per le righe all’interno dell’array. row_spacing fornisce un valore numerico per una regola di spaziatura esplicita ed è ignorato dalle regole predefinite.

Per una spaziatura esatta, il valore è misurato in punti. Per una spaziatura proporzionale, è misurato in mezze linee: il valore 3 nell’esempio indica 1,5 linee. Imposta entrambe le proprietà quando specifichi un valore esplicito; modificare solo il valore numerico non seleziona una regola di spaziatura.

L’esempio seguente salva cinque presentazioni con le stesse equazioni, allineamento e impostazioni di carattere. Le prime tre usano le preimpostazioni; le ultime due mostrano valori espliciti.

import aspose.slides as slides
import aspose.slides.mathtext as math


def create_text(value):
    text = math.MathematicalText(value)
    text.format.font_height = 24
    text.format.latin_font = slides.FontData("Cambria Math")
    return text


settings = [
    (math.MathRowSpacingRule.SINGLE_LINE_GAP, 0),
    (math.MathRowSpacingRule.ONE_AND_A_HALF_LINE_GAP, 0),
    (math.MathRowSpacingRule.TWO_LINE_GAP, 0),
    (math.MathRowSpacingRule.EXACTLY, 20),
    (math.MathRowSpacingRule.MULTIPLE, 3)
]

for rule, spacing in settings:
    file_name = f"equation-array-{rule.name}.pptx"
    with slides.Presentation() as presentation:
        math_shape = presentation.slides[0].shapes.add_math_shape(20, 20, 600, 300)
        paragraph = math_shape.text_frame.paragraphs[0]
        paragraph.paragraph_format.space_before = 0
        paragraph.paragraph_format.space_after = 0
        math_paragraph = paragraph.portions[0].math_paragraph
        math_paragraph.justification = math.MathJustification.LEFT_JUSTIFIED

        rows = [create_text("x+y=3"), create_text("x-y=1"), create_text("x=2")]
        equation_array = math.MathArray(rows)
        equation_array.base_justification = math.MathVerticalAlignment.CENTER
        equation_array.row_spacing_rule = rule
        equation_array.row_spacing = spacing
        left_text = create_text("A=")
        right_text = create_text("=B")
        equation = math.MathBlock(left_text).join(equation_array).join(right_text)
        math_paragraph.add(equation)

        presentation.save(file_name, slides.export.SaveFormat.PPTX)

La spaziatura delle righe dell’array è distinta dalla spaziatura dei paragrafi. space_before e space_after aggiungono spazio intorno al paragrafo contenitore, non tra le righe dell’array. Allo stesso modo, IMathParagraph.justification posiziona orizzontalmente l’intero paragrafo matematico; non sostituisce l’impostazione di allineamento verticale dell’array.

Aggiungi funzioni trigonometriche

Usa as_argument_of_function quando l’argomento è l’elemento corrente e il nome della funzione è noto.

La funzione trigonometrica cos applicata a 2x

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    cosine = math.MathematicalText("2x").as_argument_of_function(
        math.MathFunctionsOfOneArgument.COS
    )

    math_paragraph.add(math.MathBlock(cosine))

    presentation.save("trigonometric-function.pptx", slides.export.SaveFormat.PPTX)

Aggiungi pedici e apici

Usa gli assistenti per pedice e apice per indici e potenze. Quando gli indici devono apparire sul lato sinistro della base, usa set_sub_superscript_on_the_left.

Una Y maiuscola con pedice 1 a sinistra e apice n

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    scripts = math.MathematicalText("Y").set_sub_superscript_on_the_left("1", "n")

    math_paragraph.add(math.MathBlock(scripts))

    presentation.save("subscript-superscript.pptx", slides.export.SaveFormat.PPTX)

Aggiungi delimitatori

Usa enclose per inserire un’espressione all’interno di delimitatori. Puoi anche impostare un carattere separatore per espressioni delimitate che contengono più elementi.

Un’espressione delimitata contenente x, y e z separati da barre verticali

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    delimiter = (
        math.MathematicalText("x")
        .join("y")
        .join("z")
        .enclose("<", ">")
    )
    delimiter.separator_character = "|"

    math_paragraph.add(math.MathBlock(delimiter))

    presentation.save("delimiters.pptx", slides.export.SaveFormat.PPTX)

Dimensione e allineamento dei delimitatori

Imposta grow_to_match_operand_height a True per far crescere le parentesi attorno a un operando alto, o a False per mantenerle nella dimensione normale. delimiter_shape accetta uno dei due valori MathDelimiterShape. CENTERED centra le parentesi sull’asse matematico, che attraversa il centro del segno di uguale. MATCH le allinea con il contenuto racchiuso. Entrambe le impostazioni influenzano solo i delimitatori. L’espressione interna rimane invariata.

L’esempio inserisce una frazione nell’esponente di x così l’espressione si estende più sopra la linea di base rispetto a sotto. Tutte e quattro le equazioni usano le stesse parentesi e impostazioni di carattere.

import aspose.slides as slides
import aspose.slides.mathtext as math


def add_expression(slide, left, top, grow, shape):
    fraction = math.MathematicalText("a + b").divide("c + d")
    power = math.MathematicalText("x").set_superscript(fraction)
    delimiter = power.enclose("(", ")")
    delimiter.grow_to_match_operand_height = grow
    delimiter.delimiter_shape = shape

    math_shape = slide.shapes.add_math_shape(left, top, 300, 100)
    portion = math_shape.text_frame.paragraphs[0].portions[0]
    portion.portion_format.font_height = 32
    equation = math.MathematicalText("y = ").join(delimiter)
    portion.math_paragraph.add(equation)


with slides.Presentation() as presentation:
    slide = presentation.slides[0]
    add_expression(slide, 20, 20, True, math.MathDelimiterShape.CENTERED)
    add_expression(slide, 350, 20, True, math.MathDelimiterShape.MATCH)
    add_expression(slide, 20, 140, False, math.MathDelimiterShape.CENTERED)
    add_expression(slide, 350, 140, False, math.MathDelimiterShape.MATCH)

    presentation.save("delimiter-sizing.pptx", slides.export.SaveFormat.PPTX)

In PowerPoint, confronta le righe per vedere l’effetto della crescita. Nella riga superiore, le parentesi crescono per racchiudere l’esponente e appaiono simili per entrambe le forme. Nella riga inferiore, la crescita è disattivata. Le parentesi più piccole a sinistra (CENTERED) si allineano con il segno di uguale, mentre quelle a destra (MATCH) sono più alte attorno all’espressione.

Quattro equazioni in PowerPoint con crescita dei delimitatori abilitata sopra e disabilitata sotto, e CENTERED a sinistra e MATCH a destra

Aggiungi una casella di bordo

Chiama to_border_box su una frazione per racchiudere l’intera espressione. Il IMathBorderBox restituito mostra tutte e quattro le parti per impostazione predefinita. Usa hide_top, hide_bottom, hide_left, e hide_right per rimuovere i singoli lati.

L’esempio posiziona sei copie della stessa frazione su una diapositiva. Per mostrare l’annullamento, nascondi tutti e quattro i lati e imposta strikethrough_bottom_left_to_top_right per una diagonale ascendente (↗) o strikethrough_top_left_to_bottom_right per una diagonale discendente (↘). Puoi anche usare strikethrough_horizontal o strikethrough_vertical con qualsiasi combinazione di lati visibili.

import aspose.slides as slides
import aspose.slides.mathtext as math


def add_fraction(slide, x, y, hide_border=False):
    fraction = math.MathematicalText("x+1").divide("y+2")
    box = fraction.to_border_box()
    box.hide_top = box.hide_bottom = box.hide_left = box.hide_right = hide_border

    shape = slide.shapes.add_math_shape(x, y, 160, 90)
    portion = shape.text_frame.paragraphs[0].portions[0]
    portion.portion_format.font_height = 28
    portion.math_paragraph.add(math.MathBlock(box))
    return box


with slides.Presentation() as presentation:
    presentation.slide_size.set_size(540, 220, slides.SlideSizeScaleType.DO_NOT_SCALE)
    slide = presentation.slides[0]

    add_fraction(slide, 10, 10)

    partial = add_fraction(slide, 190, 10)
    partial.hide_top = True
    partial.hide_right = True

    add_fraction(slide, 370, 10, hide_border=True).strikethrough_bottom_left_to_top_right = True
    add_fraction(slide, 10, 120, hide_border=True).strikethrough_top_left_to_bottom_right = True
    add_fraction(slide, 190, 120, hide_border=True).strikethrough_horizontal = True
    add_fraction(slide, 370, 120).strikethrough_vertical = True

    presentation.save("border-box.pptx", slides.export.SaveFormat.PPTX)

Sei frazioni modificabili in PowerPoint. Riga superiore: bordo completo, lati inferiore e sinistro, diagonale ascendente. Riga inferiore: diagonale discendente, barra orizzontale, barra verticale con bordo completo.

In questa frazione, la barra orizzontale sovrappone la barra della frazione. La barra verticale attraversa sia il numeratore sia il denominatore mentre il bordo circostante rimane visibile. Queste linee decorano l’intera espressione. La barratura di testo ordinario si applica ai caratteri di un run di testo. Dopo aver riaperto la presentazione in PowerPoint, è ancora possibile modificare separatamente il numeratore e il denominatore.

Controlla visibilità e layout con elementi fantasma

Avvolgi un’espressione in MathPhantom per controllare indipendentemente la sua visibilità e lo spazio che contribuisce a un’equazione. Le proprietà di IMathPhantom controllano quanto segue:

Proprietà Effetto
show Impostalo a False per nascondere l’espressione. Le sue dimensioni contribuiscono ancora al layout a meno che le proprietà corrispondenti sotto siano True.
zero_width Considera la larghezza orizzontale dell’espressione come zero, permettendo agli elementi vicini di avvicinarsi.
zero_asc Considera la sua ascensione, l’altezza sopra la linea di base, come zero. Questo può ridurre lo spazio riservato sopra gli elementi vicini.
zero_desc Considera la sua discesa, la profondità sotto la linea di base, come zero. Questo può avvicinare una barra di frazione o altro contenuto sotto l’espressione ai suoi vicini.

La linea di base è la linea di riferimento su cui si trovano le lettere matematiche ordinarie. Nascondere il contenuto non rimuove le sue dimensioni, e trattare una dimensione come zero non elimina l’espressione. L’espressione sottostante rimane disponibile tramite base. Imposta show su True per visualizzarla nuovamente; le impostazioni delle dimensioni rimangono invariate.

L’esempio seguente crea cinque varianti affiancate: una frazione visibile, una frazione nascosta che riserva spazio e tre frazioni nascoste con una dimensione trattata come zero. Ogni variante utilizza la stessa espressione circostante e Cambria Math a 24 punti. Tutte le forme di equazione hanno la stessa posizione superiore, segnata dalla guida grigia. Inserire il phantom nel numeratore di una frazione esterna rende più evidenti le modifiche di layout verticale.

import aspose.slides as slides
import aspose.slides.mathtext as math


def create_text(value):
    text = math.MathematicalText(value)
    text.format.font_height = 24
    text.format.latin_font = slides.FontData("Cambria Math")
    return text


with slides.Presentation() as presentation:
    presentation.slide_size.set_size(1000, 180, slides.SlideSizeScaleType.DO_NOT_SCALE)
    slide = presentation.slides[0]
    labels = ["Visible", "Hidden: reserves space", "Hidden: ZeroWidth", "Hidden: ZeroAsc", "Hidden: ZeroDesc"]

    guide = slide.shapes.add_auto_shape(slides.ShapeType.LINE, 10, 60, 980, 0)
    guide.line_format.fill_format.fill_type = slides.FillType.SOLID
    guide.line_format.fill_format.solid_fill_color.color = slides.Color.light_gray

    for i, label_text in enumerate(labels):
        left = 10 + i * 200
        label = slide.shapes.add_auto_shape(slides.ShapeType.RECTANGLE, left, 10, 190, 30)
        label.fill_format.fill_type = slides.FillType.NO_FILL
        label.line_format.fill_format.fill_type = slides.FillType.NO_FILL
        label.text_frame.text = label_text
        label_format = label.text_frame.paragraphs[0].portions[0].portion_format
        label_format.font_height = 14
        label_format.fill_format.fill_type = slides.FillType.SOLID
        label_format.fill_format.solid_fill_color.color = slides.Color.black

        fraction_numerator = create_text("a+b")
        fraction_denominator = create_text("c+d")
        fraction = math.MathFraction(fraction_numerator, fraction_denominator)
        phantom = math.MathPhantom(fraction)
        phantom.show = i == 0
        phantom.zero_width = i == 2
        phantom.zero_asc = i == 3
        phantom.zero_desc = i == 4

        left_text = create_text("x+")
        right_text = create_text("+y")
        numerator = math.MathBlock(left_text).join(phantom).join(right_text)
        denominator = create_text("z")
        equation = math.MathFraction(numerator, denominator)

        shape = slide.shapes.add_math_shape(left, 60, 190, 100)
        shape.text_frame.text_frame_format.anchoring_type = slides.TextAnchorType.TOP
        math_paragraph = shape.text_frame.paragraphs[0].portions[0].math_paragraph
        math_paragraph.add(math.MathBlock(equation))

    presentation.save("math-phantom.pptx", slides.export.SaveFormat.PPTX)

Cinque equazioni in PowerPoint a confronto: una frazione visibile, una frazione nascosta che riserva spazio, e frazioni nascoste con ZeroWidth, ZeroAsc o ZeroDesc abilitati

Raggruppa termini

Usa group per posizionare un carattere di raggruppamento sopra o sotto un’espressione. Aggiungi un limite per etichettare i termini raggruppati.

L’espressione x più y raggruppata con l’etichetta qualsiasi testo sotto di essa

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 120)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    grouped = (
        math.MathematicalText("x + y")
        .group(chr(0x23DF), math.MathTopBotPositions.BOTTOM, math.MathTopBotPositions.TOP)
        .set_lower_limit("any text")
    )

    math_paragraph.add(math.MathBlock(grouped))

    presentation.save("grouped-terms.pptx", slides.export.SaveFormat.PPTX)

Formatta elementi matematici

Usa gli assistenti di formattazione solo dove chiariscono la formula. Per esempio, overbar posiziona una barra sopra un elemento matematico.

Un’espressione matematica ABC con una barra sopra

import aspose.slides as slides
import aspose.slides.mathtext as math

with slides.Presentation() as presentation:
    slide = presentation.slides[0]

    math_shape = slide.shapes.add_math_shape(20, 20, 700, 100)
    math_paragraph = math_shape.text_frame.paragraphs[0].portions[0].math_paragraph

    overbar = math.MathematicalText("ABC").overbar()

    math_paragraph.add(math.MathBlock(overbar))

    presentation.save("overbar.pptx", slides.export.SaveFormat.PPTX)

Formatta testo in un’equazione esistente

Per formattare il testo in tutta un’equazione esistente, percorri l’albero degli elementi di ciascun blocco matematico. IMathElement.get_children restituisce solo i figli immediati, quindi è necessario chiamarlo ricorsivamente per raggiungere il testo all’interno di frazioni, script, radici e altre strutture nidificate. Verifica l’elemento corrente così come i suoi figli per includere l’elemento iniziale quando è MathematicalText.

Questo esempio assume che input.pptx contenga un’equazione come z = xᵢ / ∛y, con una frazione che contiene un pedice nel numeratore e una radice nel denominatore. Elaborare solo gli elementi di primo livello del blocco perderebbe il testo dentro la frazione. L’esempio trova le parti matematiche nei riquadri di testo delle diapositive, accede ai loro blocchi tramite MathPortion.math_paragraph, e imposta font_height a 28 punti per ogni elemento di testo tramite la proprietà format.

import aspose.slides as slides
import aspose.slides.mathtext as math


def format_math_text(element):
    if isinstance(element, math.MathematicalText):
        element.format.font_height = 28

    for child in element.get_children():
        format_math_text(child)


with slides.Presentation("input.pptx") as presentation:
    for slide in presentation.slides:
        for shape in slide.shapes:
            if not isinstance(shape, slides.AutoShape) or shape.text_frame is None:
                continue

            for paragraph in shape.text_frame.paragraphs:
                for portion in paragraph.portions:
                    if isinstance(portion, math.MathPortion):
                        for block in portion.math_paragraph:
                            format_math_text(block)

    presentation.save("formatted-equations.pptx", slides.export.SaveFormat.PPTX)

La presentazione salvata contiene la formattazione del testo aggiornata a ogni livello di ogni equazione elaborata, preservando il contenuto testuale e la struttura matematica.

Riferimento rapido

Attività API principale
Crea testo matematico MathematicalText
Combina elementi IMathElement.join
Crea frazioni IMathElement.divide
Aggiungi apice o pedice set_superscript, set_subscript
Aggiungi funzioni function, as_argument_of_function
Aggiungi radici radical
Aggiungi limiti set_lower_limit, set_upper_limit
Aggiungi script lato sinistro set_sub_superscript_on_the_left
Aggiungi somme e integrali nary, integral
Aggiungi matrici MathMatrix
Aggiungi array di equazioni to_math_array
Aggiungi delimitatori enclose
Aggiungi barre e bordi overbar, to_border_box
Raggruppa termini group

FAQ

Posso modificare un’equazione PowerPoint esistente?

Sì. Apri la presentazione, trova la forma che contiene un MathPortion, ottieni il suo math_paragraph, e aggiorna i blocchi matematici in quel paragrafo.

Le equazioni vengono salvate come math modificabile di PowerPoint?

Sì. Quando salvi in PPTX, Aspose.Slides scrive l’equazione come contenuto Office math modificabile.

Posso esportare le equazioni in LaTeX?

Sì. Ottieni il MathParagraph dell’equazione dal suo MathPortion, e chiama MathParagraph.to_latex per esportarlo direttamente. Per un esempio completo, vedi Esporta equazioni matematiche dalle presentazioni in Python via .NET.