Bildzeichnen

Zeichnen von Linien

Dieses Beispiel verwendet die Graphics-Klasse, um Linienformen auf der Bildfläche zu zeichnen. Um den Vorgang zu demonstrieren, erstellt das Beispiel ein neues Bild und zeichnet Linien auf der Bildfläche mithilfe der durch die Graphics-Klasse bereitgestellten DrawLine-Methode. Zunächst erstellen wir ein PsdImage, indem wir seine Höhe und Breite festlegen.

Nachdem das Bild erstellt wurde, verwenden wir die Clear-Methode der Graphics-Klasse, um seine Hintergrundfarbe festzulegen. Die DrawLine-Methode der Graphics-Klasse wird verwendet, um eine Linie auf einem Bild zu zeichnen, die zwei Punktstrukturen verbindet. Diese Methode hat mehrere Überladungen, die die Instanz der Pen-Klasse und Koordinatenpaare von Punkten oder Point/PointF-Strukturen als Argumente akzeptieren. Die Pen-Klasse definiert ein Objekt, das zum Zeichnen von Linien, Kurven und Figuren verwendet wird. Die Pen-Klasse hat mehrere überladene Konstruktoren, um Linien mit angegebener Farbe, Breite und Pinsel zu zeichnen. Die SolidBrush-Klasse wird verwendet, um kontinuierlich mit einer bestimmten Farbe zu zeichnen. Schließlich wird das Bild im BMP-Dateiformat exportiert. Der folgende Code-Schnipsel zeigt Ihnen, wie Sie Linienformen auf der Bildfläche zeichnen.

        String dataDir = Utils.getDataDir(DrawingLines.class) + "DrawingImages/";

        // Create an instance of BmpOptions and set its various properties
        String outpath = dataDir + "Lines.bmp";
        BmpOptions saveOptions = new BmpOptions();
        saveOptions.setBitsPerPixel(32);

        // Create an instance of Image
        try (Image image = new PsdImage(100, 100)) {
            // Create and initialize an instance of Graphics class and Clear Graphics surface
            Graphics graphic = new Graphics(image);
            graphic.clear(Color.getYellow());

            // Draw two dotted diagonal lines by specifying the Pen object having blue color and co-ordinate Points
            graphic.drawLine(new Pen(Color.getBlue()), 9, 9, 90, 90);
            graphic.drawLine(new Pen(Color.getBlue()), 9, 90, 90, 9);

            // Draw a four continuous line by specifying the Pen object having Solid Brush with red color and two point structures
            graphic.drawLine(new Pen(new SolidBrush(Color.getRed())), new Point(9, 9), new Point(9, 90));
            graphic.drawLine(new Pen(new SolidBrush(Color.getAqua())), new Point(9, 90), new Point(90, 90));
            graphic.drawLine(new Pen(new SolidBrush(Color.getBlack())), new Point(90, 90), new Point(90, 9));
            graphic.drawLine(new Pen(new SolidBrush(Color.getWhite())), new Point(90, 9), new Point(9, 9));
            image.save(outpath, saveOptions);
        }

Zeichnen von Ellipsen

Das Beispiel zum Zeichnen von Ellipsen ist der zweite Artikel in der Serie zum Zeichnen von Formen. Wir verwenden die Graphics-Klasse, um die Ellipsenform auf der Bildfläche zu zeichnen. Um den Vorgang zu demonstrieren, erstellt das Beispiel ein neues Bild und zeichnet die Ellipsenform auf der Bildfläche mithilfe der durch die Graphics-Klasse bereitgestellten DrawEllipse-Methode. Zunächst erstellen wir ein PsdImage, indem wir seine Höhe und Breite festlegen.

