C# 將多個圖片合並成TIFF文件的兩種方法（續集）

01

—

名詞解釋

 

首先要弄清楚幾個名詞：

① 圖像的壓縮品質：指的就是壓縮后的圖象清晰度，通俗地講，就是用圖像處理軟件保存圖像時，為了節省硬盤空間，一般是要對原始圖像通過一定的算法進行壓縮的，而壓縮品質實質上就是壓縮比率的大小，壓縮的比率越高，生成的圖像所占硬盤空間就越少，便是圖片質量也就越差；相反，壓縮比率越低，圖像的品質越高，但是相應地占用硬盤空間也就越大。

② Tiff：標簽圖像文件格式（Tag Image File Format，TIFF）是一種靈活的位圖格式，TIFF（Tag Image File Format）圖像文件是圖形圖像處理中常用的格式之一，其圖像格式很復雜，但由於它對圖像信息的存放靈活多變，可以支持很多色彩系統，而且獨立於操作系統，因此得到了廣泛應用。TIFF文件以.tif為擴展名。

 

02

—

新的探索

 

變化一：這位仁兄的處理方式是把每張圖片先用CompressionImage這個方法加載到內存進行編碼壓縮的，實際上這一步是沒有必要的，不僅僅浪費了時間還沒有節省空間，因為調用的第三方本身就帶了圖片壓縮的功能，所以這一段我的項目去掉了；

變化二：這位仁兄處理是把一組圖片一次壓縮成一張tiff，我這邊的應用場景是圖片一張一張來，所以就是每來一張就壓縮一張；

變化三：除了圖片合成，我的項目中添加了tiff文件拆分的方法；

變化四：記錄圖片加載、合成、保存的時間並寫入log文件.

03

—

源碼分享

我這里測試采用的是控制台，運行后輸入你也數值：要合並的圖片的數量，就可以執行了，測試過程我只有一張圖片，所以我將這張圖片進行了克隆：

Program.cs：這里有三個方法，依次是Main、BmpToTiff和CopyImage，CopyImage負責圖片克隆，BmpToTiff方法的for循環中可以選擇圖片合成的方案一或者二。

 

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TiffHelper;

namespace TiffConsole
{
    class Program
    {
        private static Stopwatch stopwatch = new Stopwatch();
        static void Main(string[] args)
        {
            string filePath = @"C:\Users\majm\Desktop\新建文件夾\";
            CopyImage(filePath);
            BmpToTiff(filePath);
            //SplitTiffToBMP.SplitTiff(filePath);//圖片分割
            Console.ReadKey();
        }
        
        public static void BmpToTiff(string filePath)
        {
            List<TiffHelper.TimeSpan> timeSpans = new List<TiffHelper.TimeSpan>();
           
            string[] imagePaths = System.IO.Directory.GetFiles(filePath, "*.bmp");
            stopwatch.Start();
            for (int i = 0; i < imagePaths.Length; i++)
            {
                //調用方案1
                //var timeSpan = BitMiracle.Jpeg2Tiff(i, imagePaths.Length, filePath,  $"{i}.tif", 100);
                //調用方案2
                var timeSpan = RasterEdge.TIFFDocument(i,filePath);
                timeSpans.Add(timeSpan);
            }
            stopwatch.Stop();

            FileWrite.WriteLogFile("Id,LoadTime,MergeTime,SaveTime,TotalTime,flag", true);
            timeSpans.ForEach(n => FileWrite.WriteLogFile(n.ToString(), true));
            FileWrite.WriteLogFile("合成圖片總計耗時：" + stopwatch.ElapsedMilliseconds.ToString() + "毫秒", true);
            Console.WriteLine("合成圖片總計耗時：" + stopwatch.ElapsedMilliseconds.ToString() + "毫秒");
        }
        public static void CopyImage(string filePath)
        {
            Console.WriteLine("請輸入合並圖片的數量：");
            //控制台輸入圖片數量
            bool flag = false;
            int count = 0;
            while (!flag)
            {
                flag = int.TryParse(Console.ReadLine(), out count);
            }

            //復制圖片
            Bitmap bitmap = new Bitmap(filePath + "0.bmp");
            for (int i = 1; i < count; i++)
            {
                bitmap.Save(filePath + $"{i}.bmp");
            }
            bitmap.Dispose();
        }
    }
}

　　

