Graphics.DrawImage Methode

Referenz

Definition

Namespace:: System.Drawing

Assembly:: System.Drawing.Common.dll

Assembly:: System.Drawing.dll

Paket:: System.Drawing.Common v8.0.8

Paket:: System.Drawing.Common v9.0.0-preview.7.24405.4

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Zeichnet die angegebene Image an der angegebenen Position und mit der Originalgröße.

Überlädt

DrawImage(Image, Single, Single, RectangleF, GraphicsUnit)	Zeichnet einen Teil eines Bilds an einer angegebenen Position.
DrawImage(Image, Effect, RectangleF, Matrix, GraphicsUnit, ImageAttributes)
DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Int32, Int32, Int32, Int32)	Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Single, Single, Single, Single)	Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Effect)
DrawImage(Image, Point)	Zeichnet die angegebene Imageunter Verwendung der ursprünglichen physischen Größe an der angegebenen Position.
DrawImage(Image, Point[])	Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Form und Größe.
DrawImage(Image, PointF)	Zeichnet die angegebene Imageunter Verwendung der ursprünglichen physischen Größe an der angegebenen Position.
DrawImage(Image, PointF[])	Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Form und Größe.
DrawImage(Image, Rectangle)	Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, RectangleF)	Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Int32, Int32, Rectangle, GraphicsUnit)	Zeichnet einen Teil eines Bilds an einer angegebenen Position.
DrawImage(Image, Single, Single)	Zeichnet die angegebene Imageunter Verwendung der ursprünglichen physischen Größe an der angegebenen Position.
DrawImage(Image, Point[], Rectangle, GraphicsUnit)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Rectangle, Rectangle, GraphicsUnit)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, RectangleF, RectangleF, GraphicsUnit)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.
DrawImage(Image, Int32, Int32)	Zeichnet das angegebene Bild unter Verwendung seiner ursprünglichen physischen Größe an der durch ein Koordinatenpaar angegebenen Position.
DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position.

DrawImage(Image, Single, Single, RectangleF, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet einen Teil eines Bilds an einer angegebenen Position.

public:
 void DrawImage(System::Drawing::Image ^ image, float x, float y, System::Drawing::RectangleF srcRect, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, float x, float y, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * single * single * System.Drawing.RectangleF * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, x As Single, y As Single, srcRect As RectangleF, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

x: Single

Die x-Koordinate der oberen linken Ecke des gezeichneten Bilds.

y: Single

Die y-Koordinate der oberen linken Ecke des gezeichneten Bilds.

srcRect: RectangleF

RectangleF Struktur, die den teil des zu zeichnenden Image angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt die Koordinaten, an denen die obere linke Ecke des Bilds gezeichnet werden soll.
Erstellt ein Quellrechteck, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

Die Größe des Quellrechtecks bestimmt, welcher Teil des nicht skalierten Originalbilds auf den Bildschirm gezeichnet wird.

public:
   void DrawImage2FloatRectF( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create coordinates for upper-left corner of image.
      float x = 100.0F;
      float y = 100.0F;

      // Create rectangle for source image.
      RectangleF srcRect = RectangleF(50.0F,50.0F,150.0F,150.0F);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, x, y, srcRect, units );
   }

public void DrawImage2FloatRectF(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create coordinates for upper-left corner of image.
    float x = 100.0F;
    float y = 100.0F;
             
    // Create rectangle for source image.
    RectangleF srcRect = new RectangleF(50.0F, 50.0F, 150.0F, 150.0F);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, srcRect, units);
}

Public Sub DrawImage2FloatRectF(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create coordinates for upper-left corner of image.
    Dim x As Single = 100.0F
    Dim y As Single = 100.0F

    ' Create rectangle for source image.
    Dim srcRect As New RectangleF(50.0F, 50.0F, 150.0F, 150.0F)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, srcRect, units)
End Sub

Hinweise

Ein Image speichert einen Wert für die Pixelbreite und einen Wert für die horizontale Auflösung (Punkte pro Zoll). Die in Zoll gemessene physische Breite eines Bilds ist die Pixelbreite dividiert durch die horizontale Auflösung. Beispielsweise weist ein Bild mit einer Pixelbreite von 360 und einer horizontalen Auflösung von 72 Punkten pro Zoll eine physische Breite von 5 Zoll auf. Ähnliche Hinweise gelten für Pixelhöhe und physische Höhe.

Diese Methode zeichnet einen Teil eines Bilds mit seiner physischen Größe, sodass der Bildteil unabhängig von der Auflösung (Punkte pro Zoll) des Anzeigegeräts seine richtige Größe in Zoll hat. Angenommen, ein Bildteil hat eine Pixelbreite von 216 und eine horizontale Auflösung von 72 Punkten pro Zoll. Wenn Sie diese Methode aufrufen, um diesen Bildteil auf einem Gerät mit einer Auflösung von 96 Punkten pro Zoll zu zeichnen, lautet die Pixelbreite des gerenderten Bildteils (216/72)*96 = 288.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Effect, RectangleF, Matrix, GraphicsUnit, ImageAttributes)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

public void DrawImage (System.Drawing.Image image, System.Drawing.Imaging.Effects.Effect effect, System.Drawing.RectangleF srcRect = default, System.Drawing.Drawing2D.Matrix? transform = default, System.Drawing.GraphicsUnit srcUnit = System.Drawing.GraphicsUnit.Pixel, System.Drawing.Imaging.ImageAttributes? imageAttr = default);

member this.DrawImage : System.Drawing.Image * System.Drawing.Imaging.Effects.Effect * System.Drawing.RectangleF * System.Drawing.Drawing2D.Matrix * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes -> unit

Public Sub DrawImage (image As Image, effect As Effect, Optional srcRect As RectangleF = Nothing, Optional transform As Matrix = Nothing, Optional srcUnit As GraphicsUnit = System.Drawing.GraphicsUnit.Pixel, Optional imageAttr As ImageAttributes = Nothing)

Parameter

image: Image

effect: Effect

srcRect: RectangleF

transform: Matrix

srcUnit: GraphicsUnit

imageAttr: ImageAttributes

Gilt für:

DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::Point> ^ destPoints, System::Drawing::Rectangle srcRect, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr, System::Drawing::Graphics::DrawImageAbort ^ callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr, System.Drawing.Graphics.DrawImageAbort? callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr, System.Drawing.Graphics.DrawImageAbort callback);

member this.DrawImage : System.Drawing.Image * System.Drawing.Point[] * System.Drawing.Rectangle * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort -> unit

Public Sub DrawImage (image As Image, destPoints As Point(), srcRect As Rectangle, srcUnit As GraphicsUnit, imageAttr As ImageAttributes, callback As Graphics.DrawImageAbort)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: Point[]

Array von drei PointF Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

Rectangle Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Das folgende Codebeispiel wurde für die Verwendung mit Windows Forms entwickelt und erfordert PaintEventArgse, bei dem es sich um einen Parameter des Paint-Ereignishandlers handelt. Der Code definiert zuerst eine Rückrufmethode für den Graphics.DrawImageAbort Delegaten; die Definition ist vereinfacht und testet lediglich, ob die DrawImage-Methode sie mit einem Null-callBackData-Parameter aufruft. Der Haupttext des Beispiels führt die folgenden Aktionen aus:

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode:
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Rechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Parallelogramm, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

Für das ursprüngliche, nicht korrigierte Parallelogramm ermittelt die Position das Bild auf dem Bildschirm, und die Größe des Rechtecks und die Größe und Form des Parallelogramms bestimmt die Skalierung und Scherung des gezeichneten Bilds.

