### Manage TimeSeries and TimeSeriesCollection

Source: https://context7.com/jfree/jfreechart/llms.txt

Shows how to handle time-based data using various period types like Day, Month, and Hour. Includes examples of rolling windows and adding/updating data points.

```java
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.time.Day;
import org.jfree.data.time.Month;
import org.jfree.data.time.Hour;

TimeSeries<String> daily = new TimeSeries<>("Daily Sales");
daily.add(new Day(1, 1, 2024), 100.0);
daily.add(new Day(2, 1, 2024), 120.0);
daily.add(new Day(3, 1, 2024), 95.0);

TimeSeries<String> monthly = new TimeSeries<>("Monthly Revenue");
monthly.add(new Month(1, 2024), 15000.0);
monthly.add(new Month(2, 2024), 18000.0);

TimeSeries<String> hourly = new TimeSeries<>("Hourly Traffic");
hourly.add(new Hour(9, new Day(1, 1, 2024)), 250);
hourly.add(new Hour(10, new Day(1, 1, 2024)), 320);

daily.setMaximumItemCount(30);
daily.addOrUpdate(new Day(1, 1, 2024), 105.0);

TimeSeriesCollection<String> collection = new TimeSeriesCollection<>();
collection.addSeries(daily);
collection.addSeries(monthly);
```

--------------------------------

### Build JFreeChart with Maven

Source: https://github.com/jfree/jfreechart/blob/master/README.md

Execute this command in the project root directory to clean and compile the JFreeChart library. This requires JDK 11 or later installed on your system.

```bash
mvn clean install
```

--------------------------------

### Creating a Scatter Plot

Source: https://context7.com/jfree/jfreechart/llms.txt

Provides an example of creating a scatter plot to visualize the relationship between two variables using `ChartFactory.createScatterPlot()`.

```APIDOC
## Creating a Scatter Plot

### Description
The `ChartFactory.createScatterPlot()` method generates scatter plots for displaying correlation between two variables using `XYSeriesCollection`.

### Method
`ChartFactory.createScatterPlot()`

### Parameters
- `title` (String) - The chart's title.
- `domainAxisLabel` (String) - The label for the domain (X) axis.
- `rangeAxisLabel` (String) - The label for the range (Y) axis.
- `dataset` (XYDataset) - The dataset containing the XY data points.
- `orientation` (PlotOrientation) - The plot orientation (e.g., VERTICAL).
- `legend` (boolean) - Whether to display the legend.
- `tooltips` (boolean) - Whether to display tooltips.
- `urls` (boolean) - Whether to display URLs.

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;

XYSeries series = new XYSeries<>("Height vs Weight");
series.add(165, 60);
series.add(170, 68);
series.add(175, 72);
series.add(168, 65);
series.add(180, 80);
series.add(172, 70);
series.add(178, 75);
series.add(185, 85);

XYSeriesCollection dataset = new XYSeriesCollection<>();
dataset.addSeries(series);

JFreeChart chart = ChartFactory.createScatterPlot(
    "Height vs Weight Correlation",  // title
    "Height (cm)",                   // x-axis label
    "Weight (kg)",                   // y-axis label
    dataset,                         // dataset
    PlotOrientation.VERTICAL,        // orientation
    true, true, false                // legend, tooltips, URLs
);
```

### Response
#### Success Response (200)
- `JFreeChart` (Object) - The created scatter plot object.

#### Response Example
(The response is a `JFreeChart` object, not a JSON response.)
```

--------------------------------

### Manage Data with DefaultCategoryDataset

Source: https://context7.com/jfree/jfreechart/llms.txt

Provides examples for manipulating DefaultCategoryDataset, including adding values, incrementing existing data, querying dataset dimensions, and removing entries.

```java
import org.jfree.data.category.DefaultCategoryDataset;

DefaultCategoryDataset<String, String> dataset = new DefaultCategoryDataset<>();

dataset.addValue(10.0, "Series 1", "Category A");
dataset.addValue(15.0, "Series 1", "Category B");
dataset.addValue(20.0, "Series 1", "Category C");
dataset.addValue(12.0, "Series 2", "Category A");
dataset.addValue(18.0, "Series 2", "Category B");
dataset.addValue(8.0, "Series 2", "Category C");

dataset.incrementValue(5.0, "Series 1", "Category A");

Number value = dataset.getValue("Series 1", "Category A");
int rowCount = dataset.getRowCount();
int colCount = dataset.getColumnCount();

