//using MAX.Core.Helpers;
//using System;
//using System.Collections.Generic;
//using System.Drawing;
//using System.Drawing.Drawing2D;
//using System.Drawing.Imaging;
//using System.IO;

//namespace MAX.Framework.Helpers
//{
//	public class ImageBuild
//	{
//		public byte[] Img;
//		public int Width = 0, Height = 0;
//		public Image InitImage = null;
//		public string format = "";
//		public int PicQuality = 0;//图片质量
//		public bool CanUser
//		{
//			get { return format == ".jpg" || format == ".png"; }
//		}

//		public ImageBuild(byte[] image)
//		{
//			if (image == null || image.Length == 0)
//			{
//				return;
//			}

//			Img = image;
//			try
//			{
//				if (image.Length > 3145728)
//				{
//					return;
//				}
//				MemoryStream ms = new MemoryStream(Img);
//				InitImage = Image.FromStream(ms);
//				ImageFormat f = GetImageFormat(InitImage, out format);
//				ms.Close();
//				ms.Dispose();
//			}
//			catch (Exception e)
//			{
//				throw;
//			}
//			if (InitImage == null)
//			{
//				return;
//			}

//			Width = InitImage.Width;
//			Height = InitImage.Height;
//		}
//		/// <summary>
//		/// 裁剪为指定大小，不符合则返回null
//		/// </summary>
//		/// <param name="width"></param>
//		/// <param name="height"></param>
//		/// <returns></returns>
//		public byte[] CutToSize(int width, int height)
//		{
//			if (InitImage == null)
//			{
//				return null;
//			}

//			int w = InitImage.Width;
//			int h = InitImage.Height;
//			if (w < width || h < height)
//			{
//				return null;
//			}
//			int x = 0, y = 0, nw = w, nh = h;
//			int tx = 0, ty = 0, tw = width, th = height;
//			double f = w * 1.0 / width;
//			double t = h * 1.0 / height;
//			if (f == t)//无需变化
//			{
//			}
//			else if (f > t)//宽度较大
//			{
//				x = (int)((f - t) / 2 * width);
//				nw = w - (x * 2);
//			}
//			else//高度较大
//			{
//				y = (int)((t - f) / 2 * height);
//				nh = h - (y * 2);
//			}
//			Rectangle fromR = new Rectangle(x, y, nw, nh);
//			Rectangle toR = new Rectangle(tx, ty, tw, th);
//			Bitmap pickedImage = new Bitmap(width, height);

//			Graphics pickedG = Graphics.FromImage(pickedImage);
//			pickedG.InterpolationMode = InterpolationMode.Low;
//			pickedG.SmoothingMode = SmoothingMode.HighSpeed;
//			pickedG.DrawImage(InitImage, toR, fromR, GraphicsUnit.Pixel);
//			//转图片后转二进制数组
//			Image initImagex = (Image)pickedImage.Clone();
//			MemoryStream ms = new MemoryStream();
//			ImageCodecInfo icc = GetCodeInfo("1.jpg");
//			long quality = 80;
//			EncoderParameters ep = new EncoderParameters(1);
//			ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
//			initImagex.Save(ms, icc, ep);
//			byte[] bytes = ms.ToArray();
//			return bytes;
//		}
//		/// <summary>
//		/// 添加线条
//		/// </summary>
//		/// <param name="img"></param>
//		public void AddLineToImage(ref byte[] img)
//		{
//			MemoryStream ms = new MemoryStream(img);
//			Bitmap image = (Bitmap)Image.FromStream(ms);
//			ms.Close();
//			int width = image.Width;
//			int height = image.Height;
//			if (width < 100 || height < 100)
//			{
//				return;
//			}

//			int r = RandomHelper.GetRandomNumber(100, 256);
//			int b = RandomHelper.GetRandomNumber(100, 256);
//			int g = RandomHelper.GetRandomNumber(100, 256);
//			int h = RandomHelper.GetRandomNumber(1, 10);
//			Color c = Color.FromArgb(r, g, b);
//			for (int i = 0; i < h; i++)
//			{
//				for (int j = 0; j < height; j++)
//				{
//					image.SetPixel(i, j, c);
//				}

