Beheer grafiekseries in presentaties in C++
Overzicht
Een diagram kan zijn geplotte waarden opslaan in werkboekcellen of direct als numerieke literals. Een IChartSeries vertegenwoordigt één set verwante waarden, en elke IChartDataPoint vertegenwoordigt een punt in die serie. IChartCategory objecten leveren de labels of groepeervelden die door de series worden gedeeld. In diagrammen die met standaardgegevens zijn aangemaakt, gebruiken serienaam‑, categorie‑ en puntwaarden IChartDataCell objecten uit het diagram‑werkboek.
Voor een typisch categorie‑diagram gebruikt het standaardwerkboek rij 0 voor serienamen, kolom 0 voor categorienamen en de overige cellen voor seriewaarden. Werkblad‑, rij‑ en kolom‑indexen die aan IChartDataWorkbook::GetCell worden doorgegeven, zijn nul‑gebaseerd. Deze indeling is handig wanneer u een diagram met standaardgegevens maakt, maar ga er niet van uit dat elk bestaand diagram deze indeling hanteert. Voor een geladen presentatie moet u de cellen die door de series, categorieën en datapunten worden verwezen, inspecteren voordat u werkboekwaarden wijzigt.
Diagraminstellingen hebben drie verschillende scopes:
- Instellingen op serieniveau, zoals IChartSeries::get_Format, bieden de standaarduiterlijk voor alle punten in één serie.
- Instellingen per datapunt, zoals IChartDataPoint::get_Format, overschrijven de serie‑uiterlijk voor één punt.
- Groepsinstellingen gelden voor compatibele series die tot dezelfde IChartSeriesGroup behoren. Toegang tot de groep krijgt u via IChartSeries::get_ParentSeriesGroup wanneer u opties zoals overlap of gatbreedte wilt instellen.
Wanneer er geen expliciete punt‑ of serie‑vulling is ingesteld, bepalen de diagramstijl en het thema het automatische uiterlijk. Wanneer zowel serie‑ als punt‑opmaak aanwezig zijn, heeft de punt‑opmaak voorrang voor dat punt.

