Hello,
I have a java package conatain three files. I compiled this package correctly using Netbeans V.6. When I run each file in the package, it gives me a message
"class org.bluer.cg.filename does not have a main method"!!!
Can anyone help me?
I attached just two files to look at them.
(1)
package org.bluear.cg.hull;
import java.awt.geom.Point2D;
import java.util.Collection;
import java.util.List;
/**
* Defines a generic convex hull algorithm.
*
*
*/
public abstract class HullAlgorithm {
// --------------------------
----------
----------
----------
----------
-------
// Constants
// --------------------------
----------
----------
----------
----------
-------
/**
* Indicates that the given point is to the left of the segment.
*/
public static final int LEFT = 0;
/**
* Indicates that the given point is to the right of the segment.
*/
public static final int RIGHT = 1;
/**
* Indicates that the given point is beyond the segment.
*/
public static final int BEYOND = 2;
/**
* Indicates that the given point is behind the segment.
*/
public static final int BEHIND = 3;
/**
* Indicates that the given point is between the segment end points.
*/
public static final int BETWEEN = 4;
/**
* Indicates that the given point is at the origin of the segment.
*/
public static final int ORIGIN = 5;
/**
* Indicates that the given point is at the destination of the segment.
*/
public static final int DESTINATION = 6;
// --------------------------
----------
----------
----------
----------
-------
// Methods
// --------------------------
----------
----------
----------
----------
-------
/**
* Returns the array of indices of points that are part of the convex
* hull.
*
* @param points A collection of <code>Point2D</code> objects.
* @return The list of points that are vertices of a convex hull.
*/
public abstract List getHullPoints(Collection points);
// --------------------------
----------
----------
----------
----------
-------
// Helper methods
// --------------------------
----------
----------
----------
----------
-------
/**
* Classifies the location of the point (x2, y2) relatively to the segment
* defined by points (x0, y0) and (x1, y1). The following illustrates
* regions considered by this method:
* <pre>
*
* LEFT
* BEYOND
* .
* DESTINATION
* /
* BETWEEN
* / RIGHT
* ORIGIN
* .
* BEHIND
* </pre>
* @param x0 The x of the starting point of the segment.
* @param y0 The y of the starting point of the segment.
* @param x1 The x of the final point of the segment.
* @param y1 The y of the final point of the segment.
* @param x2 The x of the point whose position we are testing.
* @param y2 The y of the point whose position we are testing.
*/
public static int classify(double x0, double y0,
double x1, double y1,
double x2, double y2) {
double dx1 = x1 - x0;
double dx2 = x2 - x0;
double dy1 = y1 - y0;
double dy2 = y2 - y0;
double sa = dx1 * dy2 - dx2 * dy1;
if (sa > 0.0) {
return (LEFT);
}
if (sa < 0.0) {
return (RIGHT);
}
if (dx1 * dx2 < 0.0 || dy1 * dy2 < 0.0) {
return (BEHIND);
}
if (dx1 * dx1 + dy1 * dy1 < dx2 * dx2 + dy2 * dy2) {
return (BEYOND);
}
if (x2 == x0 && y2 == y0) {
return (ORIGIN);
}
if (x2 == x1 && y2 == y1) {
return (DESTINATION);
}
return (BETWEEN);
}
/**
* Returns a code indicating where point <code>c</code> is located with
* respect to the segment formed by points <code>a</code> and <code>b</code>.
*
* @param a The first point of the segment.
* @param b The second point of the segment.
* @param c The point classified with respect to the segment.
* @return The code indicating the relative location of c.
*/
public static int classify(Point2D a, Point2D b, Point2D c) {
return (classify(a.getX(), a.getY(), b.getX(), b.getY(), c.getX(), c.getY()));
}
/**
* Returns whether or not the tree given points are co-linear.
*
* @param p1 The first point.
* @param p2 The second points.
* @param p3 The third point.
* @return Whether or not the three points are co-linear.
*/
public static boolean colinear(Point2D p1, Point2D p2, Point2D p3) {
return (p1.getX()*(p2.getY() - p3.getY())
+ p2.getX()*(p3.getY() - p1.getY())
+ p3.getX()*(p1.getY() - p2.getY())) == 0.0;
}
}
(2)
package org.bluear.cg.hull;
import java.awt.geom.Point2D;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
public class GrahamScanHull extends HullAlgorithm {
public List getHullPoints(Collection points) {
int i;
// deal with abnormal cases first ...
if (points == null || points.size() <= 0) {
return (Collections.EMPTY_LIST);
}
int n = 0;
// count the non-null points ...
for (Iterator iter = points.iterator(); iter.hasNext(); ) {
Object obj = iter.next();
if (obj instanceof Point2D) {
++ n;
}
}
if (n <= 0) {
return (Collections.EMPTY_LIST);
}
Point2D[] pt = new Point2D[n];
i = 0;
for (Iterator iter = points.iterator(); iter.hasNext(); ) {
Object obj = iter.next();
if (obj instanceof Point2D) {
pt[i ++] = (Point2D) obj;
}
}
ArrayList hull = new ArrayList();
// Graham scan does not do too well if there are only 1 or 2 points ...
if (n < 3) {
hull.add(pt[0]);
if (n == 2) {
hull.add(pt[1]);
}
}
else {
// Step 1: find extreme point p0
int m = 0;
Point2D pi, p0 = pt[0];
for (i = 1; i < n; i++) {
pi = pt[i];
if (pi.getY() < p0.getY() || (pi.getY() == p0.getY() && pi.getX() < p0.getX())) {
m = i;
p0 = pi;
}
}
if (m != 0) {
pt[m] = pt[0];
pt[0] = p0;
}
// Step 2: sort points by their polar coordinate relative to p0
Arrays.sort(pt, 1, n, new PolarComparator(p0));
// Step 3: Find the second point of the hull ...
i = 1;
while (i+1 < n && colinear(p0, pt[i], pt[i+1])) {
++ i;
}
hull.add(p0);
hull.add(pt[i]);
// Step 4: Grow the current hull until it includes all points
for (i = i + 1; i < n; ++ i) {
pi = pt[i];
Point2D p1 = (Point2D) hull.get(hull.size() - 1);
p0 = (Point2D) hull.get(hull.size() - 2);
while (LEFT != classify(p0, p1, pi)) {
p1 = p0;
hull.remove(hull.size() - 1);
p0 = (Point2D) hull.get(hull.size() - 2);
}
hull.add(pi);
}
}
return (hull);
}
/**
* Local class used by the sort method to classify points based on their
* polar coordinates with respect to the specified pivot point, p0.
*
* @author Bo Majewski
*/
private static class PolarComparator implements Comparator {
private Point2D p0;
/**
* Creates a new comparator that used the given pivot point.
*
* @param p0 The pivot point.
*/
public PolarComparator(Point2D p0) {
this.p0 = p0;
}
/**
* Compares object o1 to object o2. This method returns a negative
* value if o1 lies to the left of o2 with respect to the pivot p0.
*
* @see java.util.Comparator#compa
re(java.la
ng.Object,
java.lang.Object)
*/
public int compare(Object o1, Object o2) {
Point2D p1 = (Point2D) o1;
Point2D p2 = (Point2D) o2;
// take care of degenerate cases first ...
if (p1.equals(this.p0)) {
return (p2.equals(this.p0)? 0 : -1);
}
if (p2.equals(this.p0)) {
return (1);
}
// this is when neither p1 nor p2 is identical to pivot ...
double d = ((p2.getX() - p0.getX())*(p1.getY() - p0.getY())
- (p1.getX() - p0.getX())*(p2.getY() - p0.getY()));
return (d < 0.0? -1 : d > 0.0? 1 : 0);
}
}
}
