/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="DA">The DA object is used to retrieve from inputs and store in outputs.</param>
protected override void SolveInstance(IGH_DataAccess DA)
{
CrowNetSOMNDP net = new CrowNetSOMNDP();
xyzD = new List <int>();
topD = new List <int>();
double relativeIndex = 0.0;
DA.GetData(0, ref net);
if (!DA.GetDataList(1, xyzD))
{
xyzD = new List <int> {
0, 1, 2
}
}
;
if (!DA.GetDataList(2, topD))
{
topD = new List <int> {
0, 1, 2
}
}
;
if (!DA.GetData(3, ref relativeIndex))
{
relativeIndex = 0.0;
}
List <Point3d> pts = new List <Point3d>();
if (net.trainedVectors.GetLength(0) > 0)
{
int[][] newAdressBook = net.adressBook;
// in case network topology is one-dimensional, add two zeros to the end of each adress book entry
if (newAdressBook[0].Length == 1)
{
for (int i = 0; i < newAdressBook.GetLength(0); i++)
{
List <int> curr = new List <int> {
newAdressBook[i][0], 0, 0
};
newAdressBook[i] = curr.ToArray();
}
}
// in case network topology is two-dimensional, add a zero to the end of each adress book entry
else if (newAdressBook[0].Length == 2)
{
for (int i = 0; i < newAdressBook.GetLength(0); i++)
{
List <int> curr = new List <int> {
newAdressBook[i][0], newAdressBook[i][1], 0
};
newAdressBook[i] = curr.ToArray();
}
}
// create point tree structure
GH_Structure <GH_Point> pointTree = net.PointTree(xyzD);
//draw polylines
List <Polyline> _1st = new List <Polyline>();
List <Polyline> _2nd = new List <Polyline>();
List <Polyline> _3rd = new List <Polyline>();
int[] newSize = net.size;
if (net.size.Length == 1)
{
newSize = new int[3] {
net.size[0], 1, 1
}
}
;
if (net.size.Length == 2)
{
newSize = new int[3] {
net.size[0], net.size[1], 1
}
}
;
for (int i = 0; i < newSize[topD[1]]; i++)
{
for (int j = 0; j < newSize[topD[2]]; j++)
{
List <Point3d> p1 = new List <Point3d>();
for (int k = 0; k < newSize[topD[0]]; k++)
{
GH_Path newPath = AddZerosToPath(new GH_Path(k, i, j), topD.ToArray(), newSize.Length, relativeIndex, newSize);
p1.Add(pointTree.get_DataItem(newPath, 0).Value);
}
_1st.Add(new Polyline(p1));
}
}
for (int i = 0; i < newSize[topD[2]]; i++)
{
for (int j = 0; j < newSize[topD[0]]; j++)
{
List <Point3d> p1 = new List <Point3d>();
for (int k = 0; k < newSize[topD[1]]; k++)
{
GH_Path newPath = AddZerosToPath(new GH_Path(j, k, i), topD.ToArray(), newSize.Length, relativeIndex, newSize);
p1.Add(pointTree.get_DataItem(newPath, 0).Value);
}
_2nd.Add(new Polyline(p1));
}
}
for (int i = 0; i < newSize[topD[0]]; i++)
{
for (int j = 0; j < newSize[topD[1]]; j++)
{
List <Point3d> p1 = new List <Point3d>();
for (int k = 0; k < newSize[topD[2]]; k++)
{
GH_Path newPath = AddZerosToPath(new GH_Path(i, j, k), topD.ToArray(), newSize.Length, relativeIndex, newSize);
p1.Add(pointTree.get_DataItem(newPath, 0).Value);
}
_3rd.Add(new Polyline(p1));
}
}
DA.SetDataList(0, _1st);
DA.SetDataList(1, _2nd);
DA.SetDataList(2, _3rd);
}
}
void Solve()
{
#region prepare and assign
trainingSet.Clear();
for (int i = 0; i < trainVectorCount; i++)
{
List <double> dl = new List <double>();
for (int j = 0; j < trainVectorDimension; j++)
{
dl.Add(trainVectors[i][j]);
}
trainingSet.Add(new TrainingSample(dl.ToArray()));
}
/// process
/// start learning
/// get learning radius for neighborhood function
int learningRadius = 0;
for (int i = 0; i < dimension; i++)
{
if (size[i] > learningRadius)
{
learningRadius = size[i];
}
}
learningRadius /= 2;
INeighborhoodFunction neighborhoodFunction = new GaussianFunction(learningRadius, netUP.neighborDistance) as INeighborhoodFunction;
if (neighborhood)
{
neighborhoodFunction = new MexicanHatFunction(learningRadius) as INeighborhoodFunction;
}
LatticeTopology topology = LatticeTopology.Rectangular;
if (latticeTopology)
{
topology = LatticeTopology.Hexagonal;
}
/// instantiate relevant network layers
KohonenLayer inputLayer = new KohonenLayer(trainVectorDimension);
KohonenLayerND outputLayer = new KohonenLayerND(size, neighborhoodFunction, topology);
KohonenConnectorND connector = new KohonenConnectorND(inputLayer, outputLayer, netUP.initialNodes);
if (netUP.initialNodes.Length != 0)
{
connector.Initializer = new GivenInput(netUP.initialNodes);
}
else
{
connector.Initializer = new RandomFunction(0.0, 1.0);
}
outputLayer.SetLearningRate(learningRate, 0.05d);
outputLayer.IsDimensionCircular = isDimensionCircular;
network = new KohonenNetworkND(inputLayer, outputLayer);
network.useRandomTrainingOrder = randomTrainingOrder;
inputLayer.ParallelComputation = false;
outputLayer.ParallelComputation = parallelComputing;
#endregion
#region delegates
network.BeginEpochEvent += new TrainingEpochEventHandler(
delegate(object senderNetwork, TrainingEpochEventArgs args)
{
#region trainingCylce
if (network == null || !GO)
{
return;
}
trainedVectors = new double[outputLayer.neuronCount, trainVectorDimension];
for (int i = 0; i < outputLayer.neuronCount; i++)
{
IList <ISynapse> synapses = (network.OutputLayer as KohonenLayerND)[outputLayer.adressBook[i]].SourceSynapses;
for (int j = 0; j < trainVectorDimension; j++)
{
trainedVectors[i, j] = synapses[j].Weight;
}
}
//make new net here
netP = new CrowNetSOMNDP(size, isDimensionCircular, latticeTopology, neighborhood, trainedVectors, outputLayer.adressBook);
counter++;
#endregion
});
network.EndSampleEvent += new TrainingSampleEventHandler(
delegate(object senderNetwork, TrainingSampleEventArgs args)
{
netP.winner = outputLayer.WinnerND.CoordinateND;
});
#endregion
network.Learn(trainingSet, cycles);
}
