Grafiekwerkbladformules toepassen in presentaties in Java

Waar deze pagina over gaat

Excel‑stijlformules toepassen in Aspose.Slides‑grafiekwerkbladen voor Java, waarden herberekenen en de resultaten gebruiken in PowerPoint‑grafieken.

Overzicht

PowerPoint‑grafieken slaan hun brongegevens doorgaans op in een ingebed werkblad. In Aspose.Slides for Java kun je dat werkblad benaderen via de chart‑data‑workbook, invoerwaarden schrijven, formules aan cellen toewijzen, ondersteunde formules berekenen en de berekende cellen als grafiekgegevens gebruiken.

Dit artikel legt de volledige formule‑workflow uit: een grafiek maken, het werkblad vullen, A1‑ of R1C1‑formules toewijzen, ze opnieuw berekenen, de berekende waarden lezen, die cellen koppelen aan een grafiekreeks en de presentatie opslaan. Het beschrijft tevens de ondersteunde formulesyntaxis, de ingebouwde functiesubset, gecachte waarden, niet‑ondersteunde formules en spreadsheet‑specifieke fouten.

Grafiek‑werkbladen en formules

Een grafiek‑werkblad bevat de categorieën, reeksnamen en waarden die door een grafiek worden gebruikt. In PowerPoint kun je het werkblad inspecteren door de grafiek‑data‑editor te openen:

PowerPoint‑grafiek met opened embedded werkblad, toont categorie‑ en reeksengegevens

In Aspose.Slides wordt het werkblad blootgesteld via de IChartDataWorkbook interface. Gebruik IChartDataCell.setFormula voor A1‑style formules en IChartDataCell.setR1C1Formula voor R1C1‑style formules. Na het wijzigen van invoercellen of formules, roep IChartDataWorkbook.calculateFormulas aan om ondersteunde formules te herberekenen en de overeenkomstige celwaarden bij te werken.

Een berekende cel geeft nog steeds zijn resultaat terug via IChartDataCell.getValue. Dit is belangrijk wanneer je het resultaat van een formule in code wilt inspecteren of de cel als een grafiekdatapunt wilt gebruiken.

Een grafiek maken en werkblad‑formules berekenen

Het volgende voorbeeld toont een end‑to‑end workflow. Het maakt een gegroepeerde kolomgrafiek, wist de voorbeeldgegevens, schrijft kwartaal‑omzet‑ en uitgavenwaarden, berekent winst met formules, leest de resultaten, gebruikt de berekende cellen als grafiekwaarden en slaat de presentatie op.

import com.aspose.slides.*;

Presentation presentation = new Presentation();
try {
    ISlide slide = presentation.getSlides().get_Item(0);
    IChart chart = slide.getShapes().addChart(ChartType.ClusteredColumn, 50, 50, 600, 350);
    IChartDataWorkbook workbook = chart.getChartData().getChartDataWorkbook();
    int worksheetIndex = 0;

    chart.getChartData().getSeries().clear();
    chart.getChartData().getCategories().clear();
    workbook.clear(worksheetIndex);

    IChartDataCell category1 = workbook.getCell(worksheetIndex, "A2", "Q1");
    IChartDataCell category2 = workbook.getCell(worksheetIndex, "A3", "Q2");
    IChartDataCell category3 = workbook.getCell(worksheetIndex, "A4", "Q3");

    workbook.getCell(worksheetIndex, "B1", "Revenue");
    workbook.getCell(worksheetIndex, "C1", "Expenses");
    workbook.getCell(worksheetIndex, "D1", "Profit");

    workbook.getCell(worksheetIndex, "B2").setValue(120.0);
    workbook.getCell(worksheetIndex, "C2").setValue(80.0);
    workbook.getCell(worksheetIndex, "B3").setValue(150.0);
    workbook.getCell(worksheetIndex, "C3").setValue(95.0);
    workbook.getCell(worksheetIndex, "B4").setValue(135.0);
    workbook.getCell(worksheetIndex, "C4").setValue(110.0);

    IChartDataCell profit1 = workbook.getCell(worksheetIndex, "D2");
    IChartDataCell profit2 = workbook.getCell(worksheetIndex, "D3");
    IChartDataCell profit3 = workbook.getCell(worksheetIndex, "D4");

    profit1.setFormula("B2-C2");
    profit2.setFormula("B3-C3");
    profit3.setFormula("B4-C4");

    workbook.calculateFormulas();

    double q1Profit = ((Number) profit1.getValue()).doubleValue(); // 40
    double q2Profit = ((Number) profit2.getValue()).doubleValue(); // 55
    double q3Profit = ((Number) profit3.getValue()).doubleValue(); // 25

    System.out.println("Q1 profit: " + q1Profit);
    System.out.println("Q2 profit: " + q2Profit);
    System.out.println("Q3 profit: " + q3Profit);

    chart.getChartData().getCategories().add(category1);
    chart.getChartData().getCategories().add(category2);
    chart.getChartData().getCategories().add(category3);

    IChartSeries profitSeries = chart.getChartData().getSeries().add(workbook.getCell(worksheetIndex, "D1"), chart.getType());
    profitSeries.getDataPoints().addDataPointForBarSeries(profit1);
    profitSeries.getDataPoints().addDataPointForBarSeries(profit2);
    profitSeries.getDataPoints().addDataPointForBarSeries(profit3);
    profitSeries.getLabels().getDefaultDataLabelFormat().setShowValue(true);

    presentation.save("chart-formulas.pptx", SaveFormat.Pptx);
} finally {
    presentation.dispose();
}

