private void GenerateAxons()
{
// Generate bezier points that approximate the paths between neurons
foreach (var neuron in _slider.Where(n => n.Terminal != null))
{
var firstPoint = neuron.Nucleus.Pos;
var lastPoint = neuron.Terminal.Nucleus.Pos;
var middlePoint = PositionAt((neuron.Nucleus.PathPosition + neuron.Terminal.Nucleus.PathPosition) / 2);
var flatness = new BezierSubdivision(new List <Vector2> {
firstPoint, middlePoint, lastPoint
}).Flatness();
double length = Vector2.Distance(firstPoint, lastPoint);
if (flatness < 0.1 || length < 8)
{
neuron.Axon = new BezierSubdivision(new List <Vector2> {
firstPoint, lastPoint
});
}
else
{
neuron.Axon = DoubleMiddleApproximation(neuron, middlePoint, out length);
}
// Calculate lengths
neuron.AxonLenth = length;
neuron.DendriteLength = neuron.WantedLength - neuron.AxonLenth;
}
}
private BezierSubdivision TangentIntersectionApproximation(Neuron neuron, out double length)
{
var firstPoint = neuron.Nucleus.Pos;
var lastPoint = neuron.Terminal.Nucleus.Pos;
var dir = Math.Sign(neuron.Terminal.Nucleus.SegmentIndex - neuron.Nucleus.SegmentIndex);
var line1 = Line2.FromPoints(neuron.Nucleus.PathPoint, _path[neuron.Nucleus.SegmentIndex + dir]);
var line2 = Line2.FromPoints(neuron.Terminal.Nucleus.PathPoint, _path[neuron.Terminal.Nucleus.SegmentIndex - dir]);
BezierSubdivision bs;
if (Line2.Intersection(line1, line2, out var intersection))
{
bs = new BezierSubdivision(new List <Vector2> {
firstPoint, intersection, lastPoint
});
length = bs.SubdividedApproximationLength();
}
else
{
bs = new BezierSubdivision(new List <Vector2> {
firstPoint, lastPoint
});
length = Vector2.Distance(firstPoint, lastPoint);
}
return(bs);
}
public void Test3()
{
List <Vector2> points = new List <Vector2> {
new Vector2(0, 0), new Vector2(4, 6), new Vector2(2, 1)
};
BezierSubdivision subdivision = new BezierSubdivision(points);
Assert.AreEqual(0.1608, subdivision.LengthToT(2), 0.01);
Assert.AreEqual(0.4568, subdivision.LengthToT(4), 0.01);
Assert.AreEqual(1.1077, subdivision.LengthToT(8), 0.01);
Assert.AreEqual(2.0559, subdivision.LengthToT(32), 0.01);
}
public void Test4()
{
List <Vector2> points = new List <Vector2> {
new Vector2(0, 0), new Vector2(100, 100), new Vector2(200, 0)
};
BezierSubdivision subdivision = new BezierSubdivision(points);
var length = new SliderPath(PathType.Bezier, points.ToArray()).Distance;
var length2 = subdivision.SubdividedApproximationLength(0.25);
Assert.AreEqual(length, length2, 0.001);
Assert.AreEqual(0.5, subdivision.LengthToT(length / 2), 0.01);
Assert.AreEqual(1, subdivision.LengthToT(length), 0.01);
Assert.AreEqual(0, subdivision.LengthToT(0), 0.01);
}
public Neuron(LatticePoint startLatticePoint, double time)
{
Nucleus = startLatticePoint;
Dendrites = new List <Vector2>();
Axon = new BezierSubdivision(new List <Vector2> {
startLatticePoint.Pos
});
Terminal = null;
Length = 0;
Error = 0;
WantedLength = 0;
DendriteLength = 0;
AxonLenth = 0;
Time = time;
}
public void Test2()
{
List <Vector2> points = new List <Vector2> {
new Vector2(0, 0), new Vector2(1, 2), new Vector2(2, 0)
};
BezierSubdivision subdivision = new BezierSubdivision(points);
List <Vector2> points2 = new List <Vector2> {
new Vector2(2, 0), new Vector2(4, 1), new Vector2(2, 6), new Vector2(1, 2)
};
BezierSubdivision subdivision2 = new BezierSubdivision(points2, 0, 1);
LinkedList <BezierSubdivision> slider = new LinkedList <BezierSubdivision>();
slider.AddLast(subdivision);
slider.AddLast(subdivision2);
BezierSubdivision.Subdivide(ref slider);
var current = slider.First;
Assert.AreEqual(0, (current.Value.Points[0] - new Vector2(0, 0)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[1] - new Vector2(0.25, 0.5)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[2] - new Vector2(0.5, 0.75)).Length, 0.001);
current = current.Next;
Assert.IsNotNull(current);
Assert.AreEqual(0, (current.Value.Points[0] - new Vector2(0.5, 0.75)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[1] - new Vector2(0.75, 1)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[2] - new Vector2(1, 1)).Length, 0.001);
current = current.Next;
Assert.IsNotNull(current);
Assert.AreEqual(0, (current.Value.Points[0] - new Vector2(1, 1)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[1] - new Vector2(1.25, 1)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[2] - new Vector2(1.5, 0.75)).Length, 0.001);
current = current.Next;
Assert.IsNotNull(current);
Assert.AreEqual(0, (current.Value.Points[0] - new Vector2(1.5, 0.75)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[1] - new Vector2(1.75, 0.5)).Length, 0.001);
Assert.AreEqual(0, (current.Value.Points[2] - new Vector2(2, 0)).Length, 0.001);
current = current.Next;
Assert.IsNotNull(current);
subdivision2 = current.Value;
for (int i = subdivision2.Level; i > 0; i--)
{
subdivision2 = subdivision2.Parent();
}
Assert.AreEqual(0, (subdivision2.Points[0] - new Vector2(2, 0)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[1] - new Vector2(4, 1)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[2] - new Vector2(2, 6)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[3] - new Vector2(1, 2)).Length, 0.001);
}
private static BezierSubdivision DoubleMiddleApproximation(Neuron neuron, Vector2 middlePoint, out double length)
{
var firstPoint = neuron.Nucleus.Pos;
var lastPoint = neuron.Terminal.Nucleus.Pos;
var average = (firstPoint + lastPoint) / 2;
var doubleMiddlePoint = average + (middlePoint - average) * 2;
var bs = new BezierSubdivision(new List <Vector2> {
firstPoint, doubleMiddlePoint, lastPoint
});
length = bs.SubdividedApproximationLength();
return(bs);
}
public void Test1()
{
List <Vector2> points = new List <Vector2> {
new Vector2(0, 0), new Vector2(1, 1), new Vector2(2, 0)
};
BezierSubdivision subdivision = new BezierSubdivision(points);
Assert.AreEqual(1, subdivision.Flatness(), 0.001);
subdivision.ScaleLeft(0.5);
Assert.AreEqual(0, (subdivision.Points[0] - new Vector2(1, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[1] - new Vector2(1.5, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[2] - new Vector2(2, 0)).Length, 0.001);
subdivision.ScaleRight(-1);
Assert.AreEqual(0, (subdivision.Points[0] - new Vector2(1, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[1] - new Vector2(0.5, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[2] - new Vector2(0, 0)).Length, 0.001);
Assert.AreEqual(0.25, subdivision.Flatness(), 0.001);
Assert.AreEqual(1.207106, subdivision.Length(), 0.001);
var subdivision2 = subdivision.Prev();
Assert.AreEqual(0, (subdivision2.Points[0] - new Vector2(2, 0)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[1] - new Vector2(1.5, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[2] - new Vector2(1, 0.5)).Length, 0.001);
subdivision.Reverse();
subdivision2 = subdivision.Next();
Assert.AreEqual(0, (subdivision2.Points[0] - new Vector2(1, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[1] - new Vector2(1.5, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[2] - new Vector2(2, 0)).Length, 0.001);
subdivision2 = subdivision.Parent();
Assert.AreEqual(0, (subdivision2.Points[0] - new Vector2(0, 0)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[1] - new Vector2(1, 1)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[2] - new Vector2(2, 0)).Length, 0.001);
subdivision2.Children(out subdivision, out subdivision2);
Assert.AreEqual(0, (subdivision.Points[0] - new Vector2(0, 0)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[1] - new Vector2(0.5, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[2] - new Vector2(1, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[0] - new Vector2(1, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[1] - new Vector2(1.5, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision2.Points[2] - new Vector2(2, 0)).Length, 0.001);
subdivision.Increase();
Assert.AreEqual(0, (subdivision.Points[0] - new Vector2(0, 0)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[1] - new Vector2(0.33333, 0.33333)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[2] - new Vector2(0.66667, 0.5)).Length, 0.001);
Assert.AreEqual(0, (subdivision.Points[3] - new Vector2(1, 0.5)).Length, 0.001);
}
public static double CalculatePathLength(List <Vector2> anchors)
{
double length = 0;
int start = 0;
int end = 0;
for (int i = 0; i < anchors.Length(); ++i)
{
end++;
if (i == anchors.Length() - 1 || anchors[i] == anchors[i + 1])
{
List <Vector2> cpSpan = anchors.GetRange(start, end - start);
length += new BezierSubdivision(cpSpan).SubdividedApproximationLength();
start = end;
}
}
return(length);
}
