private static InfoNode createInfoNode(HuffNode[] tree, int i, int level, int dataWidth) {
InfoNode newNode = null;
int dx = dataWidth;
if (i != HuffNode.NIL) {
newNode = new InfoNode();
// allocate node for left child at next level in tree; attach node
InfoNode newLeft = createInfoNode(tree, tree[i].left, level + 1, dataWidth);
newNode.left = newLeft;
// initialize data in new node
newNode.value = tree[i];
newNode.column = InfoNode.columnValue;
newNode.level = level;
// update column to position dx characters to right of current position
InfoNode.columnValue += dx;
// allocate node for right child at next level in tree; attach node
InfoNode newRight = createInfoNode(tree, tree[i].right, level + 1, dataWidth);
newNode.right = newRight;
}
return newNode;
}
public void updateFilteredTree(boolean filter) {
((DefaultMutableTreeNode) detailsTree.getModel().getRoot()).removeAllChildren();
ImageDirectory imDir = (ImageDirectory) lsm.imageDirectories.get(0);
CZLSMInfoExtended cz = (CZLSMInfoExtended) imDir.TIF_CZ_LSMINFO;
InfoNode czNode = new InfoNode("CarlZeiss", convertCZ(cz));
((DefaultMutableTreeNode) treemodel.getRoot()).add(czNode);
if (cz.scanInfo == null) return;
ScanInfo scanInfo = cz.scanInfo;
ArrayList<Recording> recordings = scanInfo.recordings;
for (int i = 0; i < recordings.size(); i++) {
Recording recording = recordings.get(i);
InfoNode recordingsNode = new InfoNode("Recordings", recording.records);
if (recording.lasers != null) {
DefaultMutableTreeNode lasersNode = new DefaultMutableTreeNode("Lasers");
for (int j = 0; j < recording.lasers.length; j++) {
LinkedHashMap<String, Object> map = recording.lasers[j].records;
Object o = map.get("LASER_ACQUIRE");
if (!filter || (o == null) || (o != null & o.toString().equals("-1")))
lasersNode.add(new InfoNode("Laser " + j, recording.lasers[j].records));
}
recordingsNode.add(lasersNode);
}
if (recording.tracks != null) {
DefaultMutableTreeNode tracksNode = new DefaultMutableTreeNode("Tracks");
for (int j = 0; j < recording.tracks.length; j++) {
DefaultMutableTreeNode trackNode =
new InfoNode("Track " + j, recording.tracks[j].records);
if (recording.tracks[j].detectionChannels != null) {
if (recording.tracks[j].detectionChannels.length > 0) {
DefaultMutableTreeNode detectionChannelsNode =
new DefaultMutableTreeNode("DetectionChannels");
for (int k = 0; k < recording.tracks[j].detectionChannels.length; k++) {
LinkedHashMap<String, Object> map =
recording.tracks[j].detectionChannels[k].records;
Object o = map.get("ACQUIRE");
if (!filter || (o == null) || (o != null & o.toString().equals("-1")))
detectionChannelsNode.add(
new InfoNode(
"DetectionChannel " + k,
recording.tracks[j].detectionChannels[k].records));
}
trackNode.add(detectionChannelsNode);
}
}
if (recording.tracks[j].illuminationChannels != null) {
if (recording.tracks[j].illuminationChannels.length > 0) {
DefaultMutableTreeNode illuminationChannelsNode =
new DefaultMutableTreeNode("IlluminationChannels");
for (int k = 0; k < recording.tracks[j].illuminationChannels.length; k++) {
LinkedHashMap<String, Object> map =
recording.tracks[j].illuminationChannels[k].records;
Object o = map.get("ACQUIRE");
if (!filter || (o == null) || (o != null & o.toString().equals("-1")))
illuminationChannelsNode.add(
new InfoNode(
"IlluminationChannel " + k,
recording.tracks[j].illuminationChannels[k].records));
}
trackNode.add(illuminationChannelsNode);
}
}
if (recording.tracks[j].beamSplitters != null) {
if (recording.tracks[j].beamSplitters.length > 0) {
DefaultMutableTreeNode beamSplittersNode =
new DefaultMutableTreeNode("BeamSplitters");
for (int k = 0; k < recording.tracks[j].beamSplitters.length; k++) {
InfoNode bsNode =
new InfoNode("Beamsplitter " + k, recording.tracks[j].beamSplitters[k].records);
beamSplittersNode.add(bsNode);
}
trackNode.add(beamSplittersNode);
}
}
if (recording.tracks[j].dataChannels != null) {
if (recording.tracks[j].dataChannels.length > 0) {
DefaultMutableTreeNode dataChannelsNode = new DefaultMutableTreeNode("DataChannels");
for (int k = 0; k < recording.tracks[j].dataChannels.length; k++) {
LinkedHashMap<String, Object> map = recording.tracks[j].dataChannels[k].records;
Object o = map.get("ACQUIRE");
if (!filter || (o == null) || (o != null & o.toString().equals("-1")))
dataChannelsNode.add(
new InfoNode(
"DataChannel " + k, recording.tracks[j].dataChannels[k].records));
}
trackNode.add(dataChannelsNode);
}
}
tracksNode.add(trackNode);
}
if (tracksNode.getChildCount() > 0) recordingsNode.add(tracksNode);
}
if (recording.markers != null) {
DefaultMutableTreeNode markersNode = new DefaultMutableTreeNode("Markers");
for (int j = 0; j < recording.markers.length; j++) {
markersNode.add(new InfoNode("Marker " + j, recording.markers[j].records));
}
recordingsNode.add(markersNode);
}
if (recording.timers != null) {
DefaultMutableTreeNode timersNode = new DefaultMutableTreeNode("Timers");
for (int j = 0; j < recording.timers.length; j++) {
timersNode.add(new InfoNode("Timer " + j, recording.timers[j].records));
}
recordingsNode.add(timersNode);
}
((DefaultMutableTreeNode) treemodel.getRoot()).add(recordingsNode);
}
lastNodeResult = null;
searchCoordinates = null;
((TreeTableModel) table.getModel()).setFiltered(filter);
treemodel.reload();
expandAll();
}
/**
* Testing basic database operations (CRUD) using our implemented class InfoDataSource. It is the
* internal database that is being tested.
*
* @throws SQLException
*/
public void testDbFun() throws SQLException {
// Test create/insert into database
InfoNode a = ids.createInfoNode("A", 0, 0, 0, "Info_1", "Addr_1", 111111111, "ObjID");
InfoNode b = ids.createInfoNode("B", 0, 0, 0, "Info_2", "Addr_2", 222222222, "ObjID");
InfoNode c = ids.createInfoNode("C", 0, 0, 0, "Info_3", "Addr_3", 333333333, "ObjID");
// Test get all data from database
List<InfoNode> infoNodes = ids.getAllInfoNodes();
/**
* Checks if the retrieved data contains all inserted data. (We only compare title for now, we
* test the unit in another class/separate test). Checks that the InfoNode's created doesn't
* have the same Id (which is generated by the database). Also checks that getLatestModified()
* method returns the right value.
*/
assertTrue(infoNodes.size() == 3);
assertTrue(infoNodes.get(0).getTitle().equals(a.getTitle()));
assertTrue(infoNodes.get(1).getTitle().equals(b.getTitle()));
assertTrue(infoNodes.get(2).getTitle().equals(c.getTitle()));
assertTrue(a.getId() != b.getId() && a.getId() != c.getId() && b.getId() != c.getId());
assertTrue(ids.getLatestModified() == c.getLatestModified());
// Test delete from database
ids.deleteInfoNode(b);
/** Checks that the deleted data is gone and that the other data still remains. */
infoNodes = ids.getAllInfoNodes();
assertTrue(infoNodes.size() == 2);
assertTrue(infoNodes.get(0).getTitle().equals(a.getTitle()));
assertTrue(infoNodes.get(1).getTitle().equals(c.getTitle()));
// Test clear all data from table
ids.clearTable();
assertTrue(ids.getAllInfoNodes().isEmpty());
}