Voor een gegroepeerd cilinderdiagram, zie hoe changing the 3D series type or bar shape de eerste serie beïnvloedt.
Serieswaarden instellen met numerieke literals
Gebruik numerieke literals wanneer seriewaarden afkomstig zijn uit toepassingsdata of berekeningen en geen verwijzingen naar werkbladcellen nodig hebben. Roep set_DataSourceTypeForValues aan met DataSourceType::DoubleLiterals vóór u de waarde die door elke punt‑get_Value wordt geretourneerd, toewijst via set_AsLiteralDouble.
De collectie‑instelling bepaalt het bron‑type van alle puntwaarden in die serie. Elke punt‑IBaseChartValue::get_DataSourceType meldt het geselecteerde type; wijzig het via de collectie‑instelling. Met Worksheet gebruikt u get_AsCell om de verwezen cel te benaderen. Met DoubleLiterals gebruikt u get_AsLiteralDouble of set_AsLiteralDouble om het getal rechtstreeks te lezen of te schrijven.
Het volgende voorbeeld maakt een kolomdiagram met standaard series en categorieën, en kent berekende waarden van 10, 20 enzovoort toe aan de bestaande punten van de eerste serie. Het slaat de presentatie op, opent deze opnieuw en drukt de opgeslagen waarden af.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/DataSourceType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataPoint.h>
#include <DOM/Chart/IChartDataPointCollection.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IDoubleChartValue.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/console.h>
#include <system/object_ext.h>
#include <system/shared_ptr.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace Aspose::Slides::Export;
using namespace System;
auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20, 20, 500, 300);
auto series = chart->get_ChartData()->get_Series()->idx_get(0);
series->get_DataPoints()->set_DataSourceTypeForValues(DataSourceType::DoubleLiterals);
for (auto i = 0; i < series->get_DataPoints()->get_Count(); i++)
{
series->get_DataPoints()->idx_get(i)->get_Value()->set_AsLiteralDouble((i + 1) * 10);
}
presentation->Save(u"numeric_literals.pptx", SaveFormat::Pptx);
presentation->Dispose();
auto reopenedPresentation = MakeObject<Presentation>(u"numeric_literals.pptx");
auto reopenedSlide = reopenedPresentation->get_Slide(0);
auto reopenedChart = ExplicitCast<IChart>(reopenedSlide->get_Shape(0));
auto reopenedSeries = reopenedChart->get_ChartData()->get_Series()->idx_get(0);
for (auto i = 0; i < reopenedSeries->get_DataPoints()->get_Count(); i++)
{
auto point = reopenedSeries->get_DataPoints()->idx_get(i);
Console::WriteLine(point->get_Value()->get_AsLiteralDouble());
}
reopenedPresentation->Dispose();
Het punt‑waarde‑bron‑type staat los van IChartData::get_DataSourceType, dat de interne of externe werkboekconfiguratie van het diagram identificeert. Het gebruik van numerieke literals verwijdert op zichzelf niet het ingesloten werkboek. In dit voorbeeld blijft het werkboek beschikbaar voor categorie‑labels, serienamen en de andere series. Zie Chart Workbook voor werkboekbeheer.
Voor spreidings‑ en bubbel‑diagrammen roept u set_DataSourceTypeForXValues en set_DataSourceTypeForYValues aan om de bronnen voor get_XValue en get_YValue te kiezen. Bubbel‑diagrammen gebruiken ook set_DataSourceTypeForBubbleSizes voor get_BubbleSize. Stel elke toepasselijke bron in op DoubleLiterals vóór u getallen toewijst via de set_AsLiteralDouble‑methode van die waarde.
Overlap van diagramseries instellen
IChartSeries::get_Overlap geeft aan hoeveel balken of kolommen overlappen in een 2D‑diagram, van -100 tot 100 procent. Het is een alleen‑lezen projectie van de instelling op de bovenliggende series‑groeps. Roep IChartSeriesGroup::set_Overlap aan om elke compatibele serie in die groep bij te werken. Deze optie geldt voor diagramtypen die gegroepeerde balken of kolommen weergeven; hij heeft geen invloed op ongerelateerde series‑groepen in een combinatie‑diagram.
Het volgende voorbeeld zet de overlap voor de groep die de eerste serie bevat:
#include <cstdint>
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IChartSeriesGroup.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/shared_ptr.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::Presentation;
const int firstSlideIndex = 0;
const int firstSeriesIndex = 0;
const int8_t overlapPercent = 30;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
// Het nieuwe diagram bevat voorbeeldseries, categorieën en waarden.
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto seriesCollection = chart->get_ChartData()->get_Series();
auto series = seriesCollection->idx_get(firstSeriesIndex);
series->get_ParentSeriesGroup()->set_Overlap(overlapPercent);
presentation->Save(u"series_overlap.pptx", SaveFormat::Pptx);
presentation->Dispose();
Het resultaat:

Vulkleur van de serie wijzigen
Gebruik IChartSeries::get_Format om de standaardvulling voor een volledige serie in te stellen. Als een punt al een expliciete vulling heeft, overschrijft de IChartDataPoint::get_Format instelling de serievulling voor dat punt.
Het volgende voorbeeld past een egale blauwe vulling toe op de eerste serie:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IFormat.h>
#include <DOM/FillType.h>
#include <DOM/IChart.h>
#include <DOM/IColorFormat.h>
#include <DOM/IFillFormat.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <drawing/color.h>
#include <system/shared_ptr.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::FillType;
using Aspose::Slides::Presentation;
using System::Drawing::Color;
const int firstSlideIndex = 0;
const int firstSeriesIndex = 0;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto seriesCollection = chart->get_ChartData()->get_Series();
auto series = seriesCollection->idx_get(firstSeriesIndex);
auto seriesColor = Color::get_Blue();
series->get_Format()->get_Fill()->set_FillType(FillType::Solid);
series->get_Format()->get_Fill()->get_SolidFillColor()->set_Color(seriesColor);
presentation->Save(u"series_color.pptx", SaveFormat::Pptx);
presentation->Dispose();
Het resultaat:

