Line.java

package model.drawables;

import java.awt.Graphics;

/**
 * Klasse, die eine Linie repräsentiert. Eine Linie besteht aus zwei
 * Punkten. Diese Punkte dienen als Start- und Endpunkt fuer den Bresenham
 * Algorithmus.
 * 
 * @author Nicolas Neubauer
 */
// TODO: (A1) Klasse vervollständigen
public class Line extends DrawableObject {
	private Point start_point;
	private Point end_point;

    protected Point getStartPoint() {return start_point;}
    protected Point getEndPoint() {return end_point;}
    protected int x;
    protected int y;
	/**
	 * Konstruktor zum Erzeugen eines Linienobjektes
	 * 
	 * @param a
	 *            Startpunktes
	 * @param e
	 *            Endpunktes
	 */
	public Line(Point a, Point e) {
		start_point = a;
		end_point = e;
	}

	/**
	 * Paint-Methode der Linienklasse Nutzt den Bresenham-Algorithmus
	 * 
	 * @param g
	 *            der Graphikkontext, in den das Objekt gezeichnet werden soll
	 */
	public void paint(Graphics g) {
		// TODO: (A1) Bresenham mit Hilfe von `setPixel()` aus der
		// Superklasse implementieren
		int dy = end_point.y - start_point.y;
		int dx = end_point.x - start_point.x;

		x = start_point.x;
		y = start_point.y;

        int sig_x = signumfunc(dx); //wasn't sure if Math import is allowed
        int sig_y = signumfunc(dy);


        if (Math.abs(dy) < Math.abs(dx)) {
            int error = -Math.abs(dx);
            int d = 2*Math.abs(dy);
            int step = 2*error;

            while (x != end_point.x) {
                error = drawPointX(sig_x,sig_y,step,d,error,g,true);
            }

        } else {
            int error = -Math.abs(dy);
            int d = 2*Math.abs(dx);
            int step = 2*error;

            while (y != end_point.y) {
                error = drawPointY(sig_x,sig_y,step,d,error,g,true);
            }
        }
        setPixel(x,y,g);
    }
    /**
     * draws for every x-coordinate
     * @param sig_x signum of dx
     * @param sig_y signum of dy
     * @param step step to increase error
     * @param d delta
     * @param error error value
     * @param g graphics
     * @return new error value
     */
    protected int drawPointX(int sig_x, int sig_y, int step, int d, int error, Graphics g, boolean draw) {
        if (draw)
            setPixel(x,y,g);
        x += sig_x;
        error += d;
        if (error > 0) {
            y += sig_y;
            error += step;
        }
        return error;
    }

    /**
     * draws for every y-coordinate
     * @param sig_x signum of dx
     * @param sig_y signum of dy
     * @param step step to increase error
     * @param d delta
     * @param error error value
     * @param g graphics
     * @return new error value
     */
    protected int drawPointY(int sig_x, int sig_y, int step, int d, int error, Graphics g, boolean draw) {
        if (draw)
            setPixel(x,y,g);
        y += sig_y;
        error += d;
        if (error > 0) {
            x += sig_x;
            error += step;
        }
        return error;
    }

    /**
     * checks sign of value and returns result.
     * can also be found in Math.sign().
     * @param x int to check for sign.
     * @return 1 on greater then 0, -1 on smaller then 0 else 0.
     */
	protected int signumfunc(int x) {
        return (x > 0) ? 1 : (x < 0) ? -1 : 0;
	}

}