合圖和拆分的代碼我寫到了類庫TiffHelper中：

 

BitMiracle.cs

using BitMiracle.LibTiff.Classic;
using System;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;

namespace TiffHelper
{
    public class BitMiracle
    {
        /// 合並jpg
        /// </summary>
        /// <param name="bmps">bitmap數組</param>
        /// <param name="tiffSavePath">保存路徑</param>
        /// <param name="quality">圖片質量，1-100</param>
        /// <returns></returns>
        public static bool Jpegs2Tiff(Bitmap[] bmps, string tiffSavePath, int quality = 15)
        {
            try
            {
                MemoryStream ms = new MemoryStream();
                using (Tiff tif = Tiff.ClientOpen(@"in-memory", "w", ms, new TiffStream()))
                {
                    foreach (var bmp in bmps)//
                    {
                        byte[] raster = GetImageRasterBytes(bmp, PixelFormat.Format24bppRgb);
                        tif.SetField(TiffTag.IMAGEWIDTH, bmp.Width);
                        tif.SetField(TiffTag.IMAGELENGTH, bmp.Height);
                        tif.SetField(TiffTag.COMPRESSION, Compression.JPEG);
                        tif.SetField(TiffTag.PHOTOMETRIC, Photometric.RGB);
                        tif.SetField(TiffTag.JPEGQUALITY, quality);
                        tif.SetField(TiffTag.ROWSPERSTRIP, bmp.Height);


                        tif.SetField(TiffTag.XRESOLUTION, 90);
                        tif.SetField(TiffTag.YRESOLUTION, 90);


                        tif.SetField(TiffTag.BITSPERSAMPLE, 8);
                        tif.SetField(TiffTag.SAMPLESPERPIXEL, 3);


                        tif.SetField(TiffTag.PLANARCONFIG, PlanarConfig.CONTIG);


                        int stride = raster.Length / bmp.Height;
                        ConvertSamples(raster, bmp.Width, bmp.Height);


                        for (int i = 0, offset = 0; i < bmp.Height; i++)
                        {
                            tif.WriteScanline(raster, offset, i, 0);
                            offset += stride;
                        }


                        tif.WriteDirectory();
                    }
                    System.IO.FileStream fs = new FileStream(tiffSavePath, FileMode.Create);

                    ms.Seek(0, SeekOrigin.Begin);
                    fs.Write(ms.ToArray(), 0, (int)ms.Length);
                    fs.Close();
                    return true;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }
        private static MemoryStream ms1 = new MemoryStream();
        private static Tiff tif = Tiff.ClientOpen(@"in-memory", "w", ms1, new TiffStream());
        /// <summary>
        /// tiff圖片合成，一次合並一張
        /// </summary>
        /// <param name="index">圖片id</param>
        /// <param name="totalCount">圖片數量</param>
        /// <param name="tiffSavePath">tiff保存路徑</param>
        /// <param name="quality">壓縮品質</param>
        /// <returns></returns>
        public static TimeSpan Jpeg2Tiff(int index, int totalCount, string tiffSavePath,string fileName, int quality = 75)
        {
            try
            {
                string fileFullPath = Path.Combine(tiffSavePath, fileName);
                Stopwatch sTotal = new Stopwatch();
                sTotal.Start();
                TimeSpan timeSpan = new TimeSpan();
                timeSpan.Id = index;
                //Bitmap[] bmps = new Bitmap[1] {new Bitmap( @"C:\Users\zhuyr\Desktop\AutoFocus\" + $"{i}.bmp")};
                Stopwatch sw = new Stopwatch();

                sw.Start();
                Bitmap bmp = new Bitmap(tiffSavePath + $"{index}.bmp");
                sw.Stop();
                timeSpan.LoadTime = sw.ElapsedMilliseconds.ToString();

                sw = new Stopwatch();
                sw.Start();
                byte[] raster = GetImageRasterBytes(bmp, PixelFormat.Format24bppRgb);
                tif.SetField(TiffTag.IMAGEWIDTH, bmp.Width);
                tif.SetField(TiffTag.IMAGELENGTH, bmp.Height);
                tif.SetField(TiffTag.COMPRESSION, Compression.NONE);
                tif.SetField(TiffTag.PHOTOMETRIC, Photometric.RGB);
                tif.SetField(TiffTag.JPEGQUALITY, quality);
                tif.SetField(TiffTag.ROWSPERSTRIP, bmp.Height);


                tif.SetField(TiffTag.XRESOLUTION, 90);
                tif.SetField(TiffTag.YRESOLUTION, 90);


                tif.SetField(TiffTag.BITSPERSAMPLE, 8);
                tif.SetField(TiffTag.SAMPLESPERPIXEL, 3);


                tif.SetField(TiffTag.PLANARCONFIG, PlanarConfig.CONTIG);


                int stride = raster.Length / bmp.Height;
                ConvertSamples(raster, bmp.Width, bmp.Height);


                for (int i = 0, offset = 0; i < bmp.Height; i++)
                {
                    tif.WriteScanline(raster, offset, i, 0);
                    offset += stride;
                }


                tif.WriteDirectory();
                sw.Stop();
                timeSpan.MergeTime = sw.ElapsedMilliseconds.ToString();

                sw = new Stopwatch();
                sw.Start();
                if (totalCount == 1000)
                {
                    if (index % 10 == 9)
                    {
                        System.IO.FileStream fs = new FileStream(fileFullPath, FileMode.Create);
                        ms1.Seek(0, SeekOrigin.Begin);
                        fs.Write(ms1.ToArray(), 0, (int)ms1.Length);
                        fs.Close();
                        sw.Stop();
                    }
                }
                else
                {
                    System.IO.FileStream fs = new FileStream(fileFullPath, FileMode.Create);
                    ms1.Seek(0, SeekOrigin.Begin);
                    fs.Write(ms1.ToArray(), 0, (int)ms1.Length);
                    fs.Close();
                    sw.Stop();
                }
                timeSpan.SaveTime = sw.ElapsedMilliseconds.ToString();

                sTotal.Stop();
                timeSpan.TotalTime = sTotal.ElapsedMilliseconds.ToString();
                timeSpan.flag = true;
                return timeSpan;

            }
            catch (Exception ex)
            {
                return null;
            }
        }

        private static byte[] GetImageRasterBytes(Bitmap bmp, PixelFormat format)
        {
            Rectangle rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
            byte[] bits = null;
            try
            {
                BitmapData bmpdata = bmp.LockBits(rect, ImageLockMode.ReadWrite, format);
                bits = new byte[bmpdata.Stride * bmpdata.Height];
                System.Runtime.InteropServices.Marshal.Copy(bmpdata.Scan0, bits, 0, bits.Length);
                bmp.UnlockBits(bmpdata);
            }
            catch
            {
                return null;
            }
            return bits;
        }
        private static void ConvertSamples(byte[] data, int width, int height)
        {
            int stride = data.Length / height;
            const int samplesPerPixel = 3;


            for (int y = 0; y < height; y++)
            {
                int offset = stride * y;
                int strideEnd = offset + width * samplesPerPixel;


                for (int i = offset; i < strideEnd; i += samplesPerPixel)
                {
                    byte temp = data[i + 2];
                    data[i + 2] = data[i];
                    data[i] = temp;
                }
            }
        }

    }
}

　　Jpeg2Tiff這個方法的參數quality可以調節壓縮比率，這個值默認是75，范圍是【0,100】，當然你也可以通過tif.SetField(TiffTag.COMPRESSION, Compression.NONE);設置壓縮方式，會有以下這些可選項，每種方式都采用了不同算法，所以壓縮效率都是不一樣的.

 

