使用Aspose组件将WORD、PDF、PPT转为图片

1. 参考资料：http://www.studyofnet.com/news/1268.html
2. 
   
3. 
   
4. 
   
5. using System;  
6. using System.Collections.Generic;  
7. using System.Text;  
8. using OMCS.Engine.WhiteBoard;  
9. using ESBasic;  
10. using System.Drawing.Imaging;  
11. using System.IO;  
12. using System.Drawing;  
13. using Schematrix;  
14.   
15. namespace OMCS.Demos.WhiteBoardTest  
16. {  
17.     /**//*   
18.      *  
19.      * 将pdf、ppf、word转换给图片的组件有很多，这里仅使用Aspose组件（试用版）作为示例。 
20.      *  
21.      *  
22.      */  
23.   
24.     图片转换器工厂 -> 将被注入到OMCS的多媒体管理器IMultimediaManager的ImageConverterFactory属性#region 图片转换器工厂 -> 将被注入到OMCS的多媒体管理器IMultimediaManager的ImageConverterFactory属性  
25.     /**//// <summary>  
26.     /// 图片转换器工厂。  
27.     /// </summary>  
28.     public class ImageConverterFactory : IImageConverterFactory  
29.     {  
30.         public IImageConverter CreateImageConverter(string extendName)  
31.         {  
32.             if (extendName == ".doc" || extendName == ".docx")  
33.             {  
34.                 return new Word2ImageConverter();  
35.             }  
36.   
37.             if (extendName == ".pdf")  
38.             {  
39.                 return new Pdf2ImageConverter();  
40.             }  
41.   
42.             if (extendName == ".ppt" || extendName == ".pptx")  
43.             {  
44.                 return new Ppt2ImageConverter();  
45.             }  
46.   
47.             if (extendName == ".rar")  
48.             {  
49.                 return new Rar2ImageConverter();   
50.             }  
51.   
52.             return null;  
53.         }  
54.   
55.         public bool Support(string extendName)  
56.         {  
57.             return extendName == ".doc" || extendName == ".docx" || extendName == ".pdf" || extendName == ".ppt" || extendName == ".pptx" || extendName == ".rar";  
58.         }  
59.     }   
60.     #endregion  
61.   
62.     将word文档转换为图片#region 将word文档转换为图片  
63.     public class Word2ImageConverter : IImageConverter  
64.     {  
65.         private bool cancelled = false;  
66.         public event CbGeneric<int, int> ProgressChanged;  
67.         public event CbGeneric ConvertSucceed;  
68.         public event CbGeneric<string> ConvertFailed;  
69.   
70.         public void Cancel()  
71.         {  
72.             if (this.cancelled)  
73.             {  
74.                 return;  
75.             }  
76.   
77.             this.cancelled = true;  
78.         }  
79.   
80.         public void ConvertToImage(string originFilePath, string imageOutputDirPath)  
81.         {  
82.             this.cancelled = false;  
83.             ConvertToImage(originFilePath, imageOutputDirPath, 0, 0, null, 200);  
84.         }  
85.   
86.         /**//// <summary>  
87.         /// 将Word文档转换为图片的方法        
88.         /// </summary>  
89.         /// <param name="wordInputPath">Word文件路径</param>  
90.         /// <param name="imageOutputDirPath">图片输出路径，如果为空，默认值为Word所在路径</param>        
91.         /// <param name="startPageNum">从PDF文档的第几页开始转换，如果为0，默认值为1</param>  
92.         /// <param name="endPageNum">从PDF文档的第几页开始停止转换，如果为0，默认值为Word总页数</param>  
93.         /// <param name="imageFormat">设置所需图片格式，如果为null，默认格式为PNG</param>  
94.         /// <param name="resolution">设置图片的像素，数字越大越清晰，如果为0，默认值为128，建议最大值不要超过1024</param>  
95.         private void ConvertToImage(string wordInputPath, string imageOutputDirPath, int startPageNum, int endPageNum, ImageFormat imageFormat, int resolution)  
96.         {  
97.             try  
98.             {  
99.                 Aspose.Words.Document doc = new Aspose.Words.Document(wordInputPath);  
100.   
101.                 if (doc == null)  
102.                 {  
103.                     throw new Exception("Word文件无效或者Word文件被加密！");  
104.                 }  
105.   
106.                 if (imageOutputDirPath.Trim().Length == 0)  
107.                 {  
108.                     imageOutputDirPath = Path.GetDirectoryName(wordInputPath);  
109.                 }  
110.   
111.                 if (!Directory.Exists(imageOutputDirPath))  
112.                 {  
113.                     Directory.CreateDirectory(imageOutputDirPath);  
114.                 }                 
115.   
116.                 if (startPageNum <= 0)  
117.                 {  
118.                     startPageNum = 1;  
119.                 }  
120.   
121.                 if (endPageNum > doc.PageCount || endPageNum <= 0)  
122.                 {  
123.                     endPageNum = doc.PageCount;  
124.                 }  
125.   
126.                 if (startPageNum > endPageNum)  
127.                 {  
128.                     int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum;  
129.                 }  
130.   
131.                 if (imageFormat == null)  
132.                 {  
133.                     imageFormat = ImageFormat.Png;  
134.                 }  
135.   
136.                 if (resolution <= 0)  
137.                 {  
138.                     resolution = 128;  
139.                 }  
140.   
141.                 string imageName = Path.GetFileNameWithoutExtension(wordInputPath);  
142.                 Aspose.Words.Saving.ImageSaveOptions imageSaveOptions = new Aspose.Words.Saving.ImageSaveOptions(Aspose.Words.SaveFormat.Png);  
143.                 imageSaveOptions.Resolution = resolution;  
144.                 for (int i = startPageNum; i <= endPageNum; i++)  
145.                 {  
146.                     if (this.cancelled)  
147.                     {  
148.                         break;  
149.                     }  
150.   
151.                     MemoryStream stream = new MemoryStream();  
152.                     imageSaveOptions.PageIndex = i - 1;  
153.                     string imgPath = Path.Combine(imageOutputDirPath, imageName) + "_" + i.ToString("000") + "." + imageFormat.ToString();  
154.                     doc.Save(stream, imageSaveOptions);  
155.                     Image img = Image.FromStream(stream);  
156.                     Bitmap bm = ESBasic.Helpers.ImageHelper.Zoom(img, 0.6f);  
157.                     bm.Save(imgPath, imageFormat);  
158.                     img.Dispose();  
159.                     stream.Dispose();  
160.                     bm.Dispose();  
161.   
162.                     System.Threading.Thread.Sleep(200);  
163.                     if (this.ProgressChanged != null)  
164.                     {  
165.                         this.ProgressChanged(i - 1, endPageNum);  
166.                     }  
167.                 }  
168.   
169.                 if (this.cancelled)  
170.                 {  
171.                     return;  
172.                 }  
173.   
174.                 if (this.ConvertSucceed != null)  
175.                 {  
176.                     this.ConvertSucceed();  
177.                 }  
178.             }  
179.             catch (Exception ex)  
180.             {  
181.                 if (this.ConvertFailed != null)  
182.                 {  
183.                     this.ConvertFailed(ex.Message);  
184.                 }  
185.             }  
186.         }  
187.     }   
188.     #endregion  
189.   
190.     将pdf文档转换为图片#region 将pdf文档转换为图片  
191.     public class Pdf2ImageConverter : IImageConverter  
192.     {  
193.         private bool cancelled = false;  
194.         public event CbGeneric<int, int> ProgressChanged;  
195.         public event CbGeneric ConvertSucceed;  
196.         public event CbGeneric<string> ConvertFailed;  
197.   
198.         public void Cancel()  
199.         {  
200.             if (this.cancelled)  
201.             {  
202.                 return;  
203.             }  
204.   
205.             this.cancelled = true;  
206.         }  
207.   
208.         public void ConvertToImage(string originFilePath, string imageOutputDirPath)  
209.         {  
210.             this.cancelled = false;  
211.             ConvertToImage(originFilePath, imageOutputDirPath, 0, 0, 200);  
212.         }  
213.   
214.         /**//// <summary>  
215.         /// 将pdf文档转换为图片的方法        
216.         /// </summary>  
217.         /// <param name="originFilePath">pdf文件路径</param>  
218.         /// <param name="imageOutputDirPath">图片输出路径，如果为空，默认值为pdf所在路径</param>         
219.         /// <param name="startPageNum">从PDF文档的第几页开始转换，如果为0，默认值为1</param>  
220.         /// <param name="endPageNum">从PDF文档的第几页开始停止转换，如果为0，默认值为pdf总页数</param>         
221.         /// <param name="resolution">设置图片的像素，数字越大越清晰，如果为0，默认值为128，建议最大值不要超过1024</param>  
222.         private void ConvertToImage(string originFilePath, string imageOutputDirPath, int startPageNum, int endPageNum, int resolution)  
223.         {  
224.             try  
225.             {  
226.                 Aspose.Pdf.Document doc = new Aspose.Pdf.Document(originFilePath);  
227.   
228.                 if (doc == null)  
229.                 {  
230.                     throw new Exception("pdf文件无效或者pdf文件被加密！");  
231.                 }  
232.   
233.                 if (imageOutputDirPath.Trim().Length == 0)  
234.                 {  
235.                     imageOutputDirPath = Path.GetDirectoryName(originFilePath);  
236.                 }  
237.   
238.                 if (!Directory.Exists(imageOutputDirPath))  
239.                 {  
240.                     Directory.CreateDirectory(imageOutputDirPath);  
241.                 }  
242.   
243.                 if (startPageNum <= 0)  
244.                 {  
245.                     startPageNum = 1;  
246.                 }  
247.   
248.                 if (endPageNum > doc.Pages.Count || endPageNum <= 0)  
249.                 {  
250.                     endPageNum = doc.Pages.Count;  
251.                 }  
252.   
253.                 if (startPageNum > endPageNum)  
254.                 {  
255.                     int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum;  
256.                 }  
257.   
258.                 if (resolution <= 0)  
259.                 {  
260.                     resolution = 128;  
261.                 }  
262.   
263.                 string imageNamePrefix = Path.GetFileNameWithoutExtension(originFilePath);  
264.                 for (int i = startPageNum; i <= endPageNum; i++)  
265.                 {  
266.                     if (this.cancelled)  
267.                     {  
268.                         break;  
269.                     }  
270.   
271.                     MemoryStream stream = new MemoryStream();                     
272.                     string imgPath = Path.Combine(imageOutputDirPath, imageNamePrefix) + "_" + i.ToString("000") + ".jpg";  
273.                     Aspose.Pdf.Devices.Resolution reso = new Aspose.Pdf.Devices.Resolution(resolution);  
274.                     Aspose.Pdf.Devices.JpegDevice jpegDevice = new Aspose.Pdf.Devices.JpegDevice(reso, 100);  
275.                     jpegDevice.Process(doc.Pages[i], stream);  
276.   
277.                     Image img = Image.FromStream(stream);  
278.                     Bitmap bm = ESBasic.Helpers.ImageHelper.Zoom(img, 0.6f);  
279.                     bm.Save(imgPath, ImageFormat.Jpeg);  
280.                     img.Dispose();  
281.                     stream.Dispose();  
282.                     bm.Dispose();  
283.   
284.                     System.Threading.Thread.Sleep(200);  
285.                     if (this.ProgressChanged != null)  
286.                     {  
287.                         this.ProgressChanged(i - 1, endPageNum);  
288.                     }  
289.                 }  
290.   
291.                 if (this.cancelled)  
292.                 {  
293.                     return;  
294.                 }  
295.   
296.                 if (this.ConvertSucceed != null)  
297.                 {  
298.                     this.ConvertSucceed();  
299.                 }  
300.             }  
301.             catch (Exception ex)  
302.             {  
303.                 if (this.ConvertFailed != null)  
304.                 {  
305.                     this.ConvertFailed(ex.Message);  
306.                 }  
307.             }  
308.         }  
309.     }   
310.     #endregion  
311.   
312.     将ppt文档转换为图片#region 将ppt文档转换为图片  
313.     public class Ppt2ImageConverter : IImageConverter  
314.     {  
315.         private Pdf2ImageConverter pdf2ImageConverter;       
316.         public event CbGeneric<int, int> ProgressChanged;  
317.         public event CbGeneric ConvertSucceed;  
318.         public event CbGeneric<string> ConvertFailed;  
319.   
320.         public void Cancel()  
321.         {  
322.             if (this.pdf2ImageConverter != null)  
323.             {  
324.                 this.pdf2ImageConverter.Cancel();  
325.             }  
326.         }  
327.   
328.         public void ConvertToImage(string originFilePath, string imageOutputDirPath)  
329.         {  
330.             ConvertToImage(originFilePath, imageOutputDirPath, 0, 0, 200);  
331.         }  
332.   
333.         /**//// <summary>  
334.         /// 将pdf文档转换为图片的方法        
335.         /// </summary>  
336.         /// <param name="originFilePath">ppt文件路径</param>  
337.         /// <param name="imageOutputDirPath">图片输出路径，如果为空，默认值为pdf所在路径</param>         
338.         /// <param name="startPageNum">从PDF文档的第几页开始转换，如果为0，默认值为1</param>  
339.         /// <param name="endPageNum">从PDF文档的第几页开始停止转换，如果为0，默认值为pdf总页数</param>         
340.         /// <param name="resolution">设置图片的像素，数字越大越清晰，如果为0，默认值为128，建议最大值不要超过1024</param>  
341.         private void ConvertToImage(string originFilePath, string imageOutputDirPath, int startPageNum, int endPageNum, int resolution)  
342.         {  
343.             try  
344.             {  
345.                 Aspose.Slides.Presentation doc = new Aspose.Slides.Presentation(originFilePath);  
346.   
347.                 if (doc == null)  
348.                 {  
349.                     throw new Exception("ppt文件无效或者ppt文件被加密！");  
350.                 }  
351.   
352.                 if (imageOutputDirPath.Trim().Length == 0)  
353.                 {  
354.                     imageOutputDirPath = Path.GetDirectoryName(originFilePath);  
355.                 }  
356.   
357.                 if (!Directory.Exists(imageOutputDirPath))  
358.                 {  
359.                     Directory.CreateDirectory(imageOutputDirPath);  
360.                 }  
361.   
362.                 if (startPageNum <= 0)  
363.                 {  
364.                     startPageNum = 1;  
365.                 }  
366.   
367.                 if (endPageNum > doc.Slides.Count || endPageNum <= 0)  
368.                 {  
369.                     endPageNum = doc.Slides.Count;  
370.                 }  
371.   
372.                 if (startPageNum > endPageNum)  
373.                 {  
374.                     int tempPageNum = startPageNum; startPageNum = endPageNum; endPageNum = startPageNum;  
375.                 }  
376.   
377.                 if (resolution <= 0)  
378.                 {  
379.                     resolution = 128;  
380.                 }  
381.   
382.                 //先将ppt转换为pdf临时文件  
383.                 string tmpPdfPath = originFilePath + ".pdf";  
384.                 doc.Save(tmpPdfPath ,Aspose.Slides.Export.SaveFormat.Pdf);  
385.   
386.                 //再将pdf转换为图片  
387.                 Pdf2ImageConverter converter = new Pdf2ImageConverter();  
388.                 converter.ConvertFailed += new CbGeneric<string>(converter_ConvertFailed);  
389.                 converter.ConvertSucceed += new CbGeneric(converter_ConvertSucceed);  
390.                 converter.ProgressChanged += new CbGeneric<int, int>(converter_ProgressChanged);  
391.                 converter.ConvertToImage(tmpPdfPath, imageOutputDirPath);  
392.   
393.                 //删除pdf临时文件  
394.                 File.Delete(tmpPdfPath);  
395.   
396.                 if (this.ConvertSucceed != null)  
397.                 {  
398.                     this.ConvertSucceed();  
399.                 }  
400.             }  
401.             catch (Exception ex)  
402.             {  
403.                 if (this.ConvertFailed != null)  
404.                 {  
405.                     this.ConvertFailed(ex.Message);  
406.                 }  
407.             }  
408.   
409.             this.pdf2ImageConverter = null;  
410.         }  
411.   
412.         void converter_ProgressChanged(int done, int total)  
413.         {  
414.             if (this.ProgressChanged != null)  
415.             {  
416.                 this.ProgressChanged(done, total);  
417.             }  
418.         }  
419.   
420.         void converter_ConvertSucceed()  
421.         {  
422.             if (this.ConvertSucceed != null)  
423.             {  
424.                 this.ConvertSucceed();  
425.             }  
426.         }  
427.   
428.         void converter_ConvertFailed(string msg)  
429.         {  
430.             if (this.ConvertFailed != null)  
431.             {  
432.                 this.ConvertFailed(msg);  
433.             }  
434.         }  
435.     }  
436.     #endregion  
437.   
438.     将图片压缩包解压。（如果课件本身就是多张图片，那么可以将它们压缩成一个rar，作为一个课件）#region 将图片压缩包解压。（如果课件本身就是多张图片，那么可以将它们压缩成一个rar，作为一个课件）  
439.     /**//// <summary>  
440.     /// 将图片压缩包解压。（如果课件本身就是多张图片，那么可以将它们压缩成一个rar，作为一个课件）  
441.     /// </summary>  
442.     public class Rar2ImageConverter : IImageConverter  
443.     {  
444.         private bool cancelled = false;  
445.         public event CbGeneric<string> ConvertFailed;  
446.         public event CbGeneric<int, int> ProgressChanged;  
447.         public event CbGeneric ConvertSucceed;  
448.   
449.         public void Cancel()  
450.         {  
451.             this.cancelled = true;  
452.         }  
453.   
454.   
455.         public void ConvertToImage(string rarPath, string imageOutputDirPath)  
456.         {  
457.             try  
458.             {  
459.                 Unrar tmp = new Unrar(rarPath);  
460.                 tmp.Open(Unrar.OpenMode.List);  
461.                 string[] files = tmp.ListFiles();  
462.                 tmp.Close();  
463.   
464.                 int total = files.Length;  
465.                 int done = 0;  
466.   
467.                 Unrar unrar = new Unrar(rarPath);  
468.                 unrar.Open(Unrar.OpenMode.Extract);  
469.                 unrar.DestinationPath = imageOutputDirPath;  
470.   
471.                 while (unrar.ReadHeader() && !cancelled)  
472.                 {  
473.                     if (unrar.CurrentFile.IsDirectory)  
474.                     {  
475.                         unrar.Skip();  
476.                     }  
477.                     else  
478.                     {  
479.                         unrar.Extract();  
480.                         ++done;  
481.   
482.                         if (this.ProgressChanged != null)  
483.                         {  
484.                             this.ProgressChanged(done, total);  
485.                         }  
486.                     }  
487.                 }  
488.                 unrar.Close();  
489.   
490.                 if (this.ConvertSucceed != null)  
491.                 {  
492.                     this.ConvertSucceed();  
493.                 }  
494.   
495.             }  
496.             catch (Exception ex)  
497.             {  
498.                 if (this.ConvertFailed != null)  
499.                 {  
500.                     this.ConvertFailed(ex.Message);  
501.                 }  
502.             }  
503.         }  
504.   
505.           
506.     }   
507.     #endregion  
508. }