JAVA根据模板导出PPTX

编程爱好者熊浪

已于 2023-07-25 13:56:41 修改

阅读量3.9k

点赞数 2

分类专栏：所遇问题文章标签： java

于 2021-09-18 13:56:42 首次发布

本文链接：https://blog.csdn.net/xionglangs/article/details/120365758

版权

所遇问题专栏收录该内容

71 篇文章 5 订阅

订阅专栏

引入JAR

<dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-base</artifactId>
            <version>4.1.0</version>
        </dependency>
        <dependency>
            <groupId>org.jfree</groupId>
            <artifactId>jcommon</artifactId>
            <version>1.0.24</version>
        </dependency>

1、使用PowerPoint新建一个PPTX模板，每个${}占一块，否则模板容易报错，模板图片添加的是jpeg，图片不能使用一样的，否则获取图片的时候永远只能获取一张图片，填充图片的时候就只会填充一张图片，图片从上到下1，2，3…，keyValueMap.put(“image1.jpeg”, imageEntity);
在这里插入图片描述

package com.utils;

import cn.afterturn.easypoi.entity.ImageEntity;
import com.google.common.collect.Lists;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import org.apache.commons.io.IOUtils;
import org.apache.poi.sl.usermodel.PictureData;
import org.apache.poi.sl.usermodel.TextParagraph;
import org.apache.poi.xslf.usermodel.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.awt.*;
import java.io.*;
import java.util.List;
import java.util.Map;

/**
 * Description：
 *
 * @Author： leo.xiong
 * @CreateDate： 2021/8/30 12:13
 * @Email： leo.xiong@suyun360.com
 * @Since：
 */