Da in diesem Beispiel eine Überladung verwendet wird, die keinen callBackData Parameter übergibt, gibt der Graphics.DrawImageAbort Rückruf truezurück, wodurch die DrawImage Methode beendet wird, und der im Beispiel enthaltene Ausnahmebehandlungscode druckt den Ausnahmetext aus, anstatt das Bild zu zeichnen.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback1( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

private:
   void DrawImageParaRectAttribAbort( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback1 );

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing original image.
      Point ulCorner = Point(100,100);
      Point urCorner = Point(550,100);
      Point llCorner = Point(150,250);
      array<Point>^ destPara1 = {ulCorner,urCorner,llCorner};

      // Create rectangle for source image.
      Rectangle srcRect = Rectangle(50,50,150,150);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destPara1, srcRect, units );

      // Create parallelogram for drawing adjusted image.
      Point ulCorner2 = Point(325,100);
      Point urCorner2 = Point(550,100);
      Point llCorner2 = Point(375,250);
      array<Point>^ destPara2 = {ulCorner2,urCorner2,llCorner2};

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );
      try
      {
         // Draw image to screen.
         e->Graphics->DrawImage( newImage, destPara2, srcRect, units, imageAttr, imageCallback );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback1(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
private void DrawImageParaRectAttribAbort(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback1);
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing original image.
    Point ulCorner = new Point(100, 100);
    Point urCorner = new Point(550, 100);
    Point llCorner = new Point(150, 250);
    Point[] destPara1 = {ulCorner, urCorner, llCorner};
             
    // Create rectangle for source image.
    Rectangle srcRect = new Rectangle(50, 50, 150, 150);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units);
             
    // Create parallelogram for drawing adjusted image.
    Point ulCorner2 = new Point(325, 100);
    Point urCorner2 = new Point(550, 100);
    Point llCorner2 = new Point(375, 250);
    Point[] destPara2 = {ulCorner2, urCorner2, llCorner2};
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
    try
    {
        checked
        {
             
            // Draw image to screen.
            e.Graphics.DrawImage(
                newImage,
                destPara2,
                srcRect,
                units,
                imageAttr,
                imageCallback);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback1(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Private Sub DrawImageParaRectAttribAbort(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback1)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing original image.
    Dim ulCorner As New Point(100, 100)
    Dim urCorner As New Point(550, 100)
    Dim llCorner As New Point(150, 250)
    Dim destPara1 As Point() = {ulCorner, urCorner, llCorner}

    ' Create rectangle for source image.
    Dim srcRect As New Rectangle(50, 50, 150, 150)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units)

    ' Create parallelogram for drawing adjusted image.
    Dim ulCorner2 As New Point(325, 100)
    Dim urCorner2 As New Point(550, 100)
    Dim llCorner2 As New Point(375, 250)
    Dim destPara2 As Point() = {ulCorner2, urCorner2, llCorner2}

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)
    Try

        ' Draw image to screen.
        e.Graphics.DrawImage(newImage, destPara2, srcRect, units, _
        imageAttr, imageCallback)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Der parameter destPoints gibt drei Punkte eines Parallelogramms an. Die drei PointF Strukturen stellen die oberen linken, oberen rechten und unteren linken Ecken des Parallelogramms dar. Der vierte Punkt wird von den ersten drei extrapoliert, um ein Parallelogramm zu bilden.

Der parameter srcRect gibt einen rechteckigen Teil des zu zeichnenden image Objekts an. Dieser Teil wird skaliert und schubiert, um in das durch den parameter destPoints angegebene Parallelogramm zu passen.

Diese Überladung mit dem parameter callback stellt die Möglichkeit bereit, die Zeichnung eines Bilds zu beenden, sobald es nach kriterien beginnt, die von der Anwendung bestimmt werden. Beispielsweise könnte eine Anwendung mit dem Zeichnen eines großen Bilds beginnen, und der Benutzer könnte das Bild auf dem Bildschirm scrollen, in diesem Fall könnte die Anwendung die Zeichnung beenden.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::PointF> ^ destPoints, System::Drawing::RectangleF srcRect, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr, System::Drawing::Graphics::DrawImageAbort ^ callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr, System.Drawing.Graphics.DrawImageAbort? callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr, System.Drawing.Graphics.DrawImageAbort callback);

member this.DrawImage : System.Drawing.Image * System.Drawing.PointF[] * System.Drawing.RectangleF * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort -> unit

Public Sub DrawImage (image As Image, destPoints As PointF(), srcRect As RectangleF, srcUnit As GraphicsUnit, imageAttr As ImageAttributes, callback As Graphics.DrawImageAbort)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: PointF[]

Array von drei PointF Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

RectangleF Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode.
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Rechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Parallelogramm, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback3( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

private:
   void DrawImageParaFRectAttribAbort( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback3 );

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing original image.
      PointF ulCorner1 = PointF(100.0F,100.0F);
      PointF urCorner1 = PointF(325.0F,100.0F);
      PointF llCorner1 = PointF(150.0F,250.0F);
      array<PointF>^ destPara1 = {ulCorner1,urCorner1,llCorner1};

      // Create rectangle for source image.
      RectangleF srcRect = RectangleF(50.0F,50.0F,150.0F,150.0F);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Create parallelogram for drawing adjusted image.
      PointF ulCorner2 = PointF(325.0F,100.0F);
      PointF urCorner2 = PointF(550.0F,100.0F);
      PointF llCorner2 = PointF(375.0F,250.0F);
      array<PointF>^ destPara2 = {ulCorner2,urCorner2,llCorner2};

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destPara1, srcRect, units );

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );
      try
      {
         // Draw adjusted image to screen.
         e->Graphics->DrawImage( newImage, destPara2, srcRect, units, imageAttr, imageCallback );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback3(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
private void DrawImageParaFRectAttribAbort(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback3);
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing original image.
    PointF ulCorner1 = new PointF(100.0F, 100.0F);
    PointF urCorner1 = new PointF(325.0F, 100.0F);
    PointF llCorner1 = new PointF(150.0F, 250.0F);
    PointF[] destPara1 = {ulCorner1, urCorner1, llCorner1};
             
    // Create rectangle for source image.
    RectangleF srcRect = new RectangleF(50.0F, 50.0F, 150.0F, 150.0F);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Create parallelogram for drawing adjusted image.
    PointF ulCorner2 = new PointF(325.0F, 100.0F);
    PointF urCorner2 = new PointF(550.0F, 100.0F);
    PointF llCorner2 = new PointF(375.0F, 250.0F);
    PointF[] destPara2 = {ulCorner2, urCorner2, llCorner2};
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
    try
    {
        checked
        {
             
            // Draw adjusted image to screen.
            e.Graphics.DrawImage(
                newImage,
                destPara2,
                srcRect,
                units,
                imageAttr,
                imageCallback);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback3(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Private Sub DrawImageParaFRectAttribAbort(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback3)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing original image.
    Dim ulCorner1 As New PointF(100.0F, 100.0F)
    Dim urCorner1 As New PointF(325.0F, 100.0F)
    Dim llCorner1 As New PointF(150.0F, 250.0F)
    Dim destPara1 As PointF() = {ulCorner1, urCorner1, llCorner1}

    ' Create rectangle for source image.
    Dim srcRect As New RectangleF(50.0F, 50.0F, 150.0F, 150.0F)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Create parallelogram for drawing adjusted image.
    Dim ulCorner2 As New PointF(325.0F, 100.0F)
    Dim urCorner2 As New PointF(550.0F, 100.0F)
    Dim llCorner2 As New PointF(375.0F, 250.0F)
    Dim destPara2 As PointF() = {ulCorner2, urCorner2, llCorner2}

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)
    Try

        ' Draw adjusted image to screen.
        e.Graphics.DrawImage(newImage, destPara2, srcRect, units, _
        imageAttr, imageCallback)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::Point> ^ destPoints, System::Drawing::Rectangle srcRect, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr, System::Drawing::Graphics::DrawImageAbort ^ callback, int callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr, System.Drawing.Graphics.DrawImageAbort? callback, int callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr, System.Drawing.Graphics.DrawImageAbort callback, int callbackData);

member this.DrawImage : System.Drawing.Image * System.Drawing.Point[] * System.Drawing.Rectangle * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort * int -> unit

Public Sub DrawImage (image As Image, destPoints As Point(), srcRect As Rectangle, srcUnit As GraphicsUnit, imageAttr As ImageAttributes, callback As Graphics.DrawImageAbort, callbackData As Integer)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: Point[]

Array von drei PointF Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

Rectangle Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

callbackData: Int32

Wert, der zusätzliche Daten für den Graphics.DrawImageAbort Delegaten angibt, der verwendet werden soll, wenn überprüft wird, ob die Ausführung der DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode beendet werden soll.

Beispiele

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode.
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Rechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Parallelogramm, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

Da in diesem Beispiel eine Überladung verwendet wird, die einen callBackData Parameter übergibt, gibt der Graphics.DrawImageAbort Rückruf falsezurück, wodurch die DrawImage-Methode fortgesetzt wird und das angepasste Bild auf den Bildschirm bezieht.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback2( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

private:
   void DrawImageParaRectAttribAbortData( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback2 );
      int imageCallbackData = 1;

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing original image.
      Point ulCorner = Point(100,100);
      Point urCorner = Point(550,100);
      Point llCorner = Point(150,250);
      array<Point>^ destPara1 = {ulCorner,urCorner,llCorner};

      // Create rectangle for source image.
      Rectangle srcRect = Rectangle(50,50,150,150);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destPara1, srcRect, units );

      // Create parallelogram for drawing adjusted image.
      Point ulCorner2 = Point(325,100);
      Point urCorner2 = Point(550,100);
      Point llCorner2 = Point(375,250);
      array<Point>^ destPara2 = {ulCorner2,urCorner2,llCorner2};

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );
      try
      {
         // Draw image to screen.
         e->Graphics->DrawImage( newImage, destPara2, srcRect, units, imageAttr, imageCallback, imageCallbackData );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback2(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
private void DrawImageParaRectAttribAbortData(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback2);
    int imageCallbackData = 1;
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing original image.
    Point ulCorner = new Point(100, 100);
    Point urCorner = new Point(550, 100);
    Point llCorner = new Point(150, 250);
    Point[] destPara1 = {ulCorner, urCorner, llCorner};
             
    // Create rectangle for source image.
    Rectangle srcRect = new Rectangle(50, 50, 150, 150);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units);
             
    // Create parallelogram for drawing adjusted image.
    Point ulCorner2 = new Point(325, 100);
    Point urCorner2 = new Point(550, 100);
    Point llCorner2 = new Point(375, 250);
    Point[] destPara2 = {ulCorner2, urCorner2, llCorner2};
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
    try
    {
        checked
        {
             
            // Draw image to screen.
            e.Graphics.DrawImage(
                newImage,
                destPara2,
                srcRect,
                units,
                imageAttr,
                imageCallback,
                imageCallbackData);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback2(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Private Sub DrawImageParaRectAttribAbortData(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback2)
    Dim imageCallbackData As Integer = 1

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing original image.
    Dim ulCorner As New Point(100, 100)
    Dim urCorner As New Point(550, 100)
    Dim llCorner As New Point(150, 250)
    Dim destPara1 As Point() = {ulCorner, urCorner, llCorner}

    ' Create rectangle for source image.
    Dim srcRect As New Rectangle(50, 50, 150, 150)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units)

    ' Create parallelogram for drawing adjusted image.
    Dim ulCorner2 As New Point(325, 100)
    Dim urCorner2 As New Point(550, 100)
    Dim llCorner2 As New Point(375, 250)
    Dim destPara2 As Point() = {ulCorner2, urCorner2, llCorner2}

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)
    Try

        ' Draw image to screen.
        e.Graphics.DrawImage(newImage, destPara2, srcRect, units, _
        imageAttr, imageCallback, imageCallbackData)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Diese Überladung mit den parametern callback und callbackData bietet die Möglichkeit, die Zeichnung eines Bilds zu beenden, sobald es nach Kriterien und Daten beginnt, die von der Anwendung bestimmt werden. Beispielsweise könnte eine Anwendung mit dem Zeichnen eines großen Bilds beginnen, und der Benutzer könnte das Bild auf dem Bildschirm scrollen, in diesem Fall könnte die Anwendung die Zeichnung beenden.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::PointF> ^ destPoints, System::Drawing::RectangleF srcRect, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr, System::Drawing::Graphics::DrawImageAbort ^ callback, int callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr, System.Drawing.Graphics.DrawImageAbort? callback, int callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr, System.Drawing.Graphics.DrawImageAbort callback, int callbackData);

member this.DrawImage : System.Drawing.Image * System.Drawing.PointF[] * System.Drawing.RectangleF * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort * int -> unit

Public Sub DrawImage (image As Image, destPoints As PointF(), srcRect As RectangleF, srcUnit As GraphicsUnit, imageAttr As ImageAttributes, callback As Graphics.DrawImageAbort, callbackData As Integer)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: PointF[]

Array von drei PointF Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

RectangleF Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

callbackData: Int32

Wert, der zusätzliche Daten für den Graphics.DrawImageAbort Delegaten angibt, der verwendet werden soll, wenn überprüft wird, ob die Ausführung der DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode beendet werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Das folgende Codebeispiel wurde für die Verwendung mit Windows Forms entwickelt und erfordert PaintEventArgse, bei dem es sich um einen Parameter des PaPaint-Ereignishandlers handelt. Der Code definiert zuerst eine Rückrufmethode für den Graphics.DrawImageAbort Delegaten; die Definition ist vereinfacht und testet lediglich, ob die DrawImage-Methode sie mit einem Null-callBackData-Parameter aufruft. Der Haupttext des Beispiels führt die folgenden Aktionen aus:

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode.
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Rechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Parallelogramm, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback4( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

private:
   void DrawImageParaFRectAttribAbortData( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback4 );
      int imageCallbackData = 1;

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing original image.
      PointF ulCorner1 = PointF(100.0F,100.0F);
      PointF urCorner1 = PointF(325.0F,100.0F);
      PointF llCorner1 = PointF(150.0F,250.0F);
      array<PointF>^ destPara1 = {ulCorner1,urCorner1,llCorner1};

      // Create rectangle for source image.
      RectangleF srcRect = RectangleF(50.0F,50.0F,150.0F,150.0F);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Create parallelogram for drawing adjusted image.
      PointF ulCorner2 = PointF(325.0F,100.0F);
      PointF urCorner2 = PointF(550.0F,100.0F);
      PointF llCorner2 = PointF(375.0F,250.0F);
      array<PointF>^ destPara2 = {ulCorner2,urCorner2,llCorner2};

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destPara1, srcRect, units );

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );
      try
      {
         // Draw adjusted image to screen.
         e->Graphics->DrawImage( newImage, destPara2, srcRect, units, imageAttr, imageCallback, imageCallbackData );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback4(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
private void DrawImageParaFRectAttribAbortData(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback4);
    int imageCallbackData = 1;
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing original image.
    PointF ulCorner1 = new PointF(100.0F, 100.0F);
    PointF urCorner1 = new PointF(325.0F, 100.0F);
    PointF llCorner1 = new PointF(150.0F, 250.0F);
    PointF[] destPara1 = {ulCorner1, urCorner1, llCorner1};
             
    // Create rectangle for source image.
    RectangleF srcRect = new RectangleF(50.0F, 50.0F, 150.0F, 150.0F);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Create parallelogram for drawing adjusted image.
    PointF ulCorner2 = new PointF(325.0F, 100.0F);
    PointF urCorner2 = new PointF(550.0F, 100.0F);
    PointF llCorner2 = new PointF(375.0F, 250.0F);
    PointF[] destPara2 = {ulCorner2, urCorner2, llCorner2};
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
    try
    {
        checked
        {
             
            // Draw adjusted image to screen.
            e.Graphics.DrawImage(
                newImage,
                destPara2,
                srcRect,
                units,
                imageAttr,
                imageCallback,
                imageCallbackData);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback4(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Private Sub DrawImageParaFRectAttribAbortData(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback4)
    Dim imageCallbackData As Integer = 1

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing original image.
    Dim ulCorner1 As New PointF(100.0F, 100.0F)
    Dim urCorner1 As New PointF(325.0F, 100.0F)
    Dim llCorner1 As New PointF(150.0F, 250.0F)
    Dim destPara1 As PointF() = {ulCorner1, urCorner1, llCorner1}

    ' Create rectangle for source image.
    Dim srcRect As New RectangleF(50.0F, 50.0F, 150.0F, 150.0F)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Create parallelogram for drawing adjusted image.
    Dim ulCorner2 As New PointF(325.0F, 100.0F)
    Dim urCorner2 As New PointF(550.0F, 100.0F)
    Dim llCorner2 As New PointF(375.0F, 250.0F)
    Dim destPara2 As PointF() = {ulCorner2, urCorner2, llCorner2}

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)
    Try

        ' Draw adjusted image to screen.
        e.Graphics.DrawImage(newImage, destPara2, srcRect, units, _
        imageAttr, imageCallback, imageCallbackData)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * int * int * int * int * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Integer, srcY As Integer, srcWidth As Integer, srcHeight As Integer, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Int32

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Int32

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Int32

Breite des zu zeichnenden Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt ein Zielrechteck, in dem das Bild gezeichnet werden soll.
Erstellt die Koordinaten eines Quellrechtecks, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

Die Position des Zielrechtecks sucht das Bild auf dem Bildschirm, und die Größen der Quell- und Zielrechtecke bestimmen die Skalierung des gezeichneten Bilds, und die Größe des Quellrechtecks bestimmt, welcher Teil des ursprünglichen Bilds auf den Bildschirm gezeichnet wird.

void DrawImageRect4Int( PaintEventArgs^ e )
{
   // Create image.
   Image^ newImage = Image::FromFile( "SampImag.jpg" );

   // Create rectangle for displaying image.
   Rectangle destRect = Rectangle(100,100,450,150);

   // Create coordinates of rectangle for source image.
   int x = 50;
   int y = 50;
   int width = 150;
   int height = 150;
   GraphicsUnit units = GraphicsUnit::Pixel;

   // Draw image to screen.
   e->Graphics->DrawImage( newImage, destRect, x, y, width, height, units );
}

private void DrawImageRect4Int(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying image.
    Rectangle destRect = new Rectangle(100, 100, 450, 150);
             
    // Create coordinates of rectangle for source image.
    int x = 50;
    int y = 50;
    int width = 150;
    int height = 150;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, x, y, width, height, units);
}

Private Sub DrawImageRect4Int(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying image.
    Dim destRect As New Rectangle(100, 100, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Integer = 50
    Dim y As Integer = 50
    Dim width As Integer = 150
    Dim height As Integer = 150
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, x, y, width, height, _
    units)
End Sub

Hinweise

Die Parameter srcX, srcY, srcWidthund srcHeight geben einen rechteckigen Teil des zu zeichnenden image Objekts an. Das Rechteck ist relativ zur oberen linken Ecke des Quellbilds. Dieser Teil wird so skaliert, dass er in das durch den parameter destRect angegebene Rechteck passt.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * int * int * int * int * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Integer, srcY As Integer, srcWidth As Integer, srcHeight As Integer, srcUnit As GraphicsUnit, imageAttr As ImageAttributes)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Int32

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Int32

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Int32

Breite des zu zeichnenden Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt ein Zielrechteck, in dem das Bild gezeichnet werden soll.
Erstellt die Koordinaten eines Quellrechtecks, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Rechteck, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

Für das ursprüngliche, nicht angepasste Zielrechteck ermittelt die Position das Bild auf dem Bildschirm, und die Größen der Quell- und Zielrechtecke bestimmen die Skalierung des gezeichneten Bilds, und die Größe des Quellrechtecks bestimmt, welcher Teil des ursprünglichen Bilds auf den Bildschirm gezeichnet wird.

void DrawImageRect4IntAtrrib( PaintEventArgs^ e )
{
   // Create image.
   Image^ newImage = Image::FromFile( "SampImag.jpg" );

   // Create rectangle for displaying original image.
   Rectangle destRect1 = Rectangle(100,25,450,150);

   // Create coordinates of rectangle for source image.
   int x = 50;
   int y = 50;
   int width = 150;
   int height = 150;
   GraphicsUnit units = GraphicsUnit::Pixel;

   // Draw original image to screen.
   e->Graphics->DrawImage( newImage, destRect1, x, y, width, height, units );

   // Create rectangle for adjusted image.
   Rectangle destRect2 = Rectangle(100,175,450,150);

   // Create image attributes and set large gamma.
   ImageAttributes^ imageAttr = gcnew ImageAttributes;
   imageAttr->SetGamma( 4.0F );

   // Draw adjusted image to screen.
   e->Graphics->DrawImage( newImage, destRect2, x, y, width, height, units, imageAttr );
}

private void DrawImageRect4IntAtrrib(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying original image.
    Rectangle destRect1 = new Rectangle(100, 25, 450, 150);
             
    // Create coordinates of rectangle for source image.
    int x = 50;
    int y = 50;
    int width = 150;
    int height = 150;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, units);
             
    // Create rectangle for adjusted image.
    Rectangle destRect2 = new Rectangle(100, 175, 450, 150);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
             
    // Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destRect2, x, y, width, height, units, imageAttr);
}

Private Sub DrawImageRect4IntAtrrib(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying original image.
    Dim destRect1 As New Rectangle(100, 25, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Integer = 50
    Dim y As Integer = 50
    Dim width As Integer = 150
    Dim height As Integer = 150
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, _
    units)

    ' Create rectangle for adjusted image.
    Dim destRect2 As New Rectangle(100, 175, 450, 150)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)

    ' Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destRect2, x, y, width, height, _
    units, imageAttr)
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttrs);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttrs);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttrs);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * single * single * single * single * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Single, srcY As Single, srcWidth As Single, srcHeight As Single, srcUnit As GraphicsUnit, imageAttrs As ImageAttributes)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Single

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Single

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Single

