Mit der fftw ein Bild erzeugen

[nork]

Moin,

ich schreibe gerade ein kleines Programm um ein Bild vom Ortsbereich in den Frequenzbereich.
Was bisher funktioniert ist das Einlesen des Bildes, schreiben in ein ByteArray(ImgToByteArray()) und dann übergebe ich das an ein IntPtr (pic_in). Anschließend führe ich eine die Fft durch. Das scheint auch zu klappen und ich bekomme ein IntPtr (pic_out) zurück. Das schreibe ich wieder in ein ByteArray (ByteArrayToImg()) und bekomme ein Stream zurück.

Leider kann ich diesen Stream nicht in ein Bild umwandeln mit "fftBox.Image = Bitmap.FromStream(MS)" mit der Begründung "Ivalid Parameter".
Deshalb habe ich den Stream in eine Txt geschrieben und gesehen das keine Bildinformationen in der Txt sind aber zumindest etwas.

Die Frage ist nun wie kann ich ein Bild erstellen? In einer vorherigen Version hatte ich auch noch den zwischen Schritt gemacht das ByteArray in ein FloatArray zu überschreiben und dann in IntPtr und zurück.

private void fft()
        {

            //Bildinformationen auslesen
            itkImageInformation info = itkImageBase.ReadInformation(outputBox.ImageLocation);
            //Höhe und Breite des Bildes in intArray speichern
            int[] size;
            size = info.Size.Data;
            //Das Bild der outputBox (PictureBox) in ein ByteArray speichern
            byte[] arraybild = ImgToByteArray(outputBox.Image);

            int n = arraybild.Length;
            pic_in = fftw.malloc(n * 32);
            pic_out = fftwf.malloc(n * 32);

            //Mein Versuch mit FloatArrays
            /*
            fin = new float[n * 2];
            fout = new float[n * 2];
            StreamWriter floatarray = new StreamWriter(@"C:\Users\nork\stream_float.txt");
            for (int nhv = 0; nhv < arraybild.Length - size[1]; nhv++)
            {
                fin[nhv] = BitConverter.ToSingle(arraybild, nhv);

            }
            for (int nhv = 0; nhv < arraybild.Length - size[1]; nhv++)
            {
                fout[nhv] = BitConverter.ToSingle(arraybild, nhv);
            }
            */
            //Kopiere managed Array zu unmanaged Array
            Marshal.Copy(arraybild, 0, pic_in, arraybild.Length);

            //erstellen des FFT Plans
            fplan1 = fftw.dft_2d(size[0], size[1], pic_in, pic_out, fftw_direction.Forward, fftw_flags.Estimate);

            //FFT ausführen
            fftw.execute(fplan1);

            int len = arraybild.Length;
            int pos = 0;
            byte[] arraybild_out = new byte[len];
            //Kopiere unmanaged Array zu managed Array
            Marshal.Copy(pic_outin, arraybild_out, 0, arraybild_out.Length);
            /*
            foreach (float f in fout)
            {
                byte[] t = BitConverter.GetBytes(f);
                Array.Copy(t, 0, arraybild_out, pos, 4);
                pos += 4;
            }
          */

            //Stream speichern und in Datei speichern
            System.IO.MemoryStream MS = ArrayToImg(arraybild_out);
            FileStream fs = File.OpenWrite(@"C:\Users\nork\stream.txt");
            fs.Write(MS.ToArray(), 0, MS.ToArray().Length);
            fs.Close();
            //fftBox.Image = Bitmap.FromStream(MS);
            //fftBox.Image = Image.FromHbitmap(pic_in);
            //Image img = Image.FromStream(ArrayToImg(fout));
            //img.Save(ArrayToImg(fout), ImageFormat.Png);

            //Alles wieder freigeben
            FreeFFTW();
        }

Wäre froh wenn mir jemand dabei helfen könnte!

Gruß Norm

[Dravere]

nork schrieb:

Wäre froh wenn mir jemand dabei helfen könnte!

Mit den gegebenen Informationen ziemlich sicher nicht.

Wir wissen gar nicht, was du für eine Fast Fourier Transformation Bibliothek verwendest. Woher sollen wir dann wissen, was diese als Ergebnis zurückgibt?
Du sagst selbst, dass die zurückgegebenen Daten keine Bilddaten sind. Woher sollen wir dann wissen, was es für Daten sind, wenn du sie nicht einmal zeigst?

Wie stellst du dir vor, dass wir dir helfen sollen?

Wenn du auf unsere Kristallkugeln hoffst, die mussten wir leider am Eingang abgeben.

Grüssli

[nork]

Okay, dann werde ich mal versuchen die fehlenden Informationen nach zu liefern und dabei meine Kristallkugel auch an der Tür abzugeben.

Ich verwende die FFTW Wrapper Lib von http://www.sdss.jhu.edu/~tamas/bytes/fftwcsharp.html diese greift zurück auf http://www.fftw.org/

Als Ausgabe vom ByteArray bekomme ich folgenden Stream http://bioinet.org/stream.txt

Als Ausgabe vom FloatArray bekomme ich folgendes http://bioinet.org/stream_float.txt

Ich habe mich zwischenzeitlich gefragt ob ich mit den Float-Werten evtl. ein Bild zeichnen kann?

Bei weiteren Rückfragen stehe ich immer gerne zur Verfügung!