TEAMModelOS/TEAMModelOS.Test.PPTX/PresentationConvert.cs

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Office2010.Drawing;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Presentation;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Linq;
using System.Xml.Xsl;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.Test.PPTX.PresentationElement;
using ColorMap = DocumentFormat.OpenXml.Presentation.ColorMap;
using Theme = DocumentFormat.OpenXml.Drawing.Theme;

namespace TEAMModelOS.Test.PPTX
{
    public class PresentationConvert
    {
        const int inchpixel = 96, inchpt = 72, pxBase = 914400,  ptBase = 12700;
        const int rotBase = 60000;
        /// <summary>
        /// 处理一页PPT的元素
        /// </summary>
        /// <param name="slidePart"></param>
        /// <param name="theme"></param>
        /// <param name="colorMap"></param>
        /// <returns></returns>
        public List<HtexElement> GetSlideElement(SlidePart slidePart, Theme theme, ColorMap colorMap)
        {
            List<HtexElement> elements = new List<HtexElement>();
            var shapeTrees = from shap in slidePart.Slide.Descendants<DocumentFormat.OpenXml.Presentation.ShapeTree>() select shap;
            if (shapeTrees.Count() > 0 && shapeTrees.First().ChildElements.Count > 0)
            {
                OpenXmlElementList openXmlElements = shapeTrees.First().ChildElements;
                int index = 0;
                foreach (OpenXmlElement element in openXmlElements)
                {
                    HtexElement pptElement = null;
                    if (element is DocumentFormat.OpenXml.Presentation.Shape shape)
                    { //p:sp
                        pptElement = ShapeConvert(shape, theme, colorMap, index);
                    }
                    if (element is DocumentFormat.OpenXml.Presentation.Picture picture)//p:pic
                    {
                        pptElement = PictureConvert(picture, slidePart, index);
                    }
                    if (element is DocumentFormat.OpenXml.AlternateContent content)//mc:alternatecontent 
                    {
                        pptElement = AlternateContentConvert(content, theme, colorMap, index);
                    }
                    if (element is DocumentFormat.OpenXml.Presentation.GraphicFrame graphicFrame)//p:graphicFrame
                    {
                        pptElement = GraphicFrameConvert(graphicFrame, theme, colorMap, index);
                    }
                    if (element is DocumentFormat.OpenXml.Presentation.GroupShape groupShape)//p:grpSp
                    {
                        pptElement = GroupShapeConvert(groupShape, theme, colorMap, index);
                    }
                    if (element is DocumentFormat.OpenXml.Presentation.ConnectionShape connectionShape) // p:cxnSp
                    {
                        pptElement = ConnectionShapeConvert(connectionShape, theme, colorMap, index);
                    }
                    if (pptElement != null) {
                        index++;
                        elements.Add(pptElement);
                    }
                }
            }
            return elements;
        }

        public HtexElement GroupShapeConvert(GroupShape groupShape, Theme theme, ColorMap colorMap, int index)
        {
            return null;
        }

        public HtexElement ConnectionShapeConvert(ConnectionShape connectionShape, Theme theme, ColorMap colorMap, int index)
        {
            string type = "";
            string fillColor = "";
            ShapeProperties properties = connectionShape.ShapeProperties;
            IEnumerable<DocumentFormat.OpenXml.Drawing.PresetGeometry> presetGeometries = GetPresetGeometry(properties);
            if (presetGeometries.Count() > 0)
            {
                type = presetGeometries.FirstOrDefault().Preset;
            }
            HtexConnector element = new HtexConnector() { Type = type };
            if (properties != null)
            {
                if (properties.Transform2D != null)
                {
                    element.OffX = properties.Transform2D.Offset.X  * inchpixel/pxBase;
                    element.OffY = properties.Transform2D.Offset.Y * inchpixel / pxBase;
                    element.ExtX = properties.Transform2D.Extents.Cx * inchpixel / pxBase;
                    element.ExtY = properties.Transform2D.Extents.Cy * inchpixel / pxBase;
                    element.FlipH = properties.Transform2D.HorizontalFlip != null ? BooleanValue.ToBoolean(properties.Transform2D.HorizontalFlip) : false;
                    element.FlipV = properties.Transform2D.VerticalFlip != null ? BooleanValue.ToBoolean(properties.Transform2D.VerticalFlip) : false;
                    element.Rot = (properties.Transform2D.Rotation != null ? properties.Transform2D.Rotation.Value : 0)/rotBase;

                }
                var headEnd = from shap in properties.Descendants<DocumentFormat.OpenXml.Drawing.HeadEnd>() select shap;
                var tailEnd = from shap in properties.Descendants<DocumentFormat.OpenXml.Drawing.TailEnd>() select shap;
                if (headEnd != null && headEnd.Count() > 0)
                {
                    element.HeadEnd = headEnd.First().Type;
                }
                if (tailEnd != null && tailEnd.Count() > 0)
                {
                    element.TailEnd = tailEnd.First().Type;
                }
                fillColor = GetPropertieFillColor(properties, theme, colorMap);
            }
            if (string.IsNullOrEmpty(fillColor))
            {
                fillColor = GetShapeStyleColor(connectionShape.ShapeStyle, "Fill", theme);
            }
            element.FillColor = fillColor;
            return element;
        }

