Graphics.DrawImage Methode

Referenz

Definition

Namespace:: System.Drawing

Assembly:: System.Drawing.Common.dll

Assembly:: System.Drawing.dll

Paket:: System.Drawing.Common v6.0.0

Paket:: System.Drawing.Common v7.0.0

Paket:: System.Drawing.Common v8.0.0

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

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 das angegebene Image an der angegebenen Position und in der ursprünglichen Größe.

Überlädt

DrawImage(Image, Single, Single, RectangleF, GraphicsUnit)	Zeichnet einen Teil eines Bildes an einer angegebenen Position.
DrawImage(Image, Effect, RectangleF, Matrix, GraphicsUnit, ImageAttributes)
DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Int32, Int32, Int32, Int32)	Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Single, Single, Single, Single)	Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Effect)
DrawImage(Image, Point)	Zeichnet das angegebene Image in seiner ursprünglichen physischen Größe an der angegebenen Position.
DrawImage(Image, Point[])	Zeichnet das angegebene Image an der angegebenen Position und in der angegebenen Form und Größe.
DrawImage(Image, PointF)	Zeichnet das angegebene Image in seiner ursprünglichen physischen Größe an der angegebenen Position.
DrawImage(Image, PointF[])	Zeichnet das angegebene Image an der angegebenen Position und in der angegebenen Form und Größe.
DrawImage(Image, Rectangle)	Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, RectangleF)	Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Int32, Int32, Rectangle, GraphicsUnit)	Zeichnet einen Teil eines Bildes an einer angegebenen Position.
DrawImage(Image, Single, Single)	Zeichnet das angegebene Image in seiner ursprünglichen physischen Größe an der angegebenen Position.
DrawImage(Image, Point[], Rectangle, GraphicsUnit)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, PointF[], RectangleF, GraphicsUnit)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Rectangle, Rectangle, GraphicsUnit)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, RectangleF, RectangleF, GraphicsUnit)	Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.
DrawImage(Image, Int32, Int32)	Zeichnet das angegebene Bild in seiner ursprünglichen physischen Größe an der von einem Koordinatenpaar angegebenen Position.
DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes)	Zeichnet den angegebenen Teil vom angegebenen Image an der angegebenen Position.

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

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet einen Teil eines Bildes 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

Der zu zeichnende Image.

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 zu zeichnenden Teil vom Image angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Das folgende Codebeispiel ist für die Verwendung mit Windows Forms konzipiert und erfordert PaintEventArgse, was ein Parameter des Paint Ereignishandlers ist. Der Code führt die folgenden Aktionen aus:

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 ungeskalierten 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 physische Breite eines Bilds in Zoll ist die Pixelbreite geteilt durch die horizontale Auflösung. Beispielsweise hat ein Bild mit einer Pixelbreite von 360 und einer horizontalen Auflösung von 72 Punkten pro Zoll eine physische Breite von 5 Zoll. Ä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, beträgt 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)

Source:: 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe 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, 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

Der zu zeichnende Image.

destPoints: Point[]

Array von drei PointF-Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

imageAttr: ImageAttributes

ImageAttributes, das Informationen über erneutes Einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Das folgende Codebeispiel ist für die Verwendung mit Windows Forms konzipiert und erfordert PaintEventArgse, was ein Parameter des Paint Ereignishandlers ist. Der Code definiert zunächst eine Rückrufmethode für den Graphics.DrawImageAbort Delegaten. Die Definition ist einfach und testet lediglich, ob die DrawImage Methode sie mit einem NULL-Parameter callBackData aufruft. Der Standard Text des Beispiels führt die folgenden Aktionen aus:

Erstellt eine instance 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 zu zeichnenden Teil des 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 auf einen größer als den üblichen Gammawert fest.
Zeichnet das angepasste Bild auf den Bildschirm.

Beim ursprünglichen, nicht angepassten Parallelogramm bestimmt die Position das Bild auf dem Bildschirm, und die Größe des Rechtecks und die Größe und Form des Parallelogramms bestimmen die Skalierung und das Scheren des gezeichneten Bilds.

Da in diesem Beispiel eine Überladung verwendet wird, die keinen callBackData Parameter übergibt, gibt der Graphics.DrawImageAbort Rückruf zurück true, wodurch die DrawImage -Methode beendet wird, und der im Beispiel enthaltene Ausnahmebehandlungscode gibt 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 destPoints Parameter 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 dreien extrapoliert, um ein Parallelogramm zu bilden.

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

Diese Überladung mit dem callback Parameter bietet die Möglichkeit, das Zeichnen eines Bilds zu beenden, sobald es gemäß den von der Anwendung festgelegten Kriterien beginnt. Beispielsweise könnte eine Anwendung mit dem Zeichnen eines großen Bilds beginnen, und der Benutzer könnte das Bild vom 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destPoints: PointF[]