//				for (int j = 0; j < width; j++)
//				{
//					image.SetPixel(j, i, c);
//				}
//			}
//			for (int i = height - h; i < height; i++)
//			{
//				for (int j = 0; j < width; j++)
//				{
//					image.SetPixel(j, i, c);
//				}
//			}
//			for (int i = width - h; i < width; i++)
//			{
//				for (int j = 0; j < height; j++)
//				{
//					image.SetPixel(i, j, c);
//				}
//			}
//			ImageCodecInfo icc = GetCodeInfo("1.jpg");
//			long quality = 75;
//			ms = new MemoryStream();
//			EncoderParameters ep = new EncoderParameters(1);
//			ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
//			image.Save(ms, icc, ep);
//			img = ms.ToArray();
//			//FileBase.WriteBytes("1.jpg", bytes);
//		}


//		/// <summary>
//		/// 在图片四周区域随机选取8*8像素，微调像素值
//		/// </summary>
//		/// <param name="img"></param>
//		public void FineTuningImageToRandomArea(ref byte[] img)
//		{
//			try
//			{
//				MemoryStream ms = new MemoryStream(img);
//				Bitmap image = (Bitmap)Image.FromStream(ms);
//				int iW = image.Width;
//				int iH = image.Height;
//				if (iW <= 32 || iH <= 32)
//				{
//					return;
//				}

//				int x = 0;
//				int y = 0;
//				Random rand = new Random();
//				int r = rand.Next(1, 4);
//				switch (r)
//				{
//					case 1:
//						x = rand.Next(0, (iW / 4) - 8);
//						y = rand.Next(0, iH - 8);
//						break;
//					case 2:
//						x = rand.Next((iW / 4) - 8, iW - 8);
//						y = rand.Next(0, (iH / 4) - 8);
//						break;
//					case 3:
//						x = rand.Next((iW / 4) - 8, iW - 8);
//						y = rand.Next(3 * iH / 4, iH - 8);
//						break;
//					case 4:
//						x = rand.Next(3 * iW / 4, iW - 8);
//						y = rand.Next((iH / 4) - 8, 3 * iH / 4);
//						break;
//				}
//				List<List<PixPoint>> lstlstPixes = new List<List<PixPoint>>();
//				int tmpx = x;
//				int tmpy = y;
//				for (int jj = 0; jj < 4; jj++)
//				{
//					List<PixPoint> lstPixes = new List<PixPoint>
//					{
//						new PixPoint { X = tmpx, Y = tmpy }
//					};
//					for (int i = 1; i < 8 - (jj * 2); i++)
//					{
//						PixPoint ppx = new PixPoint { X = x, Y = ++tmpy };
//						lstPixes.Add(ppx);
//						PixPoint ppy = new PixPoint { X = ++tmpx, Y = y };
//						lstPixes.Add(ppy);
//					}
//					lstlstPixes.Add(lstPixes);
//					if (jj == 3)
//					{
//						break;
//					}

//					tmpx = ++x;
//					tmpy = ++y;
//				}

//				for (int jj = 3; jj >= 0; jj--)
//				{

//					List<PixPoint> lstPixes = new List<PixPoint>();
//					tmpx = ++x;
//					tmpy = ++y;
//					lstPixes.Add(new PixPoint { X = tmpx, Y = tmpy });
//					for (int i = 1; i < 7 - (jj * 2); i++)
//					{
//						PixPoint ppx = new PixPoint { X = x, Y = --tmpy };
//						lstPixes.Add(ppx);
//						PixPoint ppy = new PixPoint { X = --tmpx, Y = y };
//						lstPixes.Add(ppy);
//					}
//					lstlstPixes[jj].AddRange(lstPixes);
//				}

//				int inc = 0;
//				foreach (List<PixPoint> lstpix in lstlstPixes)
//				{
//					inc++;
//					foreach (PixPoint pix in lstpix)
//					{
//						Color color = image.GetPixel(pix.X, pix.Y);
//						int newR, newG, newB;
//						newR = color.R + inc > 255 ? 255 : color.R + inc;
//						newG = color.G + inc > 255 ? 255 : color.G + inc;
//						newB = color.B + inc > 255 ? 255 : color.B + inc;
//						Color c = Color.FromArgb(newR, newG, newB);
//						image.SetPixel(pix.X, pix.Y, c);
//					}
//				}
//				ImageCodecInfo icc = GetCodeInfo("1.jpg");
//				//long quality = 75;
//				long quality = PicQuality;//之前固定值  现在改为设置的数值 
//				ms = new MemoryStream();
//				EncoderParameters ep = new EncoderParameters(1);
//				ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
//				image.Save(ms, icc, ep);
//				img = ms.ToArray();
//				//TODO:Need Test
//				//image.Dispose();
//				ms.Close();
//			}
//			catch (Exception ex)
//			{
//				throw;
//			}
//		}

