Bitmap SaveInMemory(Stream stream, long quality, Bitmap myBitmap)
        {
            ImageCodecInfo myImageCodecInfo;
            Encoder myEncoder;
            EncoderParameter myEncoderParameter;
            EncoderParameters myEncoderParameters;

            // Get an ImageCodecInfo object that represents the JPEG codec.
            myImageCodecInfo = GetEncoderInfo("image/jpeg");

            // Create an Encoder object based on the GUID
            // for the Quality parameter category.
            myEncoder = Encoder.Quality;

            // EncoderParameter object in the array.
            using (myEncoderParameters = new EncoderParameters(1))
            {
                // Save the bitmap as a JPEG file with quality level.            
                myEncoderParameter = new EncoderParameter(myEncoder, quality);
                myEncoderParameters.Param[0] = myEncoderParameter;
                myBitmap.Save(stream, myImageCodecInfo, myEncoderParameters);
            }

            return myBitmap;
        }

 public bool SaveImageForSpecifiedQuality(System.Drawing.Image sourceImage, string savePath, int imageQualityValue)
 {
     //以下代码为保存图片时，设置压缩质量
     EncoderParameters encoderParameters = new EncoderParameters();
     EncoderParameter encoderParameter = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, imageQualityValue);
     encoderParameters.Param[0] = encoderParameter;
     try
     {
         ImageCodecInfo[] ImageCodecInfoArray = ImageCodecInfo.GetImageEncoders();
         ImageCodecInfo jpegImageCodecInfo = null;
         for (int i = 0; i < ImageCodecInfoArray.Length; i++)
         {
             if (ImageCodecInfoArray[i].FormatDescription.Equals("JPEG"))
             {
                 jpegImageCodecInfo = ImageCodecInfoArray[i];
                 break;
             }
         }
         sourceImage.Save(savePath, jpegImageCodecInfo, encoderParameters);
         return true;
     }
     catch
     {
         return false;
     }
 }

        public static byte[] CreateThumbnail(byte[] PassedImage, int newWidth, int newHeight)
        {
            byte[] ReturnedThumbnail;

            using (MemoryStream StartMemoryStream = new MemoryStream(), NewMemoryStream = new MemoryStream()) {
                // write the string to the stream
                StartMemoryStream.Write(PassedImage, 0, PassedImage.Length);

                // create the start Bitmap from the MemoryStream that contains the image
                Bitmap startBitmap = new Bitmap(StartMemoryStream);

                // create a new Bitmap with dimensions for the thumbnail.
                Bitmap newBitmap = new Bitmap(newWidth, newHeight);

                // Copy the image from the START Bitmap into the NEW Bitmap.
                // This will create a thumnail size of the same image.
                newBitmap = ResizeImage(startBitmap, newWidth, newHeight);

                // Save this image to the specified stream in the specified format.
                System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, 100L);
                myEncoderParameters.Param[0] = myEncoderParameter;
                ImageCodecInfo jpgEncoder = GetEncoder(ImageFormat.Jpeg);

                newBitmap.Save(NewMemoryStream, jpgEncoder, myEncoderParameters);

                // Fill the byte[] for the thumbnail from the new MemoryStream.
                ReturnedThumbnail = NewMemoryStream.ToArray();
            }

            // return the resized image as a string of bytes.
            return ReturnedThumbnail;
        }

        //// <summary>
        /// 图片切割函数
        /// </summary>
        /// <param name="sourceFile">原始图片文件</param>
        /// <param name="xNum">在Ｘ轴上的切割数量</param>
        /// <param name="yNum">在Ｙ轴上的切割数量</param>
        /// <param name="quality">质量压缩比</param>
        /// <param name="outputFile">输出文件名，不带后缀</param>
        /// <returns>成功返回true，失败则返回false</returns>
        public bool ImageCut(String sourceFile, int xNum, int yNum, long quality, String outputFile)
        {
            try
            {
                long imageQuality = quality;
                Bitmap sourceImage = new Bitmap(sourceFile);
                ImageCodecInfo myImageCodecInfo = GetEncoderInfo("image/jpeg");
                Encoder myEncoder = Encoder.Quality;
                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, imageQuality);
                myEncoderParameters.Param[0] = myEncoderParameter;
                float xWidth = sourceImage.Width / xNum;
                float yWidth = sourceImage.Height / yNum;
                String outputImage = "";

                for (int countY = 0; countY < yNum; countY++)
                    for (int countX = 0; countX < xNum; countX++)
                    {

                        RectangleF cloneRect = new RectangleF(countX * xWidth, countY * yWidth, xWidth, yWidth);
                        Bitmap newImage = sourceImage.Clone(cloneRect, PixelFormat.Format24bppRgb);
                        outputImage = outputFile + countX + countY + ".jpg";
                        newImage.Save(outputImage, myImageCodecInfo, myEncoderParameters);

                    }
                return true;
            }
            catch
            {
                return false;
            }

        }

        /// <summary>
        /// Gets the bytes.
        /// </summary>
        /// <param name="image">The image.</param>
        /// <param name="imageFormat">The image format.</param>
        /// <param name="qualityLevel">The quality level.
        /// <remarks>
        /// A quality level of 0 corresponds to the greatest compression, and a quality level of 100 corresponds to the least compression.
        /// https://msdn.microsoft.com/library/bb882583(v=vs.110).aspx
        /// </remarks></param>
        /// <returns>System.Byte[].</returns>
        /// <exception cref="OperationFailureException">GetBytes</exception>
        public static byte[] GetBytes(this Bitmap image, ImageFormat imageFormat = null, long qualityLevel = 100)
        {
            try
            {
                image.CheckNullObject("image");

                if (imageFormat == null)
                {
                    imageFormat = ImageFormat.Jpeg;
                }

                if (qualityLevel > 100 || qualityLevel < 1)
                {
                    qualityLevel = 100;
                }

                using (var memoryStream = new MemoryStream())
                {
                    var jpegEncoder = GetImageEncoder(imageFormat);
                    var encoder = Encoder.Quality;
                    var encoderParameters = new EncoderParameters(1);

                    var myEncoderParameter = new EncoderParameter(encoder, qualityLevel);
                    encoderParameters.Param[0] = myEncoderParameter;
                    image.Save(memoryStream, jpegEncoder, encoderParameters);

                    return memoryStream.ToBytes();
                }
            }
            catch (Exception ex)
            {
                throw ex.Handle();
            }
        }

 public ActionResult Thumbnail(string path)
 {
     var myCallback =
         new Image.GetThumbnailImageAbort(ThumbnailCallback);
     var paths = new List<string>(2);
     BuildPath(path, out folderPath, out resourcePath);
     var folder = session.OpenFolder(folderPath + "/");
     var resource = folder.GetResource(resourcePath + "/");
     var sourceStream = resource.GetReadStream();
     Bitmap bitmap = null;
     try
     {
         bitmap = new Bitmap(sourceStream);
     }
     catch (Exception)
     {
         var fs = new FileStream(Server.MapPath("~/Content/kendo/2014.2.716/Bootstrap/imagebrowser.png"), FileMode.Open);
         var tempBs = new byte[fs.Length];
         fs.Read(tempBs, 0, tempBs.Length);
         return new FileContentResult(tempBs, "image/jpeg");
     }
     var myThumbnail = bitmap.GetThumbnailImage(84, 70, myCallback, IntPtr.Zero);
     var ms = new MemoryStream();
     var myEncoderParameters = new EncoderParameters(1);
     var myEncoderParameter = new EncoderParameter(Encoder.Quality, 25L);
     myEncoderParameters.Param[0] = myEncoderParameter;
     myThumbnail.Save(ms, GetEncoderInfo("image/jpeg"), myEncoderParameters);
     ms.Position = 0;
     var bytes = ms.ToArray();
     return new FileContentResult(bytes, "image/jpeg");
 }

        static void Main(string[] args)
        {
            FileSize("noname.jpg");
            var image = new Bitmap("noname.jpg");

            var jgpEncoder = GetEncoder(ImageFormat.Jpeg);
            var myEncoder = Encoder.Quality;

            var myEncoderParameters = new EncoderParameters(1);
            var myEncoderParameter = new EncoderParameter(myEncoder, 50L);
            myEncoderParameters.Param[0] = myEncoderParameter;
            image.Save(@"TestPhotoQualityFifty.jpg", jgpEncoder, myEncoderParameters);
            FileSize("TestPhotoQualityFifty.jpg");

            myEncoderParameter = new EncoderParameter(myEncoder, 100L);
            myEncoderParameters.Param[0] = myEncoderParameter;
            image.Save(@"TestPhotoQualityHundred.jpg", jgpEncoder, myEncoderParameters);
            FileSize("TestPhotoQualityHundred.jpg");

            myEncoderParameter = new EncoderParameter(myEncoder, 70L);
            myEncoderParameters.Param[0] = myEncoderParameter;
            image.Save(@"TestPhotoQualityZero.jpg", jgpEncoder, myEncoderParameters);
            FileSize("TestPhotoQualityZero.jpg");

            Console.ReadLine();
        }

        public static void StoreIcon(string extension, string path, string mimeType)
        {
            if (!File.Exists(path))
            {
                try
                {
                    if (!Directory.Exists(Path.GetDirectoryName(path)))
                        Directory.CreateDirectory(Path.GetDirectoryName(path));
                    Bitmap image = IconHandler.IconFromExtension(extension, IconSize.Small);

                    System.Drawing.Imaging.Encoder qualityEncoder = System.Drawing.Imaging.Encoder.Quality;
                    long quality = 100;
                    EncoderParameter ratio = new EncoderParameter(qualityEncoder, quality);
                    EncoderParameters codecParams = new EncoderParameters(1);
                    codecParams.Param[0] = ratio;
                    ImageCodecInfo mimeCodecInfo = null;
                    foreach (ImageCodecInfo codecInfo in ImageCodecInfo.GetImageEncoders())
                    {
                        if (codecInfo.MimeType == mimeType)
                        {
                            mimeCodecInfo = codecInfo;
                            break;
                        }
                    }
                    if (mimeCodecInfo != null)
                        image.Save(path, mimeCodecInfo, codecParams); // Save to JPG
                }
                catch (Exception ex)
                {
                    logger.LogException(LogLevel.Error, "Failed to create icon", ex);
                }
            }
        }

        private void convertToPng(string sourcedir, string sourceFile, string sourceDirandFile)
        {
            try
            {
                // Load the image.
                System.Drawing.Image image1 = System.Drawing.Image.FromFile(sourceDirandFile);
                if (filetype == "jpg")
                {
                    ImageCodecInfo jgpEncoder = GetEncoder(ImageFormat.Jpeg);
                    // Create an Encoder object based on the GUID
                    // for the Quality parameter category.
                    System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                    EncoderParameters myEncoderParameters = new EncoderParameters(1);
                    EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, 100L);
                    myEncoderParameters.Param[0] = myEncoderParameter;
                    image1.Save(sourcedir + "\\" + sourceFile + ".jpg", jgpEncoder, myEncoderParameters);

                }
                else if (filetype == "png")
                {
                    // Save the image in PNG format.
                    image1.Save(sourcedir + "\\" + sourceFile + ".png", System.Drawing.Imaging.ImageFormat.Png);
                }
                progressBar1.Increment(1);
            }
            catch
            {
                Console.WriteLine("Crap");
            }
        }

        public static bool CropAndResize(string sourceFilePath, string targetFilePath, int x, int y, int width, int height, int destWidth=0, int destHeight=0 )
        {
            Image img = getImage(sourceFilePath, targetFilePath);

            Image target = ImageCropAndResize(img, x, y, width, height, destWidth, destHeight);
            img.Dispose();

            String extension = System.IO.Path.GetExtension(sourceFilePath).ToLower();

            if (extension != ".png")
            {

                ImageCodecInfo jgpEncoder = ImageTools.GetJpgCodec();
                System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, 98L);
                myEncoderParameters.Param[0] = myEncoderParameter;

                target.Save(targetFilePath, jgpEncoder, myEncoderParameters);

            }
            else
            {
                target.Save(targetFilePath, System.Drawing.Imaging.ImageFormat.Png);
            }

            return true;
        }

        public static void BmpSave(Bitmap newBmp, string outFile)
        {
            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;

            //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
            ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
            ImageCodecInfo jpegICI = null;
            for (int x = 0; x < arrayICI.Length; x++)
            {
                if (arrayICI[x].FormatDescription.Equals("JPEG"))
                {
                    jpegICI = arrayICI[x];//设置JPEG编码
                    break;
                }
            }

            if (jpegICI != null)
            {
                newBmp.Save(outFile, jpegICI, encoderParams);
            }
            else
            {
                newBmp.Save(outFile, ImageFormat.Jpeg);
            }
            newBmp.Dispose();
        }

        public static bool KiSaveAsJPEG(Bitmap bmp, string FileName, int Qty)
        {
            try
            {
                EncoderParameter p;
                EncoderParameters ps;

                ps = new EncoderParameters(1);

                p = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, Qty);
                ps.Param[0] = p;
                try
                {
                    File.Delete(FileName);
                }
                catch (Exception ex)
                {
                    Console.Write(ex.Message);
                }
                bmp.Save(FileName, GetCodecInfo("image/jpeg"), ps);

                return true;
            }
            catch
            {
                return false;
            }
        }

        public static void work() {
            keepGoing = true;
           
            Task.Factory.StartNew(()=>check());
            do {
                Bitmap img = GetScreenShot();
                ImageCodecInfo[] codec = ImageCodecInfo.GetImageEncoders();

                // initialisation d'un tableau de dimension 2 de parametres d'encodages 
                EncoderParameters encodeurs = new EncoderParameters(2);
                // parametre qualite
                EncoderParameter qualite = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality,quality);
                // Parametre compression 
                EncoderParameter compression = new EncoderParameter(System.Drawing.Imaging.Encoder.Compression, compress);
                // remplir tableau parametre
                encodeurs.Param[0] = qualite;
                encodeurs.Param[1] = compression;

                using (MemoryStream stm = new MemoryStream())
                {
                    img.Save(stm, codec[1], encodeurs);
                    if (Cnx.sendArray(stm.ToArray(), "04")) { Console.WriteLine("success ");  }
                    
                }

                Thread.Sleep(sleeptime);
            } while (keepGoing);

        }

        public static void CompressImage(Image sourceImage, int imageQuality, string savePath)
        {
            try
            {
                //Create an ImageCodecInfo-object for the codec information
                ImageCodecInfo jpegCodec = null;

                //Set quality factor for compression
                EncoderParameter imageQualitysParameter = new EncoderParameter(
                            System.Drawing.Imaging.Encoder.Quality, imageQuality);

                //List all avaible codecs (system wide)
                ImageCodecInfo[] alleCodecs = ImageCodecInfo.GetImageEncoders();

                EncoderParameters codecParameter = new EncoderParameters(1);
                codecParameter.Param[0] = imageQualitysParameter;

                //Find and choose JPEG codec
                for (int i = 0; i < alleCodecs.Length; i++)
                {
                    if (alleCodecs[i].MimeType == "image/jpeg")
                    {
                        jpegCodec = alleCodecs[i];
                        break;
                    }
                }

                //Save compressed image
                sourceImage.Save(HttpContext.Current.Server.MapPath(savePath), jpegCodec, codecParameter);
            }
            catch (Exception ex)
            {

            }
        }

        //http://social.msdn.microsoft.com/forums/en-US/wpf/thread/0f037b9c-779d-45ad-b797-01c25999491b
        public static BitmapImage ImageFromGDIPlus(byte[] bytes)
        {
            var guid = Guid.NewGuid();
            if (Directory.Exists(@"C:\Temp\") == false)
                Directory.CreateDirectory(@"C:\Temp\");

            var stream = new MemoryStream(bytes);
            var badMetadataImage = new Bitmap(stream);
            ImageCodecInfo myImageCodecInfo;
            Encoder myEncoder;
            EncoderParameter myEncoderParameter;
            EncoderParameters myEncoderParameters;
            // get an ImageCodecInfo object that represents the JPEG codec
            myImageCodecInfo = GetEncoderInfo("image/jpeg");
            // Create an Encoder object based on the GUID for the Quality parameter category
            myEncoder = Encoder.Quality;
            // Create an EncoderParameters object
            // An EncoderParameters object has an array of EncoderParameter objects.
            // In this case, there is only one EncoderParameter object in the array.
            myEncoderParameters = new EncoderParameters(1);
            // Save the image as a JPEG file with quality level 75.
            myEncoderParameter = new EncoderParameter(myEncoder, 75L);
            myEncoderParameters.Param[0] = myEncoderParameter;
            badMetadataImage.Save(@"C:\Temp\" + guid + ".bmp", myImageCodecInfo, myEncoderParameters);
            // Create the source to use as the tb source
            var bi = new BitmapImage();
            bi.BeginInit();
            bi.UriSource = new Uri(@"C:\Temp\" + guid + ".bmp", UriKind.Absolute);
            bi.EndInit();
            return bi;
        }

        /// <summary>
        /// Takes a screen-size + internal bezel width sized bitmap and crops it to remove the area taken up by the bezels. Making the image appear as if it was seen through a window.
        /// </summary>
        /// <param name="filePaths">The file paths.</param>
        /// <remarks>
        /// Writes a file of the same name with -wallpapered appended to the end in JPEG format to the same location as the source.
        /// </remarks>
        public static void Main(String[] filePaths)
        {
            if(filePaths.Length < 1)
            {
                DisplayInstructions();
                return;
            }

            foreach(var filePath in filePaths)
            {
                String fileName = Path.GetFileNameWithoutExtension(filePath);
                String fileDirectory = Path.GetDirectoryName(filePath);
                String jpgFilePath = String.Format("{0}{1}{2}-wallpapered.jpg", fileDirectory, Path.DirectorySeparatorChar, fileName);

                using(Bitmap sourceBitmap = new Bitmap(filePath))
                {
                    //Check size
                    if(sourceBitmap.Width != TotalMonitorWidth || sourceBitmap.Height != MaximumMonitorHeight)
                    {
                        DisplayInstructions();
                        continue;
                    }

                    Bitmap wallpaper = CreateWallpaper(sourceBitmap);

                    //Save as JPEG
                    var jpegImageCodecInfo = GetEncoderInfo("image/jpeg");
                    var qualityEncoder = Encoder.Quality;
                    var encoderParameters = new EncoderParameters(1);
                    var encoderParameter = new EncoderParameter(qualityEncoder, (Int64)JPEGQuality);
                    encoderParameters.Param[0] = encoderParameter;
                    wallpaper.Save(jpgFilePath, jpegImageCodecInfo, encoderParameters);
                }
            }
        }

 public static void Save(Image image, int maxWidth, int maxHeight, int quality, string filePath)
 {
     if (image != null || !image.Equals(0))
     {
         int originalWidth = image.Width;
         int originalHeight = image.Height;
         float ratioX = maxWidth / (float)originalWidth;
         float ratioY = maxHeight / (float)originalHeight;
         float ratio = Math.Min(ratioX, ratioY);
         int newWidth = (int)(originalWidth * ratio);
         int newHeight = (int)(originalHeight * ratio);
         newImage = new Bitmap(newWidth, newHeight, PixelFormat.Format24bppRgb);
         using (Graphics graphics = Graphics.FromImage(newImage))
         {
             graphics.CompositingQuality = CompositingQuality.HighQuality;
             graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
             graphics.SmoothingMode = SmoothingMode.HighQuality;
             graphics.DrawImage(image, 0, 0, newWidth, newHeight);
         }
         ImageCodecInfo imageCodecInfo = GetEncoderInfo(ImageFormat.Jpeg);
         System.Drawing.Imaging.Encoder encoder = System.Drawing.Imaging.Encoder.Quality;
         encoderParameters = new EncoderParameters(1);
         EncoderParameter encoderParameter = new EncoderParameter(encoder, quality);
         encoderParameters.Param[0] = encoderParameter;
         newImage.Save(filePath, imageCodecInfo, encoderParameters);
     }
 }

 public static EncoderParameters getParameters(int jpegQuality, ScreenshotFormat format)
 {
     EncoderParameters result;
     switch(format)
     {
         case ScreenshotFormat.BMP:
             result = new EncoderParameters(1);
             result.Param[0] = new EncoderParameter(Encoder.ColorDepth, 24);
             break;
         case ScreenshotFormat.JPEG:
             result = new EncoderParameters(1);
             result.Param[0] = new EncoderParameter(Encoder.Quality, jpegQuality);
             break;
         case ScreenshotFormat.TIFF:
             result = new EncoderParameters(2);
             EncoderParameter parameter = 
                 new EncoderParameter(Encoder.Compression, (long)EncoderValue.CompressionLZW);
             result.Param[0] = parameter;
             parameter = new EncoderParameter(Encoder.SaveFlag, (long)EncoderValue.LastFrame);
             result.Param[1] = parameter;
             break;
         default:
             result = new EncoderParameters(2);
             result.Param[0] = new EncoderParameter(Encoder.Compression,(long)EncoderValue.CompressionCCITT4);
             result.Param[1] = new EncoderParameter(Encoder.ColorDepth, (long)24);
             break;
     }
     return result;
 }

        public static bool TakeScreenshot(int quality_quotient)
        {
            Bitmap resultant = null;
            Graphics gfxScreenshot = null;
            latestScreenshot = new MemoryStream();

            try
            {
                resultant = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
                gfxScreenshot = Graphics.FromImage(resultant);
                gfxScreenshot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
            }
            catch
            {
                return false;
            }

            ImageCodecInfo jgpEncoder = GetEncoder(ImageFormat.Jpeg);
            System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
            EncoderParameters myEncoderParameters = new EncoderParameters(1);

            // Setting the picture quality
            EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, (long)quality_quotient);
            myEncoderParameters.Param[0] = myEncoderParameter;

            resultant.Save(latestScreenshot, jgpEncoder, myEncoderParameters);

            return true;
        }

        /// <summary>  
        /// Saves an image as a jpeg image, with the given quality  
        /// </summary>  
        /// <param name="path">Path to which the image would be saved.</param>  
        /// <param name="quality">An integer from 0 to 100, with 100 being the  
        /// highest quality</param>  
        /// <exception cref="ArgumentOutOfRangeException"> 
        /// An invalid value was entered for image quality. 
        /// </exception> 
        public void SavePNG(Image[] images, int quality, string workspace)
        {
            //ensure the quality is within the correct range
            if ((quality < 0) || (quality > 100))
            {
                //create the error message
                string error = string.Format("Jpeg image quality must be between 0 and 100, with 100 being the highest quality.  A value of {0} was specified.", quality);
                //throw a helpful exception
                throw new ArgumentOutOfRangeException(error);
            }

            //create an encoder parameter for the image quality
            var qualityParam = new EncoderParameter(Encoder.Quality, quality);

            //get the jpeg codec
            ImageCodecInfo jpegCodec = converter.GetEncoderInfo("image/png");

            //create a collection of all parameters that we will pass to the encoder
            var encoderParams = new EncoderParameters(1);
            //set the quality parameter for the codec
            encoderParams.Param[0] = qualityParam;
            //save the images using the codec and the parameters
            //each image will be saved into it's folder
            for (int i = 0; i < images.Length; i++)
            {
                for (int j = 0; j < dirs.Length; j++)
                {
                    string desination = (path + splitter + workspace + dirs[i]);
                    Check(desination);
                    images[i].Save(desination, jpegCodec, encoderParams);
                }

            }
        }