Java Graphics2D: රූප සහ හැඩතල අඳිමු! - Graphics2D SC Guide

අද කාලේ software applications කියන්නේ வெறும் text boxes ටිකක් විතරක් නෙවෙයි නේද? ලස්සන graphics, images, animations නැත්නම් ඉතින් මොකක්ද තියෙන fun එක! Java වලින් මේ වගේ visual වැඩ කරන්න පුලුවන් කියලා දන්නවද? විශේෂයෙන්ම Desktop Applications හදනකොට අපිට අවශ්‍ය විදියට custom UI elements හදාගන්න, graphs අඳින්න, games වලට sprites draw කරන්න වගේ දේවල් වලට Graphics කියන concept එක ගොඩක් වැදගත් වෙනවා.

අද අපි කතා කරමු Java වල Graphics2D කියන powerful tool එක ගැන. Graphics2D පාවිච්චි කරලා කොහොමද ලස්සන හැඩතල (shapes), රේඛා (lines), ඒ වගේම අපේම images අපේ program එක ඇතුලටම ඇඳගන්නේ කියලා.

හරි එහෙනම්, අපි වැඩේට බහිමු!

Graphics2D කියන්නේ මොකක්ද? (What is Graphics2D?)

Java වල visual programming වලට භාවිතා කරන API එක තමයි Abstract Window Toolkit (AWT) සහ Swing කියන්නේ. Graphics2D කියන්නේ මේ AWT Package එකේම තියෙන class එකක්. සරලවම කිව්වොත්, මේක අපිට අපේ program එකේ component එකක් උඩ (උදාහරණයක් විදියට JFrame එකක panel එකක් උඩ) අඳින්න (draw කරන්න) පුලුවන් paintbrush එකක් වගේ tool එකක්.

සාමාන්‍යයෙන් Graphics2D object එකක් අපිට කෙලින්ම create කරන්න බෑ. ඒක අපිට ලැබෙන්නේ JComponent එකක paintComponent method එක හරහා. මේ method එකට Graphics කියන abstract class එකේ object එකක් parameter එක විදියට එනවා. අපි ඒක Graphics2D වලට cast කරලා තමයි පාවිච්චි කරන්නේ. හරියට මෙහෙම:

import javax.swing.*;
import java.awt.*;

public class MyDrawingPanel extends JPanel {

    @Override
    protected void paintComponent(Graphics g) {
        // Super class එකේ paintComponent method එක අනිවාර්යයෙන්ම call කරන්න ඕනේ.
        // මේක නැත්නම් Graphics related issues එන්න පුලුවන්.
        super.paintComponent(g);

        // Graphics object එක Graphics2D වලට cast කරගන්නවා.
        Graphics2D g2d = (Graphics2D) g;

        // දැන් g2d object එක පාවිච්චි කරලා අපිට අඳින්න පුලුවන්!
        // උදාහරණයක් විදියට රතු පාටින් හතරැස් කොටුවක් අඳිමු.
        g2d.setColor(Color.RED);
        g2d.fillRect(50, 50, 100, 100);

        // තව නිල් පාටින් රවුමක් අඳිමු.
        g2d.setColor(Color.BLUE);
        g2d.fillOval(200, 50, 100, 100);
    }

    public static void main(String[] args) {
        JFrame frame = new JFrame("My First Graphics2D Application");
        MyDrawingPanel panel = new MyDrawingPanel();

        // Panel එකේ preferred size එක set කරන්න පුලුවන්
        panel.setPreferredSize(new Dimension(400, 300));
        frame.add(panel);

        frame.pack(); // Content වලට අනුව frame එකේ size එක adjust කරනවා
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLocationRelativeTo(null); // Screen එකේ මැදට ගන්න
        frame.setVisible(true);
    }
}

මේ Code එක run කරලා බැලුවොත් ඔයාලට පේනවා ඇති රතු පාට හතරැස් කොටුවකුයි, නිල් පාට රවුමකුයි screen එකේ ඇඳිලා තියෙනවා. නියමයි නේද!