dataset.removeValue("Series 2", "Category C");
dataset.removeRow("Series 2");
dataset.removeColumn("Category C");
dataset.clear();
```

--------------------------------

### Write Chart to OutputStream (PNG/JPEG)

Source: https://context7.com/jfree/jfreechart/llms.txt

Provides examples of writing JFreeCharts directly to an OutputStream using ChartUtils.writeChartAsPNG and ChartUtils.writeChartAsJPEG. This is useful for web applications where charts are sent directly in the HTTP response.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Data", 100);

JFreeChart chart = ChartFactory.createPieChart("Chart", dataset);

// Write to any OutputStream (e.g., servlet response)
ByteArrayOutputStream out = new ByteArrayOutputStream();
ChartUtils.writeChartAsPNG(out, chart, 640, 480);
byte[] pngBytes = out.toByteArray();

// Write JPEG with quality
ByteArrayOutputStream jpegOut = new ByteArrayOutputStream();
ChartUtils.writeChartAsJPEG(jpegOut, 0.9f, chart, 640, 480);
```

--------------------------------

### Creating a Line Chart

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates how to create a basic line chart for visualizing trends over categories using `ChartFactory.createLineChart()`.

```APIDOC
## Creating a Line Chart

### Description
The `ChartFactory.createLineChart()` method creates line charts for visualizing trends over categories. It uses `LineAndShapeRenderer` to draw connecting lines between data points.

### Method
`ChartFactory.createLineChart()`

### Parameters
- `title` (String) - The chart's title.
- `categoryAxisLabel` (String) - The label for the category axis.
- `valueAxisLabel` (String) - The label for the value axis.
- `dataset` (CategoryDataset) - The dataset containing the data for the chart.
- `orientation` (PlotOrientation) - The plot orientation (e.g., VERTICAL).
- `legend` (boolean) - Whether to display the legend.
- `tooltips` (boolean) - Whether to display tooltips.
- `urls` (boolean) - Whether to display URLs.

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;

DefaultCategoryDataset<String, String> dataset = new DefaultCategoryDataset<>();
dataset.addValue(100, "Product A", "Jan");
dataset.addValue(120, "Product A", "Feb");
dataset.addValue(115, "Product A", "Mar");
dataset.addValue(140, "Product A", "Apr");
dataset.addValue(80, "Product B", "Jan");
dataset.addValue(95, "Product B", "Feb");
dataset.addValue(110, "Product B", "Mar");
dataset.addValue(125, "Product B", "Apr");

JFreeChart chart = ChartFactory.createLineChart(
    "Monthly Sales Trend",     // title
    "Month",                   // category axis label
    "Units Sold",              // value axis label
    dataset,                   // dataset
    PlotOrientation.VERTICAL,  // orientation
    true, true, false          // legend, tooltips, URLs
);
```

### Response
#### Success Response (200)
- `JFreeChart` (Object) - The created line chart object.

#### Response Example
(The response is a `JFreeChart` object, not a JSON response.)
```

--------------------------------

### Manage XYSeries and XYSeriesCollection

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates how to create, populate, and manipulate XY data series. It covers both sorted and unsorted series, data access, and grouping multiple series into a collection.

```java
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.jfree.data.xy.XYDataItem;

XYSeries<String> series = new XYSeries<>("Temperature");
series.add(0.0, 20.5);
series.add(1.0, 21.2);
series.add(2.0, 22.1);
series.add(3.0, 21.8);

XYSeries<String> unsorted = new XYSeries<>("Raw Data", false, true);
unsorted.add(1.0, 10.0);
unsorted.add(1.0, 12.0);

int count = series.getItemCount();
double x = series.getX(0).doubleValue();
double y = series.getY(0).doubleValue();
XYDataItem item = series.getDataItem(0);

series.updateByIndex(0, 19.5);
series.delete(0, 1);
series.clear();

XYSeriesCollection<String> collection = new XYSeriesCollection<>();
collection.addSeries(new XYSeries<>("Series A"));
collection.addSeries(new XYSeries<>("Series B"));
int seriesCount = collection.getSeriesCount();
```

--------------------------------

### Apply Global Chart Themes

Source: https://context7.com/jfree/jfreechart/llms.txt

Shows how to configure a StandardChartTheme with specific fonts and colors, then apply it globally using ChartFactory. This ensures all subsequently created charts share a consistent visual style.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.StandardChartTheme;
import org.jfree.data.general.DefaultPieDataset;
import java.awt.Color;
import java.awt.Font;

StandardChartTheme theme = new StandardChartTheme("Custom");
theme.setTitlePaint(Color.DARK_GRAY);
theme.setSubtitlePaint(Color.GRAY);
theme.setChartBackgroundPaint(Color.WHITE);
theme.setPlotBackgroundPaint(new Color(240, 240, 240));
theme.setExtraLargeFont(new Font("SansSerif", Font.BOLD, 20));
theme.setLargeFont(new Font("SansSerif", Font.BOLD, 14));
theme.setRegularFont(new Font("SansSerif", Font.PLAIN, 12));

ChartFactory.setChartTheme(theme);

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("A", 50);
dataset.setValue("B", 50);
JFreeChart chart = ChartFactory.createPieChart("Themed Chart", dataset);
```

--------------------------------