//		/// <summary>
//		/// 输出固定大小图片，背景白色填充，返回JPG格式二进制代码
//		/// </summary>
//		/// <param name="width"></param>
//		/// <param name="height"></param>
//		/// <param name="maxSize">最大尺寸KB</param>
//		/// <returns></returns>
//		public byte[] BuildNewSize(int width, int height, int maxSize, string codePath = "1.jpg")
//		{
//			if (InitImage == null)
//			{
//				return null;
//			}

//			int w = InitImage.Width;
//			int h = InitImage.Height;
//			int x = 0, y = 0, nw = w, nh = h;
//			int tx = 0, ty = 0, tw = width, th = height;
//			//先缩放
//			if (w <= width && h <= height)//无需缩放
//			{
//				tx = (width - w) / 2;
//				tw = w;
//				ty = (height - h) / 2;
//				th = h;
//			}
//			else if (w < width && h > height)
//			{
//				tx = (width - w) / 2;
//				tw = w;
//				y = (h - height) / 2;
//				nh = height;
//			}
//			else if (w > width && h < height)
//			{
//				ty = (height - h) / 2;
//				th = h;
//				x = (w - width) / 2;
//				nw = width;
//			}
//			else
//			{
//				double f = w * 1.0 / width;
//				double t = h * 1.0 / height;
//				if (f == t)//无需变化
//				{
//				}
//				else if (f > t)//宽度较大
//				{
//					x = (int)((f - t) / 2 * width);
//					nw = w - (x * 2);
//				}
//				else//高度较大
//				{
//					y = (int)((t - f) / 2 * height);
//					nh = h - (y * 2);
//				}
//			}
//			Rectangle fromR = new Rectangle(x, y, nw, nh);
//			Rectangle toR = new Rectangle(tx, ty, tw, th);
//			Bitmap pickedImage = new Bitmap(width, height);
//			for (int i = 0; i < pickedImage.Width; i++)
//			{
//				for (int j = 0; j < pickedImage.Height; j++)
//				{
//					Color color = Color.FromArgb(255, 255, 255);
//					pickedImage.SetPixel(i, j, color);
//				}
//			}
//			Graphics pickedG = Graphics.FromImage(pickedImage);
//			pickedG.InterpolationMode = InterpolationMode.Low;
//			pickedG.SmoothingMode = SmoothingMode.HighSpeed;
//			pickedG.DrawImage(InitImage, toR, fromR, GraphicsUnit.Pixel);
//			//转图片后转二进制数组
//			Image initImagex = (Image)pickedImage.Clone();
//			MemoryStream ms = new MemoryStream();
//			ImageCodecInfo icc = GetCodeInfo(codePath);

//			//long quality = maxSize == 1024 ? 75l : 85;
//			long quality = PicQuality;//之前固定值  现在改为设置的数值 
//			EncoderParameters ep = new EncoderParameters(1);
//			ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
//			initImagex.Save(ms, icc, ep);
//			byte[] bytes = ms.ToArray();
//			if (bytes.Length > maxSize * 1024)
//			{
//				ms = new MemoryStream();
//				ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 75L);
//				initImagex.Save(ms, icc, ep);
//				bytes = ms.ToArray();
//			}
//			if (bytes.Length > maxSize * 1024)
//			{
//				ms = new MemoryStream();
//				ep.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 55L);
//				initImagex.Save(ms, icc, ep);
//				bytes = ms.ToArray();
//			}
//			//TODO:Need Test
//			//pickedImage.Dispose();
//			//pickedG.Dispose();
//			//initImagex.Dispose();
//			//ms.Close();
//			if (bytes.Length > maxSize * 1024)
//			{
//				return null;
//			}
//			//ImageCodecInfo icc = GetCodeInfo("1.jpg");
//			//initImagex.Save("22.jpg", icc, ep);
//			return bytes;
//		}
//		/// <summary>
//		/// 根据路劲得出图片编码信息
//		/// </summary>
//		/// <param name="path"></param>
//		/// <returns></returns>
//		public ImageCodecInfo GetCodeInfo(string path)
//		{
//			string exe = path.Split('.')[path.Split('.').Length - 1].ToLower();
//			ImageCodecInfo[] icis = ImageCodecInfo.GetImageEncoders();
//			ImageCodecInfo ici = null, defCodecInfo = null;
//			foreach (ImageCodecInfo i in icis)
//			{
//				if (i.MimeType == "image/jpeg")
//				{
//					defCodecInfo = i;
//				}