        public HtexElement GraphicFrameConvert(GraphicFrame graphicFrame, Theme theme, ColorMap colorMap, int index)
        {

            DocumentFormat.OpenXml.Drawing.GraphicData graphicData = graphicFrame.ChildElements.First<DocumentFormat.OpenXml.Drawing.GraphicData>();
            if (graphicData != null)
            {
                OpenXmlElement element = graphicData.ChildElements.First();
                if (element != null)
                {
                    if (element is DocumentFormat.OpenXml.Drawing.Table table)
                    {
                        return TableConvert(graphicFrame, theme, colorMap);
                    }
                    if (element is DocumentFormat.OpenXml.Drawing.Chart chart)
                    {
                        //return ChartConvert(graphicFrame, theme, colorMap);
                    }
                    if (element is DocumentFormat.OpenXml.Drawing.Diagram diagram)
                    {
                        //return DiagramConvert(graphicFrame, theme, colorMap);
                    }
                }
            }
            return null;
        }
        public HtexElement TableConvert(GraphicFrame graphicFrame, Theme theme, ColorMap colorMap)
        {

            return null;
        }

        /// <summary>
        /// 处理普通形状的元素
        /// </summary>
        /// <param name="shape"></param>
        /// <returns></returns>
        public HtexElement ShapeConvert(Shape shape, Theme theme, ColorMap colorMap, int index)
        {
            // shape.base
            //文字颜色
            string textColor = "";
            //填充颜色
            string fillColor = "";
            // 形状类型
            string type = "rect";
            //字体大小
            int fontSize = 1800;
            //是否闭合形状
            bool complete = false;
            ShapeProperties properties = shape.ShapeProperties;
            IEnumerable<DocumentFormat.OpenXml.Drawing.PresetGeometry> presetGeometries = GetPresetGeometry(properties);
            IEnumerable<DocumentFormat.OpenXml.Drawing.CustomGeometry> customGeometries = GetCustomGeometry(properties);
            if (presetGeometries.Count() > 0)
            {
                type = presetGeometries.FirstOrDefault().Preset;
            }
            if (customGeometries.Count() > 0)
            {
                type = "custom";
            }

            DocumentFormat.OpenXml.Drawing.Transform2D transform2D = GetTransform2D(properties);
            HtexContainer element = new HtexContainer() { Type = type };
            if (transform2D != null)
            {
                element.Close = complete;
                element.OffX = transform2D.Offset.X * inchpixel / pxBase;
                element.OffY = transform2D.Offset.Y * inchpixel / pxBase;
                element.ExtX = transform2D.Extents.Cx * inchpixel / pxBase;
                element.ExtY = transform2D.Extents.Cy * inchpixel / pxBase;
                element.FlipH = transform2D.HorizontalFlip != null ? BooleanValue.ToBoolean(transform2D.HorizontalFlip) : false;
                element.FlipV = transform2D.VerticalFlip != null ? BooleanValue.ToBoolean(transform2D.VerticalFlip) : false;
                element.Rot = transform2D.Rotation != null ? transform2D.Rotation.Value : 0;

            }
            element.Index = index;
            ///获取runs的文本及颜色信息
            var runs = from shap in shape.Descendants<DocumentFormat.OpenXml.Drawing.Run>() select shap;

            foreach (var run in runs)
            {
                HtexText text = new HtexText() ;
                var runprps = from shap in run.Descendants<DocumentFormat.OpenXml.Drawing.RunProperties>() select shap;
                DocumentFormat.OpenXml.Drawing.RunProperties runProperties = runprps.FirstOrDefault();

                if (runProperties != null)
                {
                    if (runProperties.FontSize != null) {
                        text.FontSize = runProperties.FontSize;
                    }
                    if (runProperties.Italic != null)
                    {
                        text.FontItalic = runProperties.Italic;
                    }
                    if (runProperties.Bold != null)
                    {
                        text.FontBold = runProperties.Bold;
                    }
                    //if (runProperties.Italic != null)
                    //{
                    //    text.FontBold = runProperties.Bold;
                    //}
                    if (runProperties.Underline != null )
                    {
                        text.FontLine =(int)runProperties.Underline.Value;
                    }
                }
                var schemeColor = from shap in run.Descendants<DocumentFormat.OpenXml.Drawing.SchemeColor>() select shap;
                var rgbColors = from shap in run.Descendants<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>() select shap;
                textColor = GetSchemeColor(schemeColor, theme, colorMap);
                if (string.IsNullOrEmpty(textColor))
                {
                    text.TextColor=textColor = GetRgbColor(rgbColors);
                }
                text.Text = run.InnerText;
                element.Texts.Add(text);
            }
            if (string.IsNullOrEmpty(textColor))
            {
                textColor = GetShapeStyleColor(shape.ShapeStyle, "Font", theme);
            }
            if (string.IsNullOrEmpty(fillColor))
            {
                fillColor = GetShapeStyleColor(shape.ShapeStyle, "Fill", theme);
            }
            if (string.IsNullOrEmpty(fillColor))
            {
                fillColor = GetPropertieFillColor(properties, theme, colorMap);
            }
            element.FillColor = fillColor;
            var custGeometrys = from shap in properties.Descendants<DocumentFormat.OpenXml.Drawing.CustomGeometry>() select shap;
            if (custGeometrys.Count() > 0)
            {
                var pathLists = from shap in custGeometrys.First().Descendants<DocumentFormat.OpenXml.Drawing.Path>() select shap;
                if (pathLists.Count() > 0)
                {
                    element.Close = false;
                    OpenXmlElementList elements = pathLists.First().ChildElements;
                    foreach (OpenXmlElement xmlElement in elements)
                    {
                        //起点
                        if (xmlElement is DocumentFormat.OpenXml.Drawing.MoveTo moveTo)
                        {
                            DocumentFormat.OpenXml.Drawing.Point point = moveTo.Point;
                            HtexMoveToPath moveToPath = new HtexMoveToPath { Type = "MoveTo" };
                            moveToPath.Pts.Add(new Point { X = int.Parse(point.X) * inchpixel / pxBase, Y = int.Parse(point.Y) * inchpixel / pxBase });
                            element.Paths.Add(moveToPath);
                        }
                        //连线
                        if (xmlElement is DocumentFormat.OpenXml.Drawing.LineTo linTo)
                        {
                            DocumentFormat.OpenXml.Drawing.Point point = linTo.Point;
                            HtexLineToPath lineToPath = new HtexLineToPath { Type = "LineTo"  };
                            lineToPath.Pts.Add(new Point { X = int.Parse(point.X) * inchpixel / pxBase, Y = int.Parse(point.Y) * inchpixel / pxBase });
                            element.Paths.Add(lineToPath);
                        }
                        //三次贝塞尔曲线
                        if (xmlElement is DocumentFormat.OpenXml.Drawing.CubicBezierCurveTo cubicBezierCurveTo)
                        {
                            OpenXmlElementList list = cubicBezierCurveTo.ChildElements;
                            HtexCubicBezPath cubicBezPath = new HtexCubicBezPath { Type = "CubicBez" };
                            foreach (var ls in list)
                            {
                                if (ls is DocumentFormat.OpenXml.Drawing.Point point)
                                {
                                    cubicBezPath.Pts.Add(new Point { X = int.Parse(point.X) * inchpixel / pxBase, Y = int.Parse(point.Y) * inchpixel / pxBase });
                                }
                            }
                            element.Paths.Add(cubicBezPath);
                        }
                        //二次贝塞尔曲线
                        if (xmlElement is DocumentFormat.OpenXml.Drawing.QuadraticBezierCurveTo quadraticBezierCurveTo)
                        {
                            OpenXmlElementList list = quadraticBezierCurveTo.ChildElements;
                            HtexQuadBezPath quadBezPath = new HtexQuadBezPath { Type = "QuadBez" };
                            foreach (var ls in list)
                            {
                                if (ls is DocumentFormat.OpenXml.Drawing.Point point)
                                {
                                    quadBezPath.Pts.Add(new Point { X = int.Parse(point.X) * inchpixel / pxBase, Y =int.Parse(point.Y) * inchpixel / pxBase });
                                 
                                }
                            }
                            element.Paths.Add(quadBezPath);
                        }
                        //处理曲线
                        if (xmlElement is DocumentFormat.OpenXml.Drawing.ArcTo arcTO)
                        {
                            HtexArcToPath arcToPath = new HtexArcToPath() { WidthRadius = arcTO.WidthRadius, HeightRadius = arcTO.HeightRadius, StartAngle = arcTO.StartAngle, SwingAngle = arcTO.SwingAngle };
                            element.Paths.Add(arcToPath);
                        }
                        ///判断路径是否闭合
                        if (xmlElement is DocumentFormat.OpenXml.Drawing.CloseShapePath close)
                        {
                            if (close != null)
                            {
                                element.Close = true;
                            }
                        }
                    }
                }
            }
            return element;
        }
        /// <summary>
        /// 处理图片的元素
        /// </summary>
        /// <param name="picture"></param>
        /// <returns></returns>
        public HtexElement PictureConvert(Picture picture, SlidePart slidePart, int index)
        {
            BlipFill blipFill = picture.BlipFill;
            var imageRid = blipFill.Blip.Embed.Value;
            IdPartPair idParie = slidePart.Parts.Where(x => x.RelationshipId == imageRid).FirstOrDefault();
            ImagePart imagePart = (ImagePart)idParie.OpenXmlPart;
            var contentType = imagePart.ContentType;
            string base64 = "";
            using (var stream = imagePart.GetStream())
            {
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                stream.Close();
                base64 = System.Convert.ToBase64String(buffer);
                base64 = "data:" + contentType + ";base64," + base64;
            }
            ShapeProperties properties = picture.ShapeProperties;
            HtexPicture element = new HtexPicture();
            if (properties != null && properties.Transform2D != null)
            {
                element.OffX = properties.Transform2D.Offset.X * inchpixel / pxBase;
                element.OffY = properties.Transform2D.Offset.Y * inchpixel / pxBase;
                element.ExtX = properties.Transform2D.Extents.Cx * inchpixel / pxBase;
                element.ExtY = properties.Transform2D.Extents.Cy * inchpixel / pxBase;
                element.FlipH = properties.Transform2D.HorizontalFlip != null ? BooleanValue.ToBoolean(properties.Transform2D.HorizontalFlip) : false;
                element.FlipV = properties.Transform2D.VerticalFlip != null ? BooleanValue.ToBoolean(properties.Transform2D.VerticalFlip) : false;
                element.Rot = properties.Transform2D.Rotation != null ? properties.Transform2D.Rotation.Value : 0;
            }
            element.Data = base64;
            return element;
        }
        /// <summary>
        /// 处理兼容元素
        /// </summary>
        /// <param name="picture"></param>
        /// <returns></returns>
        public HtexElement AlternateContentConvert(AlternateContent content, Theme theme, ColorMap colorMap, int index)
        {
            AlternateContentChoice choice = content.ChildElements.First<AlternateContentChoice>();
            OpenXmlElement element = choice.ChildElements.First();
            if (element != null)
            {
                if (element is DocumentFormat.OpenXml.Presentation.Shape shape)
                {
                    var textMaths = from shap in shape.Descendants<TextMath>() select shap;
                    if (textMaths.Count() > 0)
                    {
                        return MathConvert(shape, theme, colorMap);
                    }
                }
            }
            return null;
        }
        /// <summary>
        /// 处理公式
        /// </summary>
        /// <param name="shape"></param>
        /// <param name="theme"></param>
        /// <param name="colorMap"></param>
        /// <returns></returns>
        public HtexElement MathConvert(DocumentFormat.OpenXml.Presentation.Shape shape, Theme theme, ColorMap colorMap)
        {
            //文字颜色
            string textColor = "";
            //填充颜色
            string fillColor = "";
            // 形状类型
            string type = "math";
            //字体大小
            int fontSize = 1800;
            //是否闭合形状
            bool complete = true;
            ShapeProperties properties = shape.ShapeProperties;
            //IEnumerable<DocumentFormat.OpenXml.Drawing.PresetGeometry> presetGeometries = GetPresetGeometry(properties);
            //if (presetGeometries.Count() > 0)
            //{
            //    type = presetGeometries.FirstOrDefault().Preset;
            //}
            DocumentFormat.OpenXml.Drawing.Transform2D transform2D = GetTransform2D(properties);
            HtexContainer element = new HtexContainer() { Type = type };
            if (transform2D != null)
            {
                element.Close = complete;
                element.OffX = properties.Transform2D.Offset.X * inchpixel / pxBase;
                element.OffY = properties.Transform2D.Offset.Y * inchpixel / pxBase;
                element.ExtX = properties.Transform2D.Extents.Cx * inchpixel / pxBase;
                element.ExtY = properties.Transform2D.Extents.Cy * inchpixel / pxBase;
                element.FlipH = properties.Transform2D.HorizontalFlip != null ? BooleanValue.ToBoolean(properties.Transform2D.HorizontalFlip) : false;
                element.FlipV = properties.Transform2D.VerticalFlip != null ? BooleanValue.ToBoolean(properties.Transform2D.VerticalFlip) : false;
                element.Rot = properties.Transform2D.Rotation != null ? properties.Transform2D.Rotation.Value : 0;
            }
            //获取行内样式
            if (string.IsNullOrEmpty(textColor))
            {
                var rgbColor = from shap in shape.TextBody.Descendants<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>() select shap;
                textColor = GetRgbColor(rgbColor);
                if (string.IsNullOrEmpty(textColor))
                {
                    var schemes = from shap in shape.TextBody.Descendants<DocumentFormat.OpenXml.Drawing.SchemeColor>() select shap;
                    textColor = GetSchemeColor(schemes, theme, colorMap);
                }
            }
            if (string.IsNullOrEmpty(textColor))
            {
                textColor = GetShapeStyleColor(shape.ShapeStyle, "Font", theme);
            }
            if (string.IsNullOrEmpty(fillColor))
            {
                fillColor = GetShapeStyleColor(shape.ShapeStyle, "Fill", theme);
            }
            if (string.IsNullOrEmpty(fillColor))
            {
                fillColor = GetPropertieFillColor(properties, theme, colorMap);
            }
            element.FillColor = fillColor;
            var textMaths = from shap in shape.Descendants<TextMath>() select shap;
            var math = textMaths.First<TextMath>();
            string elementData = ProcessOMath(math.InnerXml);
            element.Texts.Add(new HtexText { TextColor = textColor, Text = elementData, FontSize = fontSize });
            return element;
        }
        /// <summary>
        /// 处理元素的Transform2D属性
        /// </summary>
        /// <param name="properties"></param>
        /// <returns></returns>
        public DocumentFormat.OpenXml.Drawing.Transform2D GetTransform2D(ShapeProperties properties)
        {
            if (properties != null)
            {
                return properties.Transform2D;
            }
            return null;
        }
        /// <summary>
        /// 处理元素的Transform2D 系统默认的元素
        /// </summary>
        /// <param name="properties"></param>
        /// <returns></returns>
        public IEnumerable<DocumentFormat.OpenXml.Drawing.PresetGeometry> GetPresetGeometry(ShapeProperties properties)
        {
            if (properties != null)
            {
                var presetGeometrys = from shap in properties.Descendants<DocumentFormat.OpenXml.Drawing.PresetGeometry>() select shap;
                return presetGeometrys;
            }
            return null;
        }
        public IEnumerable<DocumentFormat.OpenXml.Drawing.CustomGeometry> GetCustomGeometry(ShapeProperties properties)
        {
            if (properties != null)
            {
                var customGeometrys = from shap in properties.Descendants<DocumentFormat.OpenXml.Drawing.CustomGeometry>() select shap;
                return customGeometrys;
            }
            return null;
        }
        /// <summary>
        /// 处理元素属性的填充色
        /// </summary>
        /// <param name="properties"></param>
        /// <returns></returns>
        public string GetPropertieFillColor(ShapeProperties properties, Theme theme, ColorMap colorMap)
        {
            string fillColor = "";
            if (properties != null)
            {
                var solidFills = from shape in properties.Descendants<DocumentFormat.OpenXml.Drawing.SolidFill>() select shape;
                if (solidFills.Count() > 0)
                {
                    var propRgbColor = from shape in solidFills.First().Descendants<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>() select shape;
                    fillColor = GetRgbColor(propRgbColor);
                    if (string.IsNullOrEmpty(fillColor))
                    {
                        var colorScheme = from shape in solidFills.First().Descendants<DocumentFormat.OpenXml.Drawing.SchemeColor>() select shape;
                        fillColor = GetSchemeColor(colorScheme, theme, colorMap);
                    }
                }
            }
            return fillColor;
        }

