OUCH!

Use Braces!

It's not that much effort, and your code becomes more readable and less prone to bugs:

public static Direction vectorToDirection(Vector2 vector) {
    if (vector.y >= 0) {
        if (vector.x >= 0) return NORTH_EAST;
        else return NORTH_WEST;
    } else {
        if (vector.x >= 0) return SOUTH_EAST;
        else return SOUTH_WEST;
    }
}

Becomes (with eclipse Ctrl + Shift + F:

public static Direction vectorToDirection (Vector2 vector) {
     if (vector.y >= 0) {
         if (vector.x >= 0) {
             return NORTH_EAST;
         } else {
             return NORTH_WEST;
         }
      } else {
         if (vector.x >= 0) {
             return SOUTH_EAST;
         } else {
             return SOUTH_WEST;
         }
     }
}

And suddenly it becomes extremely obvious and readable what happens here.

Naming:

Additionally I'd consider naming your method fromVector() instead. Compare:

Direction.vectorToDirection(someVector);

against

Direction.fromVector(someVector);

It's not like you're gonna run a static import on your Direction enum, right?

Documentation:

Well when I see the implementation I know, but... How is anyone outside supposed to know you prefer east > west and north > south? Write some JavaDoc. Example:

/**
* @param vector the 2-dimensional vector to be converted to a direction
* @returns The Direction. hereby North is preferred over South and 
* East is preferred over West. 
* Example: Direction.fromVector(new Vector2(0, 0)); will return NORTH_EAST
* Direction.fromVector(new Vector2(-1, 0)); will return SOUTH_EAST
*/
public static Direction fromVector(Vector2 vector) {
// ...

You can always go for branchless code:

// 1 = negative
// 0 = positive
public static int isNegative(float val) {
    return (Float.floatToIntBits(val)) >>> 31;
}

public enum Direction {
    NORTH_EAST, NORTH_WEST, SOUTH_EAST, SOUTH_WEST;
    //I had to reorder the directions (or use index mapping)

    public static Direction vectorToDirection(Vector2 vector) {
        int index = 2 * isNegative(vector.y) + isNegative(vector.x);
        return Direction.values()[index];
    }
}