//				if ((exe == "jpg" || exe == "jpeg") && i.MimeType == "image/jpeg")
//				{
//					ici = i;
//				}
//				if (exe == "bmp" && i.MimeType == "image/bmp")
//				{
//					ici = i;
//				}
//				if (exe == "png" && i.MimeType == "image/png")
//				{
//					ici = i;
//				}
//				if (exe == "gif" && i.MimeType == "image/gif")
//				{
//					ici = i;
//				}
//			}
//			if (ici == null)
//			{
//				ici = defCodecInfo;
//			}

//			return ici;
//		}

//		/// <summary>
//		/// 获取Image图片格式
//		/// </summary>
//		/// <param name="_img"></param>
//		/// <param name="format"></param>
//		/// <returns></returns>
//		private ImageFormat GetImageFormat(Image _img, out string format)
//		{
//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Jpeg))
//			{
//				format = ".jpg";
//				return System.Drawing.Imaging.ImageFormat.Jpeg;
//			}
//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Gif))
//			{
//				format = ".gif";
//				return System.Drawing.Imaging.ImageFormat.Gif;
//			}
//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Png))
//			{
//				format = ".png";
//				return System.Drawing.Imaging.ImageFormat.Png;
//			}
//			if (_img.RawFormat.Equals(System.Drawing.Imaging.ImageFormat.Bmp))
//			{
//				format = ".bmp";
//				return System.Drawing.Imaging.ImageFormat.Bmp;
//			}
//			format = string.Empty;
//			return null;
//		}


//		#region 随机裁四边--10个像素以内
//		public void CutPicture(ref byte[] file)
//		{
//			MemoryStream ms = new MemoryStream(file);
//			Bitmap image = (Bitmap)Image.FromStream(ms);

//			Random radom = new Random();
//			int cutPixl = radom.Next(1, 5); //左边切除的像素
//			int cutPixr = radom.Next(1, 5); //右边切除的像素
//			int cutPixt = radom.Next(1, 5); //顶部切除的像素
//			int cutPixb = radom.Next(1, 5); //底部切除的像素

//			Image img = BytesToImage(file);
//			int iniWidth = img.Width;
//			int iniHeight = img.Height;

//			try
//			{
//				Bitmap bitmap = StartCutImage(file, cutPixl, cutPixr, iniWidth - cutPixl - cutPixt, iniHeight - cutPixr - cutPixb, iniWidth, iniHeight);

//				image = bitmap;

//				ImageCodecInfo icc = GetCodeInfo("1.jpg");
//				//long quality = 75;
//				long quality = PicQuality;//之前固定值  现在改为设置的数值 
//				ms = new MemoryStream();
//				EncoderParameters ep = new EncoderParameters(1);
//				ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
//				image.Save(ms, icc, ep);
//				//    image.Save(ms,ImageFormat.Jpeg);
//				file = ms.ToArray();
//				//TODO:Need Test
//				//img.Dispose();
//				//bitmap.Dispose();
//				//image.Dispose();
//				ms.Close();
//			}
//			catch (Exception)
//			{

//			}

//		}

//		/// <summary>
//		/// 剪裁
//		/// </summary>
//		/// <param name="b">原始Bitmap</param>
//		/// <param name="StartX">开始坐标X</param>
//		/// <param name="StartY">开始坐标Y</param>
//		/// <param name="iWidth">宽度</param>
//		/// <param name="iHeight">高度</param>
//		/// <returns>剪裁后的Bitmap</returns>
//		public static Bitmap StartCutImage(byte[] bytes, int StartX, int StartY, int iWidth, int iHeight, int iniWidth, int iniHeight)
//		{
//			Image image = BytesToImage(bytes);
//			Bitmap b = new Bitmap(image);
//			if (bytes == null)
//			{
//				return null;
//			}

//			try
//			{
//				Bitmap bmpOut = new Bitmap(iWidth, iHeight, PixelFormat.Format24bppRgb);//裁剪成小一号的图片
//																						//Bitmap bmpOut = new Bitmap(w, h, PixelFormat.Format24bppRgb);//保持原大小，裁剪部分用指定的颜色填充
//				Graphics graphics = Graphics.FromImage(bmpOut);
//				//graphics.Clear(Color.White);//裁剪部分用指定的颜色填充
//				graphics.DrawImage(b, new Rectangle(0, 0, iWidth, iHeight), new Rectangle(StartX, StartY, iWidth, iHeight), GraphicsUnit.Pixel);
//				graphics.Dispose();
//				bmpOut = new Bitmap(bmpOut, iniWidth, iniHeight);//图片保存原始的大小尺寸 
//				return bmpOut;
//			}
//			catch
//			{
//				return null;
//			}

//		}

//		/// <summary>
//		/// 字节数组转换为图片
//		/// </summary>
//		/// <param name="buffer">字节数组</param>
//		/// <returns>图片</returns>
//		public static Image BytesToImage(byte[] buffer)
//		{
//			MemoryStream ms = new MemoryStream(buffer, 0, buffer.Length);
//			Image img = Image.FromStream(ms);
//			ms.Dispose();
//			return img;
//		}

//		/// <summary>
//		/// 图片对象转字节数组
//		/// </summary>
//		/// <param name="imagePath">图片路径</param>
//		/// <returns>图片字节数组</returns>
//		private byte[] ImageToBytes(string imagePath)
//		{
//			FileStream fs = new FileStream(imagePath, FileMode.Open);
//			byte[] imgBytes = new byte[fs.Length];
//			fs.Read(imgBytes, 0, imgBytes.Length);
//			fs.Close();
//			return imgBytes;
//			//var bf = new BinaryFormatter();
//			//bf.Serialize(ms,imagePath);
//			//ms.Close();
//			//return ms.ToArray();

//		}

//		#endregion

//		#region 添加文字水印
//		public void AddWaterMark(ref byte[] file, string shopName = "")
//		{
//			MemoryStream ms = new MemoryStream(file);
//			Bitmap image = (Bitmap)Image.FromStream(ms);

//			try
//			{
//				Bitmap bitmap = StartAddWaterMark(file, shopName);
//				image = bitmap;

//				ImageCodecInfo icc = GetCodeInfo("1.jpg");
//				//long quality = 75;
//				long quality = PicQuality;//之前固定值  现在改为设置的数值 
//				ms = new MemoryStream();
//				EncoderParameters ep = new EncoderParameters(1);
//				ep.Param[0] = new EncoderParameter(Encoder.Quality, quality);
//				image.Save(ms, icc, ep);
//				file = ms.ToArray();
//				//image.Dispose();
//				//bitmap.Dispose();
//				ms.Close();
//			}
//			catch (Exception)
//			{
//				throw;
//			}

//		}

//		/// <summary>
//		/// 检测是否是白底图
//		/// </summary>
//		/// <param name="bytesImg">图片byte数组</param>
//		/// <returns>true-白底图  false-非白底图</returns>
//		public static bool CheckImageIsWhiteBackground(byte[] bytesImg)
//		{
//			MemoryStream ms = new MemoryStream(bytesImg);
//			Bitmap image = (Bitmap)Image.FromStream(ms);
//			int iWhitePixNum = 0;
//			int iTotalPix = 0;
//			try
//			{
//				int iWidth = image.Width;
//				int iHeight = image.Height;
//				int iInpectWidth = 20;
//				//统计三窄边白色像素数量
//				for (int i = 0; i < iInpectWidth; i++)
//				{
//					for (int j = 0; j < iHeight; j++)
//					{
//						Color cl = image.GetPixel(i, j);
//						iTotalPix++;
//						if (cl.Name.Equals("ffffffff"))
//						{
//							iWhitePixNum++;
//						}
//					}
//				}
//				for (int i = iWidth - iInpectWidth; i < iWidth; i++)
//				{
//					for (int j = iInpectWidth; j < iHeight; j++)
//					{
//						Color cl = image.GetPixel(i, j);
//						iTotalPix++;
//						if (cl.Name.Equals("ffffffff"))
//						{
//							iWhitePixNum++;
//						}
//					}
//				}
//				for (int i = iInpectWidth; i < iWidth; i++)
//				{
//					for (int j = 0; j < iInpectWidth; j++)
//					{
//						Color cl = image.GetPixel(i, j);
//						iTotalPix++;
//						if (cl.Name.Equals("ffffffff"))
//						{
//							iWhitePixNum++;
//						}
//					}
//				}
//			}
//			catch (Exception ex)
//			{
//				throw;
//			}
//			finally
//			{
//				ms.Close();
//				image.Dispose();
//			}
//			//如果三窄边的白色像素数量占比高于85%，则判定为白底图
//			return Decimal.Divide(iWhitePixNum, iTotalPix) > (decimal)0.85;
//		}

