Create line extensions for given line created by u

I've been working in an app which I have to capture user's touches and draw a line on the screen. This is working so far.

The problem is that I'd like to create some kind of extension for that line that goes from the line start/end to the screen boundaries. It's important to that extension be aligned to the main line.

I've been trying to accomplish this for some days but without positive results. My idea was to use some kind of linear equation to represent the line and after create two point lying on the line and on the screen boundaries. The first problem I faced was with vertical lines.

y = m * x + b
slope = (y2 - y2)/(x2 - x1)
y_intercept = b = y - m * x

Also the user can create lines in any direction and orientation.

I tried to use these equations to find arbitrary points (x = 0, y = 0, x = 320, y = 480) but I got some strange issues like in the figures bellow.

a) Lines going really further the limit of the screen. This caused the app almost crash.

b) Also I couldn't identify how to link each new point with the current touch points.

Code

import Foundation
import UIKit





public class TestView : UIView
{
    var lineLayer : CAShapeLayer?
    var lineExtensionALayer : CAShapeLayer?
    var lineExtensionBLayer : CAShapeLayer?

    var startPoint : CGPoint?
    var endPoint : CGPoint?

    override init(frame: CGRect){
        super.init(frame:frame)

        self.backgroundColor = UIColor.clearColor()

        self.lineLayer = self.createLine(color: UIColor.redColor())
        self.lineExtensionALayer = self.createLine(color: UIColor.greenColor())
        self.lineExtensionBLayer = self.createLine(color: UIColor.blueColor())
    }

    required public init(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

    public override func touchesBegan(touches: Set<NSObject>, withEvent event: UIEvent) {
        let touch : UITouch = touches.first as! UITouch
        let position = touch.locationInView(self)

        self.startPoint = position
    }

    public override func touchesCancelled(touches: Set<NSObject>!, withEvent event: UIEvent!) {

    }

    public override func touchesEnded(touches: Set<NSObject>, withEvent event: UIEvent) {

    }

    public override func touchesMoved(touches: Set<NSObject>, withEvent event: UIEvent) {

        let touch : UITouch = touches.first as! UITouch
        let position = touch.locationInView(self)

        self.endPoint = position

        self.updateLine()
    }


    func createLine(color selectedColor : UIColor) -> CAShapeLayer
    {
        let line = CAShapeLayer()
        line.frame = self.bounds
        line.strokeColor = selectedColor.CGColor
        line.fillColor = nil
        line.lineWidth = 2

        self.layer.addSublayer(line)

        return line
    }

    func drawLine(line lineToDraw : CAShapeLayer,start pointA : CGPoint, end pointB : CGPoint)
    {
        let path = UIBezierPath()
        path.moveToPoint(pointA)
        path.addLineToPoint(pointB)

        lineToDraw.path = path.CGPath
    }

    func updateLine(){

        var line = LineFunction(point1: self.startPoint!, point2: self.endPoint!)

        // Draw main line.
        self.drawLine(line: self.lineLayer!, start: self.startPoint!, end: self.endPoint!)
    }
}

Taken from this answer, translated to swift and altered a bit:

func getLines(xmin: CGFloat, ymin: CGFloat, xmax: CGFloat, ymax: CGFloat, x1: CGFloat, x2: CGFloat, y1: CGFloat, y2: CGFloat) -> (CGPoint, CGPoint) {
    if y1 == y2 {
        return (CGPoint(x: xmin, y: y1), CGPoint(x: xmax, y: y1))
    }
    if x1 == x2 {
        return (CGPoint(x: x1, y: ymin), CGPoint(x: x1, y: ymax))
    }

    let y_for_xmin = y1 + (y2 - y1) * (xmin - x1) / (x2 - x1)
    let y_for_xmax = y1 + (y2 - y1) * (xmax - x1) / (x2 - x1)

    let x_for_ymin = x1 + (x2 - x1) * (ymin - y1) / (y2 - y1)
    let x_for_ymax = x1 + (x2 - x1) * (ymax - y1) / (y2 - y1)

    if ymin <= y_for_xmin && y_for_xmin <= ymax {
        if xmin <= x_for_ymax && x_for_ymax <= xmax {
            return (CGPoint(x: xmin, y: y_for_xmin), CGPoint(x: x_for_ymax, y: ymax))
        }
        if xmin <= x_for_ymin && x_for_ymin <= xmax {
            return (CGPoint(x: xmin, y: y_for_xmin), CGPoint(x: x_for_ymin, y: ymin))
        }
        return (CGPoint(x: xmin, y: y_for_xmin), CGPoint(x: xmax, y: y_for_xmax))
    }

    if ymin <= y_for_xmax && y_for_xmax <= ymax {
        if xmin <= x_for_ymin && x_for_ymin <= xmax {
            return (CGPoint(x: x_for_ymin, y: ymin), CGPoint(x: xmax, y: y_for_xmax))
        }
        if xmin <= x_for_ymax && x_for_ymax <= xmax {
            return (CGPoint(x: x_for_ymax, y: ymax), CGPoint(x: xmax, y: y_for_xmax))
        }
        return (CGPoint(x: xmin, y: y_for_xmin), CGPoint(x: xmax, y: y_for_xmax))
    }

    return (CGPoint(x: x_for_ymin, y: ymin), CGPoint(x: x_for_ymax, y: ymax))
}

func updateLine(){
    let x1 = self.startPoint!.x
    let x2 = self.endPoint!.x
    let y1 = self.startPoint!.y
    let y2 = self.endPoint!.y

    let (start, end) = getLines(0, ymin: 0, xmax: bounds.width, ymax: bounds.height, x1: x1, x2: x2, y1: y1, y2: y2)

    print(start, appendNewline: false)
    print(" - ", appendNewline: false)
    print(end)

    // Draw main line.
    self.drawLine(line: self.lineLayer!, start: start, end: end)
}

Unfortunately that is not fully functional yet since in half of the cases the returned if-construct for returning the correct extended line is not returning anything useful. I will try to fix this either now or tomorrow.

~~But it should get you started~~

Edit: seems to not be working if both the start and the endpoint would be on either the horizontal or vertical axis. it works if they are on different axes.

After I added three more return statements the code is now fully functional :)

If you take a look at the logged information you will see that the drawn line actually extends exactly to the bounds, not a bit further.