### Create Pie Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates how to initialize a DefaultPieDataset and use ChartFactory to generate a pie chart. The resulting chart is saved as a PNG file using ChartUtils.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
import java.io.File;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Java", 43.2);
dataset.setValue("Python", 35.8);
dataset.setValue("JavaScript", 12.5);
dataset.setValue("Other", 8.5);

JFreeChart chart = ChartFactory.createPieChart(
    "Programming Language Usage",
    dataset,
    true,
    true,
    false
);

ChartUtils.saveChartAsPNG(new File("languages-pie.png"), chart, 600, 400);
```

--------------------------------

### Creating an XY Line Chart with XYSeries

Source: https://context7.com/jfree/jfreechart/llms.txt

Illustrates how to generate an XY line chart for continuous numeric data using `ChartFactory.createXYLineChart()` and `XYSeriesCollection`.

```APIDOC
## Creating an XY Line Chart with XYSeries

### Description
The `ChartFactory.createXYLineChart()` method creates XY line charts using `XYSeriesCollection`. This is ideal for continuous data where both axes represent numeric values.

### Method
`ChartFactory.createXYLineChart()`

### Parameters
- `title` (String) - The chart's title.
- `domainAxisLabel` (String) - The label for the domain (X) axis.
- `rangeAxisLabel` (String) - The label for the range (Y) axis.
- `dataset` (XYDataset) - The dataset containing the XY data points.
- `orientation` (PlotOrientation) - The plot orientation (e.g., VERTICAL).
- `legend` (boolean) - Whether to display the legend.
- `tooltips` (boolean) - Whether to display tooltips.
- `urls` (boolean) - Whether to display URLs.

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;

// Create XY series with (x, y) data points
XYSeries series1 = new XYSeries<>("Sensor 1");
series1.add(0.0, 1.2);
series1.add(1.0, 2.4);
series1.add(2.0, 1.8);
series1.add(3.0, 3.1);
series1.add(4.0, 2.9);

XYSeries series2 = new XYSeries<>("Sensor 2");
series2.add(0.0, 0.8);
series2.add(1.0, 1.5);
series2.add(2.0, 2.2);
series2.add(3.0, 2.8);
series2.add(4.0, 3.5);

// Combine series into collection
XYSeriesCollection dataset = new XYSeriesCollection<>();
dataset.addSeries(series1);
dataset.addSeries(series2);

JFreeChart chart = ChartFactory.createXYLineChart(
    "Sensor Readings",          // title
    "Time (seconds)",           // x-axis label
    "Value",                    // y-axis label
    dataset,                    // dataset
    PlotOrientation.VERTICAL,   // orientation
    true, true, false           // legend, tooltips, URLs
);
```

### Response
#### Success Response (200)
- `JFreeChart` (Object) - The created XY line chart object.

#### Response Example
(The response is a `JFreeChart` object, not a JSON response.)
```

--------------------------------

### Creating a Time Series Chart

Source: https://context7.com/jfree/jfreechart/llms.txt

Shows how to create a time series chart suitable for date-based data using `ChartFactory.createTimeSeriesChart()`.

```APIDOC
## Creating a Time Series Chart

### Description
The `ChartFactory.createTimeSeriesChart()` method creates charts with a DateAxis for time-based data using `TimeSeries` and `TimeSeriesCollection`.

### Method
`ChartFactory.createTimeSeriesChart()`

### Parameters
- `title` (String) - The chart's title.
- `timeAxisLabel` (String) - The label for the time (X) axis.
- `valueAxisLabel` (String) - The label for the value (Y) axis.
- `dataset` (TimeSeriesCollection) - The dataset containing the time series data.
- `legend` (boolean) - Whether to display the legend.
- `tooltips` (boolean) - Whether to display tooltips.
- `urls` (boolean) - Whether to display URLs.

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.time.Day;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;

// Create time series with daily data
TimeSeries<String> series = new TimeSeries<>("Stock Price");
series.add(new Day(1, 1, 2024), 150.25);
series.add(new Day(2, 1, 2024), 152.40);
series.add(new Day(3, 1, 2024), 151.80);
series.add(new Day(4, 1, 2024), 155.10);
series.add(new Day(5, 1, 2024), 158.30);
series.add(new Day(8, 1, 2024), 157.20);
series.add(new Day(9, 1, 2024), 160.45);

TimeSeriesCollection dataset = new TimeSeriesCollection<>();
dataset.addSeries(series);

JFreeChart chart = ChartFactory.createTimeSeriesChart(
    "Stock Price History",  // title
    "Date",                 // x-axis label
    "Price ($)",            // y-axis label
    dataset,                // dataset
    true, true, false       // legend, tooltips, URLs
);
```

### Response
#### Success Response (200)
- `JFreeChart` (Object) - The created time series chart object.

#### Response Example
(The response is a `JFreeChart` object, not a JSON response.)
```

--------------------------------

### Creating a Candlestick Chart

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates how to create a candlestick chart using OHLCDataset for financial data visualization.

```APIDOC
## Creating a Candlestick Chart