De grafiekdatapunten verwijzen naar D2:D4, zodat de grafiek de berekende winstwaarden gebruikt. Er is geen aparte grafiek‑verversingsaanroep in deze workflow: bereken eerst het werkblad, gebruik daarna de of sla de grafiekgegevens op die naar de berekende cellen wijzen.

Gebruik A1‑stijlformules

A1‑notatie identificeert kolommen met letters en rijen met cijfers. Wijs A1‑style uitdrukkingen toe via IChartDataCell.setFormula.

import com.aspose.slides.*;

Presentation presentation = new Presentation();
try {
    ISlide slide = presentation.getSlides().get_Item(0);
    IChart chart = slide.getShapes().addChart(ChartType.ClusteredColumn, 50, 50, 500, 300);
    IChartDataWorkbook workbook = chart.getChartData().getChartDataWorkbook();

    workbook.getCell(0, "C3").setValue(10);
    workbook.getCell(0, "F2").setValue(2);
    workbook.getCell(0, "G2").setValue(3);
    workbook.getCell(0, "H2").setValue(4);

    IChartDataCell cell = workbook.getCell(0, "A2");
    cell.setFormula("C3+SUM(F2:H2)");

    workbook.calculateFormulas();

    Object value = cell.getValue(); // 19
} finally {
    presentation.dispose();
}

Veelvoorkomende A1‑referentievormen zijn:

Referentie	Relatief	Absoluut	Gemengd
Cel	`A2`	`$A$2`	`A$2`, `$A2`
Rij	`2:2`	`$2:$2`	—
Kolom	`A:A`	`$A:$A`	—
Bereik	`A2:C4`	`$A$2:$C$4`	`A$2:$C4`, `$A2:C$4`

Relatieve referenties kunnen veranderen wanneer een formule wordt verplaatst of gekopieerd door een spreadsheet‑applicatie. Absolute referenties houden beide coördinaten vast, terwijl gemengde referenties slechts een rij of een kolom fixeren.

Gebruik R1C1‑stijlformules

R1C1‑notatie identificeert zowel rijen als kolommen numeriek. Relatieve referenties gebruiken offsets tussen rechte haken. Wijs deze syntaxis toe via IChartDataCell.setR1C1Formula.

import com.aspose.slides.*;

Presentation presentation = new Presentation();
try {
    ISlide slide = presentation.getSlides().get_Item(0);
    IChart chart = slide.getShapes().addChart(ChartType.ClusteredColumn, 50, 50, 500, 300);
    IChartDataWorkbook workbook = chart.getChartData().getChartDataWorkbook();

    workbook.getCell(0, "B2").setValue(12);
    workbook.getCell(0, "C2").setValue(5);

    IChartDataCell cell = workbook.getCell(0, "D2");
    cell.setR1C1Formula("RC[-2]-RC[-1]");

    workbook.calculateFormulas();

    Object value = cell.getValue(); // 7
} finally {
    presentation.dispose();
}