Breite des zu zeichnenden Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

imageAttrs: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt ein Zielrechteck, in dem das Bild gezeichnet werden soll.
Erstellt die Koordinaten eines Quellrechtecks, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Rechteck, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

private:
   void DrawImageRect4FloatAttrib( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying original image.
      Rectangle destRect1 = Rectangle(100,25,450,150);

      // Create coordinates of rectangle for source image.
      float x = 50.0F;
      float y = 50.0F;
      float width = 150.0F;
      float height = 150.0F;
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destRect1, x, y, width, height, units );

      // Create rectangle for adjusted image.
      Rectangle destRect2 = Rectangle(100,175,450,150);

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );

      // Draw adjusted image to screen.
      e->Graphics->DrawImage( newImage, destRect2, x, y, width, height, units, imageAttr );
   }

private void DrawImageRect4FloatAttrib(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying original image.
    Rectangle destRect1 = new Rectangle(100, 25, 450, 150);
             
    // Create coordinates of rectangle for source image.
    float x = 50.0F;
    float y = 50.0F;
    float width = 150.0F;
    float height = 150.0F;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, units);
             
    // Create rectangle for adjusted image.
    Rectangle destRect2 = new Rectangle(100, 175, 450, 150);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
             
    // Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destRect2, x, y, width, height, units, imageAttr);
}

Private Sub DrawImageRect4FloatAttrib(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying original image.
    Dim destRect1 As New Rectangle(100, 25, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Single = 50.0F
    Dim y As Single = 50.0F
    Dim width As Single = 150.0F
    Dim height As Single = 150.0F
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, _
    height, units)

    ' Create rectangle for adjusted image.
    Dim destRect2 As New Rectangle(100, 175, 450, 150)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)

    ' Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destRect2, x, y, width, height, _
    units, imageAttr)
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr, System::Drawing::Graphics::DrawImageAbort ^ callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr, System.Drawing.Graphics.DrawImageAbort? callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr, System.Drawing.Graphics.DrawImageAbort callback);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * int * int * int * int * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Integer, srcY As Integer, srcWidth As Integer, srcHeight As Integer, srcUnit As GraphicsUnit, imageAttr As ImageAttributes, callback As Graphics.DrawImageAbort)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Int32

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Int32

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Int32

Breite des zu zeichnenden Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die Neufärbungs- und Gammainformationen für imageangibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode.
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Zielrechteck definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Zielrechteck, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