### Description
The `ChartFactory.createCandlestickChart()` method creates financial candlestick charts from `OHLCDataset` for displaying open-high-low-close data.

### Method
`ChartFactory.createCandlestickChart()`

### Parameters
- `title` (String) - The title of the chart.
- `timeAxisLabel` (String) - The label for the time axis.
- `valueAxisLabel` (String) - The label for the value axis.
- `dataset` (OHLCDataset) - The dataset containing the financial data.
- `legend` (boolean) - Whether to display the legend.

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.xy.DefaultOHLCDataset;
import org.jfree.data.xy.OHLCDataItem;
import java.util.Date;

// Create OHLC data items (date, open, high, low, close, volume)
Date[] dates = {new Date(124, 0, 1), new Date(124, 0, 2), new Date(124, 0, 3)};
OHLCDataItem[] items = {
    new OHLCDataItem(dates[0], 100.0, 105.0, 98.0, 103.0, 1000000),
    new OHLCDataItem(dates[1], 103.0, 108.0, 101.0, 106.0, 1200000),
    new OHLCDataItem(dates[2], 106.0, 110.0, 104.0, 108.0, 1100000)
};

DefaultOHLCDataset dataset = new DefaultOHLCDataset("STOCK", items);

JFreeChart chart = ChartFactory.createCandlestickChart(
    "Stock Price",     // title
    "Date",            // time axis label
    "Price ($)",       // value axis label
    dataset,           // dataset
    true               // legend
);
```

### Response
- `JFreeChart` - The created candlestick chart object.
```

--------------------------------

### Create Gantt Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Generates a Gantt chart for project scheduling. Requires JFreeChart library and a TaskSeriesCollection.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.gantt.Task;
import org.jfree.data.gantt.TaskSeries;
import org.jfree.data.gantt.TaskSeriesCollection;
import org.jfree.data.time.SimpleTimePeriod;
import java.util.Date;
import java.util.Calendar;

// Helper to create dates
Calendar cal = Calendar.getInstance();
cal.set(2024, Calendar.JANUARY, 1);
Date jan1 = cal.getTime();
cal.set(2024, Calendar.JANUARY, 15);
Date jan15 = cal.getTime();
cal.set(2024, Calendar.FEBRUARY, 1);
Date feb1 = cal.getTime();
cal.set(2024, Calendar.FEBRUARY, 28);
Date feb28 = cal.getTime();
cal.set(2024, Calendar.MARCH, 15);
Date mar15 = cal.getTime();

TaskSeries series = new TaskSeries("Project Phases");
series.add(new Task("Planning", new SimpleTimePeriod(jan1, jan15)));
series.add(new Task("Development", new SimpleTimePeriod(jan15, feb28)));
series.add(new Task("Testing", new SimpleTimePeriod(feb1, mar15)));

TaskSeriesCollection dataset = new TaskSeriesCollection();
dataset.add(series);

JFreeChart chart = ChartFactory.createGanttChart(
    "Project Schedule",  // title
    "Task",              // category axis label
    "Date",              // date axis label
    dataset,             // dataset
    true, true, false    // legend, tooltips, URLs
);
```

--------------------------------

### Create Line Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates how to use ChartFactory.createLineChart to visualize categorical trends. It utilizes DefaultCategoryDataset to manage data points across multiple categories.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;

DefaultCategoryDataset<String, String> dataset = new DefaultCategoryDataset<>();
dataset.addValue(100, "Product A", "Jan");
dataset.addValue(120, "Product A", "Feb");
dataset.addValue(115, "Product A", "Mar");
dataset.addValue(140, "Product A", "Apr");
dataset.addValue(80, "Product B", "Jan");
dataset.addValue(95, "Product B", "Feb");
dataset.addValue(110, "Product B", "Mar");
dataset.addValue(125, "Product B", "Apr");

JFreeChart chart = ChartFactory.createLineChart(
    "Monthly Sales Trend",
    "Month",
    "Units Sold",
    dataset,
    PlotOrientation.VERTICAL,
    true, true, false
);
```

--------------------------------

### Generate HTML Image Maps for Interactivity

Source: https://context7.com/jfree/jfreechart/llms.txt

Explains how to capture rendering information during chart export to generate an HTML image map. This allows for tooltips or clickable areas when the chart is embedded in a web page.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartRenderingInfo;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
import java.io.File;
import java.io.PrintWriter;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Java", 45);
dataset.setValue("Python", 35);
dataset.setValue("JavaScript", 20);

JFreeChart chart = ChartFactory.createPieChart("Languages", dataset, true, true, true);

ChartRenderingInfo info = new ChartRenderingInfo();
ChartUtils.saveChartAsPNG(new File("chart.png"), chart, 600, 400, info);

