/**
* Set the partition bit to true for segments on the border and where the direction is 0
*
* @param sl
*/
private void setPartitionBitForCertainSegments(ArrayList<Seg> sl) {
for (int i = 0; i != sl.size(); i++) {
Seg se = sl.get(i);
if (((se.x == 0 || se.x == width) && se.dx == 0)
|| ((se.y == 0 || se.y == height) && se.dy == 0)) se.partition = true;
}
}
@Test
public void analyze() throws RuleBaseException, TransformException {
SortBlock block = define("<sort as='corresponding'>$src</sort>");
setModGlobalScope(content.query());
Seg seg = block.createSeg(mod);
seg.analyze();
assertThat(block.requiredVariables, is(collection(new QName(null, "src", null))));
}
private void print(String what, ASTNode where) {
String addr = StringUtil.addrToString(segment.getCurrentAddress());
modulePrinter.println(
segment.getName()
+ " @ "
+ addr
+ ": "
+ what
+ " on line "
+ where.getLeftMostToken().beginLine);
}
/**
* Store the content of a leaf node, in particular its list of segments. All entries carry the
* number of the node as an index and each segment has an additional second index for the segment
* number.
*
* @param doc document to add data to
* @param mazeXML element to add data to
* @param number is an index number for this node in the XML format
* @return the highest used index number, in this case the given number
*/
int store(Document doc, Element mazeXML, int number) {
super.store(doc, mazeXML, number); // leaves number unchanged
if (isleaf == false) System.out.println("WARNING: isleaf flag and class are inconsistent!");
// store list of segments, store total number of elements first
MazeFileWriter.appendChild(doc, mazeXML, "numSeg_" + number, slist.size());
int i = 0;
for (Seg s : slist) {
s.storeSeg(doc, mazeXML, number, i);
i++;
}
return number;
}
/**
* Sets the seencells bit for all cells of a segment
*
* @param seg
*/
private void udpateSeenCellsForSegment(Seg seg) {
seg.seen = true; // updates the segment
int sdx = seg.dx / map_unit; // constant, only set once here
int sdy = seg.dy / map_unit; // constant, only set once here
// get initial position right on loop variables sx, sy
int sx = seg.x / map_unit;
if (sdx < 0) sx--;
int sy = seg.y / map_unit;
if (sdy < 0) sy--;
// define constants to avoid method calls in following loop
int sdsx = MazeBuilder.getSign(sdx);
int sdsy = MazeBuilder.getSign(sdy);
int bit = (sdx != 0) ? Cells.CW_TOP : Cells.CW_LEFT;
int len = Math.abs(sdx + sdy);
// true loop variables are (sx,sy),
for (int i = 0; i != len; i++) {
// seencells[sx][sy] |= bit;
seencells.setBitToOne(sx, sy, bit); // updates the cell
sx += sdsx;
sy += sdsy;
}
}
/**
* Method called in genNodes to determine the minimum of all such grades. The method is static,
* i.e. it does not update internal attributes and just calculates the returned value.
*
* @param sl vector of segments
* @param pe particular segment
* @return undocumented
*/
private int grade_partition(ArrayList<Seg> sl, Seg pe) {
// copy attributes of parameter pe
final int x = pe.x;
final int y = pe.y;
final int dx = pe.dx;
final int dy = pe.dy;
final int inc = (sl.size() >= 100) ? sl.size() / 50 : 1; // increment for iteration below
// define some local counter
int lcount = 0, rcount = 0, splits = 0;
// check all segments
for (int i = 0; i < sl.size(); i += inc) {
Seg se = (Seg) sl.get(i);
int df1x = se.x - x; // difference between beginning of segment and x
int df1y = se.y - y; // difference between beginning of segment and y
int sendx = se.x + se.dx; // end of segment
int sendy = se.y + se.dy; // end of segment
int df2x = sendx - x; // difference between end of segment and x
int df2y = sendy - y; // difference between end of segment and y
int nx = dy;
int ny = -dx;
int dot1 = df1x * nx + df1y * ny;
int dot2 = df2x * nx + df2y * ny;
if (getSign(dot1) != getSign(dot2)) {
if (dot1 == 0) dot1 = dot2;
else if (dot2 != 0) {
splits++;
continue;
}
}
if (dot1 > 0 || (dot1 == 0 && se.getDir() == pe.getDir())) {
rcount++;
} else if (dot1 < 0 || (dot1 == 0 && se.getDir() == -pe.getDir())) {
lcount++;
} else {
dbg("grade_partition problem: dot1 = " + dot1 + ", dot2 = " + dot2);
}
}
return Math.abs(lcount - rcount) + splits * 3;
}
protected void addItem(Item i) {
itemList.add(i);
segment.advance(i.itemSize());
}
// .byte directive
public void reserveBytes(Expr e, Expr f) {
// TODO: fill section with particular value
int result = e.evaluate(segment.getCurrentAddress(), this);
modulePrinter.println("reserveBytes(" + e + ") -> " + result);
addItem(new Item.UninitializedData(segment, result));
}
// .org directive
public void setOrigin(Expr.Constant c) {
int result = c.evaluate(segment.getCurrentAddress(), this);
modulePrinter.println("setOrigin(" + c + ") -> " + result);
segment.setOrigin(result);
}
/**
* It generates the nodes. In every node, it has two section, left and right. It chooses the
* segment which has the minimum grade value and then split this node into two nodes through this
* segment. If all the segments in one node are partitioned, it will stop to split.
*
* @param sl
* @return root node for BSP tree
*/
private BSPNode genNodes(ArrayList<Seg> sl) {
// if there is no segment with a partition bit set to false, there is nothing else to do and we
// are at a leaf node
if (countNonPartitions(sl) == 0) return new BSPLeaf(sl);
// from the ones that have a partition bit set to false, pick a candidate with a low grade
Seg pe = findPartitionCandidate(sl);
// work on segment pe
// mark pe as partitioned
pe.partition = true;
final int x = pe.x;
final int y = pe.y;
final int dx = pe.dx;
final int dy = pe.dy;
final ArrayList<Seg> lsl = new ArrayList<Seg>();
final ArrayList<Seg> rsl = new ArrayList<Seg>();
for (int i = 0; i != sl.size(); i++) {
Seg se = (Seg) sl.get(i);
int df1x = se.x - x;
int df1y = se.y - y;
int sendx = se.x + se.dx;
int sendy = se.y + se.dy;
int df2x = sendx - x;
int df2y = sendy - y;
int nx = dy;
int ny = -dx;
int dot1 = df1x * nx + df1y * ny;
int dot2 = df2x * nx + df2y * ny;
if (getSign(dot1) != getSign(dot2)) {
if (dot1 == 0) dot1 = dot2;
else if (dot2 != 0) {
// we need to split this
int spx = se.x;
int spy = se.y;
if (dx == 0) spx = x;
else spy = y;
Seg sps1 = new Seg(se.x, se.y, spx - se.x, spy - se.y, se.dist, colchange);
Seg sps2 = new Seg(spx, spy, sendx - spx, sendy - spy, se.dist, colchange);
if (dot1 > 0) {
rsl.add(sps1);
lsl.add(sps2);
} else {
rsl.add(sps2);
lsl.add(sps1);
}
sps1.partition = sps2.partition = se.partition;
continue;
}
}
if (dot1 > 0 || (dot1 == 0 && se.getDir() == pe.getDir())) {
rsl.add(se);
if (dot1 == 0) se.partition = true;
} else if (dot1 < 0 || (dot1 == 0 && se.getDir() == -pe.getDir())) {
lsl.add(se);
if (dot1 == 0) se.partition = true;
} else {
dbg("error xx 1 " + dot1);
}
}
if (lsl.size() == 0) return new BSPLeaf(rsl);
if (rsl.size() == 0) return new BSPLeaf(lsl);
return new BSPBranch(x, y, dx, dy, genNodes(lsl), genNodes(rsl)); // recursion on both branches
}
