248 lines
6.1 KiB
Java
248 lines
6.1 KiB
Java
import twodsack.set.*;
|
|
import twodsack.setelement.datatype.basicdatatype.*;
|
|
import twodsack.util.collectiontype.*;
|
|
import twodsack.util.comparator.*;
|
|
import twodsack.util.number.*;
|
|
import java.lang.reflect.*;
|
|
import java.io.*;
|
|
import java.util.*;
|
|
|
|
|
|
/**
|
|
* This class implements the Points type. A Points instance consists of a set of points. Points are one of the three geometric types, that are
|
|
* used as parameter types in the ROSE algebra. The other two types are Regions and Lines.
|
|
*/
|
|
public class Points implements Serializable{
|
|
/*
|
|
* fields
|
|
*/
|
|
/**
|
|
* The set of points.
|
|
*/
|
|
public PointMultiSet pointset;
|
|
|
|
/**
|
|
* The bounding box of the Points object.
|
|
*/
|
|
private Rect bbox;
|
|
|
|
/**
|
|
* If true, a bbox was already computed and is valid
|
|
*/
|
|
private boolean bboxDefined = false;
|
|
|
|
/*
|
|
* constructors
|
|
*/
|
|
/**
|
|
* Constructs an emtpy Points value.
|
|
*/
|
|
public Points() {
|
|
pointset = new PointMultiSet(new PointComparator());
|
|
bbox = null;
|
|
bboxDefined = false;
|
|
}
|
|
|
|
|
|
/**
|
|
* Constructs a new Points value from a set of points.
|
|
* Note that no copy is made of the set of points.
|
|
*
|
|
* @param pl the set of points
|
|
*/
|
|
public Points(PointMultiSet pl) {
|
|
pointset = pl;
|
|
bbox = pl.rect();
|
|
bboxDefined = true;
|
|
}
|
|
|
|
|
|
/**
|
|
* Constructs a new Points value from an already existing Points value.
|
|
* Note that no copy is made of the set of points.
|
|
*
|
|
* @param p the Points value
|
|
*/
|
|
public Points(Points p) {
|
|
this.pointset = p.pointset;
|
|
this.bbox = p.bbox;
|
|
this.bboxDefined = p.bboxDefined;
|
|
}
|
|
|
|
|
|
/*
|
|
* methods
|
|
*/
|
|
/**
|
|
* Returns the bounding box of the Points object.
|
|
*/
|
|
public Rect rect() {
|
|
if (bboxDefined)
|
|
return bbox;
|
|
else {
|
|
this.bbox = pointset.rect();
|
|
this.bboxDefined = true;
|
|
return bbox;
|
|
}//if
|
|
}//end method rect
|
|
|
|
|
|
/**
|
|
* Returns the size of the pointset.
|
|
*
|
|
* @return the size as int
|
|
*/
|
|
public int size() {
|
|
return this.pointset.size();
|
|
}//end method size
|
|
|
|
|
|
/**
|
|
* Adds the given point <tt>p</tt> to the pointset.
|
|
*
|
|
* @param p the point
|
|
*/
|
|
public void add(Point p) {
|
|
this.pointset.add(p);
|
|
this.bbox = null;
|
|
this.bboxDefined = false;
|
|
}//end method add
|
|
|
|
|
|
/**
|
|
* Constructs a new point from the given Rational coordinates and adds that point to the pointset.
|
|
*
|
|
* @param x the x coordinate for the new point
|
|
* @param y the y coordinate for the new point
|
|
*/
|
|
public void add(Rational x, Rational y) {
|
|
this.pointset.add(new Point(x,y));
|
|
this.bbox = null;
|
|
this.bboxDefined = false;
|
|
}//end method add
|
|
|
|
|
|
/**
|
|
* Constructs a new point from the given int coordinates and adds that point to the pointset.
|
|
*
|
|
* @param x the x coordinate for the new point
|
|
* @param y the y coodrinate for the new point
|
|
*/
|
|
public void add(int x, int y) {
|
|
this.pointset.add(new Point(x,y));
|
|
this.bbox = null;
|
|
this.bboxDefined = false;
|
|
}//end method add
|
|
|
|
|
|
/**
|
|
* Constructs a new point from the given double coordinates and adds that point to the pointset.
|
|
*
|
|
* @param x the x coordinate for the new point
|
|
* @param y the y coordinate for the new point
|
|
*/
|
|
public void add(double x, double y) {
|
|
this.pointset.add(new Point(x,y));
|
|
this.bbox = null;
|
|
this.bboxDefined = false;
|
|
}//end method add
|
|
|
|
|
|
/**
|
|
* Constructs a Points value from a byte array.
|
|
* Given a byte array (probably from a disk access), a Points value is constructed from it.
|
|
* If the value cannot be restored properly, <tt>null</tt> is returned.
|
|
*
|
|
* @param buffer the byte array
|
|
* @return the restored Points value
|
|
*/
|
|
public static Points readFrom(byte[] buffer){
|
|
try{
|
|
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(buffer));
|
|
Points res = (Points) ois.readObject();
|
|
ois.close();
|
|
return res;
|
|
} catch(Exception e){
|
|
return null;
|
|
}
|
|
}//end method readFrom
|
|
|
|
|
|
/**
|
|
* Constructs a serialized Points value.
|
|
* From the Points value, a byte array is constructed. Then, this array can be written to disk.
|
|
*
|
|
* @return the byte array
|
|
*/
|
|
public byte[] writeToByteArray(){
|
|
try{
|
|
ByteArrayOutputStream byteout = new ByteArrayOutputStream();
|
|
ObjectOutputStream objectout = new ObjectOutputStream(byteout);
|
|
objectout.writeObject(this);
|
|
objectout.flush();
|
|
byte[] res = byteout.toByteArray();
|
|
objectout.close();
|
|
return res;
|
|
} catch(Exception e){
|
|
System.out.println("Error in Points.writeToByteArray."+e);
|
|
e.printStackTrace();
|
|
return null;
|
|
}
|
|
}//end method writeToByteArray
|
|
|
|
|
|
/**
|
|
* Returns a <i>deep</i> copy of <tt>this</tt>.
|
|
*/
|
|
public Points copy () {
|
|
Points np = new Points();
|
|
np.pointset = PointMultiSet.convert(this.pointset.copy());
|
|
np.bbox = this.bbox;
|
|
np.bboxDefined = this.bboxDefined;
|
|
|
|
return np;
|
|
}//end method copy
|
|
|
|
|
|
/**
|
|
* Prints the set of points to the standard output.
|
|
*/
|
|
public void print() {
|
|
this.pointset.print();
|
|
}//end method print
|
|
|
|
|
|
/**
|
|
* Compares two Points objects.
|
|
* Returns 0, if both objects are equal.<br>
|
|
* Returns 1, if <tt>this</tt> is greater than <tt>p</tt>.<br>
|
|
* Returns -1 otherwise.<p>
|
|
* The points of the Points object are sorted and then compared in parallel. The Points object with the first point that is
|
|
* greater than the appropriate point of the other object is greater etc.
|
|
*
|
|
* @param p the Points object to compare with
|
|
*/
|
|
public int compare (Points p) {
|
|
Iterator it1 = this.pointset.iterator();
|
|
Iterator it2 = p.pointset.iterator();
|
|
Point actPoint1,actPoint2;
|
|
int res;
|
|
while (it1.hasNext() && it2.hasNext()) {
|
|
actPoint1 = (Point)((MultiSetEntry)it1.next()).value;
|
|
actPoint2 = (Point)((MultiSetEntry)it2.next()).value;
|
|
res = actPoint1.compare(actPoint2);
|
|
if (res != 0) return res;
|
|
}//while
|
|
|
|
//both sets are equal
|
|
if (!it1.hasNext() && !it2.hasNext()) return 0;
|
|
|
|
//p still has elements
|
|
if (!it1.hasNext()) return -1;
|
|
|
|
return 1;
|
|
}//end method compare
|
|
|
|
}//end class Points
|
|
|