private void SaveFile(string fileName)
{
SuspendEngine();
string tempFile = System.IO.Path.GetTempFileName();
FileStream file = File.Create(tempFile);
foreach (ModuleView na in theNeuronArray.modules)
{
if (na.TheModule != null)
{
na.TheModule.SetUpBeforeSave();
}
}
//hide unused neurons to save on file size
for (int i = 0; i < theNeuronArray.arraySize; i++)
{
if (!theNeuronArray.GetNeuron(i).InUse() && theNeuronArray.GetNeuron(i).Model == Neuron.modelType.Std)
{
theNeuronArray.SetNeuron(i, null);
}
}
//Save the data from the network (NeuronArray and modules) to the file
try
{
theNeuronArray.displayParams = theNeuronArrayView.Dp;
XmlSerializer writer = new XmlSerializer(typeof(NeuronArray), GetModuleTypes());
writer.Serialize(file, theNeuronArray);
file.Close();
currentFileName = fileName;
Properties.Settings.Default["CurrentFile"] = currentFileName;
Properties.Settings.Default.Save();
File.Copy(tempFile, currentFileName, true);
File.Delete(tempFile);
}
catch (Exception e1)
{
MessageBox.Show("Save Failed because: " + e1.Message + "\r\n" + e1.InnerException.Message);
if (File.Exists(tempFile))
{
file.Close();
File.Delete(tempFile);
}
}
//restore unused neurons
for (int i = 0; i < theNeuronArray.arraySize; i++)
{
if (theNeuronArray.GetNeuron(i) == null)
{
theNeuronArray.SetNeuron(i, new Neuron(i));
}
}
ResumeEngine();
}
public static bool Load(ref NeuronArray theNeuronArray, string fileName)
{
FileStream file = File.Open(fileName, FileMode.Open);
XmlSerializer reader1 = new XmlSerializer(typeof(NeuronArray), GetModuleTypes());
theNeuronArray = (NeuronArray)reader1.Deserialize(file);
file.Close();
//the above automatically loads the content of the neuronArray object but can't load the neurons themselves
//because of formatting changes
XmlDocument xmldoc = new XmlDocument();
XmlNodeList neuronNodes;
FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
xmldoc.Load(fs);
fs.Close();
int arraySize = theNeuronArray.arraySize;
theNeuronArray.Initialize(arraySize);
neuronNodes = xmldoc.GetElementsByTagName("Neuron");
for (int i = 0; i < neuronNodes.Count; i++)
{
XmlElement neuronNode = (XmlElement)neuronNodes[i];
XmlNodeList idNodes = neuronNode.GetElementsByTagName("Id");
if (idNodes.Count < 1)
{
continue;
}
int id = -1;
int.TryParse(idNodes[0].InnerText, out id);
if (id == -1)
{
continue;
}
Neuron n = theNeuronArray.GetNeuron(id);
n.Owner = theNeuronArray;
n.id = id;
foreach (XmlElement node in neuronNode.ChildNodes)
{
string name = node.Name;
switch (name)
{
case "Label":
n.label = node.InnerText;
break;
case "Model":
Enum.TryParse(node.InnerText, out Neuron.modelType theModel);
n.model = theModel;
break;
case "LeakRate":
float.TryParse(node.InnerText, out float leakRate);
n.leakRate = leakRate;
break;
case "LastCharge":
float.TryParse(node.InnerText, out float lastCharge);
n.LastCharge = lastCharge;
n.currentCharge = lastCharge;
break;
case "Synapses":
theNeuronArray.SetCompleteNeuron(n);
XmlNodeList synapseNodess = node.GetElementsByTagName("Synapse");
foreach (XmlNode synapseNode in synapseNodess)
{
Synapse s = new Synapse();
foreach (XmlNode synapseAttribNode in synapseNode.ChildNodes)
{
string name1 = synapseAttribNode.Name;
switch (name1)
{
case "TargetNeuron":
int.TryParse(synapseAttribNode.InnerText, out int target);
s.targetNeuron = target;
break;
case "Weight":
float.TryParse(synapseAttribNode.InnerText, out float weight);
s.weight = weight;
break;
case "IsHebbian":
bool.TryParse(synapseAttribNode.InnerText, out bool isheb);
s.isHebbian = isheb;
break;
}
}
n.AddSynapse(s.targetNeuron, s.weight, s.isHebbian);
}
break;
}
}
theNeuronArray.SetCompleteNeuron(n);
}
return(true);
}
public void PasteNeurons()
{
NeuronArray myClipBoard = MainWindow.myClipBoard;
if (targetNeuronIndex == -1)
{
return;
}
if (myClipBoard == null)
{
return;
}
//We are pasting neurons from the clipboard.
//The arrays have different sizes so we may by row-col.
//first check to see if the destination is claar and warn
List <int> targetNeurons = new List <int>();
for (int i = 0; i < myClipBoard.arraySize; i++)
{
if (myClipBoard.GetNeuron(i, true) != null)
{
targetNeurons.Add(GetNeuronArrayId(i));
}
}
MainWindow.theNeuronArray.GetNeuronLocation(targetNeuronIndex, out int col, out int row);
if (col + myClipBoard.Cols > MainWindow.theNeuronArray.Cols ||
row + myClipBoard.rows > MainWindow.theNeuronArray.rows)
{
MessageBoxResult result = MessageBox.Show("Paste would exceed neuron array boundary!", "Error", MessageBoxButton.OK);
return;
}
if (!IsDestinationClear(targetNeurons, 0, true))
{
MessageBoxResult result = MessageBox.Show("Some desination neurons are in use and will be overwritten, continue?", "Continue", MessageBoxButton.YesNo);
if (result == MessageBoxResult.No)
{
return;
}
}
MainWindow.theNeuronArray.SetUndoPoint();
//now paste the neurons
for (int i = 0; i < myClipBoard.arraySize; i++)
{
if (myClipBoard.GetNeuron(i) != null)
{
int destID = GetNeuronArrayId(i);
MainWindow.theNeuronArray.GetNeuron(destID).AddUndoInfo();
Neuron n = myClipBoard.GetCompleteNeuron(i, true);
n.Owner = myClipBoard;
n.synapses = myClipBoard.GetSynapsesList(i);
Neuron sourceNeuron = n.Clone();
sourceNeuron.id = destID;
while (sourceNeuron.label != "" && MainWindow.theNeuronArray.GetNeuron(sourceNeuron.label) != null)
{
int num = 0;
int digitCount = 0;
while (sourceNeuron.label != "" && Char.IsDigit(sourceNeuron.label[sourceNeuron.label.Length - 1]))
{
int.TryParse(sourceNeuron.label[sourceNeuron.label.Length - 1].ToString(), out int digit);
num = num + (int)Math.Pow(10, digitCount) * digit;
digitCount++;
sourceNeuron.label = sourceNeuron.label.Substring(0, sourceNeuron.label.Length - 1);
}
num++;
sourceNeuron.label = sourceNeuron.label + num.ToString();
}
sourceNeuron.Owner = MainWindow.theNeuronArray;
sourceNeuron.Label = sourceNeuron.label;
MainWindow.theNeuronArray.SetNeuron(destID, sourceNeuron);
foreach (Synapse s in n.Synapses)
{
MainWindow.theNeuronArray.GetNeuron(destID).
AddSynapseWithUndo(GetNeuronArrayId(s.TargetNeuron), s.Weight, s.model);
}
}
}
//handle boundary synapses
foreach (BoundarySynapse b in boundarySynapsesOut)
{
int sourceID = GetNeuronArrayId(b.innerNeuronID);
Neuron targetNeuron = MainWindow.theNeuronArray.GetNeuron(b.outerNeuronID);
if (targetNeuron != null)
{
MainWindow.theNeuronArray.GetNeuron(sourceID).AddSynapseWithUndo(targetNeuron.id, b.weight, b.model);
}
}
foreach (BoundarySynapse b in boundarySynapsesIn)
{
int targetID = GetNeuronArrayId(b.innerNeuronID);
Neuron sourceNeuron = MainWindow.theNeuronArray.GetNeuron(b.outerNeuronID);
if (sourceNeuron != null)
{
sourceNeuron.AddSynapseWithUndo(targetID, b.weight, b.model);
}
}
//paste modules
foreach (ModuleView mv in myClipBoard.modules)
{
ModuleView newMV = new ModuleView()
{
FirstNeuron = GetNeuronArrayId(mv.FirstNeuron),
TheModule = mv.TheModule,
Color = mv.Color,
Height = mv.Height,
Width = mv.Width,
Label = mv.Label,
CommandLine = mv.CommandLine,
};
MainWindow.theNeuronArray.modules.Add(newMV);
}
Update();
}
private bool LoadFile(string fileName)
{
CloseAllModuleDialogs();
CloseHistoryWindow();
CloseNotesWindow();
theNeuronArrayView.theSelection.selectedRectangles.Clear();
CloseAllModuleDialogs();
SuspendEngine();
try
{
// Load the data from the XML to the Brainsim Engine.
FileStream file = File.Open(fileName, FileMode.Open);
XmlSerializer reader = new XmlSerializer(typeof(NeuronArray), GetModuleTypes());
theNeuronArray = (NeuronArray)reader.Deserialize(file);
file.Close();
}
catch (Exception e1)
{
if (e1.InnerException != null)
{
MessageBox.Show("File Load failed because:\r\n " + e1.Message + "\r\nAnd:\r\n" + e1.InnerException.Message);
}
else
{
MessageBox.Show("File Load failed because:\r\n " + e1.Message);
}
return(false);
}
for (int i = 0; i < theNeuronArray.arraySize; i++)
{
if (theNeuronArray.GetNeuron(i) == null)
{
theNeuronArray.SetNeuron(i, new Neuron(i));
}
if (theNeuronArray.GetNeuron(i).CurrentCharge > 0 || theNeuronArray.GetNeuron(i).LastCharge > 0)
{
theNeuronArray.AddToFiringQueue(theNeuronArray.GetNeuron(i).Id);
}
}
//Update all the synapses to ensure that the synapse-from lists are correct
foreach (Neuron n in theNeuronArray.Neurons())
{
if (n.SynapsesFrom != null)
{
n.SynapsesFrom.Clear();
}
}
foreach (Neuron n in theNeuronArray.Neurons())
{
if (n.Synapses != null)
{
foreach (Synapse s in n.Synapses)
{
n.AddSynapse(s.TargetNeuron, s.Weight, theNeuronArray, false);
s.N = theNeuronArray.GetNeuron(s.TargetNeuron);
}
}
if (n.CurrentCharge >= 1 || n.LastCharge >= 1 || n.Model == Neuron.modelType.LIF)
{
theNeuronArray.AddToFiringQueue(n.Id);
}
}
theNeuronArray.CheckSynapseArray();
theNeuronArrayView.Update();
setTitleBar();
Task.Delay(1000).ContinueWith(t => ShowDialogs());
foreach (ModuleView na in theNeuronArray.modules)
{
if (na.TheModule != null)
{
na.TheModule.SetUpAfterLoad();
}
}
if (theNeuronArray.displayParams != null)
{
theNeuronArrayView.Dp = theNeuronArray.displayParams;
}
NeuronArrayView.SortAreas();
Update();
SetShowSynapsesCheckBox(theNeuronArray.ShowSynapses);
OpenHistoryWindow();
ResumeEngine();
return(true);
}
//copy the selection to a clipboard
public void CopyNeurons()
{
//get list of neurons to copy
List <int> neuronsToCopy = theSelection.EnumSelectedNeurons();
theSelection.GetSelectedBoundingRectangle(out int X1o, out int Y1o, out int X2o, out int Y2o);
myClipBoard = new NeuronArray();
myClipBoard.Initialize((X2o - X1o + 1) * (Y2o - Y1o + 1), (Y2o - Y1o + 1));
//by setting neurons to null, we can handle odd-shaped selections
for (int i = 0; i < myClipBoard.arraySize; i++)
{
myClipBoard.SetNeuron(i, null);
}
//copy the neurons
foreach (int nID in neuronsToCopy)
{
int destId = GetClipboardId(X1o, Y1o, nID);
//copy the source neuron to the clipboard
Neuron sourceNeuron = MainWindow.theNeuronArray.GetNeuron(nID);
Neuron destNeuron = sourceNeuron.Clone();
destNeuron.Id = destId;
myClipBoard.SetNeuron(destId, destNeuron);
}
//copy the synapses (this is two-pass so we make sure all neurons exist prior to copying
foreach (int nID in neuronsToCopy)
{
Neuron sourceNeuron = MainWindow.theNeuronArray.GetNeuron(nID);
int destId = GetClipboardId(X1o, Y1o, nID);
Neuron destNeuron = myClipBoard.GetNeuron(destId);
if (sourceNeuron.synapses != null)
{
foreach (Synapse s in sourceNeuron.synapses)
{
//only copy synapses with both ends in the selection
if (neuronsToCopy.Contains(s.TargetNeuron))
{
destNeuron.AddSynapse(GetClipboardId(X1o, Y1o, s.TargetNeuron), s.Weight);
}
}
}
}
//copy modules
foreach (ModuleView mv in MainWindow.theNeuronArray.modules)
{
if (theSelection.NeuronInSelection(mv.FirstNeuron) > 0 && theSelection.NeuronInSelection(mv.LastNeuron) > 0)
{
ModuleView newMV = new ModuleView()
{
FirstNeuron = GetClipboardId(X1o, Y1o, mv.FirstNeuron),
TheModule = mv.TheModule,
Color = mv.Color,
Height = mv.Height,
Width = mv.Width,
Label = mv.Label,
CommandLine = mv.CommandLine,
};
myClipBoard.modules.Add(newMV);
}
}
}
public static bool Load(ref NeuronArray theNeuronArray, string fileName)
{
FileStream file;
try
{
file = File.Open(fileName, FileMode.Open, FileAccess.Read);
}
catch (Exception e)
{
MessageBox.Show("Could not open file because: " + e.Message);
RemoveFileFromMRUList(fileName);
return(false);
}
// first check if the required start tag is present in the file...
byte[] buffer = new byte[60];
file.Read(buffer, 0, 60);
string line = Encoding.UTF8.GetString(buffer, 0, buffer.Length);
if (line.Contains("NeuronArray"))
{
file.Seek(0, SeekOrigin.Begin);
}
else
{
file.Close();
MessageBox.Show("File is no valid Brain Simulator II XML file.");
return(false);
}
MainWindow.thisWindow.SetProgress(0, "Loading Network File");
theNeuronArray = new NeuronArray();
XmlSerializer reader1 = new XmlSerializer(typeof(NeuronArray), GetModuleTypes());
theNeuronArray = (NeuronArray)reader1.Deserialize(file);
file.Close();
//the above automatically loads the content of the neuronArray object but can't load the neurons themselves
//because of formatting changes
XmlDocument xmldoc = new XmlDocument();
XmlNodeList neuronNodes;
FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
xmldoc.Load(fs);
fs.Close();
int arraySize = theNeuronArray.arraySize;
theNeuronArray.Initialize(arraySize, theNeuronArray.rows);
neuronNodes = xmldoc.GetElementsByTagName("Neuron");
for (int i = 0; i < neuronNodes.Count; i++)
{
var progress = i / (float)neuronNodes.Count;
progress *= 100;
if (progress != 0 && MainWindow.thisWindow.SetProgress(progress, ""))
{
MainWindow.thisWindow.SetProgress(100, "");
return(false);
}
XmlElement neuronNode = (XmlElement)neuronNodes[i];
XmlNodeList idNodes = neuronNode.GetElementsByTagName("Id");
int id = i; //this is a hack to read files where all neurons were included but no Id's
if (idNodes.Count > 0)
{
int.TryParse(idNodes[0].InnerText, out id);
}
if (id == -1)
{
continue;
}
Neuron n = theNeuronArray.GetNeuron(id);
n.Owner = theNeuronArray;
n.id = id;
foreach (XmlElement node in neuronNode.ChildNodes)
{
string name = node.Name;
switch (name)
{
case "Label":
n.Label = node.InnerText;
break;
case "Model":
Enum.TryParse(node.InnerText, out Neuron.modelType theModel);
n.model = theModel;
break;
case "LeakRate":
float.TryParse(node.InnerText, out float leakRate);
n.leakRate = leakRate;
break;
case "AxonDelay":
int.TryParse(node.InnerText, out int axonDelay);
n.axonDelay = axonDelay;
break;
case "LastCharge":
if (n.model != Neuron.modelType.Color)
{
float.TryParse(node.InnerText, out float lastCharge);
n.LastCharge = lastCharge;
n.currentCharge = lastCharge;
}
else //is color
{
int.TryParse(node.InnerText, out int lastChargeInt);
n.LastChargeInt = lastChargeInt;
n.currentCharge = lastChargeInt; //current charge is not used on color neurons
}
break;
case "ShowSynapses":
bool.TryParse(node.InnerText, out bool showSynapses);
if (showSynapses)
{
MainWindow.arrayView.AddShowSynapses(n.id);
}
break;
case "Synapses":
theNeuronArray.SetCompleteNeuron(n);
XmlNodeList synapseNodess = node.GetElementsByTagName("Synapse");
foreach (XmlNode synapseNode in synapseNodess)
{
Synapse s = new Synapse();
foreach (XmlNode synapseAttribNode in synapseNode.ChildNodes)
{
string name1 = synapseAttribNode.Name;
switch (name1)
{
case "TargetNeuron":
int.TryParse(synapseAttribNode.InnerText, out int target);
s.targetNeuron = target;
break;
case "Weight":
float.TryParse(synapseAttribNode.InnerText, out float weight);
s.weight = weight;
break;
case "IsHebbian": //Obsolete: backwards compatibility
bool.TryParse(synapseAttribNode.InnerText, out bool isheb);
if (isheb)
{
s.model = Synapse.modelType.Hebbian1;
}
else
{
s.model = Synapse.modelType.Fixed;
}
break;
case "Model":
Enum.TryParse(synapseAttribNode.InnerText, out Synapse.modelType model);
s.model = model;
break;
}
}
n.AddSynapse(s.targetNeuron, s.weight, s.model);
}
break;
}
}
theNeuronArray.SetCompleteNeuron(n);
}
MainWindow.thisWindow.SetProgress(100, "");
return(true);
}
public static bool Load(ref NeuronArray theNeuronArray, string fileName)
{
FileStream file = File.Open(fileName, FileMode.Open);
XmlSerializer reader1 = new XmlSerializer(typeof(NeuronArray), GetModuleTypes());
theNeuronArray = (NeuronArray)reader1.Deserialize(file);
file.Close();
//the above automatically loads the content of the neuronArray object but can't load the neurons themselves
//because of formatting changes
XmlDocument xmldoc = new XmlDocument();
XmlNodeList neuronNodes;
FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
xmldoc.Load(fs);
fs.Close();
int arraySize = theNeuronArray.arraySize;
theNeuronArray.Initialize(arraySize);
neuronNodes = xmldoc.GetElementsByTagName("Neuron");
for (int i = 0; i < neuronNodes.Count; i++)
{
var progress = i / (float)neuronNodes.Count;
if (i % 1000 == 0)
{
MainWindow.thisWindow.SetProgress(progress);
}
XmlElement neuronNode = (XmlElement)neuronNodes[i];
XmlNodeList idNodes = neuronNode.GetElementsByTagName("Id");
int id = i; //this is a hack to read files where all neurons were included but no Id's
if (idNodes.Count > 0)
{
int.TryParse(idNodes[0].InnerText, out id);
}
if (id == -1)
{
continue;
}
Neuron n = theNeuronArray.GetNeuron(id);
n.Owner = theNeuronArray;
n.id = id;
foreach (XmlElement node in neuronNode.ChildNodes)
{
string name = node.Name;
switch (name)
{
case "Label":
n.Label = node.InnerText;
break;
case "Model":
Enum.TryParse(node.InnerText, out Neuron.modelType theModel);
n.model = theModel;
break;
case "LeakRate":
float.TryParse(node.InnerText, out float leakRate);
n.leakRate = leakRate;
break;
case "AxonDelay":
int.TryParse(node.InnerText, out int axonDelay);
n.axonDelay = axonDelay;
break;
case "LastCharge":
if (n.model != Neuron.modelType.Color)
{
float.TryParse(node.InnerText, out float lastCharge);
n.LastCharge = lastCharge;
n.currentCharge = lastCharge;
}
else //is color
{
int.TryParse(node.InnerText, out int lastChargeInt);
n.LastChargeInt = lastChargeInt;
n.currentCharge = lastChargeInt; //current charge is not used on color neurons
}
break;
case "ShowSynapses":
bool.TryParse(node.InnerText, out bool showSynapses);
if (showSynapses)
{
MainWindow.arrayView.AddShowSynapses(n.id);
}
break;
case "Synapses":
theNeuronArray.SetCompleteNeuron(n);
XmlNodeList synapseNodess = node.GetElementsByTagName("Synapse");
foreach (XmlNode synapseNode in synapseNodess)
{
Synapse s = new Synapse();
foreach (XmlNode synapseAttribNode in synapseNode.ChildNodes)
{
string name1 = synapseAttribNode.Name;
switch (name1)
{
case "TargetNeuron":
int.TryParse(synapseAttribNode.InnerText, out int target);
s.targetNeuron = target;
break;
case "Weight":
float.TryParse(synapseAttribNode.InnerText, out float weight);
s.weight = weight;
break;
case "IsHebbian": //Obsolete: backwards compatibility
bool.TryParse(synapseAttribNode.InnerText, out bool isheb);
if (isheb)
{
s.model = Synapse.modelType.Hebbian1;
}
else
{
s.model = Synapse.modelType.Fixed;
}
break;
case "Model":
Enum.TryParse(synapseAttribNode.InnerText, out Synapse.modelType model);
s.model = model;
break;
}
}
n.AddSynapse(s.targetNeuron, s.weight, s.model);
}
break;
}
}
theNeuronArray.SetCompleteNeuron(n);
}
MainWindow.thisWindow.SetProgress(-1);
return(true);
}
