2866 lines
109 KiB
Java
2866 lines
109 KiB
Java
/*
|
|
* SetOps.java 2005-05-02
|
|
*
|
|
* Dirk Ansorge, FernUniversitaet Hagen
|
|
*
|
|
*/
|
|
|
|
package twodsack.operation.setoperation;
|
|
|
|
import twodsack.io.*;
|
|
import twodsack.set.*;
|
|
import twodsack.setelement.*;
|
|
import twodsack.setelement.datatype.*;
|
|
import twodsack.setelement.datatype.basicdatatype.*;
|
|
import twodsack.util.collection.*;
|
|
import twodsack.util.collectiontype.*;
|
|
import twodsack.util.comparator.*;
|
|
import twodsack.util.graph.*;
|
|
import twodsack.util.iterator.*;
|
|
import twodsack.util.number.*;
|
|
import java.util.*;
|
|
import java.lang.reflect.*;
|
|
import java.io.*;
|
|
|
|
/**
|
|
* The SetOps class is one of the central classes of the whole 2D-SACK package.
|
|
* Collected in this class are all
|
|
* of the genereric set operations the package offers. Sets in 2D-SACK are commonly {@link ElemMultiSet}, i.e. they
|
|
* are one of {{@link PointMultiSet}, {@link SegMultiSet}, {@link TriMultiSet}}. Most of the operations provided here are made for this
|
|
* type. Other types are {@link PairMultiSet}, {@link LeftJoinPairMultiSet} and, in one special case a LinkedList.<p>
|
|
* A PairMultiSet is the result type of a join performed on two sets. Each element of such a set is an {@link ElemPair}
|
|
* which holds two elements. A LeftJoinPairMultiSet is the result of an {@link #leftOuterJoin(ElemMultiSet,ElemMultiSet,Method)} and also has pairs
|
|
* as elements. Such a pair looks like this: <code>(Element x ElemMultiSet)</code>. Finally, a LinkedList type
|
|
* only appears in some sorting algorithm in this class.<p>
|
|
* The operations in this class can be roughly divided in four groups:<ol>
|
|
* <li> set operations for ElemMultiSet(s)
|
|
* <li> set operations for PairMultiSet(s)
|
|
* <li> set operations for LeftJoinPairMultiSet(s)
|
|
* <li> supporting operations
|
|
* </ol><p>
|
|
* E.g. the group for set operations for PairMultiSet(s) holds several join operations to construct PairMultiSets
|
|
* from pairs of ElemMultiSet(s). Then, some other operations can be used for further processing, like {@link #filter(PairMultiSet,Method,boolean)},
|
|
* {@link #proj1(PairMultiSet)}, {@link #proj2(PairMultiSet)}, and four different versions of <tt>map(...)</tt>. The operations in the other
|
|
* groups are quite similar.<p>
|
|
* In this class, different implementations can be found for similar operations like <tt>join(...)</tt> and <tt>overlapJoin(...)</tt> or
|
|
* <tt>group(...)</tt>
|
|
* and <tt>overlapGroup</tt>. The <i>overlap</i> prefix indicates a method as using a special mechanism for speeding up
|
|
* the operation. Whereas a simple <tt>join</tt> takes quite a long time, the <tt>overlapJoin</tt> uses a filter&refine technique
|
|
* to reduce the number of possibly interesting pairs of elements before executing (possibly) expensive following
|
|
* operations. The only constraint for these overlap versions of methods is, that the passed predicate and operation
|
|
* for this operation may work only <i>inside of bounding boxes</i>. This means for predicates, that it only holds for
|
|
* two elements, if their bounding boxes overlap or are adjacent at least. For operations, the result of the operation must
|
|
* lie inside of the bounding box of the two bounding boxes involved.
|
|
*/
|
|
|
|
public class SetOps {
|
|
/*
|
|
* fields
|
|
*/
|
|
static final ElemComparator ELEM_COMPARATOR = new ElemComparator();
|
|
static final LeftJoinPairComparator LEFTJOINPAIR_COMPARATOR = new LeftJoinPairComparator();
|
|
static final ElemPairComparator ELEMPAIR_COMPARATOR = new ElemPairComparator();
|
|
|
|
|
|
/*
|
|
* constructors
|
|
*/
|
|
/**
|
|
* The standard constructor.
|
|
*/
|
|
public SetOps(){}
|
|
|
|
|
|
/*
|
|
* methods
|
|
*/
|
|
|
|
/**
|
|
* Separates the passed PairMultiSet and returns the elements in the two passed ElemMultiSet(s).
|
|
* Both passed sets <tt>ems1,ems2</tt> are cleared before adding new elements.
|
|
*
|
|
* @param pms the set that is separated
|
|
* @param ems1 all first elements are stored in this set
|
|
* @param ems2 all second elements are stored in this set
|
|
*/
|
|
static public void separateSets (PairMultiSet pms, ElemMultiSet ems1, ElemMultiSet ems2) {
|
|
if (ems1 == null) ems1 = new ElemMultiSet(ELEM_COMPARATOR);
|
|
if (ems2 == null) ems2 = new ElemMultiSet(ELEM_COMPARATOR);
|
|
ems1.clear();
|
|
ems2.clear();
|
|
|
|
Iterator it = pms.iterator();
|
|
ElemPair actPair;
|
|
while (it.hasNext()) {
|
|
actPair = (ElemPair)((MultiSetEntry)it.next()).value;
|
|
ems1.add(actPair.first);
|
|
ems2.add(actPair.second);
|
|
}//while it
|
|
|
|
}//end method separateSets
|
|
|
|
|
|
|
|
/**
|
|
* Returns a set of elements which is 'reduced' using the passed <tt>predicate</tt> and <tt>method</tt>.<p>
|
|
* This is another variant of the normal {@link #reduce(ElemMultiSet,Method,Method)} operation. For the functionality of <tt>reduce</tt> itself,
|
|
* have a look at that method. <p>
|
|
* Here, a plane sweep algorithm is used for the computation of the reduced set:<ul>
|
|
* <li> construct the sweep event structure (ses) from the bounding boxes of the elements in ems; store the right and
|
|
* left interval borders
|
|
* <li> sort the intervals by their x-coordinate, lower y-coordinate, upper y-coordinate, in that order
|
|
* <li> construct a sweep status structure (sss) which is initially empty but will hold intervals later on
|
|
* <li> traverse the ses; for every element do:<ul>
|
|
* <li> if it is a left interval: check whether it overlaps any of the intervals in sss. If it does:<ul>
|
|
* <li> evaluate the <tt>predicate</tt> for the two involved objects
|
|
* <li> evaluate the operation if the <tt>predicate</tt> yields <tt>true</tt>
|
|
* <li> if the result of the operation is empty, delete the left and right intervals from ses and sss,
|
|
* otherwise adjust the intervals in ses and sss</ul>
|
|
* <li> if it is a left interval and the intervals don't overlap, add the interval to sss
|
|
* <li> if it is a right interval: add the object to the result set and delete the interval from sss</ul>
|
|
* </ul>
|
|
* This method is successfully used in the <tt>SupportOps.minimal()</tt> method. There, it works for sets of segments,
|
|
* the predicate <tt>adjacent()</tt> and the method <tt>concat()</tt>. No other implementations were tested, yet.<p>
|
|
* Note, that the signature of all predicates and methods must be<br>
|
|
* <code>Element x Element -> boolean</code> and <code>Element x Element -> Element</code>, resp.
|
|
*
|
|
* @param ems the input set of elements
|
|
* @param predicate the method that is used to identify candidates for the second method
|
|
* @param method the method that is invoked on pairs identified by the predicate
|
|
* @param meet if <tt>true</tt>, also objects of <tt>ems</tt> which have only adjacent bounding boxes are tested with predicate
|
|
* @return the 'reduced' set of objects
|
|
*/
|
|
public static ElemMultiSet overlapReduceSweep (ElemMultiSet ems, Method predicate, Method method, boolean meet) {
|
|
//construct sweep event structure from ems
|
|
//the left and right intervals of the bounding boxes of all elements in ems are stored
|
|
if (ems.isEmpty()) return ems;
|
|
|
|
//get some information about the passed methods
|
|
int paramTypeCountP = Array.getLength(predicate.getParameterTypes());
|
|
int paramTypeCountM = Array.getLength(method.getParameterTypes());
|
|
Element[] paramListP = new Element[paramTypeCountP];
|
|
Element[] paramListM = new Element[paramTypeCountM];
|
|
|
|
//the elements of ems are stored in an array for better accessibility
|
|
Object[] elemStore = ems.toArray();
|
|
|
|
//declare the sweep event structure (ses) and fill it with the left and right borders of the
|
|
//bounding boxes of all elements in ems.
|
|
MultiSet ses = new MultiSet(new IvlComparator(meet));
|
|
Object[] sesArr;
|
|
Element actEl;
|
|
Rect actRect;
|
|
boolean buddy;
|
|
for (int i = 0; i < elemStore.length; i++) {
|
|
actEl = (Element)elemStore[i];
|
|
actRect = actEl.rect();
|
|
buddy = actRect.ulx.equal(actRect.urx);
|
|
ses.add(new Interval(actRect.lly,actRect.uly,"blueleft",actRect.ulx,null,i,buddy));
|
|
ses.add(new Interval(actRect.lry,actRect.ury,"blueright",actRect.urx,null,i,buddy));
|
|
}//for i
|
|
|
|
//declare the sweep status structure
|
|
MultiSet sss = new MultiSet(new IvlComparator(meet));
|
|
Interval actIvl,sesIvl;
|
|
Interval sssIvl = null;
|
|
Iterator it,it2,it3;
|
|
boolean predTrue,resultIsEmpty,removedIvl,ivlOverlap = false;
|
|
ElemMultiSet resultSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
Element resultElement = null;
|
|
|
|
sesArr = ses.toArray();
|
|
|
|
//start the sweep
|
|
for (int sesIdx = 0; sesIdx < sesArr.length; sesIdx++) {
|
|
//while there are elements left in ses, continue with the sweep
|
|
while (sesArr[sesIdx] == null) {
|
|
sesIdx++;
|
|
}//while
|
|
|
|
actIvl = (Interval)sesArr[sesIdx];
|
|
|
|
//the actually visited interval can be marked with blueleft or blueright
|
|
//the first case handled is blueleft
|
|
if (actIvl.mark == "blueleft") {
|
|
resultIsEmpty = false;
|
|
it2 = sss.iterator();
|
|
|
|
//now, traverse the intervals already stored in sss.
|
|
while (!resultIsEmpty && it2.hasNext()) {
|
|
sssIvl = (Interval)(((MultiSetEntry)it2.next()).value);
|
|
predTrue = false;
|
|
|
|
if (actIvl.right.less(sssIvl.left)) {
|
|
//break;
|
|
}
|
|
else {
|
|
//define ivlOverlap = true, if actIvl and sssIvl overlap
|
|
//in case flag meet is true, ivlOverlap = true if the intervals are adjacent, too
|
|
if (!meet)
|
|
ivlOverlap =
|
|
(sssIvl.left.less(actIvl.left) && sssIvl.right.greaterOrEqual(actIvl.left)) ||
|
|
(sssIvl.left.equal(actIvl.left) && sssIvl.right.greater(actIvl.left)) ||
|
|
(sssIvl.left.greater(actIvl.left) && sssIvl.left.less(actIvl.right));
|
|
else
|
|
ivlOverlap =
|
|
(sssIvl.left.less(actIvl.left) && sssIvl.right.greaterOrEqual(actIvl.left)) ||
|
|
(sssIvl.left.equal(actIvl.left) && sssIvl.right.greater(actIvl.left)) ||
|
|
(sssIvl.left.greater(actIvl.left) && sssIvl.left.less(actIvl.right)) ||
|
|
sssIvl.right.equal(actIvl.left) || sssIvl.left.equal(actIvl.right);;
|
|
}//else
|
|
|
|
//if both intervals overlap check the predicate
|
|
if (ivlOverlap) {
|
|
//now check for predicate
|
|
|
|
//if predicate has one argument
|
|
if (paramTypeCountP == 1) paramListP[0] = (Element)elemStore[actIvl.number];
|
|
//if predicate has two arguments
|
|
else {
|
|
paramListP[0] = (Element)elemStore[sssIvl.number];
|
|
paramListP[1] = (Element)elemStore[actIvl.number];
|
|
}//else
|
|
|
|
//evaluate predicate
|
|
try {
|
|
predTrue = ((Boolean)predicate.invoke((Element)elemStore[sssIvl.number],paramListP)).booleanValue();
|
|
} catch (Exception e) {
|
|
System.out.println("Exception in SetOps.overlapReduceSweep when evaluating predicate.");
|
|
System.out.println("elemStore[sssIvl.number]: "+(Element)elemStore[sssIvl.number]);
|
|
System.out.println("elemStore[actIvl.number]: "+(Element)elemStore[actIvl.number]);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
//invoke method on the elements linked to the intervals, if the predicate yields true
|
|
if (predTrue) {
|
|
//evaluate method, note that result may be empty
|
|
if (paramTypeCountM == 1) paramListM[0] = (Element)elemStore[actIvl.number];
|
|
else {
|
|
paramListM[0] = (Element)elemStore[sssIvl.number];
|
|
paramListM[1] = (Element)elemStore[actIvl.number];
|
|
}//else
|
|
|
|
//evaluate method
|
|
try {
|
|
resultElement = (Element)method.invoke((Element)elemStore[sssIvl.number],paramListM);
|
|
} catch (Exception e) {
|
|
System.out.println("Exception in SetOps.overlapReduceSweep when evaluating method.");
|
|
System.out.println("elemStore[sssIvl.number]: "+(Element)elemStore[sssIvl.number]);
|
|
System.out.println("elemStore[actIvl.number]: "+(Element)elemStore[actIvl.number]);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
if (resultElement == null) resultIsEmpty = true;
|
|
|
|
//update ref in actEl, update interval borders in actEl
|
|
elemStore[actIvl.number] = resultElement;
|
|
actIvl.left = resultElement.rect().lly;
|
|
actIvl.right = resultElement.rect().uly;
|
|
|
|
//remove the sssIvl from sss and remove right interval with number = sssIvl.number from ses,
|
|
//i.e. remove the interval also from ses, where its "blueright" interval still exists
|
|
it2.remove();
|
|
removedIvl = false;
|
|
for (int i = sesIdx; i < sesArr.length; i++) {
|
|
if ((sesArr[i] != null) &&((Interval)sesArr[i]).number == sssIvl.number) {
|
|
sesArr[i] = null;
|
|
removedIvl = true;
|
|
break;
|
|
}//if
|
|
}//for i
|
|
|
|
}//if predTrue
|
|
}//if ivlOverlap
|
|
}//while it2
|
|
|
|
//if the result of the method invocation is not empty, add the interval of the new/changed
|
|
//object to the sss
|
|
//otherwise delete the right partner of the left interval from sss
|
|
if (!resultIsEmpty)
|
|
sss.add(actIvl);
|
|
else {
|
|
//remove the right interval from ses
|
|
removedIvl = false;
|
|
for (int i = sesIdx; i < sesArr.length; i++) {
|
|
if ((sesArr[i] != null) && ((Interval)sesArr[i]).number == sssIvl.number) {
|
|
sesArr[i] = null;
|
|
removedIvl = true;
|
|
break;
|
|
}//if
|
|
}//for i
|
|
}//else
|
|
}//if blueleft
|
|
|
|
|
|
//the actually visited interval is marked with blueright
|
|
else {
|
|
//store the object linked to the interval in the result set
|
|
resultSet.add(elemStore[actIvl.number]);
|
|
|
|
//remove left interval from sss
|
|
it2 = sss.iterator();
|
|
while (it2.hasNext()) {
|
|
sesIvl = (Interval)(((MultiSetEntry)it2.next()).value);
|
|
if (sesIvl.number == actIvl.number) {
|
|
it2.remove();
|
|
break;
|
|
}//if
|
|
}//while it2
|
|
}//else if blueright
|
|
}//while it
|
|
|
|
return resultSet;
|
|
}//end method overlapReduceSweep
|
|
|
|
|
|
|
|
/**
|
|
* This method is a variant of overlapReduceSweep for methods of type <tt>Element x Element -> ElemMultiSet</tt>.
|
|
* More information about this method can be found there.
|
|
*
|
|
* @param ems the input set of elements
|
|
* @param predicate the method that is used to identify candidates for the second method
|
|
* @param method the method that is invoked on pairs identified by the predicate
|
|
* @param meet if <tt>true</tt>, also objects of <tt>ems</tt> which have only adjacent bounding boxes are tested with predicate
|
|
* @return the 'reduced' set of objects
|
|
*/
|
|
public static ElemMultiSet overlapReduceSweep2 (ElemMultiSet ems, Method predicate, Method method, boolean meet) {
|
|
//construct sweep event structure (ses) from ems;
|
|
//the left an right intervals of the bounding boxes of all elements in ems are stored in ses
|
|
if (ems.isEmpty()) return ems;
|
|
|
|
//get some information about the passed methods
|
|
int paramTypeCountP = Array.getLength(predicate.getParameterTypes());
|
|
int paramTypeCountM = Array.getLength(method.getParameterTypes());
|
|
Element[] paramListP = new Element[paramTypeCountP];
|
|
Element[] paramListM = new Element[paramTypeCountM];
|
|
|
|
//the elements of ems are stored in a Vector we need a dynamic structure here in contrast the
|
|
//ordinary overlapReduceSweep, since the SES is changed during the sweep
|
|
Vector elemStore = ems.toVector();
|
|
int number = ems.size();
|
|
|
|
//declare the sweep event structure (SES) and fill it with the left and right borders of the
|
|
//bounding boxes of all elements of ems
|
|
IvlComparator ivlComp = new IvlComparator(meet);
|
|
MultiSet ses = new MultiSet(ivlComp);
|
|
ProLinkedList sesList;
|
|
Element actEl,actEl2;
|
|
Rect actRect;
|
|
boolean buddy;
|
|
for (int i = 0; i < elemStore.size(); i++) {
|
|
actEl = (Element)elemStore.get(i);
|
|
actRect = actEl.rect();
|
|
buddy = actRect.ulx.equal(actRect.urx);
|
|
ses.add(new Interval(actRect.lly,actRect.uly,"blueleft",actRect.ulx,null,i,buddy));
|
|
ses.add(new Interval(actRect.lry,actRect.ury,"blueright",actRect.urx,null,i,buddy));
|
|
}//for i
|
|
|
|
//declare the sweep status structure SSS
|
|
MultiSet sss = new MultiSet(new IvlComparator(meet));
|
|
Interval actIvl,actIvl2,sesIvl;
|
|
Interval sssIvl = null;
|
|
Iterator it2,it4;
|
|
ProListIterator it,it3;
|
|
boolean predTrue = false;
|
|
boolean resultIsEmpty,removedIvl,ivlOverlap = false;
|
|
ElemMultiSet resultSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
ElemMultiSet resultEMS = null;
|
|
int sweepPointer;
|
|
|
|
sesList = new ProLinkedList(ses,new IvlComparatorSimpleType(meet));
|
|
|
|
//start the sweep
|
|
it = sesList.listIterator(0);
|
|
sweepPointer = -1;
|
|
//while there are elements left in SES, continue with the sweep
|
|
while (it.hasNext()) {
|
|
actIvl = (Interval)it.next();
|
|
sweepPointer++;
|
|
|
|
//the actually visited interval is marked with either "blueleft" or "blueright";
|
|
//handle "blueleft" first
|
|
if (actIvl.mark == "blueleft") {
|
|
|
|
resultIsEmpty = false;
|
|
predTrue = false;
|
|
it2 = sss.iterator();
|
|
|
|
//now, traverse the intervals already stored in SSS
|
|
while (it2.hasNext()) {
|
|
sssIvl = (Interval)(((MultiSetEntry)it2.next()).value);
|
|
predTrue = false;
|
|
|
|
if (actIvl.right.less(sssIvl.left)) {
|
|
//break;
|
|
}
|
|
else {
|
|
//define ivlOverlap = true, if actIvl and sssIvl overlap
|
|
//in case flag meet is true, ivlOverlap = true if the intervals are adjacent, too
|
|
if (!meet)
|
|
ivlOverlap =
|
|
(sssIvl.left.less(actIvl.left) && sssIvl.right.greaterOrEqual(actIvl.left)) ||
|
|
(sssIvl.left.equal(actIvl.left) && sssIvl.right.greater(actIvl.left)) ||
|
|
(sssIvl.left.greater(actIvl.left) && sssIvl.left.less(actIvl.right));
|
|
else
|
|
ivlOverlap =
|
|
(sssIvl.left.less(actIvl.left) && sssIvl.right.greaterOrEqual(actIvl.left)) ||
|
|
(sssIvl.left.equal(actIvl.left) && sssIvl.right.greater(actIvl.left)) ||
|
|
(sssIvl.left.greater(actIvl.left) && sssIvl.left.less(actIvl.right)) ||
|
|
sssIvl.right.equal(actIvl.left) || sssIvl.left.equal(actIvl.right);;
|
|
}//else
|
|
|
|
//if both intervals overlap check the predicate
|
|
if (ivlOverlap) {
|
|
//now check for predicate
|
|
|
|
//if predicate has one argument
|
|
if (paramTypeCountP == 1) paramListP[0] = (Element)elemStore.get(actIvl.number);
|
|
//if predicate has two arguments
|
|
else {
|
|
paramListP[0] = (Element)elemStore.get(sssIvl.number);
|
|
paramListP[1] = (Element)elemStore.get(actIvl.number);
|
|
}//else
|
|
|
|
//evaluate predicate
|
|
try {
|
|
predTrue = ((Boolean)predicate.invoke((Element)elemStore.get(sssIvl.number),paramListP)).booleanValue();
|
|
} catch (Exception e) {
|
|
System.out.println("Exception in SetOps.overlapReduceSweep2 when evaluating predicate.");
|
|
System.out.println("elemStore.get(sssIvl.number): "+(Element)elemStore.get(sssIvl.number));
|
|
System.out.println("elemStore.get(actIvl.number): "+(Element)elemStore.get(actIvl.number));
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
//invoke method on the elements linked to the intervals, if the predicate yields true
|
|
if (predTrue) {
|
|
|
|
//evaluate method, note that result may be empty
|
|
if (paramTypeCountM == 1) paramListM[0] = (Element)elemStore.get(actIvl.number);
|
|
else {
|
|
paramListM[0] = (Element)elemStore.get(sssIvl.number);
|
|
paramListM[1] = (Element)elemStore.get(actIvl.number);
|
|
}//else
|
|
|
|
//evaluate method
|
|
try {
|
|
resultEMS = (ElemMultiSet)method.invoke((Element)elemStore.get(sssIvl.number),paramListM);
|
|
} catch (Exception e) {
|
|
System.out.println("Exception in SetOps.overlapReduceSweep when evaluating method.");
|
|
System.out.println("elemStore.get(sssIvl.number): "+(Element)elemStore.get(sssIvl.number));
|
|
System.out.println("elemStore.get(actIvl.number): "+(Element)elemStore.get(actIvl.number));
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
if ((resultEMS == null) || resultEMS.isEmpty()) resultIsEmpty = true;
|
|
else resultIsEmpty = false;
|
|
|
|
//remove the sssIvl from sss and remove both intervals marked with sssIvl.number from SES
|
|
//System.out.println("\nremove sssIvl and its partner from sss and ses. sssIvl.number: "+sssIvl.number);
|
|
it2.remove();
|
|
it3 = sesList.listIterator(0);
|
|
int ct = 0;
|
|
while (it3.hasNext()) {
|
|
actIvl2 = (Interval)it3.next();
|
|
|
|
if (actIvl2.number == sssIvl.number) {
|
|
it3.remove();
|
|
ct++;
|
|
}//if
|
|
if (ct == 2) break;
|
|
}//while it3
|
|
sweepPointer--;
|
|
}//if predTrue
|
|
}//if ivlOverlap
|
|
//if method was invoked, break
|
|
if (predTrue) break;
|
|
}//while it
|
|
|
|
if (predTrue) {
|
|
//delete actIvl and its partner from SES
|
|
it3 = sesList.listIterator(0);
|
|
int ct = 0;
|
|
|
|
int ct1 = 0;
|
|
while (it3.hasNext()) {
|
|
|
|
actIvl2 = (Interval)it3.next();
|
|
ct1++;
|
|
if (actIvl2.number == actIvl.number) {
|
|
it3.remove();
|
|
ct++;
|
|
}//if
|
|
if (ct == 2) break;
|
|
}//while it
|
|
if (ct != 2) {
|
|
System.out.println("\nct = "+ct);
|
|
System.out.println("\ndelete actIvl and its partner from SES. actIvl.nr: "+actIvl.number);
|
|
System.out.println("\n********************************");
|
|
System.out.println("SESLIST:");
|
|
for (int i = 0; i < sesList.size(); i++) {
|
|
System.out.print("["+i+"] ");((Interval)sesList.get(i)).print();
|
|
}
|
|
System.out.println("********************************");
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}
|
|
|
|
sweepPointer--;
|
|
|
|
//if the result of the method invocation is not empty, add all new objects to SES and elemStore;
|
|
int pos;
|
|
if (!resultIsEmpty) {
|
|
it4 = resultEMS.iterator();
|
|
while (it4.hasNext()) {
|
|
actEl2 = (Element)((MultiSetEntry)it4.next()).value;
|
|
|
|
elemStore.add(actEl2);
|
|
actRect = actEl2.rect();
|
|
buddy = actRect.ulx.equal(actRect.urx);
|
|
|
|
pos = sesList.addSorted(new Interval(actRect.lly,actRect.uly,"blueleft",actRect.ulx,null,number,buddy));
|
|
//one or none of the new intervals may have been added BEFORE the actual x;
|
|
//set pointer to pos-1 or pos-2, resp.
|
|
if (pos <= sweepPointer) {
|
|
sweepPointer++;
|
|
}//if
|
|
pos = sesList.addSorted(new Interval(actRect.lry,actRect.ury,"blueright",actRect.urx,null,number,buddy));
|
|
|
|
if (pos <= sweepPointer) {
|
|
sweepPointer++;
|
|
}//if
|
|
number++;
|
|
}//while it4
|
|
|
|
it.reset();
|
|
for (int i = 0; i < sweepPointer+1; i++) it.next();
|
|
} else {
|
|
|
|
//if result is empty, two intervals were deleted, that have positions < X;
|
|
//decrease sweepPointer by 2
|
|
it.reset();
|
|
for (int i = 0; i < sweepPointer+1; i++) it.next();
|
|
}//else
|
|
|
|
} else {
|
|
//if predTrue = false;
|
|
//simply add actIvl to sss
|
|
sss.add(actIvl);
|
|
}//else
|
|
}//if blueleft
|
|
|
|
//the actually visited interval is marked "blueright"
|
|
else {
|
|
//store the object linked to the interval in the result set
|
|
resultSet.add(elemStore.get(actIvl.number));
|
|
|
|
//remove left interval from sss
|
|
it2 = sss.iterator();
|
|
while (it2.hasNext()) {
|
|
sesIvl = (Interval)(((MultiSetEntry)it2.next()).value);
|
|
if (sesIvl.number == actIvl.number) {
|
|
it2.remove();
|
|
break;
|
|
}//if
|
|
}//while it2
|
|
|
|
//remove both intervals from ses
|
|
it.remove(); //removes right interval
|
|
it.reset();
|
|
while (it.hasNext()) {
|
|
sesIvl = (Interval)(it.next());
|
|
if (sesIvl.number == actIvl.number) {
|
|
it.remove();
|
|
break;
|
|
}//if
|
|
}//while it
|
|
|
|
sweepPointer = sweepPointer-2;
|
|
it.reset();
|
|
for (int i = 0; i < sweepPointer+1; i++)
|
|
if (it.hasNext()) it.next();
|
|
}//if blueright
|
|
}//while it
|
|
|
|
return resultSet;
|
|
}//end method overlapReduceSweep2
|
|
|
|
/**
|
|
* Collects elements from the parameter set and stores them in the resulting set.
|
|
* Every element of <tt>ljpMS</tt> consists of a pair <tt>(Element x ElemMultiSet)</tt>. This method traverses the set and
|
|
* stores the <tt>Element</tt> in the result set if <tt>Element != NULL</tt>. If <tt>Element == NULL</tt>, the <tt>ElemMultiSet</tt> is stored
|
|
* in the result set instead.
|
|
*
|
|
* @param ljpMS the 'in' set
|
|
* @return the collected elements of <tt>ljpMS</tt> stored in an <tt>ElemMultiSet</tt>
|
|
*/
|
|
public static ElemMultiSet collect (LeftJoinPairMultiSet ljpMS) {
|
|
ElemMultiSet result = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
if (ljpMS.isEmpty()) return result;
|
|
|
|
Iterator it = ljpMS.iterator();
|
|
LeftJoinPair actPair;
|
|
|
|
while (it.hasNext()) {
|
|
actPair = (LeftJoinPair)((MultiSetEntry)it.next()).value;
|
|
if (actPair.elemSet == null) {
|
|
result.add(actPair.element); }
|
|
else result.addAll(actPair.elemSet);
|
|
}//while it.hasNext
|
|
|
|
return result;
|
|
}//end method collect
|
|
|
|
|
|
/**
|
|
* Collects elements from the parameter set and stores them in the resulting set.
|
|
* This method collects <i>only</i> the elements of the <tt>ElemMultiSet</tt>s of every entry of <tt>ljpMS</tt>.
|
|
* The first entries, i.e. the <tt>Element</tt> part of every pair, is ignored.
|
|
*
|
|
* @param ljpMS the 'in' set
|
|
* @return the collected elements stored in a ElemMultiSet
|
|
*/
|
|
public static ElemMultiSet collect2nd (LeftJoinPairMultiSet ljpMS) {
|
|
ElemMultiSet result = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
if (ljpMS.isEmpty()) return result;
|
|
|
|
Iterator it = ljpMS.iterator();
|
|
LeftJoinPair actPair;
|
|
|
|
while (it.hasNext()) {
|
|
actPair = (LeftJoinPair)((MultiSetEntry)it.next()).value;
|
|
if (actPair.elemSet != null) {
|
|
result.addAll(actPair.elemSet);
|
|
}//if
|
|
}//while
|
|
|
|
return result;
|
|
}//end method collect2nd
|
|
|
|
|
|
/**
|
|
* For the two passed sets, a LeftJoinpPairMultiSet is computed where every element of the set has the form <tt>(Element x ElemMultiSet)</tt>.
|
|
* For every pair <tt>Element x ElementOfEMS</tt> of this set element, the <tt>predicate</tt> holds. This set is computed as follows:<ul>
|
|
* <li> call <tt>overlappingPairs()</tt> to find all the pairs <tt>e1 x e2</tt>, <tt>e1</tt> element of <tt>el1</tt> and
|
|
* <tt>e2</tt> element of <tt>el2</tt>, which have
|
|
* overlapping bounding boxes; an {@link EarlyExit} exception is thrown when the <tt>earlyExit</tt> flag is set
|
|
* <li> in a filter step, the number of pairs is reduced using the passed <tt>predicate</tt>
|
|
* <li> while the set of pairs is traversed, all pairs which have the same first element, are collected and all of them are
|
|
* stored in one single entry of the resulting LeftJoinPairMultiSet
|
|
* </ul>
|
|
* The new LeftJoinPairMultiSet is returned, then.<p>
|
|
* This is the 'overlap' version of the normal {@link #leftOuterJoin(ElemMultiSet,ElemMultiSet,Method)}. It only works for predicates which solely hold
|
|
* for elements with overlapping bounding boxes.<p>
|
|
* If, in a special case, for one element <tt>ex</tt> of <tt>el1</tt> no element <tt>ey</tt> of <tt>el2</tt> is found, the entry constructed in the
|
|
* resulting set is <tt>(ex x NULL)</tt>, i.e. the <tt>ElemMultiSet</tt> is <u>not</u> <tt>initialized</tt>.<p>
|
|
* The <tt>predicate</tt> must have the signature <code>Element x Element -> boolean</code>.
|
|
*
|
|
* @param el1 the first set of elements. These elements can be found again in the resulting LeftJoinPairMultiSet
|
|
* as the first entry of every <tt>(Element x ElemMultiSet)</tt>. In particular, this means that if <tt>el1</tt> is <tt>(e1, e2, e3...)</tt>,
|
|
* the resulting set is <tt>( (e1 x ems1), (e2 x ems2), (e3 x ems3) ...)</tt>.
|
|
* @param el2 the second set of elements. The elements of this set are found in the second entries (i.e. in the sets)
|
|
* of the resulting LeftJoinPairMultiSet
|
|
* @param predicate according to this predicate, the ElemMultiSet(s) in the LeftJoinPairMultiSet's entries are built
|
|
* @param useOvLapPairsMeet this flag is passed to <tt>overlappingPairs()</tt>; if <tt>true</tt> objects whith adjacent bounding boxes are
|
|
* reported, too
|
|
* @param bboxFilter this flag is passed to <tt>overlappingPairs()</tt>; if <tt>true</tt>, in a pre-processing step the number of
|
|
* candidates is reduced by removing objects of <tt>el1</tt>,</tt>el2</tt> which don't overlap the unified bounding box of <tt>el1</tt>,
|
|
* <tt>el2</tt> resp.
|
|
* @param earlyExit if <tt>true</tt>, an {@link EarlyExit} exception is thrown immediately when the first object of <tt>elN</tt> is found which
|
|
* doesn't have a partner in <tt>elM</tt>, i.e. at least one element of <tt>elM</tt> which has a bounding box that overlaps the
|
|
* bounding box of the element of <tt>elN</tt>. <tt>N</tt> is the passed <tt>setNumber</tt>. earlyExit is evaluated in <tt>bboxFilter</tt>, so if shall
|
|
* be used, be sure that <tt>bboxFilter = true</tt>
|
|
* @param setNumber must be 1 or 2; specifies the set for earlyExit
|
|
* @return the resulting LeftJoinPairMultiSet
|
|
* @throws EarlyExit
|
|
* @see #leftOuterJoin(ElemMultiSet,ElemMultiSet,Method)
|
|
*/
|
|
public static LeftJoinPairMultiSet overlapLeftOuterJoin (ElemMultiSet el1, ElemMultiSet el2, Method predicate, boolean useOvLapPairsMeet, boolean bboxFilter, boolean earlyExit, int setNumber)
|
|
throws EarlyExit {
|
|
//compute overlapping pairs
|
|
PairMultiSet pl;
|
|
try {
|
|
pl = overlappingPairs(el1,el2,false,useOvLapPairsMeet,bboxFilter,earlyExit,setNumber);
|
|
} catch (NoOverlappingBoxFoundException nop) {
|
|
throw new EarlyExit();
|
|
}//catch
|
|
|
|
//filter set
|
|
pl = filter(pl,predicate,true);
|
|
|
|
//make final set; note, that the elements in pl are already sorted
|
|
LeftJoinPairMultiSet retList = new LeftJoinPairMultiSet(LEFTJOINPAIR_COMPARATOR);
|
|
Iterator lit1 = el1.iterator();
|
|
Iterator lit2;
|
|
Element act1;
|
|
ElemPair act2;
|
|
LeftJoinPair ljp;
|
|
boolean stillTrue;
|
|
boolean constructedEMS;
|
|
int num;
|
|
while (lit1.hasNext()) {
|
|
act1 = (Element)((MultiSetEntry)lit1.next()).value;
|
|
ljp = new LeftJoinPair();
|
|
ljp.element = act1;
|
|
constructedEMS = false;
|
|
|
|
while (pl.size() > 0) {
|
|
act2 = (ElemPair)pl.first();
|
|
num = pl.firstMSE().number;
|
|
if (act2.first.equal(act1)) {
|
|
if (!constructedEMS) {
|
|
ljp.elemSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
constructedEMS = true;
|
|
}//if
|
|
ljp.elemSet.add(act2.second);
|
|
pl.removeAllOfThisKind(act2,num);
|
|
}//if
|
|
else break;
|
|
}//while pl.size > 0
|
|
|
|
retList.add(ljp);
|
|
}//while
|
|
|
|
return retList;
|
|
}//end method overlapLeftOuterJoin
|
|
|
|
|
|
/**
|
|
* Invokes the passed method on each pair of elements in every entry of <tt>ljpl</tt>.
|
|
* An entry of the passed <tt>ljpl</tt> has the form <tt>(Element x ElemMultiSet)</tt>. Now, let the ElemMultiSet be <tt>(l1, l2 ... ln)</tt>.
|
|
* Then, using the passed method <tt>subtractSets</tt> computes from such a pair <tt>(Element x (l1, l2 ... ln))</tt> a new pair
|
|
* <tt>(element x (method(Element,l1), method(Element,l2) ... method(Element,ln)))</tt>.<p>
|
|
* The method must have the signature <code>Element x Element -> Element</code> or
|
|
* <code>Element x Element -> ElemMultiSet</code>.
|
|
*
|
|
* @param ljpl the passed LeftJoinPairMultiSet
|
|
* @param method the method that is invoked on the elements
|
|
* @return the result set with the changed ElemMultiSet(s)
|
|
*/
|
|
public static LeftJoinPairMultiSet subtractSets (LeftJoinPairMultiSet ljpl, Method method) {
|
|
Iterator lit1 = ljpl.iterator();
|
|
Iterator lit2;
|
|
LeftJoinPair actLjp;
|
|
ElemMultiSet actList;
|
|
Element actElem1;
|
|
Element actElem2;
|
|
ElemMultiSet subList;
|
|
int paramTypeCount = Array.getLength(method.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
boolean metTypeElement = false;
|
|
boolean metTypeElemMultiSet = false;
|
|
|
|
//examine passed method
|
|
try {
|
|
if (method.getReturnType().isInstance(Class.forName("twodsack.setelement.Element")) ||
|
|
method.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.setelement.Element"))) {
|
|
metTypeElement = true; }
|
|
if (method.getReturnType().isInstance(Class.forName("twodsack.set.ElemMultiSet")) ||
|
|
method.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.set.ElemMultiSet"))) {
|
|
metTypeElemMultiSet = true; }
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.subtractSets: can't examine method.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
//traverse element sets
|
|
while (lit1.hasNext()) {
|
|
actLjp = (LeftJoinPair)((MultiSetEntry)lit1.next()).value;
|
|
actElem1 = actLjp.element;
|
|
actList = actLjp.elemSet;
|
|
if (!(actList == null)) {
|
|
lit2 = actList.iterator();
|
|
subList = new ElemMultiSet(ELEM_COMPARATOR);
|
|
while (lit2.hasNext()) {
|
|
actElem2 = (Element)((MultiSetEntry)lit2.next()).value;
|
|
//if method has one argument
|
|
if (paramTypeCount == 1) {
|
|
paramList[0] = actElem2; }
|
|
//if method has two arguments
|
|
else {
|
|
paramList[0] = actElem1;
|
|
paramList[1] = actElem2; }
|
|
try {
|
|
if (metTypeElement) {
|
|
subList.add((Element)(method.invoke(actElem1,paramList))); }
|
|
else if (metTypeElemMultiSet) {
|
|
subList.addAll((ElemMultiSet)(method.invoke(actElem1,paramList))); }
|
|
else {
|
|
System.out.println("Error in SetOps.subtractSets: can't invoke method");
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.subtractSets: Problem with using method.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
}//while
|
|
//substitute original elemSet with subList
|
|
actLjp.elemSet = subList;
|
|
}//if != null
|
|
}//while
|
|
|
|
return ljpl;
|
|
}//end method subtractSets
|
|
|
|
|
|
/**
|
|
* Returns a set of elements which is 'reduced' using the passed predicate and method.
|
|
* This is a variant of the normal {@link #reduce(ElemMultiSet,Method,Method)} operation. For the fuctionality of <tt>reduce</tt> itself,
|
|
* have a look at that method.<p>
|
|
* This is a recursive algorithm which uses graph algorithms to find groups of candidates for the invocation
|
|
* of the passed method. First note, that the predicate must be an 'overlap' predicate, i.e. is may only yield
|
|
* <tt>true</tt>, if the bounding boxes of both elements overlap or are adjacent at least. Additionally, the method
|
|
* may only return an object which bounding box lies inside of the bounding box of the bounding box of the
|
|
* objects it was constructed from (for clarification: the result may not be <i>bigger</i> than the original two
|
|
* objects.)<p>
|
|
* <tt>overlapReduce(el,PRED,METH,...)</tt> works as follows:<ol>
|
|
* <li> perform <tt>overlappingPairs</tt> on <tt>el</tt> to find all pairs of candidates, result is called <tt>PL</tt>; if <tt>earlyExit</tt>
|
|
* flag is set,
|
|
* throw an <tt>EarlyExit</tt> exception if neccessary
|
|
* <li> filter <tt>PL</tt> using <tt>PRED</tt>
|
|
* <li> if then, no pairs still exist, return <tt>el</tt>
|
|
* <li> build a graph with vertices (all elements of <tt>el</tt>) and edges; an edge exists between <tt>x,y</tt> (of <tt>el</tt>) if a pair
|
|
* <tt>(x,y)</tt> exists in <tt>PL</tt>
|
|
* <li> compute the connected components of that graph
|
|
* <li> for every component <tt>COMP</tt> of the connected components, do the following <ul>
|
|
* <li> compute a set of (independent) pairs of that component, such that no element is part of two pairs
|
|
* <li> invoke the method <tt>METH</tt> on all those pairs
|
|
* <li> replace every pair <tt>(x,y)</tt> with <tt>METH(x,y)</tt>
|
|
* <li> call <tt>overlapReduce(COMP,...)</tt>
|
|
* </ul></ol><p>
|
|
* The predicate must have the signature <code>Element x Element -> boolean</code> and method must have the signature
|
|
* <code>Element x Element -> ElemMultiSet</code>
|
|
*
|
|
* @param el the set that shall be reduced
|
|
* @param predicate according to this predicate, candidates are filtered
|
|
* @param method this method is invoked on the pairs of elements that were found
|
|
* @param ovLapPairsMeet this flag is passed to <tt>overlappingPairs()</tt>; if <tt>true</tt>, objects with adjacent bounding boxes are
|
|
* reported, too
|
|
* @param bboxFilter this flag is passed to <tt>overlappingPairs()</tt>; if <tt>true</tt>, in a pre-processing step the number of
|
|
* candidates is reduced by removing objects of <tt>el1,el2</tt> which don't overlap the unified bounding box of <tt>el1,el2</tt> resp.
|
|
* @param earlyExit if <tt>true</tt>, an <tt>EarlyExit</tt> exception is thrown immediately when the first object of <tt>elN</tt> is found which
|
|
* doesn't have a partner in <tt>elM</tt>, i.e. at least one element of <tt>elM</tt> which has a bounding box that overlaps the
|
|
* bounding box of the element of <tt>elN</tt>. <tt>N</tt> is the passed setNumber. <tt>earlyExit</tt> is evaluated in <tt>bboxFilter</tt>, so if shall
|
|
* be used, be sure that <tt>bboxFilter = true</tt>
|
|
* @param setNumber must be 1 or 2; specifies the set for <tt>earlyExit</tt>
|
|
* @return the 'reduced' set of elements
|
|
* @throws EarlyExit
|
|
*/
|
|
public static ElemMultiSet overlapReduce (ElemMultiSet el, Method predicate, Method method, boolean ovLapPairsMeet, boolean bboxFilter, boolean earlyExit, int setNumber)
|
|
throws EarlyExit {
|
|
ElemMultiSet retList = new ElemMultiSet(ELEM_COMPARATOR);
|
|
PairMultiSet pl;
|
|
try {
|
|
pl = overlappingPairs(el,el,true,ovLapPairsMeet,bboxFilter,earlyExit,setNumber);
|
|
} catch (NoOverlappingBoxFoundException nop) {
|
|
throw new EarlyExit();
|
|
}//catch
|
|
|
|
pl = filter(pl,predicate,true);
|
|
if (pl.isEmpty()) {
|
|
return el; }
|
|
Graph g = new Graph(el,pl);
|
|
ConnectedComponentsPair ccp = g.connectedComponents();
|
|
|
|
//the pairs from ccE must not be computed all at once
|
|
//so compute the set of pairs that may be computed
|
|
ccp = g.computeReducedPair(ccp);
|
|
|
|
ElemMultiSetList vertices = ccp.verticesToEMSList();
|
|
PairMultiSetList edges = ccp.edgesToPairListList();
|
|
|
|
ListIterator litE = edges.listIterator(0);
|
|
ListIterator litV = vertices.listIterator(0);
|
|
PairMultiSet actPL;
|
|
ElemMultiSet actEL;
|
|
ElemMultiSet ml = new ElemMultiSet(ELEM_COMPARATOR);
|
|
while (litE.hasNext()) {
|
|
actPL = (PairMultiSet)litE.next();
|
|
actEL = (ElemMultiSet)litV.next();
|
|
|
|
//if there are no pairs, get the isolated elements from actEL
|
|
if (!actPL.isEmpty()) {
|
|
ml = map(actPL,method); }
|
|
else { ml = new ElemMultiSet(ELEM_COMPARATOR); }
|
|
retList.addAll(overlapReduce(disjointUnion(ml,actEL),predicate,method,ovLapPairsMeet,bboxFilter,earlyExit,setNumber));
|
|
|
|
}//for i
|
|
rdup(retList);
|
|
return retList;
|
|
|
|
}//end method overlapReduce
|
|
|
|
|
|
/**
|
|
* Lets through pairs of the set depending on the predicate and the 'keep' flag.
|
|
* If <tt>keep = true</tt>, a pair <tt>(x,y)</tt> is kept if <tt>predicate(x,y) = true</tt>. All other pairs are deleted. If <tt>keep = false</tt>,
|
|
* the inverse set is returned.<p>
|
|
* The predicate must have the signature <code>Element x Element -> boolean</code>.
|
|
*
|
|
* @param plIn the set of pairs
|
|
* @param predicate the predicate that is used to filter the pairs
|
|
* @param keep if <tt>true</tt>, pairs are kept for which the predicate holds
|
|
* @return the filtered set
|
|
*/
|
|
public static PairMultiSet filter (PairMultiSet plIn, Method predicate, boolean keep) {
|
|
int paramTypeCount = Array.getLength(predicate.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
boolean predHolds = false;
|
|
Iterator it = plIn.iterator();
|
|
ElemPair actElem;
|
|
MultiSetEntry mse;
|
|
int number;
|
|
while (it.hasNext()) {
|
|
actElem = (ElemPair)((MultiSetEntry)it.next()).value;
|
|
|
|
//if predicate is non-static
|
|
if (paramTypeCount == 1) {
|
|
paramList[0] = actElem.second;
|
|
}//if
|
|
//if predicate is static
|
|
else {
|
|
paramList[0] = actElem.first;
|
|
paramList[1] = actElem.second;
|
|
}//else
|
|
|
|
try {
|
|
predHolds = (((Boolean)predicate.invoke(actElem.first,paramList)).booleanValue());
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" in SetOps.filter(PairList,Method,boolean). Can't invoke method '"+predicate+"' on");
|
|
actElem.first.print();
|
|
actElem.second.print();
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
if ((predHolds && !keep) ||
|
|
(!predHolds && keep)) { it.remove(); }
|
|
}//while
|
|
plIn.recomputeSize();
|
|
return plIn;
|
|
}//end method filter
|
|
|
|
|
|
/**
|
|
* Divides the elements of the passed set in groups according to the parameter predicate.<p>
|
|
* This is the 'overlap' variant of the ordinary {@link #group(ElemMultiSet,Method)}. The result of this method is a list of <tt>ElemMultiSet</tt>(s).
|
|
* For every pair of elements <tt>(x,y)</tt> of such a group (<tt>ElemMultiSet</tt>), <tt>predicate(x,y)</tt> holds.<p>
|
|
* First note, that the passed predicate must be an 'overlap' predicate. Such a predicate may only hold, if
|
|
* the bounding box of its parameter objects overlap or are adjacent at least.<p>
|
|
* This method works as follows:<ul>
|
|
* <li> call <tt>overlappingPairs</tt> to compute the candidate pairs; store the result in <tt>PL</tt>
|
|
* <li> filter <tt>PL</tt> using <tt>predicate</tt>
|
|
* <li> construct a graph from <tt>PL</tt> using <tt>ems</tt> as vertices and <tt>PL</tt> as edges
|
|
* <li> compute the connected components for that graph
|
|
* <li> store all elements of such a component in a single <tt>ElemMultiSet</tt>; store all <tt>ElemMultiSet</tt>(s) in
|
|
* a <tt>ElemMultiSetList</tt>
|
|
* <li> return that <tt>ElemMultiSetList</tt><p>
|
|
* The signature of the predicate must be <code>Element x Element -> boolean</code>.
|
|
*
|
|
* @param ems the set of elements that shall be divided in groups
|
|
* @param predicate the predicate that is used to filter the candidate pairs
|
|
* @param ovLapPairsMeet this flag is passed to <tt>overlappingPairs()</tt>; if <tt>true</tt>, objects with adjacent bounding boxes are
|
|
* reported, too
|
|
* @return the groups of elements
|
|
*/
|
|
public static ElemMultiSetList overlapGroup (ElemMultiSet ems, Method predicate, boolean ovLapPairsMeet) {
|
|
//find the overlapping pairs of elements
|
|
boolean sameSet = true;
|
|
boolean bboxFilter = false;
|
|
boolean earlyExit = false;
|
|
PairMultiSet pl = null;
|
|
|
|
double tt01 = System.currentTimeMillis();
|
|
|
|
try {
|
|
pl = overlappingPairs(ems,ems,sameSet,ovLapPairsMeet,bboxFilter,earlyExit,0);
|
|
} catch (Exception e) {
|
|
System.out.println("Unexpected error in SetOps.overlapGroup during execution of overlappingPairs.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
double tt02 = System.currentTimeMillis();
|
|
|
|
//filter method: remove pairs for which predicate doesn't hold
|
|
pl = filter(pl,predicate,true);
|
|
|
|
double tt03 = System.currentTimeMillis();
|
|
|
|
//construct a graph with vertices: elements and edges exist for pairs of elements
|
|
Graph g = new Graph(ems,pl);
|
|
|
|
double tt04 = System.currentTimeMillis();
|
|
|
|
//compute the connected components
|
|
ConnectedComponentsPair ccp = g.connectedComponents();
|
|
|
|
double tt05 = System.currentTimeMillis();
|
|
|
|
ElemMultiSetList retList = ccp.verticesToEMSList();
|
|
|
|
double tt06 = System.currentTimeMillis();
|
|
/*
|
|
System.out.println("\n+++++++++++++++++++++++++++++++++++++");
|
|
System.out.println("costs for overlapGroup (in detail):");
|
|
System.out.println("overlappingPairs: "+(tt02-tt01)+" ms");
|
|
System.out.println("filter: "+(tt03-tt02)+" ms");
|
|
System.out.println("construct graph: "+(tt04-tt03)+" ms");
|
|
System.out.println("connectedComponents: "+(tt05-tt04)+" ms");
|
|
System.out.println("construct result list: "+(tt06-tt05)+" ms");
|
|
System.out.println("+++++++++++++++++++++++++++++++++++++");
|
|
*/
|
|
return retList;
|
|
}//end method overlapGroup
|
|
|
|
|
|
/**
|
|
* Computes a join on two element sets.<p>
|
|
* This is a variant of the normal <tt>join</tt> operation which uses 'overlap' predicates.
|
|
* First note, that the passed predicate must be an 'overlap' predicate. Such a predicate may only hold, if
|
|
* the bounding box of its parameter objects overlap or are adjacent at least.<p>
|
|
* That 'overlap' predicate is also the join predicate. For all pairs <tt>(x,y)</tt> in the resulting set, that predicate holds.<p>
|
|
* The join is computed by first calling <tt>overlappingPairs(ems1,ems2,...)</tt>. After that, the resulting set is filtered
|
|
* using predicate.<p>
|
|
* The predicate must have the signature <code>Element x Element -> boolean</code>.
|
|
*
|
|
* @param ems1 the first set
|
|
* @param ems2 the second set
|
|
* @param predicate the join predicate
|
|
* @param ovLapPairsMeet this flag is passed to <tt>overlappingPairs()</tt>; if <tt>true</tt>, objects with adjacent bounding boxes are
|
|
* reported, too
|
|
* @param bboxFilter this flag is passed to <tt>overlappingPairs()</tt>; if <tt>true</tt>, in a pre-processing step the number of
|
|
* candidates is reduced by removing objects of <tt>el1,el2</tt> which don't overlap the unified bounding box of <tt>el1,el2</tt> resp.
|
|
* @param earlyExit if <tt>true</tt>, an <tt>EarlyExit</tt> exception is thrown immediately when the first object of <tt>elN</tt> is found which
|
|
* doesn't have a partner in <tt>elM</tt>, i.e. at least one element of <tt>elM</tt> which has a bounding box that overlaps the
|
|
* bounding box of the element of <tt>elN</tt>. <tt>N</tt> is the passed setNumber. <tt>earlyExit</tt> is evaluated in <tt>bboxFilter</tt>, so if shall
|
|
* be used, be sure that <tt>bboxFilter = true</tt>
|
|
* @param setNumber must be 1 or 2; specifies the set for <tt>earlyExit</tt>
|
|
* @return the PairMultiSet as join of <tt>ems1</tt> and <tt>ems2</tt>
|
|
* @throws EarlyExit
|
|
*/
|
|
public static PairMultiSet overlapJoin (ElemMultiSet ems1, ElemMultiSet ems2, Method predicate, boolean ovLapPairsMeet, boolean bboxFilter, boolean earlyExit, int setNumber)
|
|
throws EarlyExit {
|
|
PairMultiSet retSet;
|
|
try {
|
|
retSet = overlappingPairs(ems1,ems2,false,ovLapPairsMeet,bboxFilter,earlyExit,setNumber);
|
|
} catch (NoOverlappingBoxFoundException nop) {
|
|
throw new EarlyExit();
|
|
}//catch
|
|
|
|
retSet = filter(retSet,predicate,true);
|
|
|
|
return retSet;
|
|
}//end method overlapJoin
|
|
|
|
|
|
/**
|
|
* This method constructs groups from the passed set such that for every element <tt>e</tt> in a group another element <tt>f</tt> can be found with <tt>predicate(e,f) = true</tt>.<p>
|
|
* Example: Let the original set be <tt>{a,b,c,d}</tt>. Assume, that the predicate <tt>p</tt> holds for the pairs <tt>(a,b),(b,c)</tt>.
|
|
* Then, the resulting groups are <tt>{a,b,c}, {d}</tt>.<p>
|
|
* The predicate's signature must be: <tt>Element x Element -> boolean</tt>
|
|
*
|
|
* @param ems the set that shall be divided in groups
|
|
* @param predicate the predicate that is responsible for the division into groups
|
|
* @return the list of groups
|
|
* @see #overlapGroup(ElemMultiSet,Method,boolean)
|
|
*/
|
|
public static ElemMultiSetList group (ElemMultiSet ems, Method predicate) {
|
|
/*
|
|
* This method works as follows: It traverses ems and for each element E it checks all already existing groups.
|
|
* It traverses each group. For each element F of such group it invokes predicate(E,F) until the predicate holds.
|
|
* Then, it stores the group in a special list. This is done for each group. The reason why this complicated
|
|
* computation is needed is that a new element E can _combine_ two or more groups. Therefore, all groups must be visited.
|
|
* After all groups were checked, all groups in the special list are joined. If there is no entry in the special list
|
|
* a new group is build for E.
|
|
*/
|
|
|
|
ElemMultiSetList retList = new ElemMultiSetList();
|
|
|
|
if (ems == null || ems.isEmpty()) return retList;
|
|
int paramTypeCount = Array.getLength(predicate.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
|
|
Iterator it = ems.iterator();
|
|
Iterator itRL, it2;
|
|
Element actElem1, actElem2;
|
|
ElemMultiSet actGroup;
|
|
boolean belongsToGroup = false;
|
|
LinkedList idxList = new LinkedList();
|
|
|
|
//traverse elements of ems
|
|
while (it.hasNext()) {
|
|
actElem1 = (Element)((MultiSetEntry)it.next()).value;
|
|
belongsToGroup = false;
|
|
idxList.clear();
|
|
|
|
if (retList.isEmpty()) {
|
|
//build new group and add it to retList
|
|
ElemMultiSet group = new ElemMultiSet(ELEM_COMPARATOR);
|
|
group.add(actElem1);
|
|
retList.add(group);
|
|
} else {
|
|
//other groups already exist
|
|
itRL = retList.listIterator(0);
|
|
while (itRL.hasNext()) {
|
|
actGroup = (ElemMultiSet)itRL.next();
|
|
|
|
it2 = actGroup.iterator();
|
|
while (it2.hasNext()) {
|
|
actElem2 = (Element)((MultiSetEntry)it2.next()).value;
|
|
if (paramTypeCount == 1)
|
|
//predicate is non-static
|
|
paramList[0] = actElem2;
|
|
else {
|
|
//predicate is static
|
|
paramList[0] = actElem1;
|
|
paramList[1] = actElem2;
|
|
}//else
|
|
|
|
//evaluate predicate
|
|
try {
|
|
belongsToGroup = ((Boolean)predicate.invoke(actElem1,paramList)).booleanValue();
|
|
} catch (Exception e) {
|
|
System.out.println("Error in SetOps.group: Wasn't able to invoke predicate.");
|
|
e.printStackTrace();
|
|
}//catch
|
|
|
|
System.out.println(belongsToGroup);
|
|
|
|
if (belongsToGroup) {
|
|
//actGroup.add(actElem2);
|
|
idxList.add(actGroup);
|
|
break;
|
|
}//if
|
|
}//while it2
|
|
}//while itRL
|
|
|
|
if (belongsToGroup || !idxList.isEmpty()) {
|
|
//merge all groups for which belongsToGroup was true
|
|
|
|
while (idxList.size() > 1) {
|
|
((ElemMultiSet)idxList.get(idxList.size()-2)).addAll((ElemMultiSet)idxList.get(idxList.size()-1));
|
|
//clear and remove second set
|
|
((ElemMultiSet)idxList.get(idxList.size()-1)).clear();
|
|
idxList.remove(idxList.size()-1);
|
|
}//while
|
|
|
|
//now, add the new element
|
|
((ElemMultiSet)idxList.get(0)).add(actElem1);
|
|
|
|
//remove all empty groups from retList
|
|
itRL = retList.listIterator(0);
|
|
while (itRL.hasNext()) {
|
|
actGroup = (ElemMultiSet)itRL.next();
|
|
if (actGroup.isEmpty()) itRL.remove();
|
|
}//while
|
|
|
|
} else {
|
|
//actElem doesn't belong to any group
|
|
//build new group and add it to retList
|
|
|
|
ElemMultiSet group = new ElemMultiSet(ELEM_COMPARATOR);
|
|
group.add(actElem1);
|
|
retList.add(group);
|
|
}//else
|
|
}//else other groups exist
|
|
}//while it hasNext
|
|
|
|
return retList;
|
|
}//end method group
|
|
|
|
|
|
/**
|
|
* This map method invokes the <tt>secMethod</tt> on pairs of elements of <tt>ljpl</tt> for which the <tt>predicate</tt> holds.<p>
|
|
* The <tt>mainMethod</tt> itself must be a set operation with the signature <code>ElemMultiSet x ElemMultiSet x predicate
|
|
* x secMethod -> ElemMultiSet</code>. Such a method can be found in this class.
|
|
* Then, this map operation only splits every entry of <tt>ljpl</tt> and calls
|
|
* <tt>mainMethod</tt> with the two objects of the entry and the parameters <tt>predicate</tt> and <tt>secMethod</tt>.<p>
|
|
* The signatures for predicate and secMethod have to be <code>Element x Element -> boolean</code> and
|
|
* <code>Element x Element -> Element</code>, resp.<p>
|
|
* The resulting sets of mainMethods are collected and stored in the result set.
|
|
* @param ljpl the 'in' set
|
|
* @param mainMethod this method is called for every entry of <tt>ljpl</tt>
|
|
* @param predicate the predicate is passed to <tt>mainMethod</tt>
|
|
* @param secMethod this method is passed to <tt>mainMethod</tt>
|
|
* @return the union of the results of <tt>mainMethod</tt>
|
|
*/
|
|
public static ElemMultiSet map (LeftJoinPairMultiSet ljpl, Method mainMethod, Method predicate, Method secMethod) {
|
|
ElemMultiSet retList = new ElemMultiSet(ELEM_COMPARATOR);
|
|
Object[] paramListMM = new Object[4];
|
|
|
|
ElemMultiSet paramList1 = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
Iterator lit = ljpl.iterator();
|
|
LeftJoinPair actLjp;
|
|
while (lit.hasNext()) {
|
|
actLjp = (LeftJoinPair)((MultiSetEntry)lit.next()).value;
|
|
//if second list is not empty do the computation
|
|
if (!(actLjp.elemSet == null) && !actLjp.elemSet.isEmpty()) {
|
|
try {
|
|
paramList1.clear();
|
|
paramList1.add(actLjp.element);
|
|
paramListMM[0] = paramList1;
|
|
paramListMM[1] = actLjp.elemSet;
|
|
paramListMM[2] = predicate;
|
|
paramListMM[3] = secMethod;
|
|
|
|
retList.addAll((ElemMultiSet)mainMethod.invoke(null,paramListMM));
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.map(ljpl,m,m,m). Can't invoke method "+mainMethod);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
}//if
|
|
else { retList.add(actLjp.element); }
|
|
}//for i
|
|
|
|
return retList;
|
|
}//end method map
|
|
|
|
|
|
/**
|
|
* Perfoms a projection on the first element.
|
|
* The first partner of every pair is stored in the result set.
|
|
*
|
|
* @param pl the 'in' set
|
|
* @return the projection on the first element
|
|
*/
|
|
public static ElemMultiSet proj1 (PairMultiSet pl) {
|
|
ElemMultiSet retSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
Iterator it = pl.iterator();
|
|
while (it.hasNext()) retSet.add(((ElemPair)((MultiSetEntry)it.next()).value).first);
|
|
|
|
return retSet;
|
|
}//end method proj1
|
|
|
|
|
|
/**
|
|
* Performs a projection on the second element.
|
|
* The second partner of every pair is stored in the result set.
|
|
*
|
|
* @param pl the 'in' set
|
|
* @return the projection on the second element
|
|
*/
|
|
public static ElemMultiSet proj2 (PairMultiSet pl) {
|
|
ElemMultiSet retSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
Iterator it = pl.iterator();
|
|
while (it.hasNext()) retSet.add(((ElemPair)((MultiSetEntry)it.next()).value).second);
|
|
|
|
return retSet;
|
|
}//end method proj2
|
|
|
|
|
|
/**
|
|
* Returns <tt>true</tt>, if both sets are disjoint.
|
|
* Takes use of the <tt>intersects()</tt> method which must be implemented for each type which implements the {@link Element} interface.
|
|
* An <tt>overlapJoin()</tt> is computed using that <tt>intersects()</tt> method. If the result is empty, <tt>true</tt> is returned.
|
|
* <tt>false</tt> otherwise.
|
|
*
|
|
* @param ems1 the first set
|
|
* @param ems2 the second set
|
|
* @return <tt>true</tt>, if <tt>ems1,ems2</tt> are disjoint
|
|
*/
|
|
public static boolean disjoint (ElemMultiSet ems1, ElemMultiSet ems2) {
|
|
if (ems1 == null || ems1.isEmpty() ||
|
|
ems2 == null || ems2.isEmpty()) return true;
|
|
|
|
Class [] paramList = new Class [1];
|
|
PairMultiSet rms = new PairMultiSet(ELEMPAIR_COMPARATOR);
|
|
Class c = ems1.first().getClass();
|
|
|
|
try {
|
|
paramList[0] = Class.forName("twodsack.setelement.Element");
|
|
Method intersectsM = c.getMethod("intersects",paramList);
|
|
rms = overlapJoin(ems1,ems2,intersectsM,true,true,false,0);
|
|
} catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.disjoint. Can't get Method intersects.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
if (rms.isEmpty()) { return true; }
|
|
else { return false; }
|
|
}//end method disjoint
|
|
|
|
|
|
/**
|
|
* Returns true, if both sets are equal.<p>
|
|
* Uses the <tt>compare()</tt> method which must be implemented for every type which implements the {@link Element} interface.<p>
|
|
* Throws a <tt>WrongTypeException</tt>, if the sets are not of the same type.<p>
|
|
* Note, that <tt>equal((a,a,b), (a,b))</tt> returns <tt>false</tt>.
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @return <tt>true</tt>, if both sets are equal
|
|
*/
|
|
public static boolean equal (ElemMultiSet el1, ElemMultiSet el2) throws WrongTypeException {
|
|
if (el1.size() != el2.size()) return false;
|
|
|
|
Iterator it1 = el1.iterator();
|
|
Iterator it2 = el2.iterator();
|
|
ElemComparator ec = ELEM_COMPARATOR;
|
|
|
|
while (it1.hasNext())
|
|
if (ec.compare(it1.next(),it2.next()) != 0)
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}//end method equal
|
|
|
|
|
|
/**
|
|
* For two sets <tt>E,F</tt> and a predicate <tt>p</tt> this method returns a set of {@link LeftJoinPair}s where the first elements of the pairs are elements of <tt>E</tt> and their partners are elements of <tt>F</tt>.
|
|
* Each element of <tt>E</tt> appears exactly once in the resulting {@link LeftJoinPairMultiSet}. For all of the partners of such an
|
|
* element <tt>e</tt>, <tt>p(e,g)</tt>, <tt>g</tt> element of the partner set of <tt>e</tt>, holds.<p>
|
|
* Given an example, if <tt>E,F</tt> are sets of triangles and <tt>p</tt> is a predicate <tt>overlap: Triangle x Triangle -> boolean</tt>.
|
|
* <tt>E = {a,b,c,d}, F = {e,f,g}</tt>. Now, <tt>e</tt> overlaps <tt>a,b</tt> and <tt>g</tt> overlaps <tt>a,b,c</tt>. Then the result would be:<p>
|
|
* <tt>{<br>
|
|
* (a x {e,g}),<br>
|
|
* (b x {e,g}),<br>
|
|
* (c x {g}),<br>
|
|
* (d x {})<br>
|
|
* }</tt><p>
|
|
* The predicate must have the signature: <tt>Element x Element -> boolean</tt>.
|
|
*
|
|
* @param ems1 the first set
|
|
* @param ems2 the second set
|
|
* @param predicate the join predicate used to construct the <tt>LeftJoinPair</tt>s
|
|
* @return the resulting <tt>LeftJoinPairMultiSet</tt>
|
|
* @see #overlapLeftOuterJoin(ElemMultiSet,ElemMultiSet,Method,boolean,boolean,boolean,int)
|
|
*/
|
|
public static LeftJoinPairMultiSet leftOuterJoin (ElemMultiSet ems1, ElemMultiSet ems2, Method predicate) {
|
|
LeftJoinPairMultiSet retSet = new LeftJoinPairMultiSet(LEFTJOINPAIR_COMPARATOR);
|
|
int paramTypeCount = Array.getLength(predicate.getParameterTypes());
|
|
boolean predHolds = false;
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
|
|
Iterator it1 = ems1.iterator();
|
|
Iterator it2;
|
|
Element actElem1,actElem2;
|
|
|
|
//traverse the first set
|
|
while (it1.hasNext()) {
|
|
actElem1 = (Element)((MultiSetEntry)it1.next()).value;
|
|
|
|
//construct new LeftJoinPair and initialize values
|
|
LeftJoinPair newLjp = new LeftJoinPair();
|
|
newLjp.element = actElem1;
|
|
newLjp.elemSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
//traverse the second set
|
|
it2 = ems2.iterator();
|
|
while (it2.hasNext()) {
|
|
actElem2 = (Element)((MultiSetEntry)it2.next()).value;
|
|
|
|
//set paramList
|
|
if (paramTypeCount == 1)
|
|
//predicate is non-static
|
|
paramList[0] = actElem2;
|
|
else {
|
|
//predicate is static
|
|
paramList[0] = actElem1;
|
|
paramList[1] = actElem2;
|
|
}//else
|
|
|
|
//invoke predicate
|
|
try {
|
|
predHolds = ((Boolean)predicate.invoke(actElem1,paramList)).booleanValue();
|
|
} catch (Exception e) {
|
|
System.out.println("Error in SetOps.leftOuterJoin: Can't invoke predicate.");
|
|
e.printStackTrace();
|
|
}//catch
|
|
|
|
//add element to elemSet if predHolds == true
|
|
if (predHolds)
|
|
newLjp.elemSet.add(actElem2);
|
|
}//while it2
|
|
|
|
//add new LeftJoinPair to retSet
|
|
retSet.add(newLjp);
|
|
}//while it1
|
|
|
|
return retSet;
|
|
}//end method leftOuterJoin
|
|
|
|
|
|
|
|
/**
|
|
* For every pair <tt>(Element x ElemMultiSet)</tt> of <tt>ljpMS</tt> the method is invoked on that pair if the predicate holds.
|
|
* The predicate may be <tt>NULL</tt>. If so, it is assumed, that the predicate holds for all pairs of <tt>ljpMS</tt>. Then, the
|
|
* method is invoked on all entries with no further checks.<p>
|
|
* For every {@link LeftJoinPair}, the <tt>method</tt> is invoked on that pair, if the <tt>predicate</tt> holds (if not <tt>NULL</tt>). Then, the
|
|
* result of the method invocation is stored in <tt>LeftJoinPair.elemSet</tt>, i.e. it replaces the original
|
|
* <tt>ElemMultiSet</tt>. The first argument of the method (the <tt>Element</tt>) remains unchanged.<p>
|
|
* The allowed signature for predicate is <code>Element x ElemMultiSet -> boolean</code>. The method must have
|
|
* the signature <code>Element x ElemMultiSet -> ElemMultiSet</code>.
|
|
*
|
|
* @param ljpMS the 'in' set
|
|
* @param predicate it checks whether the <tt>method</tt> may be invoked on a pair; may be <tt>NULL</tt>
|
|
* @param method is invoked on each pair for which the predicate holds
|
|
* @return the changed <tt>leftJoinPairMultiSet</tt>
|
|
*/
|
|
public static LeftJoinPairMultiSet map (LeftJoinPairMultiSet ljpMS, Method predicate, Method method) {
|
|
boolean predOkay = (predicate != null);
|
|
int paramTypeCountP = 0;
|
|
Object[] paramListP = null;
|
|
if (predOkay) {
|
|
paramTypeCountP = Array.getLength(predicate.getParameterTypes());
|
|
paramListP = new Object[paramTypeCountP];
|
|
}//if
|
|
int paramTypeCountM = Array.getLength(method.getParameterTypes());
|
|
Object[] paramListM = new Object[paramTypeCountM];
|
|
ElemMultiSet returnSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
Iterator it = ljpMS.iterator();
|
|
LeftJoinPair actLJP;
|
|
Element actElem;
|
|
ElemMultiSet actSet;
|
|
boolean isTrue = false;
|
|
ElemMultiSet mResult = null;
|
|
while (it.hasNext()) {
|
|
actLJP = (LeftJoinPair)((MultiSetEntry)it.next()).value;
|
|
actElem = actLJP.element;
|
|
actSet = actLJP.elemSet;
|
|
|
|
//if predicate is okay and non-static
|
|
if (predOkay) {
|
|
if (paramTypeCountP == 1) {
|
|
paramListP[0] = actSet; }
|
|
else {
|
|
paramListP[0] = actElem;
|
|
paramListP[1] = actSet;
|
|
}//else
|
|
|
|
//compute boolean value for predicate
|
|
try {
|
|
isTrue = ((Boolean)predicate.invoke(actElem,paramListP)).booleanValue();
|
|
} catch (Exception e) {
|
|
System.out.println("\nException in SetOps.map(ljpMS,pred,met) when computing boolean value.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
}//if
|
|
else isTrue = true;
|
|
|
|
if (isTrue) {
|
|
//if method has one argument
|
|
if (paramTypeCountM == 1)
|
|
paramListM[0] = actSet;
|
|
else {
|
|
paramListM[0] = actElem;
|
|
paramListM[1] = actSet;
|
|
}//else
|
|
|
|
//invoke method
|
|
try {
|
|
mResult = (ElemMultiSet)method.invoke(actElem,paramListM);
|
|
} catch (Exception e) {
|
|
System.out.println("Exception in SetOps.map(ljpMS,pred,met) when invoking method.");
|
|
System.out.println("\nmethod: "+method);
|
|
System.out.println("\nactElem: "+actElem);
|
|
System.out.println("\nparamListM[0]: "+paramListM[0]);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
//set result
|
|
actLJP.elemSet = mResult;
|
|
}//if isTrue
|
|
}//while it.hasNext
|
|
|
|
return ljpMS;
|
|
}//end method map
|
|
|
|
|
|
/**
|
|
* As long as a pair <tt>e1</tt> of <tt>el1 x e2</tt> of <tt>el2</tt> exists which <tt>predicate(e1,e2) == true</tt>, replace <tt>e1</tt> in <tt>el</tt> with <tt>method(e1,e2)</tt>.
|
|
* The <tt>predicate</tt> and <tt>method</tt> must have the signature <code>Element x Element -> boolean</code> and
|
|
* <code>Element x Element -> Element</code> (of the same type as <tt>el1</tt>), resp.<p>
|
|
* This is a very expensive operation w.r.t. time consumption!
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @param predicate chooses the candidates for <tt>method</tt>
|
|
* @param method is invoked on candidates selected by <tt>predicate</tt>
|
|
* @return the 'subtracted' set
|
|
*/
|
|
public static ElemMultiSet subtract (ElemMultiSet el1, ElemMultiSet el2, Method predicate, Method method) {
|
|
int paramTypeCountPred = Array.getLength(predicate.getParameterTypes());
|
|
int paramTypeCountMet = Array.getLength(method.getParameterTypes());
|
|
ElemMultiSet retSet = (ElemMultiSet)el1.clone();
|
|
ElemMultiSet paramList = (ElemMultiSet)el2.clone();
|
|
boolean stillExist = false;
|
|
boolean isTrue = false;
|
|
Element[] paramListP = new Element[paramTypeCountPred];
|
|
Element[] paramListM = new Element[paramTypeCountMet];
|
|
|
|
ElemMultiSet mreturn = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
Iterator lit1;
|
|
Iterator lit2;
|
|
Element actEl1;
|
|
Element actEl2;
|
|
ElemMultiSet finalSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
MultiSetEntry mse1;
|
|
|
|
do {
|
|
stillExist = false;
|
|
lit1 = retSet.iterator();
|
|
while (lit1.hasNext()) {
|
|
mse1 = (MultiSetEntry)lit1.next();
|
|
actEl1 = (Element)mse1.value;
|
|
|
|
isTrue = false;
|
|
lit2 = paramList.iterator();
|
|
while (lit2.hasNext()) {
|
|
actEl2 = (Element)((MultiSetEntry)lit2.next()).value;
|
|
|
|
//if predicate has one argument
|
|
if (paramTypeCountPred == 1) {
|
|
paramListP[0] = actEl2;
|
|
}//if
|
|
|
|
//if predicate has two arguments
|
|
else {
|
|
paramListP[0] = actEl1;
|
|
paramListP[1] = actEl2;
|
|
}//else
|
|
try {
|
|
isTrue = ((Boolean)predicate.invoke(actEl1,paramListP)).booleanValue();
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.subtract(el,el,pr,m).");
|
|
System.out.println("Cause for Exception: "+e.getCause());
|
|
System.out.println("Exception String: "+e.toString());
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
if (isTrue) {
|
|
//if method has one argument
|
|
if (paramTypeCountMet == 1) {
|
|
paramListM[0] = actEl2;
|
|
}//if
|
|
//if method has two arguments
|
|
else {
|
|
paramListM[0] = actEl1;
|
|
paramListM[1] = actEl2;
|
|
}//else
|
|
try {
|
|
mreturn = (ElemMultiSet)(method.invoke(actEl1,paramListM));
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.subtract(el,el,pr,m). Can't invoke method "+method);
|
|
System.out.println("Cause for Exception: "+e.getCause());
|
|
System.out.println("Exception String: "+e.toString());
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
if (isTrue) {
|
|
//copy first elements of retSet to finalSet
|
|
//these elements are not needed anymore
|
|
SortedSet ss = retSet.treeSet().headSet(mse1);
|
|
Iterator tempIt = ss.iterator();
|
|
while (tempIt.hasNext()) {
|
|
finalSet.add((Element)((MultiSetEntry)tempIt.next()).value); }
|
|
|
|
retSet.removeAllOfThisKind(actEl1);
|
|
retSet.addAll(mreturn);
|
|
mreturn = null;
|
|
stillExist = true;
|
|
lit1 = retSet.iterator();
|
|
break;
|
|
}//if
|
|
|
|
if (retSet.isEmpty()) { break; }
|
|
}//if
|
|
}//for j
|
|
if (retSet.isEmpty()) {
|
|
break; }
|
|
}//for i
|
|
}//do
|
|
while (stillExist);
|
|
|
|
//copy all elements of retSet to finalSet
|
|
Iterator tmpIt = retSet.iterator();
|
|
while (tmpIt.hasNext()) {
|
|
finalSet.add((Element)((MultiSetEntry)tmpIt.next()).value); }
|
|
|
|
return finalSet;
|
|
}//end method subtract
|
|
|
|
|
|
/**
|
|
* Returns a pair of elements which returns the maximum value of all possible pairs of <tt>ems1,ems2</tt> using method.<p>
|
|
* All pairs of <tt>e1</tt> of <tt>ems1</tt> and <tt>e2</tt> of <tt>ems2</tt> are checked for their return value of
|
|
* <tt>method(e1,e2)</tt>. That pair, which returns
|
|
* the maximum value of all pairs, is returned.<p>
|
|
* The passed method must have the signature <code>Element x Element -> Rational</code>.
|
|
*
|
|
* @param ems1 the first set
|
|
* @param ems2 the second set
|
|
* @param method the method that is used to compute the values for <tt>ElemPair</tt>(s)
|
|
* @return the pair with the maximum value
|
|
*/
|
|
public static ElemPair max (ElemMultiSet ems1, ElemMultiSet ems2, Method method) {
|
|
Element elem1 = (Element)ems1.first();
|
|
Element elem2 = (Element)ems2.first();
|
|
Rational maximum = RationalFactory.constRational(0); // just for initialization
|
|
Rational value = RationalFactory.constRational(0); //dto.
|
|
int paramTypeCount = Array.getLength(method.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
|
|
//initialization
|
|
try {
|
|
//if method has one argument
|
|
if (paramTypeCount ==1) paramList[0] = (Element)ems2.first();
|
|
//if method has two arguments (is static)
|
|
else {
|
|
paramList[0] = (Element)ems1.first();
|
|
paramList[1] = (Element)ems2.first();
|
|
}//else
|
|
maximum = ((Rational)method.invoke(elem1,paramList));
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.max. Can't invoke method "+method);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
Iterator it1 = ems1.iterator();
|
|
Iterator it2;
|
|
Element actElem1;
|
|
Element actElem2;
|
|
|
|
while (it1.hasNext()) {
|
|
actElem1 = (Element)((MultiSetEntry)it1.next()).value;
|
|
it2 = ems2.iterator();
|
|
while (it2.hasNext()) {
|
|
actElem2 = (Element)((MultiSetEntry)it2.next()).value;
|
|
try {
|
|
//if method has one argument
|
|
if (paramTypeCount == 1) {
|
|
paramList[0] = actElem2;
|
|
}//if
|
|
//if method has two arguments (is static)
|
|
else {
|
|
paramList[0] = actElem1;
|
|
paramList[1] = actElem2;
|
|
}//else
|
|
value = ((Rational)method.invoke(actElem1,paramList));
|
|
} catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.max. Can't invoke method "+method);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
if (value.greater(maximum)) {
|
|
maximum = value.copy();
|
|
elem1 = actElem1;
|
|
elem2 = actElem2;
|
|
}//if
|
|
}//while it2
|
|
}//while it1
|
|
|
|
return new ElemPair(elem1,elem2);
|
|
}//end method max
|
|
|
|
|
|
/**
|
|
* Returns a pair of elements which returns the minimum value of all possible pairs of <tt>ems1,ems2</tt> using method.<p>
|
|
* All pairs of <tt>e1</tt> of <tt>ems1</tt> and <tt>e2</tt> of <tt>ems2</tt> are checked for their return value of
|
|
* <tt>method(e1,e2)</tt>. That pair, which returns
|
|
* the minimum value of all pairs, is returned.<p>
|
|
* The passed method must have the signature <code>Element x Element -> Rational</code>.
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @param method the method that is used to compute the values for <tt>ElemPair</tt>(s)
|
|
* @return the pair with the maximum value
|
|
*/
|
|
public static ElemPair min (ElemMultiSet el1, ElemMultiSet el2, Method method) {
|
|
if (el1 == null || el1.isEmpty() || el2 == null || el2.isEmpty()) return null;
|
|
|
|
Element elem1 = (Element)el1.first();
|
|
Element elem2 = (Element)el2.first();;
|
|
Rational value = null;
|
|
int paramTypeCount = Array.getLength(method.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
Rational minimum = null;
|
|
|
|
//initialization
|
|
try {
|
|
//if method has one argument
|
|
if (paramTypeCount == 1) {
|
|
paramList[0] = (Element)el2.first();
|
|
}//if
|
|
//if method has two arguments (is static)
|
|
else {
|
|
paramList[0] = (Element)el1.first();
|
|
paramList[1] = (Element)el2.first();
|
|
}//else
|
|
minimum = ((Rational)method.invoke(el1.first(),paramList));
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.min. Can't invoke method "+method);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
Iterator it1 = el1.iterator();
|
|
Iterator it2;
|
|
Element actElem1;
|
|
Element actElem2;
|
|
|
|
while (it1.hasNext()) {
|
|
actElem1 = (Element)((MultiSetEntry)it1.next()).value;
|
|
it2 = el2.iterator();
|
|
while (it2.hasNext()) {
|
|
actElem2 = (Element)((MultiSetEntry)it2.next()).value;
|
|
//if method has one argument
|
|
if (paramTypeCount == 1) {
|
|
paramList[0] = actElem2;
|
|
}//if
|
|
//if method has two arguments (is static)
|
|
else {
|
|
paramList[0] = actElem1;
|
|
paramList[1] = actElem2;
|
|
}//else
|
|
try {
|
|
value = ((Rational)method.invoke(actElem1,paramList));
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.min. Can't invoke method "+method);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
if (value.equal(0)) return new ElemPair(actElem1,actElem2);
|
|
|
|
if (value.less(minimum)) {
|
|
minimum = value.copy();
|
|
elem1 = actElem1;
|
|
elem2 = actElem2;
|
|
}//if
|
|
}//while j
|
|
}//while i
|
|
|
|
return new ElemPair(elem1,elem2);
|
|
}//end method min
|
|
|
|
|
|
/**
|
|
* As long as a pair <tt>e1,e2</tt> of <tt>el</tt> exists with <tt>predicate(e1,e2) == true</tt>, replace both elements by <tt>method(e1,e2)</tt>.<p>
|
|
* The reduce operation traverses the set <tt>el</tt> and searches for pairs of elements for which the <tt>predicate</tt> holds.
|
|
* If such a pair is found, both elements are removed from the set and the result of the <tt>method</tt> invoked on that
|
|
* pair is added to the set. If, at some point, no such pair can be found, reduce exits and returns the 'reduced' set.<p>
|
|
* The <tt>predicate</tt> must have the signature <code>Element x Element -> boolean</code>. The <tt>method</tt> must have the signature
|
|
* <code>Element x Element -> Element</code> (of the same type).<p>
|
|
* This method is very time consuming. Some other implementations of <tt>reduce</tt> exist and can be found in this class.
|
|
*
|
|
* @param el the 'in' set that shall be reduced
|
|
* @param predicate checks for candidates for the method
|
|
* @param method is invoked on the candidates found by the predicate
|
|
* @return the 'reduced' set
|
|
* @see #overlapReduce(ElemMultiSet,Method,Method,boolean,boolean,boolean,int)
|
|
* @see #overlapReduceSweep(ElemMultiSet,Method,Method,boolean)
|
|
*/
|
|
public static ElemMultiSet reduce (ElemMultiSet el, Method predicate, Method method) {
|
|
ElemMultiSet retSet = el.copy();
|
|
|
|
boolean stillExist;
|
|
boolean isTrue;
|
|
int paramTypeCountPred = Array.getLength(predicate.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCountPred];
|
|
Element[] paramListMet = new Element[2];
|
|
|
|
Element actElem1;
|
|
Element actElem2;
|
|
//these variables are used to determine wether the method
|
|
//has return type Element or ElemList
|
|
boolean metTypeElement = false;
|
|
boolean metTypeElemMultiSet = false;
|
|
|
|
try {
|
|
if (method.getReturnType().isInstance(Class.forName("twodsack.setelement.Element")) ||
|
|
method.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.setelement.Element"))) {
|
|
metTypeElement = true; }
|
|
if (method.getReturnType().isInstance(Class.forName("twodsack.set.ElemMultiSet")) ||
|
|
method.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.set.ElemMultiSet"))) {
|
|
metTypeElemMultiSet = true; }
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.reduce: can't examine method.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
//NEW CODE WITH ITERATORS AND MULTISETS
|
|
Iterator it1;
|
|
Iterator it2;
|
|
MultiSetEntry mse1;
|
|
int number1;
|
|
MultiSetEntry mse2;
|
|
int number2;
|
|
|
|
//first, handle multiple elements:
|
|
//the set is traversed and for all duplicates, the entries are replaced by the method result,
|
|
//if the predicate holds
|
|
it1 = retSet.iterator();
|
|
while(it1.hasNext()) {
|
|
mse1 = (MultiSetEntry)it1.next();
|
|
if (mse1.number > 1) {
|
|
//check for predicate
|
|
|
|
//if predicate has one argument
|
|
if (paramTypeCountPred == 1)
|
|
paramList[0] = (Element)mse1.value;
|
|
//if predicate has two arguments (is static)
|
|
else {
|
|
paramList[0] = (Element)mse1.value;
|
|
paramList[1] = (Element)mse1.value;
|
|
}//else
|
|
isTrue = false;
|
|
try {
|
|
isTrue = ((Boolean)predicate.invoke(mse1.value,paramList)).booleanValue();
|
|
} catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.reduce: Problem with using predicate.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
if (isTrue) {
|
|
paramListMet[0] = (Element)mse1.value;
|
|
paramListMet[1] = (Element)mse1.value;
|
|
try {
|
|
//if method has returnType Element
|
|
if (metTypeElement)
|
|
retSet.add((Element)(method.invoke(null,paramListMet)));
|
|
else {
|
|
if (metTypeElemMultiSet)
|
|
retSet.addAll((ElemMultiSet)(method.invoke(null,paramListMet)));
|
|
else {
|
|
System.out.println("ERROR in SO.reduce(): can't invoke method");
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//else
|
|
}//else
|
|
} catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.reduce: Problem with using method.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
//remove element from set
|
|
it1.remove();
|
|
}//if isTrue
|
|
}//if mse1.number > 1
|
|
}//while it.hasNext
|
|
|
|
//now, all duplicates should be removed
|
|
|
|
//start processing the remaining elements
|
|
|
|
do {
|
|
//reset loop variables
|
|
stillExist = false;
|
|
isTrue = false;
|
|
|
|
it1 = retSet.iterator();
|
|
while (it1.hasNext()) {
|
|
//get element from first set
|
|
mse1 = (MultiSetEntry)it1.next();
|
|
actElem1 = (Element)mse1.value;
|
|
isTrue = false;
|
|
it2 = retSet.iterator();
|
|
while (it2.hasNext()) {
|
|
//get element from second set
|
|
mse2 = (MultiSetEntry)it2.next();
|
|
if (((Object)mse2).equals((Object)mse1))
|
|
if (it2.hasNext()) mse2 = (MultiSetEntry)it2.next();
|
|
else break;
|
|
|
|
number2 = mse2.number;
|
|
actElem2 = (Element)mse2.value;
|
|
|
|
//if predicate has one argument
|
|
if (paramTypeCountPred == 1)
|
|
paramList[0] = actElem2;
|
|
//if predicate has two arguments (is static)
|
|
else {
|
|
paramList[0] = actElem1;
|
|
paramList[1] = actElem2;
|
|
}//else
|
|
isTrue = false;
|
|
try {
|
|
isTrue = ((Boolean)predicate.invoke(actElem1,paramList)).booleanValue();
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.reduce: Problem with using predicate.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
if (isTrue) {
|
|
paramListMet[0] = actElem1;
|
|
paramListMet[1] = actElem2;
|
|
try {
|
|
//if method has returnType Element
|
|
if (metTypeElement)
|
|
retSet.add((Element)(method.invoke(null,paramListMet)));
|
|
else {
|
|
if (metTypeElemMultiSet)
|
|
retSet.addAll((ElemMultiSet)(method.invoke(null,paramListMet)));
|
|
else {
|
|
System.out.println("ERROR in SO.reduce(): can't invoke method");
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//else
|
|
}//else
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.reduce: Problem with using method.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
//now remove elements from retSet
|
|
retSet.removeOneEntry(actElem1);
|
|
retSet.removeOneEntry(actElem2);
|
|
|
|
stillExist = true;
|
|
isTrue = false;
|
|
if (retSet.isEmpty())
|
|
stillExist = false;
|
|
}//if isTrue
|
|
if (stillExist) break;
|
|
}//while it2
|
|
if (stillExist) break;
|
|
}//while it1
|
|
} while (stillExist);
|
|
|
|
return retSet;
|
|
}//end method reduce
|
|
|
|
|
|
/**
|
|
* From two sets <tt>E,F</tt> and a predicate <tt>p</tt> this method computes a set of pairs <tt>(e,f)</tt> with <tt>e</tt> element of
|
|
* <tt>E</tt>, <tt>f</tt> element of <tt>F</tt> and <tt>p(e,f) == true</tt>.<p>
|
|
* The predicate's signature must be <tt>Element x Element -> boolean</tt>. This method uses a O(n*n) algorithm.
|
|
*
|
|
* @param ems1 the first set
|
|
* @param ems2 the second set
|
|
* @param predicate the join predicate
|
|
* @return the set of pairs
|
|
* @see #overlapJoin(ElemMultiSet,ElemMultiSet,Method,boolean,boolean,boolean,int)
|
|
*/
|
|
public static PairMultiSet join (ElemMultiSet ems1, ElemMultiSet ems2, Method predicate) {
|
|
PairMultiSet retSet = new PairMultiSet(new ElemPairComparator());
|
|
if (ems1 == null || ems2 == null || ems1.isEmpty() || ems2.isEmpty()) return retSet;
|
|
|
|
int paramTypeCount = Array.getLength(predicate.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
|
|
Iterator it1 = ems1.iterator();
|
|
Iterator it2;
|
|
Element actElem1, actElem2;
|
|
|
|
while (it1.hasNext()) {
|
|
actElem1 = (Element)((MultiSetEntry)it1.next()).value;
|
|
it2 = ems2.iterator();
|
|
while (it2.hasNext()) {
|
|
actElem2 = (Element)((MultiSetEntry)it2.next()).value;
|
|
|
|
if (paramTypeCount == 1)
|
|
//predicate is non-static
|
|
paramList[0] = actElem2;
|
|
else {
|
|
//predicate is static
|
|
paramList[0] = actElem1;
|
|
paramList[1] = actElem2;
|
|
}//else
|
|
|
|
//invoke predicate
|
|
try {
|
|
if (((Boolean)predicate.invoke(actElem1,paramList)).booleanValue())
|
|
retSet.add(new ElemPair(actElem1,actElem2));
|
|
} catch (Exception e) {
|
|
System.out.println("Error in SetOps.join: Wasn't able to invoke predicate.");
|
|
e.printStackTrace();
|
|
}//catch
|
|
}//while it2
|
|
}//while it1
|
|
|
|
return retSet;
|
|
}//end method join
|
|
|
|
|
|
|
|
/**
|
|
* Invokes the passed method on each pair of the passed PairMultiSet. The result is collected and returned.<p>
|
|
* The method must have the signature <code>Element x Element -> Element</code> or
|
|
* <tt>Element x Element -> ElemMultiSet</tt>.<p>
|
|
* At the end, duplicates are removed.
|
|
*
|
|
* @param pl the set of ElemPair(s)
|
|
* @param method the method that is invoked on the ElemPair(s)
|
|
* @return the set of results collected in an ElemMultiSet
|
|
*/
|
|
public static ElemMultiSet map (PairMultiSet pl, Method method) {
|
|
ElemMultiSet retSet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
int paramTypeCount = Array.getLength(method.getParameterTypes());
|
|
Element[] paramList = new Element[paramTypeCount];
|
|
Iterator lit = pl.iterator();
|
|
ElemPair actPair;
|
|
boolean metTypeElement = false;
|
|
boolean metTypeElemList = false;
|
|
Element result;
|
|
try {
|
|
if (method.getReturnType().isInstance(Class.forName("twodsack.setelement.Element")) ||
|
|
method.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.setelement.Element"))) {
|
|
metTypeElement = true; }
|
|
if (method.getReturnType().isInstance(Class.forName("twodsack.set.ElemMultiSet")) ||
|
|
method.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.set.ElemMultiSet"))) {
|
|
metTypeElemList = true; }
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.reduce: can't examine method.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
MultiSetEntry mse;
|
|
int number;
|
|
while (lit.hasNext()) {
|
|
mse = (MultiSetEntry)lit.next();
|
|
number = mse.number;
|
|
actPair = (ElemPair)mse.value;
|
|
//muliset handling
|
|
for (int msenum = 0; msenum < number; msenum++) {
|
|
try {
|
|
|
|
//if method has one argument
|
|
if (paramTypeCount == 1) {
|
|
paramList[0] = actPair.second;
|
|
}//if
|
|
//if method has two arguments (is static)
|
|
else {
|
|
paramList[0] = actPair.first;
|
|
paramList[1] = actPair.second;
|
|
}//else
|
|
|
|
//if returntype of m is Element
|
|
if (metTypeElement) {
|
|
result = (Element)method.invoke(actPair.first,paramList);
|
|
if (result != null)
|
|
retSet.add(result);
|
|
//retSet.add((Element)(method.invoke(actPair.first,paramList)));
|
|
|
|
}//if
|
|
//if returntype of m is ElemList
|
|
else {
|
|
if (metTypeElemList) {
|
|
retSet.addAll((ElemMultiSet)(method.invoke(actPair.first,paramList)));
|
|
|
|
}//if
|
|
else {
|
|
System.out.println("Error in SetOps.map: can't invoke method");
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//else
|
|
}//else
|
|
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.map(pl,m). Can't invoke method "+method);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
}//for
|
|
}//while
|
|
return retSet;
|
|
}//end method map
|
|
|
|
|
|
/**
|
|
* Invokes the method on every element of the set and returns the resulting set.<p>
|
|
* Duplicates are removed afterwards.<p>
|
|
* The signature of the method <tt>m</tt> must be one of
|
|
* <code>Element -> Element</code>,<p>
|
|
* <code>Element -> ElemMultiSet</code> or<p>
|
|
* <code>Element -> Element[]</code>.
|
|
*
|
|
* @param el the 'in' set
|
|
* @param m the method that is invoked on the elements of <tt>el</tt>
|
|
* @return the changed <tt>el</tt>
|
|
*/
|
|
public static ElemMultiSet map (ElemMultiSet el, Method m) {
|
|
ElemMultiSet retList = new ElemMultiSet(ELEM_COMPARATOR);
|
|
boolean mRetTypeElem = false;
|
|
boolean mRetTypeElemMultiSet = false;
|
|
boolean mRetTypeElemArray = false;
|
|
|
|
try {
|
|
mRetTypeElemArray = m.getReturnType().isArray();
|
|
if (!mRetTypeElemArray) {
|
|
mRetTypeElem = (m.getReturnType().isInstance(Class.forName("twodsack.setelement.Element")) ||
|
|
m.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.setelement.Element")));
|
|
if (!mRetTypeElem)
|
|
mRetTypeElemMultiSet = (m.getReturnType().isInstance(Class.forName("twodsack.set.ElemMultiSet")) ||
|
|
m.getReturnType().getSuperclass().isAssignableFrom(Class.forName("twodsack.set.ElemMultiSet")));
|
|
}//if
|
|
} catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.map: can't examine method.");
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
|
|
Iterator lit = el.iterator();
|
|
Element actEl;
|
|
MultiSetEntry mse;
|
|
int numOfmse;
|
|
|
|
while (lit.hasNext()) {
|
|
mse = (MultiSetEntry)lit.next();
|
|
actEl = (Element)mse.value;
|
|
numOfmse = mse.number;
|
|
//handling multiple entries
|
|
for (int nom = 0; nom < numOfmse; nom++) {
|
|
try {
|
|
//if returntype of m is Element
|
|
if (mRetTypeElem) {
|
|
retList.add(m.invoke(actEl,null));
|
|
}//if
|
|
//if returntype of m is ElemList
|
|
else {
|
|
if (mRetTypeElemMultiSet) {
|
|
retList.addAll((ElemMultiSet)m.invoke(actEl,null));
|
|
}//if
|
|
else {
|
|
if (mRetTypeElemArray) {
|
|
retList.add((Element[])m.invoke(actEl,null));
|
|
}//if
|
|
else {
|
|
System.out.println("ERROR (SetOps.map): can't invoke method");
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//else
|
|
}//else
|
|
}//else
|
|
|
|
}//try
|
|
catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.map. Can't invoke method "+m);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
}//for nom
|
|
}//while
|
|
|
|
return retList;
|
|
}//end method map
|
|
|
|
|
|
/**
|
|
* Returns the disjoint union of both sets.
|
|
* This means that <tt>disjointUnion((a,b),(b,c)) -> (a,b,b,c)</tt>.
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @return the disjoint union of <tt>el1,el2</tt>
|
|
*/
|
|
public static ElemMultiSet disjointUnion (ElemMultiSet el1, ElemMultiSet el2) {
|
|
ElemMultiSet eUnion = el1.copy();
|
|
|
|
eUnion.addAll(el2);
|
|
return eUnion;
|
|
}//end method disjointUnion
|
|
|
|
|
|
/**
|
|
* Returns the intersecion of both sets.<p>
|
|
* This means that <tt>intersection((a,b),(b,c)) -> (b)</tt>.<p>
|
|
* This method uses the <tt>compare()</tt> method which must be implemented for any type that implements the Element interface and
|
|
* throws a WrongTypeException if the sets are not of the same type.
|
|
*
|
|
* @param el1In the first set
|
|
* @param el2In the second set
|
|
* @return the intersection of <tt>el1In,el2In</tt>
|
|
* @throws WrongTypeException
|
|
*/
|
|
public static ElemMultiSet intersection (ElemMultiSet el1In, ElemMultiSet el2In) throws WrongTypeException {
|
|
ElemMultiSet eRet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
if ((el1In.size() == 0) ||
|
|
(el2In.size() == 0))
|
|
return eRet;
|
|
|
|
ElemMultiSet ems1 = el1In;
|
|
ElemMultiSet ems2 = el2In;
|
|
|
|
Iterator it1 = ems1.iterator();
|
|
Iterator it2 = ems2.iterator();
|
|
boolean getNextE1 = true;
|
|
boolean getNextE2 = true;
|
|
MultiSetEntry mse1 = null;
|
|
MultiSetEntry mse2 = null;
|
|
Element e1,e2;
|
|
|
|
while (true) {
|
|
if (getNextE1) { mse1 = (MultiSetEntry)it1.next(); }
|
|
if (getNextE2) { mse2 = (MultiSetEntry)it2.next(); }
|
|
e1 = (Element)mse1.value;
|
|
e2 = (Element)mse2.value;
|
|
|
|
int cmp = e1.compare(e2);
|
|
if (cmp == 0) {
|
|
eRet.add(e1);
|
|
getNextE1 = true;
|
|
getNextE2 = true;
|
|
}//if
|
|
else if (cmp == -1) {
|
|
getNextE1 = true;
|
|
getNextE2 = false;
|
|
}//if
|
|
else {
|
|
getNextE1 = false;
|
|
getNextE2 = true;
|
|
}//else
|
|
if ((getNextE1 && !it1.hasNext()) ||
|
|
(getNextE2 && !it2.hasNext()))
|
|
break;
|
|
}//while
|
|
|
|
return eRet;
|
|
}//end method intersection
|
|
|
|
|
|
/**
|
|
* Returns the difference of the two sets.<p>
|
|
* This means that <tt>difference((a,b,c),(a,b)) -> (c)</tt>.<p>
|
|
* This method uses the <tt>compare()</tt> method which must be implemented for any type that implements the <tt>Element</tt> interface and
|
|
* throws a WrongTypeException if the sets are not of the same type.
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @return the difference <tt>el - el2</tt>
|
|
* @throws WrongTypeException
|
|
*/
|
|
public static ElemMultiSet difference (ElemMultiSet el1, ElemMultiSet el2) throws WrongTypeException {
|
|
ElemMultiSet eDiff = new ElemMultiSet(ELEM_COMPARATOR);
|
|
|
|
int el1size = el1.size();
|
|
int el2size= el2.size();
|
|
|
|
el1 = rdup(el1);
|
|
el2 = rdup(el2);
|
|
|
|
if (el2.isEmpty()) { return el1; }
|
|
|
|
Iterator it1 = el1.iterator();
|
|
Iterator it2 = el2.iterator();
|
|
boolean next1 = true;
|
|
boolean next2 = true;
|
|
Element elem1 = null;//just for initialization
|
|
Element elem2 = null;//dito
|
|
int comp;
|
|
|
|
while ((!next1 || it1.hasNext()) &&
|
|
(!next2 || it2.hasNext())) {
|
|
if (next1) elem1 = (Element)((MultiSetEntry)it1.next()).value;
|
|
if (next2) elem2 = (Element)((MultiSetEntry)it2.next()).value;
|
|
next1 = false;
|
|
next2 = false;
|
|
|
|
if (elem1.equal(elem2)) {
|
|
next1 = true;
|
|
next2 = true;
|
|
}//if
|
|
else {
|
|
comp = elem1.compare(elem2);
|
|
switch (comp) {
|
|
case -1 : {
|
|
eDiff.add(elem1.copy());
|
|
next1 = true;
|
|
break; }
|
|
case 1 : { next2 = true; }
|
|
}//switch
|
|
}//else
|
|
}//while
|
|
|
|
if (!next1) { eDiff.add(elem1.copy()); }
|
|
|
|
while (it1.hasNext()) {
|
|
eDiff.add(((Element)((MultiSetEntry)it1.next()).value).copy());
|
|
}//while
|
|
|
|
return eDiff;
|
|
}//end method difference
|
|
|
|
|
|
/**
|
|
* Removes the duplicates from the (multi-)set.
|
|
* As an ElemMultiSet is a set type that allows duplicates, this method removes all duplicates, i.e.
|
|
* <tt>rdup((a,b,b,c)) -> (a,b,c)</tt>.
|
|
*
|
|
* @param elIn the 'in' set
|
|
* @return <tt>elIn</tt> without duplicates
|
|
* @throws WrongTypeException
|
|
*/
|
|
public static ElemMultiSet rdup (ElemMultiSet elIn) throws WrongTypeException {
|
|
Iterator it = elIn.iterator();
|
|
MultiSetEntry mse;
|
|
int num;
|
|
while (it.hasNext()) {
|
|
mse = (MultiSetEntry)it.next();
|
|
num = mse.number;
|
|
elIn.size = elIn.size - num + 1;
|
|
mse.number = 1;
|
|
}//while
|
|
|
|
return elIn;
|
|
}//end method rdup
|
|
|
|
|
|
/**
|
|
* Removes from the set all elements which are found more than once.
|
|
* This means that <tt>rdup2((a,b,b,c)) -> (a,c)</tt>.
|
|
*
|
|
* @param elIn the 'in' set
|
|
* @return <tt>elIn</tt> without any duplicates
|
|
*/
|
|
public static ElemMultiSet rdup2 (ElemMultiSet elIn) {
|
|
Iterator it = elIn.iterator();
|
|
while (it.hasNext()) {
|
|
MultiSetEntry mse = (MultiSetEntry)it.next();
|
|
if (mse.number > 1)
|
|
it.remove();
|
|
}//while
|
|
elIn.recomputeSize();
|
|
|
|
return elIn;
|
|
}//end method rdup2
|
|
|
|
|
|
/**
|
|
* Computes the union of both sets.<p>
|
|
* This means that <tt>union((a,b),(b,c)) -> (a,b,c)</tt>. The duplicates are removed.
|
|
* A <tt>WrongTypeException</tt> is thrown, if the sets are not of the same type.
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @return the union of <tt>el1,el2</tt>
|
|
* @throws WrongTypeException
|
|
*/
|
|
public static ElemMultiSet union (ElemMultiSet el1, ElemMultiSet el2) throws WrongTypeException {
|
|
ElemMultiSet eRet = new ElemMultiSet(ELEM_COMPARATOR);
|
|
eRet = rdup(disjointUnion(el1,el2));
|
|
return eRet;
|
|
}//end method union
|
|
|
|
|
|
/**
|
|
* Sums up the results of method <tt>m</tt> invoked on every element of the set.
|
|
* Method <tt>m</tt> must have the signature <code>Element -> double</code>.
|
|
*
|
|
* @param ems the 'in' set
|
|
* @param m the method that is invoked on the elements of ems
|
|
* @return the sum of the results of <tt>m</tt>'s invocation
|
|
*/
|
|
public static double sum (ElemMultiSet ems, Method m) {
|
|
double retSum = 0;
|
|
Iterator it = ems.iterator();
|
|
MultiSetEntry mse;
|
|
|
|
try {
|
|
while (it.hasNext()) {
|
|
mse = (MultiSetEntry)it.next();
|
|
for (int count = 0; count < mse.number; count++) {
|
|
retSum = retSum + ((Double)m.invoke((Element)mse.value,null)).doubleValue();
|
|
}//for count
|
|
}//while
|
|
} catch (Exception e) {
|
|
System.out.println("Exception: "+e.getClass()+" --- "+e.getMessage());
|
|
System.out.println("Error in SetOps.sum. Can't invoke method "+m);
|
|
e.printStackTrace();
|
|
throw new RuntimeException("An error occurred in the ROSEAlgebra.");
|
|
}//catch
|
|
return retSum;
|
|
}//end method sum
|
|
|
|
|
|
/**
|
|
* Computes for two sets of geometrical objects a set of object pairs for which holds, that their bounding boxes overlap.<p>
|
|
* This method implements a pretty complex DAC algorithm which is not described here.<p>
|
|
* In general, pairs are computed for objects of two sets (which don't have to be of the same type). But, when using the
|
|
* <tt>sameSet</tt> flag, one may indicate that the sets passed are actually the same object. In that case, all pairs of identical
|
|
* objects are removed. To clarify this: If <tt>overlappingPairs</tt> is invoked on <tt>(e1,e2,e3...) x (f1,f2,f3)</tt> one would get (at least)
|
|
* the pairs <tt<(e1,f1),(e2,f2),(e3,f3)</tt< because <tt>(e1,f2)</tt> etc. are identical and therefore have overlapping bounding boxes.
|
|
* If the <tt>sameSet</tt> flag is set, these pairs are not found in the resulting set.<p>
|
|
* Using the <tt>meet</tt> flag, an overlap of the object's bounding boxes is not required. Now, adjacency of bounding boxes is
|
|
* sufficient for an object pair to be stored in the result set.<p>
|
|
* If the <tt>bboxFilter</tt> flag is set, first the bounding box of the complete sets <tt>el1,el2</tt> is computed, i.e. that complete bounding box
|
|
* includes <u>all</u> of the set's objects. Then, all object's bounding boxes of <tt>el1</tt> are checked against the <tt>el2</tt> complete box.*
|
|
* Objects with boxes that don't intersect the set's box are removed. The same is done for the elements of <tt>el2</tt> and the box of <tt>el1</tt>.
|
|
* <p>
|
|
* When using the <tt>earlyExit</tt> flag, the <tt>setNumber</tt> is evaluated. This number must be 1 or 2 and specifies one of the two sets. When,
|
|
* during the execution of <tt>bboxFilter</tt> one object of that set is removed for the reason that it doesn't overlap the big box
|
|
* of the other set, a <tt>NoOverlappingBoxFoundException</tt> is thrown.<p>
|
|
* Note, that the <tt>earlyExit</tt> flag can <u>only</u> be used together with the <tt>bboxFilter</tt> flag and the <tt>setNumber</tt>.
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @param sameSet choose <tt>true</tt>, if identical pairs should not be reported in the case that <tt>el1 == el2</tt>
|
|
* @param meet set to <tt>true</tt>, if adjancency for bounding boxed should suffice instead of overlap
|
|
* @param bboxFilter use <tt>true</tt>, if a filter step should be used to reduce the number of objects
|
|
* @param earlyExit if set to <tt>true</tt>, an <tt>NoOverlappingboxException</tt> will be thrown, if one element of the set specified by
|
|
* setNumber finds no partner
|
|
* @param setNumber specifies the set for <tt>earlyExit</tt>
|
|
* @return the set of object pairs which all have overlapping (or adjacent) bounding boxes
|
|
* @throws NoOverlappingBoxFoundException
|
|
*/
|
|
public static PairMultiSet overlappingPairs(ElemMultiSet el1, ElemMultiSet el2, boolean sameSet, boolean meet, boolean bboxFilter, boolean earlyExit, int setNumber) throws NoOverlappingBoxFoundException {
|
|
|
|
PairMultiSet pairs = new PairMultiSet(new ElemPairComparator());
|
|
|
|
if (el1.isEmpty() || el2.isEmpty()) return pairs;
|
|
|
|
Object[] ivlArr;
|
|
|
|
if (bboxFilter) {
|
|
//Use bboxFilter to reduce number of elements.
|
|
ElemMultiSet[] newSets = bboxFilter(el1,el2,earlyExit,setNumber);
|
|
if (newSets[0].isEmpty() || newSets[1].isEmpty()) return pairs;
|
|
|
|
//generate interval list which stores left,right vertical
|
|
//intervals of the elements bboxes of el1,el2
|
|
MultiSet ems = generateIntervalList(newSets[0],newSets[1],meet);
|
|
ivlArr = ems.toArray();
|
|
}//if bboxFilter
|
|
else {
|
|
//generate interval list which stores left,right vertical
|
|
//intervals of the elements bboxes of el1,el2
|
|
//Store elements in an array.
|
|
MultiSet ems = generateIntervalList(el1,el2,meet);
|
|
ivlArr = ems.toArray();
|
|
}//else
|
|
|
|
//everything is done so start the DAC
|
|
IvlList mtList = new IvlList();
|
|
ResultList inlist = new ResultList(mtList,mtList,mtList,mtList,mtList,mtList,mtList);
|
|
|
|
//initialize a structure for storing the already found intersections
|
|
ProLinkedList[] intStore = new ProLinkedList[el1.size()+el2.size()];
|
|
for (int i = 0; i < intStore.length; i++) {
|
|
intStore[i] = new ProLinkedList(); }
|
|
|
|
PairMultiSet pairList = new PairMultiSet(new ElemPairComparator());
|
|
int idx1 = 0;
|
|
int idx2 = ivlArr.length-1;
|
|
ResultList rl = computeOverlaps(intStore,inlist,sameSet,el1.size(),pairList,ivlArr,idx1,idx2);
|
|
|
|
return pairList;
|
|
}//end method overlappingPairs
|
|
|
|
|
|
/**
|
|
* This method does the <i>real</i> work for the DAC.
|
|
* Comments are found in the code.
|
|
*
|
|
* @param intStore this array stores for every object of the first set a list with objects of the second set which have overlapping
|
|
* or adjacent bounding boxes; in fact, not the objects themselves are stored in that array, but the object IDs
|
|
* @param il in this structure, all left,right,blue,green etc. intervals are stored; additionally, all information which is passed
|
|
* through the several recursive steps of this algorithm are stored in here
|
|
* @param sameSet the flag which indicates whether both (initial) sets are equal or not
|
|
* @param size the size of the first (initial)set
|
|
* @param resultingPairs the set of pairs which has to be computed
|
|
* @param ivlArr stores the left and right border intervals of the objects bounding boxes
|
|
* @param idx1 defines the actual left index on <tt>ivlArr</tt>
|
|
* @param idx2 defines the acutal right index on <tt>ivlArr</tt>
|
|
* @return the new ResulList structure
|
|
*/
|
|
private static ResultList computeOverlaps(ProLinkedList[] intStore, ResultList il, boolean sameSet, int size, PairMultiSet resultingPairs,Object[] ivlArr, int idx1, int idx2) {
|
|
//initially il.m is the full intervall list
|
|
ResultList rl;
|
|
|
|
//is m small enough?
|
|
//if (il.m.size() == 1) {
|
|
if (idx2 == idx1) {
|
|
|
|
rl = new ResultList(il.m,null,null,null,null,null,null);
|
|
|
|
//dependent on the only element in m compute the sets
|
|
//blue, green, blueLeft, blueRight, greenLeft, greenRight
|
|
//Interval actInt = (Interval)il.m.getFirst();
|
|
Interval actInt = (Interval)ivlArr[idx1];
|
|
if (actInt.mark == "blueleft") {
|
|
if (rl.blue == null) rl.blue = new IvlList();
|
|
rl.blue.add(actInt);
|
|
rl.green = il.green;
|
|
if (rl.blueLeft == null) rl.blueLeft = new IvlList();
|
|
rl.blueLeft.add(actInt);
|
|
rl.blueRight = il.blueRight;
|
|
rl.greenLeft = il.greenLeft;
|
|
rl.greenRight = il.greenRight;
|
|
}//if
|
|
else if (actInt.mark == "blueright") {
|
|
if (rl.blue == null) rl.blue = new IvlList();
|
|
rl.blue.add(actInt);
|
|
rl.green = il.green;
|
|
rl.blueLeft = il.blueLeft;
|
|
if (rl.blueRight == null) rl.blueRight = new IvlList();
|
|
rl.blueRight.add(actInt);
|
|
rl.greenLeft = il.greenLeft;
|
|
rl.greenRight = il.greenRight;
|
|
}//if
|
|
else if (actInt.mark == "greenleft") {
|
|
rl.blue = il.blue;
|
|
if (rl.green == null) rl.green = new IvlList();
|
|
rl.green.add(actInt);;
|
|
rl.blueLeft = il.blueLeft;
|
|
rl.blueRight = il.blueRight;
|
|
if (rl.greenLeft == null) rl.greenLeft = new IvlList();
|
|
rl.greenLeft.add(actInt);
|
|
rl.greenRight = il.greenRight;
|
|
}//if
|
|
else if (actInt.mark == "greenright") {
|
|
rl.blue = il.blue;
|
|
if (rl.green == null) rl.green = new IvlList();
|
|
rl.green.add(actInt);
|
|
rl.blueLeft = il.blueLeft;
|
|
rl.blueRight = il.blueRight;
|
|
rl.greenLeft = il.greenLeft;
|
|
if (rl.greenRight == null) rl.greenRight = new IvlList();
|
|
rl.greenRight.add(actInt);
|
|
}//if
|
|
}//if size() == 1
|
|
|
|
else {
|
|
//DIVIDE
|
|
int half = (idx2-idx1)/2;
|
|
|
|
int m1idx1 = idx1;
|
|
int m1idx2 = idx1+half;
|
|
|
|
int m2idx1 = m1idx2+1;
|
|
int m2idx2 = idx2;
|
|
|
|
|
|
//CONQUER
|
|
ResultList rl1 =
|
|
computeOverlaps(intStore,
|
|
new ResultList(null,il.blue,il.green,il.blueLeft,il.blueRight,il.greenLeft,il.greenRight),
|
|
sameSet,size,resultingPairs,
|
|
ivlArr,m1idx1,m1idx2);
|
|
ResultList rl2 =
|
|
computeOverlaps(intStore,
|
|
new ResultList(null,il.blue,il.green,il.blueLeft,il.blueRight,il.greenLeft,il.greenRight),
|
|
sameSet,size,resultingPairs,
|
|
ivlArr,m2idx1,m2idx2);
|
|
|
|
//MERGE
|
|
IvlList fullBlue;
|
|
IvlList fullGreen;
|
|
|
|
fullBlue = IvlList.intersect(rl1.blueLeft,rl2.blueRight);
|
|
fullGreen = IvlList.intersect(rl1.greenLeft,rl2.greenRight);
|
|
|
|
rl = new ResultList(null,null,null,null,null,null,null);
|
|
|
|
rl.blue = IvlList.merge(rl1.blue,rl2.blue,true);
|
|
rl.green = IvlList.merge(rl1.green,rl2.green,true);
|
|
|
|
IvlList rl1BlueLeftMINUSfullBlue = IvlList.minus(rl1.blueLeft,fullBlue);
|
|
IvlList rl1GreenLeftMINUSfullGreen = IvlList.minus(rl1.greenLeft,fullGreen);
|
|
IvlList rl2BlueRightMINUSfullBlue = IvlList.minus(rl2.blueRight,fullBlue);
|
|
IvlList rl2GreenRightMINUSfullGreen = IvlList.minus(rl2.greenRight,fullGreen);
|
|
|
|
rl.blueLeft = IvlList.merge(rl1BlueLeftMINUSfullBlue,rl2.blueLeft,false);
|
|
rl.blueRight = IvlList.merge(rl2BlueRightMINUSfullBlue,rl1.blueRight,false);
|
|
rl.greenLeft = IvlList.merge(rl1GreenLeftMINUSfullGreen,rl2.greenLeft,false);
|
|
rl.greenRight = IvlList.merge(rl2GreenRightMINUSfullGreen,rl1.greenRight,false);
|
|
|
|
//compute pairs
|
|
resultingPairs = IvlList.overlappingIntervals(intStore,sameSet,size,
|
|
rl1BlueLeftMINUSfullBlue,
|
|
rl2.green, resultingPairs);
|
|
resultingPairs = IvlList.overlappingIntervals(intStore,sameSet,size,rl2.blue,
|
|
rl1GreenLeftMINUSfullGreen,
|
|
resultingPairs);
|
|
resultingPairs = IvlList.overlappingIntervals(intStore,sameSet,size,
|
|
rl2BlueRightMINUSfullBlue,
|
|
rl1.green,resultingPairs);
|
|
resultingPairs = IvlList.overlappingIntervals(intStore,sameSet,size,rl1.blue,
|
|
rl2GreenRightMINUSfullGreen,
|
|
resultingPairs);
|
|
}//else
|
|
|
|
return rl;
|
|
}//end method compute overlaps
|
|
|
|
|
|
/**
|
|
* Constructs a set of intervals which are the border intervals form the bounding boxes of <tt>el1</tt>'s and <tt>el2</tt>'s objects.
|
|
* This is a supportive method for the <tt>overlappingPairs</tt> method. From the elements of <tt>el1,el2</tt>, the vertical intervals
|
|
* of the bounding boxes are taken and stored as intervals in the resulting MultiSet. All elements of el1 are marked
|
|
* with "blueleft" or "blueright" and elements of <tt>el2</tt> are marked with "greenleft" and "greenright". Additionally,
|
|
* all bounding boxes get a number which is assigned to the intervals. A flag is set for every interval, whether
|
|
* the partner of an inerval is located at the same x-coordinate or not.
|
|
*
|
|
* @param el1 the first set
|
|
* @param el2 the second set
|
|
* @param meet <tt>true</tt>, if adjacency of bounding boxes suffices for reporting it in the result set
|
|
* @return the MultiSet with the intervals
|
|
*/
|
|
static private MultiSet generateIntervalList (ElemMultiSet el1, ElemMultiSet el2, boolean meet) {
|
|
MultiSet retSet = new MultiSet(new IvlComparator(meet));
|
|
int counter = 0;
|
|
Iterator it1 = el1.iterator();
|
|
Iterator it2 = el2.iterator();
|
|
Element actEl;
|
|
Rect actRect;
|
|
MultiSetEntry mse;
|
|
boolean buddy;
|
|
|
|
while (it1.hasNext()) {
|
|
mse = (MultiSetEntry)it1.next();
|
|
|
|
actEl = (Element)mse.value;
|
|
actRect = actEl.rect();
|
|
buddy = actRect.ulx.equal(actRect.urx);
|
|
//multiset handling
|
|
for (int msenum = 0; msenum < mse.number; msenum++) {
|
|
retSet.add(new Interval(
|
|
actRect.lly,
|
|
actRect.uly,
|
|
"blueleft",
|
|
actRect.ulx,
|
|
actEl,
|
|
counter,
|
|
buddy));
|
|
|
|
retSet.add(new Interval(
|
|
actRect.lry,
|
|
actRect.ury,
|
|
"blueright",
|
|
actRect.urx,
|
|
actEl,
|
|
counter,
|
|
buddy));
|
|
|
|
counter++;
|
|
}//for
|
|
}//while
|
|
|
|
while (it2.hasNext()) {
|
|
mse = (MultiSetEntry)it2.next();
|
|
|
|
actEl = (Element)mse.value;
|
|
actRect = actEl.rect();
|
|
buddy = actRect.ulx.equal(actRect.urx);
|
|
for (int msenum = 0; msenum < mse.number; msenum++) {
|
|
retSet.add(new Interval(
|
|
actRect.lly,
|
|
actRect.uly,
|
|
"greenleft",
|
|
actRect.ulx,
|
|
actEl,
|
|
counter,
|
|
buddy));
|
|
|
|
retSet.add(new Interval(
|
|
actRect.lry,
|
|
actRect.ury,
|
|
"greenright",
|
|
actRect.urx,
|
|
actEl,
|
|
counter,
|
|
buddy));
|
|
|
|
counter++;
|
|
}//for
|
|
}//while
|
|
|
|
return retSet;
|
|
}//end method generateIntervalList
|
|
|
|
|
|
/**
|
|
* Sorts the input list using mergesort.
|
|
* First, elements are sorted using their <tt>compareX()</tt> method, then using their <tt>compareY()</tt> method.<p>
|
|
* This method can <i>only</i> be used for <tt>Element</tt> lists.
|
|
*
|
|
* @param el the unsorted list
|
|
* @return the sorted list
|
|
*/
|
|
public static void mergesortXY (LinkedList el) {
|
|
mergesXY(el,0,el.size()-1);
|
|
}//end method mergesortXY
|
|
|
|
|
|
/**
|
|
* This is a supportive method for {@link #mergesortXY(LinkedList)}.
|
|
*
|
|
* @param list the list to be sorted
|
|
* @param lo the bottom index
|
|
* @param hi the top index
|
|
* @return a list that is sorted form lo to hi
|
|
*/
|
|
private static void mergesXY (LinkedList list, int lo, int hi) {
|
|
//lo,hi are indices to determine which part of the list shoult be sorted
|
|
int m;
|
|
if (lo < hi) {
|
|
m = (lo + hi) / 2;
|
|
mergesXY (list,lo,m);
|
|
mergesXY (list,m+1,hi);
|
|
mergeXY (list,lo,hi);
|
|
}//if
|
|
}//end method mergesXY
|
|
|
|
|
|
/**
|
|
* Supportive method for {@link #mergesXY(LinkedList,int,int)}.
|
|
*
|
|
* @param list the list to be sorted
|
|
* @param lo the bottom index
|
|
* @param hi the top index
|
|
* @return the list that is sorted from <tt<lo</tt> to <tt>hi</tt>
|
|
*/
|
|
private static void mergeXY(LinkedList list, int lo, int hi) {
|
|
int i,j,k,m,n = hi-lo+1;
|
|
Element[] tmp = new Element[n];//temporary array
|
|
byte erg;
|
|
|
|
k = 0;
|
|
m = (lo+hi)/2;
|
|
//copy lower half to array b
|
|
for (i = lo; i <= m; i++)
|
|
tmp[k++] = (Element)list.get(i);
|
|
//copy upper half in reverse order to array b
|
|
for (j = hi; j >= m+1; j--)
|
|
tmp[k++] = (Element)list.get(j);
|
|
|
|
i = 0;
|
|
j = n-1;
|
|
k = lo;
|
|
|
|
//copy the next greatest element back until i,j meet
|
|
while (i <= j) {
|
|
erg = tmp[i].compX(tmp[j]);
|
|
if (erg == 0) {
|
|
erg = tmp[i].compY(tmp[j]);
|
|
switch (erg) {
|
|
case -1 : { erg = 1; break; }
|
|
case 1 : { erg = -1; break; }
|
|
case 0 : erg = 0;
|
|
}//switch
|
|
}//if
|
|
|
|
switch (erg) {
|
|
case -1 : { list.set(k++,(Element)tmp[i++]); break; }
|
|
case 0 : { list.set(k++,(Element)tmp[i++]); break; }
|
|
case 1 : list.set(k++,(Element)tmp[j--]);
|
|
}//switch
|
|
}//while
|
|
}//end method mergeXY
|
|
|
|
|
|
/**
|
|
* Returns the subsets of elements which bounding boxes overlap the bounding box of the element set of the other set.<p>
|
|
* The bounding boxes for every passed set is computed first. Then, the intersection of these bounding boxes,
|
|
* which is again a rectangle and can be described as the "convex hull rectangle", is computed.
|
|
* Afterwards, the elements of both sets are compared to this convex hull rectangle. If the bounding box of such
|
|
* an element has at least one common point with the hull, it belongs to the subset for a set. Subsets are computed
|
|
* for both sets and are returned in an array.
|
|
* The parameter <code>earlyExit</code> can be used to stop the execution of the calling algorithm. Therefore,
|
|
* a <code>setNumber</code> is passed together with <code>earlyExit</code>. If <code>true</code>,
|
|
* <code>bboxFilter</code> throws a {@link NoOverlappingBoxFoundException} if the bounding box of an element of the
|
|
* set specified by <code>setNumber</code> doesn't overlap the hull of the other set.
|
|
*
|
|
* @param ems1 the first set of elements
|
|
* @param ems2 the second set of elements
|
|
* @param earlyExit must be <tt>true</tt>, if execution shall be stopped
|
|
* @param setNumber the number of the set which is examined if <tt>earlyExit == true</tt>
|
|
* @return the subsets
|
|
*/
|
|
public static ElemMultiSet[] bboxFilter (ElemMultiSet ems1, ElemMultiSet ems2, boolean earlyExit, int setNumber)
|
|
throws NoOverlappingBoxFoundException {
|
|
|
|
if (earlyExit && (setNumber < 1 || setNumber > 2)) throw new InternalError("SetOps.bboxFilter: setNumber must be 1 or 2.");
|
|
|
|
ElemMultiSet[] retArr = new ElemMultiSet[2];
|
|
if (ems1.size() == 0 || ems2.size() == 0) return retArr;
|
|
|
|
ElemMultiSet ems1Clone = (ElemMultiSet)ems1.clone();
|
|
ElemMultiSet ems2Clone = (ElemMultiSet)ems2.clone();
|
|
|
|
Rect ems1Rect = ems1Clone.rect();
|
|
Rect ems2Rect = ems2Clone.rect();
|
|
|
|
Rect combinedRect = ems1Rect.intersection(ems2Rect);
|
|
|
|
Element actElem;
|
|
Iterator it;
|
|
|
|
it = ems1Clone.iterator();
|
|
while (it.hasNext()) {
|
|
actElem = (Element)((MultiSetEntry)it.next()).value;
|
|
if (!actElem.rect().hasCommonPoints(combinedRect)) {
|
|
if (earlyExit && setNumber == 1) throw new NoOverlappingBoxFoundException();
|
|
it.remove();
|
|
}//if
|
|
}//while
|
|
ems1Clone.recomputeSize();
|
|
retArr[0] = ems1Clone;
|
|
|
|
it = ems2Clone.iterator();
|
|
while (it.hasNext()) {
|
|
actElem = (Element)((MultiSetEntry)it.next()).value;
|
|
if (!actElem.rect().hasCommonPoints(combinedRect)) {
|
|
if (earlyExit && setNumber == 2) throw new NoOverlappingBoxFoundException();
|
|
it.remove();
|
|
}//if
|
|
}//while
|
|
ems2Clone.recomputeSize();
|
|
retArr[1] = ems2Clone;
|
|
|
|
return retArr;
|
|
}//end method bboxFilter
|
|
|
|
}//class SetOps
|
|
|
|
|
|
|
|
|
|
|
|
|