//		/// <summary>
//		/// 添加图片水印
//		/// </summary>
//		/// <param name="image"></param>
//		/// <param name="text"></param>
//		/// <param name="rectX">水印开始X坐标（自动扣除图片宽度）</param>
//		/// <param name="rectY">水印开始Y坐标（自动扣除图片高度</param>
//		/// <param name="opacity">透明度 0-1</param>
//		/// <param name="externName">文件后缀名</param>
//		/// <returns></returns>
//		public void AddLogoWaterMark(ref byte[] file, Image watermark, float opacity, string externName, bool bFill = true)
//		{
//			MemoryStream ms = new MemoryStream(file);
//			Bitmap image = (Bitmap)Image.FromStream(ms);
//			Bitmap bitmap = new Bitmap(image, image.Width, image.Height); //改为固定

//			Graphics g = Graphics.FromImage(bitmap);

//			//下面定义一个矩形区域      
//			float rectWidth = watermark.Width + 10;
//			float rectHeight = watermark.Height + 10;
//			//声明矩形域

//			RectangleF textArea;
//			if (bFill)
//			{
//				textArea = new RectangleF(0, 0, image.Width, image.Height);
//			}
//			else
//			{
//				int height = watermark.Height;
//				int width = watermark.Width;
//				height = 80;
//				width = 80;
//				textArea = new RectangleF(0, 0, width, height);
//			}
//			Bitmap w_bitmap = ChangeOpacity(watermark, opacity);

//			g.DrawImage(w_bitmap, 0, 0, 80, 80);
//			ms = new MemoryStream();
//			//保存图片
//			switch (externName)
//			{
//				case ".jpg":
//					bitmap.Save(ms, ImageFormat.Jpeg);
//					break;
//				case ".gif":
//					bitmap.Save(ms, ImageFormat.Gif);
//					break;
//				case ".png":
//					bitmap.Save(ms, ImageFormat.Png);
//					break;
//				default:
//					bitmap.Save(ms, ImageFormat.Jpeg);
//					break;
//			}

//			file = ms.ToArray();
//			ms.Close();
//			g.Dispose();
//			bitmap.Dispose();
//		}

//		/// <summary>
//		/// 改变图片的透明度
//		/// </summary>
//		/// <param name="img">图片</param>
//		/// <param name="opacityvalue">透明度</param>
//		/// <returns></returns>
//		public Bitmap ChangeOpacity(Image img, float opacityvalue)
//		{

//			float[][] nArray ={ new float[] {1, 0, 0, 0, 0},
//								new float[] {0, 1, 0, 0, 0},
//								new float[] {0, 0, 1, 0, 0},
//								new float[] {0, 0, 0, opacityvalue, 0},
//								new float[] {0, 0, 0, 0, 1}};
//			ColorMatrix matrix = new ColorMatrix(nArray);
//			ImageAttributes attributes = new ImageAttributes();
//			attributes.SetColorMatrix(matrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
//			Image srcImage = img;
//			Bitmap resultImage = new Bitmap(srcImage.Width, srcImage.Height);
//			Graphics g = Graphics.FromImage(resultImage);
//			g.DrawImage(srcImage, new Rectangle(0, 0, srcImage.Width, srcImage.Height), 0, 0, srcImage.Width, srcImage.Height, GraphicsUnit.Pixel, attributes);
//			//g.DrawImage(srcImage, 0, 0, srcImage.Width, srcImage.Height) ;
//			//g.DrawImage(srcImage, 0, 0, 80,80);
//			g.Dispose();
//			attributes.Dispose();
//			return resultImage;
//		}