String imageMap = ChartUtils.getImageMap("chartMap", info);
System.out.println(imageMap);
```

--------------------------------

### Create Ring (Donut) Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Generates a donut-style pie chart with a hollow center. Requires JFreeChart library and a PieDataset.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Marketing", 25.0);
dataset.setValue("Development", 40.0);
dataset.setValue("Operations", 20.0);
dataset.setValue("Admin", 15.0);

JFreeChart chart = ChartFactory.createRingChart(
    "Budget Allocation",  // title
    dataset,              // dataset
    true,                 // include legend
    true,                 // tooltips
    false                 // URLs
);
```

--------------------------------

### ChartFactory.createPieChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Generates a standard pie chart from a dataset.

```APIDOC
## METHOD ChartFactory.createPieChart

### Description
Creates a pie chart from a DefaultPieDataset. The chart automatically generates labels, tooltips, and legends based on the dataset keys and values.

### Parameters
- **title** (String) - Required - The chart title.
- **dataset** (DefaultPieDataset) - Required - The data to visualize.
- **legend** (boolean) - Required - Whether to include a legend.
- **tooltips** (boolean) - Required - Whether to generate tooltips.
- **urls** (boolean) - Required - Whether to generate URLs.

### Request Example
DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Java", 43.2);

### Response
- **JFreeChart** (Object) - Returns a configured JFreeChart instance.
```

--------------------------------

### Writing Charts to Output Streams

Source: https://context7.com/jfree/jfreechart/llms.txt

Covers writing charts directly to output streams, suitable for web applications.

```APIDOC
## Writing Charts to Output Streams

### Description
The `ChartUtils.writeChartAsPNG()` and `writeChartAsJPEG()` methods write charts directly to output streams for web applications.

### Method
`ChartUtils.writeChartAsPNG()` and `ChartUtils.writeChartAsJPEG()`

### Parameters
- `outputStream` (OutputStream) - The output stream to write the chart to.
- `chart` (JFreeChart) - The chart to write.
- `width` (int) - The width of the generated image.
- `height` (int) - The height of the generated image.
- `quality` (float, optional for JPEG) - The JPEG quality (0.0f to 1.0f).

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
import java.io.ByteArrayOutputStream;
import java.io.OutputStream;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Data", 100);

JFreeChart chart = ChartFactory.createPieChart("Chart", dataset);

// Write to any OutputStream (e.g., servlet response)
ByteArrayOutputStream out = new ByteArrayOutputStream();
ChartUtils.writeChartAsPNG(out, chart, 640, 480);
byte[] pngBytes = out.toByteArray();

// Write JPEG with quality
ByteArrayOutputStream jpegOut = new ByteArrayOutputStream();
ChartUtils.writeChartAsJPEG(jpegOut, 0.9f, chart, 640, 480);
```

### Response
These methods write the chart data to the provided `OutputStream`. An `IOException` may be thrown if there are issues writing to the stream.
```

--------------------------------

### Create Stacked Bar Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Illustrates the creation of a stacked bar chart to visualize part-to-whole relationships over time. It uses DefaultCategoryDataset to organize data by series and categories.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;

DefaultCategoryDataset<String, String> dataset = new DefaultCategoryDataset<>();
dataset.addValue(40, "Desktop", "2021");
dataset.addValue(35, "Desktop", "2022");
dataset.addValue(30, "Desktop", "2023");
dataset.addValue(45, "Mobile", "2021");
dataset.addValue(55, "Mobile", "2022");
dataset.addValue(60, "Mobile", "2023");
dataset.addValue(15, "Tablet", "2021");
dataset.addValue(10, "Tablet", "2022");
dataset.addValue(10, "Tablet", "2023");

JFreeChart chart = ChartFactory.createStackedBarChart(
    "Device Usage by Year",
    "Year",
    "Percentage",
    dataset,
    PlotOrientation.VERTICAL,
    true, true, false
);
```

--------------------------------

### Saving Charts to PNG

Source: https://context7.com/jfree/jfreechart/llms.txt

Explains how to save JFreeChart charts to PNG image files with various options.

```APIDOC
## Saving Charts to PNG

### Description
The `ChartUtils.saveChartAsPNG()` method exports a chart to PNG format at the specified dimensions.

### Method
`ChartUtils.saveChartAsPNG()`

### Parameters
- `file` (File) - The file to save the chart to.
- `chart` (JFreeChart) - The chart to save.
- `width` (int) - The width of the generated image.
- `height` (int) - The height of the generated image.
- `renderingInfo` (ChartRenderingInfo, optional) - Information about the rendering process.
- `encodeAlpha` (boolean, optional) - Whether to encode the alpha channel.
- `compressionLevel` (int, optional) - The compression level (0-9).

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartRenderingInfo;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
import java.io.File;
import java.io.IOException;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Category A", 40);
dataset.setValue("Category B", 35);
dataset.setValue("Category C", 25);

JFreeChart chart = ChartFactory.createPieChart("Sample", dataset);

// Simple save
ChartUtils.saveChartAsPNG(new File("chart.png"), chart, 800, 600);

// Save with rendering info for image maps
ChartRenderingInfo info = new ChartRenderingInfo();
ChartUtils.saveChartAsPNG(new File("chart-with-info.png"), chart, 800, 600, info);

// Save with alpha and compression control
ChartUtils.saveChartAsPNG(
    new File("chart-compressed.png"),
    chart, 800, 600, info,
    true,   // encode alpha channel
    9       // compression level (0-9)
);
```