Für das ursprüngliche, nicht angepasste Zielrechteck ermittelt die Position das Bild auf dem Bildschirm, und die Größe des Quellrechtecks sowie die Größe und Form des Zielrechtecks bestimmt die Skalierung des gezeichneten Bilds.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback5( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

private:
   void DrawImageRect4IntAtrribAbort( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback5 );

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying original image.
      Rectangle destRect1 = Rectangle(100,25,450,150);

      // Create coordinates of rectangle for source image.
      int x = 50;
      int y = 50;
      int width = 150;
      int height = 150;
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destRect1, x, y, width, height, units );

      // Create rectangle for adjusted image.
      Rectangle destRect2 = Rectangle(100,175,450,150);

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );
      try
      {
         // Draw adjusted image to screen.
         e->Graphics->DrawImage( newImage, destRect2, x, y, width, height, units, imageAttr, imageCallback );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback5(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
private void DrawImageRect4IntAtrribAbort(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback5);
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying original image.
    Rectangle destRect1 = new Rectangle(100, 25, 450, 150);
             
    // Create coordinates of rectangle for source image.
    int x = 50;
    int y = 50;
    int width = 150;
    int height = 150;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, units);
             
    // Create rectangle for adjusted image.
    Rectangle destRect2 = new Rectangle(100, 175, 450, 150);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
    try
    {
        checked
        {
             
            // Draw adjusted image to screen.
            e.Graphics.DrawImage(
                newImage,
                destRect2,
                x, y,
                width, height,
                units,
                imageAttr,
                imageCallback);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback5(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Private Sub DrawImageRect4IntAtrribAbort(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback5)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying original image.
    Dim destRect1 As New Rectangle(100, 25, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Integer = 50
    Dim y As Integer = 50
    Dim width As Integer = 150
    Dim height As Integer = 150
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, _
    units)

    ' Create rectangle for adjusted image.
    Dim destRect2 As New Rectangle(100, 175, 450, 150)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)
    Try

        ' Draw adjusted image to screen.
        e.Graphics.DrawImage(newImage, destRect2, x, y, width, _
        height, units, imageAttr, imageCallback)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttrs, System::Drawing::Graphics::DrawImageAbort ^ callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttrs, System.Drawing.Graphics.DrawImageAbort? callback);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttrs, System.Drawing.Graphics.DrawImageAbort callback);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * single * single * single * single * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Single, srcY As Single, srcWidth As Single, srcHeight As Single, srcUnit As GraphicsUnit, imageAttrs As ImageAttributes, callback As Graphics.DrawImageAbort)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Single

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Single

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Single

Breite des zu zeichnenden Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

imageAttrs: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode.
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Zielrechteck definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Zielrechteck, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback7( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

private:
   void DrawImageRect4FloatAttribAbort( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback7 );

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying original image.
      Rectangle destRect1 = Rectangle(100,25,450,150);

      // Create coordinates of rectangle for source image.
      float x = 50.0F;
      float y = 50.0F;
      float width = 150.0F;
      float height = 150.0F;
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destRect1, x, y, width, height, units );

      // Create rectangle for adjusted image.
      Rectangle destRect2 = Rectangle(100,175,450,150);

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );
      try
      {
         // Draw adjusted image to screen.
         e->Graphics->DrawImage( newImage, destRect2, x, y, width, height, units, imageAttr, imageCallback );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback7(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
private void DrawImageRect4FloatAttribAbort(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback7);
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying original image.
    Rectangle destRect1 = new Rectangle(100, 25, 450, 150);
             
    // Create coordinates of rectangle for source image.
    float x = 50.0F;
    float y = 50.0F;
    float width = 150.0F;
    float height = 150.0F;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, units);
             
    // Create rectangle for adjusted image.
    Rectangle destRect2 = new Rectangle(100, 175, 450, 150);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
    try
    {
        checked
        {
             
            // Draw adjusted image to screen.
            e.Graphics.DrawImage(
                newImage,
                destRect2,
                x, y,
                width, height,
                units,
                imageAttr,
                imageCallback);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback7(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Private Sub DrawImageRect4FloatAttribAbort(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback7)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying original image.
    Dim destRect1 As New Rectangle(100, 25, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Single = 50.0F
    Dim y As Single = 50.0F
    Dim width As Single = 150.0F
    Dim height As Single = 150.0F
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, _
    height, units)

    ' Create rectangle for adjusted image.
    Dim destRect2 As New Rectangle(100, 175, 450, 150)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)
    Try

        ' Draw adjusted image to screen.
        e.Graphics.DrawImage(newImage, destRect2, x, y, width, _
        height, units, imageAttr, imageCallback)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttrs, System::Drawing::Graphics::DrawImageAbort ^ callback, IntPtr callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttrs, System.Drawing.Graphics.DrawImageAbort? callback, IntPtr callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, int srcX, int srcY, int srcWidth, int srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttrs, System.Drawing.Graphics.DrawImageAbort callback, IntPtr callbackData);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * int * int * int * int * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort * nativeint -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Integer, srcY As Integer, srcWidth As Integer, srcHeight As Integer, srcUnit As GraphicsUnit, imageAttrs As ImageAttributes, callback As Graphics.DrawImageAbort, callbackData As IntPtr)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Int32

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Int32

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Int32

Breite des zu zeichnenden Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

imageAttrs: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

callbackData: IntPtr
nativeint

Wert, der zusätzliche Daten für den Graphics.DrawImageAbort Delegaten angibt, der verwendet werden soll, wenn überprüft wird, ob die Ausführung der DrawImage-Methode beendet werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode.
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Zielrechteck definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Zielrechteck, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback6( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

private:
   void DrawImageRect4IntAtrribAbortData( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback6 );
      IntPtr imageCallbackData = IntPtr(1);

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying original image.
      Rectangle destRect1 = Rectangle(100,25,450,150);

      // Create coordinates of rectangle for source image.
      int x = 50;
      int y = 50;
      int width = 150;
      int height = 150;
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destRect1, x, y, width, height, units );

      // Create rectangle for adjusted image.
      Rectangle destRect2 = Rectangle(100,175,450,150);

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );
      try
      {
         // Draw adjusted image to screen.
         e->Graphics->DrawImage( newImage, destRect2, x, y, width, height, units, imageAttr, imageCallback, imageCallbackData );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback6(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
private void DrawImageRect4IntAtrribAbortData(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback6);
    IntPtr imageCallbackData = new IntPtr(1);
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying original image.
    Rectangle destRect1 = new Rectangle(100, 25, 450, 150);
             
    // Create coordinates of rectangle for source image.
    int x = 50;
    int y = 50;
    int width = 150;
    int height = 150;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, units);
             
    // Create rectangle for adjusted image.
    Rectangle destRect2 = new Rectangle(100, 175, 450, 150);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
    try
    {
        checked
        {
             
            // Draw adjusted image to screen.
            e.Graphics.DrawImage(
                newImage,
                destRect2,
                x, y,
                width, height,
                units,
                imageAttr,
                imageCallback,
                imageCallbackData);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback6(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Private Sub DrawImageRect4IntAtrribAbortData(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback6)
    Dim imageCallbackData As New IntPtr(1)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying original image.
    Dim destRect1 As New Rectangle(100, 25, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Integer = 50
    Dim y As Integer = 50
    Dim width As Integer = 150
    Dim height As Integer = 150
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, _
    units)

    ' Create rectangle for adjusted image.
    Dim destRect2 As New Rectangle(100, 175, 450, 150)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)
    Try

        ' Draw adjusted image to screen.
        e.Graphics.DrawImage(newImage, destRect2, x, y, width, _
        height, units, imageAttr, imageCallback, imageCallbackData)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttrs, System::Drawing::Graphics::DrawImageAbort ^ callback, IntPtr callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttrs, System.Drawing.Graphics.DrawImageAbort? callback, IntPtr callbackData);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttrs, System.Drawing.Graphics.DrawImageAbort callback, IntPtr callbackData);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * single * single * single * single * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes * System.Drawing.Graphics.DrawImageAbort * nativeint -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Single, srcY As Single, srcWidth As Single, srcHeight As Single, srcUnit As GraphicsUnit, imageAttrs As ImageAttributes, callback As Graphics.DrawImageAbort, callbackData As IntPtr)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Single

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Single

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Single

Breite des zu zeichnenden Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

imageAttrs: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort Delegat, der eine Methode angibt, die während der Zeichnung des Bilds aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu überprüfen, ob die Ausführung der DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)-Methode gemäß anwendungsbestimmten Kriterien beendet werden soll.

callbackData: IntPtr
nativeint

Wert, der zusätzliche Daten für den Graphics.DrawImageAbort Delegaten angibt, der verwendet werden soll, wenn überprüft wird, ob die Ausführung der DrawImage-Methode beendet werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine Instanz der Graphics.DrawImageAbort Rückrufmethode.
Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Zielrechteck definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Zielrechteck, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

   // Define DrawImageAbort callback method.
private:
   bool DrawImageCallback8( IntPtr callBackData )
   {
      // Test for call that passes callBackData parameter.
      if ( callBackData == IntPtr::Zero )
      {
         
         // If no callBackData passed, abort DrawImage method.
         return true;
      }
      else
      {
         
         // If callBackData passed, continue DrawImage method.
         return false;
      }
   }

public:
   void DrawImageRect4FloatAttribAbortData( PaintEventArgs^ e )
   {
      // Create callback method.
      Graphics::DrawImageAbort^ imageCallback = gcnew Graphics::DrawImageAbort( this, &Form1::DrawImageCallback8 );
      IntPtr imageCallbackData = IntPtr(1);

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying original image.
      Rectangle destRect1 = Rectangle(100,25,450,150);

      // Create coordinates of rectangle for source image.
      float x = 50.0F;
      float y = 50.0F;
      float width = 150.0F;
      float height = 150.0F;
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destRect1, x, y, width, height, units );

      // Create rectangle for adjusted image.
      Rectangle destRect2 = Rectangle(100,175,450,150);

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );

      // Draw adjusted image to screen.
      try
      {
         // Draw adjusted image to screen.
         e->Graphics->DrawImage( newImage, destRect2, x, y, width, height, units, imageAttr, imageCallback, imageCallbackData );
      }
      catch ( Exception^ ex ) 
      {
         e->Graphics->DrawString( ex->ToString(), gcnew System::Drawing::Font( "Arial",8 ), Brushes::Black, PointF(0,0) );
      }
   }