Array von drei PointF-Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

imageAttr: ImageAttributes

ImageAttributes, das Informationen über erneutes Einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine instance 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 zu zeichnenden Teil des 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 auf einen größer als den üblichen Gammawert fest.
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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe 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, 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

Der zu zeichnende Image.

destPoints: Point[]

Array von drei PointF-Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

imageAttr: ImageAttributes

ImageAttributes, das Informationen über erneutes Einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

callbackData: Int32

Ein Wert, der zusätzliche Daten angibt, mit denen der Graphics.DrawImageAbort-Delegat prüfen kann, ob die Ausführung der DrawImage(Image, Point[], Rectangle, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode abgebrochen werden muss.

Beispiele

Erstellt eine instance 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 zu zeichnenden Teil des 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 auf einen größer als den üblichen Gammawert fest.
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 zurück false, wodurch die DrawImage -Methode fortgesetzt wird, und das Beispiel zeichnet das angepasste Bild auf den Bildschirm.

   // 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 callback Parametern und callbackData bietet die Möglichkeit, das Zeichnen eines Bilds zu beenden, sobald es gemäß den von der Anwendung festgelegten Kriterien und Daten beginnt. Beispielsweise könnte eine Anwendung mit dem Zeichnen eines großen Bilds beginnen, und der Benutzer könnte das Bild vom 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destPoints: PointF[]

Array von drei PointF-Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

imageAttr: ImageAttributes

ImageAttributes, das Informationen über erneutes Einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

callbackData: Int32

Ein Wert, der zusätzliche Daten angibt, mit denen der Graphics.DrawImageAbort-Delegat prüfen kann, ob die Ausführung der DrawImage(Image, PointF[], RectangleF, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, Int32)-Methode abgebrochen werden muss.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Das folgende Codebeispiel ist für die Verwendung mit Windows Forms konzipiert und erfordert PaintEventArgse, was ein Parameter des PaPaint Ereignishandlers ist. Der Code definiert zunächst eine Rückrufmethode für den Graphics.DrawImageAbort Delegaten. Die Definition ist einfach und testet lediglich, ob die DrawImage Methode sie mit einem NULL-Parameter callBackData aufruft. Der Standard Text des Beispiels führt die folgenden Aktionen aus:

Erstellt eine instance 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 zu zeichnenden Teil des 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 auf einen größer als den üblichen Gammawert fest.
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

Der destPoints Parameter 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 aus den ersten drei Punkten extrapoliert, um ein Parallelogramm zu bilden.

Der srcRect Parameter gibt einen rechteckigen Teil des image zu zeichnenden Objekts an. Dieser Teil wird skaliert und schert, um in das vom destPoints Parameter angegebene Parallelogramm zu passen.

Diese Überladung mit den callback Parametern und callbackData bietet die Möglichkeit, das Zeichnen eines Bilds zu beenden, sobald es nach den von der Anwendung festgelegten Kriterien und Daten gestartet wird. Beispielsweise könnte eine Anwendung mit dem Zeichnen eines großen Bilds beginnen, und der Benutzer könnte das Bild vom Bildschirm scrollen. In diesem Fall könnte die Anwendung die Zeichnung beenden.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

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

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Int32

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

srcY: Int32

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

srcWidth: Int32

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

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 Originalbilds 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 srcXParameter , srcY, srcWidthund srcHeight geben einen rechteckigen Teil des image zu zeichnenden Objekts an. Das Rechteck ist relativ zur linken oberen Ecke des Quellbilds. Dieser Teil wird so skaliert, dass er in das durch den destRect Parameter angegebene Rechteck passt.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

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

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Int32

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

srcY: Int32

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

srcWidth: Int32

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

imageAttr: ImageAttributes

ImageAttributes, das Informationen über erneutes 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 sie einen größer als üblichen Gammawert aufweisen.
Zeichnet das angepasste Bild auf den Bildschirm.

Beim ursprünglichen, nicht justierten Zielrechteck wird das Bild auf dem Bildschirm lokalisiert, 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Single

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

srcY: Single

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

srcWidth: Single

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

imageAttrs: ImageAttributes

ImageAttributes, das Informationen über erneutes 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 sie einen größer als üblichen Gammawert aufweisen.
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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Int32

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

srcY: Int32

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

srcWidth: Int32

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

imageAttr: ImageAttributes

ImageAttributes, das Neueinfärbungs- und Gammainformationen für image angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine instance 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 zu zeichnenden Teil des 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 sie einen größer als üblichen Gammawert aufweisen.
Zeichnet das angepasste Bild auf den Bildschirm.

Beim ursprünglichen, nicht justierten Zielrechteck wird das Bild auf dem Bildschirm von der Position gesucht, und die Größe des Quellrechtecks sowie die Größe und Form des Zielrechtecks bestimmen die Skalierung des gezeichneten Bilds.

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

   // 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

Diese Überladung mit dem callback Parameter bietet die Möglichkeit, das Zeichnen eines Bilds zu beenden, sobald es nach den von der Anwendung festgelegten Kriterien gestartet wird. Beispielsweise könnte eine Anwendung mit dem Zeichnen eines großen Bilds beginnen, und der Benutzer könnte das Bild vom Bildschirm scrollen. In diesem Fall könnte die Anwendung die Zeichnung beenden.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

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

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Single

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

srcY: Single

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

srcWidth: Single

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

imageAttrs: ImageAttributes

ImageAttributes, das Informationen über erneutes Einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine instance 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 zu zeichnenden Teil des 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 sie einen größer als üblichen Gammawert aufweisen.
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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Int32

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

srcY: Int32

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

srcWidth: Int32

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Int32

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

imageAttrs: ImageAttributes

ImageAttributes, das Informationen über erneutes Einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, Rectangle, Int32, Int32, Int32, Int32, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

callbackData: IntPtr
nativeint

Ein Wert, der zusätzliche Daten angibt, mit denen der Graphics.DrawImageAbort-Delegat prüfen kann, ob die Ausführung der DrawImage-Methode abgebrochen werden muss.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine instance 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 zu zeichnenden Teil des 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 sie einen größer als üblichen Gammawert aufweisen.
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 zurück false, wodurch die DrawImage Methode fortgesetzt wird, und das Beispiel 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Single

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

srcY: Single

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

srcWidth: Single

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

imageAttrs: ImageAttributes

ImageAttributes, das Informationen über erneutes Einfärben und Gammainformationen für das image-Objekt angibt.

callback: Graphics.DrawImageAbort

Graphics.DrawImageAbort-Delegat, der eine Methode angibt, die während des Zeichnens des Bildes aufgerufen werden soll. Diese Methode wird häufig aufgerufen, um zu prüfen, ob die Ausführung der DrawImage(Image, Rectangle, Single, Single, Single, Single, GraphicsUnit, ImageAttributes, Graphics+DrawImageAbort, IntPtr)-Methode gemäß den durch die Anwendung bestimmten Kriterien abgebrochen werden soll.

callbackData: IntPtr
nativeint

Ein Wert, der zusätzliche Daten angibt, mit denen der Graphics.DrawImageAbort-Delegat prüfen kann, ob die Ausführung der DrawImage-Methode abgebrochen werden muss.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt eine instance 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 zu zeichnenden Teil des 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 sie einen größer als üblichen Gammawert aufweisen.
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 zurück false, wodurch die DrawImage Methode fortgesetzt wird, und das Beispiel 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcX: Single

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

srcY: Single

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

srcWidth: Single

Breite des zu zeichnenden Bereichs des Quellbilds.

srcHeight: Single

Höhe des zu zeichnenden Bereichs des Quellbilds.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten angibt, mit denen das Quellrechteck bestimmt wird.

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 originalen 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

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 originalen Bilds und die Größe des Rechtecks bestimmen 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 xParameter , , y, widthund height 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

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 originalen Bilds und die Größe des Rechtecks bestimmen 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 xParameter , , y, widthund height 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destPoints: PointF[]

Array von drei PointF-Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

imageAttr: ImageAttributes

ImageAttributes, das Informationen über erneutes 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 Zielparallelogramm 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 sie einen größer als üblichen Gammawert aufweisen.
Zeichnet das angepasste Bild auf den Bildschirm.

Beim ursprünglichen, nicht justierten Zielparallelogramm bestimmt die Position das Bild auf dem Bildschirm, die Größe des Quellrechtecks und die Größe und Form des Zielparallelogramms die Skalierung und Scherung des gezeichneten Bilds, und die Größe des Rechtecks bestimmt, welcher Teil des Originalbilds 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

Der destPoints Parameter 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 aus den ersten drei Punkten extrapoliert, um ein Parallelogramm zu bilden.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Effect)