Nachdem das Bild erstellt wurde, erstellen und initialisieren wir ein Objekt der Graphics-Klasse und setzen die Hintergrundfarbe des Bildes mithilfe der Clear-Methode der Graphics-Klasse. Die DrawEllipse-Methode der Graphics-Klasse wird verwendet, um die Ellipsenform auf einer Bildfläche zu zeichnen, die durch die Bounding-Rectangle-Struktur angegeben ist. Diese Methode hat mehrere Überladungen, die die Instanzen der Pen- und Rectangle-/RectangleF-Klassen oder ein Koordinatenpaar, eine Höhe und eine Breite als Argumente akzeptieren. Die Pen-Klasse definiert ein Objekt, das zum Zeichnen von Linien, Kurven und Figuren verwendet wird. Die Pen-Klasse hat mehrere überladene Konstruktoren, um Linien mit angegebener Farbe, Breite und Pinsel zu zeichnen. Die Rectangle-Klasse speichert einen Satz von vier Ganzzahlen, die den Standort und die Größe eines Rechtecks darstellen. Die Rectangle-Klasse hat mehrere überladene Konstruktoren, um die Rechteckstruktur mit angegebener Größe und Lage zu zeichnen. Die SolidBrush-Klasse wird verwendet, um kontinuierlich mit einer bestimmten Farbe zu zeichnen. Schließlich wird das Bild im BMP-Dateiformat exportiert. Der folgende Code-Schnipsel zeigt Ihnen, wie Sie die Ellipsenform auf der Bildfläche zeichnen.

        String dataDir = Utils.getDataDir(DrawingEllipse.class) + "DrawingImages/";

        // Create an instance of BmpOptions and set its various properties
        String outpath = dataDir + "Ellipse.bmp";
        // Create an instance of BmpOptions and set its various properties
        BmpOptions saveOptions = new BmpOptions();
        saveOptions.setBitsPerPixel(32);

        // Create an instance of Image
        try (Image image = new PsdImage(100, 100)) {
            // Create and initialize an instance of Graphics class and Clear Graphics surface                    
            Graphics graphic = new Graphics(image);
            graphic.clear(Color.getYellow());

            // Draw a dotted ellipse shape by specifying the Pen object having red color and a surrounding Rectangle
            graphic.drawEllipse(new Pen(Color.getRed()), new Rectangle(30, 10, 40, 80));

            // Draw a continuous ellipse shape by specifying the Pen object having solid brush with blue color and a surrounding Rectangle
            graphic.drawEllipse(new Pen(new SolidBrush(Color.getBlue())), new Rectangle(10, 30, 80, 40));

            // export image to bmp file format.
            image.save(outpath, saveOptions);
        }

Zeichnen von Rechtecken

In diesem Beispiel werden wir die Rechtecksform auf der Bildfläche zeichnen. Um den Vorgang zu demonstrieren, erstellt das Beispiel ein neues Bild und zeichnet die Rechtecksform auf der Bildfläche mithilfe der durch die Graphics-Klasse bereitgestellten DrawRectangle-Methode. Zunächst erstellen wir ein PsdImage, indem wir seine Höhe und Breite festlegen. Anschließend setzen wir die Hintergrundfarbe des Bildes mithilfe der Clear-Methode der Graphics-Klasse.

Die DrawRectangle-Methode der Graphics-Klasse wird verwendet, um die Rechtecksform auf einer Bildfläche zu zeichnen, die durch die Rechtecksstruktur angegeben ist. Diese Methode hat mehrere Überladungen, die die Instanzen der Pen- und Rectangle/RectangleF-Klassen oder Koordinatenpaare, eine Breite und eine Höhe als Argumente akzeptieren. Die Rectangle-Klasse speichert einen Satz von vier Ganzzahlen, die den Standort und die Größe eines Rechtecks darstellen. Die Rectangle-Klasse hat mehrere überladene Konstruktoren, um die Rechteckstruktur mit angegebener Größe und Lage zu zeichnen. Schließlich wird das Bild im BMP-Dateiformat exportiert. Der folgende Code-Schnipsel zeigt Ihnen, wie Sie die Rechtecksform auf der Bildfläche zeichnen.

        // Create an instance of BmpOptions and set its various properties
        String outpath = dataDir + "Rectangle.bmp";
        // Create an instance of BmpOptions and set its various properties
        BmpOptions saveOptions = new BmpOptions();
        saveOptions.setBitsPerPixel(32);

        // Create an instance of Image
        try (Image image = new PsdImage(100, 100)) {
            // Create and initialize an instance of Graphics class,  Clear Graphics surface, Draw a rectangle shapes and  save all changes.
            Graphics graphic = new Graphics(image);
            graphic.clear(Color.getYellow());
            graphic.drawRectangle(new Pen(Color.getRed()), new Rectangle(30, 10, 40, 80));
            graphic.drawRectangle(new Pen(new SolidBrush(Color.getBlue())), new Rectangle(10, 30, 80, 40));

            // export image to bmp file format.
            image.save(outpath, saveOptions);
        }

