Programmgesteuertes Hinzufügen von Bildern zum RTF-Dokument

Ich versuche ein Bild hinzufügen, um ein RTF-Dokument, das ich erschaffe. Ich würde es lieber nicht verwenden "copy/paste" - Methoden (das einbeziehen einfügen das Bild in einem RichTextBox-Steuerelement, und dann Zugriff auf die .RTF-Eigenschaft), die purge-die Zwischenablage (und damit Störung und Verwirrung für meine Endbenutzer).

Den code habe ich bislang gibt den string zurück, muss eingefügt werden in das RTF-Dokument, das Bild zu drucken. Das Bild eingegeben werden ($Pfad) ist in der Regel im bmp-oder jpeg-format, aber in diesem Stadium bin ich nicht betroffen mit, wie das Bild gespeichert ist innerhalb der RTF nur, dass ich es bekommen kann, zu arbeiten.

public string GetImage(string path, int width, int height)
{
    MemoryStream stream = new MemoryStream();
    string newPath = Path.Combine(Environment.CurrentDirectory, path);
    Image img = Image.FromFile(newPath);
    img.Save(stream, System.Drawing.Imaging.ImageFormat.Png);

    byte [] bytes = stream.ToArray();

    string str = BitConverter.ToString(bytes, 0).Replace("-", string.Empty);
    //string str = System.Text.Encoding.UTF8.GetString(bytes);

    string mpic = @"{\pict\pngblip\picw" + 
        img.Width.ToString() + @"\pich" + img.Height.ToString() +
        @"\picwgoa" + width.ToString() + @"\pichgoa" + height.ToString() + 
        @"\hex " + str + "}";
    return mpic
}

Aber das problem ist, dass dieser code funktioniert nicht, weil so weit wie ich sagen kann, das string str, nicht die richtigen string-Konvertierung in das RTF.

Edit: Mein problem war, fehlt ein Leerzeichen nach dem \hex in @"\hex "und auch nicht entfernen der" - " - Zeichen aus den zurückgegebenen Wert der BitConverter

InformationsquelleAutor der Frage | 2009-09-29

c#image image-formats rtf

versuchen Sie diese links

müssen Sie ändern "picwgoa" zu "picwgoal" und "pichgoa" zu "pichgoal"

string mpic = @"{\pict\pngblip\picw" + 
    img.Width.ToString() + @"\pich" + img.Height.ToString() +
    @"\picwgoal" + width.ToString() + @"\pichgoal" + height.ToString() + 
    @"\bin " + str + "}";

Hier haben Sie eine Liste der unterstützten Bildformate

