void DendrogramPanel::Setup(GdaNode* _root, int _nelements, int _nclusters,
std::vector<wxInt64>& _clusters, double _cutoff)
{
if (root != NULL) {
delete[] root;
}
root = new GdaNode[_nelements];
for (size_t i=0; i<_nelements; ++i) {
root[i] = _root[i];
}
nelements = _nelements;
clusters = _clusters;
nclusters = _nclusters;
cutoffDistance = _cutoff;
color_vec.clear();
CatClassification::PickColorSet(color_vec, nclusters);
// top Node will be nelements - 2
accessed_node.clear();
leaves = countLeaves(-(nelements-2) - 1);
level_node.clear();
levels = countLevels(-(nelements-2) - 1, 0);
maxDistance = root[nelements-2].distance;
init();
}
int DendrogramPanel::countLevels(GdaNode* node)
{
if (node->left >= 0 && node->right >= 0) {
return 1;
}
if (node->left >= 0 && node->right < 0) {
return 1 + countLevels(&root[-node->right-1]);
}
if (node->left < 0 && node->right >= 0) {
return 1 + countLevels(&root[-node->left-1]);
}
return 1 + max(countLevels(&root[-node->left-1]), countLevels(&root[-node->right-1]));
}
int DendrogramPanel::countLevels(int node_idx, int cur_lvl)
{
if (node_idx >= 0) {
return 1;
}
if (level_node.find(node_idx) != level_node.end()) {
// loop!!!
return 1;
}
level_node[node_idx] = root[-node_idx-1].distance;
int left = countLevels(root[-node_idx-1].left, cur_lvl+1);
int right = countLevels(root[-node_idx-1].right, cur_lvl+1);
int lvl = 1 + max(left, right);
return lvl;
}
void writeIndex(struct chromInfo *chromList, int chromCount, char *fileName)
/* Write index file - a b+ tree. */
{
/* Open file and write out header. */
FILE *f = mustOpen(fileName, "w");
bits32 magic = chromSizeIndexSig;
bits32 count = chromCount;
bits16 bSize = blockSize;
bits16 reserved16 = 0;
bits32 reserved32 = 0;
writeOne(f, magic);
writeOne(f, chromCount);
writeOne(f, bSize);
writeOne(f, reserved16);
writeOne(f, reserved32);
bits32 indexOffset = ftell(f);
/* Make array for all chromosomes. */
struct chromInfo *chrom, **chromArray;
AllocArray(chromArray, chromCount);
int i;
for (i=0, chrom=chromList; i<chromCount; ++i, chrom=chrom->next)
chromArray[i] = chrom;
/* Figure out how many levels in B tree, and number of chroms between items at highest level. */
int levels = countLevels(blockSize, chromCount);
verbose(1, "%d levels with blockSize %d covers %d items\n", levels, blockSize, chromCount);
/* Write non-leaf nodes. */
for (i=levels-1; i > 0; --i)
{
bits32 endLevelOffset = writeIndexLevel(chromArray, chromCount, indexOffset, i, f);
indexOffset = ftell(f);
if (endLevelOffset != indexOffset)
errAbort("internal err: mismatch endLevelOffset=%u vs indexOffset=%u", endLevelOffset, indexOffset);
}
/* Write leaf nodes */
writeLeafLevel(chromArray, chromCount, f);
/* Clean up and go home. */
freez(&chromArray);
carefulClose(&f);
}
int main(int argc, const char *argv[])
{
if (argc<2)
usage(0);
int arg = 1;
while (arg < argc)
{
if (stricmp(argv[arg], "-crc") == 0)
{
checkCRC = true;
}
else if (stricmp(argv[arg], "-errorLimit") == 0)
{
++arg;
if (arg>=argc)
usage(1);
errorLimit = strtoul(argv[arg], NULL, 10);
if (!errorLimit)
errorLimit = (unsigned) -1;
}
else if (stricmp(argv[arg], "-node") == 0)
{
++arg;
if (arg>=argc)
usage(1);
nodeAddress = strtoul(argv[arg], NULL, 16);
checkCRC = true;
}
else if (stricmp(argv[arg], "-noleaf") == 0)
{
skipLeafLevel = true;
}
else if (stricmp(argv[arg], "-quick") == 0)
{
quick = true;
}
else if (*argv[arg]=='-')
usage(1);
++arg;
}
arg = 1;
while (arg < argc)
{
if (*argv[arg]!='-')
{
curFileName = argv[arg];
printf("Processing key file %s\n", curFileName);
int f = _open(argv[arg], _O_RDONLY|_O_BINARY);
if (f==-1)
{
noteError(0, "Could not open file\n");
}
else
{
KeyHdr h;
if (_read(f, &h, sizeof(h)) != sizeof(h))
{
noteError(0, "Could not read key header\n");
}
else
{
SwapBigEndian(h);
if (nodeAddress)
{
checkNode(f, h, nodeAddress);
}
else if (quick)
{
int levels = countLevels(f, h, h.root);
printf("%d levels found\n", levels);
}
else
{
unsigned level = 0;
checkLevel(f, h, level, h.root);
}
}
_close(f);
}
}
arg++;
}
return errors;
}
unsigned countLevels(int f, KeyHdr &h, offset_t firstnode)
{
_lseeki64(f, firstnode, SEEK_SET);
char *nodeData = (char *) malloc(h.nodeSize);
if (!nodeData || _read(f, nodeData, h.nodeSize) != h.nodeSize)
{
noteError(firstnode, "Could not read node (error %d)\n", errno);
free(nodeData);
return 0;
}
else
{
NodeHdr &nodeHdr = *(NodeHdr *) nodeData;
swap(nodeHdr);
if (!nodeHdr.leafFlag)
{
unsigned __int64 fpos = *(unsigned __int64 *) (nodeData + sizeof(nodeHdr));
_WINREV(fpos);
free(nodeData);
return countLevels(f, h, fpos)+1;
}
else
{
free(nodeData);
return 1;
}
}
}