Zeichnen von Bögen

In dieser Sitzung der Zeichenformen-Serie werden wir die Bogenform auf der Bildfläche zeichnen. Wir verwenden die DrawArc-Methode von Graphics, um den Vorgang an einem BMP-Bild zu demonstrieren. Zunächst erstellen wir ein PsdImage, in dem wir seine Höhe und Breite festlegen. Nachdem das Bild erstellt wurde, verwenden wir die Clear-Methode der Graphics-Klasse, um seine Hintergrundfarbe festzulegen.

Die DrawArc-Methode der Graphics-Klasse wird verwendet, um die Bogenform auf einer Bildfläche zu zeichnen. DrawArc stellt einen Teil einer Ellipse dar, der durch die Rechtecksstruktur oder das Koordinatenpaar angegeben ist. Diese Methode hat mehrere Überladungen, die die Instanzen der Pen-Klassen und Rectangle /RectangleF-Struktur oder ein Koordinatenpaar, eine Breite und eine Höhe als Argumente akzeptieren. Schließlich wird das Bild im BMP-Dateiformat exportiert. Der folgende Code-Schnipsel zeigt Ihnen, wie Sie die Bogenform auf der Bildfläche zeichnen.

        String dataDir = Utils.getDataDir(DrawingArc.class) + "DrawingImages/";
        // Create an instance of BmpOptions and set its various properties
        String outpath = dataDir + "Arc.bmp";
        // Create an instance of BmpOptions and set its various properties
        BmpOptions saveOptions = new BmpOptions();
        saveOptions.setBitsPerPixel(32);

        // Create an instance of Image
        try (Image image = new PsdImage(100, 100)) {
            // Create and initialize an instance of Graphics class and clear Graphics surface
            Graphics graphic = new Graphics(image);
            graphic.clear(Color.getYellow());

            // Draw an arc shape by specifying the Pen object having red black color and coordinates, height, width, start & end angles                 
            int width = 100;
            int height = 200;
            int startAngle = 45;
            int sweepAngle = 270;

            // Draw arc to screen and save all changes.
            graphic.drawArc(new Pen(Color.getBlack()), 0, 0, width, height, startAngle, sweepAngle);

            // export image to bmp file format.
            image.save(outpath, saveOptions);
        }

Zeichnen von Bezierkurven

Dieses Beispiel verwendet die Graphics-Klasse, um die Bezierkurvenform auf der Bildfläche zu zeichnen. Um den Vorgang zu demonstrieren, erstellt das Beispiel ein neues Bild und zeichnet die Bezierkurvenform auf der Bildfläche mithilfe der durch die Graphics-Klasse bereitgestellten DrawBezier-Methode. Zunächst erstellen wir ein PsdImage, indem wir seine Höhe und Breite festlegen. Sobald das Bild erstellt wurde, verwenden wir die Clear-Methode der Graphics-Klasse, um seine Hintergrundfarbe festzulegen.