// Define DrawImageAbort callback method.
private bool DrawImageCallback8(IntPtr callBackData)
{
             
    // Test for call that passes callBackData parameter.
    if(callBackData==IntPtr.Zero)
    {
             
        // If no callBackData passed, abort DrawImage method.
        return true;
    }
    else
    {
             
        // If callBackData passed, continue DrawImage method.
        return false;
    }
}
public void DrawImageRect4FloatAttribAbortData(PaintEventArgs e)
{
             
    // Create callback method.
    Graphics.DrawImageAbort imageCallback
        = new Graphics.DrawImageAbort(DrawImageCallback8);
    IntPtr imageCallbackData = new IntPtr(1);
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying original image.
    Rectangle destRect1 = new Rectangle(100, 25, 450, 150);
             
    // Create coordinates of rectangle for source image.
    float x = 50.0F;
    float y = 50.0F;
    float width = 150.0F;
    float height = 150.0F;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, height, units);
             
    // Create rectangle for adjusted image.
    Rectangle destRect2 = new Rectangle(100, 175, 450, 150);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
             
    // Draw adjusted image to screen.
    try
    {
        checked
        {
             
            // Draw adjusted image to screen.
            e.Graphics.DrawImage(
                newImage,
                destRect2,
                x, y,
                width, height,
                units,
                imageAttr,
                imageCallback,
                imageCallbackData);
        }
    }
    catch (Exception ex)
    {
        e.Graphics.DrawString(
            ex.ToString(),
            new Font("Arial", 8),
            Brushes.Black,
            new PointF(0, 0));
    }
}

Private Function DrawImageCallback8(ByVal callBackData As IntPtr) As Boolean

    ' Test for call that passes callBackData parameter.
    If callBackData.Equals(IntPtr.Zero) Then

        ' If no callBackData passed, abort DrawImage method.
        Return True
    Else

        ' If callBackData passed, continue DrawImage method.
        Return False
    End If
End Function
Public Sub DrawImageRect4FloatAttribAbortData(ByVal e As PaintEventArgs)

    ' Create callback method.
    Dim imageCallback As New _
    Graphics.DrawImageAbort(AddressOf DrawImageCallback8)
    Dim imageCallbackData As New IntPtr(1)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying original image.
    Dim destRect1 As New Rectangle(100, 25, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Single = 50.0F
    Dim y As Single = 50.0F
    Dim width As Single = 150.0F
    Dim height As Single = 150.0F
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destRect1, x, y, width, _
    height, units)

    ' Create rectangle for adjusted image.
    Dim destRect2 As New Rectangle(100, 175, 450, 150)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)

    ' Draw adjusted image to screen.
    Try

        ' Draw adjusted image to screen.
        e.Graphics.DrawImage(newImage, destRect2, x, y, width, _
        height, units, imageAttr, imageCallback, imageCallbackData)
    Catch ex As Exception
        e.Graphics.DrawString(ex.ToString(), New Font("Arial", 8), _
        Brushes.Black, New PointF(0, 0))
    End Try
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, float srcX, float srcY, float srcWidth, float srcHeight, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * single * single * single * single * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcX As Single, srcY As Single, srcWidth As Single, srcHeight As Single, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcX: Single

Die x-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcY: Single

Die y-Koordinate der oberen linken Ecke des zu zeichnenden Quellbilds.

srcWidth: Single

Breite des zu zeichnenden Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die zum Bestimmen des Quellrechtecks verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt die Koordinaten eines Zielrechtecks, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

Die Position des Zielrechtecks sucht das Bild auf dem Bildschirm, die Größen der Quell- und Zielrechtecke bestimmen die Skalierung des gezeichneten Bilds, und die Größe des Quellrechtecks bestimmt, welcher Teil des ursprünglichen Bilds auf den Bildschirm gezeichnet wird.

private:
   void DrawImageRect4Float( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying image.
      Rectangle destRect = Rectangle(100,100,450,150);

      // Create coordinates of rectangle for source image.
      float x = 50.0F;
      float y = 50.0F;
      float width = 150.0F;
      float height = 150.0F;
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destRect, x, y, width, height, units );
   }

private void DrawImageRect4Float(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying image.
    Rectangle destRect = new Rectangle(100, 100, 450, 150);
             
    // Create coordinates of rectangle for source image.
    float x = 50.0F;
    float y = 50.0F;
    float width = 150.0F;
    float height = 150.0F;
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, x, y, width, height, units);
}

Private Sub DrawImageRect4Float(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying image.
    Dim destRect As New Rectangle(100, 100, 450, 150)

    ' Create coordinates of rectangle for source image.
    Dim x As Single = 50.0F
    Dim y As Single = 50.0F
    Dim width As Single = 150.0F
    Dim height As Single = 150.0F
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, x, y, width, height, _
    units)
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Int32, Int32, Int32, Int32)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, int x, int y, int width, int height);

public void DrawImage (System.Drawing.Image image, int x, int y, int width, int height);

member this.DrawImage : System.Drawing.Image * int * int * int * int -> unit

Public Sub DrawImage (image As Image, x As Integer, y As Integer, width As Integer, height As Integer)

Parameter

image: Image

Image, um zu zeichnen.

x: Int32

Die x-Koordinate der oberen linken Ecke des gezeichneten Bilds.

y: Int32

Die y-Koordinate der oberen linken Ecke des gezeichneten Bilds.

width: Int32

Breite des gezeichneten Bilds.

height: Int32

Höhe des gezeichneten Bilds.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt die Position und Größe eines Rechtecks, in dem das Bild gezeichnet werden soll.
Zeichnet das Bild auf den Bildschirm.

Die Position des Rechtecks sucht das Bild auf dem Bildschirm, und die Größe des Originalbilds und die Größe des Rechtecks bestimmt die Skalierung des gezeichneten Bilds.

public:
   void DrawImage4Int( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create coordinates for upper-left corner.
      // of image and for size of image.
      int x = 100;
      int y = 100;
      int width = 450;
      int height = 150;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, x, y, width, height );
   }

public void DrawImage4Int(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create coordinates for upper-left corner.
             
    // of image and for size of image.
    int x = 100;
    int y = 100;
    int width = 450;
    int height = 150;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, width, height);
}

Public Sub DrawImage4Int(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create coordinates for upper-left corner

    ' of image and for size of image.
    Dim x As Integer = 100
    Dim y As Integer = 100
    Dim width As Integer = 450
    Dim height As Integer = 150

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, width, height)
End Sub

Hinweise

Das durch die x, y, widthund height Parameter definierte Rechteck bestimmt die Position und Größe des gezeichneten Bilds.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Single, Single, Single, Single)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, float x, float y, float width, float height);

public void DrawImage (System.Drawing.Image image, float x, float y, float width, float height);

member this.DrawImage : System.Drawing.Image * single * single * single * single -> unit

Public Sub DrawImage (image As Image, x As Single, y As Single, width As Single, height As Single)

Parameter

image: Image

Image, um zu zeichnen.

x: Single

Die x-Koordinate der oberen linken Ecke des gezeichneten Bilds.

y: Single

Die y-Koordinate der oberen linken Ecke des gezeichneten Bilds.

width: Single

Breite des gezeichneten Bilds.

height: Single

Höhe des gezeichneten Bilds.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt die Position und Größe eines Rechtecks, in dem das Bild gezeichnet werden soll.
Zeichnet das Bild auf den Bildschirm.

Die Position des Rechtecks sucht das Bild auf dem Bildschirm, und die Größe des Originalbilds und die Größe des Rechtecks bestimmt die Skalierung des gezeichneten Bilds.

public:
   void DrawImage4Float( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create coordinates for upper-left corner.
      // of image and for size of image.
      float x = 100.0F;
      float y = 100.0F;
      float width = 450.0F;
      float height = 150.0F;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, x, y, width, height );
   }

public void DrawImage4Float(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create coordinates for upper-left corner.
             
    // of image and for size of image.
    float x = 100.0F;
    float y = 100.0F;
    float width = 450.0F;
    float height = 150.0F;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, width, height);
}

Public Sub DrawImage4Float(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create coordinates for upper-left corner

    ' of image and for size of image.
    Dim x As Single = 100.0F
    Dim y As Single = 100.0F
    Dim width As Single = 450.0F
    Dim height As Single = 150.0F

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, width, height)
End Sub

Hinweise

Das durch die x, y, widthund height Parameter definierte Rechteck bestimmt die Position und Größe des gezeichneten Bilds.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::PointF> ^ destPoints, System::Drawing::RectangleF srcRect, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr);

member this.DrawImage : System.Drawing.Image * System.Drawing.PointF[] * System.Drawing.RectangleF * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes -> unit

Public Sub DrawImage (image As Image, destPoints As PointF(), srcRect As RectangleF, srcUnit As GraphicsUnit, imageAttr As ImageAttributes)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: PointF[]

Array von drei PointF Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

RectangleF Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Ziel-Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Parallelogramm, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

Für das ursprüngliche, nicht angepasste Ziel-Parallelogramm ermittelt die Position das Bild auf dem Bildschirm, die Größe des Quellrechtecks und die Größe und Form des Zielparallelogramms, bestimmt die Skalierung und Scherung des gezeichneten Bilds, und die Größe des Rechtecks bestimmt, welcher Teil des ursprünglichen Bilds auf den Bildschirm gezeichnet wird.

void DrawImageParaFRectFAttrib( PaintEventArgs^ e )
{
   // Create image.
   Image^ newImage = Image::FromFile( "SampImag.jpg" );

   // Create parallelogram for drawing original image.
   PointF ulCorner1 = PointF(100.0F,100.0F);
   PointF urCorner1 = PointF(325.0F,100.0F);
   PointF llCorner1 = PointF(150.0F,250.0F);
   array<PointF>^ destPara1 = {ulCorner1,urCorner1,llCorner1};

   // Create rectangle for source image.
   RectangleF srcRect = RectangleF(50.0F,50.0F,150.0F,150.0F);
   GraphicsUnit units = GraphicsUnit::Pixel;

   // Create parallelogram for drawing adjusted image.
   PointF ulCorner2 = PointF(325.0F,100.0F);
   PointF urCorner2 = PointF(550.0F,100.0F);
   PointF llCorner2 = PointF(375.0F,250.0F);
   array<PointF>^ destPara2 = {ulCorner2,urCorner2,llCorner2};

   // Draw original image to screen.
   e->Graphics->DrawImage( newImage, destPara1, srcRect, units );

   // Create image attributes and set large gamma.
   ImageAttributes^ imageAttr = gcnew ImageAttributes;
   imageAttr->SetGamma( 4.0F );

   // Draw adjusted image to screen.
   e->Graphics->DrawImage( newImage, destPara2, srcRect, units, imageAttr );
}