මූලික හැඩතල අඳිමු (Let's Draw Basic Shapes)

Graphics2D එකෙන් අපිට පුලුවන් විවිධ මූලික හැඩතල (basic shapes) අඳින්න. අපි පොඩ්ඩක් බලමු ඒවට පාවිච්චි කරන methods මොනවද කියලා:

රේඛා (Lines)

රේඛාවක් අඳින්න `drawLine(int x1, int y1, int x2, int y2)` method එක පාවිච්චි කරන්න පුලුවන්. මෙතන `(x1, y1)` කියන්නේ රේඛාවේ ආරම්භක ලක්ෂ්‍යය, `(x2, y2)` කියන්නේ අවසාන ලක්ෂ්‍යය.

g2d.setColor(Color.GREEN);
g2d.drawLine(20, 20, 150, 150); // කොල පාටින් රේඛාවක්

හතරැස් (Rectangles)

හතරැස් කොටු අඳින්න methods දෙකක් තියෙනවා:

• `drawRect(int x, int y, int width, int height)`: මේකෙන් අඳින්නේ හතරැස් කොටුවේ දාරය විතරයි.
• `fillRect(int x, int y, int width, int height)`: මේකෙන් අඳින්නේ හතරැස් කොටුව පාටින් පුරවලා.

මෙතන `(x, y)` කියන්නේ හතරැස් කොටුවේ වම්-ඉහල කෙලවරේ පිහිටීම. `width` සහ `height` කියන්නේ පළල සහ උස.

g2d.setColor(Color.ORANGE);
g2d.drawRect(50, 200, 100, 70); // දාරය විතරක් තැඹිලි පාටින්

g2d.setColor(Color.MAGENTA);
g2d.fillRect(180, 200, 100, 70); // පාටින් පිරවුනු දම් පාට හතරැස් කොටුවක්

වෘත්ත සහ ඉලිප්සාකාර (Ovals/Circles)

වෘත්ත හෝ ඉලිප්සාකාර හැඩතල අඳින්නත් methods දෙකක් තියෙනවා:

• `drawOval(int x, int y, int width, int height)`: මේකෙන් අඳින්නේ ඉලිප්සාකාර හැඩයේ දාරය විතරයි.
• `fillOval(int x, int y, int width, int height)`: මේකෙන් අඳින්නේ ඉලිප්සාකාර හැඩය පාටින් පුරවලා.

මෙතනත් `(x, y)` කියන්නේ ඉලිප්සාකාර හැඩය අඳින සෘජුකෝණාස්‍රයේ වම්-ඉහල කෙලවරේ පිහිටීම. `width` සහ `height` කියන්නේ ඒ සෘජුකෝණාස්‍රයේ පළල සහ උස. වෘත්තයක් අඳින්න ඕන නම් `width` එකයි `height` එකයි දෙකම සමාන වෙන්න ඕනේ.

g2d.setColor(Color.CYAN);
g2d.drawOval(300, 20, 80, 80); // දාරය විතරක් Cyan පාටින් (රවුමක්)

g2d.setColor(Color.YELLOW);
g2d.fillOval(300, 120, 120, 60); // කහ පාටින් පිරවුනු ඉලිප්සාකාර හැඩයක්

ඔයාලට ඕන තරම් පාට වර්ග Graphics2D වලට `Color` class එකෙන් දෙන්න පුලුවන්. එහෙම නැත්නම් `new Color(R, G, B)` විදියට තමන්ට අවශ්‍ය පාට RGB values වලින් හදාගන්නත් පුලුවන්.

Stroke සහ Paint භාවිතය (Using Stroke and Paint)

අපි මේ දක්වා ඇන්දේ සාමාන්‍ය thickness එකකින් යුක්ත රේඛා සහ හැඩතල. Graphics2D වල `setStroke()` method එක පාවිච්චි කරලා අපිට රේඛාවක ඝනකම (thickness) සහ style එක වෙනස් කරන්න පුලුවන්. ඒකට අපි `BasicStroke` class එක පාවිච්චි කරනවා.

g2d.setColor(Color.BLACK);

// ඝනකම වැඩි රේඛාවක්
g2d.setStroke(new BasicStroke(5)); // Line width එක 5 pixels
g2d.drawLine(20, 300, 150, 300);

// කඩ ඉරි සහිත රේඛාවක්
float[] dashingPattern1 = {10, 10}; // 10 pixels line, 10 pixels space
g2d.setStroke(new BasicStroke(2, // Line width
                              BasicStroke.CAP_BUTT, // End-cap style
                              BasicStroke.JOIN_MITER, // Join style
                              10.0f, // Miter limit
                              dashingPattern1, // Dash pattern array
                              0.0f)); // Dash phase
g2d.drawLine(20, 320, 150, 320);

// Stroke එක නැවත default අගයට ගේනවා
g2d.setStroke(new BasicStroke(1)); 

setPaint() method එකෙන් අපිට පුලුවන් solid color එකකට වඩා වැඩි දෙයක් පාවිච්චි කරන්න. උදාහරණයක් විදියට gradient (පාට දෙකක් හෝ වැඩි ගානක් ක්‍රම ක්‍රමයෙන් එකිනෙකට මිශ්‍ර වීම) එකක්, එහෙම නැත්නම් texture එකක් පාවිච්චි කරන්න පුලුවන්. මේක ටිකක් advanced topic එකක්. දැනට අපි solid Colors ගැන අවධානය යොමු කරමු.

රූප අඳිමු (Drawing Images)

අපේ program එක ඇතුලට Images (PNG, JPG වගේ) draw කරගන්න එකත් Graphics2D වලින් පහසුවෙන් කරන්න පුලුවන්. ඒකට අපි `ImageIO` class එක පාවිච්චි කරනවා image එකක් load කරගන්න. ඊට පස්සේ `drawImage()` method එකෙන් ඒක draw කරන්න පුලුවන්.

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

// MyDrawingPanel class එකේ paintComponent method එක ඇතුලේ
// ...

BufferedImage image = null;
try {
    // image.png කියන file එක project folder එකේම තියෙන්න ඕනේ
    // නැත්නම් full path එක දෙන්න (e.g., "C:/Users/YourUser/Desktop/image.png")
    image = ImageIO.read(new File("logo.png")); 
} catch (IOException e) {
    e.printStackTrace();
    System.out.println("Error loading image: " + e.getMessage());
}

if (image != null) {
    // Image එක අඳිනවා (x, y coordinate එකෙන් පටන් අරන්)
    g2d.drawImage(image, 20, 350, this);

    // Image එකේ size එක වෙනස් කරලා අඳින්නත් පුලුවන්
    g2d.drawImage(image, 200, 350, 100, 100, this); // 100x100 pixels වලට resize කරලා අඳිනවා
}

// ...

Image එකක් load කරනකොට `IOException` එකක් එන්න පුලුවන් නිසා `try-catch` block එකක් ඇතුලේ ඒ වැඩේ කරන්න අමතක කරන්න එපා. `logo.png` කියන file එක ඔයාලගේ project එකේ root folder එකේම තියන්න (එහෙම නැත්නම් compile කරපු .jar file එක තියෙන තැන) නැත්නම් image එක load වෙන්නේ නෑ. Image එක load වුනේ නැත්නම් `image` object එක `null` වෙනවා, එතකොට `drawImage` call කරන එකෙන් වළකින්න `if (image != null)` check එකක් දාන්න පුරුදු වෙන්න.

ප්‍රායෝගික උපදෙස් සහ හොඳම භාවිතයන් (Practical Tips and Best Practices)

• `super.paintComponent(g)`: මේ method call එක අනිවාර්යයෙන්ම `paintComponent` method එකේ මුලින්ම තියෙන්න ඕනේ. මේකෙන් component එක කලින් ඇඳපු දේවල් clear කරලා අලුතින් draw කරන්න අවශ්‍ය පසුබිම සකස් කරනවා.
• සම්බන්ධීකරණ පද්ධතිය (Coordinate System): Java වල Graphics2D වලදී, `(0,0)` කියන්නේ drawing area එකේ වම්-ඉහළ කෙලවර. X අගය වැඩි වෙද්දී දකුණට යනවා, Y අගය වැඩි වෙද්දී පහලට යනවා. මේක මතක තියාගන්න.
• Repainting: ඔයාලගේ component එකේ content එක වෙනස් වෙනවා නම් (උදාහරණයක් විදියට animation එකක් වගේ) ඔයාලට `repaint()` method එක call කරන්න ඕනේ. මේකෙන් `paintComponent` method එක නැවත call කරනවා, එතකොට අලුත් content එක draw වෙනවා.
• Anti-aliasing: Graphics2D වලින් අඳිනකොට රේඛා වල, හැඩතල වල දාර ටිකක් රළු (jagged) පේන්න පුලුවන්. ඒක smoothen කරන්න පුලුවන් Rendering Hints පාවිච්චි කරලා.
• Double Buffering: ගොඩක් complex drawings කරනකොට නැත්නම් animations කරනකොට screen එක flicker වෙන්න පුලුවන්. ඒක වළක්වන්න Double Buffering කියන concept එක පාවිච්චි කරනවා. Swing components වලට මේක default විදියටම enable වෙලා තියෙනවා, ඒ නිසා ගොඩක් වෙලාවට අපිට මේ ගැන හිතන්න ඕනේ නෑ.

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                     RenderingHints.VALUE_ANTIALIAS_ON);

නිගමනය (Conclusion)

ඉතින් යාළුවනේ, Java වල Graphics2D කියන්නේ නිකන්ම නිකන් tool එකක් නෙවෙයි, ඒක Art Studio එකක් වගේ. අපි අද කතා කරපු දේවල් පාවිච්චි කරලා ඔයාලට පුළුවන් ඔයාලගේම applications වලට ලස්සන visual elements එකතු කරන්න. පොඩි පොඩි දේවල් වලින් පටන් අරන්, මේකත් එක්ක පොරබදලා බලන්න! ඔයාලගේ project වලට මේ concept එක integrate කරලා බලන්න. ඒකෙන් ඔයාලගේ applications වලට අලුත් පෙනුමක් ලැබෙයි.

ඔයාලට මේ ගැන තව මොනවා හරි දැනගන්න ඕන නම්, නැත්නම් ඔයාලගේ අත්දැකීම් share කරන්න ඕන නම්, නැත්නම් මේ ලිපියේ මොනවා හරි අඩුපාඩුවක් තියෙනවා නම් පහලින් comment එකක් දාගෙනම යන්න. අලුත් ලිපියකින් හමුවෙමු! Happy Coding!