Trouble with Graham's Scan

Question

currently working on with Graham's Scan in conjunction with Convex HUll. I am a student, so I am trying to get it done myself, however I've been sifting through multiple sites to find an answer. In short I have my constructors, one from a file and one randomly generated, working so I am able to create an array of points. The next step is to implement quicksort, sorting by Polar angles. This is done via a comparator class. The comparator class is where I am stuck, we are told to use dot compare and cross compare to do the comparisons of the angles but I am pretty lost.

/**
 * Use cross product and dot product to implement this method.  Do not take square roots 
 * or use trigonometric functions. See the PowerPoint notes on how to carry out cross and 
 * dot products. 
 * 
 * Call comparePolarAngle() and compareDistance(). 
 * 
 * @param p1
 * @param p2
 * @return -1 if one of the following three conditions holds: 
 *                a) p1 and referencePoint are the same point but p2 is a different point; 
 *                b) neither p1 nor p2 equals referencePoint, and the polar angle of 
 *                   p1 with respect to referencePoint is less than that of p2; 
 *                c) neither p1 nor p2 equals referencePoint, p1 and p2 have the same polar 
 *                   angle w.r.t. referencePoint, and p1 is closer to referencePoint than p2. 
 *         0  if p1 and p2 are the same point  
 *         1  if one of the following three conditions holds:
 *                a) p2 and referencePoint are the same point but p1 is a different point; 
 *                b) neither p1 nor p2 equals referencePoint, and the polar angle of
 *                   p1 with respect to referencePoint is greater than that of p2;
 *                c) neither p1 nor p2 equals referencePoint, p1 and p2 have the same polar
 *                   angle w.r.t. referencePoint, and p1 is further to referencePoint than p2. 
 *                   
 */
public int compare(Point p1, Point p2){
    if(p1 == referencePoint && p2 != referencePoint){
        return -1;
    } else if(p1 == p2){
        return 0;
    } else {

    }
    return 0; 
}


/**
 * Compare the polar angles of two points p1 and p2 with respect to referencePoint.  Use 
 * cross products.  Do not use trigonometric functions. 
 * 
 * Precondition:  p1 and p2 are distinct points. 
 * 
 * @param p1
 * @param p2
 * @return   -1  if p1 equals referencePoint or its polar angle with respect to referencePoint
 *               is less than that of p2. 
 *            0  if p1 and p2 have the same polar angle. 
 *            1  if p2 equals referencePoint or its polar angle with respect to referencePoint
 *               is less than that of p1. 
 */
public int comparePolarAngle(Point p1, Point p2){
    // TODO 
    return 0; 
}


/**
 * Compare the distances of two points p1 and p2 to referencePoint.  Use dot products. 
 * Do not take square roots. 
 * 
 * @param p1
 * @param p2
 * @return   -1   if p1 is closer to referencePoint 
 *            0   if p1 and p2 are equidistant to referencePoint
 *            1   if p2 is closer to referencePoint
 */
public int compareDistance(Point p1, Point p2){
    int distance = 0;

    return distance; 
}

That's the whole of it, I just kind of went through little things on the compare method before just getting stuck.

The quickSort and partition methods are pretty standard, but I will add them so you guys can get a broad spectrum look at everything:

/**
 * Sort the array points[] in the increasing order of polar angle with respect to lowestPoint.  
 * Use quickSort.  Construct an object of the pointComparator class with lowestPoint as the 
 * argument for point comparison.  
 * 
 * Ought to be private, but is made public for testing convenience.   
 */
public void quickSort(){

    // TODO 
}


/**
 * Operates on the subarray of points[] with indices between first and last. 
 * 
 * @param first  starting index of the subarray
 * @param last   ending index of the subarray
 */
private void quickSortRec(int first, int last){

    // TODO
}


/**
 * Operates on the subarray of points[] with indices between first and last.
 * 
 * @param first
 * @param last
 * @return
 */
private int partition(int first, int last){

    // TODO 
    return 0; 
}

I know I essentially need to get the Compare class up and running before I can get the quicksort method going, but I feel like I don't know how to even use the dot / cross compare at all so am feeling really lost.