private void DrawImageParaFRectFAttrib(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing original image.
    PointF ulCorner1 = new PointF(100.0F, 100.0F);
    PointF urCorner1 = new PointF(325.0F, 100.0F);
    PointF llCorner1 = new PointF(150.0F, 250.0F);
    PointF[] destPara1 = {ulCorner1, urCorner1, llCorner1};
             
    // Create rectangle for source image.
    RectangleF srcRect = new RectangleF(50.0F, 50.0F, 150.0F, 150.0F);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Create parallelogram for drawing adjusted image.
    PointF ulCorner2 = new PointF(325.0F, 100.0F);
    PointF urCorner2 = new PointF(550.0F, 100.0F);
    PointF llCorner2 = new PointF(375.0F, 250.0F);
    PointF[] destPara2 = {ulCorner2, urCorner2, llCorner2};
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units);
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
             
    // Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destPara2, srcRect, units, imageAttr);
}

Private Sub DrawImageParaFRectFAttrib(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing original image.
    Dim ulCorner1 As New PointF(100.0F, 100.0F)
    Dim urCorner1 As New PointF(325.0F, 100.0F)
    Dim llCorner1 As New PointF(150.0F, 250.0F)
    Dim destPara1 As PointF() = {ulCorner1, urCorner1, llCorner1}

    ' Create rectangle for source image.
    Dim srcRect As New RectangleF(50.0F, 50.0F, 150.0F, 150.0F)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Create parallelogram for drawing adjusted image.
    Dim ulCorner2 As New PointF(325.0F, 100.0F)
    Dim urCorner2 As New PointF(550.0F, 100.0F)
    Dim llCorner2 As New PointF(375.0F, 250.0F)
    Dim destPara2 As PointF() = {ulCorner2, urCorner2, llCorner2}

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units)

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)

    ' Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destPara2, srcRect, units, _
    imageAttr)
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Effect)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Imaging::Effects::Effect ^ effect);

public void DrawImage (System.Drawing.Image image, System.Drawing.Imaging.Effects.Effect effect);

member this.DrawImage : System.Drawing.Image * System.Drawing.Imaging.Effects.Effect -> unit

Public Sub DrawImage (image As Image, effect As Effect)

Parameter

image: Image

effect: Effect

Gilt für:

DrawImage(Image, Point)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Imageunter Verwendung der ursprünglichen physischen Größe an der angegebenen Position.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Point point);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point point);

member this.DrawImage : System.Drawing.Image * System.Drawing.Point -> unit

Public Sub DrawImage (image As Image, point As Point)

Parameter

image: Image

Image, um zu zeichnen.

point: Point

Point Struktur, die die Position der oberen linken Ecke des gezeichneten Bilds darstellt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt einen Punkt, an dem die obere linke Ecke des Bilds gezeichnet werden soll.
Zeichnet das nicht skalierte Bild auf den Bildschirm.

private:
   void DrawImagePoint( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create Point for upper-left corner of image.
      Point ulCorner = Point(100,100);

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, ulCorner );
   }

private void DrawImagePoint(PaintEventArgs e)
{         
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create Point for upper-left corner of image.
    Point ulCorner = new Point(100, 100);
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, ulCorner);
}

Private Sub DrawImagePoint(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create Point for upper-left corner of image.
    Dim ulCorner As New Point(100, 100)

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, ulCorner)
End Sub

Hinweise

Ein Image speichert einen Wert für die Pixelbreite und einen Wert für die horizontale Auflösung (Punkte pro Zoll). Die in Zoll gemessene physische Breite eines Bilds ist die Pixelbreite dividiert durch die horizontale Auflösung. Beispielsweise weist ein Bild mit einer Pixelbreite von 216 und einer horizontalen Auflösung von 72 Punkten pro Zoll eine physische Breite von 3 Zoll auf. Ähnliche Hinweise gelten für Pixelhöhe und physische Höhe.

Diese Methode zeichnet ein Bild mit seiner physischen Größe, sodass das Bild unabhängig von der Auflösung (Punkte pro Zoll) des Anzeigegeräts seine richtige Größe in Zoll hat. Angenommen, ein Bild hat eine Pixelbreite von 216 und eine horizontale Auflösung von 72 Punkten pro Zoll. Wenn Sie diese Methode aufrufen, um dieses Bild auf einem Gerät mit einer Auflösung von 96 Punkten pro Zoll zu zeichnen, lautet die Pixelbreite des gerenderten Bilds (216/72)*96 = 288.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Point[])

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Form und Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::Point> ^ destPoints);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints);

member this.DrawImage : System.Drawing.Image * System.Drawing.Point[] -> unit

Public Sub DrawImage (image As Image, destPoints As Point())

Parameter

image: Image

Image, um zu zeichnen.

destPoints: Point[]

Array von drei Point Strukturen, die ein Parallelogramm definieren.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Zeichnet das Bild auf den Bildschirm.

Die Position des Parallelogramms sucht das Bild auf dem Bildschirm, und die Größe des Originalbilds sowie die Größe und Form des Parallelogramms bestimmt die Skalierung und Scherung des gezeichneten Bilds.

private:
   void DrawImagePara( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing image.
      Point ulCorner = Point(100,100);
      Point urCorner = Point(550,100);
      Point llCorner = Point(150,250);
      array<Point>^ destPara = {ulCorner,urCorner,llCorner};

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destPara );
   }

private void DrawImagePara(PaintEventArgs e)
{
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing image.
    Point ulCorner = new Point(100, 100);
    Point urCorner = new Point(550, 100);
    Point llCorner = new Point(150, 250);
    Point[] destPara = {ulCorner, urCorner, llCorner};
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara);
}

Private Sub DrawImagePara(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing image.
    Dim ulCorner As New Point(100, 100)
    Dim urCorner As New Point(550, 100)
    Dim llCorner As New Point(150, 250)
    Dim destPara As Point() = {ulCorner, urCorner, llCorner}

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara)
End Sub

Hinweise

Der parameter destPoints gibt drei Punkte eines Parallelogramms an. Die drei Point Strukturen stellen die oberen linken, oberen rechten und unteren linken Ecken des Parallelogramms dar. Der vierte Punkt wird von den ersten drei extrapoliert, um ein Parallelogramm zu bilden.

Das bild, das durch den parameter image dargestellt wird, wird skaliert und sheared, um die Form des durch die destPoints Parameter angegebenen Parallelogramms anzupassen.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, PointF)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Imageunter Verwendung der ursprünglichen physischen Größe an der angegebenen Position.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::PointF point);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF point);

member this.DrawImage : System.Drawing.Image * System.Drawing.PointF -> unit

Public Sub DrawImage (image As Image, point As PointF)

Parameter

image: Image

Image, um zu zeichnen.

point: PointF

PointF Struktur, die die obere linke Ecke des gezeichneten Bilds darstellt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt einen Punkt, an dem die obere linke Ecke des Bilds gezeichnet werden soll.
Zeichnet das nicht skalierte Bild auf den Bildschirm.

private:
   void DrawImagePointF( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create point for upper-left corner of image.
      PointF ulCorner = PointF(100.0F,100.0F);

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, ulCorner );
   }

private void DrawImagePointF(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create point for upper-left corner of image.
    PointF ulCorner = new PointF(100.0F, 100.0F);
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, ulCorner);
}

Private Sub DrawImagePointF(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create point for upper-left corner of image.
    Dim ulCorner As New PointF(100.0F, 100.0F)

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, ulCorner)
End Sub

Hinweise

Ein Image speichert einen Wert für die Pixelbreite und einen Wert für die horizontale Auflösung (Punkte pro Zoll). Die in Zoll gemessene physische Breite eines Bilds ist die Pixelbreite dividiert durch die horizontale Auflösung. Beispielsweise weist ein Bild mit einer Pixelbreite von 216 und einer horizontalen Auflösung von 72 Punkten pro Zoll eine physische Breite von 3 Zoll auf. Ähnliche Hinweise gelten für Pixelhöhe und physische Höhe.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, PointF[])

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Form und Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::PointF> ^ destPoints);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints);

member this.DrawImage : System.Drawing.Image * System.Drawing.PointF[] -> unit

Public Sub DrawImage (image As Image, destPoints As PointF())

Parameter

image: Image

Image, um zu zeichnen.

destPoints: PointF[]

Array von drei PointF Strukturen, die ein Parallelogramm definieren.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Zeichnet das Bild auf den Bildschirm.

private:
   void DrawImageParaF( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing image.
      PointF ulCorner = PointF(100.0F,100.0F);
      PointF urCorner = PointF(550.0F,100.0F);
      PointF llCorner = PointF(150.0F,250.0F);
      array<PointF>^ destPara = {ulCorner,urCorner,llCorner};

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destPara );
   }

private void DrawImageParaF(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing image.
    PointF ulCorner = new PointF(100.0F, 100.0F);
    PointF urCorner = new PointF(550.0F, 100.0F);
    PointF llCorner = new PointF(150.0F, 250.0F);
    PointF[] destPara = {ulCorner, urCorner, llCorner};
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara);
}

Private Sub DrawImageParaF(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing image.
    Dim ulCorner As New PointF(100.0F, 100.0F)
    Dim urCorner As New PointF(550.0F, 100.0F)
    Dim llCorner As New PointF(150.0F, 250.0F)
    Dim destPara As PointF() = {ulCorner, urCorner, llCorner}

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara)
End Sub

Hinweise

Das bild, das durch das image-Objekt dargestellt wird, wird skaliert und sheared, um die Form des durch den parameter destPoints angegebenen Parallelogramms anzupassen.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle rect);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle rect);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle -> unit

Public Sub DrawImage (image As Image, rect As Rectangle)

Parameter

image: Image

Image, um zu zeichnen.

rect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt ein Rechteck, in dem das Bild gezeichnet werden soll.
Zeichnet das Bild auf den Bildschirm.

Die Position des Rechtecks sucht das Bild auf dem Bildschirm, und die Größe des Originalbilds und die Größe des Rechtecks bestimmt die Skalierung des gezeichneten Bilds.

private:
   void DrawImageRect( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying image.
      Rectangle destRect = Rectangle(100,100,450,150);

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destRect );
   }

private void DrawImageRect(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying image.
    Rectangle destRect = new Rectangle(100, 100, 450, 150);
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect);
}

Private Sub DrawImageRect(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying image.
    Dim destRect As New Rectangle(100, 100, 450, 150)

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect)
End Sub

Hinweise

Das durch das image-Objekt dargestellte Bild wird auf die Abmessungen des rect Rechtecks skaliert.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, RectangleF)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::RectangleF rect);

public void DrawImage (System.Drawing.Image image, System.Drawing.RectangleF rect);

member this.DrawImage : System.Drawing.Image * System.Drawing.RectangleF -> unit

Public Sub DrawImage (image As Image, rect As RectangleF)