Naam van de serie wijzigen
Een serienaam wordt opgeslagen in het diagram‑werkboek en normaal weergegeven in de legenda. In het standaardwerkboek dat voor een gegroepeerd kolomdiagram wordt aangemaakt, bevindt cel B1 zich op rij 0, kolom 1 en bevat de naam van de eerste serie. De benoemde constanten in het volgende voorbeeld maken die structuur expliciet:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/object_ext.h>
#include <system/shared_ptr.h>
#include <system/string.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::Presentation;
using System::ObjectExt;
using System::String;
const int firstSlideIndex = 0;
const int worksheetIndex = 0;
const int seriesNameRowIndex = 0;
const int firstSeriesColumnIndex = 1;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto workbook = chart->get_ChartData()->get_ChartDataWorkbook();
auto seriesNameCell = workbook->GetCell(worksheetIndex, seriesNameRowIndex, firstSeriesColumnIndex);
auto seriesName = ObjectExt::Box<String>(u"Revenue");
seriesNameCell->set_Value(seriesName);
presentation->Save(u"series_name.pptx", SaveFormat::Pptx);
presentation->Dispose();
U kunt ook de cel die al wordt verwezen door IChartSeries::get_Name bijwerken. Deze benadering voorkomt aannames over een specifieke rij en kolom in een bestaand diagram:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartCellCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IStringChartValue.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/object_ext.h>
#include <system/shared_ptr.h>
#include <system/string.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::Presentation;
using System::ObjectExt;
using System::String;
const int firstSlideIndex = 0;
const int firstSeriesIndex = 0;
const int firstNameCellIndex = 0;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto seriesCollection = chart->get_ChartData()->get_Series();
auto series = seriesCollection->idx_get(firstSeriesIndex);
auto seriesNameCells = series->get_Name()->get_AsCells();
auto seriesNameCell = seriesNameCells->idx_get(firstNameCellIndex);
auto seriesName = ObjectExt::Box<String>(u"Revenue");
seriesNameCell->set_Value(seriesName);
presentation->Save(u"series_name.pptx", SaveFormat::Pptx);
presentation->Dispose();
Het resultaat:

Een serie met een naam uit meerdere cellen maken
Een samengestelde serienaam is handig wanneer een productnaam en een rapportageperiode in aparte werkboekcellen staan. U kunt bijvoorbeeld Product A in B1 en 2026 in C1 combineren tot één serienaam, terwijl beide delen gekoppeld blijven aan hun broncellen.
Gebruik IChartDataWorkbook::GetCellCollection om het naam‑bereik op te halen, en geef die collectie door aan IChartSeriesCollection::Add. Het argument skipHiddenCells bepaalt of verborgen cellen worden meegenomen: true sluit ze uit, false neemt ze op. Dit voorbeeld gebruikt false om elke cel in het naam‑bereik op te nemen.
Het volgende voorbeeld maakt een presentatie met één serie en twee datapunten. Cellen B1:C1 leveren alleen de serienaam; A2:A3 leveren de categorielabels, en B2:B3 leveren de numerieke waarden.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartCategoryCollection.h>
#include <DOM/Chart/IChartCellCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPointCollection.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/object_ext.h>
#include <system/shared_ptr.h>
#include <system/string.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace Aspose::Slides::Export;
using System::ObjectExt;
using System::String;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 50.0f, 50.0f, 620.0f, 180.0f);
auto chartData = chart->get_ChartData();
chartData->get_Series()->Clear();
chartData->get_Categories()->Clear();
chart->set_HasLegend(true);
auto workbook = chartData->get_ChartDataWorkbook();
workbook->Clear(0);
// Deze twee cellen leveren de serienaam.
auto productName = ObjectExt::Box<String>(u"Product A");
auto reportingPeriod = ObjectExt::Box<String>(u"2026");
workbook->GetCell(0, 0, 1, productName);
workbook->GetCell(0, 0, 2, reportingPeriod);
auto nameCells = workbook->GetCellCollection(u"Sheet1!$B$1:$C$1", false);
auto series = chartData->get_Series()->Add(nameCells, ChartType::ClusteredColumn);
// Aparte cellen leveren de categorieën en numerieke datapunten.
auto northLabel = ObjectExt::Box<String>(u"North");
auto southLabel = ObjectExt::Box<String>(u"South");
auto northCategory = workbook->GetCell(0, 1, 0, northLabel);
auto southCategory = workbook->GetCell(0, 2, 0, southLabel);
chartData->get_Categories()->Add(northCategory);
chartData->get_Categories()->Add(southCategory);
auto northAmount = ObjectExt::Box<int>(120);
auto southAmount = ObjectExt::Box<int>(150);
auto northValue = workbook->GetCell(0, 1, 1, northAmount);
auto southValue = workbook->GetCell(0, 2, 1, southAmount);
series->get_DataPoints()->AddDataPointForBarSeries(northValue);
series->get_DataPoints()->AddDataPointForBarSeries(southValue);
presentation->Save(u"composite_series_name.pptx", SaveFormat::Pptx);
presentation->Dispose();
De resulterende serienaam is Product A 2026, met een spatie tussen de twee celwaarden. De legenda toont dit als één item voor beide kolommen. De afbeelding hieronder illustreert het resultaat:

Automatische vulkleur van de serie ophalen
IChartSeries::GetAutomaticSeriesColor retourneert de kleur die op basis van de serievergelijking en de diagramstijl wordt berekend. Dit is de kleur die wordt gebruikt wanneer de serievulling niet expliciet is gedefinieerd. Het aanroepen van de methode leest de berekende kleur; hij wijzigt geen vulling.
Het volgende voorbeeld drukt de automatische kleur van elke standaardserie af:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <drawing/color.h>
#include <system/console.h>
#include <system/shared_ptr.h>
#include <system/string.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Presentation;
using System::Console;
using System::String;
const int firstSlideIndex = 0;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto seriesCollection = chart->get_ChartData()->get_Series();
const int seriesCount = seriesCollection->get_Count();
for (int seriesIndex = 0; seriesIndex < seriesCount; seriesIndex++)
{
auto series = seriesCollection->idx_get(seriesIndex);
auto automaticColor = series->GetAutomaticSeriesColor();
auto colorName = automaticColor.get_Name();
auto outputLine = String::Format(u"Series {0}: {1}", seriesIndex, colorName);
Console::WriteLine(outputLine);
}
presentation->Dispose();
Voorbeeldoutput voor de standaarddiagramstijl:
Series 0: ff4f81bd
Series 1: ffc0504d
Series 2: ff9bbb59
De exacte kleuren hangen af van de diagramstijl en het thema.
Omgekeerde vulkleur voor een diagramserie instellen
Voor balk‑, kolom‑ en bubbel‑series kan IChartSeries::set_InvertIfNegative negatieve waarden met een andere vulling weergeven. Stel de gewone serievulling in op een egale kleur, schakel inversie in, en ken de negatieve‑waarde‑kleur toe via IChartSeries::get_InvertedSolidFillColor. Negatieve getallen blijven ongewijzigd in het werkboek; alleen hun weergavekleur verandert.
Het volgende voorbeeld vervangt de standaarddiagramdata door één serie. Werkbladrij 0 bevat de serienaam, kolom 0 bevat categorienamen, en kolom 1 bevat de waarden:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartCategoryCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPointCollection.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IFormat.h>
#include <DOM/FillType.h>
#include <DOM/IChart.h>
#include <DOM/IColorFormat.h>
#include <DOM/IFillFormat.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <drawing/color.h>
#include <system/object_ext.h>
#include <system/shared_ptr.h>
#include <system/string.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::FillType;
using Aspose::Slides::Presentation;
using System::Drawing::Color;
using System::ObjectExt;
using System::String;
const int firstSlideIndex = 0;
const int worksheetIndex = 0;
const int headerRowIndex = 0;
const int categoryColumnIndex = 0;
const int firstSeriesColumnIndex = 1;
const int firstDataRowIndex = 1;
const int categoryCount = 3;
const String categoryNames[] = {u"Category 1", u"Category 2", u"Category 3"};
const int seriesValues[] = {-20, 50, -30};
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto chartData = chart->get_ChartData();
auto workbook = chartData->get_ChartDataWorkbook();
auto seriesCollection = chartData->get_Series();
seriesCollection->Clear();
chartData->get_Categories()->Clear();
auto seriesName = ObjectExt::Box<String>(u"Series 1");
auto seriesNameCell = workbook->GetCell(worksheetIndex, headerRowIndex, firstSeriesColumnIndex, seriesName);
auto chartType = chart->get_Type();
auto series = seriesCollection->Add(seriesNameCell, chartType);
for (int categoryIndex = 0; categoryIndex < categoryCount; categoryIndex++)
{
const int dataRowIndex = firstDataRowIndex + categoryIndex;
auto categoryName = categoryNames[categoryIndex];
const int seriesValue = seriesValues[categoryIndex];
auto boxedCategoryName = ObjectExt::Box<String>(categoryName);
auto categoryCell = workbook->GetCell(worksheetIndex, dataRowIndex, categoryColumnIndex, boxedCategoryName);
chartData->get_Categories()->Add(categoryCell);
auto boxedSeriesValue = ObjectExt::Box<int>(seriesValue);
auto valueCell = workbook->GetCell(worksheetIndex, dataRowIndex, firstSeriesColumnIndex, boxedSeriesValue);
series->get_DataPoints()->AddDataPointForBarSeries(valueCell);
}
auto automaticSeriesColor = series->GetAutomaticSeriesColor();
auto invertedSeriesColor = Color::get_Red();
series->get_Format()->get_Fill()->set_FillType(FillType::Solid);
series->get_Format()->get_Fill()->get_SolidFillColor()->set_Color(automaticSeriesColor);
series->set_InvertIfNegative(true);
series->get_InvertedSolidFillColor()->set_Color(invertedSeriesColor);
presentation->Save(u"inverted_solid_fill_color.pptx", SaveFormat::Pptx);
presentation->Dispose();
Het resultaat:

U kunt inversie voor één punt inschakelen via IChartDataPoint::set_InvertIfNegative. In het volgende voorbeeld is inversie uitgeschakeld voor de serie en alleen ingeschakeld voor het geselecteerde punt. Het punt krijgt ook een negatieve waarde zodat het effect zichtbaar is:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPoint.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IDoubleChartValue.h>
#include <DOM/Chart/IFormat.h>
#include <DOM/FillType.h>
#include <DOM/IChart.h>
#include <DOM/IColorFormat.h>
#include <DOM/IFillFormat.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <drawing/color.h>
#include <system/object_ext.h>
#include <system/shared_ptr.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::FillType;
using Aspose::Slides::Presentation;
using System::Drawing::Color;
using System::ObjectExt;
const int firstSlideIndex = 0;
const int firstSeriesIndex = 0;
const int targetDataPointIndex = 2;
const int negativeValue = -30;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto seriesCollection = chart->get_ChartData()->get_Series();
auto series = seriesCollection->idx_get(firstSeriesIndex);
auto automaticSeriesColor = series->GetAutomaticSeriesColor();
auto invertedSeriesColor = Color::get_Red();
series->get_Format()->get_Fill()->set_FillType(FillType::Solid);
series->get_Format()->get_Fill()->get_SolidFillColor()->set_Color(automaticSeriesColor);
series->get_InvertedSolidFillColor()->set_Color(invertedSeriesColor);
series->set_InvertIfNegative(false);
auto dataPoint = series->get_DataPoint(targetDataPointIndex);
auto boxedNegativeValue = ObjectExt::Box<int>(negativeValue);
dataPoint->get_YValue()->get_AsCell()->set_Value(boxedNegativeValue);
dataPoint->set_InvertIfNegative(true);
presentation->Save(u"data_point_invert_color_if_negative.pptx", SaveFormat::Pptx);
presentation->Dispose();
Specifieke datapuntwaarde wissen
Om één punt leeg te maken zonder de andere punten te verwijderen, stelt u de onderliggende werkboekcel in op nullptr. Voor een kolomdiagram is de geplotte waarde beschikbaar via IChartDataPoint::get_YValue. Het datapunt blijft op dezelfde categorielocatie, maar het diagram behandelt de waarde als leeg conform de instellingen voor lege waarden.
Het volgende voorbeeld wist alleen het tweede punt in de eerste serie:
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPoint.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IDoubleChartValue.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/shared_ptr.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::Presentation;
const int firstSlideIndex = 0;
const int firstSeriesIndex = 0;
const int targetDataPointIndex = 1;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::ClusteredColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto seriesCollection = chart->get_ChartData()->get_Series();
auto series = seriesCollection->idx_get(firstSeriesIndex);
auto dataPoint = series->get_DataPoint(targetDataPointIndex);
dataPoint->get_YValue()->get_AsCell()->set_Value(nullptr);
presentation->Save(u"clear_data_point_value.pptx", SaveFormat::Pptx);
presentation->Dispose();
Spreidings‑diagrammen gebruiken afzonderlijke X‑ en Y‑cellen, en bubbel‑diagrammen gebruiken ook een grootte‑cel. Wis alleen de cel die de waarde vertegenwoordigt die u wilt verwijderen. Roep IChartDataPointCollection::Clear niet aan wanneer u de andere punten wilt behouden, want die methode verwijdert elk datapunt uit de collectie.
Weergave van lege cellen beheren
Verborgen cellen die waarden bevatten vormen een apart geval van lege cellen. Om data uit verborgen rijen en kolommen van een werkblad op te nemen of uit te sluiten, zie Include Data from Hidden Rows and Columns.
Een lege werkboekcel staat voor ontbrekende data; een cel met 0 staat voor een bekende numerieke waarde. Roep IChartDataCell::set_Value aan met nullptr om een cel leeg te maken. Een numerieke nul blijft een nul ongeacht de instelling voor lege cellen.
Gebruik IChart::set_DisplayBlanksAs om te kiezen hoe het diagram lege cellen weergeeft. Deze instelling geldt voor het gehele diagram. Hij wijzigt hoe lege waarden worden geplot, zonder de lege werkboekcel te vullen met nul of een geïnterpoleerde waarde.
Het volgende zelfstandige voorbeeld maakt een lijndiagram met één serie, wist de waarde voor Dag 3, en slaat hetzelfde diagram op met elke modus. Er is geen invoerbestand nodig. De IChartDataWorkbook gebruikt werkblad 0, kolom 0 voor categorielabels en kolom 1 voor waarden; rij 0 bevat de serienaam. De uiteindelijke data is 10, 20, empty, 30, 40.
#include <array>
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/DisplayBlanksAsType.h>
#include <DOM/Chart/IChartCategoryCollection.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartDataCell.h>
#include <DOM/Chart/IChartDataPointCollection.h>
#include <DOM/Chart/IChartDataWorkbook.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/object_ext.h>
#include <system/shared_ptr.h>
#include <system/string.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace Aspose::Slides::Export;
using System::ObjectExt;
using System::String;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::LineWithMarkers, 40.0f, 40.0f, 640.0f, 400.0f);
auto chartData = chart->get_ChartData();
auto workbook = chartData->get_ChartDataWorkbook();
chartData->get_Series()->Clear();
chartData->get_Categories()->Clear();
auto seriesName = ObjectExt::Box<String>(u"Measurements");
auto seriesNameCell = workbook->GetCell(0, 0, 1, seriesName);
auto series = chartData->get_Series()->Add(seriesNameCell, chart->get_Type());
auto values = std::array<int, 5>{10, 20, 25, 30, 40};
for (auto i = 0; i < values.size(); i++)
{
auto categoryName = String::Format(u"Day {0}", i + 1);
auto boxedCategoryName = ObjectExt::Box<String>(categoryName);
auto categoryCell = workbook->GetCell(0, i + 1, 0, boxedCategoryName);
chartData->get_Categories()->Add(categoryCell);
auto boxedValue = ObjectExt::Box<int>(values[i]);
auto valueCell = workbook->GetCell(0, i + 1, 1, boxedValue);
series->get_DataPoints()->AddDataPointForLineSeries(valueCell);
}
// Laat dag 3 echt leeg, terwijl de categorie en datapunt behouden blijven.
workbook->GetCell(0, 3, 1)->set_Value(nullptr);
auto modes = std::array<DisplayBlanksAsType, 3>{DisplayBlanksAsType::Gap, DisplayBlanksAsType::Zero, DisplayBlanksAsType::Span};
for (auto mode : modes)
{
chart->set_DisplayBlanksAs(mode);
auto outputPath = String::Format(u"empty_cells_{0}.pptx", mode);
presentation->Save(outputPath, SaveFormat::Pptx);
}
presentation->Dispose();
Elk uitvoerbestand bevat de modus die vóór het opslaan is ingesteld: empty_cells_Gap.pptx, empty_cells_Zero.pptx en empty_cells_Span.pptx. Om slechts één versie op te slaan, stelt u de gewenste modus in en slaat u de presentatie één keer op in plaats van de modi te itereren.
De vergelijking hieronder toont dezelfde data in alle drie de bestanden. Dag 3 is in elk geval leeg in het werkboek:

Het zichtbare effect hangt af van het diagramtype. Een lijndiagram maakt alle drie de modi makkelijk te vergelijken. Balk‑ en kolom‑diagrammen hebben geen lijn om een ontbrekende categorie te verbinden, dus Span kan het verbindingssegment niet produceren dat hierboven wordt getoond; een ontbrekende kolom en een kolom met nul‑hoogte kunnen ook op elkaar lijken. Evenzo heeft een spreidings‑diagram met alleen markers geen verbindingslijn. Verwacht geen drie verschillende resultaten voor elk diagramtype; controleer de output voor het type dat u gebruikt.
Gatbreedte van de serie instellen
De gatbreedte is de ruimte tussen aangrenzende balk‑ of kolomclusters, uitgedrukt als een percentage van de balk‑ of kolombreedte. Net als overlap behoort hij tot de bovenliggende series‑groep en niet tot één enkele serie. Roep IChartSeriesGroup::set_GapWidth één keer voor de groep aan. Een hogere waarde creëert meer ruimte tussen clusters; een lagere waarde maakt ze dichter op elkaar.
Het volgende voorbeeld wijzigt de gatbreedte en slaat alleen de uiteindelijke presentatie op:
#include <cstdint>
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IChartSeriesGroup.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/shared_ptr.h>
using Aspose::Slides::Charts::ChartType;
using Aspose::Slides::Export::SaveFormat;
using Aspose::Slides::Presentation;
const int firstSlideIndex = 0;
const int firstSeriesIndex = 0;
const uint16_t gapWidthPercent = 30;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(firstSlideIndex);
auto chart = slide->get_Shapes()->AddChart(ChartType::StackedColumn, 20.0f, 20.0f, 500.0f, 200.0f);
auto seriesCollection = chart->get_ChartData()->get_Series();
auto series = seriesCollection->idx_get(firstSeriesIndex);
series->get_ParentSeriesGroup()->set_GapWidth(gapWidthPercent);
presentation->Save(u"gap_width_30.pptx", SaveFormat::Pptx);
presentation->Dispose();
Het resultaat:

Serieslijnen weergeven of verbergen
Serieslijnen verbinden visueel gerelateerde delen van een diagram. Gebruik IChartSeriesGroup::set_HasSeriesLines om ze weer te geven of te verbergen in ondersteunde gestapelde balk‑ en ForPie‑diagrammen. In tweedimensionale gestapelde balk‑ en kolomdiagrammen verbinden ze de overeenkomende stapelgrenzen over categorieën heen. In Pie of Pie‑ en Bar of Pie‑diagrammen verbinden ze het hoofd‑plot met het secundaire plot. Deze instelling is geen algemene connector voor andere diagramtypen.
Toegang tot de groep krijgt u via IChartSeries::get_ParentSeriesGroup. De instelling geldt voor elke serie in die groep. IChartSeries::get_HasSeriesLines leest alleen de waarde en geeft de instelling van de bovenliggende groep weer; roep de groep‑setter aan om deze bij te werken.
Het volgende voorbeeld maakt één ChartType::PieOfPie diagram met standaarddata. Het slaat hetzelfde diagram op met serieslijnen ingeschakeld en daarna uitgeschakeld, waardoor twee presentaties voor vergelijking ontstaan.
#include <DOM/Chart/ChartType.h>
#include <DOM/Chart/IChartData.h>
#include <DOM/Chart/IChartSeries.h>
#include <DOM/Chart/IChartSeriesCollection.h>
#include <DOM/Chart/IChartSeriesGroup.h>
#include <DOM/IChart.h>
#include <DOM/IShapeCollection.h>
#include <DOM/ISlide.h>
#include <DOM/Presentation.h>
#include <Export/SaveFormat.h>
#include <system/shared_ptr.h>
using namespace Aspose::Slides;
using namespace Aspose::Slides::Charts;
using namespace Aspose::Slides::Export;
auto presentation = System::MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);
auto chart = slide->get_Shapes()->AddChart(ChartType::PieOfPie, 50, 50, 600, 400);
auto series = chart->get_ChartData()->get_Series()->idx_get(0);
auto seriesGroup = series->get_ParentSeriesGroup();
seriesGroup->set_HasSeriesLines(true);
presentation->Save(u"series_lines_enabled.pptx", SaveFormat::Pptx);
seriesGroup->set_HasSeriesLines(false);
presentation->Save(u"series_lines_disabled.pptx", SaveFormat::Pptx);
presentation->Dispose();
| Series lines enabled | Series lines disabled |
|---|---|
![]() |
![]() |
| De twee lijnen verbinden de hoofd‑pie met de secundaire pie. | Beide pies blijven zichtbaar, maar de verbindingslijnen zijn verborgen. |
Serieslijnen verschillen van leiderslijnen voor gegevenslabels, die labels verbinden met hun datapunten; rasterlijnen, die intervallen langs de assen markeren; en de lijnen in een lijndiagram, die de gegevenswaarden representeren. Deze instelling beheert die elementen niet.
FAQ
Welke diagramtypen ondersteunen dataseries?
Alle diagramtypen die worden vertegenwoordigd door de ChartType enumeratie gebruiken diagramdata, maar hun series hebben niet allemaal dezelfde waardestructuur of instellingen. Bijvoorbeeld, categorie‑diagrammen gebruiken categorieën en waarden, spreidings‑diagrammen gebruiken X‑ en Y‑waarden, en bubbel‑diagrammen voegen bubbelformaten toe. Gebruik de methode voor het aanmaken van datapunten die overeenkomt met het serietype. Opties zoals overlap en gatbreedte gelden alleen voor compatibele balk‑ of kolomgroepen.
Wat is een diagram‑seriegroep?
Een IChartSeriesGroup bevat compatibele series die groeps‑niveau plotinstellingen delen. Een combinatie‑diagram kan meer dan één groep bevatten, zodat het wijzigen van de groep die via één serie wordt bereikt, niet per se elke serie in het diagram wijzigt.
Bevat een nieuw aangemaakt diagram standaarddata?
Ja. Standaard maakt IShapeCollection::AddChart voorbeeldseries, categorieën en waarden aan. U kunt die cellen bewerken of zowel de series‑ als categorieverzamelingen wissen voordat u een volledig aangepaste dataset toevoegt. Een overload kan ook een diagram zonder standaarddata aanmaken.
Hoe zijn diagramobjecten gekoppeld aan werkboekcellen?
Serienamen, categorielabels en datapunten‑waarden verwijzen naar cellen in een IChartDataWorkbook. Het wijzigen van een verwezen cel werkt het overeenkomstige diagramonderdeel bij. Wanneer u aangepaste data bouwt, houd de rijen voor categorieën en series‑waardes op elkaar afgestemd, zodat elk punt onder de juiste categorie wordt geplot.
Hoe maak ik één punt leeg in plaats van de hele serie?
Stel de betreffende waardecel in op nullptr om de positie van het punt in de categorie te behouden als een leeg punt. Roep IChartDataPointCollection::Clear alleen aan wanneer u alle punten uit die serie wilt verwijderen. Als u ook categorieën verwijdert, werk dan elke serie bij zodat hun waarden blijven overeenkomen met de categorieverzameling.
Hoe worden lege punten weergegeven?
Het resultaat hangt af van het diagramtype en IChart::get_DisplayBlanksAs. Ondersteunde diagrammen kunnen lege waarden weergeven als gaten, als nulwaarden, of door aangrenzende punten te verbinden. Kies de instelling die past bij de betekenis van ontbrekende data in uw presentatie. Zie Control the Display of Empty Cells voor een volledig voorbeeld en visueel vergelijk.
Hoe worden negatieve waarden opgemaakt?
Voor ondersteunde balk‑, kolom‑ en bubbel‑series roept u IChartSeries::set_InvertIfNegative aan en stelt de kleur in via IChartSeries::get_InvertedSolidFillColor. U kunt het gedrag voor een individueel punt overschrijven met IChartDataPoint::set_InvertIfNegative. Deze methoden beïnvloeden de opmaak, niet de opgeslagen numerieke waarden.
Welke opmaak wint wanneer zowel een serie als een punt zijn opgemaakt?
Expliciete datapunt‑opmaak heeft voorrang voor dat punt. Andere punten blijven de expliciete serie‑opmaak gebruiken of, wanneer de serie‑opmaak niet is gedefinieerd, de automatische diagramstijl en het thema. Groepsinstellingen zoals overlap en gatbreedte regelen de lay‑out en zijn geen overrides op punt‑niveau.
Is er een limiet aan het aantal series dat een diagram kan bevatten?
Aspose.Slides legt geen aparte vaste limiet op voor het aantal series. In de praktijk bepalen bestandslimieten van de presentatie, beschikbaar geheugen, render‑tijd en de leesbaarheid van het diagram de praktische limiet.
Wat moet ik aanpassen wanneer kolommen te dicht bij elkaar staan of te ver uit elkaar?
Roep IChartSeriesGroup::set_GapWidth aan op de juiste bovenliggende series‑groep. Verhoog de waarde om de ruimte tussen clusters te vergroten, of verlaag deze om de clusters dichter bij elkaar te brengen.