### Response
This method does not return a value but saves the chart to the specified file. An `IOException` may be thrown if there are issues writing the file.
```

--------------------------------

### Create Bar Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Shows the creation of a vertical bar chart using DefaultCategoryDataset. It demonstrates mapping multiple series to categories and exporting the output to a PNG file.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;
import java.io.File;

DefaultCategoryDataset<String, String> dataset = new DefaultCategoryDataset<>();
dataset.addValue(186.0, "Sales", "Q1");
dataset.addValue(210.0, "Sales", "Q2");
dataset.addValue(195.0, "Sales", "Q3");
dataset.addValue(245.0, "Sales", "Q4");
dataset.addValue(150.0, "Expenses", "Q1");
dataset.addValue(165.0, "Expenses", "Q2");
dataset.addValue(180.0, "Expenses", "Q3");
dataset.addValue(190.0, "Expenses", "Q4");

JFreeChart chart = ChartFactory.createBarChart(
    "Quarterly Financial Summary",
    "Quarter",
    "Amount ($K)",
    dataset,
    PlotOrientation.VERTICAL,
    true,
    true,
    false
);

ChartUtils.saveChartAsPNG(new File("quarterly-bar.png"), chart, 800, 600);
```

--------------------------------

### Create XY Line Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Shows how to generate an XY line chart for continuous numeric data. It uses XYSeries and XYSeriesCollection to map specific (x, y) coordinates.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;

XYSeries series1 = new XYSeries<>("Sensor 1");
series1.add(0.0, 1.2);
series1.add(1.0, 2.4);
series1.add(2.0, 1.8);
series1.add(3.0, 3.1);
series1.add(4.0, 2.9);

XYSeries series2 = new XYSeries<>("Sensor 2");
series2.add(0.0, 0.8);
series2.add(1.0, 1.5);
series2.add(2.0, 2.2);
series2.add(3.0, 2.8);
series2.add(4.0, 3.5);

XYSeriesCollection dataset = new XYSeriesCollection<>();
dataset.addSeries(series1);
dataset.addSeries(series2);

JFreeChart chart = ChartFactory.createXYLineChart(
    "Sensor Readings",
    "Time (seconds)",
    "Value",
    dataset,
    PlotOrientation.VERTICAL,
    true, true, false
);
```

--------------------------------

### Displaying Charts in Swing Applications

Source: https://context7.com/jfree/jfreechart/llms.txt

Shows how to embed and display interactive JFreeCharts within a Swing GUI.

```APIDOC
## Displaying Charts in Swing Applications

### Description
The `ChartPanel` class provides a Swing component for displaying interactive charts with zooming, panning, and popup menus.

### Method
`ChartPanel(JFreeChart chart)`

### Parameters
- `chart` (JFreeChart) - The chart to display.

### Request Example
```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.swing.ChartPanel;
import org.jfree.data.general.DefaultPieDataset;
import javax.swing.JFrame;
import java.awt.Dimension;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Slice 1", 30);
dataset.setValue("Slice 2", 70);

JFreeChart chart = ChartFactory.createPieChart("Interactive Chart", dataset);

// Create panel with default settings
ChartPanel panel = new ChartPanel(chart);
panel.setPreferredSize(new Dimension(800, 600));
panel.setMouseWheelEnabled(true);  // enable zoom with mouse wheel

// Create and show frame
JFrame frame = new JFrame("JFreeChart Demo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(panel);
frame.pack();
frame.setVisible(true);
```

### Response
This code creates a Swing `JFrame` containing a `ChartPanel` that displays the provided `JFreeChart`. The panel supports interactive features like zooming and panning.
```

--------------------------------

### POST /api/v1/time-period/create

Source: https://github.com/jfree/jfreechart/blob/master/README.md

Creates a new time period object (Month, Quarter, or Year) with specific Locale and TimeZone settings.

```APIDOC
## POST /api/v1/time-period/create

### Description
Initializes a time period object using the specified Date, TimeZone, and Locale. This replaces deprecated constructors that lacked Locale support.

### Method
POST

### Endpoint
/api/v1/time-period/create

### Parameters
#### Request Body
- **periodType** (string) - Required - 'Month', 'Quarter', or 'Year'
- **date** (string) - Required - ISO 8601 date string
- **timeZone** (string) - Required - Time zone ID (e.g., 'UTC')
- **locale** (string) - Required - Locale code (e.g., 'en_US')