Parameter

image: Image

Image, um zu zeichnen.

rect: RectangleF

RectangleF Struktur, die die Position und Größe des gezeichneten Bilds angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt ein Rechteck, in dem das Bild gezeichnet werden soll.
Zeichnet das Bild auf den Bildschirm.

Die Position des Rechtecks sucht das Bild auf dem Bildschirm, und die Originalgröße des Bilds und die Größe des Rechtecks bestimmt die Skalierung des gezeichneten Bilds.

public:
   void DrawImageRectF( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying image.
      RectangleF rect = RectangleF(100.0F,100.0F,450.0F,150.0F);

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, rect );
   }

public void DrawImageRectF(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying image.
    RectangleF rect = new RectangleF(100.0F, 100.0F, 450.0F, 150.0F);
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, rect);
}

Public Sub DrawImageRectF(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying image.
    Dim rect As New RectangleF(100.0F, 100.0F, 450.0F, 150.0F)

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, rect)
End Sub

Hinweise

Das durch das image-Objekt dargestellte Bild wird auf die Abmessungen des rect Rechtecks skaliert.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Int32, Int32, Rectangle, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet einen Teil eines Bilds an einer angegebenen Position.

public:
 void DrawImage(System::Drawing::Image ^ image, int x, int y, System::Drawing::Rectangle srcRect, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, int x, int y, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * int * int * System.Drawing.Rectangle * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, x As Integer, y As Integer, srcRect As Rectangle, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

x: Int32

Die x-Koordinate der oberen linken Ecke des gezeichneten Bilds.

y: Int32

Die y-Koordinate der oberen linken Ecke des gezeichneten Bilds.

srcRect: Rectangle

Rectangle Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt die Koordinaten, an denen die obere linke Ecke des Bilds gezeichnet werden soll.
Erstellt ein Quellrechteck, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

Die Größe des Quellrechtecks bestimmt, welcher Teil des nicht skalierten Originalbilds auf den Bildschirm gezeichnet wird.

public:
   void DrawImage2IntRect( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create coordinates for upper-left corner of image.
      int x = 100;
      int y = 100;

      // Create rectangle for source image.
      Rectangle srcRect = Rectangle(50,50,150,150);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, x, y, srcRect, units );
   }

public void DrawImage2IntRect(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create coordinates for upper-left corner of image.
    int x = 100;
    int y = 100;
             
    // Create rectangle for source image.
    Rectangle srcRect = new Rectangle(50, 50, 150, 150);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, srcRect, units);
}

Public Sub DrawImage2IntRect(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create coordinates for upper-left corner of image.
    Dim x As Integer = 100
    Dim y As Integer = 100

    ' Create rectangle for source image.
    Dim srcRect As New Rectangle(50, 50, 150, 150)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y, srcRect, units)
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Single, Single)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet die angegebene Imageunter Verwendung der ursprünglichen physischen Größe an der angegebenen Position.

public:
 void DrawImage(System::Drawing::Image ^ image, float x, float y);

public void DrawImage (System.Drawing.Image image, float x, float y);

member this.DrawImage : System.Drawing.Image * single * single -> unit

Public Sub DrawImage (image As Image, x As Single, y As Single)

Parameter

image: Image

Image, um zu zeichnen.

x: Single

Die x-Koordinate der oberen linken Ecke des gezeichneten Bilds.

y: Single

Die y-Koordinate der oberen linken Ecke des gezeichneten Bilds.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt die Koordinaten eines Punkts, an dem die obere linke Ecke des Bilds gezeichnet werden soll.
Zeichnet das nicht skalierte Bild auf den Bildschirm.

public:
   void DrawImage2Float( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create coordinates for upper-left corner of image.
      float x = 100.0F;
      float y = 100.0F;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, x, y );
   }

public void DrawImage2Float(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create coordinates for upper-left corner of image.
    float x = 100.0F;
    float y = 100.0F;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y);
}

Public Sub DrawImage2Float(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create coordinates for upper-left corner of image.
    Dim x As Single = 100.0F
    Dim y As Single = 100.0F

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y)
End Sub

Hinweise

Ein Image speichert einen Wert für die Pixelbreite und einen Wert für die horizontale Auflösung (Punkte pro Zoll). Die in Zoll gemessene physische Breite eines Bilds ist die Pixelbreite dividiert durch die horizontale Auflösung. Beispielsweise weist ein Bild mit einer Pixelbreite von 216 und einer horizontalen Auflösung von 72 Punkten pro Zoll eine physische Breite von 3 Zoll auf. Ähnliche Hinweise gelten für Pixelhöhe und physische Höhe.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Point[], Rectangle, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::Point> ^ destPoints, System::Drawing::Rectangle srcRect, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * System.Drawing.Point[] * System.Drawing.Rectangle * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, destPoints As Point(), srcRect As Rectangle, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: Point[]

Array von drei Point Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

Rectangle Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Rechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

Die Position des Parallelogramms sucht das Bild auf dem Bildschirm, und die Größe des Rechtecks und die Größe und Form des Parallelogramms bestimmt die Skalierung und Scherung des gezeichneten Bilds.

private:
   void DrawImageParaRect( PaintEventArgs^ e )
   {

      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing image.
      Point ulCorner = Point(100,100);
      Point urCorner = Point(325,100);
      Point llCorner = Point(150,250);
      array<Point>^ destPara = {ulCorner,urCorner,llCorner};

      // Create rectangle for source image.
      Rectangle srcRect = Rectangle(50,50,150,150);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destPara, srcRect, units );
   }

private void DrawImageParaRect(PaintEventArgs e)
{
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing image.
    Point ulCorner = new Point(100, 100);
    Point urCorner = new Point(325, 100);
    Point llCorner = new Point(150, 250);
    Point[] destPara = {ulCorner, urCorner, llCorner};
             
    // Create rectangle for source image.
    Rectangle srcRect = new Rectangle(50, 50, 150, 150);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara, srcRect, units);
}

Private Sub DrawImageParaRect(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing image.
    Dim ulCorner As New Point(100, 100)
    Dim urCorner As New Point(325, 100)
    Dim llCorner As New Point(150, 250)
    Dim destPara As Point() = {ulCorner, urCorner, llCorner}

    ' Create rectangle for source image.
    Dim srcRect As New Rectangle(50, 50, 150, 150)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara, srcRect, units)
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, PointF[], RectangleF, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::PointF> ^ destPoints, System::Drawing::RectangleF srcRect, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, System.Drawing.PointF[] destPoints, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * System.Drawing.PointF[] * System.Drawing.RectangleF * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, destPoints As PointF(), srcRect As RectangleF, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: PointF[]

Array von drei PointF Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

RectangleF Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Ziel-Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

Die Position des Ziel-Parallelogramms sucht das Bild auf dem Bildschirm, die Größe des Quellrechtecks und die Größe und Form des Zielparallelogramms bestimmt die Skalierung und Scherung des gezeichneten Bilds, und die Größe des Rechtecks bestimmt, welcher Teil des ursprünglichen Bilds auf den Bildschirm gezeichnet wird.

private:
   void DrawImageParaFRectF( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing image.
      PointF ulCorner = PointF(100.0F,100.0F);
      PointF urCorner = PointF(550.0F,100.0F);
      PointF llCorner = PointF(150.0F,250.0F);
      array<PointF>^ destPara = {ulCorner,urCorner,llCorner};

      // Create rectangle for source image.
      RectangleF srcRect = RectangleF(50.0F,50.0F,150.0F,150.0F);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destPara, srcRect, units );
   }

private void DrawImageParaFRectF(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing image.
    PointF ulCorner = new PointF(100.0F, 100.0F);
    PointF urCorner = new PointF(550.0F, 100.0F);
    PointF llCorner = new PointF(150.0F, 250.0F);
    PointF[] destPara = {ulCorner, urCorner, llCorner};
             
    // Create rectangle for source image.
    RectangleF srcRect = new RectangleF(50.0F, 50.0F, 150.0F, 150.0F);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara, srcRect, units);
}

Private Sub DrawImageParaFRectF(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing image.
    Dim ulCorner As New PointF(100.0F, 100.0F)
    Dim urCorner As New PointF(550.0F, 100.0F)
    Dim llCorner As New PointF(150.0F, 250.0F)
    Dim destPara As PointF() = {ulCorner, urCorner, llCorner}

    ' Create rectangle for source image.
    Dim srcRect As New RectangleF(50.0F, 50.0F, 150.0F, 150.0F)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destPara, srcRect, units)
End Sub

Hinweise

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Rectangle, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::Rectangle destRect, System::Drawing::Rectangle srcRect, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, System.Drawing.Rectangle destRect, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * System.Drawing.Rectangle * System.Drawing.Rectangle * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, destRect As Rectangle, srcRect As Rectangle, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

destRect: Rectangle

Rectangle Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcRect: Rectangle

Rectangle Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt ein Zielrechteck, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

private:
   void DrawImageRectRect( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying image.
      Rectangle destRect = Rectangle(100,100,450,150);

      // Create rectangle for source image.
      Rectangle srcRect = Rectangle(50,50,150,150);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destRect, srcRect, units );
   }

private void DrawImageRectRect(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying image.
    Rectangle destRect = new Rectangle(100, 100, 450, 150);
             
    // Create rectangle for source image.
    Rectangle srcRect = new Rectangle(50, 50, 150, 150);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, srcRect, units);
}

Private Sub DrawImageRectRect(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying image.
    Dim destRect As New Rectangle(100, 100, 450, 150)

    ' Create rectangle for source image.
    Dim srcRect As New Rectangle(50, 50, 150, 150)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, srcRect, units)
End Sub

Hinweise

Der parameter srcRect gibt einen rechteckigen Teil des zu zeichnenden image Objekts an. Dieser Teil wird so skaliert, dass er in das durch den parameter destRect angegebene Rechteck passt.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, RectangleF, RectangleF, GraphicsUnit)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position und mit der angegebenen Größe.

public:
 void DrawImage(System::Drawing::Image ^ image, System::Drawing::RectangleF destRect, System::Drawing::RectangleF srcRect, System::Drawing::GraphicsUnit srcUnit);

public void DrawImage (System.Drawing.Image image, System.Drawing.RectangleF destRect, System.Drawing.RectangleF srcRect, System.Drawing.GraphicsUnit srcUnit);

member this.DrawImage : System.Drawing.Image * System.Drawing.RectangleF * System.Drawing.RectangleF * System.Drawing.GraphicsUnit -> unit

Public Sub DrawImage (image As Image, destRect As RectangleF, srcRect As RectangleF, srcUnit As GraphicsUnit)

Parameter

image: Image

Image, um zu zeichnen.

destRect: RectangleF