 RasterEdge.cs  方案2，每次把新來的圖片插入上一次合成的tiff中

using RasterEdge.Imaging.Basic;
using RasterEdge.XDoc.TIFF;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TiffHelper
{
    public class RasterEdge
    {
        public static TimeSpan TIFFDocument(int index,string filePath)
        {
            Stopwatch sTotal = new Stopwatch();
            sTotal.Start();
            TimeSpan timeSpan = new TimeSpan();
            timeSpan.Id = index;

            Stopwatch sw = new Stopwatch();
            sw.Start();
            Bitmap[] bmps = new Bitmap[1] { new Bitmap(filePath + $"{index}.bmp") };
            sw.Stop();
            timeSpan.LoadTime = sw.ElapsedMilliseconds.ToString();

            sw = new Stopwatch();
            sw.Start();
            //ImageOutputOption option = new ImageOutputOption() { Color = ColorType.Color, Compression = ImageCompress.CCITT };
            ImageOutputOption option = new ImageOutputOption() { Type = ImageType.JPEG, Color = ColorType.Color, Compression = ImageCompress.Uncompressed };
            TIFFDocument tifDoc_new = new TIFFDocument(bmps, option);
            TIFFDocument tifDoc_old;
            if (index > 0)
            {
                tifDoc_old = new TIFFDocument(filePath + $"{index - 1}.tif");
                BasePage page = tifDoc_new.GetPage(0);
                tifDoc_old.InsertPage(page, index);
            }
            else
            {
                tifDoc_old = tifDoc_new;
            }
            if (tifDoc_old == null)
                throw new Exception("Fail to construct TIFF Document");
            sw.Stop();
            timeSpan.MergeTime = sw.ElapsedMilliseconds.ToString();

            sw = new Stopwatch();
            sw.Start();
            tifDoc_old.Save(filePath + $"{index}.tif");
            sw.Stop();
            timeSpan.SaveTime = sw.ElapsedMilliseconds.ToString();

            sTotal.Stop();
            timeSpan.TotalTime = sTotal.ElapsedMilliseconds.ToString();
            timeSpan.flag = true;
            return timeSpan;
        }
    }
}

　　

 

