2D-Grafiken in Java
- PHPzOriginal
- 2024-08-30 16:06:061111Durchsuche
2D-Grafiken können mithilfe der Java-Programmierung mithilfe einiger erweiterter Funktionen der Java 2-Plattform erstellt werden, zu denen die in Java integrierten Funktionen für Vorgänge wie Bildverarbeitung, erweiterte Grafikdesignoptionen, geometrische Transformation, Alpha-Compositing usw. gehören . Es gibt eine Reihe von Paketen, die im Rahmen des Java 2D-Pakets bereitgestellt werden, z. B. awt, awt.image, awt.color, awt.font, awt.geom, awt.print und awt.image.renderable. Java ist in der Gaming-Entwickler-Community aufgrund seines hochwertigen grafischen Ergebnisses eine beliebte Option. Die große Auswahl an geometrischen Gestaltungsoptionen erleichtert das Drucken von Dokumenten und ermöglicht die Beibehaltung der Leistung des entwickelten Produkts.
WERBUNG Beliebter Kurs in dieser Kategorie JAVA MASTERY - Spezialisierung | 78 Kursreihe | 15 ProbetestsJava 2D-Rendering
Java 2D API unterstützt ein einheitliches Rendering-Modell auf allen verschiedenen Geräten: einem Anzeigemonitor oder einem Drucker. Während der Entwicklung des Programms funktioniert das Rendern unabhängig von der Endkomponente, ob es sich um einen Drucker oder einen Anzeigemonitor handelt, auf die gleiche Weise. Das Paket erkennt und ändert automatisch den Grafikkontext basierend auf der Endkomponente. Die Java 2D-API besteht aus java.awt.Graphics2D, das die Graphics-Klasse erweitert, um Unterstützung für erweiterte Grafik- und Rendering-Funktionen bereitzustellen.
Im Folgenden sind die Funktionen aufgeführt, die das Paket bietet:
- Es unterstützt die Darstellung primitiver geometrischer Formen und Figuren.
- Es bietet die Möglichkeit, das Innere jeder Form mithilfe von Strichen mit jeder Farbe oder jedem Muster zu füllen, die in den Farbattributen angegeben sind.
- Damit können Sie das angegebene Bild rendern.
- Damit können Sie die Textzeichenfolgen in Glyphen umwandeln, die mit den in den Farbattributen angegebenen Farben gefüllt werden.
Beispiel #1
Schauen wir uns das gleiche Java-Programm an und sehen, wie es funktioniert.
Code:
import javax.swing.JFrame;
import java.awt.*; // AWT package is responsible for creating GUI
import javax.swing.*; // Java swing package is responsible to provide UI components
// AWT class extents Jframe which is part of Swing package
public class AWTGraphicsSampleProgram extends JFrame {
/**
*
*/
// Defining all the static variables
private static final long serialVersionUID = 1L;
public static final int SAMPLE_CANVAS_WIDTH = 500;
public static final int SAMPLE_CANVAS_HEIGHT = 500;
// The program enters from the main method
public static void main(String[] args) {
SwingUtilities.invokeLater(new Runnable() {
@Override
public void run() {
new AWTGraphicsSampleProgram(); // this run method will create a new object and thus invoke the constructor method.
}
});
}
//Here we are creating an instance of the drawing canvas inner class called DrawCanwas
private DrawCanvas sampleCanvas;
public AWTGraphicsSampleProgram() {
sampleCanvas = new DrawCanvas();
sampleCanvas.setPreferredSize(new Dimension(SAMPLE_CANVAS_WIDTH, SAMPLE_CANVAS_HEIGHT));
Container containerPane = getContentPane();
containerPane.add(sampleCanvas);
setDefaultCloseOperation(EXIT_ON_CLOSE); // setting up the default close mechanism
pack();
setTitle("......"); // set the desired title of the JFrame
setVisible(true); // setVisible method will be set the visibility of the Jframe to true
}
/**
* here drawCanvas is the inner class of the Jpanel which is used for custom drawing
*/
private class DrawCanvas extends JPanel {
/**
*
*/
private static final long serialVersionUID = 1L;
// Overriding paintComponent will let you to design your own painting
@Override
public void paintComponent(Graphics graphics) {
super.paintComponent(graphics);
setBackground(Color.BLACK); // setting the background color to black
graphics.setColor(Color.GREEN); // setting up the color to green
graphics.drawLine(30, 40, 100, 200);
graphics.drawOval(150, 180, 10, 10);
graphics.drawRect(200, 210, 20, 30);
graphics.setColor(Color.magenta);
graphics.fillOval(300, 310, 30, 50);
graphics.fillRect(400, 350, 60, 50);
graphics.setColor(Color.WHITE);
graphics.setFont(new Font("Monospaced", Font.PLAIN, 12)); // setting up the font style and font size
graphics.drawString("Java Graphics in 2D ...", 10, 20);
}
}
}
Ausgabe:
Die Grafikklasse bietet verschiedene Methoden zum Zeichnen verschiedener grafischer Objekte. Die gebräuchlichsten Methoden sind drawString(), drawImage() und fillXxx(). Diese Methoden lassen sich grob in zwei Kategorien einteilen. Die erste Art der Grafikmethode besteht darin, dass sie Zeichen- und Füllfunktionen bereitstellt, die es den Benutzern ermöglichen, die grundlegenden Formen, Texte und Bilder zu rendern. Die andere Art von Methode betrifft Attributeinstellungen, mit denen Sie den Effekt ändern können, wie die Zeichnung in der Konsole angezeigt wird. Mit Methoden wie setColor und setFont können Sie entscheiden, wie das Zeichnen und Füllen gerendert wird. Der Grafikkontext ist für die Beibehaltung des Status oder von Attributen wie der aktuellen Malfarbe der aktuellen Schriftart verantwortlich.
Beispiel #2
Sehen wir uns ein weiteres Beispiel dafür an, was wir sonst noch mit Java 2D-Klassen erreichen können.
Code:
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
public class GeometricShapes extends JFrame
{
/**
*
*/
private static final long serialVersionUID = 1L;
@SuppressWarnings("deprecation")
public GeometricShapes()
{
super( "Geometric shapes" );
setSize( 425, 160 );
show();
}
public static void main( String args[] )
{
GeometricShapes figure = new GeometricShapes();
figure.addWindowListener( new WindowAdapter()
{
public void windowclosing( WindowEvent e )
{
System.exit( 0 );
}
});
}
public void paint( Graphics graphics )
{
// Instantiating Graphics 2D class
Graphics2D graphics2D = ( Graphics2D ) graphics;
graphics2D.setPaint( new GradientPaint( 16, 30,
Color.red,
45, 105,
Color.green,
true ) );
graphics2D.fill( new Ellipse2D.Double( 6, 31, 61, 105 ) );
graphics2D.setPaint( Color.black );
graphics2D.setStroke(new BasicStroke( 9.0f ) );
graphics2D.draw( new Rectangle2D.Double( 82, 32, 67, 102 ) );
// This will create a black colored rounded rectangle
BufferedImage bufferedImage = new BufferedImage( 10, 10, BufferedImage.TYPE_INT_RGB );
Graphics2D design = bufferedImage.createGraphics();
design.setColor( Color.blue );
design.fillRect( 0, 0, 9, 9 );
design.setColor( Color.orange );
design.drawRect( 2, 2, 7, 7 );
design.setColor( Color.black );
design.fillRect( 2, 2, 4, 4 );
design.setColor( Color.pink );
design.fillRect( 5, 5, 2, 2 );
graphics2D.setPaint( new TexturePaint( bufferedImage, new Rectangle( 9, 9 ) ) );
graphics2D.fill( new RoundRectangle2D.Double( 156, 31, 76, 101, 51, 51 ) );
graphics2D.setPaint( Color.CYAN );
graphics2D.setStroke(new BasicStroke( 7.0f ) );
graphics2D.draw( new Arc2D.Double( 240, 30, 75, 100, 0, 270, Arc2D.PIE ) );
// this will create line in red and black color
graphics2D.setPaint( Color.red );
graphics2D.draw( new Line2D.Double( 400, 40, 350, 180 ) );
float dashesArray[] = { 20 };
graphics2D.setPaint( Color.black );
graphics2D.setStroke( new BasicStroke( 4, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 10, dashesArray, 0 ) );
graphics2D.draw( new Line2D.Double( 320, 30, 395, 150 ) );
}
}
Ausgabe:
Beispiel #3
Lassen Sie uns 2D-Java im folgenden Programm anwenden.
Code:
import javax.swing.*;
import java.awt.event.*;
import java.awt.*;
import java.awt.geom.*;
public class GeometricShapes2 extends JFrame
{
/**
*
*/
private static final long <em>serialVersionUID</em> = 1L;
public static void main( String args[] )
{
GeometricShapes2 design = new GeometricShapes2();
design.addWindowListener(new WindowAdapter()
{
});
}
@SuppressWarnings("deprecation")
public GeometricShapes2()
{
super( "A circle made up of stars by joining them at certain position filled with random colors" );
setBackground( Color.<em>green</em> );
setSize( 450, 450 );
show();
}
public void paint( Graphics graphics )
{
int xCoordinates[] = { 57, 69, 111, 75, 85, 57, 29, 39, 3, 45 };
int yCoordinates[] = { 2, 38, 38, 56, 98, 74, 98, 56, 38, 38 };
Graphics2D graphics2D = ( Graphics2D ) graphics;
GeneralPath starFigure = new GeneralPath();
starFigure.moveTo( xCoordinates[ 0 ], yCoordinates[ 0 ] );
for ( int j = 1; j < xCoordinates.length; j++ )
starFigure.lineTo( xCoordinates[ j ], yCoordinates[ j ] );
starFigure.closePath();
graphics2D.translate( 200, 200 );
for ( int i = 1; i <= 10; i++ )
{
graphics2D.rotate( Math.<em>PI</em> / 9.0 );
graphics2D.setColor(new Color( ( int ) ( Math.<em>random</em>() * 128 ),( int ) ( Math.<em>random</em>() * 128 ),
( int ) ( Math.<em>random</em>() * 128 ) ) );
graphics2D.fill( starFigure );
}
}
}
Ausgabe:
Beispiel #4
Anwenden der Farbcodierung im folgenden Programm.
Code:
import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
public class GeometricShapes3 extends Canvas {
/**
*
*/
private static final long serialVersionUID = 1L;
Frame windowFrame;
TextField sampleText;
Font sampleFont;
Color colorOfText;
Color colorOfCircle;
public static void main(String args[]) {
GeometricShapes3 start;
start = new GeometricShapes3();
}
public GeometricShapes3() {
this("Arial", Font.BOLD, 18, Color.gray, Color.red);
}
public GeometricShapes3(String ff, int fs, int fz, Color bg, Color fg) {
setBackground(bg);
colorOfCircle = Color.green.brighter();
colorOfText = fg;
sampleFont = new Font(ff, fs, fz);
sampleText = new TextField("eduCBA (Corporate Bridge Consultancy Pvt Ltd) ");
windowFrame = new Frame("Demo");
windowFrame.add(sampleText, BorderLayout.NORTH);
windowFrame.add(this, BorderLayout.CENTER);
windowFrame.setSize(new Dimension(300,340));
windowFrame.setLocation(150,140);
windowFrame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent we) {
System.exit(0);
}
});
sampleText.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent ae) {
repaint();
}
});
windowFrame.setVisible(true);
}
public void paint(Graphics graphics) {
String sampleTxt = sampleText.getText();
if (sampleTxt.length() == 0) return;
if (graphics instanceof Graphics2D) {
Dimension dimension = getSize();
Point point = new Point(dimension.width / 2, dimension.height / 2);
int radius = (int)(point.x * 0.84);
graphics.setColor(colorOfCircle);
graphics.drawArc(point.x - radius, point.y - radius,
radius*2-1, radius*2-1,
0, 360);
graphics.setColor(colorOfText);
graphics.setFont(sampleFont);
CircularText((Graphics2D)graphics, sampleTxt, point, radius, -Math.PI/2, 1.0);
}
else {
System.out.println("Some Error Occurred");
}
}
static void CircularText(Graphics2D graphics, String sampleTxt, Point center,
double radius, double length, double height)
{
double circleAngle = length;
Point2D circle = new Point2D.Double(center.x, center.y);
char chArray[] = sampleTxt.toCharArray();
FontMetrics fm = graphics.getFontMetrics();
AffineTransform formx, formy;
formx = AffineTransform.getTranslateInstance(circle.getX(),circle.getY());
for(int i = 0; i < chArray.length; i++) {
double cwid = (double)(getWidth(chArray[i],fm));
if (!(chArray[i] == ' ' || Character.isSpaceChar(chArray[i]))) {
cwid = (double)(fm.charWidth(chArray[i]));
formy = new AffineTransform(formx);
formy.rotate(circleAngle, 0.0, 0.0);
String chstr = new String(chArray, i, 1);
graphics.setTransform(formy);
graphics.drawString(chstr, (float)(-cwid/2), (float)(-radius));
}
if (i < (chArray.length - 1)) {
double adv = cwid/2.0 + fm.getLeading() + getWidth(chArray[i + 1],fm)/2.0;
circleAngle += Math.sin(adv / radius);
}
}
}
static int getWidth(char charText, FontMetrics fontMetrics) {
if (charText == ' ' || Character.isSpaceChar(charText)) {
return fontMetrics.charWidth('n');
}
else {
return fontMetrics.charWidth(charText);
}
}
} <strong> </strong><strong>Output:</strong>
Beispiel #5
2D-Java für Textgrafiken.
Code:
import java.awt.*;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
public class FontsDemo extends Frame {
/**
*
*/
private static final long <em>serialVersionUID</em> = 1L;
public static void main( String[] argv ) {
FontsDemo myExample = new FontsDemo( "Text Graphics" );
}
public FontsDemo( String title ) {
super( title );
setSize( 450, 180 );
addWindowListener( new WindowAdapter() {
public void windowClosing( WindowEvent we ) {
dispose();
System.<em>exit</em>( 0 );
}
} );
setVisible( true );
}
public void paint( Graphics g ) {
Graphics2D graphics = (Graphics2D) g;
FontRenderContext frc = graphics.getFontRenderContext();
Font font = new Font( "Arial", Font.<em>HANGING_BASELINE</em> | Font.<em>BOLD</em>, 72 );
TextLayout tl = new TextLayout( "eduCBA", font, frc );
Shape myShape = tl.getOutline( AffineTransform.<em>getTranslateInstance</em>( 50, 100 ) );
Paint myPaint = loadTextureResource( "1.gif" );
graphics.setPaint( myPaint );
graphics.fill( myShape );
}
public TexturePaint loadTextureResource( String absfilename ) {
MediaTracker tracker = new MediaTracker( this );
Image imtexture = Toolkit.getDefaultToolkit().getImage( absfilename );
tracker.addImage( imtexture, 0 );
try {
tracker.waitForID( 0 );
int width = imtexture.getWidth( this );
int height = imtexture.getHeight( this );
System.<em>out</em>.println( "width" + width + " height =" + height );
BufferedImage buffImg = new
BufferedImage( width, height, BufferedImage.<em>TYPE_INT_ARGB</em> );
Graphics g = buffImg.getGraphics();
g.drawImage( imtexture, 0, 0, this );
return new TexturePaint( buffImg, new Rectangle2D.Double( 0, 0, width, height ) );
}
catch( Exception e ) {
System.<em>out</em>.println( "Exception on Image-Texture Loading" );
}
return null;
}
}
Ausgabe:
Fazit
Da wir nun am Ende des Artikels angelangt sind, hoffe ich, dass Sie eine gute Vorstellung davon haben, was Sie mit der Java 2D-Grafik erreichen können. Ehrlich gesagt sind die Fähigkeiten von Java 2D-Klassen nicht auf einfache Formen und Figuren beschränkt; Es kann erweitert werden, um komplexe Figuren und geometrische Formen zu entwerfen, und hängt hauptsächlich davon ab, wie Sie die vorhandenen Klassen und Methoden nutzen.
Das obige ist der detaillierte Inhalt von2D-Grafiken in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!