The "whereAboutSegment" function will return a String this time, with more detailed info of the Point's where-a-abouts instead of just knowing if its behind a line.

 
/*-----------------------------------------------------------------
Returns a String describing where Point P is relevant to line CD:
"left","right","front" or "behind"
If Point P is a Point on line CD, an empty String is returned.
 ----------------------------------------------------------------*/
function whereAboutSegment(P:Point,C:Point,D:Point):String
{
	var F:Point;
	var G:Point;
	var s:Boolean;
	var l:Boolean;
	var r:Boolean;
	var f:Boolean;
	var a:Number=Point.distance(P,C.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI / 2)));
	var b:Number=Point.distance(P,C.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI / 2)));
	s = a == b;
	if (a < b) {
		f=true;
	}
	F=C.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	G=C.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	a=Point.distance(P,F.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI)));
	b=Point.distance(P,G.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI)));
	if (a < b) {
		r=true;
	}
	F=D.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	G=D.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI));
	a=Point.distance(P,F.add(Point.polar(1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI )));
	b=Point.distance(P,G.add(Point.polar(-1,Math.atan2(C.y - D.y,C.x - D.x) + Math.PI)));
	if (a > b) {
		l=true;
	}
	if (s && l && r) {
		return "";
	}
	if (!f && l && r) {
		return "behind";
	}
	if (f && l && r) {
		return "front";
	}
	if (l) {
		return "left";
	}
	if (r) {
		return "right";
	}
	return "";
}
 

 
 
/*---------------------------------------------------------------------------
Returns Array of intersection Points on a quadratic curve.
An empty Array is returned if no intersection is found.
 
Parameters:
A		-Start Point of a segment to make intersection.
B		-End Point of a segment to make intersection.
sp		-Start Point of curve.
cp		-Control Point of curve.
ep		-End Point of curve.
rez		-The resolution of curve tests
Note: Uses another function for testing the intersections:
 
http://keith-hair.net/blog/2008/08/04/find-intersection-point-of-two-lines-in-as3/
 
----------------------------------------------------------------------------*/
function lineToQCurve_Intersect(A:Point,B:Point,sp:Point,cp:Point,ep:Point,rez:Number=80):Array
{
	//rez less than 2 is almost "Pointless" LOL.
	var low:Number=2;
	var high:Number=99; //100 causes infinite loop.
	rez=Math.min(Math.max(Math.min(low,high),rez),high);
	var t:Number=0;
	var ft:Number=0;
	var n:Number=99/rez;
	var C:Point=new Point();
	var D:Point=new Point();
	var L:Point=new Point();
	var ip:Point;
	var a:Array=[];
	//test possible segment intersections in a loop.
	var z:int=100;
	while (z > -1)
	{
		t=z/100;
		C.x=Math.pow(1-t,2)*sp.x+2*(1-t)*t*cp.x+Math.pow(t,2)*ep.x;
		C.y=Math.pow(1-t,2)*sp.y+2*(1-t)*t*cp.y+Math.pow(t,2)*ep.y;
		D=L;//Connect start to last end point
		L=C.clone();
		if (z == 100) {
			D=ep.clone();
		}
		ip=lineIntersectLine(A,B,C,D);
		if (ip != null) {
			a.push(ip);
			if(a.length == 2){
				break;
			}
		}
		z-=n;
	}
	return a;
}
 

