WPF Image de byte[]

Je suis en train de convertir de System.Windows.Controls.Image à byte[] et je n'ai pas de savoir quelle méthode de classe Image pourrait aider dans cette scène, par la façon dont je ne sais pas vraiment ce que je dois faire, car dans mes modèle LINQ, le champ apparaît comme Binary type, je dois changer cela si je veux l'enregistrer comme un byte[] type?

J'ai trouvé le code posté ici, mais sans l'utilisation de WPF:

Bitmap newBMP = new Bitmap(originalBMP, newWidth, newHeight);
System.IO.MemoryStream stream = new System.IO.MemoryStream();
newBMP.Save(stream, System.Drawing.Imaging.ImageFormat.Bmp);
PHJProjectPhoto myPhoto = new PHJProjectPhoto {
    ProjectPhoto = stream.ToArray(), //<<--- This will convert your stream to a byte[] 
    OrderDate = DateTime.Now, 
    ProjectPhotoCaption = ProjectPhotoCaptionTextBox.Text,
    ProjectId = selectedProjectId
};

InformationsquelleAutor Jonathan Escobedo | 2009-02-16

bytearray c#image wpf

Vraie Solution... si vous voulez enregistrer les images jpg à partir d'un Système.De Windows.De contrôle.Image lorsque votre base de données mappé champ de l'ORM est le Byte[] /byte[] /Bynary

public byte[] getJPGFromImageControl(BitmapImage imageC)
{
       MemoryStream memStream = new MemoryStream();              
        JpegBitmapEncoder encoder = new JpegBitmapEncoder();
        encoder.Frames.Add(BitmapFrame.Create(imageC));
        encoder.Save(memStream);
        return memStream.ToArray();
}

appel :

getJPGFromImageControl(firmaUno.Source as BitmapImage)

Espoirs aide 🙂

ce sujet de windows 8 ???
Bon 1+ 🙂
ouais... mais plutôt lent, 470+ millisecondes...:(

InformationsquelleAutor Jonathan Escobedo

13

Je ne sais pas comment votre Image est déclaré, mais supposons que nous avons cette déclaration XAML:
```
<Image x:Name="img">
    <Image.Source>
        <BitmapImage UriSource="test.png" />
    </Image.Source>
</Image>
```
Ensuite, vous pouvez convertir le contenu de test.png à un tableau d'octets comme ceci:
```
var bmp = img.Source as BitmapImage;

int height = bmp.PixelHeight;
int width  = bmp.PixelWidth;
int stride = width * ((bmp.Format.BitsPerPixel + 7) / 8);

byte[] bits = new byte[height * stride];
bmp.CopyPixels(bits, stride, 0);
```
- mon xaml est : <Image de la Marge="6" Name="firmaUno" Stretch="Centrer"> </Image> Im réglage de la source dans le code-behind, donc ce qui est mieux?
- la surprise est de l'enregistrement : 0x000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000... :/
- c'est le travail. Merci gix
- Je préfère cette méthode car nous pouvez enregistrer n'importe quel type de fichier à byteArray 🙂
InformationsquelleAutor gix
2
```
public byte[] BufferFromImage(BitmapImage imageSource)
{        
    Stream stream = imageSource.StreamSource;
    byte[] buffer = null;

    if (stream != null && stream.Length > 0)
    {
        using (BinaryReader br = new BinaryReader(stream))
        {
            buffer = br.ReadBytes((Int32)stream.Length);
        }
    }

    return buffer;
}
```
serait une autre façon, mais la différence est-ce que avez moins de bytes[x] que la première solution
- Je pense que cela dépend de l'initialisation de l'image. Si vous définissez un BitmapImage StreamSource semble être null.
- Je suis en train de l'Image.Source BitmapImage et en obtenant un nul BitmapImage de retour, j'ai aussi essayé de le jeter à BitmapImage, quelle est la solution pour cela? Il semble comme une défaillance de fonte, pourtant je vois cette solution partout, y compris social.msdn.microsoft.com/Forums/en-US/wpf/thread/....
InformationsquelleAutor Jonathan Escobedo

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    private void btnBrowse_Click(object sender, RoutedEventArgs e)
    {
        var of = new OpenFileDialog();
        of.Filter = "Image files (*.png;*.jpeg)|*.png;*.jpeg|All files (*.*)|*.*";
        var res = of.ShowDialog();
        if (res.HasValue)
        {
            imgPreview.Source = new BitmapImage(new Uri(of.FileName));

            var t = Utils.ConvertBitmapSourceToByteArray(imgPreview.Source as BitmapSource);
            var d = Utils.ConvertBitmapSourceToByteArray(new BitmapImage(new Uri(of.FileName)));
            var s = Utils.ConvertBitmapSourceToByteArray(imgPreview.Source);
            var enc = Utils.ConvertBitmapSourceToByteArray(new PngBitmapEncoder(), imgPreview.Source);
            //imgPreview2.Source = Utils.ConvertByteArrayToBitmapImage(enc);
            imgPreview2.Source = Utils.ConvertByteArrayToBitmapImage2(enc);
            //var i = 0;


        }
        else
        {
            MessageBox.Show("Select a currect file...");

        }
    }

}