### Request Example
{
  "periodType": "Month",
  "date": "2008-12-31T00:00:00Z",
  "timeZone": "UTC",
  "locale": "en_US"
}

### Response
#### Success Response (200)
- **id** (string) - The generated time period identifier

#### Response Example
{
  "id": "Month-2008-12"
}
```

--------------------------------

### Create Time Series Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Illustrates the creation of a time-based chart using TimeSeries and TimeSeriesCollection. This is designed for data points associated with specific calendar dates.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.time.Day;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;

TimeSeries<String> series = new TimeSeries<>("Stock Price");
series.add(new Day(1, 1, 2024), 150.25);
series.add(new Day(2, 1, 2024), 152.40);
series.add(new Day(3, 1, 2024), 151.80);
series.add(new Day(4, 1, 2024), 155.10);
series.add(new Day(5, 1, 2024), 158.30);
series.add(new Day(8, 1, 2024), 157.20);
series.add(new Day(9, 1, 2024), 160.45);

TimeSeriesCollection dataset = new TimeSeriesCollection<>();
dataset.addSeries(series);

JFreeChart chart = ChartFactory.createTimeSeriesChart(
    "Stock Price History",
    "Date",
    "Price ($)",
    dataset,
    true, true, false
);
```

--------------------------------

### Create Histogram with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Generates a histogram to display frequency distributions of data. Requires JFreeChart library and a HistogramDataset.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.statistics.HistogramDataset;
import org.jfree.data.statistics.HistogramType;

// Generate sample data
double[] values = new double[100];
java.util.Random random = new java.util.Random(42);
for (int i = 0; i < values.length; i++) {
    values[i] = random.nextGaussian() * 15 + 50;  // mean=50, std=15
}

// Create histogram dataset with 10 bins
HistogramDataset dataset = new HistogramDataset();
dataset.setType(HistogramType.FREQUENCY);
dataset.addSeries("Test Scores", values, 10);  // 10 bins

JFreeChart chart = ChartFactory.createHistogram(
    "Test Score Distribution",  // title
    "Score",                    // x-axis label
    "Frequency",                // y-axis label
    dataset,                    // dataset
    PlotOrientation.VERTICAL,   // orientation
    true, true, false           // legend, tooltips, URLs
);
```

--------------------------------

### Create Scatter Plot with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates the generation of a scatter plot to analyze correlations between two numeric variables. It uses an XYSeriesCollection to plot individual data points.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;

XYSeries series = new XYSeries<>("Height vs Weight");
series.add(165, 60);
series.add(170, 68);
series.add(175, 72);
series.add(168, 65);
series.add(180, 80);
series.add(172, 70);
series.add(178, 75);
series.add(185, 85);

XYSeriesCollection dataset = new XYSeriesCollection<>();
dataset.addSeries(series);

JFreeChart chart = ChartFactory.createScatterPlot(
    "Height vs Weight Correlation",
    "Height (cm)",
    "Weight (kg)",
    dataset,
    PlotOrientation.VERTICAL,
    true, true, false
);
```

--------------------------------

### ChartFactory.createStackedBarChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Generates a stacked bar chart to show part-to-whole relationships.

```APIDOC
## METHOD ChartFactory.createStackedBarChart

### Description
Creates stacked bar charts where series values are stacked on top of each other, useful for showing part-to-whole relationships across categories.

### Parameters
- **title** (String) - Required - The chart title.
- **categoryAxisLabel** (String) - Required - Label for the category axis.
- **valueAxisLabel** (String) - Required - Label for the value axis.
- **dataset** (DefaultCategoryDataset) - Required - The data to visualize.
- **orientation** (PlotOrientation) - Required - Vertical or Horizontal.

### Response
- **JFreeChart** (Object) - Returns a configured JFreeChart instance.
```

--------------------------------

### Save Chart as PNG Image

Source: https://context7.com/jfree/jfreechart/llms.txt

Shows how to save a JFreeChart to a PNG file using ChartUtils.saveChartAsPNG. This method supports saving with or without rendering information and allows control over alpha channel encoding and compression level.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartRenderingInfo;
import org.jfree.chart.ChartUtils;
import org.jfree.chart.JFreeChart;
import org.jfree.data.general.DefaultPieDataset;
import java.io.File;
import java.io.IOException;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Category A", 40);
dataset.setValue("Category B", 35);
dataset.setValue("Category C", 25);

JFreeChart chart = ChartFactory.createPieChart("Sample", dataset);

// Simple save
ChartUtils.saveChartAsPNG(new File("chart.png"), chart, 800, 600);

// Save with rendering info for image maps
ChartRenderingInfo info = new ChartRenderingInfo();
ChartUtils.saveChartAsPNG(new File("chart-with-info.png"), chart, 800, 600, info);