This uses the "lineIntersectLine" function of the earlier post.

 
/*---------------------------------------------------------------------------
Returns an Object with the following properties:
intersects        -Boolean indicating if an intersection exists.
start_inside      -Boolean indicating if Point A is inside of the polygon.
end_inside       -Boolean indicating if Point B is inside of the polygon.
intersections    -Array of intersection Points along the polygon.
centroid          -A Point indicating "center of mass" of the polygon.
 
"pa" is an Array of Points.
----------------------------------------------------------------------------*/
function lineIntersectPoly(A : Point, B : Point, pa:Array):Object {
	var An:int=1;
	var Bn:int=1;
	var C:Point;
	var D:Point;
	var i:Point;
	var cx:Number=0;
	var cy:Number=0;
	var result:Object = new Object();
	pa.push(pa[0]);
	result.intersects = false;
	result.intersections=[];
	result.start_inside=false;
	result.end_inside=false;
	var n:int=pa.length-1;
	while(n > -1){
		C=Point(pa[n]);
		if(n > 0){
			cx+=C.x;
			cy+=C.y;
			D=Point(pa[n-1])||Point(pa[0]);
			i=lineIntersectLine(A,B,C,D);
			if(i != null){
				result.intersections.push(i);
			}
			if(lineIntersectLine(A,new Point(C.x+D.x,A.y),C,D) != null){
				An++;
			}
			if(lineIntersectLine(B,new Point(C.x+D.x,B.y),C,D) != null){
				Bn++;
			}
		}
		n--;
	}
	if(An % 2 == 0){
		result.start_inside=true;
	}
	if(Bn % 2 == 0){
		result.end_inside=true;
	}
	result.centroid=new Point(cx/(pa.length-1),cy/(pa.length-1));
	result.intersects = result.intersections.length > 0;
	return result;
}
 

 
/*---------------------------------------------------------------------------
Returns an Object with the following properties:
	enter			-Intersection Point entering the circle.
	exit			-Intersection Point exiting the circle.
	inside			-Boolean indicating if the points of the line are inside the circle.
	tangent		-Boolean indicating if line intersect at one point of the circle.
	intersects		-Boolean indicating if there is an intersection of the points and the circle.
 
If both "enter" and "exit" are null, or "intersects" == false, it indicates there is no intersection.
 
This is a customization of the intersectCircleLine Javascript function found here:
 
http://www.kevlindev.com/gui/index.htm
 
----------------------------------------------------------------------------*/
function lineIntersectCircle(A : Point, B : Point, C : Point, r : Number = 1):Object {
	var result : Object = new Object ();
	result.inside = false;
	result.tangent = false;
	result.intersects = false;
	result.enter=null;
	result.exit=null;
	var a : Number = (B.x - A.x) * (B.x - A.x) + (B.y - A.y) * (B.y - A.y);
	var b : Number = 2 * ((B.x - A.x) * (A.x - C.x) +(B.y - A.y) * (A.y - C.y));
	var cc : Number = C.x * C.x + C.y * C.y + A.x * A.x + A.y * A.y - 2 * (C.x * A.x + C.y * A.y) - r * r;
	var deter : Number = b * b - 4 * a * cc;
	if (deter <= 0 ) {
		result.inside = false;
	} else {
		var e : Number = Math.sqrt (deter);
		var u1 : Number = ( - b + e ) / (2 * a );
		var u2 : Number = ( - b - e ) / (2 * a );
		if ((u1 < 0 || u1 > 1) && (u2 < 0 || u2 > 1)) {
			if ((u1 < 0 && u2 < 0) || (u1 > 1 && u2 > 1)) {
				result.inside = false;
			} else {
				result.inside = true;
			}
		} else {
			if (0 <= u2 && u2 <= 1) {
				result.enter=Point.interpolate (A, B, 1 - u2);
			}
			if (0 <= u1 && u1 <= 1) {
				result.exit=Point.interpolate (A, B, 1 - u1);
			}
			result.intersects = true;
			if (result.exit != null && result.enter != null && result.exit.equals (result.enter)) {
				result.tangent = true;
			}
		}
	}
	return result;
}
 

//---------------------------------------------------------------
//Checks for intersection of Segment if as_seg is true.
//Checks for intersection of Line if as_seg is false.
//Return intersection of Segment AB and Segment EF as a Point
//Return null if there is no intersection
//---------------------------------------------------------------
function lineIntersectLine(A:Point,B:Point,E:Point,F:Point,as_seg:Boolean=true):Point {
    var ip:Point;
    var a1:Number;
    var a2:Number;
    var b1:Number;
    var b2:Number;
    var c1:Number;
    var c2:Number;

    a1= B.y-A.y;
    b1= A.x-B.x;
    c1= B.x*A.y - A.x*B.y;
    a2= F.y-E.y;
    b2= E.x-F.x;
    c2= F.x*E.y - E.x*F.y;

    var denom:Number=a1*b2 - a2*b1;
    if (denom == 0) {
        return null;
    }
    ip=new Point();
    ip.x=(b1*c2 - b2*c1)/denom;
    ip.y=(a2*c1 - a1*c2)/denom;

    //---------------------------------------------------
    //Do checks to see if intersection to endpoints
    //distance is longer than actual Segments.
    //Return null if it is with any.
    //---------------------------------------------------
    if(as_seg){
        if(Math.pow(ip.x - B.x, 2) + Math.pow(ip.y - B.y, 2) > Math.pow(A.x - B.x, 2) + Math.pow(A.y - B.y, 2))
        {
           return null;
        }
        if(Math.pow(ip.x - A.x, 2) + Math.pow(ip.y - A.y, 2) > Math.pow(A.x - B.x, 2) + Math.pow(A.y - B.y, 2))
        {
           return null;
        }

        if(Math.pow(ip.x - F.x, 2) + Math.pow(ip.y - F.y, 2) > Math.pow(E.x - F.x, 2) + Math.pow(E.y - F.y, 2))
        {
           return null;
        }
        if(Math.pow(ip.x - E.x, 2) + Math.pow(ip.y - E.y, 2) > Math.pow(E.x - F.x, 2) + Math.pow(E.y - F.y, 2))
        {
           return null;
        }
    }
    return ip;
}