Die DrawBezier-Methode der Graphics-Klasse wird verwendet, um die Bezier-Spline-Form auf einer Bildfläche zu zeichnen, die durch vier Point-Strukturen definiert ist. Diese Methode hat mehrere Überladungen, die die Instanzen der Pen-Klasse und vier geordnete Koordinatenpaare oder vier Point/PointF-Strukturen oder ein Array von Point/PointF-Strukturen als Argumente akzeptieren. Die Pen-Klasse definiert ein Objekt, das zum Zeichnen von Linien, Kurven und Figuren verwendet wird. Die Pen-Klasse hat mehrere überladene Konstruktoren, um Linien mit angegebener Farbe, Breite und Pinsel zu zeichnen. Schließlich wird das Bild im BMP-Dateiformat exportiert. Der folgende Code-Schnipsel zeigt Ihnen, wie Sie die Bezierkurve auf der Bildfläche zeichnen.

        String dataDir = Utils.getDataDir(DrawingBezier.class) + "DrawingImages/";

        // Create an instance of BmpOptions and set its various properties
        String outpath = dataDir + "Bezier.bmp";
        // Create an instance of BmpOptions and set its various properties
        BmpOptions saveOptions = new BmpOptions();
        saveOptions.setBitsPerPixel(32);

        // Create an instance of Image
        try (Image image = new PsdImage(100, 100)) {
            // Create and initialize an instance of Graphics class and clear Graphics surface
            Graphics graphic = new Graphics(image);
            graphic.clear(Color.getYellow());

            // Initializes the instance of PEN class with black color and width
            Pen BlackPen = new Pen(Color.getBlack(), 3);
            float startX = 10;
            float startY = 25;
            float controlX1 = 20;
            float controlY1 = 5;
            float controlX2 = 55;
            float controlY2 = 10;
            float endX = 90;
            float endY = 25;

            // Draw a Bezier shape by specifying the Pen object having black color and co-ordinate Points and save all changes.
            graphic.drawBezier(BlackPen, startX, startY, controlX1, controlY1, controlX2, controlY2, endX, endY);

            // export image to bmp file format.
            image.save(outpath, saveOptions);
        }

Zeichnen von Bildern mit Kernfunktionalität

Aspose.PSD ist eine Bibliothek, die viele wertvolle Funktionen bietet, darunter das Erstellen von Bildern von Grund auf. Zeichnen Sie mithilfe der Kernfunktionalität wie der Manipulation von Bitmapinformationen eines Bildes oder verwenden Sie die erweiterten Funktionen wie Graphics und GraphicsPath, um Formen auf der Bildfläche mit Hilfe verschiedener Pinsel und Stifte zu zeichnen. Mit der RasterImage-Klasse von Aspose.PSD können Sie die Pixelinformationen eines Bildbereichs abrufen und manipulieren. Die RasterImage-Klasse enthält die gesamte Kern-Zeichenfunktionalität, wie das Abrufen und Setzen von Pixeln und andere Methoden zur Bildmanipulation. Erstellen Sie ein neues Bild mithilfe einer der in der Dokumentation “Dateien erstellen” beschriebenen Methoden und weisen Sie es einer Instanz der RasterImage-Klasse zu. Verwenden Sie die LoadPixels-Methode der RasterImage-Klasse, um die Pixelinformationen eines Bildbereichs abzurufen. Sobald Sie ein Pixelarray haben, können Sie es manipulieren, indem Sie beispielsweise die Farbe jedes Pixels ändern. Nach der Manipulation der Pixelinformationen setzen Sie sie an der gewünschten Stelle im Bild mit Hilfe der SavePixels-Methode der RasterImage-Klasse zurück. Der folgende Code-Schnipsel zeigt Ihnen, wie Sie Bilder mithilfe der Kernfunktionalität zeichnen.

        String dataDir = Utils.getDataDir(CoreDrawingFeatures.class) + "DrawingImages/";

        // Create an instance of BmpOptions and set its various properties
        String loadpath = dataDir + "sample.psd";
        String outpath = dataDir + "CoreDrawingFeatures.bmp";
        // Create an instance of Image    

        try (PsdImage image = new PsdImage(loadpath)) {
            // load pixels
            int[] pixels = image.loadArgb32Pixels(new Rectangle(0, 0, 100, 10));

            for (int i = 0; i < pixels.length; i++) {
                // specify pixel color value (gradient in this case).
                pixels[i] = i;
            }

            // save modified pixels.
            image.saveArgb32Pixels(new Rectangle(0, 0, 100, 10), pixels);

            // export image to bmp file format.
            image.save(outpath, new BmpOptions());
        }