Anti-aliased Line | Xiaolin Wu's algorithm

import java.awt.*;
import java.awt.image.BufferedImage;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.ImageIcon;

// Class to represent a pixel
class Pixel {
    int x, y;
    float brightness;

    public Pixel(int x, int y, float brightness) {
        this.x = x;
        this.y = y;
        this.brightness = brightness;
    }
}

public class Main extends JFrame {

    private BufferedImage canvas;

    // Constructor to set up the canvas and the JFrame
    public Main() {
        canvas = new BufferedImage(640, 480, BufferedImage.TYPE_INT_ARGB);
        setContentPane(new JLabel(new ImageIcon(canvas)));
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setSize(640, 480);
        setLocationRelativeTo(null);
        setVisible(true);
    }

    // Method to draw a pixel on the canvas with a given brightness
    // 0 <= brightness <= 1
    public void drawPixel(int x, int y, float brightness) {
        int c = (int)(255 * brightness);
        int color = new Color(c, c, c).getRGB();
        canvas.setRGB(x, y, color);
    }

    // Method to swap two integers
    public void swap(Pixel p1, Pixel p2) {
        Pixel temp = new Pixel(p1.x, p1.y, p1.brightness);
        p1.x = p2.x;
        p1.y = p2.y;
        p1.brightness = p2.brightness;
        p2.x = temp.x;
        p2.y = temp.y;
        p2.brightness = temp.brightness;
    }

    // Method to get the absolute value of a number
    public float absolute(float x) {
        if (x < 0) return -x;
        else return x;
    }

    // Method to get the integer part of a floating point number
    public int iPartOfNumber(float x) {
        return (int)x;
    }

    // Method to round off a number
    public int roundNumber(float x) {
        return iPartOfNumber(x + 0.5f);
    }

    // Method to get the fractional part of a number
    public float fPartOfNumber(float x) {
        if (x > 0) return x - iPartOfNumber(x);
        else return x - (iPartOfNumber(x)+1);
    }

    // Method to get 1 - fractional part of number
    public float rfPartOfNumber(float x) {
        return 1 - fPartOfNumber(x);
    }

    // Method to draw an anti-aliased line
    public void drawAALine(int x0, int y0, int x1, int y1) {
        boolean steep = absolute(y1 - y0) > absolute(x1 - x0);

        Pixel p1 = new Pixel(x0, y0, 1);
        Pixel p2 = new Pixel(x1, y1, 1);

        // Swap the coordinates if slope > 1 or we draw backwards
        if (steep) {
            swap(p1, p2);
        }
        if (p1.x > p2.x) {
            swap(p1, p2);
        }

        // Compute the slope
        float dx = p2.x - p1.x;
        float dy = p2.y - p1.y;
        float gradient = dy / dx;
        if (dx == 0.0)
            gradient = 1;

        float intersectY = p1.y;

        // Main loop
        if (steep) {
            for (int x = p1.x; x <= p2.x; x++) {
                // Pixel coverage is determined by fractional part of y coordinate
                drawPixel(iPartOfNumber(intersectY), x, rfPartOfNumber(intersectY));
                drawPixel(iPartOfNumber(intersectY) - 1, x, fPartOfNumber(intersectY));
                intersectY += gradient;
            }
        } else {
            for (int x = p1.x; x <= p2.x; x++) {
                // Pixel coverage is determined by fractional part of y coordinate
                drawPixel(x, iPartOfNumber(intersectY), rfPartOfNumber(intersectY));
                drawPixel(x, iPartOfNumber(intersectY) - 1, fPartOfNumber(intersectY));
                intersectY += gradient;
            }
        }
    }

    // Driver code
    public static void main(String[] args) {
        Main frame = new Main();
        frame.drawAALine(80, 200, 550, 150);
    }
}