public class PptUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(PptUtil.class);
    public static final String TITLE = "title";
    /**
     * 首页内容
     */
    public static final String FIRST_CONTENT = "firstContent";
    /**
     * 首页位置 Rectangle，x轴坐标，y轴坐标，宽度，高度
     */
    public static final String ANCHOR = "anchor";
    /**
     * 图片信息
     */
    public static final String IMAGE = "image";

    public static final String CATALOG = "catalog";
    public static final String PREFIX = "${";
    public static final String SUFFIX = "}";

    public static final String IMAGE_SUFFIX = ".jpeg";

    public static String exportPpt(File file, Map<String, Object> keyValueMap) {
        //创建ppt对象
        XMLSlideShow ppt = new XMLSlideShow();
        //首页
        XSLFSlide slideFirst = ppt.createSlide();
        Map<String, Object> firstValueMap = (Map<String, Object>) keyValueMap.get(FIRST_CONTENT);
        fillFirstContent(slideFirst, firstValueMap);
        //目录
        XSLFSlide slideCatalog = ppt.createSlide();
        Map<String, Object> keyCatalogMap = (Map<String, Object>) keyValueMap.get(CATALOG);
        List<XSLFSlide> contentSlides = Lists.newArrayList();
        if (!CollectionUtils.isEmpty(keyCatalogMap)) {
            keyCatalogMap.forEach((key, content) -> {
                contentSlides.add(ppt.createSlide());
            });
        }
        fillCatalog(slideCatalog, contentSlides, keyCatalogMap);
        Map<String, List<ImageEntity>> imageEntityListMap = (Map<String, List<ImageEntity>>) keyValueMap.get(IMAGE);
        fillContent(contentSlides, keyCatalogMap, imageEntityListMap, ppt);
        StringBuffer fileUrl = new StringBuffer();
        fileUrl.append(file.getName());
        fileUrl.append(file.getName());
        FileOutputStream out = null;
        try {
            file = new File(fileUrl.toString());
            out = new FileOutputStream(file);
            ppt.write(out);
        } catch (FileNotFoundException e) {
            LOGGER.error("文件创建失败，请尝试给web目录赋权777");
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (out != null) {
                    out.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return file.getName();
    }

    /**
     * 填充正文，包含图片
     *
     * @param contentSlides
     * @param keyCatalogMap
     * @param imageEntityListMap
     * @param ppt
     */
    private static void fillContent(List<XSLFSlide> contentSlides, Map<String, Object> keyCatalogMap, Map<String, List<ImageEntity>> imageEntityListMap, XMLSlideShow ppt) {
        if (contentSlides != null) {
            List<String> titles = (List<String>) keyCatalogMap.get(TITLE);
            int len = contentSlides.size();
            for (int i = 0; i < len; i++) {
                createTitle(contentSlides.get(i), titles.get(i));
                List<ImageEntity> entityList = imageEntityListMap.get(titles.get(i));
                if (CollectionUtils.isEmpty(entityList)) {
                    continue;
                }
                for (ImageEntity imageEntity : entityList) {
                    createPicture(contentSlides.get(i), imageEntity.getUrl(), ppt, i);
                }
            }
        }
    }

    /**
     * 填充时间
     *
     * @param xslfSlide
     * @param picCreateTime
     */
    private static void createTime(XSLFSlide xslfSlide, String picCreateTime) {
        //标题文本框
        XSLFTextBox xslfTextBox = xslfSlide.createTextBox();
        xslfTextBox.setAnchor(new Rectangle(400, 460, 300, 80));
        xslfTextBox.setFlipHorizontal(true);
        //段落
        XSLFTextParagraph paragraph0 = xslfTextBox.addNewTextParagraph();
        paragraph0.setTextAlign(TextParagraph.TextAlign.LEFT);
        XSLFTextRun xslfTextRun = paragraph0.addNewTextRun();
        xslfTextRun.setFontSize(18D);
        //宋体 (正文)
        xslfTextRun.setFontFamily("宋体");
        String text = "123";
        xslfTextRun.setText(String.format(text, picCreateTime));
    }

    /**
     * 填充图片
     *
     * @param slide
     * @param picturePath
     * @param ppt
     * @param flag
     */
    private static void createPicture(XSLFSlide slide, String picturePath, XMLSlideShow ppt, int flag) {
        try {
            byte[] pictureData = IOUtils.toByteArray(new FileInputStream(picturePath));
            XSLFPictureData pictureIndex = ppt.addPicture(pictureData, PictureData.PictureType.JPEG);
            XSLFPictureShape pictureShape = slide.createPicture(pictureIndex);
            if (flag == 4) {
                pictureShape.setAnchor(new Rectangle(125, 100, 467, 200));
            } else {
                pictureShape.setAnchor(new Rectangle(125, 100, 467, 350));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 目录填充
     *
     * @param xslfSlide
     * @param catalogMap
     */
    private static void fillCatalog(XSLFSlide xslfSlide, List<XSLFSlide> contentSlides, Map<String, Object> catalogMap) {
        createTitle(xslfSlide, "目录");
        //内容文本框
        XSLFTextBox xslfTextBox = xslfSlide.createTextBox();

        xslfTextBox.setAnchor((Rectangle) catalogMap.get(ANCHOR));
        xslfTextBox.setFlipHorizontal(true);
        //段落
        XSLFTextParagraph paragraph = xslfTextBox.addNewTextParagraph();
        paragraph.setTextAlign(TextParagraph.TextAlign.LEFT);
        List<String> titles = (List<String>) catalogMap.get(TITLE);
        if (CollectionUtils.isEmpty(titles)) {
            return;
        }
        for (int i = 0, len = titles.size(); i < len; i++) {
            XSLFTextRun xslfTextRun = paragraph.addNewTextRun();
            xslfTextRun.setUnderlined(true);
            xslfTextRun.setFontSize(36D);
            xslfTextRun.setFontFamily("宋体");
            xslfTextRun.setText(i + 1 + "、" + titles.get(i));
            xslfTextRun.createHyperlink().setAddress(contentSlides.get(i).toString());
        }
    }

    /**
     * 生成标题头
     *
     * @param xslfSlide
     * @param title
     */
    private static void createTitle(XSLFSlide xslfSlide, String title) {
        //标题文本框
        XSLFTextBox xslfTextBox = xslfSlide.createTextBox();
        xslfTextBox.setAnchor(new Rectangle(10, 25, 700, 85));
        xslfTextBox.setFlipHorizontal(true);
        //段落
        XSLFTextParagraph paragraph0 = xslfTextBox.addNewTextParagraph();
        paragraph0.setTextAlign(TextParagraph.TextAlign.CENTER);
        XSLFTextRun xslfTextRun = paragraph0.addNewTextRun();
        xslfTextRun.setFontSize(44D);
        //黑体
        xslfTextRun.setFontFamily("宋体");
        xslfTextRun.setBold(true);
        xslfTextRun.setText(title);
    }

    /**
     * 填充首页内容
     *
     * @param xslfSlide
     * @param firstValueMap
     */
    private static void fillFirstContent(XSLFSlide xslfSlide, Map<String, Object> firstValueMap) {
        //文本框
        XSLFTextBox xslfTextBox = xslfSlide.createTextBox();
        //坐标，x轴，y轴，宽度，高度
        xslfTextBox.setAnchor((Rectangle) firstValueMap.get(ANCHOR));
        xslfTextBox.setFlipHorizontal(true);
        //段落
        XSLFTextParagraph paragraph = xslfTextBox.addNewTextParagraph();
        paragraph.setTextAlign(TextParagraph.TextAlign.CENTER);
        //标题
        XSLFTextRun xslfTextRun = paragraph.addNewTextRun();
        xslfTextRun.setBold(true);
        xslfTextRun.setFontSize(44D);
        //宋体 (标题)
        xslfTextRun.setFontFamily("宋体");
        xslfTextRun.setText((String) firstValueMap.get(TITLE));
    }

    public static byte[] getFileToByte(File file) {
        byte[] bytes = new byte[(int) file.length()];
        try {
            InputStream is = new FileInputStream(file);
            ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
            byte[] bb = new byte[2048];
            int ch;
            ch = is.read(bb);
            while (ch != -1) {
                byteStream.write(bb, 0, ch);
                ch = is.read(bb);
            }
            bytes = byteStream.toByteArray();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return bytes;
    }

    /**
     * 导出XML
     *
     * @param tempPath
     * @param tempName
     * @param exportPath
     * @param keyValueMap
     * @throws IOException
     */
    public static void exportXML(String tempPath, String tempName, String exportPath, Map<String, Object> keyValueMap) throws IOException {
        Configuration configuration = new Configuration();
        configuration.setDefaultEncoding("UTF-8");
        configuration.setDirectoryForTemplateLoading(new File(tempPath));
        //读取模板路径下的PPT的.xml模板文件
        Template template = configuration.getTemplate(tempName, "UTF-8");
        //设置导出路径
        File outfile = new File(exportPath);
        Writer out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outfile)), 10240);
        try {
            //将数据替换并导出PPT
            template.process(keyValueMap, out);
        } catch (TemplateException e) {
            e.printStackTrace();
        } finally {
            out.close();
        }
    }

     /**
     * 根据模板生成PPTX
     *
     * @param dir
     * @param tempName
     * @param downLoadPath
     * @param keyValueMap
     * @throws IOException
     */
    public static void exportPPTX(String dir, String tempName, String downLoadPath, Map<String, Object> keyValueMap) throws IOException {
        exportPPTX(dir, tempName, downLoadPath, keyValueMap, null);
    }

    /**
     * 根据模板生成PPTX
     * 根据removePageIdList移除page信息，索引从0开始
     *
     * @param dir
     * @param tempName
     * @param downLoadPath
     * @param keyValueMap
     * @param removePageIdList
     * @throws IOException
     */
    public static void exportPPTX(String dir, String tempName, String downLoadPath, Map<String, Object> keyValueMap, List<Integer> removePageIdList) throws IOException {
        XMLSlideShow pptx = null;
        FileOutputStream out = null;
        try {
            pptx = new XMLSlideShow(new FileInputStream(dir + "/" + tempName));
            //当模板不定时，需要定义最大的模板page，之后通过删除不用的page索引，从而生成真正的文件信息
            if (!CollectionUtils.isEmpty(removePageIdList)) {
                Collections.sort(removePageIdList);
                for (int i = removePageIdList.size() - 1; i >= 0; i--) {
                    //索引从0开始，先删除最大的索引否则会出现数组越界
                    pptx.removeSlide(removePageIdList.get(i));
                }
            }
            for (int i = 0; i < pptx.getSlides().size(); i++) {
                XSLFSlide xSLFShape = pptx.getSlides().get(i);
                List<XSLFShape> shapes = xSLFShape.getShapes();
                // 遍历PPT的图形
                for (XSLFShape shape : shapes) {
                    if (shape instanceof XSLFTextShape) {
                        // 判断该图形类是否是文本框类
                        // 将图像类强制装换成文本框类
                        XSLFTextShape ts = (XSLFTextShape) shape;
                        // 替换文本框内的文字
                        ts.setText((String) replace(ts.getText(), keyValueMap));
                    } else if (shape instanceof XSLFTable) {
                        // 判断该图形类是否是表格类
                        // 将图像类强制装换成表格类
                        XSLFTable table = (XSLFTable) shape;
                        // 获取表格中的所有行
                        List<XSLFTableRow> rows = table.getRows();
                        for (XSLFTableRow tr : rows) {
                            // 获取行中的所有单元格
                            List<XSLFTableCell> cells = tr.getCells();
                            for (XSLFTableCell tc : cells) {
                                //替换单元格信息
                                tc.setText((String) replace(tc.getText(), keyValueMap));
                            }
                        }
                    } else if (shape instanceof XSLFPictureShape) {
                        // 判断该图形类是否是图片框类
                        // 将图像类强制装换成图片框类
                        XSLFPictureShape ps = (XSLFPictureShape) shape;
                        //替换图片信息，图片命名为 image+index.jpeg
                        String fileName = PREFIX + ps.getPictureData().getFileName() + SUFFIX;
                        ps.getPictureData().setData((byte[]) replace(fileName, keyValueMap));
                    }
                }
            }

            File file = new File(downLoadPath);
            out = new FileOutputStream(file);
            pptx.write(out);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (out != null) {
                out.close();
            }
            if (pptx != null) {
                pptx.close();
            }
        }
    }
    /**
     * 替换信息
     *
     * @param tempKey
     * @param keyValueMap
     * @return
     */
    private static Object replace(String tempKey, Map<String, Object> keyValueMap) {
        for (Map.Entry<String, Object> keyValue : keyValueMap.entrySet()) {
            String key = PREFIX + keyValue.getKey() + SUFFIX;
            Object value = keyValue.getValue();
            if (tempKey.contains(key)) {
                if (value instanceof String) {
                    tempKey = tempKey.replace(key, value == null ? "" : (String) value);
                } else if (value instanceof ImageEntity) {
                    return ((ImageEntity) value).getData();
                }
            }
        }
        return tempKey;
    }
}

package com.utils;

import cn.afterturn.easypoi.entity.ImageEntity;
import com.alibaba.dubbo.common.utils.Assert;
import com.alibaba.dubbo.common.utils.StringUtils;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.StandardChartTheme;
import org.jfree.chart.axis.*;
import org.jfree.chart.labels.ItemLabelAnchor;
import org.jfree.chart.labels.ItemLabelPosition;
import org.jfree.chart.labels.StandardCategoryItemLabelGenerator;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.category.BarRenderer;
import org.jfree.chart.ui.TextAnchor;
import org.jfree.data.RangeType;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.data.xy.XYSeriesCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.awt.*;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.text.DecimalFormat;

/**
 * @author Andrew.zheng
 * @version 2020/6/18
 * @className ChartUtils
 * @Description 图表类型    工厂类方法	数据集类型	备注
 * 柱状图	createBarChart	CategoryDataset
 * 柱状图3D	createBarChart3D	CategoryDataset
 * 饼图	createPieChart	PieDataset
 * 饼图3D	createPieChart3D	PieDataset
 * 线图	createLineChart	CategoryDataset
 * 线图3D	createLineChart3D	CategoryDataset
 * 复合饼图	createMultiplePieChart	CategoryDataset	需要设置TableOrder
 * 复合饼图3D	createMultiplePieChart3D	CategoryDataset
 * 环形图	createRingChart	PieDataset
 * 瀑布图	createWaterfallChart	CategoryDataset	柱图特殊形式
 * 面积图	createAreaChart	CategoryDataset
 * 散点图	createScatterPlot	XYSeriesCollection
 * 组织图	createHistogram	XYSeriesCollection
 * 数据点阶梯图	createXYStepChart	XYSeriesCollection
 * 堆积面积图	createStackedAreaChart	CategoryDataset
 * 堆积柱状图	createStackedBarChart	CategoryDataset
 * 堆积柱状图3D	createStackedBarChart3D	CategoryDataset
 * 数据点线图	createXYLineChart	XYSeriesCollection
 * 数据点面积图	createXYAreaChart	XYSeriesCollection
 * 数据点阶梯面积图	createXYStepAreaChart	XYSeriesCollection
 * 堆积数据点面积图	createStackedXYAreaChart	TableXYDataset
 * 时序图	createTimeSeriesChart	XYDataset
 * 晶片图	createWaferMapChart	WaferMapDataset
 * WindPlot	createWindPlot	WindDataset
 * 极线图	createPolarChart	XYDataset
 * 气泡图	createBubbleChart	XYZDataset
 * BoxAndWhiskerChart	createBoxAndWhiskerChart	BoxAndWhiskerXYDataset
 * 烛台图	createCandlestickChart	OHLCDataset
 * 股价图	createHighLowChart	OHLCDataset	2种 时间线差别
 * 甘特图	createGanttChart	IntervalCategoryDataset
 * 数据点柱状图	createXYBarChart	IntervalXYDataset
 */
public class ChartUtils {
    private static final Logger LOGGER = LoggerFactory.getLogger(ChartUtils.class);

    /**
     * 将图片转化为字节数组
     *
     * @return 字节数组
     */
    private static byte[] imgToByte(String tempImgPath) {
        File file = new File(tempImgPath);
        byte[] buffer = null;
        try {
            FileInputStream fis = new FileInputStream(file);
            ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
            byte[] b = new byte[1000];
            int n;
            while ((n = fis.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            fis.close();
            bos.close();
            buffer = bos.toByteArray();
        } catch (IOException e) {
            e.getMessage();
        }
        //删除临时文件
        file.delete();
        return buffer;
    }

    public static JFreeChart xYLineChart(String title, String xAxisLabel, String yAxisLabel, XYSeriesCollection dataCollection) {
        //创建主题样式
        StandardChartTheme standardChartTheme = new StandardChartTheme("CN");

        //设置标题字体
        standardChartTheme.setExtraLargeFont(FontUtils.getFont("simsun.ttf", "新宋体", Font.PLAIN, 18f));
//        //设置图例的字体
//        standardChartTheme.setRegularFont(FontUtils.getFont(path,"yqyzh.ttf","文泉驿正黑", Font.PLAIN, 12f));
//        //设置轴向的字体
//        standardChartTheme.setLargeFont(FontUtils.getFont(path,"yqyzh.ttf","文泉驿正黑", Font.PLAIN, 12f));
//        standardChartTheme.setSmallFont(FontUtils.getFont(path,"yqyzh.ttf","文泉驿正黑", Font.PLAIN, 10f));
        //设置图例的字体
        standardChartTheme.setRegularFont(FontUtils.getFont("simsun.ttf", "宋体", Font.PLAIN, 12f));
        //设置轴向的字体
        standardChartTheme.setLargeFont(FontUtils.getFont("simsun.ttf", "宋体", Font.PLAIN, 12f));
        standardChartTheme.setSmallFont(FontUtils.getFont("simsun.ttf", "宋体", Font.PLAIN, 12f));
        //设置主题样式
        ChartFactory.setChartTheme(standardChartTheme);
        //图标标题、数据集合、是否显示图例标识、是否显示tooltips、是否支持超链接
        JFreeChart chart = ChartFactory.createXYLineChart(title, xAxisLabel, yAxisLabel, dataCollection, PlotOrientation.VERTICAL, true, true, false);
        //将jfreechart里RenderingHints做文字渲染参数的修改
        chart.getRenderingHints().put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);

        ChartPanel chartPanel = new ChartPanel(chart);
        chartPanel.setPreferredSize(new java.awt.Dimension(560, 367));
        final XYPlot plot = chart.getXYPlot();
//        setContentPane( chartPanel ); //原文出自【易百教程】，商业转载请联系作者获得授权，非商业请保留原文链接：https://www.yiibai.com/jfreechart/jfreechart_xy_chart.html
        ValueAxis domainAxis = plot.getDomainAxis();
        domainAxis.setTickLabelsVisible(true);//X轴的标题文字是否显示
        domainAxis.setTickMarksVisible(true);
        domainAxis.setAutoRange(true);
//        ValueAxis rAxisR = plot.getRangeAxis(1);
//        ((Axis) rAxisR).setTickLabelsVisible(true);//Y轴的标题文字是否显示
//        ((NumberAxis) rAxisR).setAutoRangeStickyZero(true);

        //设置抗锯齿
        chart.setTextAntiAlias(false);


//        plot.setNoDataMessage("no data");
        //设置背景图片颜色
        plot.setBackgroundImageAlpha(0.0f);
        //设置背景色
        plot.setBackgroundPaint(Color.WHITE);
        //设置网格横线颜色
        plot.setRangeGridlinePaint(Color.black);
        //忽略无值的分类
//        plot.setIgnoreNullValues(true);
//        plot.setBackgroundAlpha(0f);
//        //设置标签阴影颜色
//        plot.setShadowPaint(new Color(255,255,255));
//        //设置标签生成器(默认{0})
//        plot.setLabelGenerator(new StandardPieSectionLabelGenerator("{0}({1})/{2}"));
        return chart;
    }

    public static JFreeChart addYLineChart(JFreeChart chart, XYSeriesCollection xySeriesCollection, String twoyAxisLabel) {
        if (StringUtils.isEmpty(twoyAxisLabel)) {
            return chart;
        }
        NumberAxis axis2 = new NumberAxis(twoyAxisLabel);
//        axis2.setLabelFont(FontUtils.getFont(path,"yqyzh.ttf","文泉驿正黑", Font.PLAIN, 12f));
        axis2.setLabelFont(FontUtils.getFont("simhei.ttf", "黑体", Font.PLAIN, 12f));
        // -- 修改第2个Y轴的显示效果
        axis2.setAxisLinePaint(Color.BLUE);
        axis2.setLabelPaint(Color.BLUE);
        axis2.setTickLabelPaint(Color.BLUE);

        chart.getXYPlot().setRangeAxis(1, axis2);
        chart.getXYPlot().setDataset(1, xySeriesCollection);
        chart.getXYPlot().mapDatasetToRangeAxis(1, 1);
        return chart;
    }

    /**
     * 柱状图
     *
     * @param title
     * @param xName
     * @param yName
     * @param categoryDataset
     * @param height
     * @param tempImgPath
     * @return
     */
    public static ImageEntity createImage(String title, String xName, String yName, DefaultCategoryDataset categoryDataset, int height, String tempImgPath) {
        /**
         * 标题,目录轴的显示标签,数值的显示标签,数据,图标方向  水平/垂直,是否显示图例，是否生成工具，是否生成URL链接
         */
        JFreeChart chart = ChartFactory.createBarChart(title, xName, yName, categoryDataset, PlotOrientation.HORIZONTAL, true, true, false);
        //头部字体修改
        chart.getTitle().setFont(FontUtils.getFont("simsun.ttf", "新宋体", Font.BOLD, 20f));
        //VALUE_TEXT_ANTIALIAS_OFF表示将文字的抗锯齿关闭,使用的关闭抗锯齿后，字体尽量选择12到14号的宋体字,字体清晰度。
        chart.getRenderingHints().put(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
        //图部分
        CategoryPlot categoryPlot = chart.getCategoryPlot();
        //背景颜色
        categoryPlot.setBackgroundPaint(new Color(241, 241, 245));
        //X轴
        CategoryAxis domainAxis = categoryPlot.getDomainAxis();
        //X轴下标  90°显示
        domainAxis.setCategoryLabelPositions(CategoryLabelPositions.STANDARD);
        //自动换行    最多显示多少行
        domainAxis.setMaximumCategoryLabelLines(100);
        //下标
        domainAxis.setLabelFont(FontUtils.getFont("simsun.ttf", "黑体", Font.PLAIN, 14f));
        //X轴标题
        domainAxis.setTickLabelFont(FontUtils.getFont("simsun.ttf", "宋体", Font.PLAIN, 14f));
        //Y轴
        ValueAxis rangeAxis = categoryPlot.getRangeAxis();
        //下标
        rangeAxis.setLabelFont(FontUtils.getFont("simsun.ttf", "黑体", Font.PLAIN, 14f));
        //Y轴标题
        rangeAxis.setTickLabelFont(FontUtils.getFont("simsun.ttf", "宋体", Font.PLAIN, 14f));
        NumberAxis numberAxis = (NumberAxis) categoryPlot.getRangeAxis();
        //取消自动设置Y轴刻度
        numberAxis.setAutoTickUnitSelection(false);
        //刻度大小
        numberAxis.setTickUnit(new NumberTickUnit(20));
        //和下面一行搭配使用   设置Y轴都是正数
        numberAxis.setAutoRangeStickyZero(true);
        numberAxis.setRangeType(RangeType.POSITIVE);
        //设置Y轴上的数值精度
        numberAxis.setNumberFormatOverride(new DecimalFormat("0"));
        //图标字体
        chart.getLegend().setItemFont(FontUtils.getFont("simsun.ttf", "黑体", Font.PLAIN, 14f));
        chart.getTitle().setFont(FontUtils.getFont("simsun.ttf", "黑体", Font.PLAIN, 14f));
        //图形修改
        BarRenderer renderer = (BarRenderer) categoryPlot.getRenderer();
        //设置柱状图上的数值精度
        renderer.setDefaultItemLabelGenerator(new StandardCategoryItemLabelGenerator("{2}", new DecimalFormat("0.00")));
        //设置柱子之间的距离
        renderer.setItemMargin(0);
        renderer.setPositiveItemLabelPositionFallback(new ItemLabelPosition(ItemLabelAnchor.OUTSIDE12, TextAnchor.BOTTOM_CENTER));
        renderer.setDefaultItemLabelFont(FontUtils.getFont("simsun.ttf", "黑体", Font.PLAIN, 14f));
        renderer.setDrawBarOutline(false);
        //设置柱子宽度
        renderer.setMaximumBarWidth(0.1);
        //设置柱子高度
        renderer.setMinimumBarLength(0.00);
        //设置最高柱子离顶部位置
        rangeAxis.setUpperMargin(0.18);
        //柱状体上的数值显示
        renderer.setDefaultItemLabelsVisible(true);
        //柱子颜色
        renderer.setSeriesPaint(0, new Color(0, 144, 230));
        return ChartUtils.creatImag(chart, tempImgPath, 500, height);
    }

    public static ImageEntity creatImag(JFreeChart chart, String tempImgPath, int width, int height) {
        return creatImag(chart, tempImgPath, width, height, Boolean.FALSE);
    }

    /**
     * 画图
     *
     * @param chart
     * @param tempImgPath
     * @param width
     * @param height
     * @param isPng       是否PNG,默认不是
     * @return
     */
    public static ImageEntity creatImag(JFreeChart chart, String tempImgPath, int width, int height, boolean isPng) {
        try {
            if (isPng) {
                org.jfree.chart.ChartUtils.saveChartAsPNG(new File(tempImgPath), chart, width, height);
            } else {
                org.jfree.chart.ChartUtils.saveChartAsJPEG(new File(tempImgPath), 1.0f, chart, width, height);
            }
        } catch (IOException e1) {
            LOGGER.warn("Failed to generate line chart!", e1);
        }
        ImageEntity imageEntity = new ImageEntity(imgToByte(tempImgPath), width, height);
        Assert.notNull(imageEntity.getData(), "Failed to generate line chart!");
        return imageEntity;
    }
}

package com.test;

import cn.afterturn.easypoi.entity.ImageEntity;
import com.google.common.collect.Maps;
import com.suyun.modules.testdata.model.entity.ChartStyleValue;
import com.suyun.modules.testdata.model.entity.DmasChartData;
import com.utils.ChartUtils;
import com.utils.PptUtil;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.DateAxis;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.axis.NumberTickUnit;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.plot.DatasetRenderingOrder;
import org.jfree.chart.plot.SeriesRenderingOrder;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeriesCollection;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Description：
 *
 * @Author： leo.xiong
 * @CreateDate： 2021/9/7 17:14
 * @Email： leo.xiong@suyun360.com
 * @Since：
 */
public class exportPPT {
    public static void main(String[] args) throws IOException {
        Map<String, Object> keyValueMap = Maps.newHashMap();
        keyValueMap.put("currentDate", "2021-09-07");
        keyValueMap.put("productSerial", "211P-DL3-1-001");
        keyValueMap.put("runTime", "2614.7");
//        ImageEntity imageEntity = createImage("");
//        BASE64Encoder base64Encoder = new BASE64Encoder();
        //imageEntity.setData(PptUtil.getFileToByte(new File("C:/Users/熊浪/Desktop/20210611/RESULTS/Cell_voltage_vs_Stack_current_2.jpeg")));
//        String base64EncoderValue = base64Encoder.encode(imageEntity.getData());
        keyValueMap.put("image1.jpeg", createImage("1"));
        keyValueMap.put("averageCellVoltageTimeImageWidth", 300);
        keyValueMap.put("averageCellVoltageTimeImageHeight", 500);

        keyValueMap.put("image2.jpeg", createImage("2"));
        keyValueMap.put("averageCellVoltageStackCurrentImageWidth", 300);
        keyValueMap.put("averageCellVoltageStackCurrentImageHeight", 500);

        keyValueMap.put("image3.jpeg", createImage("3"));
        keyValueMap.put("upperCellVoltageStackCurrentImageWidth", 300);
        keyValueMap.put("upperCellVoltageStackCurrentImageHeight", 500);

        keyValueMap.put("image4.jpeg", createImage("4"));
        keyValueMap.put("lowerCellVoltageStackCurrentImageWidth", 300);
        keyValueMap.put("lowerCellVoltageStackCurrentImageHeight", 500);

        keyValueMap.put("image5.jpeg", createImage("5"));
        keyValueMap.put("airInletPressureStackCurrentImageWidth", 300);
        keyValueMap.put("airInletPressureStackCurrentImageHeight", 500);

        keyValueMap.put("image6.jpeg", createImage("6"));
        keyValueMap.put("airMassFlowStackCurrentImageWidth", 300);
        keyValueMap.put("airMassFlowStackCurrentImageHeight", 500);

        keyValueMap.put("image7.jpeg", createImage("7"));
        keyValueMap.put("anodeDpWithoutPurgeStackCurrentImageWidth", 300);
        keyValueMap.put("anodeDpWithoutPurgeStackCurrentImageHeight", 500);

        keyValueMap.put("image8.jpeg", createImage("8"));
        keyValueMap.put("anodeDpWithPurgeStackCurrentImageWidth", 300);
        keyValueMap.put("anodeDpWithPurgeStackCurrentImageHeight", 500);

        keyValueMap.put("image9.jpeg", createImage("9"));
        keyValueMap.put("coolantInletTemperatureStackCurrentImageWidth", 300);
        keyValueMap.put("coolantInletTemperatureStackCurrentImageHeight", 500);

        keyValueMap.put("image10.jpeg", createImage("10"));
        keyValueMap.put("coolantDtStackCurrentImageWidth", 300);
        keyValueMap.put("coolantDtStackCurrentImageHeight", 500);

        keyValueMap.put("image11.jpeg", createImage("11"));
        keyValueMap.put("hrbSpeedStackCurrentImageWidth", 300);
        keyValueMap.put("hrbSpeedStackCurrentImageHeight", 500);

        keyValueMap.put("image12.jpeg", createImage("12"));
        keyValueMap.put("wcpSpeedStackCurrentImageWidth", 300);
        keyValueMap.put("wcpSpeedStackCurrentImageHeight", 500);

        keyValueMap.put("image13.jpeg", createImage("13"));
        keyValueMap.put("acpSpeedStackCurrentImageWidth", 300);
        keyValueMap.put("acpSpeedStackCurrentImageHeight", 500);
//        exportPpt(new File("C:/Users/熊浪/Desktop/20210611/1.ppt"), keyValueMap);
        //设置模板格式和路径
        //PptUtil.exportPPT("D:/IDEAWORKSPACES/master_data_service/src/main/resources/bin", "IDURABILITY.xml", "C:/Users/熊浪/Desktop/20210830/test.xml", keyValueMap);
        PptUtil.exportPPT("D:/IDEAWORKSPACES/master_data_service/src/main/resources/bin", "IDURABILITY.pptx", "C:/Users/熊浪/Desktop/20210830/test.pptx", keyValueMap);
    }


    private static ImageEntity createImage(String testStr) {
        DmasChartData dmasChartData = new DmasChartData();
        ChartStyleValue tempChartStyleValue = new ChartStyleValue();
        tempChartStyleValue.setEllipseIndex(2);
        dmasChartData.addXMinValue(0D).addXMaxValue(100D).addYMinValue(0D).addYMaxValue(100D).addXNumberTick(10D).addYNumberTick(10D)
                .putNameChartStyleValue("123", tempChartStyleValue);
        dmasChartData.addXyValue("123", 0, "10", "20", null, null);
        JFreeChart chart = ChartUtils.xYLineChart("测试【" + testStr + "】下", "时间", "数据", null);
        AtomicInteger atomicInteger = new AtomicInteger(0);
        dmasChartData.getDotLineNameChartStyleValueMap().forEach((xyItemRenderer, nameChartStyleValueMap) -> {
            int index = atomicInteger.getAndAdd(1);
            XYDataset xyDataset = null;
            if (dmasChartData.isTime()) {
                xyDataset = new TimeSeriesCollection();
                DateAxis dateAxis = new DateAxis();
                dateAxis.setDateFormatOverride(new SimpleDateFormat(dmasChartData.getPattern()));
                chart.getXYPlot().setDomainAxis(index, dateAxis);
            } else {
                xyDataset = new XYSeriesCollection();
            }
            XYDataset finalXyDataset = xyDataset;
            nameChartStyleValueMap.forEach((name, chartStyleValue) -> {
                chartStyleValue.buildXYItemRenderer(xyItemRenderer, finalXyDataset, name);
            });
            chart.getXYPlot().setRenderer(index, xyItemRenderer);
            chart.getXYPlot().setDataset(index, xyDataset);
            /**
             * X轴取值范围
             */
            ValueAxis domainAxis = chart.getXYPlot().getDomainAxis(index);
            if (domainAxis != null && domainAxis instanceof NumberAxis) {
                NumberAxis xNumberAxis = (NumberAxis) domainAxis;
                if (dmasChartData.getXMinValue() != null && dmasChartData.getXMaxValue() != null) {
                    xNumberAxis.setRange(dmasChartData.getXMinValue(), dmasChartData.getXMaxValue());
                    xNumberAxis.setTickUnit(new NumberTickUnit(dmasChartData.getXNumberTick()));
                    xNumberAxis.setVerticalTickLabels(Boolean.TRUE);
                }
            }
            /**
             * Y轴取值范围
             */
            ValueAxis rangeAxis = chart.getXYPlot().getRangeAxis(index);
            if (rangeAxis != null && rangeAxis instanceof NumberAxis) {
                NumberAxis yNumberAxis = (NumberAxis) rangeAxis;
                if (dmasChartData.getYMinValue() != null && dmasChartData.getYMaxValue() != null) {
                    yNumberAxis.setRange(dmasChartData.getYMinValue(), dmasChartData.getYMaxValue());
                    yNumberAxis.setTickUnit(new NumberTickUnit(dmasChartData.getYNumberTick()));
                    yNumberAxis.setVerticalTickLabels(Boolean.TRUE);
                }
            }
        });
        chart.getXYPlot().setDatasetRenderingOrder(DatasetRenderingOrder.FORWARD);
        chart.getXYPlot().setSeriesRenderingOrder(SeriesRenderingOrder.FORWARD);
        return ChartUtils.creatImag(chart, "123Jfree.jpeg", 500, 500);
    }
}


```java
package com.suyun.modules.testdata.model.entity;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.jfree.data.time.Second;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.data.time.TimeSeriesDataItem;
import org.jfree.data.xy.XYDataset;
import org.jfree.data.xy.XYSeries;
import org.jfree.data.xy.XYSeriesCollection;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.CollectionUtils;

import java.awt.*;
import java.awt.geom.Ellipse2D;
import java.io.Serializable;
import java.util.List;
import java.util.*;

/**
 * Description：
 * <p>
 * 画图信息
 * </p>
 *
 * @Author： leo.xiong
 * @CreateDate： 2021/9/13 10:16
 * @Email： leo.xiong@suyun360.com
 * @Since：
 */
public class ChartStyleValue implements Serializable {
    private static final Logger LOGGER = LoggerFactory.getLogger(ChartStyleValue.class);
    private static final long serialVersionUID = 3216294279099035955L;
    /**
     * 曲线颜色 (setSeriesPaint(0, Color.GREEN);)
     */
    public static final List<Color> PAINT_COLOR_LIST;
    /**
     * 曲线数据点画图型的颜色（setSeriesOutlinePaint(0,Color.BLACK)）
     */
    private static final List<Color> OUT_LINE_PAINT_COLOR_LIST;
    /**
     * 曲线数据点填充色（setSeriesFillPaint(0,Color.CYAN)）
     */
    private static final List<Color> FILL_PAINT_COLOR_LIST;
    /**
     * 曲线数据点的图形（setSeriesShape(0,new Ellipse2D.Double(-2, -2, 4, 4));）
     */
    private static final List<Ellipse2D.Double> SHAPE_PAINT_COLOR_LIST;

    /**
     * 数据点可见（setSeriesShapesVisible(0,Boolean.TRUE);），默认可见
     */

    static {
        PAINT_COLOR_LIST = Lists.newArrayList(new Color(31, 119, 180)
                , new Color(255, 172, 14)
                , new Color(44, 160, 44)
                , new Color(219, 34, 40)
                , new Color(17, 238, 17)
                , new Color(136, 170, 85)
                , new Color(238, 238, 17)
                , new Color(26, 230, 230)
                , new Color(0, 255, 0)
                , new Color(51, 112, 204)
                , new Color(187, 68, 92));
        OUT_LINE_PAINT_COLOR_LIST = Lists.newArrayList(new Color(204, 143, 51)
                , new Color(0, 255, 0)
                , new Color(26, 230, 230)
                , new Color(238, 238, 17)
                , new Color(187, 68, 92)
                , new Color(51, 112, 204)
                , new Color(17, 238, 17)
                , new Color(136, 170, 85));
        FILL_PAINT_COLOR_LIST = Lists.newArrayList(new Color(0, 255, 0)
                , new Color(187, 68, 92)
                , new Color(238, 238, 17)
                , new Color(26, 230, 230)
                , new Color(136, 170, 85)
                , new Color(204, 143, 51)
                , new Color(51, 112, 204)
                , new Color(17, 238, 17));
        SHAPE_PAINT_COLOR_LIST = Lists.newArrayList(new Ellipse2D.Double(-3D, -3D, 3D, 3D)
                , new Ellipse2D.Double(5D, 5D, 5D, 5D)
                , new Ellipse2D.Double(-4D, -4D, 8D, 8D));
    }

    /**
     * 初始化数据容器2W
     */
    private static final int DATA_VALUE_SIZE = 20000;
    /**
     * 图线索引
     */
    private int index = 0;
    /**
     * 图像
     */
    private Integer ellipseIndex;
    /**
     * 字体大小，默认为1
     */
    private float fontSize = 1.0f;
    /**
     * 数据点可见（setSeriesShapesVisible(0,Boolean.TRUE);），默认可见
     */
    private Map<Integer, Color> indexColorMap = Maps.newHashMap();
    /**
     * 是否画曲线数据点的轮廓图形（setUseOutlinePaint(Boolean.TRUE);），默认是
     */
    private Boolean useOutlinePaint = Boolean.TRUE;
    /**
     * 是否填充曲线数据点（setUseFillPaint(Boolean.TRUE);），默认是
     */
    private Boolean useFillPaint = Boolean.TRUE;
    /**
     * x轴的值
     */
    private List<Double> xValueList = new ArrayList<>(DATA_VALUE_SIZE);
    /**
     * y轴的值
     */
    private List<Double> yValueList = new ArrayList<>(DATA_VALUE_SIZE);

    public ChartStyleValue addFontSize(float fontSize) {
        this.fontSize = fontSize;
        return this;
    }

    public Boolean getUseOutlinePaint() {
        return useOutlinePaint;
    }

    public void setUseOutlinePaint(Boolean useOutlinePaint) {
        this.useOutlinePaint = useOutlinePaint;
    }

    public Boolean getUseFillPaint() {
        return useFillPaint;
    }

    public void setUseFillPaint(Boolean useFillPaint) {
        this.useFillPaint = useFillPaint;
    }

    public List<Double> getXValueList() {
        return xValueList;
    }

    public void setXValueList(List<Double> xValueList) {
        this.xValueList = xValueList;
    }

    public List<Double> getYValueList() {
        return yValueList;
    }

    public void setYValueList(List<Double> yValueList) {
        this.yValueList = yValueList;
    }

    public void setEllipseIndex(Integer ellipseIndex) {
        this.ellipseIndex = ellipseIndex;
    }

    public ChartStyleValue() {
        this(0, PAINT_COLOR_LIST.get(0));
    }

    public ChartStyleValue(Integer index) {
        this(index, PAINT_COLOR_LIST.get(index));
    }

    public ChartStyleValue(Integer index, Color color) {
        this.index = index;
        indexColorMap.put(index, color);
    }

    /**
     * 添加数据信息，设置样式
     *
     * @param xyItemRenderer
     * @param xyDataset
     * @param name
     * @return
     */
    public ChartStyleValue buildXYItemRenderer(XYItemRenderer xyItemRenderer, XYDataset xyDataset, String name) {
        xyItemRenderer.setSeriesStroke(index, new BasicStroke(this.fontSize));
        xyItemRenderer.setSeriesPaint(this.index, indexColorMap.get(index));
        if (this.ellipseIndex != null) {
            xyItemRenderer.setSeriesShape(this.index, SHAPE_PAINT_COLOR_LIST.get(ellipseIndex));
        } else if (xyItemRenderer instanceof XYLineAndShapeRenderer && ((XYLineAndShapeRenderer) xyItemRenderer).getDefaultLinesVisible()) {
            xyItemRenderer.setSeriesShape(this.index, SHAPE_PAINT_COLOR_LIST.get(2));
        } else {
            xyItemRenderer.setSeriesShape(this.index, SHAPE_PAINT_COLOR_LIST.get(1));
        }
        xyItemRenderer.setSeriesOutlinePaint(this.index, indexColorMap.get(index));
        xyItemRenderer.setSeriesFillPaint(this.index, indexColorMap.get(index));
        if (xyItemRenderer instanceof XYLineAndShapeRenderer) {
            ((XYLineAndShapeRenderer) xyItemRenderer).setSeriesShapesVisible(this.index, Boolean.TRUE);
        }
        if (CollectionUtils.isEmpty(this.xValueList) || CollectionUtils.isEmpty(this.yValueList) || this.xValueList.size() != this.yValueList.size()) {
            return this;
        }
        buildNumber(xyDataset, name);
        return this;
    }

    private void buildNumber(XYDataset xyDataset, String name) {
        if (xyDataset instanceof XYSeriesCollection) {
            XYSeries xySeries = new XYSeries(name);
            for (int i = 0, len = this.xValueList.size(); i < len; i++) {
                Double xValue = this.xValueList.get(i);
                Double yValue = this.yValueList.get(i);
                xySeries.add(xValue == xValue.intValue() ? xValue.intValue() : xValue, yValue == yValue.intValue() ? yValue.intValue() : yValue);
            }
            ((XYSeriesCollection) xyDataset).addSeries(xySeries);
        } else if (xyDataset instanceof TimeSeriesCollection) {
            TimeSeries series = new TimeSeries(name);
            Set<Long> timeSet = new HashSet<>(this.xValueList.size());
            for (int i = 0, len = this.xValueList.size(); i < len; i++) {
                Long xValueTime = Double.valueOf(this.xValueList.get(i)).longValue();
                if (timeSet.contains(xValueTime)) {
                    LOGGER.warn("Time already exists name: {} xValueTime: {}", name, xValueTime);
                    continue;
                }
                timeSet.add(xValueTime);
                Date xValue = new Date(xValueTime * 1000);
                Double yValue = this.yValueList.get(i);
                series.add(new TimeSeriesDataItem(new Second(xValue), yValue));
            }
            ((TimeSeriesCollection) xyDataset).addSeries(series);
        }
    }
}

package com.suyun.modules.testdata.model.entity;

import cn.afterturn.easypoi.entity.ImageEntity;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.suyun.common.lang.Tuple2;
import com.suyun.modules.testdata.constant.DayDmasChartConstants;
import com.suyun.vehicle.utils.DatetimeUtil;
import com.utils.lang.StringUtils;
import org.jfree.chart.renderer.xy.XYItemRenderer;
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
import org.springframework.util.CollectionUtils;

import java.io.Serializable;
import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.function.DoubleFunction;

/**
 * Description：
 *
 * @Author： leo.xiong
 * @CreateDate： 2021/9/1 14:28
 * @Email： leo.xiong@suyun360.com
 * @Since：
 */
public class DmasChartData implements Serializable {
    private static final long serialVersionUID = -4888193351504457493L;

    private static final String VALID_FLAG = "1";
    public static final String NO_VALID = "-1";

    private int index;

    private String imageTitleName;

    private String xLabel;

    private String yLabel;

    private Map<XYItemRenderer, Map<String, ChartStyleValue>> dotLineNameChartStyleValueMap = Maps.newHashMap();

    private XYItemRenderer lineRenderer = null;

    private XYItemRenderer dotRenderer = null;

    private ImageEntity imageEntity;
    /**
     * x轴最小值
     */
    private Double xMinValue;
    /**
     * x轴最大值
     */
    private Double xMaxValue;
    /**
     * x轴最小值
     */
    private Double yMinValue;
    /**
     * x轴最大值
     */
    private Double yMaxValue;
    /**
     * x分割值
     */
    private Double xNumberTick;
    /**
     * y分割值
     */
    private Double yNumberTick;
    /**
     * 图片宽度
     */
    private Integer width = 500;
    /**
     * 图片高度
     */
    private Integer height = 500;
    /**
     * 时间格式化，默认为年-月-日 时:分:秒
     */
    private String pattern = DatetimeUtil.TIME_FORMAT_Y_M_D;
    /**
     * X 轴是否是时间，默认否
     */
    private Boolean xIsTime = Boolean.FALSE;

    private Boolean dot = Boolean.TRUE;

    /**
     * 默认点状图，修改一次为线状图，继续又变为点
     * 循环切换
     *
     * @return
     */
    private DmasChartData toggle() {
        this.dot = this.dot ? Boolean.FALSE : Boolean.TRUE;
        return this;
    }

    /**
     * 直接设置是否点状图
     *
     * @param dot
     */
    public void setDotFlag(Boolean dot) {
        if (dot.equals(this.dot)) {
            return;
        }
        toggle();
    }

    private XYItemRenderer getRenderer() {
        return this.dot ? dotRenderer : lineRenderer;
    }

    public String getXLabel() {
        return xLabel;
    }

    public DmasChartData addXLabel(String xLabel) {
        this.xLabel = xLabel;
        return this;
    }

    public String getYLabel() {
        return yLabel;
    }

    public DmasChartData addYLabel(String yLabel) {
        this.yLabel = yLabel;
        return this;
    }

    public String getImageTitleName() {
        return imageTitleName;
    }

    public DmasChartData addImageTitleName(String imageTitleName) {
        this.imageTitleName = imageTitleName;
        return this;
    }

    public Map<XYItemRenderer, Map<String, ChartStyleValue>> getDotLineNameChartStyleValueMap() {
        return dotLineNameChartStyleValueMap;
    }

    public void putNameChartStyleValue(String name, ChartStyleValue chartStyleValue) {
        XYItemRenderer xyItemRenderer = this.getRenderer();
        if (xyItemRenderer == null) {
            if (this.dot) {
                xyItemRenderer = new XYLineAndShapeRenderer(Boolean.FALSE, Boolean.TRUE);
                this.dotRenderer = xyItemRenderer;
            } else {
                xyItemRenderer = new XYLineAndShapeRenderer();
                this.lineRenderer = xyItemRenderer;
            }
            this.dotLineNameChartStyleValueMap.put(xyItemRenderer, Maps.newLinkedHashMap());
        }
        this.dotLineNameChartStyleValueMap.get(xyItemRenderer).put(name, chartStyleValue);
    }

    public Double getXMinValue() {
        return xMinValue;
    }

    public DmasChartData addXMinValue(Double xMinValue) {
        this.xMinValue = xMinValue;
        return this;
    }

    public Double getXMaxValue() {
        return xMaxValue;
    }

    public DmasChartData addXMaxValue(Double xMaxValue) {
        this.xMaxValue = xMaxValue;
        return this;
    }

    public Double getYMinValue() {
        return yMinValue;
    }

    public DmasChartData addYMinValue(Double yMinValue) {
        this.yMinValue = yMinValue;
        return this;
    }

    public Double getYMaxValue() {
        return yMaxValue;
    }

    public DmasChartData addYMaxValue(Double yMaxValue) {
        this.yMaxValue = yMaxValue;
        return this;
    }


    public Integer getWidth() {
        return width;
    }

    public void setWidth(Integer width) {
        this.width = width;
    }

    public Integer getHeight() {
        return height;
    }

    public void setHeight(Integer height) {
        this.height = height;
    }

    public Double getXNumberTick() {
        return xNumberTick;
    }

    public DmasChartData addXNumberTick(Double xNumberTick) {
        this.xNumberTick = xNumberTick;
        return this;
    }

    public Double getYNumberTick() {
        return yNumberTick;
    }

    public DmasChartData addYNumberTick(Double yNumberTick) {
        this.yNumberTick = yNumberTick;
        return this;
    }

    public ImageEntity getImageEntity() {
        return imageEntity;
    }

    public void setImageEntity(ImageEntity imageEntity) {
        this.imageEntity = imageEntity;
    }

    public String getPattern() {
        return pattern;
    }

    public void setPattern(String pattern) {
        this.pattern = pattern;
    }

    public Boolean isTime() {
        return xIsTime;
    }

    public void setXIsTime(Boolean xIsTime) {
        this.xIsTime = xIsTime;
    }

    public int getIndex() {
        return index;
    }

    public DmasChartData addIndex(int index) {
        this.index = index;
        return this;
    }

    public void addXyValueList(String name, List<String> xValueList, List<String> yValueList, DoubleFunction<Double> xFunction, DoubleFunction<Double> yFunction) {
        if (CollectionUtils.isEmpty(xValueList) || CollectionUtils.isEmpty(yValueList) || xValueList.size() != yValueList.size()) {
            return;
        }
        ChartStyleValue chartStyleValue = this.dotLineNameChartStyleValueMap.get(getRenderer()).get(name);
        if (chartStyleValue == null) {
            return;
        }
        for (int i = 0, len = xValueList.size(); i < len; i++) {
            String xValue = xValueList.get(i);
            String yValue = yValueList.get(i);
            addXyValue(chartStyleValue, null, xValue, yValue, xFunction, yFunction);
        }
    }

    /**
     * 判断值是否有效，有效返回行数+1，否者返回前一次的行号
     *
     * @param name      数据集合名称
     * @param i         前一次行号,如果为空，这不需要传行号
     * @param xValue    传入的X值
     * @param yValue    传入的Y值
     * @param xFunction X执行的数据转换函数，为空，不转换
     * @param yFunction Y执行的数据转换函数，为空，不转换
     * @return
     */
    public Integer addXyValue(String name, Integer i, String xValue, String yValue, DoubleFunction<Double> xFunction, DoubleFunction<Double> yFunction) {
        return addXyValue(this.dotLineNameChartStyleValueMap.get(getRenderer()).get(name), i, xValue, yValue, xFunction, yFunction);
    }

    private Integer addXyValue(ChartStyleValue chartStyleValue, Integer i, String xValue, String yValue, DoubleFunction<Double> xFunction, DoubleFunction<Double> yFunction) {
        if (!isValidValue(xValue, yValue)) {
            return i;
        }
        if (chartStyleValue == null) {
            return i;
        }
        chartStyleValue.getXValueList().add(xFunction == null ? Double.valueOf(xValue) : xFunction.apply(Double.valueOf(xValue)));
        chartStyleValue.getYValueList().add(yFunction == null ? Double.valueOf(yValue) : yFunction.apply(Double.valueOf(yValue)));
        return i == null ? null : (i + 1);
    }


    /**
     * 是否有效FLAG 值为1有效
     * 有效返回TRUE,无效返回FALSE
     *
     * @param values
     * @return
     */
    public static boolean isValidFlag(String... values) {
        if (!isValidValue(values)) {
            return Boolean.FALSE;
        }
        for (String value : values) {
            if (!VALID_FLAG.equals(value)) {
                return Boolean.FALSE;
            }
        }
        return Boolean.TRUE;
    }

    /**
     * 是否有效值
     * 有效：TRUE，无效：FALSE
     *
     * @param values
     * @return
     */
    public static boolean isValidValue(String... values) {
        for (String value : values) {
            if (StringUtils.isEmpty(value)) {
                return Boolean.FALSE;
            }
        }
        return Boolean.TRUE;
    }

    public static String validAverage(String value) {
        return NO_VALID.equals(value) ? "" : value;
    }

    /**
     * 初始化数据容器信息，存在标准数据，初始化标准数据信息
     * key：头部信息
     * value：map集合 key：图片头部信息，数据信息
     * isSignalTestBench：是否批量测试信号
     *
     * @return
     */
    public static Map<String, Map<String, DmasChartData>> initDmasChartTargetData(DmasTargetParamFile dmasTargetParamFile, Map<String, List<String>> headerDataListMap) {
        Map<String, Map<String, DmasChartData>> headerTitleNameDataMap = Maps.newHashMap();
        for (int i = 0, len = DayDmasChartConstants.HEADER_NAME_LIST.size(); i < len; i++) {
            String headerName = DayDmasChartConstants.HEADER_NAME_LIST.get(i);
            Map<String, DmasChartData> titleNameDataMap = headerTitleNameDataMap.get(headerName);
            if (titleNameDataMap == null) {
                titleNameDataMap = new HashMap<>(3);
                headerTitleNameDataMap.put(headerName, titleNameDataMap);
            }
            String titleName = DayDmasChartConstants.IMAGE_NAME_LIST.get(i);
            DmasChartData dmasChartData = new DmasChartData().addIndex(i + 1)
                    .addImageTitleName(DayDmasChartConstants.IMAGE_TITLE_LIST.get(i))
                    .addXLabel(DayDmasChartConstants.IMAGE_X_LABEL_LIST.get(i))
                    .addYLabel(DayDmasChartConstants.IMAGE_Y_LABEL_LIST.get(i));
            switch (titleName) {
                case DayDmasChartConstants.AVERAGE_CELL_VOLTAGE_TIME_IMAGE:
                    dmasChartData.setDotFlag(Boolean.TRUE);
                    dmasChartData.setXIsTime(Boolean.TRUE);
                    dmasChartData.setPattern(DatetimeUtil.TIME_H_M_S);
                    ChartStyleValue chartStyleValue = new ChartStyleValue();
                    chartStyleValue.setEllipseIndex(0);
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.LINE_SPM_U_STK_VOLT, chartStyleValue);
                    break;
                case DayDmasChartConstants.AVERAGE_CELL_VOLTAGE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.UPPER_CELL_VOLTAGE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.LOWER_CELL_VOLTAGE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.AIR_MASS_FLOW_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.ANODE_DP_WITHOUT_PURGE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.ANODE_DP_WITH_PURGE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.HRB_SPEED_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.WCP_SPEED_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.ACP_SPEED_STACK_CURRENT_IMAGE:
                    //如果是批量信号，并且是上下堆整体电压分布，则无需画图
                    if (!dmasTargetParamFile.isSignalTestBench() && Lists.newArrayList(DayDmasChartConstants.LOWER_CELL_VOLTAGE_STACK_CURRENT_IMAGE, DayDmasChartConstants.UPPER_CELL_VOLTAGE_STACK_CURRENT_IMAGE).contains(titleName)) {
                        break;
                    }
                    dmasChartData.setDotFlag(Boolean.FALSE);
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.LINE_OPS, new ChartStyleValue());
                    dmasChartData.setDotFlag(Boolean.TRUE);
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_TRANSIENT, new ChartStyleValue(0));
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_2S, new ChartStyleValue(1));
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_10S, new ChartStyleValue(2));
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_30S, new ChartStyleValue(3));
                    dmasChartData.setDotFlag(Boolean.FALSE);
                    initOpsTargetOpsData(dmasChartData, DayDmasChartConstants.LINE_OPS, dmasTargetParamFile.getCellNum(), headerDataListMap, titleName);
                    break;
                case DayDmasChartConstants.AIR_INLET_PRESSURE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.COOLANT_INLET_TEMPERATURE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.COOLANT_DT_STACK_CURRENT_IMAGE:
                    dmasChartData.setDotFlag(Boolean.FALSE);
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.LINE_OPS, new ChartStyleValue(0));
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.LINE_OPS_UL, new ChartStyleValue(1));
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.LINE_OPS_LL, new ChartStyleValue(2));
                    dmasChartData.setDotFlag(Boolean.TRUE);
                    dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_TRANSIENT, new ChartStyleValue(0));
                    if (Lists.newArrayList(DayDmasChartConstants.AIR_INLET_PRESSURE_STACK_CURRENT_IMAGE).contains(titleName)) {
                        dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_2S, new ChartStyleValue(1));
                        dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_10S, new ChartStyleValue(2));
                        dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_30S, new ChartStyleValue(3));
                    } else {
                        dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_10S, new ChartStyleValue(1));
                        dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_30S, new ChartStyleValue(2));
                        dmasChartData.putNameChartStyleValue(DayDmasChartConstants.DOT_STABLE_60S, new ChartStyleValue(3));
                    }
                    dmasChartData.setDotFlag(Boolean.FALSE);
                    initOpsTargetOpsUlLlData(dmasChartData, headerDataListMap, titleName);
                    break;
                default:
                    break;
            }
            buildRangeValueByName(titleName, dmasTargetParamFile, dmasChartData, headerDataListMap);
            titleNameDataMap.put(titleName, dmasChartData);
        }
        return headerTitleNameDataMap;
    }

    /**
     * 初始化标准数据
     *
     * @param dmasChartData
     * @param cellNum
     * @param headerDataListMap
     * @param titleName
     * @return
     */
    private static void initOpsTargetOpsData(DmasChartData dmasChartData, String name, Integer cellNum, Map<String, List<String>> headerDataListMap, String titleName) {
        if (CollectionUtils.isEmpty(headerDataListMap)) {
            return;
        }
        List<String> xValueList = null, yValueList = null;
        if (Lists.newArrayList(DayDmasChartConstants.AIR_MASS_FLOW_STACK_CURRENT_IMAGE).contains(titleName)) {
            yValueList = headerDataListMap.get(DayDmasChartConstants.OPS_ADC_DM_MFM);
        } else if (Lists.newArrayList(DayDmasChartConstants.ANODE_DP_WITHOUT_PURGE_STACK_CURRENT_IMAGE, DayDmasChartConstants.ANODE_DP_WITH_PURGE_STACK_CURRENT_IMAGE).contains(titleName)) {
            yValueList = headerDataListMap.get(DayDmasChartConstants.ANODE_DP);
        } else if (Lists.newArrayList(DayDmasChartConstants.HRB_SPEED_STACK_CURRENT_IMAGE).contains(titleName)) {
            yValueList = headerDataListMap.get(DayDmasChartConstants.OPS_HDC_N_HRB_SPD);
        } else if (Lists.newArrayList(DayDmasChartConstants.WCP_SPEED_STACK_CURRENT_IMAGE).contains(titleName)) {
            yValueList = headerDataListMap.get(DayDmasChartConstants.OPS_CDC_N_WCP_SPD);
        } else if (Lists.newArrayList(DayDmasChartConstants.ACP_SPEED_STACK_CURRENT_IMAGE).contains(titleName)) {
            yValueList = headerDataListMap.get(DayDmasChartConstants.OPS_ADC_N_ACP_SPD);
        } else {
            yValueList = headerDataListMap.get(DayDmasChartConstants.OPS_SPM_U_STK_VOLT);
        }
        xValueList = headerDataListMap.get(DayDmasChartConstants.OPS_SPM_I_STK_CURR);
        if (Lists.newArrayList(DayDmasChartConstants.AVERAGE_CELL_VOLTAGE_STACK_CURRENT_IMAGE, DayDmasChartConstants.UPPER_CELL_VOLTAGE_STACK_CURRENT_IMAGE, DayDmasChartConstants.LOWER_CELL_VOLTAGE_STACK_CURRENT_IMAGE).contains(titleName)) {
            dmasChartData.addXyValueList(name, xValueList, yValueList, null, yValue -> {
                return yValue / cellNum * 1000;
            });
        } else {
            dmasChartData.addXyValueList(name, xValueList, yValueList, null, null);
        }
    }

    private static void initOpsTargetOpsUlLlData(DmasChartData dmasChartData, Map<String, List<String>> headerDataListMap, String titleName) {
        if (CollectionUtils.isEmpty(headerDataListMap)) {
            return;
        }
        List<String> xValueList = null, yValueOneList = null, yValueTwoList = null, yValueThreeList = null;
        switch (titleName) {
            case DayDmasChartConstants.AIR_INLET_PRESSURE_STACK_CURRENT_IMAGE:
                yValueOneList = headerDataListMap.get(DayDmasChartConstants.OPS_ADC_P_PRS_IN);
                yValueTwoList = headerDataListMap.get(DayDmasChartConstants.OPS_ADC_P_PRS_IN_UL);
                yValueThreeList = headerDataListMap.get(DayDmasChartConstants.OPS_ADC_P_PRS_IN_LL);
                break;
            case DayDmasChartConstants.COOLANT_INLET_TEMPERATURE_STACK_CURRENT_IMAGE:
                yValueOneList = headerDataListMap.get(DayDmasChartConstants.OPS_CDC_T_TEMP_IN);
                yValueTwoList = headerDataListMap.get(DayDmasChartConstants.OPS_CDC_T_TEMP_IN_UL);
                yValueThreeList = headerDataListMap.get(DayDmasChartConstants.OPS_CDC_T_TEMP_IN_LL);
                break;
            case DayDmasChartConstants.COOLANT_DT_STACK_CURRENT_IMAGE:
                yValueOneList = headerDataListMap.get(DayDmasChartConstants.DT);
                yValueTwoList = headerDataListMap.get(DayDmasChartConstants.DT_UL);
                yValueThreeList = headerDataListMap.get(DayDmasChartConstants.DT_LL);
                break;
            default:
                break;
        }
        xValueList = headerDataListMap.get(DayDmasChartConstants.OPS_SPM_I_STK_CURR);
        dmasChartData.addXyValueList(DayDmasChartConstants.LINE_OPS, xValueList, yValueOneList, null, null);
        dmasChartData.addXyValueList(DayDmasChartConstants.LINE_OPS_UL, xValueList, yValueTwoList, null, null);
        dmasChartData.addXyValueList(DayDmasChartConstants.LINE_OPS_LL, xValueList, yValueThreeList, null, null);
    }

    /**
     * 初始化 DmasChartData ，包含取值范围
     *
     * @param i
     * @param titleName
     * @param dmasTargetParamFile
     * @return
     */
    private static DmasChartData buildDmasChartData(int i, String titleName, DmasTargetParamFile dmasTargetParamFile) {
        DmasChartData dmasChartData = new DmasChartData().addIndex(i + 1)
                .addImageTitleName(DayDmasChartConstants.IMAGE_TITLE_LIST.get(i))
                .addXLabel(DayDmasChartConstants.IMAGE_X_LABEL_LIST.get(i))
                .addYLabel(DayDmasChartConstants.IMAGE_Y_LABEL_LIST.get(i));
        return dmasChartData;
    }

    /**
     * 补充最大最小值，分割值
     *
     * @param titleName
     * @param dmasTargetParamFile
     * @param dmasChartData
     */
    private static void buildRangeValueByName(String titleName, DmasTargetParamFile dmasTargetParamFile, DmasChartData dmasChartData, Map<String, List<String>> headerDataListMap) {
        Tuple2<DmasTargetParamRange, String> tuple2 = dmasTargetParamFile.getRangeValueByName(titleName);
        DmasTargetParamRange dmasTargetParamRange = tuple2._1();
        String[] defaultRangeValues = tuple2._2().split(",");
        if (dmasTargetParamRange.getxMinValue() != null) {
            dmasChartData.addXMinValue(dmasTargetParamRange.getxMinValue());
        } else if (StringUtils.isNotEmpty(defaultRangeValues[DmasTargetParamFile.X_MIN_INDEX])) {
            dmasChartData.addXMinValue(Double.valueOf(defaultRangeValues[DmasTargetParamFile.X_MIN_INDEX]));
        }
        if (dmasTargetParamRange.getxMaxValue() != null) {
            dmasChartData.addXMaxValue(dmasTargetParamRange.getxMaxValue());
        } else if (StringUtils.isNotEmpty(defaultRangeValues[DmasTargetParamFile.X_MAX_INDEX])) {
            dmasChartData.addXMaxValue(Double.valueOf(defaultRangeValues[DmasTargetParamFile.X_MAX_INDEX]));
        }
        if (dmasTargetParamRange.getyMinValue() != null) {
            dmasChartData.addYMinValue(dmasTargetParamRange.getyMinValue());
        } else if (StringUtils.isNotEmpty(defaultRangeValues[DmasTargetParamFile.Y_MIN_INDEX])) {
            dmasChartData.addYMinValue(Double.valueOf(defaultRangeValues[DmasTargetParamFile.Y_MIN_INDEX]));
        }
        if (DmasTargetParamFile.USE_FORMULA_VALUE == dmasChartData.getYMinValue().intValue()) {
            switch (titleName) {
                case DayDmasChartConstants.COOLANT_DT_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMinValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.DT_LL, DayDmasChartConstants.MIN_TYPE, (value) -> {
                        return Math.floor(value / 10) * 10;
                    }, -5D));
                    break;
                case DayDmasChartConstants.HRB_SPEED_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMinValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_HDC_N_HRB_SPD, DayDmasChartConstants.MIN_TYPE, (value) -> {
                        return Math.floor(value / 1000) * 1000;
                    }, 4000D));
                    break;
                case DayDmasChartConstants.WCP_SPEED_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMinValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_CDC_N_WCP_SPD, DayDmasChartConstants.MIN_TYPE, (value) -> {
                        return Math.floor(value / 1000) * 1000;
                    }, 1000D));
                    break;
                case DayDmasChartConstants.ACP_SPEED_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMinValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_ADC_N_ACP_SPD, DayDmasChartConstants.MIN_TYPE, (value) -> {
                        return Math.floor(value * 0.8 / 1000) * 1000;
                    }, 10000D));
                    break;
                default:
                    break;
            }
        }
        if (dmasTargetParamRange.getyMaxValue() != null) {
            dmasChartData.addYMaxValue(dmasTargetParamRange.getyMaxValue());
        } else if (StringUtils.isNotEmpty(defaultRangeValues[DmasTargetParamFile.Y_MAX_INDEX])) {
            dmasChartData.addYMaxValue(Double.valueOf(defaultRangeValues[DmasTargetParamFile.Y_MAX_INDEX]));
        }
        if (DmasTargetParamFile.USE_FORMULA_VALUE == dmasChartData.getYMaxValue().intValue()) {
            switch (titleName) {
                case DayDmasChartConstants.AIR_INLET_PRESSURE_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_ADC_P_PRS_IN_UL, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value / 10) * 10;
                    }, 230D));
                    break;
                case DayDmasChartConstants.AIR_MASS_FLOW_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_ADC_DM_MFM, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value * 1.2 / 10) * 10;
                    }, 140D));
                    break;
                case DayDmasChartConstants.ANODE_DP_WITHOUT_PURGE_STACK_CURRENT_IMAGE:
                case DayDmasChartConstants.ANODE_DP_WITH_PURGE_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.ANODE_DP, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value / 10) * 10;
                    }, 60D));
                    break;
                case DayDmasChartConstants.COOLANT_INLET_TEMPERATURE_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_CDC_T_TEMP_IN_UL, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value * 1.4 / 10) * 10;
                    }, 80D));
                    break;
                case DayDmasChartConstants.COOLANT_DT_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.DT_UL, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value / 10) * 10;
                    }, 35D));
                    break;
                case DayDmasChartConstants.HRB_SPEED_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_HDC_N_HRB_SPD, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value / 1000) * 1000;
                    }, 8000D));
                    break;
                case DayDmasChartConstants.WCP_SPEED_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_CDC_N_WCP_SPD, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value / 1000) * 1000;
                    }, 6000D));
                    break;
                case DayDmasChartConstants.ACP_SPEED_STACK_CURRENT_IMAGE:
                    dmasChartData.addYMaxValue(getCriticalValue(headerDataListMap, DayDmasChartConstants.OPS_ADC_N_ACP_SPD, DayDmasChartConstants.MAX_TYPE, (value) -> {
                        return Math.ceil(value * 1.2 / 1000) * 1000;
                    }, 90000D));
                    break;
                default:
                    break;
            }
        }
        if (dmasTargetParamRange.getWidth() != null) {
            dmasChartData.setWidth(dmasTargetParamRange.getWidth());
        } else if (StringUtils.isNotEmpty(defaultRangeValues[DmasTargetParamFile.WIDTH_INDEX])) {
            dmasChartData.setWidth(Integer.valueOf(defaultRangeValues[DmasTargetParamFile.WIDTH_INDEX]));
        } else {
            dmasChartData.setWidth(Integer.valueOf(DmasTargetParamFile.DEFAULT_WIGHT));
        }
        if (dmasTargetParamRange.getHeight() != null) {
            dmasChartData.setHeight(dmasTargetParamRange.getHeight());
        } else if (StringUtils.isNotEmpty(defaultRangeValues[DmasTargetParamFile.HEIGHT_INDEX])) {
            dmasChartData.setHeight(Integer.valueOf(defaultRangeValues[DmasTargetParamFile.HEIGHT_INDEX]));
        } else {
            dmasChartData.setHeight(Integer.valueOf(DmasTargetParamFile.DEFAULT_HEIGHT));
        }
        if (dmasTargetParamRange.getxNumberTick() != null) {
            dmasChartData.addXNumberTick(dmasTargetParamRange.getxNumberTick());
        } else if (dmasChartData.getXMinValue() != null && dmasChartData.getXMaxValue() != null && dmasChartData.getXNumberTick() == null) {
            dmasChartData.addXNumberTick(createNumberTick(dmasChartData.getXMaxValue(), dmasChartData.getXMinValue()));
        }
        if (dmasTargetParamRange.getyNumberTick() != null) {
            dmasChartData.addYNumberTick(dmasTargetParamRange.getyNumberTick());
        } else if (dmasChartData.getYMinValue() != null && dmasChartData.getYMaxValue() != null && dmasChartData.getYNumberTick() == null) {
            dmasChartData.addYNumberTick(createNumberTick(dmasChartData.getYMaxValue(), dmasChartData.getYMinValue()));
        }
    }

    /**
     * 获取临界值
     *
     * @param headerDataListMap
     * @param key
     * @param functionValue
     * @param defaultValue
     * @return
     */
    private static Double getCriticalValue(Map<String, List<String>> headerDataListMap, String key, String type, DoubleFunction<Double> functionValue, Double defaultValue) {
        List<String> dataList = headerDataListMap.get(key);
        if (CollectionUtils.isEmpty(dataList)) {
            return defaultValue;
        }
        Double maxValue = -1D;
        Double minValue = -1D;
        for (String dataValue : dataList) {
            if (StringUtils.isEmpty(dataValue)) {
                continue;
            }
            Double dataValueDouble = Double.valueOf(dataValue);
            if (DmasTargetParamFile.USE_FORMULA_VALUE == maxValue.intValue() || dataValueDouble > maxValue) {
                maxValue = dataValueDouble;
            }
            if (DmasTargetParamFile.USE_FORMULA_VALUE == minValue || dataValueDouble < minValue) {
                minValue = dataValueDouble;
            }
        }
        switch (type) {
            case DayDmasChartConstants.MAX_TYPE:
                return maxValue.intValue() == -1 ? defaultValue : functionValue.apply(maxValue);
            case DayDmasChartConstants.MIN_TYPE:
                return minValue.intValue() == -1 ? defaultValue : functionValue.apply(minValue);
            default:
                return defaultValue;
        }
    }

    /**
     * 探索在7到13之间，最合适的分割值
     *
     * @param maxValue
     * @param minValue
     * @return
     */
    private static Double createNumberTick(Double maxValue, Double minValue) {
        BigDecimal maxValueBigDecimal = new BigDecimal(maxValue);
        BigDecimal minValueBigDecimal = new BigDecimal(minValue);
        BigDecimal range = new BigDecimal(8);
        BigDecimal rangeValue = null;
        do {
            rangeValue = maxValueBigDecimal.subtract(minValueBigDecimal).divide(range, 0, BigDecimal.ROUND_HALF_UP);
            range = range.add(new BigDecimal(1));
        } while (rangeValue.doubleValue() % 10 != 0 && range.intValue() < 13 && range.intValue() >= 7);
        return rangeValue.doubleValue();
    }
}