/util.cs/

public class Utils
{
public static byte[] ConvertBitmapSourceToByteArray(BitmapEncoder encoder, ImageSource imageSource)
{
byte[] bytes = null;
var bitmapSource = imageSource as BitmapSource;
if (bitmapSource != null)
{
encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
using (var stream = new MemoryStream())
{
encoder.Save(stream);
bytes = stream.ToArray();
}
}
return bytes;
}
public static byte[] ConvertBitmapSourceToByteArray(BitmapSource image)
{
byte[] data;
BitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image));
using (MemoryStream ms = new MemoryStream())
{
encoder.Save(ms);
data = ms.ToArray();
}
return data;
}
public static byte[] ConvertBitmapSourceToByteArray(ImageSource imageSource)
{
var image = imageSource as BitmapSource;
byte[] data;
BitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image));
using (MemoryStream ms = new MemoryStream())
{
encoder.Save(ms);
data = ms.ToArray();
}
return data;
}
public static byte[] ConvertBitmapSourceToByteArray(Uri uri)
{
var image = new BitmapImage(uri);
byte[] data;
BitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image));
using (MemoryStream ms = new MemoryStream())
{
encoder.Save(ms);
data = ms.ToArray();
}
return data;
}
public static byte[] ConvertBitmapSourceToByteArray(string filepath)
{
var image = new BitmapImage(new Uri(filepath));
byte[] data;
BitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image));
using (MemoryStream ms = new MemoryStream())
{
encoder.Save(ms);
data = ms.ToArray();
}
return data;
}
public static BitmapImage ConvertByteArrayToBitmapImage(Byte[] bytes)
{
var stream = new MemoryStream(bytes);
stream.Seek(0, SeekOrigin.Begin);
var image = new BitmapImage();
image.BeginInit();
image.StreamSource = stream;
image.EndInit();
return image;
}
}

InformationsquelleAutor Vahidshirzadi

Cela fonctionne pour moi:

MemoryStream stream = (MemoryStream)bitmapImage.StreamSource;
byte[] data = stream.ToArray();

InformationsquelleAutor Beny

Vous pouvez également utiliser BitmapSources de CopyPixels méthode

int stride = snapshot.PixelWidth * (snapshot.Format.BitsPerPixel / 8);
byte[] data = new byte[stride * snapshot.PixelHeight];
snapshot.CopyPixels(data, stride, 0);
var memoryStream = new MemoryStream(data);

InformationsquelleAutor Andreas

J'aime les encodeurs et les décodeurs de l'espace de noms: Système.De Windows.Médias.L'imagerie

public static class Extensions {        
public static byte[] ToByteArray(this BitmapSource bitmapSource) {
var encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(bitmapSource));
using (var stream = new MemoryStream()) {
encoder.Save(stream);
return stream.ToArray();
}
}
public static BitmapSource ToBitmapSource(this byte[] bytes) {
using (var stream = new MemoryStream(bytes)) {
var decoder = new JpegBitmapDecoder(stream, BitmapCreateOptions.None, BitmapCacheOption.Default);
return decoder.Frames.First();
}
}
}

Vous pouvez l'utiliser comme ceci:

var bytes = bitmapSource.ToByteArray();

Ou comme ceci:

var bitmapSource = bytes.ToBitmapSource();

InformationsquelleAutor Stanislav Kuzmich

Vous devez vous connecter pour publier un commentaire.