Three-pointer! But what kind? From http://en.wikipedia.org/wiki/Triangle:


Write a program that takes three 2d coordinate tuples (Cartesian), and classifies what shape these three points describe.
In almost all cases these points will describe a triangle of varying types.  In some degenerate cases, the points will either describe a singular point or a straight line.  The program will determine which of the following tags apply to the described shape:

Point         (3 points are co-incident)
Line          (3 points lie on a straight line - no more than 2 points may be co-incident)
Equilateral   (3 sides equal, 3 angles equal)
Isosceles     (2 sides equal, 2 angles equal)
Scalene       (0 sides equal, 0 angles equal)
Right         (1 angle exactly π/2 (or 90°))
Oblique       (0 angles exactly π/2 (or 90°))
Obtuse        (1 angle &gt; π/2 (or 90°))
Acute         (3 angles &lt; π/2 (or 90°))

Note that for some described shapes, more than one of the above tags will apply.  For example, any right-angled will also either be isosceles or scalene.
Input

The program may read the 3 input coordinates from STDIN, command-line, environment variables or whatever method is convenient for your language of choice.
The input co-ordinates my be formatted however is convenient for your language of choice.  It can be assumed that all input numbers are well-formed with respect to the datatypes you end up using.
Nothing can be assumed about the ordering of the input coordinates.

Output

The program will output to STDOUT, dialog box or whatever display method is convenient for your language of choice.
The output will display all the tags applicable to the shape described by the input coordinates.
Tags may be output in any order.

Other Rules

Your language's trigonometric libraries/APIs are allowed, but any APIs that specifically calculate triangle types are banned.
When determining equality of angles or lengths of sides, you will likely end up comparing floating-point values.  Two such values are to be considered &quot;equal&quot; if one is within 1% of the other.
Standard “loopholes” which are no longer funny
This is code-golf, so the shortest answer in bytes wins.

Examples
Input                   Output
(1,2) (1,2) (1,2)       Point
(1,2) (3,4) (5,6)       Line
(0,0) (1,1) (2,0)       Isosceles Right
(0,0) (2,1) (10,1)      Scalene Oblique Obtuse
C (451 bytes)

Uses only squared lengths and slopes.

p[2],q[2],r[2];z(c){char*y[]={"Line","Point","Isosceles ","Equilateral ","Scalene ","Right","Oblique ","Acute","Obtuse"};printf(y[c]);}d(int*a,int*b){int c=*a++-*b++,e=*a-*b;return c*c+e*e;}main(){scanf("%d%d%d%d%d%d",p,p+1,q,q+1,r,r+1);int a=d(p,q),b=d(q,r),c=d(r,p),e=!a+!b+!c,f=(a==b)+(b==c)+(c==a),g=a&gt;b&amp;&amp;b&gt;c?a:b&gt;c?b:c,h=g^a?g^b?a+b:c+a:b+c;e?z(e/2):(1[q]-1[p])*(*r-*q)^(1[r]-1[q])*(*q-*p)?f?z(2+f/2),f-1&amp;&amp;z(2):z(4),h^g?z(6),z(7+(h&lt;g)):z(5):z(0);}


Ungolfed (and ternary operator replaced with if/else):

int p[2],q[2],r[2];

void print(c){
    char *y[]={"Line","Point","Isosceles ","Equilateral ","Scalene ","Right","Oblique ","Acute","Obtuse"};
    printf(y[c]);
}
squared_distance(int *a,int *b){
    int c = *a++ - *b++, e = *a - *b;
    return c*c+e*e;
}
main(){
    scanf("%d%d%d%d%d%d",p,p+1,q,q+1,r,r+1); // read in coordinates
    int a = squared_distance(p,q),b = squared_distance(q,r),c = squared_distance(r,p),
    e=!a+!b+!c, // number of sides of length 0
    f=(a==b)+(b==c)+(c==a), // number of equal-length pairs
    g = a &gt; b &amp;&amp; b &gt; c ? a : (b &gt; c ? b : c), // longest side
    h = g != a ? g != b ? a + b : c + a : b + c; // sum of squares of length of other two sides
    if(e)
        print(e/2); // 1 side of len 0: line, 3 sides: point
    // comparing slopes PQ and QR
    else if((q[1]-p[1])*(*r-*q) != (r[1]-q[1])*(*q-*p)){ // not line
        if(f){
            print(2+f/2); // 1 pair of equal length sides: isosceles, 3: equilateral
            if(f-1) print(2); // equilateral therefore also isosceles
        }else print(4); // 0: scalene
        if(h!=g){ // a^2+b^2!=c^2: not right
            print(6); // oblique
            print(7+(h&lt;g)); // a^2+b^2&lt;c^2:obtuse, acute otherwise 
        }else print(5); // right
    }else
        print(0); // line
}


Input (through stdin) Format: x y x y x y

ex. 0 0 1 1 2 0 for Isosceles Right