bitmap = null Buffer gesucht

[David (Gast)]

  private void TwoInOnePicture()
        {/*
            Bitmap bitmap = new Bitmap(image1.Width + image2.Width, Math.Max(image1.Height, image2.Height));
    using (Graphics g = Graphics.FromImage(bitmap))
    {
        g.DrawImage(image1, 0, 0);
        g.DrawImage(image2, image1.Width, 0);
            */

            Bitmap bitmap2_neu;
            Bitmap bitmap1_neu;
            bitmap1_neu = bitmap1;
            bitmap2_neu = bitmap2;
            if (bitmap1 != null || bitmap2 != null)
            {
                Int32 s32MemID1;
                Int32 s32MemID2;
                //System.Threading.Thread.Sleep(5000);
                Bitmap bitmap_gesamt = new Bitmap(bitmap1_neu.Width + bitmap2_neu.Width, bitmap1_neu.Height + bitmap2_neu.Height);
                Bitmap bitmap_gesamt_neu = bitmap_gesamt;
                Graphics g = Graphics.FromImage(bitmap_gesamt_neu);
                //System.Threading.Thread.Sleep(200);
                Camera1.Memory.GetActive(out s32MemID1);
                Camera2.Memory.GetActive(out s32MemID2);
                //DoDrawing(ref g, s32MemID);
                g.DrawImage(bitmap1_neu, new Rectangle(0, 0, bitmap1_neu.Width, bitmap1_neu.Height));

                g.DrawImage(bitmap2_neu, new Rectangle(bitmap1_neu.Width, 0, bitmap2_neu.Width, bitmap2_neu.Height));
                if (grafik == true)
                {
                    g.DrawEllipse(new Pen(System.Drawing.Color.Red, 5f), bitmap1_neu.Width + 3, 5, (bitmap2_neu.Width / 20), (bitmap2_neu.Height / 16));
                    g.DrawEllipse(new Pen(System.Drawing.Color.Red, 5f), 5, 5, (bitmap1_neu.Width / 20), (bitmap1_neu.Height / 16));
                }
                i++;

ich würde einen Buffer für Bitmaps benötigen, da ich manchmal ein NULL 
zurückbekomme als Bitmap1 oder Bitmap2

Danke Gruß

dave

[nicht"Gast" (Gast)]

Hm, mach doch deine zuweisung nach der abfrage und nicht davor

[David (Gast)]

Wie genau meinst du das?

[David (Gast)]

Die if Abfrage danach!

[bluppdidupp (Gast)]

Das || sollte doch bestimmt eher ein && sein?

Man sieht übrigens kein using() oder .Dispose() - Je nachdem wie oft 
deine TwoInOnePicture() aufgerufen wird könnte das problematisch 
werden...

[Manu (Gast)]

Wie wende ich denn das Using() in der Funktion genau an?

[Karl H. (kbuchegg)]

Ich versteh eigentlich die ganze Fragestellung nicht.

Was soll
> ich würde einen Buffer für Bitmaps benötigen, da ich manchmal
> ein NULL zurückbekomme als Bitmap1 oder Bitmap2
bedeuten.

bitmap1 bzw. bitmap2 sind doch offenbar irgendwelche globale Bitmaps, 
die zu einem kompletten Bild zusammengesetzt werden sollen. Zumindest 
versteh ich den Code beim schnellen Querlesen so.

Wenn also bitmap1 bzw. bitmap2 NULL sind, dann heißt das doch, das es 
genau diese Bitmaps eben nicht gibt. Wie soll man aber eine einzelne 
Bitmap mit einer anderen nicht existenten Bitmap zu einem 2-Bitmap Bild 
zusammensetzen? Das heißt für mich: was du brauchst ist nicht irgendein 
ominöser Buffer, sondern eine entsprechende Programmlogik, die mit 
diesem Fall klar kommt, das diese Funktion aufgerufen wird, obwohl es 
nur eine Ausgangsbitmap gibt.

[Karl H. (kbuchegg)]

Manu schrieb:
> Wie wende ich denn das Using() in der Funktion genau an?

Wenn du schon kein C#-Buch hast, dann leg dir wenigstens in deinem 
Browser einen Bookmark auf Google. Dort gibst du ins Suchfeld "C# using" 
ein und hantelst dich durch.
Sorry wenn das jetzt unfreundlich klingt. Aber Informationen suchen und 
finden gehört zum Handwerkszeug eines Programmieres mit dazu, wie in 
Bayern ein Bier zu einer Brotzeit dazu gehört.
Ohne wird das nichts und am Besten ein ausführliches Tutorial 
durcharbeiten, da ich aber keines kenne, bleibt als optimale Alternative 
nur noch ein C#-Buch.
Dieses Buch hat nicht umsonst ein paar hundert Seiten. Die hat es 
sicherlich nicht, weil man C# nach der Methode "Try&Error" auf eigene 
Faust in ein paar Nachmittagen lernen kann.

http://msdn.microsoft.com/de-de/library/yh598w02(v=vs.80).aspx

Microsoft hat die komplette C# Doku online. Du musst sie nur lesen - was 
allerdings nur insofern weiter hilft, wenn du weißt, was du eigentlich 
brauchst. Womit dann wieder die Literatur ins Spiel kommt.

[max (Gast)]

Mich würde auch mal interessieren, wo man hier using oder dispose 
benutzen sollte. Ich sehe da keine Notwendigkeit.

Gruß, Max

[Karl H. (kbuchegg)]

Ich schon.

Hier

            Bitmap bitmap_gesamt = new Bitmap(bitmap1_  .....

wird eine neue Bitmap angelegt, die kurze Zeit später keiner mehr 
braucht. Also wozu soll das Objekt im Speicher rumlungern, bis es vom 
Garbage Collector entsorgt wird, wenn man selbst sehr genau weißt, dass 
diese Bitmap nach ein paar Schritten weiter im Programm nicht mehr 
benötigt wird?

[max (Gast)]

Huch, ich hatte gedacht, dass die Objekte automatisch nach dem Ende der 
Funktion gelöscht werden. Wieder was gelernt...

[Karl H. (kbuchegg)]

max schrieb:
> Huch, ich hatte gedacht, dass die Objekte automatisch nach dem Ende der
> Funktion gelöscht werden. Wieder was gelernt...

C++ schon.
C# nicht. Da räumt der Garbage Collector irgendwann auf. Wann genau, das 
steht in den Sternen. Wann gerade Zeit ist, oder wenn der Speicher zur 
Neige geht, oder wenn Windows fad ist oder ....

Selbiges ja auch hier

              g.DrawImage(bitmap1_neu, new Rectangle(0, 0, bitmap1_neu.Width, bitmap1_neu.Height));

                g.DrawImage(bitmap2_neu, new Rectangle(bitmap1_neu.Width, 0, bitmap2_neu.Width, bitmap2_neu.Height));
                if (grafik == true)
                {
                    g.DrawEllipse(new Pen(System.Drawing.Color.Red, 5f), bitmap1_neu.Width + 3, 5, (bitmap2_neu.Width / 20), (bitmap2_neu.Height / 16));
                    g.DrawEllipse(new Pen(System.Drawing.Color.Red, 5f), 5, 5, (bitmap1_neu.Width / 20), (bitmap1_neu.Height / 16));

die ganzen Rectangles und Pens lungern im Speicher rum, bis jemand 
aufräumt.
Gut, das ist jetzt nicht DER Speicherverbrauch, aber ... es läppert 
sich, wenn die Funktion nur oft genug aufgerufen wird.

[__tom (Gast)]

Karl Heinz Buchegger schrieb:
> Gut, das ist jetzt nicht DER Speicherverbrauch, aber

Der Speicherverbrauch ist auch nicht der Grund warum Bitmap (und auch 
Pen) IDisposable implementieren.

Es gibt im System noch mehr Resourcen die Endlich sind, z.B. GDI 
Handles. Der GC räumt nur auf wenn er der Meinung ist er müsste das tun. 
Zu der Überzeugung kann er kommen wenn der Arbeitsspeicher sich füllt, 
"unmanaged resources" wie die GDI Handles (oder auch File Handles) hat 
er dagegen nicht im Blick.

Es kann also passieren dass noch massig Ram frei ist, der GC damit nicht 
aktiv wird, aber trotzdem keine freien GDI Handles mehr da sind - weil 
die eben erst freigegeben werden wenn der GC ein Dispose() erzwingt.