 SplitTiffToBMP.cs：圖片拆分

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TiffHelper
{
    public class SplitTiffToBMP
    {
        private static Stopwatch stopwatch = new Stopwatch();
        public static void SplitTiff(string filePath)
        {
            stopwatch.Start();
            List<TimeSpan> timeSpans = new List<TimeSpan>();

            //分割Tif圖片為多個Gif圖片
            System.Drawing.Image img = System.Drawing.Image.FromFile(filePath+"9.tif");
            Guid guid = (Guid)img.FrameDimensionsList.GetValue(0);
            FrameDimension dimension = new FrameDimension(guid);
            int totalPage = img.GetFrameCount(dimension);

            for (int i = 0; i < totalPage; i++)
            {
                TimeSpan timeSpan = new TimeSpan();
                Stopwatch sw = new Stopwatch();
                sw.Start();
                img.SelectActiveFrame(dimension, i);
                img.Save(filePath + i + ".bmp", System.Drawing.Imaging.ImageFormat.Bmp);
                sw.Stop();
                timeSpan.Id = i;
                timeSpan.TotalTime = sw.ElapsedMilliseconds.ToString();
                timeSpans.Add(timeSpan);
            }
            stopwatch.Stop();
            FileWrite.WriteLogFile("Id,,,,TotalTime", true);
            timeSpans.ForEach(n => FileWrite.WriteLogFile(n.ToString(), true));
            FileWrite.WriteLogFile("拆分圖片總計耗時：" + stopwatch.ElapsedMilliseconds.ToString() + "毫秒", true);
            Console.WriteLine("拆分圖片總計耗時：" + stopwatch.ElapsedMilliseconds.ToString() + "毫秒");
        }
    }
}

　　

數據模型：

FileWrite.cs  記錄耗時，寫入

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TiffHelper
{
    public class FileWrite
    {
        /// <summary>
        /// log文件打印
        /// </summary>
        /// <param name="logFullPath">文件全路徑</param>
        /// <param name="content">寫入內容</param>
        /// <param name="flag">true：追加，false：覆蓋</param>
        public static void WriteLogFile(string content, bool flag,string logFullPath = @"C:\Users\majm\Desktop\新建文件夾\log.txt")
        {
            StreamWriter sw = new StreamWriter(logFullPath ,flag);
            sw.WriteLine(content);
            sw.Close();
        }
    }
}

　　TimeSpan.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TiffHelper
{
    public class TimeSpan
    {
        public int Id;
        public string LoadTime;
        public string MergeTime;
        public string SaveTime;
        public string TotalTime;
        public bool flag;
        public override string ToString()
        {
            StringBuilder report = new StringBuilder();
            report.Append($"{Id},{LoadTime},{MergeTime},{SaveTime},{TotalTime},{flag}");
            return report.ToString();
        }
    }
}

　　

04

—

運行演示

 

 

05

—

項目源碼

 

鏈接：https://pan.baidu.com/s/1xw6iJkPg_5-P63QpLlX0kA 

提取碼：點擊在看后添加小編微信zls20210502獲取