RectangleF Struktur, die die Position und Größe des gezeichneten Bilds angibt. Das Bild wird so skaliert, dass es an das Rechteck angepasst wird.

srcRect: RectangleF

RectangleF Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt ein Zielrechteck, in dem das Bild gezeichnet werden soll.
Erstellt ein Quellrechteck, aus dem ein Teil des Bilds extrahiert werden soll.
Legt die Maßeinheit des Quellrechtecks auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

public:
   void DrawImageRectFRectF( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create rectangle for displaying image.
      RectangleF destRect = RectangleF(100.0F,100.0F,450.0F,150.0F);

      // Create rectangle for source image.
      RectangleF srcRect = RectangleF(50.0F,50.0F,150.0F,150.0F);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, destRect, srcRect, units );
   }

public void DrawImageRectFRectF(PaintEventArgs e)
{
             
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create rectangle for displaying image.
    RectangleF destRect = new RectangleF(100.0F, 100.0F, 450.0F, 150.0F);
             
    // Create rectangle for source image.
    RectangleF srcRect = new RectangleF(50.0F, 50.0F, 150.0F, 150.0F);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, srcRect, units);
}

Public Sub DrawImageRectFRectF(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create rectangle for displaying image.
    Dim destRect As New RectangleF(100.0F, 100.0F, 450.0F, 150.0F)

    ' Create rectangle for source image.
    Dim srcRect As New RectangleF(50.0F, 50.0F, 150.0F, 150.0F)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, destRect, srcRect, units)
End Sub

Hinweise

Der parameter srcRect gibt einen rechteckigen Teil des zu zeichnenden image Objekts an. Dieser Teil wird so skaliert, dass er in das durch den parameter destRect angegebene Rechteck passt.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Int32, Int32)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet das angegebene Bild unter Verwendung seiner ursprünglichen physischen Größe an der durch ein Koordinatenpaar angegebenen Position.

public:
 void DrawImage(System::Drawing::Image ^ image, int x, int y);

public void DrawImage (System.Drawing.Image image, int x, int y);

member this.DrawImage : System.Drawing.Image * int * int -> unit

Public Sub DrawImage (image As Image, x As Integer, y As Integer)

Parameter

image: Image

Image, um zu zeichnen.

x: Int32

Die x-Koordinate der oberen linken Ecke des gezeichneten Bilds.

y: Int32

Die y-Koordinate der oberen linken Ecke des gezeichneten Bilds.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels SampImag.jpg im Ordner des Beispiels.
Erstellt die Koordinaten eines Punkts, an dem die obere linke Ecke des Bilds gezeichnet werden soll.
Zeichnet das nicht skalierte Bild.

public:
   void DrawImage2Int( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create coordinates for upper-left corner of image.
      int x = 100;
      int y = 100;

      // Draw image to screen.
      e->Graphics->DrawImage( newImage, x, y );
   }

public void DrawImage2Int(PaintEventArgs e)
{
                
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
                
    // Create coordinates for upper-left corner of image.
    int x = 100;
    int y = 100;
                
    // Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y);
}

Public Sub DrawImage2Int(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create coordinates for upper-left corner of image.
    Dim x As Integer = 100
    Dim y As Integer = 100

    ' Draw image to screen.
    e.Graphics.DrawImage(newImage, x, y)
End Sub

Hinweise

Ein Image speichert einen Wert für die Pixelbreite und einen Wert für die horizontale Auflösung (Punkte pro Zoll). Die in Zoll gemessene physische Breite eines Bilds ist die Pixelbreite dividiert durch die horizontale Auflösung. Beispielsweise weist ein Bild mit einer Pixelbreite von 216 und einer horizontalen Auflösung von 72 Punkten pro Zoll eine physische Breite von 3 Zoll auf. Ähnliche Hinweise gelten für Pixelhöhe und physische Höhe.

Die DrawImage-Methode zeichnet ein Bild mit seiner physischen Größe, sodass das Bild unabhängig von der Auflösung (Punkte pro Zoll) des Anzeigegeräts die richtige Größe in Zoll hat. Angenommen, ein Bild hat eine Pixelbreite von 216 und eine horizontale Auflösung von 72 Punkten pro Zoll. Wenn Sie DrawImage aufrufen, um dieses Bild auf einem Gerät mit einer Auflösung von 96 Punkten pro Zoll zu zeichnen, lautet die Pixelbreite des gerenderten Bilds (216/72)*96 = 288.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes)

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Quelle:: Graphics.cs

Zeichnet den angegebenen Teil der angegebenen Image an der angegebenen Position.

public:
 void DrawImage(System::Drawing::Image ^ image, cli::array <System::Drawing::Point> ^ destPoints, System::Drawing::Rectangle srcRect, System::Drawing::GraphicsUnit srcUnit, System::Drawing::Imaging::ImageAttributes ^ imageAttr);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes? imageAttr);

public void DrawImage (System.Drawing.Image image, System.Drawing.Point[] destPoints, System.Drawing.Rectangle srcRect, System.Drawing.GraphicsUnit srcUnit, System.Drawing.Imaging.ImageAttributes imageAttr);

member this.DrawImage : System.Drawing.Image * System.Drawing.Point[] * System.Drawing.Rectangle * System.Drawing.GraphicsUnit * System.Drawing.Imaging.ImageAttributes -> unit

Public Sub DrawImage (image As Image, destPoints As Point(), srcRect As Rectangle, srcUnit As GraphicsUnit, imageAttr As ImageAttributes)

Parameter

image: Image

Image, um zu zeichnen.

destPoints: Point[]

Array von drei Point Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

Rectangle Struktur, die den Teil des zu zeichnenden image Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Aufzählung, die die Maßeinheiten angibt, die vom srcRect-Parameter verwendet werden.

imageAttr: ImageAttributes

ImageAttributes, die neu einfärben und Gammainformationen für das image-Objekt angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Parallelogramm definieren, in dem das Bild gezeichnet werden soll.
Erstellt ein Rechteck, um den Teil des zu zeichnenden Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Originalbild auf den Bildschirm.
Erstellt ein zusätzliches Parallelogramm, in dem ein angepasstes Bild gezeichnet werden soll.
Erstellt und legt die Attribute des angepassten Bilds so fest, dass ein größer als üblicher Gammawert vorhanden ist.
Zeichnet das angepasste Bild auf den Bildschirm.

private:
   void DrawImageParaRectAttrib( PaintEventArgs^ e )
   {
      // Create image.
      Image^ newImage = Image::FromFile( "SampImag.jpg" );

      // Create parallelogram for drawing image.
      Point ulCorner1 = Point(100,100);
      Point urCorner1 = Point(325,100);
      Point llCorner1 = Point(150,250);
      array<Point>^ destPara1 = {ulCorner1,urCorner1,llCorner1};

      // Create rectangle for source image.
      Rectangle srcRect = Rectangle(50,50,150,150);
      GraphicsUnit units = GraphicsUnit::Pixel;

      // Draw original image to screen.
      e->Graphics->DrawImage( newImage, destPara1, srcRect, units );

      // Create parallelogram for drawing adjusted image.
      Point ulCorner2 = Point(325,100);
      Point urCorner2 = Point(550,100);
      Point llCorner2 = Point(375,250);
      array<Point>^ destPara2 = {ulCorner2,urCorner2,llCorner2};

      // Create image attributes and set large gamma.
      ImageAttributes^ imageAttr = gcnew ImageAttributes;
      imageAttr->SetGamma( 4.0F );

      // Draw adjusted image to screen.
      e->Graphics->DrawImage( newImage, destPara2, srcRect, units, imageAttr );
   }

private void DrawImageParaRectAttrib(PaintEventArgs e)
{
    // Create image.
    Image newImage = Image.FromFile("SampImag.jpg");
             
    // Create parallelogram for drawing image.
    Point ulCorner1 = new Point(100, 100);
    Point urCorner1 = new Point(325, 100);
    Point llCorner1 = new Point(150, 250);
    Point[] destPara1 = {ulCorner1, urCorner1, llCorner1};
             
    // Create rectangle for source image.
    Rectangle srcRect = new Rectangle(50, 50, 150, 150);
    GraphicsUnit units = GraphicsUnit.Pixel;
             
    // Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units);
             
    // Create parallelogram for drawing adjusted image.
    Point ulCorner2 = new Point(325, 100);
    Point urCorner2 = new Point(550, 100);
    Point llCorner2 = new Point(375, 250);
    Point[] destPara2 = {ulCorner2, urCorner2, llCorner2};
             
    // Create image attributes and set large gamma.
    ImageAttributes imageAttr = new ImageAttributes();
    imageAttr.SetGamma(4.0F);
             
    // Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destPara2, srcRect, units, imageAttr);
}

Private Sub DrawImageParaRectAttrib(ByVal e As PaintEventArgs)

    ' Create image.
    Dim newImage As Image = Image.FromFile("SampImag.jpg")

    ' Create parallelogram for drawing image.
    Dim ulCorner1 As New Point(100, 100)
    Dim urCorner1 As New Point(325, 100)
    Dim llCorner1 As New Point(150, 250)
    Dim destPara1 As Point() = {ulCorner1, urCorner1, llCorner1}

    ' Create rectangle for source image.
    Dim srcRect As New Rectangle(50, 50, 150, 150)
    Dim units As GraphicsUnit = GraphicsUnit.Pixel

    ' Draw original image to screen.
    e.Graphics.DrawImage(newImage, destPara1, srcRect, units)

    ' Create parallelogram for drawing adjusted image.
    Dim ulCorner2 As New Point(325, 100)
    Dim urCorner2 As New Point(550, 100)
    Dim llCorner2 As New Point(375, 250)
    Dim destPara2 As Point() = {ulCorner2, urCorner2, llCorner2}

    ' Create image attributes and set large gamma.
    Dim imageAttr As New ImageAttributes
    imageAttr.SetGamma(4.0F)

    ' Draw adjusted image to screen.
    e.Graphics.DrawImage(newImage, destPara2, srcRect, units, _
    imageAttr)
End Sub

Hinweise

Der parameter srcRect gibt einen rechteckigen Teil des zu zeichnendenimage Objekts an. Dieser Teil wird skaliert und schubiert, um in das durch den parameter destPoints angegebene Parallelogramm zu passen.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

Teilen über

Graphics.DrawImage Methode

Definition

Überlädt

DrawImage(Image, Single, Single, RectangleF, GraphicsUnit)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Effect, RectangleF, Matrix, GraphicsUnit, ImageAttributes)

Parameter

Gilt für:

DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)

Parameter

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)

Parameter

Ausnahmen

Beispiele

Hinweise

Weitere Informationen

Gilt für:

DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)

Parameter

Ausnahmen

Beispiele