Veelvoorkomende R1C1‑referentievormen zijn:

Referentie	Relatief	Absoluut	Gemengd
Cel	`R[2]C[3]`	`R2C3`	`R2C[3]`, `R[2]C3`
Rij	`R[2]`	`R2`	—
Kolom	`C[3]`	`C3`	—
Bereik	`R[2]C[3]:R[5]C[7]`	`R2C3:R5C7`	`R2C3:R[5]C[7]`, `R[2]C3:R5C[7]`

Bijvoorbeeld, in cel D2 betekent RC[-2] de cel in dezelfde rij twee kolommen naar links (B2).

Formule‑constanten en -operatoren

De ingebouwde formule‑evaluator ondersteunt logische waarden, numerieke literals, strings, spreadsheet‑foutwaarden, rekenkundige operatoren en vergelijkingsoperatoren.

Constanten en literals

Type	Voorbeelden	Opmerkingen
Logisch	`TRUE`, `FALSE`	Kan rechtstreeks worden gebruikt in logische uitdrukkingen zoals `A2=TRUE`.
Numeriek	`1`, `0.5`, `.3`, `1E-2`	Gebruikelijke en wetenschappelijke notaties worden ondersteund.
String	`"abc"`, `"2/3/2020 12:00"`	Tekst‑literals staan tussen dubbele aanhalingstekens binnen de formule.
Foutresultaat	`#DIV/0!`, `#N/A`, `#REF!`	Een geldige formule kan evalueren tot een spreadsheet‑foutwaarde i.p.v. een normaal resultaat.

Dit voorbeeld gebruikt verschillende constanttypes:

import com.aspose.slides.*;

Presentation presentation = new Presentation();
try {
    ISlide slide = presentation.getSlides().get_Item(0);
    IChart chart = slide.getShapes().addChart(ChartType.ClusteredColumn, 50, 50, 500, 300);
    IChartDataWorkbook workbook = chart.getChartData().getChartDataWorkbook();

    workbook.getCell(0, "A2").setValue(false);
    workbook.getCell(0, "B2").setFormula("A2=TRUE");
    workbook.getCell(0, "C2").setFormula("1+0.5");
    workbook.getCell(0, "D2").setFormula(".3*1E-2");
    workbook.getCell(0, "E2").setFormula("\"abc\"");
    workbook.getCell(0, "F2").setFormula("2/0");

    workbook.calculateFormulas();

    Object logicalValue = workbook.getCell(0, "B2").getValue(); // false
    Object numericValue = workbook.getCell(0, "C2").getValue(); // 1.5
    Object scientificValue = workbook.getCell(0, "D2").getValue(); // 0.003
    Object stringValue = workbook.getCell(0, "E2").getValue(); // abc
    Object errorValue = workbook.getCell(0, "F2").getValue(); // #DIV/0!
} finally {
    presentation.dispose();
}

Rekenkundige operatoren

Operator	Betekenis	Voorbeeld
`+`	Optelling of unair plus	`2+3`
`-`	Aftrekking of negatie	`2-3`, `-3`
`*`	Vermenigvuldiging	`2*3`
`/`	Deling	`2/3`
`%`	Percentage	`30%`
`^`	Machtsverheffing	`2^3`

Gebruik haakjes om de evaluatievolgorde expliciet te maken, bijvoorbeeld (A2+B2)*C2.

Vergelijkingsoperatoren

Vergelijkingsuitdrukkingen retourneren logische waarden.

Operator	Betekenis	Voorbeeld
`=`	Gelijk aan	`A2=3`
`<>`	Niet gelijk aan	`A2<>3`
`>`	Groter dan	`A2>3`
`>=`	Groter dan of gelijk aan	`A2>=3`
`<`	Kleiner dan	`A2<3`
`<=`	Kleiner dan of gelijk aan	`A2<=3`

Ondersteunde vooraf gedefinieerde functies

Aspose.Slides bevat een ingebouwde formule‑evaluator voor grafiek‑werkbladen, maar het is geen volledige Excel‑berekeningsengine. De gedocumenteerde functieverzameling is beperkt tot de functies hieronder. Ga er niet van uit dat een willekeurige Excel‑functie kan worden herberekend met IChartDataWorkbook.calculateFormulas.