Source:: 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image in seiner 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

Der zu zeichnende Image.

point: Point

Point-Struktur, die die Position der oberen linken Ecke des gezeichneten Bildes 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 physische Breite eines Bilds in Zoll ist die Pixelbreite geteilt 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, beträgt die Pixelbreite des gerenderten Bilds (216/72)*96 = 288.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Point[])

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image an der angegebenen Position und in 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

Der zu zeichnende Image.

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 originalen Bilds und die Größe und Form des Parallelogramms bestimmen die Skalierung und Das Scheren 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 destPoints Parameter 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 dreien extrapoliert, um ein Parallelogramm zu bilden.

Das durch den image -Parameter dargestellte Bild wird skaliert und schert, um der Form des durch die destPoints Parameter angegebenen Parallelogramms zu entsprechen.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, PointF)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image in seiner 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

Der zu zeichnende Image.

point: PointF

PointF-Struktur, die die obere linke Ecke des gezeichneten Bildes 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 physische Breite eines Bilds in Zoll ist die Pixelbreite geteilt 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[])

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image an der angegebenen Position und in 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

Der zu zeichnende Image.

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 durch das image -Objekt dargestellte Bild wird skaliert und schert, um der form des durch den destPoints Parameter angegebenen Parallelogramms zu entsprechen.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