        /// <summary>
        /// 获取ShapeStyle样式表 各种属性 的颜色
        /// </summary>
        /// <param name="shapeStyle"></param>
        /// <param name="colorType"></param>
        /// <param name="theme"></param>
        /// <returns></returns>
        public string GetShapeStyleColor(DocumentFormat.OpenXml.Presentation.ShapeStyle shapeStyle, string colorType, Theme theme)
        {
            if (shapeStyle == null)
            {
                return "";
            }
            // 效果颜色
            if (colorType.Equals("Effect"))
            {
                DocumentFormat.OpenXml.Drawing.SchemeColor EffectcolorScheme = shapeStyle.EffectReference.ChildElements.First<DocumentFormat.OpenXml.Drawing.SchemeColor>();
                return ColorForThemeClr(EffectcolorScheme.Val, theme);
            }
            // 线条颜色
            if (colorType.Equals("Line"))
            {
                DocumentFormat.OpenXml.Drawing.SchemeColor LinecolorScheme = shapeStyle.LineReference.ChildElements.First<DocumentFormat.OpenXml.Drawing.SchemeColor>();
                return ColorForThemeClr(LinecolorScheme.Val, theme);
            }
            // 填充色
            if (colorType.Equals("Fill"))
            {
                DocumentFormat.OpenXml.Drawing.SchemeColor FillcolorScheme = shapeStyle.FillReference.ChildElements.First<DocumentFormat.OpenXml.Drawing.SchemeColor>();
                return ColorForThemeClr(FillcolorScheme.Val, theme);
            }
            // 字体颜色
            if (colorType.Equals("Font"))
            {
                DocumentFormat.OpenXml.Drawing.SchemeColor FontcolorScheme = shapeStyle.FontReference.ChildElements.First<DocumentFormat.OpenXml.Drawing.SchemeColor>();
                return ColorForThemeClr(FontcolorScheme.Val, theme);
            }
            return "";
        }