Functie	Doel of ondersteunde vorm	Voorbeeld
`ABS`	Absolute waarde	`ABS(A2)`
`AVERAGE`	Rekenkundig gemiddelde	`AVERAGE(B2:B5)`
`CEILING`	Afronden naar boven op een veelvoud	`CEILING(A2,5)`
`CHOOSE`	Een waarde selecteren op index	`CHOOSE(A2,"Low","High")`
`CONCAT`	Tekstwaarden samenvoegen	`CONCAT(A2,B2)`
`CONCATENATE`	Tekstwaarden samenvoegen	`CONCATENATE(A2," ",B2)`
`DATE`	Een datumwaarde maken met het 1900‑datumstelsel	`DATE(2026,8,19)`
`DAYS`	Aantal dagen tussen data retourneren	`DAYS(B2,A2)`
`FIND`	Een tekstwaarde in een andere zoeken	`FIND("-",A2)`
`FINDB`	Byte‑georiënteerd zoeken	`FINDB("a",A2)`
`IF`	Voorwaardelijk resultaat	`IF(A2>0,A2,0)`
`INDEX`	Referentie‑vorm	`INDEX(A2:C4,2,3)`
`LOOKUP`	Vector‑vorm	`LOOKUP(A2,B2:B5,C2:C5)`
`MATCH`	Vector‑vorm	`MATCH(A2,B2:B5,0)`
`MAX`	Maximumwaarde	`MAX(B2:B5)`
`SUM`	Som van waarden	`SUM(B2:B5)`
`VLOOKUP`	Verticaal zoeken	`VLOOKUP(A2,B2:D10,3,FALSE)`

De beperkingen in de tabel zijn significant: INDEX is gedocumenteerd in referentie‑vorm, terwijl LOOKUP en MATCH in hun vector‑vormen staan. DATE gebruikt het 1900‑datumstelsel. Functies die hier niet zijn opgesomd, moeten worden beschouwd als niet‑ondersteund door de Aspose.Slides‑formule‑evaluator, tenzij ze afzonderlijk gedocumenteerd zijn.

Formules berekenen met een voorkeurs‑cultuur

Sommige werkboek‑functies interpreteren tekst volgens cultuur‑specifieke regels. Dit is vooral belangrijk voor functies bedoeld voor talen die double‑byte‑character‑sets (DBCS) gebruiken. Om dergelijke formules correct te berekenen, maak een LoadOptions aan, stel de voorkeurs‑cultuur in met SpreadsheetOptions.setPreferredCulture, wijs de spreadsheet‑opties toe via LoadOptions.setSpreadsheetOptions, en laad vervolgens de presentatie.

Het volgende voorbeeld selecteert de Japanse cultuur, opent een presentatie met de geconfigureerde load‑options, en roept IChartDataWorkbook.calculateFormulas aan voor elk grafiek‑werkboek:

import com.aspose.slides.*;
import java.util.Locale;

Locale japaneseCulture = Locale.forLanguageTag("ja-JP");

ISpreadsheetOptions spreadsheetOptions = new SpreadsheetOptions();
spreadsheetOptions.setPreferredCulture(japaneseCulture);

LoadOptions loadOptions = new LoadOptions();
loadOptions.setSpreadsheetOptions(spreadsheetOptions);

Presentation presentation = new Presentation("presentation.pptx", loadOptions);
try {
    for (ISlide slide : presentation.getSlides()) {
        for (IShape shape : slide.getShapes()) {
            if (shape instanceof IChart) {
                IChart chart = (IChart) shape;
                chart.getChartData().getChartDataWorkbook().calculateFormulas();
            }
        }
    }
} finally {
    presentation.dispose();
}

De voorkeurs‑cultuur maakt deel uit van de presentatie‑laad‑configuratie, dus stel deze in vóór het aanmaken van de Presentation instantie. Gebruik de cultuur die door de werkboek‑formules wordt verwacht; bijvoorbeeld ja-JP voor formules die de Japanse DBCS‑berekeningsregels volgen.

Herberekening en gecachte waarden