// Save with alpha and compression control
ChartUtils.saveChartAsPNG(
    new File("chart-compressed.png"),
    chart, 800, 600, info,
    true,   // encode alpha channel
    9       // compression level (0-9)
);
```

--------------------------------

### Create Area Chart with JFreeChart

Source: https://context7.com/jfree/jfreechart/llms.txt

Generates a filled area chart to visualize cumulative values or magnitude of change. Requires JFreeChart library and a CategoryDataset.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.data.category.DefaultCategoryDataset;

DefaultCategoryDataset<String, String> dataset = new DefaultCategoryDataset<>();
dataset.addValue(200, "Revenue", "Jan");
dataset.addValue(250, "Revenue", "Feb");
dataset.addValue(225, "Revenue", "Mar");
dataset.addValue(300, "Revenue", "Apr");
dataset.addValue(280, "Revenue", "May");
dataset.addValue(350, "Revenue", "Jun");

JFreeChart chart = ChartFactory.createAreaChart(
    "Monthly Revenue",        // title
    "Month",                  // category axis label
    "Revenue ($K)",           // value axis label
    dataset,                  // dataset
    PlotOrientation.VERTICAL, // orientation
    true, true, false         // legend, tooltips, URLs
);
```

--------------------------------

### Display Chart in Swing Application

Source: https://context7.com/jfree/jfreechart/llms.txt

Illustrates how to display a JFreeChart within a Swing application using the ChartPanel component. This panel provides interactive features like zooming, panning, and context menus, and can be added to a JFrame.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.swing.ChartPanel;
import org.jfree.data.general.DefaultPieDataset;
import javax.swing.JFrame;
import java.awt.Dimension;

DefaultPieDataset<String> dataset = new DefaultPieDataset<>();
dataset.setValue("Slice 1", 30);
dataset.setValue("Slice 2", 70);

JFreeChart chart = ChartFactory.createPieChart("Interactive Chart", dataset);

// Create panel with default settings
ChartPanel panel = new ChartPanel(chart);
panel.setPreferredSize(new Dimension(800, 600));
panel.setMouseWheelEnabled(true);  // enable zoom with mouse wheel

// Create and show frame
JFrame frame = new JFrame("JFreeChart Demo");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.add(panel);
frame.pack();
frame.setVisible(true);
```

--------------------------------

### Create Candlestick Chart with OHLC Data

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates how to create a candlestick chart using JFreeChart's ChartFactory.createCandlestickChart method. It requires an OHLCDataset which is populated with OHLCDataItem objects, each containing date, open, high, low, and close values.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.data.xy.DefaultOHLCDataset;
import org.jfree.data.xy.OHLCDataItem;
import java.util.Date;

// Create OHLC data items (date, open, high, low, close, volume)
Date[] dates = {new Date(124, 0, 1), new Date(124, 0, 2), new Date(124, 0, 3)};
OHLCDataItem[] items = {
    new OHLCDataItem(dates[0], 100.0, 105.0, 98.0, 103.0, 1000000),
    new OHLCDataItem(dates[1], 103.0, 108.0, 101.0, 106.0, 1200000),
    new OHLCDataItem(dates[2], 106.0, 110.0, 104.0, 108.0, 1100000)
};

DefaultOHLCDataset dataset = new DefaultOHLCDataset("STOCK", items);

JFreeChart chart = ChartFactory.createCandlestickChart(
    "Stock Price",     // title
    "Date",            // time axis label
    "Price ($)",       // value axis label
    dataset,           // dataset
    true               // legend
);
```

--------------------------------

### Customize JFreeChart Visual Appearance

Source: https://context7.com/jfree/jfreechart/llms.txt

Demonstrates how to modify the title, background, border, and padding of a JFreeChart instance. It also shows how to access and style the underlying CategoryPlot.

```java
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.title.TextTitle;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.api.RectangleInsets;
import org.jfree.data.category.DefaultCategoryDataset;
import java.awt.Color;
import java.awt.Font;
import java.awt.BasicStroke;

DefaultCategoryDataset<String, String> dataset = new DefaultCategoryDataset<>();
dataset.addValue(100, "Series", "A");
dataset.addValue(80, "Series", "B");

JFreeChart chart = ChartFactory.createBarChart("Title", "X", "Y", dataset);

chart.setTitle(new TextTitle("Custom Title", new Font("Arial", Font.BOLD, 24)));
chart.setBackgroundPaint(Color.WHITE);
chart.setBorderVisible(true);
chart.setBorderPaint(Color.DARK_GRAY);
chart.setBorderStroke(new BasicStroke(2.0f));
chart.setPadding(new RectangleInsets(10, 10, 10, 10));

CategoryPlot plot = chart.getCategoryPlot();
plot.setBackgroundPaint(Color.LIGHT_GRAY);
plot.setDomainGridlinePaint(Color.WHITE);
plot.setRangeGridlinePaint(Color.WHITE);
```