C#图片格式转换

#region MyRegion
        private static string mypPath;
        /// <summary>
        /// 图片路径
        /// </summary>
        public static string MypPath
        {
            get
            {
                JHPubClass.mypPath = Application.StartupPath + "\\图片测试\\";
                return JHPubClass.mypPath;
            }
            set { JHPubClass.mypPath = value; }
        }
        /// <summary>
        /// 其他图片格式转换为jpg并进行缩放处理
        /// </summary>
        /// <param name="picWidth"></param>
        /// <param name="picHeight"></param>
        /// <param name="strBase64"></param>
        /// <param name="iMode">0png图片 1jpg图片</param>
        /// <param name="hospitalNO"></param>
        /// <returns></returns>
        public byte[] GetPicToJPG(int picWidth, int picHeight, string strBase64, int iMode, string hospitalNO)
        {
            byte[] byt = null;
            try
            {
              
                byte[] byPat = Convert.FromBase64String(strBase64);
                using (MemoryStream msPIC = new MemoryStream(byPat))
                {
                    Bitmap bmpJpg = new Bitmap(msPIC);
                    if (iMode == 1)
                    {
                        //jpg格式
                        bmpJpg.Save(MypPath + "Dest.jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                        bmpJpg.Dispose();

                        msPIC.Close();
                        msPIC.Dispose();
                    }
                    else if (iMode == 0)
                    {
                        bmpJpg.Save(MypPath + "Source.png", System.Drawing.Imaging.ImageFormat.Png);
                        bmpJpg.Dispose();//避免 GDI+ 中发生一般性错误

                        #region png图片格式转换为jpg格式
                        Image img = Image.FromFile(MypPath + "Source.png");
                        using (var bmp = new Bitmap(img.Width, img.Height))
                        {
                            bmp.SetResolution(img.HorizontalResolution, img.VerticalResolution);
                            using (var g = Graphics.FromImage(bmp))
                            {
                                g.Clear(Color.White);
                                g.DrawImageUnscaled(img, 0, 0);
                                g.Dispose();
                            }
                            img.Dispose();//避免 GDI+ 中发生一般性错误
                          
                            bmp.Save(MypPath + "Dest.jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                            bmp.Dispose(); //避免 GDI+ 中发生一般性错误
                        }

                        msPIC.Dispose();
                        #endregion
                    }

                    if (File.Exists(MypPath + "Dest.jpg"))
                    {
                        #region 缩放图片
                        //取图片通过
                        Bitmap oImage = new Bitmap(MypPath + "Dest.jpg");
                        Bitmap newTmep = new Bitmap(oImage);
                        oImage.Dispose();
                        Image imgTemp = newTmep;

                        Image imgJpg = PictureHandle.Instance().GetReducedImage(picWidth, picHeight, imgTemp, MypPath + "DestTmp.jpg");
                        imgJpg.Dispose();

                   
                        if (File.Exists(JHPubClass.PicPath + "DestTmp.jpg"))
                        {
                            try
                            {
                                byt = File.ReadAllBytes(MypPath + "DestTmp.jpg");

                                if (byt == null)
                                {
                                    MessageBox.Show("未获取到图片数据");
                                }
                                else
                                { 
                                 
                                }
                            }
                            catch (Exception ex)
                            {
                               MessageBox.Show("读取图片：" + ex.Message);
                            }
                        }
                        else
                        {
                           
                        }
                        #endregion


                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show("转换图片格式出现问题：" + ex.Message);
            }


            return byt;
        }
        #endregion

public class PictureHandle
    {
        public static PictureHandle picUtils;

        public static PictureHandle Instance()
        {
            if (picUtils == null)
            {
                picUtils = new PictureHandle();
            }
            return picUtils;
        }

        #region 采用双三次插值法,执行预筛选以确保高质量的收缩,此模式可产生质量教高的转换图像
        /// <summary>
        /// 按照指定的高和宽生成相应的规格的图片，采用此方法生成的缩略图片不会失真
        /// </summary>
        /// <param name="width">指定宽度</param>
        /// <param name="height">指定高度</param>
        /// <param name="imageFrom">原图片</param>
        /// <returns>返回新生成的图</returns>
        public Image GetReducedImage(int width, int height, Image imageFrom, string path)
        {
            // 源图宽度及高度 
            int imageFromWidth = imageFrom.Width;
            int imageFromHeight = imageFrom.Height;

            // 生成的缩略图实际宽度及高度.如果指定的高和宽比原图大，则返回原图；否则按照指定高宽生成图片
            if (width >= imageFromWidth && height >= imageFromHeight)
            {
                imageFrom.Save(@path, ImageFormat.Jpeg);
                return imageFrom;
            }
            else
            {
                // 生成的缩略图在上述"画布"上的位置
                int X = 0;
                int Y = 0;

                // 创建画布
                Bitmap bmp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
                bmp.SetResolution(imageFrom.HorizontalResolution, imageFrom.VerticalResolution);
                using (Graphics g = Graphics.FromImage(bmp))
                {
                    // 用白色清空 
                    g.Clear(Color.White);

                    // 指定高质量的双三次插值法。执行预筛选以确保高质量的收缩。此模式可产生质量最高的转换图像。 
                    g.InterpolationMode = InterpolationMode.HighQualityBicubic;

                    // 指定高质量、低速度呈现。 
                    g.SmoothingMode = SmoothingMode.HighQuality;
                    g.CompositingQuality = CompositingQuality.HighQuality;
                    //清空一下画布
                    g.Clear(Color.White);
                    ////防止出现渐变
                    //var imgAtt = new ImageAttributes();
                    //imgAtt.SetWrapMode(WrapMode.TileFlipXY);
                    // 在指定位置并且按指定大小绘制指定的 Image 的指定部分。 
                    g.DrawImage(imageFrom, new Rectangle(X, Y, width, height),
                        new Rectangle(0, 0, imageFromWidth, imageFromHeight), GraphicsUnit.Pixel);
                    //  g.DrawImage(imageFrom, new Rectangle(0, 0, imageFromWidth, imageFromHeight), X, Y, width, height,
                    // GraphicsUnit.Pixel, imgAtt);

                    //将图片以指定的格式保存到到指定的位置
                    bmp.Save(@path, ImageFormat.Jpeg);
                    Image afterImg = Image.FromHbitmap(bmp.GetHbitmap());
                    return afterImg;
                }
            }
        }

        /// <summary>
        /// 按照指定的高和宽生成相应的规格的图片，采用此方法生成的缩略图片不会失真
        /// </summary>
        /// <param name="width">指定宽度</param>
        /// <param name="height">指定高度</param>
        /// <param name="imageFrom">原图片</param>
        /// <returns>返回新生成的图</returns>
        public Image GetReducedImage(int width, int height, Image imageFrom)
        {
            // 源图宽度及高度 
            int imageFromWidth = imageFrom.Width;
            int imageFromHeight = imageFrom.Height;

            // 生成的缩略图实际宽度及高度.如果指定的高和宽比原图大，则返回原图；否则按照指定高宽生成图片
            if (width >= imageFromWidth && height >= imageFromHeight)
            {
                //imageFrom.Save(@path, ImageFormat.Jpeg);
                return imageFrom;
            }
            else
            {
                // 生成的缩略图在上述"画布"上的位置
                int X = 0;
                int Y = 0;

                // 创建画布
                Bitmap bmp = new Bitmap(width, height, PixelFormat.Format24bppRgb);
                bmp.SetResolution(imageFrom.HorizontalResolution, imageFrom.VerticalResolution);
                using (Graphics g = Graphics.FromImage(bmp))
                {
                    // 用白色清空 
                    g.Clear(Color.White);

                    // 指定高质量的双三次插值法。执行预筛选以确保高质量的收缩。此模式可产生质量最高的转换图像。 
                    g.InterpolationMode = InterpolationMode.HighQualityBicubic;

                    // 指定高质量、低速度呈现。 
                    g.SmoothingMode = SmoothingMode.HighQuality;
                    g.CompositingQuality = CompositingQuality.HighQuality;
                    //清空一下画布
                    g.Clear(Color.White);
                    ////防止出现渐变
                    //var imgAtt = new ImageAttributes();
                    //imgAtt.SetWrapMode(WrapMode.TileFlipXY);
                    // 在指定位置并且按指定大小绘制指定的 Image 的指定部分。 
                    g.DrawImage(imageFrom, new Rectangle(X, Y, width, height),
                        new Rectangle(0, 0, imageFromWidth, imageFromHeight), GraphicsUnit.Pixel);
                    //  g.DrawImage(imageFrom, new Rectangle(0, 0, imageFromWidth, imageFromHeight), X, Y, width, height,
                    // GraphicsUnit.Pixel, imgAtt);

                    ////将图片以指定的格式保存到到指定的位置
                    //bmp.Save(@path, ImageFormat.Jpeg);
                    Image afterImg = Image.FromHbitmap(bmp.GetHbitmap());
                    return afterImg;
                }
            }
        }

        #endregion

        //缩放图片
        public Image GetThumbnail(Image b, int destHeight, int destWidth)
        {
            System.Drawing.Image imgSource = b;
            System.Drawing.Imaging.ImageFormat thisFormat = imgSource.RawFormat;

            int sW = 0, sH = 0;
            // 按比例缩放
            int sWidth = imgSource.Width;
            int sHeight = imgSource.Height;
            if (sHeight > destHeight || sWidth > destWidth)
            {
                if ((sWidth * destHeight) > (sHeight * destWidth))
                {
                    sW = destWidth;
                    sH = (destWidth * sHeight) / sWidth;
                }
                else
                {
                    sH = destHeight;
                    sW = (sWidth * destHeight) / sHeight;
                }
            }
            else
            {
                sW = sWidth;
                sH = sHeight;
            }
            Bitmap outBmp = new Bitmap(destWidth, destHeight);
            Graphics g = Graphics.FromImage(outBmp);
            g.Clear(Color.Transparent);
            // 设置画布的描绘质量       
            g.CompositingQuality = CompositingQuality.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            g.DrawImage(imgSource, new Rectangle((destWidth - sW) / 2, (destHeight - sH) / 2, sW, sH), 0, 0, imgSource.Width, imgSource.Height, GraphicsUnit.Pixel);
            g.Dispose();
            // 以下代码为保存图片时，设置压缩质量    
            EncoderParameters encoderParams = new EncoderParameters();
            long[] quality = new long[1];
            quality[0] = 100;
            EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
            encoderParams.Param[0] = encoderParam;
            imgSource.Dispose();
            return outBmp;
        }

        /// <summary>
        /// 转换jpg图片
        /// </summary>
        /// <param name="btGif"></param>
        /// <returns></returns>
        public byte[] CovertGifToJpg(byte[] btGif)
        {
            string currentDirectory = Environment.CurrentDirectory;
            MemoryStream memoryStream = new MemoryStream(btGif);
            Image image = Image.FromStream(memoryStream);
            memoryStream.Close();
            MemoryStream memoryStream2 = new MemoryStream();
            using (Bitmap bitmap = new Bitmap(image.Width, image.Height))
            {
                bitmap.SetResolution(image.HorizontalResolution, image.VerticalResolution);
                using (Graphics graphics = Graphics.FromImage(bitmap))
                {
                    graphics.Clear(Color.White);
                    graphics.DrawImageUnscaled(image, 0, 0);
                }
                bitmap.Save(memoryStream2, ImageFormat.Jpeg);
            }
            return memoryStream2.ToArray();
        }


        /// <summary>
        /// 图片合成(单张，或者2张)
        /// </summary>
        /// <param name="bmp1">手写轨迹图片</param>
        /// <param name="bmp2">指纹图片</param>
        /// <param name="width">图片宽度</param>
        /// <param name="height">图片高度</param>
        /// <returns></returns>
        public Image MergerImg(string bmp1, string bmp2, int width, int height, string path)
        {
            if (string.IsNullOrEmpty(bmp1) && string.IsNullOrEmpty(bmp2))
            {
                return null;
            }
            Bitmap img1 = null;
            Bitmap img2 = null;
            Bitmap backgroudImg = null;
            Image backImg = null;
            if (File.Exists(path + "\\sign.jpg"))
            {
                File.Delete(path + "\\sign.jpg");
            }
            if (File.Exists(path + "\\fig.jpg"))
            {
                File.Delete(path + "\\fig.jpg");
            }
            if (!string.IsNullOrEmpty(bmp1))
            {
                img1 = new Bitmap(GetReducedImage(width, height, ToImage(bmp1), path + "\\sign.jpg"));
            }
            if (!string.IsNullOrEmpty(bmp2))
            {
                img2 = new Bitmap(GetReducedImage(width, height, ToImage(bmp2), path + "\\fig.jpg"));
            }
            if (!string.IsNullOrEmpty(bmp2) && !string.IsNullOrEmpty(bmp1))
            {
                ////创建要显示的图片对象,根据参数的个数设置宽度
                backgroudImg = new Bitmap(width * 2, height);
                Graphics g = Graphics.FromImage(backgroudImg);
                ////清除画布,背景设置为白色
                g.Clear(System.Drawing.Color.White);
                //g.Clear(Color.Transparent);
                g.DrawImageUnscaled(img1, 0, 0);
                g.DrawImageUnscaled(img2, width, 0);
                g.Dispose();
                backImg = backgroudImg;
            }
            else
            {
                backgroudImg = new Bitmap(width, height);
                Graphics g = Graphics.FromImage(backgroudImg);
                ////清除画布,背景设置为白色
                g.Clear(System.Drawing.Color.White);
                //g.Clear(Color.Transparent);
                if (string.IsNullOrEmpty(bmp1))
                {
                    g.DrawImageUnscaled(img2, 0, 0);
                }
                else if (string.IsNullOrEmpty(bmp2))
                {
                    g.DrawImageUnscaled(img1, 0, 0);
                }
                //g.DrawImageUnscaled(img2, width, 0);
                g.Dispose();
                backImg = backgroudImg;
            }
            backgroudImg = (Bitmap)GetReducedImage(width, height, backImg, path + "\\PadSign.jpg");

            return backgroudImg;
        }

        //base64转成图片
        private Image ToImage(string base64code)
        {
            byte[] imageBytes = Convert.FromBase64String(base64code);
            //读入MemoryStream对象
            MemoryStream memoryStream = new MemoryStream(imageBytes, 0, imageBytes.Length);
            memoryStream.Write(imageBytes, 0, imageBytes.Length);
            //转成图片
            Image image = Image.FromStream(memoryStream);
            return image;
        }

        /// <summary>
        /// 通过FileStream 来打开文件，这样就可以实现不锁定Image文件，到时可以让多用户同时访问Image文件
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        public static Bitmap ReadImageFile(string path)
        {
            FileStream fs = File.OpenRead(path); //OpenRead
            int filelength = 0;
            filelength = (int)fs.Length; //获得文件长度 
            Byte[] image = new Byte[filelength]; //建立一个字节数组 
            fs.Read(image, 0, filelength); //按字节流读取 
            System.Drawing.Image result = System.Drawing.Image.FromStream(fs);
            fs.Close();
            Bitmap bit = new Bitmap(result);
            return bit;
        }


        /// <summary>
        /// 图片转byte
        /// </summary>
        /// <param name="imagefile"></param>
        /// <returns></returns>
        public byte[] GetBytesFromImage(string imagefile)
        {
          
            try
            {
                FileStream fs = new FileStream(imagefile, FileMode.Open, FileAccess.Read); //将图片以文件流的形式进行保存
                BinaryReader br = new BinaryReader(fs);
                byte[] imgBytesIn = br.ReadBytes((int)fs.Length); //将流读入到字节数组中
                return imgBytesIn;
            }
            catch (Exception e)
            {
                throw new Exception("转换失败!" + e.Message);
            }
        }


     
        /// <summary>
        /// Image转换为base64字符串
        /// </summary>
        /// <param name="bmp"></param>
        /// <returns></returns>
        public string ImageToBase64(Image img)
        {
            try
            {
                byte[] byt = null;
                using (MemoryStream ms = new MemoryStream())
                {
                    img.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
                    byt = new byte[ms.Length];
                    ms.Position = 0;
                    ms.Read(byt, 0, (int)ms.Length);
                    ms.Close();
                }
                if (byt == null)
                {
                    MessageBox.Show("ImageToBase64转换失败");
                    return "";
                }
                else
                {
                    return Convert.ToBase64String(byt);
                }

            }
            catch (Exception ex)
            {
                MessageBox.Show("转换失败：" + ex.Message);
              
                return "";
            }
        }

      

        /// <summary>
        /// 缩放图片（缩放PNG）
        /// </summary>
        /// <param name="imgToResize"></param>
        /// <param name="size"></param>
        /// <returns></returns>
        public System.Drawing.Image ResizeImage(System.Drawing.Image imgToResize, Size size)
        {
            //获取图片宽度
            int sourceWidth = imgToResize.Width;
            //获取图片高度
            int sourceHeight = imgToResize.Height;

            float nPercent = 0;
            float nPercentW = 0;
            float nPercentH = 0;
            //计算宽度的缩放比例
            nPercentW = ((float)size.Width / (float)sourceWidth);
            //计算高度的缩放比例
            nPercentH = ((float)size.Height / (float)sourceHeight);

            if (nPercentH < nPercentW)
                nPercent = nPercentH;
            else
                nPercent = nPercentW;
            //期望的宽度
            int destWidth = (int)(sourceWidth * nPercent);
            //期望的高度
            int destHeight = (int)(sourceHeight * nPercent);

            Bitmap b = new Bitmap(destWidth, destHeight);
            Graphics g = Graphics.FromImage((System.Drawing.Image)b);
            g.InterpolationMode = InterpolationMode.HighQualityBicubic;
            //绘制图像
            g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
            g.Dispose();
            return (System.Drawing.Image)b;
        }
    }