Spreadsheet‑bestanden slaan doorgaans zowel een formule als de laatst berekende waarde op. Aspose.Slides kan daarom een gecachte waarde lezen via IChartDataCell.getValue wanneer een presentatie wordt geladen en de relevante grafiek‑data niet is gewijzigd.

Na het wijzigen van invoercellen of formules, moet je niet vertrouwen op een oude gecachte uitkomst. Roep IChartDataWorkbook.calculateFormulas aan vóór het lezen van berekende waarden of het opslaan van grafiekdata die ervan afhangen.

Voor formules buiten de ondersteunde subset kan Aspose.Slides de formule mogelijk niet parseren of de afhankelijkheden niet vaststellen. Als het werkboek is aangepast, kan de vorige gecachte waarde niet meer als betrouwbaar worden beschouwd. In zo’n situatie kan het lezen van de waarde van een cel met niet‑ondersteunde data een CellUnsupportedDataException veroorzaken.

Als je grafiek afhankelijk is van Excel‑functies die Aspose.Slides niet evalueert, bereken die formules dan met een spreadsheet‑engine die ze ondersteunt en schrijf de resulterende waarden terug naar het grafiek‑werkboek. Vervang niet‑ondersteunde formules door geraden waarden.

Foutafhandeling van formules

Er zijn twee verschillende soorten problemen te onderscheiden.

Een formule kan geldig zijn maar een spreadsheet‑foutresultaat opleveren zoals #DIV/0!, #N/A, #NAME?, #NULL!, #NUM!, #REF! of #VALUE!. In dat geval is het fout‑token een celresultaat en kan het worden geretourneerd via IChartDataCell.getValue.

Een formule kan ook falen bij het parseren, de referentie, de afhankelijkheid of op het niveau van ondersteunde data. Aspose.Slides biedt spreadsheet‑specifieke uitzonderingen voor deze gevallen: CellInvalidFormulaException, CellInvalidReferenceException, CellCircularReferenceException en CellUnsupportedDataException.

Wanneer formules afkomstig zijn van templates of gebruikersinvoer, behandel deze uitzonderingen rond herberekening en waardetoegang:

import com.aspose.slides.*;

Presentation presentation = new Presentation();
try {
    ISlide slide = presentation.getSlides().get_Item(0);
    IChart chart = slide.getShapes().addChart(ChartType.ClusteredColumn, 50, 50, 500, 300);
    IChartDataWorkbook workbook = chart.getChartData().getChartDataWorkbook();
    IChartDataCell cell = workbook.getCell(0, "A2");
    cell.setFormula("SUM(B2:B5)");

    try {
        workbook.calculateFormulas();
        System.out.println(cell.getValue());
    } catch (CellInvalidFormulaException ex) {
        System.err.println("Invalid formula: " + ex.getMessage());
    } catch (CellInvalidReferenceException ex) {
        System.err.println("Invalid cell reference: " + ex.getMessage());
    } catch (CellCircularReferenceException ex) {
        System.err.println("Circular reference: " + ex.getMessage());
    } catch (CellUnsupportedDataException ex) {
        System.err.println("Unsupported spreadsheet data: " + ex.getMessage());
    }
} finally {
    presentation.dispose();
}

Praktische beperkingen

De formule‑ondersteuning in grafiek‑werkbladen is bedoeld voor een gedefinieerde subset van spreadsheet‑berekeningen, niet voor volledige Excel‑compatibiliteit. Houd deze beperkingen in gedachten bij het ontwerpen van een rapportage‑workflow:

Gebruik alleen de gedocumenteerde constanten, operatoren, referenties en functies wanneer je wilt dat Aspose.Slides formules herberekent.
Herbereken na het wijzigen van cellen waar formuleresultaten van afhankelijk zijn.
Beschouw gecachte waarden uit geladen presentaties als momentopnames, niet als vervanging voor herberekening na bewerkingen.
Test formules uit bestaande templates voordat je vertrouwt op hun berekende waarden, vooral wanneer ze functies buiten de gedocumenteerde lijst gebruiken.
Voor formules die een volledige spreadsheet‑berekeningsengine vereisen, bereken ze extern en werk vervolgens het grafiek‑werkboek bij met de resulterende waarden.

FAQ