rect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes 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 ursprünglichen Bilds und die Größe des Rechtecks bestimmen 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

rect: RectangleF

RectangleF-Struktur, die die Position und Größe des gezeichneten Bildes 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 ursprüngliche Größe des Bilds und die Größe des Rechtecks bestimmen 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet einen Teil eines Bildes 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

Der zu zeichnende Image.

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 zu zeichnenden Teil des image-Objekts angibt.

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

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 ungeskalierten 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

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 geteilt 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.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Single, Single)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Image in seiner 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

Der zu zeichnende Image.

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 geteilt 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)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe 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);

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

Der zu zeichnende Image.

destPoints: Point[]

Array von drei Point-Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter 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 zu zeichnenden Teil des Bilds auszuwählen.
Legt die Grafikzeichnungseinheit auf Pixel fest.
Zeichnet das Bild auf den Bildschirm.

Die Position des Parallelogramms lokalisiert das Bild auf dem Bildschirm, und die Größe des Rechtecks und die Größe und Form des Parallelogramms bestimmen 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

Der destPoints Parameter 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 aus den ersten drei Punkten extrapoliert, um ein Parallelogramm zu bilden.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

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

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destPoints: PointF[]

Array von drei PointF-Strukturen, die ein Parallelogramm definieren.

srcRect: RectangleF

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

Ausnahmen

ArgumentNullException

image ist null.

Beispiele

Erstellt ein Bild aus einer JPEG-Datei SampImag.jpg im Ordner des Beispiels.
Erstellt Punkte, die ein Zielparallelogramm 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 Zielparallelogramms sucht das Bild auf dem Bildschirm, die Größe des Quellrechtecks und die Größe und Form des Zielparallelogramms bestimmen die Skalierung und Das Scheren des gezeichneten Bilds, und die Größe des Rechtecks bestimmt, welcher Teil des Originalbilds 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

Der destPoints Parameter 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 aus den ersten drei Punkten extrapoliert, um ein Parallelogramm zu bilden.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Rectangle, Rectangle, GraphicsUnit)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: Rectangle

Rectangle-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcRect: Rectangle

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter 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 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 srcRect Parameter gibt einen rechteckigen Teil des image zu zeichnenden Objekts an. Dieser Teil wird so skaliert, dass er in das durch den destRect Parameter angegebene Rechteck passt.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, RectangleF, RectangleF, GraphicsUnit)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Bereich vom angegebenen Image in der angegebenen Größe an der angegebenen Position.

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

Der zu zeichnende Image.

destRect: RectangleF

RectangleF-Struktur, die die Position und Größe des gezeichneten Bildes angibt. Das Bild wird skaliert, sodass es in das Rechteck passt.

srcRect: RectangleF

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter 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 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 srcRect Parameter gibt einen rechteckigen Teil des image zu zeichnenden Objekts an. Dieser Teil wird so skaliert, dass er in das durch den destRect Parameter angegebene Rechteck passt.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

DrawImage(Image, Int32, Int32)

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet das angegebene Bild in seiner ursprünglichen physischen Größe an der von einem 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

Der zu zeichnende Image.

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 physische Breite eines Bilds in Zoll ist die Pixelbreite geteilt 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 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 aufrufen DrawImage , um dieses Bild auf einem Gerät mit einer Auflösung von 96 Punkten pro Zoll zu zeichnen, beträgt die Pixelbreite des gerenderten Bilds (216/72)*96 = 288.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für:

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

Source:: Graphics.cs

Source:: Graphics.cs

Source:: Graphics.cs

Zeichnet den angegebenen Teil vom 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

Der zu zeichnende Image.

destPoints: Point[]

Array von drei Point-Strukturen, die ein Parallelogramm definieren.

srcRect: Rectangle

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

srcUnit: GraphicsUnit

Member der GraphicsUnit-Enumeration, der die Maßeinheiten für den srcRect-Parameter angibt.

imageAttr: ImageAttributes

ImageAttributes, das Informationen über erneutes 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 zu zeichnenden Teil des 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 auf einen größer als den üblichen Gammawert fest.
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 srcRect Parameter gibt einen rechteckigen Teil desimage zu zeichnenden Objekts an. Dieser Teil wird skaliert und schert, um in das durch den destPoints -Parameter angegebene Parallelogramm zu passen.

Weitere Informationen

Bilder, Bitmaps und Metadateien

Gilt für: