C# Image.Save方法代码示例

        public void Save(string filename, Image image)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                string ext = R.Util.Str.getFileExtension(filename);
                switch (ext)
                {
                    case "jpg":
                    case "jpeg":
                        JpegEncoder jpgencoder = new JpegEncoder();
                        image.Save(ms, jpgencoder);
                        break;

                    case "png":
                        PngEncoder pngencoder = new PngEncoder();
                        image.Save(ms, pngencoder);
                        break;

                }
                //save to disk
                using (FileStream fs = new FileStream(R.Server.MapPath(filename), FileMode.Create))
                {
                    ms.Position = 0;
                    ms.WriteTo(fs);
                    fs.Dispose();
                }
                ms.Dispose();
            }
        }

	static string ImageToString (Image img)
	{
		MemoryStream stream = new MemoryStream ();
		img.Save (stream, ImageFormat.Png);
		stream.Position = 0;
		int LengthOfBuffer = (int) stream.Length;
		byte [] buff = new byte [LengthOfBuffer];
		stream.Read (buff, 0, LengthOfBuffer);
		return Convert.ToBase64String (buff);
	}

    // Use this for initialization
    void Start()
    {
        Image<Bgr, byte> picture = new Image<Bgr, byte> ("/Users/jacobhanshaw/Desktop/picture1.jpg");
        Bgr myWhiteColor = new Bgr (255, 255, 255);
        for (int i=0; i<200; i++) {
            picture [0, i] = myWhiteColor;
        }
        picture.Save ("/Users/jacobhanshaw/Desktop/picture2.jpg");

        //FaceRecognizer faceRec = new FaceRecognizer();
    }

 /// <summary>
 /// Adds a frame to this animation.
 /// </summary>
 /// <param name="img">The image to add</param>
 /// <param name="x">The positioning x offset this image should be displayed at.</param>
 /// <param name="y">The positioning y offset this image should be displayed at.</param>
 public void AddFrame(Image img, int x = 0, int y = 0, TimeSpan? frameDelay = null)
 {
     using (var gifStream = new MemoryStream())
     {
         img.Save(gifStream, ImageFormat.Gif);
         if (_isFirstImage) // Steal the global color table info
         {
             InitHeader(gifStream, img.Width, img.Height);
         }
         WriteGraphicControlBlock(gifStream, frameDelay.GetValueOrDefault(FrameDelay));
         WriteImageBlock(gifStream, !_isFirstImage, x, y, img.Width, img.Height);
     }
     _isFirstImage = false;
 }

    public static void SaveJpeg(string path, Image image, int quality)
    {
        if ((quality < 0) || (quality > 100))
            {
                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 new ArgumentOutOfRangeException(error);
            }

            EncoderParameter qualityParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)quality);
            ImageCodecInfo jpegCodec = GetEncoderInfo("image/jpeg");

            EncoderParameters encoderParams = new EncoderParameters(1);
            encoderParams.Param[0] = qualityParam;
            image.Save(path, jpegCodec, encoderParams);
    }

    public static void SaveImage(Image img)
    {
        try
        {
            using (var sfd = new SaveFileDialog { Title = "Redact | Save Image", Filter = "PNG Files (.png) | *.png" })
                if (sfd.ShowDialog() == DialogResult.OK)
                {
                    img.Save(sfd.FileName, ImageFormat.Png);

                    MessageBox.Show("Image successfully saved to " + sfd.FileName, "Redact", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
        }
        catch
        {
            MessageBox.Show("An error occured when attempting to save.", "Redact", MessageBoxButtons.OK, MessageBoxIcon.Error);
        }
    }

 /// <summary>
 /// Окно сохранения изображений
 /// </summary>
 /// <param name="image"></param>
 public static void SaveImage(Image image)
 {
     SaveFileDialog sfd = new SaveFileDialog();
     sfd.Filter = "Images|*.png;*.bmp;*.jpg";
     ImageFormat format = ImageFormat.Png;
     if (sfd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
     {
         string ext = System.IO.Path.GetExtension(sfd.FileName);
         switch (ext)
         {
             case ".jpg":
                 format = ImageFormat.Jpeg;
                 break;
             case ".bmp":
                 format = ImageFormat.Bmp;
                 break;
         }
         image.Save(sfd.FileName, format);
     }
 }

 static void SaveImage(Image img, Stream outputStream, ImageFormat fmt)
 {
     if (fmt==ImageFormat.Jpeg) {
         // for jpeg, lets set 90% quality explicitely
         ImageCodecInfo[] codecs = ImageCodecInfo.GetImageDecoders();
         var jpegCodec = codecs.Where( c=> c.FormatID == ImageFormat.Jpeg.Guid ).FirstOrDefault();
         if (jpegCodec!=null) {
             var jpegEncoderParameters = new EncoderParameters(1);
             jpegEncoderParameters.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 90L);
              img.Save(outputStream, jpegCodec, jpegEncoderParameters);
             return;
         }
     }
      img.Save(outputStream, fmt);
 }

    string HashFromImage(Image img)
    {
        string hash;
        byte[] bytes = null;

        using (MemoryStream ms = new MemoryStream()) {
            img.Save (ms, img.RawFormat);
            bytes = ms.ToArray ();
        }

        using (SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider()) {
            bytes = sha1.ComputeHash (bytes);
            hash = BitConverter.ToString (bytes).Replace ("-", "").ToLower ();
        }

        return hash;
    }

    // Saves the image to specific location, save location includes filename
    private static void saveImageToLocation(Image theImage, string saveLocation)
    {
        // Strip the file from the end of the dir
        string saveFolder = Path.GetDirectoryName(saveLocation);
        if (!Directory.Exists(saveFolder))
        {
            Directory.CreateDirectory(saveFolder);
        }

        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;

        // 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.
        EncoderParameters myEncoderParameters = new EncoderParameters(1);
        EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, 90L);
        myEncoderParameters.Param[0] = myEncoderParameter;

        // Save to disk
        theImage.Save(saveLocation, jgpEncoder, myEncoderParameters);
    }

        private async void CompositionTarget_Rendering(object sender, EventArgs e)
        {
            currentFrame = grabber.QueryFrame().Resize(320, 240, Emgu.CV.CvEnum.INTER.CV_INTER_CUBIC);            

            if (_rects == null || _rects.Length == 0)
            {
                gray = currentFrame.Convert<Gray, Byte>();

                var size = new System.Drawing.Size(20, 20);
                var window = new System.Drawing.Size(grabber.Width, grabber.Height);
                _rects = _faceClassifier.DetectMultiScale(gray, 1.2, 10, size, window);

                _vmodel.PersonRecognized = _rects.Length;

                if (_rects.Length > 0)
                {                    
                    /*
                    1) save the current rendered faces
                    2) upload the current frame to detect
                    3) verify with trained images
                    */
                    string snapshot = CommonData.TARGET_SNAPSHOT_PAHT + DateTime.Now.ToString().Replace('/', '_').Replace(':', '_') + "." + CommonData.IMAGE_EXT;
                    currentFrame.Save(snapshot);

                    _progressRec.IsIndeterminate = false;
                    _progressRec.IsEnabled = true;

                    var fr = await UploadAndDetectFaces(snapshot);

                    //detect all faces
                    foreach (var trainedFile in CommonData.ImageFiles)
                    {
                        var fileStream = File.OpenRead(trainedFile);
                        var f = await faceServiceClient.DetectAsync(fileStream);
                        _trainedFacesAI.AddRange(f.ToList());
                    }

                    int i = 0;
                    //verify reading from all db
                    foreach (var face in _detectedFaceFromAI)
                    {
                        foreach (var secondFace in _trainedFacesAI)
                        {
                            var res = await faceServiceClient.VerifyAsync(face.FaceId, secondFace.FaceId);

                            PictureModel _model = new PictureModel();
                            _model.ImgSource = new WriteableBitmap(new BitmapImage(new Uri(CommonData.ImageFiles[i])));
                            _model.AIID = face.FaceId.ToString();

                            if (res.IsIdentical)
                            {
                                _model.Name = CommonData.Names[i];
                                _model.ID = i;
                                _model.IsVerified = true;
                                _model.Confidence = res.Confidence;
                            }
                            else
                            {
                                _model.Name = "Unkonwn";
                                _model.IsVerified = false;
                                _model.Confidence = res.Confidence;
                            }

                            var c = _vmodel.Pictures.Where(x => x.AIID == _model.AIID).Count();
                            if (!(c > 0))//adds only if is not already added
                            {
                                _vmodel.Pictures.Add(_model);
                            }

                            i++;
                        }
                    }

                    _progressRec.IsIndeterminate = false;
                    _progressRec.IsEnabled = false;
                }                
            }            

            _imgSource.Source = ImageHelper.ToBitmapSource(currentFrame);
        }

 public static byte[] ImageToByte2(Image img)
 {
     byte[] byteArray = new byte[0];
     using (MemoryStream stream = new MemoryStream())
     {
         img.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);
         stream.Close();
         byteArray = stream.ToArray();
     }
     return byteArray;
 }

 public string ConvertToString(Image value)
 {
     MemoryStream imageStream = new MemoryStream();
     EncoderParameters pams = new EncoderParameters(1);
     pams.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 100L);
     value.Save(imageStream, VideoEncoder.GetEncoder(ImageFormat.Jpeg), pams);
     return Convert.ToBase64String(imageStream.ToArray());
 }

 internal static byte[] ImageToBinary( Image NewImage)
 {
     try
     {
         byte[] ImageByteArray = null;
         MemoryStream ReadImage = new MemoryStream();
         NewImage.Save(ReadImage, System.Drawing.Imaging.ImageFormat.Png);
         ImageByteArray = new byte[Convert.ToInt32(ReadImage.Length - 1) + 1];
         ReadImage.Position = 0;
         ReadImage.Read(ImageByteArray, 0, Convert.ToInt32(ReadImage.Length));
         return ImageByteArray;
     }catch(Exception ex){
         MessageBox.Show(ex.Message);
         return null;
     }
 }

    public string ImageToBase64(Image image, System.Drawing.Imaging.ImageFormat format)
    {
        using (MemoryStream ms = new MemoryStream())
        {
            // Convert Image to byte[]
            image.Save(ms, format);
            byte[] imageBytes = ms.ToArray();

            // Convert byte[] to Base64 String
            string base64String = Convert.ToBase64String(imageBytes);
            return base64String;
        }
    }