        /// <summary>
        /// 获取声明式颜色
        /// </summary>
        /// <param name="rgbColors"></param>
        /// <returns></returns>
        public string GetSchemeColor(IEnumerable<DocumentFormat.OpenXml.Drawing.SchemeColor> colorScheme, Theme theme, ColorMap colorMap)
        {
            string rgbColor = "";
            if (colorScheme.Count() > 0)
            {
                rgbColor = ColorForThemeClr(SchemeColorForColorMap(colorScheme.FirstOrDefault().Val.Value, colorMap), theme);
            }
            return rgbColor;
        }
        /// <summary>
        /// 获取RGBColor
        /// </summary>
        /// <param name="rgbColors"></param>
        /// <returns></returns>
        public string GetRgbColor(IEnumerable<DocumentFormat.OpenXml.Drawing.RgbColorModelHex> rgbColors)
        {
            string rgbColor = "";
            if (rgbColors.Count() > 0)
            {
                rgbColor = rgbColors.FirstOrDefault().Val;
            }
            return rgbColor;
        }
        /// <summary>
        /// 加载PPTX文件
        /// </summary>
        /// <param name="presentationFile"></param>
        /// <returns></returns>
        public object LoadPresentation(string presentationFile)
        {
            using (PresentationDocument presentationDocument = PresentationDocument.Open(presentationFile, false))
            {
                if (presentationDocument == null)
                {
                    throw new ArgumentNullException("presentationDocument");
                }
                // Get a PresentationPart object from the PresentationDocument object.
                PresentationPart presentationPart = presentationDocument.PresentationPart;
                if (presentationPart != null && presentationPart.Presentation != null)
                {
                    var slideMasterParts = presentationPart.SlideMasterParts;
                    ColorMap colorMap = null;
                    Theme theme = null;
                    foreach (var slideMasterPart in slideMasterParts)
                    {
                        if (colorMap != null && theme != null)
                        {
                            break;
                        }
                        colorMap = slideMasterPart.SlideMaster.ColorMap;
                        theme = slideMasterPart.ThemePart.Theme;
                    }
                    // Get a Presentation object from the PresentationPart object.
                    Presentation presentation = presentationPart.Presentation;
                    if (presentation.SlideIdList != null)
                    {
                        //获取PPT 一页大小
                        int x = presentation.SlideSize.Cx;
                        int y = presentation.SlideSize.Cy;
                        // Get the title of each slide in the slide order.
                        // 获取的是几页PPT数量
                        foreach (var slideId in presentation.SlideIdList.Elements<SlideId>())
                        {
                            // 获取这一页 PPT 的id 
                            string id = slideId.RelationshipId;
                            SlidePart slidePart = presentationPart.GetPartById(slideId.RelationshipId) as SlidePart;
                            //获取当前页 PPT 的所有元素
                            GetSlideElement(slidePart, theme, colorMap);
                        }
                    }
                }
                return null;
            }
        }
        /// <summary>
        /// 在主题Theme中获取颜色
        /// </summary>
        /// <param name="scv"></param>
        /// <param name="theme"></param>
        /// <returns></returns>
        public static string ColorForThemeClr(string scv, Theme theme)
        {
            DocumentFormat.OpenXml.Drawing.ColorScheme colorScheme = theme.ThemeElements.ColorScheme;
            string colorStr = "";
            if (scv.Equals("dk1"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Dark1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Dark1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            if (scv.Equals("dk2"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Dark2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Dark2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent1"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent2"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent3"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent3Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent3Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent4"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent4Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent4Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent5"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent5Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent5Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("accent6"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Accent6Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Accent6Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("lt1"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Light1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Light1Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("lt2"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Light2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Light2Color.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("hlink"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.Hyperlink.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.Hyperlink.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            else if (scv.Equals("folHlink"))
            {
                DocumentFormat.OpenXml.Drawing.SystemColor sysColor = colorScheme.FollowedHyperlinkColor.ChildElements.First<DocumentFormat.OpenXml.Drawing.SystemColor>();
                if (sysColor != null)
                {
                    return sysColor.LastColor;
                }
                DocumentFormat.OpenXml.Drawing.RgbColorModelHex rgbColor = colorScheme.FollowedHyperlinkColor.ChildElements.First<DocumentFormat.OpenXml.Drawing.RgbColorModelHex>();
                if (rgbColor != null)
                {
                    return rgbColor.Val;
                }
                return colorStr;
            }
            return "";
        }
        /// <summary>
        /// 按照ColorMap 去寻找对应的颜色 
        /// </summary>
        /// <param name="schemeColorValues"></param>
        /// <param name="colorMap"></param>
        /// <returns></returns>
        public static string SchemeColorForColorMap(DocumentFormat.OpenXml.Drawing.SchemeColorValues schemeColorValues, ColorMap colorMap)
        {
            string scv = schemeColorValues.ToString();
            if (scv.Equals("Text1"))
            {
                return colorMap.Text1.ToString();
            }
            if (scv.Equals("Text2"))
            {
                return colorMap.Text2.ToString();
            }
            else if (scv.Equals("Accent1"))
            {
                return colorMap.Accent1.ToString();
            }
            else if (scv.Equals("Accent2"))
            {
                return colorMap.Accent2.ToString();
            }
            else if (scv.Equals("Accent3"))
            {
                return colorMap.Accent3.ToString();
            }
            else if (scv.Equals("Accent4"))
            {
                return colorMap.Accent4.ToString();
            }
            else if (scv.Equals("Accent5"))
            {
                return colorMap.Accent5.ToString();
            }
            else if (scv.Equals("Accent6"))
            {
                return colorMap.Accent6.ToString();
            }
            else if (scv.Equals("Background1"))
            {
                return colorMap.Background1.ToString();
            }
            else if (scv.Equals("Background2"))
            {
                return colorMap.Background2.ToString();
            }
            else if (scv.Equals("Hyperlink"))
            {
                return colorMap.Hyperlink.ToString();
            }
            else if (scv.Equals("FollowedHyperlink"))
            {
                return colorMap.FollowedHyperlink.ToString();
            }
            else if (scv.Equals("PhColor"))
            {
                return "PhColor";
            }
            else if (scv.Equals("Dark1"))
            {
                return "dk1";
            }
            else if (scv.Equals("Dark2"))
            {
                return "dk2";
            }
            else if (scv.Equals("Light1"))
            {
                return "lt1";
            }
            else if (scv.Equals("Light2"))
            {
                return "lt2";
            }
            return null;
        }

        /// <summary>
        /// 转换Surrogate 类型的编码的字符串
        /// </summary>
        /// <param name="xml"></param>
        /// <returns></returns>
        public static Dictionary<string, string> StringEncode(string xml)
        {
            Dictionary<string, string> codeValues = new Dictionary<string, string>();
            Char[] charstr = xml.ToCharArray();
            int len = charstr.Length;
            for (int i = 0; i < len; i++)
            {
                var stringBuilder = "";
                string str = Char.ToString(charstr[i]);
                if (Char.GetUnicodeCategory(charstr[i]) == UnicodeCategory.Surrogate)
                {
                    string str1 = Char.ToString(charstr[i + 1]);
                    str += str1;
                    var bytes = Encoding.UTF32.GetBytes(str);
                    for (var j = 0; j < bytes.Length; j += 2)
                    {
                        stringBuilder = bytes[j + 1].ToString("x").PadLeft(2, '0') + bytes[j].ToString("x").PadLeft(2, '0') + stringBuilder;
                    }
                    var id = Convert.ToInt64(stringBuilder, 16);
                    i += 1;
                    string code = id + "";
                    codeValues.TryAdd(str, code);
                }
            }
            return codeValues;
        }

        /// <summary>
        /// 根据OfficeML转换为MathML
        /// </summary>
        /// <param name="innerXml"></param>
        /// <returns></returns>
        public static string ProcessOMath(string innerXml)
        {
            Dictionary<string, string> codeValues = StringEncode(innerXml);
            if (codeValues != null)
            {
                foreach (string codeValue in codeValues.Keys)
                {
                    innerXml = Regex.Replace(innerXml, codeValue, codeValues[codeValue]);
                }
            }
            XElement element = XElement.Load(new StringReader(innerXml));
            List<XElement> elements = element.Elements().ToList();
            element = elements.Where(x => x.Name.LocalName.Equals("oMath")).FirstOrDefault();
            XslCompiledTransform xslTransform = new XslCompiledTransform();
            xslTransform.Load("E:/document/OMML2MML.XSL");
            string mathXml = element.ToString();
            string officeML = string.Empty;
            using (TextReader tr = new StringReader(mathXml))
            {
                using (XmlReader reader = XmlReader.Create(tr))
                {
                    using (MemoryStream ms = new MemoryStream())
                    {
                        XmlWriterSettings settings = xslTransform.OutputSettings.Clone();
                        settings.ConformanceLevel = ConformanceLevel.Fragment;
                        settings.OmitXmlDeclaration = true;
                        settings.Encoding = Encoding.Unicode;
                        XmlWriter xw = XmlWriter.Create(ms, settings);
                        xslTransform.Transform(reader, xw);
                        ms.Seek(0, SeekOrigin.Begin);
                        using (StreamReader sr = new StreamReader(ms, Encoding.UTF8))
                        {
                            officeML = sr.ReadToEnd();
                        }
                    }
                }
            }
            officeML = officeML.Replace("mml:", "");
            if (codeValues != null)
            {
                foreach (string codeValue in codeValues.Keys)
                {
                    officeML = Regex.Replace(officeML, codeValues[codeValue], codeValue);
                }
            }
            return officeML;
        }
    }
}