Wat is het verschil tussen IChartDataCell.setFormula en IChartDataCell.setR1C1Formula?

IChartDataCell.setFormula slaat een A1‑style expressie op, bijvoorbeeld B2-C2. IChartDataCell.setR1C1Formula slaat een R1C1‑style expressie op, bijvoorbeeld RC[-2]-RC[-1]. Gebruik de notatie die het beste past bij hoe je formules genereert of kopieert.

Moet ik de cel zelf lezen of de waarde na berekening?

IChartDataWorkbook.getCell retourneert een IChartDataCell. Om het berekende resultaat te verkrijgen, roep je de IChartDataCell.getValue methode van die cel aan na herberekening.

Wanneer moet ik IChartDataWorkbook.calculateFormulas aanroepen?

Roep IChartDataWorkbook.calculateFormulas aan nadat je invoerwaarden of formules hebt gewijzigd en voordat je afhankelijk bent van de berekende resultaten. Dit werkt de waarden bij van formules die de ingebouwde evaluator ondersteunt.

Ondersteunt Aspose.Slides elke Excel‑functie?

Nee. De ingebouwde evaluator ondersteunt een gedocumenteerde subset van functies. Functies buiten die subset mogen niet worden verondersteld correct te worden herberekend. Als volledige Excel‑formule‑compatibiliteit vereist is, voer de berekening dan uit met een geschikte spreadsheet‑engine en schrijf de uiteindelijke waarden naar het grafiek‑werkboek.

Wat gebeurt er als een geladen presentatie een niet‑ondersteunde formule bevat?

Als de grafiekdata niet is gewijzigd, kan het werkboek nog een eerder berekende gecachte waarde bevatten. Nadat gerelateerde data is aangepast, is die gecachte waarde mogelijk niet meer geldig. Het benaderen van een cel waarvan de formule niet kan worden verwerkt, kan een CellUnsupportedDataException veroorzaken.

Zijn formule‑foutwaarden hetzelfde als Java‑exceptions?

Nee. Een resultaat zoals #DIV/0! is een spreadsheet‑waarde die ontstaat uit een geldige berekening. Exceptions zoals CellInvalidFormulaException of CellCircularReferenceException geven aan dat de formule niet normaal kan worden verwerkt.

Ververs een grafiek automatisch wanneer een formulecel verandert?

Een grafiekreeks kan verwijzen naar werkboekcellen. Herbereken eerst het werkboek, sla daarna de presentatie op of render deze. Als de grafiekdatapunten naar de berekende cellen verwijzen, gebruikt de grafiek die bijgewerkte celwaarden; een aparte grafiek‑verversingsmethode is niet nodig voor deze workflow.

Kunnen grafieken een extern Excel‑werkboek gebruiken?

Ja, grafiekdata kan worden geconfigureerd om een extern werkboek te gebruiken via de grafiek‑data‑API. De formule‑berekeningsworkflow die in dit artikel wordt beschreven, heeft echter betrekking op het grafiek‑data‑werkboek en de formule‑subset die door Aspose.Slides wordt geëvalueerd. Ga er niet van uit dat IChartDataWorkbook.calculateFormulas volledige herberekening van willekeurige formules in een extern XLSX‑bestand biedt.

Kan ik formules gebruiken die verwijzen naar een ander werkblad of werkboek?

Excel‑style verwijzingen kunnen voorkomen in grafiek‑werkboeken, maar de formule‑evaluatie is beperkt tot de ondersteunde parser en functieset. Als een cross‑sheet‑ of externe referentie essentieel is, controleer dan die specifieke formule met de versie van Aspose.Slides die je gebruikt. Voor workflows die brede Excel‑referentie‑compatibiliteit vereisen, bereken het werkboek extern en schrijf de geëvalueerde waarden terug naar de grafiekdata.

Moeten formule‑strings beginnen met =?

De Aspose.Slides‑API‑voorbeelden wijzen uitdrukkingen toe zoals B2-C2 of SUM(B2:B5) zonder een leidende =. Het gebruik van die vorm houdt gegenereerde formules consistent met de gedocumenteerde API‑voorbeelden.

Diagrammen in presentaties opmaken in Java Animeer PowerPoint-grafieken in Java