private void MakeDendrogs(AglomerativeType linkage)
{
ClusterOutput outCl;
hierarchicalCluster dendrog = new hierarchicalCluster(dMeasure, input, dirName);
currentV = 0;
maxV = leaves.Count + 1;
double remProgress = currentProgress;
for (int i = 0; i < leaves.Count; i++)
{
HClusterNode c = leaves[i];
dendrog.mustRefStructure = c.setStruct[0];
outCl = dendrog.HierarchicalClustering(c.setStruct);
dendrogList.Add(c);
c.levelDist = outCl.hNode.levelDist;
c.realDist = dMeasure.GetRealValue(c.levelDist);
c.refStructure = outCl.hNode.refStructure;
if (outCl.hNode.joined != null)
{
c.joined = new List <HClusterNode>();
foreach (var item in outCl.hNode.joined)
{
c.joined.Add(item);
}
}
currentV++;
currentProgress = remProgress + 1.0 / maxProgress * (double)currentV / maxV;
}
maxV = currentV;
currentProgress = remProgress;
}
public hierarchicalCluster(DistanceMeasure dMeasure, HierarchicalCInput hier, string dirName)
{
this.dMeasure = dMeasure;
this.linkageType = hier.linkageType;
this.dirName = dirName;
progressRead = 0;
hierOpt = hier;
}
public HashClusterDendrog(DCDFile dcd, HashCInput input, HierarchicalCInput dendrogOpt) : base(dcd, input)
{
this.dMeasure = dendrogOpt.distance;
this.linkageType = dendrogOpt.linkageType;
this.atoms = dendrogOpt.atoms;
this.jury1d = dendrogOpt.reference1DjuryH;
this.profileName = dendrogOpt.hammingProfile;
this.refJuryProfile = dendrogOpt.jury1DProfileH;
hier = dendrogOpt;
}
public FastDendrog(DistanceMeasure dMeasure, HierarchicalCInput input, string dirName)
{
this.dMeasure = dMeasure;
this.initNodesNum = input.numInitNodes;
this.linkage = input.linkageType;
this.useKMeans = input.ItMeans;
this.hConcensus = input.HConsensus;
this.kMeansIter = input.ItNum;
this.dirName = dirName;
this.input = input;
}
public HashClusterDendrog(string dirName, string alignFile, HashCInput input, DistanceMeasures dMeasure, AglomerativeType linkageType, PDB.PDBMODE atoms, bool jury1d, string alignFileName,
string profileName = null, string refJuryProfile = null):base(dirName,alignFile,input)
{
this.dMeasure=dMeasure;
this.linkageType=linkageType;
this.atoms = atoms;
this.jury1d = jury1d;
this.profileName = profileName;
this.refJuryProfile = refJuryProfile;
this.dirName = dirName;
}
public FastDendrog(DistanceMeasure dMeasure,HierarchicalCInput input,string dirName)
{
this.dMeasure = dMeasure;
this.initNodesNum = input.numInitNodes;
this.linkage = input.linkageType;
this.useKMeans = input.ItMeans;
this.hConcensus = input.HConsensus;
this.kMeansIter = input.ItNum;
this.dirName = dirName;
this.input = input;
}
//private jury1D jury;
public hierarchicalCluster (DistanceMeasure dMeasure, AglomerativeType linkageType,string dirName)
{
this.dMeasure=dMeasure;
this.linkageType = linkageType;
this.dirName = dirName;
}
//private jury1D jury;
public hierarchicalCluster(DistanceMeasure dMeasure, AglomerativeType linkageType, string dirName)
{
this.dMeasure = dMeasure;
this.linkageType = linkageType;
this.dirName = dirName;
}
private HClusterNode ConnectDendrogs(AglomerativeType linkage)
{
List <Dictionary <int, int> > sim = new List <Dictionary <int, int> >();
HClusterNode rootNode;
int maxV = 1000000000;
int minV = maxV - 1;
while (minV != maxV && dendrogList.Count > 2)
{
int[,] distanceM = new int[dendrogList.Count, dendrogList.Count];
minV = maxV;
for (int i = 0; i < dendrogList.Count; i++)
{
for (int j = i + 1; j < dendrogList.Count; j++)
{
distanceM[i, j] = dMeasure.GetDistance(dendrogList[i].refStructure, dendrogList[j].refStructure);
//distanceM[i, j] = dMeasure.FindMinimalDistance(dendrogList[i], dendrogList[j],linkage);
if (distanceM[i, j] < minV)
{
minV = distanceM[i, j];
}
}
}
if (minV != maxV)
{
sim.Clear();
for (int i = 0; i < dendrogList.Count; i++)
{
Dictionary <int, int> aux = new Dictionary <int, int>();
aux.Add(i, 0);
for (int j = i + 1; j < dendrogList.Count; j++)
{
if (distanceM[i, j] == minV)
{
aux.Add(j, 0);
}
}
if (aux.Keys.Count > 1)
{
sim.Add(aux);
}
}
for (int i = 0; i < sim.Count; i++)
{
for (int j = i + 1; j < sim.Count; j++)
{
foreach (var item in sim[j].Keys)
{
if (sim[i].ContainsKey(item))
{
foreach (var itemCopy in sim[j].Keys)
{
if (!sim[i].ContainsKey(itemCopy))
{
sim[i].Add(itemCopy, 0);
}
}
sim.RemoveAt(j);
i = -1;
j = sim.Count;
break;
}
}
}
}
List <HClusterNode> lNodes = new List <HClusterNode>();
List <int> removeList = new List <int>();
for (int n = sim.Count - 1; n >= 0; n--)
{
HClusterNode node = new HClusterNode();
node.joined = new List <HClusterNode>();
node.setStruct = new List <string>();
lNodes.Clear();
foreach (var item in sim[n].Keys)
{
if (!lNodes.Contains(dendrogList[item]))
{
lNodes.Add(dendrogList[item]);
}
}
node = JoinNodes(lNodes);
node.levelDist = minV;
node.realDist = dMeasure.GetRealValue(minV);
List <int> keys = new List <int>(sim[n].Keys);
keys.Sort();
dendrogList[keys[0]] = node;
for (int i = keys.Count - 1; i >= 1; i--)
{
if (!removeList.Contains(keys[i]))
{
removeList.Add(keys[i]);
}
// dendrogList.RemoveAt(keys[i]);
}
}
removeList.Sort();
for (int i = removeList.Count - 1; i >= 0; i--)
{
dendrogList.RemoveAt(removeList[i]);
}
}
}
if (dendrogList.Count > 1)
{
rootNode = JoinNodes(dendrogList);
}
else
{
rootNode = dendrogList[0];
}
return(rootNode);
}
private HClusterNode ConnectDendrogs(AglomerativeType linkage)
{
List <Dictionary<int,int>> sim = new List<Dictionary<int,int>>();
HClusterNode rootNode;
int maxV = 1000000000;
int minV = maxV-1;
while (minV != maxV && dendrogList.Count>2)
{
int[,] distanceM = new int[dendrogList.Count, dendrogList.Count];
minV = maxV;
for (int i = 0; i < dendrogList.Count; i++)
{
for (int j = i + 1; j < dendrogList.Count; j++)
{
distanceM[i, j] = dMeasure.GetDistance(dendrogList[i].refStructure, dendrogList[j].refStructure);
//distanceM[i, j] = dMeasure.FindMinimalDistance(dendrogList[i], dendrogList[j],linkage);
if (distanceM[i, j] < minV)
minV = distanceM[i, j];
}
}
if (minV != maxV)
{
sim.Clear();
for (int i = 0; i < dendrogList.Count; i++)
{
Dictionary<int, int> aux = new Dictionary<int, int>();
aux.Add(i, 0);
for (int j = i + 1; j < dendrogList.Count; j++)
{
if (distanceM[i, j] == minV)
aux.Add(j, 0);
}
if (aux.Keys.Count > 1)
sim.Add(aux);
}
for (int i = 0; i < sim.Count; i++)
{
for (int j = i + 1; j < sim.Count; j++)
{
foreach (var item in sim[j].Keys)
if (sim[i].ContainsKey(item))
{
foreach (var itemCopy in sim[j].Keys)
if (!sim[i].ContainsKey(itemCopy))
sim[i].Add(itemCopy, 0);
sim.RemoveAt(j);
i = -1;
j=sim.Count;
break;
}
}
}
List<HClusterNode> lNodes = new List<HClusterNode>();
List<int> removeList = new List<int>();
for (int n = sim.Count-1; n >=0; n--)
{
HClusterNode node = new HClusterNode();
node.joined = new List<HClusterNode>();
node.setStruct = new List<string>();
lNodes.Clear();
foreach (var item in sim[n].Keys)
if(!lNodes.Contains(dendrogList[item]))
lNodes.Add(dendrogList[item]);
node = JoinNodes(lNodes);
node.levelDist = minV;
node.realDist = dMeasure.GetRealValue(minV);
List<int> keys = new List<int>(sim[n].Keys);
keys.Sort();
dendrogList[keys[0]] = node;
for (int i = keys.Count - 1; i >= 1;i-- )
{
if(!removeList.Contains(keys[i]))
removeList.Add(keys[i]);
// dendrogList.RemoveAt(keys[i]);
}
}
removeList.Sort();
for (int i = removeList.Count - 1; i >= 0; i--)
dendrogList.RemoveAt(removeList[i]);
}
}
if (dendrogList.Count > 1)
rootNode = JoinNodes(dendrogList);
else
rootNode = dendrogList[0];
return rootNode;
}
private void MakeDendrogs(AglomerativeType linkage)
{
ClusterOutput outCl;
hierarchicalCluster dendrog = new hierarchicalCluster(dMeasure,linkage,dirName);
currentV = 0;
maxV = leaves.Count+1;
double remProgress = currentProgress;
for(int i=0;i<leaves.Count;i++)
{
HClusterNode c = leaves[i];
dendrog.mustRefStructure = c.setStruct[0];
outCl = dendrog.HierarchicalClustering(c.setStruct);
dendrogList.Add(c);
c.levelDist = outCl.hNode.levelDist;
c.realDist = dMeasure.GetRealValue(c.levelDist);
c.refStructure = outCl.hNode.refStructure;
if(outCl.hNode.joined!=null)
{
c.joined = new List<HClusterNode>();
foreach (var item in outCl.hNode.joined)
c.joined.Add(item);
}
currentV++;
currentProgress=remProgress+1.0/maxProgress* (double)currentV / maxV;
}
maxV = currentV;
currentProgress = remProgress;
}
public KeyValuePair <int, int> FindMinimalDistance(HClusterNode clust1, HClusterNode clust2, AglomerativeType linkageType)
{
int dist = 0;
int index = 0;
int min = 0;
switch (linkageType)
{
case AglomerativeType.SINGLE:
min = Int32.MaxValue;
foreach (var item1 in clust1.setStruct)
{
int v = hashIndex[item1];
foreach (var item2 in clust2.setStruct)
{
dist = GetDistance(v, hashIndex[item2]);
if (dist < min)
{
min = dist;
index = GetIndex(v, hashIndex[item2]);
}
}
}
break;
case AglomerativeType.AVERAGE:
dist = GetDistance(hashIndex[clust1.refStructure], hashIndex[clust2.refStructure]);
index = GetIndex(hashIndex[clust1.refStructure], hashIndex[clust2.refStructure]);
break;
case AglomerativeType.COMPLETE:
min = Int32.MinValue;
foreach (var item1 in clust1.setStruct)
{
int v = hashIndex[item1];
foreach (var item2 in clust2.setStruct)
{
dist = GetDistance(v, hashIndex[item2]);
if (dist > min)
{
min = dist;
index = GetIndex(v, hashIndex[item2]);
}
}
}
break;
}
return(new KeyValuePair <int, int>(dist, index));
}