//		//private static Font crFont = new Font("微软雅黑", 30, FontStyle.Bold);
//		/// <summary>
//		/// 
//		/// </summary>
//		/// <param name="bytes"></param>
//		/// <param name="text">水印文字</param>
//		/// <returns></returns>
//		public static Bitmap StartAddWaterMark(byte[] bytes, string text = "")
//		{
//			if (bytes == null)
//			{
//				return null;
//			}

//			Image image = BytesToImage(bytes);
//			Bitmap bitmap = new Bitmap(image);
//			try
//			{

//				int width = bitmap.Width, height = bitmap.Height;

//				Graphics g = Graphics.FromImage(bitmap);

//				g.DrawImage(bitmap, 0, 0);

//				g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;

//				g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;

//				g.DrawImage(image, new Rectangle(0, 0, width, height), 0, 0, width, height, GraphicsUnit.Pixel);

//				Font crFont = new Font("微软雅黑", 30, FontStyle.Bold);
//				SizeF crSize = new SizeF();
//				crSize = g.MeasureString(text, crFont);

//				//背景位置(去掉了. 如果想用可以自己调一调 位置.)
//				//g.FillRectangle(new SolidBrush(Color.FromArgb(200, 255, 255, 255)), (width - crSize.Width) / 2, (height - crSize.Height) / 2, crSize.Width, crSize.Height);

//				SolidBrush semiTransBrush = new SolidBrush(Color.FromArgb(120, 177, 171, 171));//177, 171, 171


//				//文字水印随机加在一遍
//				Random rdom = new Random();
//				int rdLocation = rdom.Next(1, 5);//1:左边 2:右边 3：上边 4：下边

//				if (rdLocation == 1)
//				{
//					#region 左边
//					//将原点移动 到图片中点
//					g.TranslateTransform(0, (height / 2) + crSize.Height);
//					//以原点为中心 转 -45度
//					g.RotateTransform(-90);

//					g.DrawString(text, crFont, semiTransBrush, new PointF(0, 0));//文字所加的位置
//					#endregion
//				}
//				else if (rdLocation == 2)
//				{
//					#region 右边
//					//将原点移动 到图片中点
//					g.TranslateTransform(width - (crSize.Width / 2), (height / 2) + crSize.Height);
//					//以原点为中心 转 -45度
//					g.RotateTransform(-90);

//					g.DrawString(text, crFont, semiTransBrush, new PointF(0, 0));//文字所加的位置
//					#endregion
//				}
//				else if (rdLocation == 3)
//				{
//					#region 上边
//					////将原点移动 到图片中点
//					//g.TranslateTransform(width / 2 - crSize.Width, 0);
//					////以原点为中心 转 -45度
//					//g.RotateTransform(-0);

//					g.DrawString(text, crFont, semiTransBrush, new PointF((width / 2) - (crSize.Width / 2), 0));//文字所加的位置
//					#endregion
//				}
//				else if (rdLocation == 4)
//				{
//					#region 下边
//					////将原点移动 到图片中点
//					//g.TranslateTransform(width / 2 - crSize.Width, height - crSize.Height * 3);
//					////以原点为中心 转 -0度
//					////g.RotateTransform(-0);

//					g.DrawString(text, crFont, semiTransBrush, new PointF((width / 2) - (crSize.Width / 2), height - crSize.Height));//文字所加的位置
//					#endregion
//				}
//				else
//				{
//					#region 上边
//					g.DrawString(text, crFont, semiTransBrush, new PointF((width / 2) - (crSize.Width / 2), 0));//文字所加的位置
//					#endregion
//				}
//				//crFont.Dispose();
//				g.Dispose();
//				//image.Dispose();
//				//semiTransBrush.Dispose();
//				////将原点移动 到图片中点
//				//g.TranslateTransform(width / 2, height / 2);
//				////以原点为中心 转 -45度
//				//g.RotateTransform(-45);

//				//g.DrawString(text, crFont, semiTransBrush, new PointF(width / 2 - crSize.Width / 2, 0));//文字所加的位置


//			}
//			catch (Exception e)
//			{
//				throw;
//			}

//			return bitmap;
//		}
//		#endregion

//		/// <summary>
//		/// 获取两张图片的相似度
//		/// </summary>
//		/// <param name="image1">图片1</param>
//		/// <param name="image2">图片2</param>
//		/// <returns></returns>
//		public static string GetSimilarityForTwoImgs(Image image1, Image image2)
//		{
//			string sImg1Hash = GetHash(image1);
//			string sImg2Hash = GetHash(image2);
//			return (Math.Round(((64.0 * 64.0) - CalcSimularDegree(sImg1Hash, sImg2Hash)) / (64.0 * 64.0), 4) * 100) + "%";
//		}