If anyone would be willing to help, I would be very grateful! Thank you very much for looking, have a great evening.

Answer 1

In all of these methods, when you need to see if two Point objects are equal you should use Point's equals method, not "==" :

if(p1.equals(p2)) {
    //code
}

Implementing compare

Notice that your compare method needs to use equals(), comparePolarAngle(), and compareDistance() in it's implementation. Also the last set of conditions (return 1) can just be taken care of in an else statement.

public int compare(Point p1, Point p2) {
   if(p1.equals(p2)) {
      return 0;
   }
   else if(p1.equals(referencePoint) ||
          (!p1.equals(referencePoint) && !p2.equals(referencePoint) && comparePolarAngle(p1, p2) == -1) ||
          (!p1.equals(referencePoint) && !p2.equals(referencePoint) && comparePolarAngle(p1, p2) == 0 && compareDistance(p1, p2) == -1))
   {
      return -1;
   }
   else {
      return 1;
   }
}

Implementing compareDistance

The main piece of information that we need here is how to determine the length of the vector from referencePoint to a Point object using only dot products. First, lets implement a helper method that takes two Points as input and returns the dot product as an integer value.

private int dotProduct(Point p1, Point p2) {
   int p1X = p1.getX() - referencePoint.getX();
   int p1Y = p1.getY() - referencePoint.getY();
   int p2X = p2.getX() - referencePoint.getX();
   int p2Y = p2.getY() - referencePoint.getY();
   //compensate for a reference point other than (0, 0)

   return (p1X * p2X) + (p1Y * p2Y);  //formula for dot product
}

So how can we use this to calculate the length of a vector? If we take the dot product of a Point with itself, we get (xx) + (yy) which is the left side of the Pythagorean Theorem (a^2 + b^2 = c^2). So if we call dotProduct(p1, p1), we will get the length of its vector squared. Now lets implement compareDistance.

public int compareDistance(Point p1, Point p2) {
   if(dotProduct(p1, p1) == dotProduct(p2, p2)) {
      return 0;
   }
   else if(dotProduct(p1, p1) < dotProduct(p2, p2)) {
      return -1;
   }
   else {
      return 1;
   }
}

Taking the square root of the dot product is not needed, you can just compare the squared lengths. Also note that "==" is fine to use here because we are comparing integers, not Points.

Implementing comparePolarAngle

As with dot product, lets implement a helper method that computes the cross product of two input Points.

private int crossProduct(Point p1, Point p2) {
   int p1X = p1.getX() - referencePoint.getX();
   int p1Y = p1.getY() - referencePoint.getY();
   int p2X = p2.getX() - referencePoint.getX();
   int p2Y = p2.getY() - referencePoint.getY();
   //compensate for a reference point other than (0, 0)

   return (p1X * p2Y) - (p2X * p1Y);  //formula for cross product
}

Another way of writing the result of taking the cross product of two points is |p1||p2|sin(theta) where |p1| is the length of p1's vector, |p2| is the length of p2's vector and theta is the angle from p1 to p2.

Two points with the same polar angle with respect to the reference point have a theta value of zero. sin(0) = 0, so the cross product of two points with the same polar angle is zero.

If p1's polar angle with respect to the reference point is less than that of p2, the angle from p1 to p2 is positive. For 0 < theta < 180, sin(theta) is positive. Therefore, if we take the cross product of p1 and p2 and it is positive, p1's polar angle must be less that that of p2.

If p1's polar angle with respect to the reference point is greater than that of p2, the angle from p1 to p2 would be negative. for -180 < theta < 0, sin(theta) is negative. Therefore, if we take the cross product of p1 and p2 and it is negative, p1's polar angle must be greater than that of p2.

Using this information, we can finally implement comparePolarAngle.

public int comparePolarAngle(Point p1, Point p2) {
   if(crossProduct(p1, p2) == 0) {
      return 0;
   }
   else if(p1.equals(referencePoint) || crossProduct(p1, p2) > 0) {
      return -1;
   }
   else {
      return 1;
   }
}

I will leave the implementation of quick sort to you, as I don't know how your Point objects are being stored, accessed and compared.