//-------------------------------------------------------------------
public void AddFatherAll(TaxonTreeNode _taxon)
{
if (_taxon == null)
{
return;
}
TaxonDialog.NewTaxon dlg = new TaxonDialog.NewTaxon
{
TopMost = true,
CheckNameUsage = true
};
dlg.ShowDialog();
if (dlg.DialogResult != DialogResult.OK)
{
return;
}
TaxonDesc newTaxon = new TaxonDesc(dlg.TaxonName);
TaxonTreeNode newNode = new TaxonTreeNode(newTaxon);
TaxonTreeNode OldFather = _taxon.Father;
foreach (TaxonTreeNode child in OldFather.Children)
{
newNode.AddChild(child);
}
OldFather.Children.Clear();
OldFather.AddChild(newNode);
OldFather.Expand();
newNode.Expand();
RefreshGraph();
}
//-------------------------------------------------------------------
public void AddFather(TaxonTreeNode _taxon)
{
if (_taxon == null)
{
return;
}
TaxonDialog.NewTaxon dlg = new TaxonDialog.NewTaxon
{
TopMost = true,
CheckNameUsage = true
};
dlg.ShowDialog();
if (dlg.DialogResult != DialogResult.OK)
{
return;
}
TaxonDesc newTaxon = new TaxonDesc(dlg.TaxonName);
TaxonTreeNode newNode = new TaxonTreeNode(newTaxon);
TaxonTreeNode OldFather = _taxon.Father;
OldFather.ReplaceChild(_taxon, newNode);
newNode.AddChild(_taxon);
OldFather.Expand();
newNode.Expand();
RefreshGraph();
}
public void ImportNode(TaxonTreeNode _where, TaxonTreeNode _what)
{
if (_what.Desc.Name == "__ignore__" || _where.Desc.RefMultiName.ItsOneOfMyNames(_what.Desc.RefMultiName.Main))
{
foreach (TaxonTreeNode node in _what.Children)
{
_where.AddChild(node);
}
}
else
{
_where.AddChild(_what);
}
_where.SortChildren();
_where.Expand();
TaxonUtils.OriginalRoot.UpdateRedListCategoryFlags();
RefreshGraph();
}
//=========================================================================================
// Newick load
//
static TaxonTreeNode ParseNewick(StreamReader sr)
{
TaxonTreeNode node = new TaxonTreeNode(new TaxonDesc());
string name = "";
char ch = (char)sr.Read();
if (ch == '(')
{
while (ch != ')')
{
TaxonTreeNode child = ParseNewick(sr);
node.AddChild(child);
ch = (char)sr.Read();
}
}
if (ch != ')')
{
name += ch;
}
ch = (char)sr.Peek();
while (ch != ',' && ch != ';' && ch != ')')
{
sr.Read();
name += ch;
ch = (char)sr.Peek();
}
name = name.Replace("'", "");
int index = name.LastIndexOf("_ott");
if (index != -1)
{
string ottString = name.Substring(index + 4);
UInt32 id;
if (UInt32.TryParse(ottString, out id))
{
node.Desc.OTTID = id;
name = name.Remove(index);
}
}
node.Desc.RefMultiName = new Helpers.MultiName(name.Replace('_', ' '));
return(node);
}
//-------------------------------------------------------------------
public void AddChild(TaxonTreeNode _taxon)
{
if (_taxon == null)
{
return;
}
string firstName = null;
if (_taxon.Desc.ClassicRank == ClassicRankEnum.Genre)
{
firstName = _taxon.Desc.RefMainName;
}
TaxonDialog.NewTaxon dlg = new TaxonDialog.NewTaxon(firstName)
{
TopMost = true,
CheckNameUsage = true
};
dlg.ShowDialog();
if (dlg.DialogResult != DialogResult.OK)
{
return;
}
TaxonDesc newTaxon = new TaxonDesc(dlg.TaxonName);
if (_taxon.Desc.ClassicRank == ClassicRankEnum.Genre)
{
newTaxon.ClassicRank = ClassicRankEnum.Espece;
}
else if (_taxon.Desc.ClassicRank == ClassicRankEnum.Espece)
{
newTaxon.ClassicRank = ClassicRankEnum.SousEspece;
}
TaxonTreeNode newNode = new TaxonTreeNode(newTaxon);
_taxon.AddChild(newNode);
_taxon.SortChildren();
_taxon.Expand();
RefreshGraph();
}
static TaxonTreeNode LoadBin(BinaryReader _r, uint _version)
{
LoadCounterInc();
if (_LoadCanceled)
{
return(null);
}
TaxonTreeNode node = new TaxonTreeNode()
{
Desc = TaxonDesc.LoadBin(_r, _version)
};
int count = _r.ReadInt32();
for (int i = 0; i < count; i++)
{
TaxonTreeNode child = LoadBin(_r, _version);
if (child == null)
{
return(null);
}
node.AddChild(child);
}
return(node);
}
public static TaxonTreeNode ImportOTT(string _folder)
{
if (!Directory.Exists(_folder))
{
return(null);
}
string fileTaxonomy = _folder + Path.DirectorySeparatorChar + "taxonomy.tsv";
if (!File.Exists(fileTaxonomy))
{
return(null);
}
TaxonTreeNode root = null;
using (StreamReader sr = new StreamReader(fileTaxonomy))
{
string line;
// read header line
if ((line = sr.ReadLine()) == null)
{
return(null);
}
List <string> columsHeader = line.Split(new Char[] { '|' }).ToList();
if (columsHeader.Count < 3)
{
return(null);
}
int[] ColumnIndex = Enumerable.Repeat(-1, (int)ColumnType.count).ToArray();
List <string> unknownHeader = new List <string>();
for (int i = 0; i < columsHeader.Count; i++)
{
string header = columsHeader[i].Trim().ToLower();
if (header == "uid")
{
ColumnIndex[(int)ColumnType.uid] = i;
}
else if (header == "parent_uid")
{
ColumnIndex[(int)ColumnType.parent_uid] = i;
}
else if (header == "name")
{
ColumnIndex[(int)ColumnType.name] = i;
}
else if (header == "rank")
{
ColumnIndex[(int)ColumnType.rank] = i;
}
else if (header == "sourceinfo")
{
ColumnIndex[(int)ColumnType.sourceinfo] = i;
}
else if (header == "uniqname")
{
ColumnIndex[(int)ColumnType.uniqname] = i;
}
else if (header == "flags")
{
ColumnIndex[(int)ColumnType.flags] = i;
}
else
{
unknownHeader.Add(header);
}
}
if (ColumnIndex[(int)ColumnType.uid] == -1)
{
return(null);
}
if (ColumnIndex[(int)ColumnType.parent_uid] == -1)
{
return(null);
}
if (ColumnIndex[(int)ColumnType.name] == -1)
{
return(null);
}
if (ColumnIndex[(int)ColumnType.rank] == -1)
{
return(null);
}
Dictionary <uint, TaxonTreeNode> dico = new Dictionary <uint, TaxonTreeNode>();
List <string> listRanks = new List <string>();
List <string> listSourceInfo = new List <string>();
List <string> listFlags = new List <string>();
Dictionary <uint, string> dicoUniqueName = new Dictionary <uint, string>();
bool first = true;
while ((line = sr.ReadLine()) != null)
{
string[] columns = line.Split(new Char[] { '|' });
if (columns.Length != columsHeader.Count)
{
continue;
}
uint id;
if (!uint.TryParse(columns[ColumnIndex[(int)ColumnType.uid]].Trim(), out id))
{
continue;
}
TaxonTreeNode node = new TaxonTreeNode(new TaxonDesc(columns[ColumnIndex[(int)ColumnType.name]].Trim()));
node.Desc.OTTID = id;
dico[id] = node;
if (!first)
{
uint parent_uid;
if (!uint.TryParse(columns[ColumnIndex[(int)ColumnType.parent_uid]].Trim(), out parent_uid))
{
continue;
}
if (!dico.ContainsKey(parent_uid))
{
continue;
}
TaxonTreeNode parentNode = dico[parent_uid];
parentNode.AddChild(node);
}
else
{
first = false;
root = node;
}
string rank = columns[ColumnIndex[(int)ColumnType.rank]].Trim().ToLower();
if (rank != "")
{
AddRank(listRanks, rank);
node.Desc.ClassicRank = fromOttString(rank);
}
AddSourceInfos(listSourceInfo, columns[ColumnIndex[(int)ColumnType.sourceinfo]]);
AddFlags(listFlags, columns[ColumnIndex[(int)ColumnType.flags]]);
}
listRanks.Sort();
using (System.IO.StreamWriter file = new System.IO.StreamWriter(_folder + "/ranks.txt"))
{
foreach (string rank in listRanks)
{
file.WriteLine(rank);
}
}
listSourceInfo.Sort();
using (System.IO.StreamWriter file = new System.IO.StreamWriter(_folder + "/sources.txt"))
{
foreach (string source in listSourceInfo)
{
file.WriteLine(source);
}
}
listFlags.Sort();
using (System.IO.StreamWriter file = new System.IO.StreamWriter(_folder + "/flags.txt"))
{
foreach (string flag in listFlags)
{
file.WriteLine(flag);
}
}
}
ConvertOttString = null;
return(root);
}
//=========================================================================================
// Jac File load
//
static TaxonTreeNode LoadJacFile(string _filename)
{
try
{
using (StreamReader sr = new StreamReader(_filename))
{
TaxonTreeNode root = new TaxonTreeNode(new TaxonDesc("__ignore__"));
TaxonTreeNode currentNode = root;
int currentTab = 0;
int currentLine = 0;
string line;
// read header line
while ((line = sr.ReadLine()) != null)
{
currentLine++;
int tab = 0;
while (line.StartsWith("\t"))
{
tab++; line = line.Substring(1);
}
if (tab > currentTab)
{
if (tab - currentTab > 1 || currentNode.Children.Count == 0)
{
Loggers.WriteError(LogTags.Data, _filename + "(" + currentLine.ToString() + ") too many tabs");
return(null);
}
currentTab = tab;
currentNode = currentNode.Children[currentNode.Children.Count - 1];
}
else if (tab < currentTab)
{
while (currentTab != tab)
{
if (currentNode == root)
{
Loggers.WriteError(LogTags.Data, _filename + "(" + currentLine.ToString() + ") tabulation error");
return(null);
}
currentTab--;
currentNode = currentNode.Father;
}
}
string[] parts = line.Split('>');
TaxonTreeNode newNode = new TaxonTreeNode(new TaxonDesc()
{
RefMultiName = new Helpers.MultiName(parts[0]),
FrenchMultiName = parts.Length < 2 || String.IsNullOrWhiteSpace(parts[1]) ? null : new Helpers.MultiName(parts[1]),
ClassicRank = parts.Length < 3 || String.IsNullOrWhiteSpace(parts[2]) ? ClassicRankEnum.None : ClassicRankEnumExt.FromString(parts[2]),
Flags = (parts.Length < 4 || String.IsNullOrWhiteSpace(parts[3])) ? 0 : FlagsEnumExt.FromString(parts[3]),
RedListCategory = (parts.Length < 5 || String.IsNullOrWhiteSpace(parts[4])) ? RedListCategoryEnum.NotEvaluated : RedListCategoryExt.FromString(parts[4]),
}
);
currentNode.AddChild(newNode);
}
return(root);
}
}
catch (Exception e)
{
Loggers.WriteError(LogTags.Data, "Exception raised while reading file " + _filename + "\n " + e.Message);
return(null);
}
}