//		private static int CalcSimularDegree(string a, string b)
//		{
//			if (a.Length != b.Length)
//			{
//				throw new ArgumentException();
//			}

//			int count = 0;
//			for (int i = 0; i < a.Length; i++)
//			{
//				if (a[i] != b[i])
//				{
//					count++;
//				}
//			}
//			return count;
//		}

//		private static string GetHash(Image sourceImage)
//		{
//			Image image = ReduceSize(sourceImage);
//			byte[] grayValues = ReduceColor(image);
//			byte average = CalcAverage(grayValues);
//			string sRes = ComputeBits(grayValues, average);
//			image.Dispose();
//			image = null;
//			return sRes;
//		}

//		private static string ComputeBits(byte[] grayValues, byte average)
//		{
//			char[] result = new char[grayValues.Length];
//			for (int i = 0; i < grayValues.Length; i++)
//			{
//				if (grayValues[i] < average)
//				{
//					result[i] = '0';
//				}
//				else
//				{
//					result[i] = '1';
//				}
//			}
//			return new string(result);
//		}

//		private static byte CalcAverage(byte[] grayValues)
//		{
//			int sum = 0;
//			for (int i = 0; i < grayValues.Length; i++)
//			{
//				sum += grayValues[i];
//			}
//			return System.Convert.ToByte(sum / grayValues.Length);
//		}

//		private static byte[] ReduceColor(Image image)
//		{
//			Bitmap bitmap = new Bitmap(image);
//			byte[] grayValues = new byte[image.Width * image.Height];

//			for (int i = 0; i < image.Width; i++)
//			{
//				for (int j = 0; j < image.Height; j++)
//				{
//					Color color = bitmap.GetPixel(i, j);
//					byte grayValue = (byte)(((color.R * 30) + (color.G * 59) + (color.B * 11)) / 100);
//					grayValues[(i * image.Width) + j] = grayValue;
//				}
//			}
//			bitmap.Dispose();
//			return grayValues;
//		}

//		private static Image ReduceSize(Image image)
//		{
//			Image image1 = image.GetThumbnailImage(64, 64, () =>
//			{
//				return false;
//			}, IntPtr.Zero);
//			return image1;
//		}

//		//byte[] 转换 Bitmap
//		public static Bitmap BytesToBitmap(byte[] Bytes)
//		{
//			MemoryStream stream = null;
//			try
//			{
//				stream = new MemoryStream(Bytes);
//				return new Bitmap(new Bitmap(stream));
//			}
//			catch (ArgumentNullException ex)
//			{
//				throw ex;
//			}
//			catch (ArgumentException ex)
//			{
//				throw ex;
//			}
//			finally
//			{
//				stream.Close();
//			}
//		}
//		//Bitmap转byte[]  
//		public static byte[] BitmapToBytes(Bitmap Bitmap)
//		{
//			MemoryStream ms = null;
//			try
//			{
//				ms = new MemoryStream();
//				Bitmap.Save(ms, Bitmap.RawFormat);
//				byte[] byteImage = new Byte[ms.Length];
//				byteImage = ms.ToArray();
//				return byteImage;
//			}
//			catch (ArgumentNullException ex)
//			{
//				throw ex;
//			}
//			finally
//			{
//				ms.Close();
//			}
//		}
//		public static Image ResizeImage(Image imgToResize, Size size)
//		{
//			//获取图片宽度
//			int sourceWidth = imgToResize.Width;
//			//获取图片高度
//			int sourceHeight = imgToResize.Height;

//			float nPercent = 0;
//			float nPercentW = 0;
//			float nPercentH = 0;
//			//计算宽度的缩放比例
//			nPercentW = size.Width / (float)sourceWidth;
//			//计算高度的缩放比例
//			nPercentH = 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(b);
//			g.InterpolationMode = InterpolationMode.HighQualityBicubic;
//			//绘制图像
//			g.DrawImage(imgToResize, 0, 0, destWidth, destHeight);
//			g.Dispose();
//			return b;
//		}

//		private class PixPoint
//		{
//			public int X { get; set; }
//			public int Y { get; set; }
//		}
//	}
//}