\emfblip Quelle des Bildes ist ein EMF (enhanced metafile). 
\pngblip Quelle für das Bild ist ein PNG. 
\jpegblip Quelle für das Bild ist ein JPEG. 
\shppict Gibt ein Wort 97-2000 Bild. Dies ist eine destination control word". 
\nonshppict Gibt an, dass Word 97-2000 geschrieben hat, ein {\pict-destination, die Sie nicht Lesen Sie auf Eingabe. Dieses Schlüsselwort ist für die Kompatibilität mit anderen Lesern. 
\macpict Quelle des Bildes ist die QuickDraw. 
\pmmetafileN Quelle des Bildes ist ein OS/2 metafile. Das N argument identifiziert die Metadatei geben. Die N-Werte sind beschrieben in den \pmmetafile Tabelle unten. 
\wmetafileN Quelle des Bildes ist eine Windows metafile. Das N argument identifiziert die metafile-Typ (Standard ist 1). 
\dibitmapN Quelle des Bildes ist ein Windows-device-independent bitmap. Das N argument identifiziert den bitmap-Typ (muss gleich 0).Die Informationen, die im RTF von einem Windows-device-independent bitmap ist die Verkettung der BITMAPINFO-Struktur, gefolgt von den eigentlichen pixel-Daten. 
\wbitmapN Quelle des Bildes ist ein Windows-device-dependent bitmap. Das N argument identifiziert den bitmap-Typ (muss gleich 0).Die Informationen, die im RTF von einem Windows-device-dependent bitmap ist das Ergebnis der GetBitmapBits Funktion.

InformationsquelleAutor der Antwort RRUZ

Verbrachte einen Tag oder so googeln Antworten. Zusammengebastelt Leckerbissen aus der ganzen stackoverflow und anderen Quellen. Feed dieses eine Bild, werde es zurück die Zeichenfolge, die Sie brauchen, um hinzuzufügen, um Ihre richtextbox-Steuerelement.rtf-Erweiterung. Die Breite des Bildes ändert sich und muss berechnet werden, die Formel ist gegeben.

    //RTF Image Format
    //{\pict\wmetafile8\picw[A]\pich[B]\picwgoal[C]\pichgoal[D]
    // 
    //A    = (Image Width in Pixels /Graphics.DpiX) * 2540 
    // 
    //B    = (Image Height in Pixels /Graphics.DpiX) * 2540 
    // 
    //C    = (Image Width in Pixels /Graphics.DpiX) * 1440 
    // 
    //D    = (Image Height in Pixels /Graphics.DpiX) * 1440 

    [Flags]
    enum EmfToWmfBitsFlags
    {
        EmfToWmfBitsFlagsDefault = 0x00000000,
        EmfToWmfBitsFlagsEmbedEmf = 0x00000001,
        EmfToWmfBitsFlagsIncludePlaceable = 0x00000002,
        EmfToWmfBitsFlagsNoXORClip = 0x00000004
    }

    const int MM_ISOTROPIC = 7;
    const int MM_ANISOTROPIC = 8;

    [DllImport("gdiplus.dll")]
    private static extern uint GdipEmfToWmfBits(IntPtr _hEmf, uint _bufferSize,
        byte[] _buffer, int _mappingMode, EmfToWmfBitsFlags _flags);
    [DllImport("gdi32.dll")]
    private static extern IntPtr SetMetaFileBitsEx(uint _bufferSize,
        byte[] _buffer);
    [DllImport("gdi32.dll")]
    private static extern IntPtr CopyMetaFile(IntPtr hWmf,
        string filename);
    [DllImport("gdi32.dll")]
    private static extern bool DeleteMetaFile(IntPtr hWmf);
    [DllImport("gdi32.dll")]
    private static extern bool DeleteEnhMetaFile(IntPtr hEmf);

        public static string GetEmbedImageString(Bitmap image)
        {
                Metafile metafile = null;
                float dpiX; float dpiY;

                using (Graphics g = Graphics.FromImage (image)) 
                {
                    IntPtr hDC = g.GetHdc ();
                    metafile = new Metafile (hDC, EmfType.EmfOnly);
                    g.ReleaseHdc (hDC);
                }

                using (Graphics g = Graphics.FromImage (metafile)) 
                {
                    g.DrawImage (image, 0, 0);
            dpiX = g.DpiX;
            dpiY = g.DpiY;
                }

                IntPtr _hEmf = metafile.GetHenhmetafile ();
                uint _bufferSize = GdipEmfToWmfBits (_hEmf, 0, null, MM_ANISOTROPIC,
                EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);
                byte[] _buffer = new byte[_bufferSize];
                GdipEmfToWmfBits (_hEmf, _bufferSize, _buffer, MM_ANISOTROPIC,
                                            EmfToWmfBitsFlags.EmfToWmfBitsFlagsDefault);
                IntPtr hmf = SetMetaFileBitsEx (_bufferSize, _buffer);
                string tempfile = Path.GetTempFileName ();
                CopyMetaFile (hmf, tempfile);
                DeleteMetaFile (hmf);
                DeleteEnhMetaFile (_hEmf);

                var stream = new MemoryStream ();
                byte[] data = File.ReadAllBytes (tempfile);
                //File.Delete (tempfile);
                int count = data.Length;
                stream.Write (data, 0, count);

                string proto = @"{\rtf1{\pict\wmetafile8\picw" + (int)( ( (float)image.Width / dpiX ) * 2540 )
                                  + @"\pich" + (int)( ( (float)image.Height / dpiY ) * 2540 )
                                  + @"\picwgoal" + (int)( ( (float)image.Width / dpiX ) * 1440 )
                                  + @"\pichgoal" + (int)( ( (float)image.Height / dpiY ) * 1440 )
                                  + " " 
                      + BitConverter.ToString(stream.ToArray()).Replace("-", "")
                                  + "}}";                   
                return proto;
        }

InformationsquelleAutor der Antwort JiffyWhip

Später Besucher dieser Seite (wie war ich vor ein paar Tagen) ist, könnte der folgende link hilfreich: Konvertieren Sie ein Bild in WMF mit .NET

Wird man feststellen, dass WordPad ignoriert Bild nicht gespeichert in der richtigen Windows-MetaFile-format. Also, im vorherigen Beispiel auf dieser Seite nicht zeigen, bis überhaupt nicht (obwohl es funktioniert gut in OpenOffice und Word selbst). Das format, das WordPad unterstützt:

{/pict/wmetafile8/picw[Breite]/pich[Höhe]/picwgoal[scaledwidth]/pichgoal[scaledheight] [Bild-als-string-byte-hex-Werte]} (mit Bedingungen in eckigen Klammern ersetzt mit den entsprechenden Daten).

Immer die "geeignete Daten" getan werden kann durch die Verfahren in den obigen link. Für diejenigen, die mit python auf der Suche nach einer Lösung, hier ist der Anfang von einem (ich glaube einige dpi/Skalierung Probleme bleiben). Dies erfordert PIL(oder Kissen), ctypesund clr (Python .NET). Verwendung von PIL/Kissen und öffnen Sie zuerst das Bild. Hier habe ich es offen, wie "canv":

from ctypes import *
import clr
clr.AddReference("System.IO")
clr.AddReference("System.Drawing")
from System import IntPtr
from System.Drawing import SolidBrush
from System.Drawing import Color
from System.Drawing import Imaging
from System.Drawing import Graphics
from System.IO import FileStream
from System.IO import FileMode
from System.IO import MemoryStream
from System.IO import File

def byte_to_hex(bytefile):
  acc = ''
  b = bytefile.read(1)
  while b:
    acc+=("%02X" % ord(b))
    b = bytefile.read(1)
  return acc.strip()

#... in here is some code where 'canv' is created as the PIL image object, and
#...   'template' is defined as a string with placeholders for picw, pich, 
#...   picwgoal, pichgoal, and the image data


mfstream     = MemoryStream()
offscrDC     = Graphics.FromHwndInternal(IntPtr.Zero)
imgptr       = offscrDC.GetHdc()
mfile        = Imaging.Metafile(mfstream, imgptr, Imaging.EmfType.EmfOnly)
gfx          = Graphics.FromImage(mfile)
width,height = canv.size
pixels       = canv.load()
for x in range(width):
  for y in range(height):
    _r,_g,_b = pixels[x, y]
    c     = Color.FromArgb(_r, _g, _b)
    brush = SolidBrush(c)
    gfx.FillRectangle(brush, x, y, 1, 1)
gfx.Dispose()
offscrDC.ReleaseHdc()
_hEmf            = mfile.GetHenhmetafile()
GdipEmfToWmfBits = windll.gdiplus.GdipEmfToWmfBits
_bufferSize      = GdipEmfToWmfBits(
                      int(str(_hEmf)),
                      c_uint(0),
                      None,
                      c_int(8),           # MM_ANISOTROPIC
                      c_uint(0x00000000)) # Default flags
_buffer = c_int * _bufferSize
_buffer = _buffer(*[0 for x in range(_bufferSize)])
GdipEmfToWmfBits( int(str(_hEmf)),
                  c_uint(_bufferSize),
                  _buffer,
                  c_int(8),            # MM_ANISOTROPIC
                  c_uint(0x00000000) ) # Default flags
hmf = windll.gdi32.SetMetaFileBitsEx(c_uint(_bufferSize), _buffer)
windll.gdi32.CopyMetaFileA(int(str(hmf)), "temp.wmf")
windll.gdi32.DeleteMetaFile(int(str(hmf)))
windll.gdi32.DeleteEnhMetaFile(int(str(_hEmf)))
mfstream.Close()

imgstr = open("temp.wmf", 'rb')
imgstr = byte_to_hex(imgstr)
with open('script-out.rtf','wb') as outf:
  template = template % (str(_cx),str(_cy),str(15*_cx),str(15*_cy),imgstr)
  outf.write(template)

InformationsquelleAutor der Antwort Darren Ringer

0

Fand ich, dass die meisten RTF-Felder mit dem folgenden format:
```
{\object\objemb{\*\objclass Paint.Picture}\objw2699\objh4799{\*\objdata [hex/bin]}}
```
Wenn [hex/bin] ist die große Menge von hex-Zeichenfolgen, die das Bild-format. Auf diese Weise arbeiten beide für Word, rtf, und sowohl für die RTF-box - so ist es effizienter.

In meiner computer Bild in einer Größe von 180x320 Pixel umgewandelt worden, 2699x4799 twips, was bedeutet, dass 1pix=15 twips, soweit ich sehen kann, wie dies in 3 Rechnern, die ich habe testen, zwischen Ihnen WinXP prof, WinXP home und Win 7.

InformationsquelleAutor der Antwort Xerix

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.