public float[] GetOutput(float[] inputs)
{
float[] outputLayer1 = Numpy.forward(inputs, weightsLayer1, biasesLayer1);
float[] outputLayer2 = Numpy.forward(outputLayer1, weightsLayer2, biasesLayer2);
float[] output = Numpy.dot(outputLayer2, outputWeights);
return(output);
}
private static IEnumerable <Line> OctoSphereStartOLD(double alpha, int xLimit, int yLimit)
{
var origin = new Vector3D(0, 0, 0);
var planePoint = new Vector3D(1, 1, 0);
var pointA = new Vector3D(2, 0, 0);
var pointB = new Vector3D(0, 2, 0);
var distanceFromOriginAtTheBase = Vector3D.AbsoluteValue(planePoint - origin);
var distanceFromOriginAtTheBaseOnTheXAxis = distanceFromOriginAtTheBase / Sin(45.0.ToRadian());
var pointOnXAxisOnTheBase = new Vector3D(distanceFromOriginAtTheBaseOnTheXAxis, 0.0, 0.0);
var horizontalDistanceAtTop = Sqrt(8);
var halfDistanceAtTop = horizontalDistanceAtTop / 2;
var horizontalDirection = (planePoint - pointOnXAxisOnTheBase).Normalize();
var halfPoint = (0, 0, 2);
var verticalDistance = Vector3D.AbsoluteValue(planePoint - halfPoint);
var verticalDirection = (planePoint - halfPoint).Normalize();
var horizontalJumps = Numpy.LinSpace(0, horizontalDistanceAtTop, xLimit).ToList();
var verticalJumps = Numpy.LinSpace(0, verticalDistance, yLimit).ToList();
var midPoint = (pointA + (horizontalJumps[xLimit / 2] * horizontalDirection)) + (verticalJumps[yLimit / 2] * verticalDirection);
var mainDirection = origin - midPoint;
foreach (var horizontalJump in horizontalJumps)
{
var point = pointA + (horizontalJump * horizontalDirection);
foreach (var verticalJump in verticalJumps)
{
var finalPoint = point + (verticalJump * verticalDirection);
var direction = RotateVector3D(mainDirection.X, mainDirection.Y, mainDirection.Z, alpha.ToRadian());
yield return(Line.FromPointAndDirection(finalPoint, direction));
}
}
}
private static IEnumerable <Line> CreateCylinderStartLines2(double alpha, int zLimit, int yLimit)
{
var b = Sqrt(8) / 2;
var alpha2 = 90 - alpha;
var beta = 180 - 45 - alpha2;
var a = 2 - Sin(alpha2.ToRadian()) / Sin(beta.ToRadian()) * b;
var r = CausticCylinder.R;
var verticalLine = new Line((0, 0, -r), (-r, 0, 0));
var distance = Vector3D.AbsoluteValue(verticalLine.SecondPoint - verticalLine.BasePoint);
var midpoint = verticalLine.GetPointOnLine(distance / 2);
var(xDir, yDir, zDir) = (-1, 0, -1 + a) - midpoint;
var zRange = Numpy.LinSpace(0, distance, zLimit).ToList();
var yRange = Numpy.LinSpace(0, CausticCylinder.L, yLimit).ToList();
foreach (var z in zRange)
{
foreach (var y in yRange)
{
var(x, y2, z2) = verticalLine.GetPointOnLine(z);
yield return(Line.FromPointAndDirection((x, y, z2), (xDir, yDir, zDir)));
}
}
}
private static IEnumerable <Line> OctoSphereStart(double alpha, int xLimit, int yLimit)
{
var xPoint = new Vector3D(2, 0, 0);
var yPoint = new Vector3D(0, 2, 0);
var topPoint = new Vector3D(0, 0, 2);
var distance = Vector3D.AbsoluteValue(yPoint - xPoint);
var bottomLine = new Line(xPoint, yPoint);
var bottomPoint = bottomLine.GetPointOnLine(distance / 2);
var verticalDistance = Vector3D.AbsoluteValue(bottomPoint - topPoint);
var horizontalDirection = (yPoint - xPoint).Normalize();
var verticalDirection = (topPoint - bottomPoint).Normalize();
var mainDirection = -1 * (new Plane(xPoint, yPoint, topPoint).NormalVector);
var horizontalJumps = Numpy.LinSpace(0, distance, xLimit);
var verticalJumps = Numpy.LinSpace(0, verticalDistance, yLimit);
foreach (var horizontalJump in horizontalJumps)
{
var horiPoint = xPoint + (horizontalJump * horizontalDirection);
foreach (var verticalJump in verticalJumps)
{
var finalPoint = horiPoint + (verticalJump * verticalDirection);
var direction = RotateVector3D(mainDirection.X, mainDirection.Y, mainDirection.Z, alpha.ToRadian());
yield return(Line.FromPointAndDirection(finalPoint, direction));
}
}
}
public void Merge(Brain brain1, Brain brain2)
{
weightsLayer1 = Numpy.merge(brain1.weightsLayer1, brain2.weightsLayer1);
biasesLayer1 = Numpy.merge(brain1.biasesLayer1, brain2.biasesLayer1);
weightsLayer2 = Numpy.merge(brain1.weightsLayer2, brain2.weightsLayer2);
biasesLayer2 = Numpy.merge(brain1.biasesLayer2, brain2.biasesLayer2);
outputWeights = Numpy.merge(brain1.outputWeights, brain2.outputWeights);
}
public void Init()
{
weightsLayer1 = Numpy.rand(2, 20);
biasesLayer1 = Numpy.rand(20);
weightsLayer2 = Numpy.rand(20, 20);
biasesLayer2 = Numpy.rand(20);
outputWeights = Numpy.rand(20, 2);
}
public static void SetUp(string backend)
{
using (Py.GIL())
{
Numpy.Initialize();
Matplotlib.Initialize(backend);
//PythonEngine.Exec("import matplotlib;print(matplotlib.get_backend())");
Console.WriteLine(Matplotlib.get_backend());
}
}
private static IEnumerable <Line> OctoSphereTri()
{
const double alpha = 0.0;
var xPoint = new Vector3D(2, 0, 0);
var yPoint = new Vector3D(0, 2, 0);
var topPoint = new Vector3D(0, 0, 2);
var side1 = Vector3D.AbsoluteValue(yPoint - xPoint);
var side2 = Vector3D.AbsoluteValue(topPoint - xPoint);
var side3 = Vector3D.AbsoluteValue(topPoint - yPoint);
var bigT = Heron(side1, side2, side3);
var distance = Vector3D.AbsoluteValue(yPoint - xPoint);
var bottomLine = new Line(xPoint, yPoint);
var bottomPoint = bottomLine.GetPointOnLine(distance / 2);
var verticalDistance = Vector3D.AbsoluteValue(bottomPoint - topPoint);
var horizontalDirection = (yPoint - xPoint).Normalize();
var verticalDirection = (topPoint - bottomPoint).Normalize();
var mainDirection = -1 * (new Plane(xPoint, yPoint, topPoint).NormalVector);
var horizontalJumps = Numpy.LinSpace(0, distance, 500);
var verticalJumps = Numpy.LinSpace(0, verticalDistance, 500);
foreach (var horizontalJump in horizontalJumps)
{
var horiPoint = xPoint + (horizontalJump * horizontalDirection);
foreach (var verticalJump in verticalJumps)
{
var finalPoint = horiPoint + (verticalJump * verticalDirection);
var dist1 = Vector3D.AbsoluteValue(finalPoint - xPoint);
var dist2 = Vector3D.AbsoluteValue(finalPoint - yPoint);
var dist3 = Vector3D.AbsoluteValue(finalPoint - topPoint);
var T1 = Heron(side1, dist1, dist2);
var T2 = Heron(side2, dist1, dist3);
var T3 = Heron(side3, dist2, dist3);
var T = T1 + T2 + T3;
var difference = Abs(bigT - T);
if (difference >= 0e-5)
{
yield return(Line.GetInvalid());
}
else
{
var direction = RotateVector3D(mainDirection.X, mainDirection.Y, mainDirection.Z, alpha.ToRadian());
yield return(Line.FromPointAndDirection(finalPoint, direction));
}
}
}
}
public static byte[] SaveFigureToArray(PyObject fig, int dpi = 200, string format = "png")
{
if (fig.GetPythonType().Handle != PltFigureType)
{
throw new Exception("object is not a matplotlib Figure");
}
dynamic _np = np;
//buf = io.BytesIO()
dynamic buf = BytesIO.Invoke();
//fig.savefig(buf, dpi=__dpi__, format='png')
fig.InvokeMethod("savefig", new PyTuple(new PyObject[] { buf }), Py.kw("dpi", dpi, "format", format));
var buf_out = _np.array(buf.getbuffer(), Py.kw("dtype", Numpy.GetNumpyDataType(typeof(byte))));
var arr = Numpy.ToArray(buf_out);
return((byte[])arr);
}
public static void PlotInWindow()
{
byte[] plotdata;
using (Py.GIL())
{
var scope = Py.CreateScope();
var np = scope.Import("numpy", "np");
var plt = scope.Import("matplotlib.pylab", "plt");
var x = Numpy.NewArray(new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });
var y = np.sin(x);
scope.Set("x", x);
scope.Set("y", y);
scope.Exec(
"fig = plt.figure() \n" +
"plt.plot(x[1:], y[1:]) \n"
);
var fig = scope.Get("fig");
plotdata = Matplotlib.SaveFigureToArray(fig, 200, "png");
}
Stream stream = new MemoryStream(plotdata);
Thread th = new Thread(
() => {
BitmapImage bitmapImage = new BitmapImage();
bitmapImage.BeginInit();
bitmapImage.StreamSource = stream;
bitmapImage.EndInit();
var img1 = new System.Windows.Controls.Image();
img1.Source = bitmapImage;
Window window = new Window();
window.Content = img1;
window.ShowDialog();
mEvent.Set();
}
);
th.SetApartmentState(ApartmentState.STA);
th.Start();
mEvent.WaitOne();
}
private static IEnumerable <Line> CreateCylinderStartLines(double alpha, int zLimit, int yLimit, double quarter)
{
var inRadian = alpha.ToRadian();
var dz = Tan(inRadian);
var r = Sqrt(Pow(CausticCylinder.R, 2) - Pow(CausticCylinder.R / quarter, 2));
var zRange = Numpy.LinSpace(-r, r, zLimit).ToList();
var yRange = Numpy.LinSpace(0, CausticCylinder.L, yLimit).ToList();
foreach (var z in zRange)
{
foreach (var y in yRange)
{
if (Abs(Abs(z) - Abs(r)) <= 5e-5 || Abs(y) <= 5e-5 || Abs(y - CausticCylinder.L) <= 5e-5)
{
continue;
}
yield return(Line.FromPointAndDirection((-CausticCylinder.R / quarter, y, z), (-1, 0, dz)));
}
}
}
private static IEnumerable <Line> SphereStart(double alpha, int xLimit, int yLimit)
{
var inRadian = alpha.ToRadian();
var dx = Tan(inRadian);
var xRange = Numpy.LinSpace(-1, 1, xLimit).ToList();
var yRange = Numpy.LinSpace(-1, 1, yLimit).ToList();
foreach (var x in xRange)
{
foreach (var y in yRange)
{
if (x * x + y * y >= 1)
{
continue;
}
yield return(Line.FromPointAndDirection((x - dx, y, 2), (dx, 0, -1)));
}
}
}
public static void Plot()
{
using (Py.GIL())
{
dynamic plt = Py.Import("matplotlib.pylab");
dynamic np = Py.Import("numpy");
var x = Numpy.NewArray(new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });
var y = np.sin(x);
//plt.plot(x);
plt.figure();
//plt.scatter(x, y);
plt.show();
}
using (Py.GIL())
{
var scope = Py.CreateScope();
var np = scope.Import("numpy", "np");
var plt = scope.Import("matplotlib.pylab", "plt");
var x = Numpy.NewArray(new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 });
var y = np.sin(x);
scope.Set("x", x);
scope.Set("y", y);
//directly plot
plt.plot(x, y);
plt.show();
//use python slice grammer
scope.Exec(
"fig = plt.figure() \n" +
"plt.plot(x[1:], y[1:]) \n" +
"plt.show()"
);
}
}
public void TestNumpy()
{
using (Py.GIL())
{
Numpy.Initialize();
var scope = Py.CreateScope();
var np = scope.Import("numpy", "np");
dynamic m1 = np.matrix(new List <List <float> > {
new List <float>()
{
1, 2, 3
}, new List <float>()
{
4, 5, 6
}
});
TestOutput(m1);
dynamic m2 = np.matrix(new List <List <float> > {
new List <float>()
{
1, 2,
}, new List <float>()
{
3, 4
}, new List <float>()
{
5, 6
}
});
TestOutput(m2);
TestOutput((m1 * m2).ToString());
}
}
// only returns the aug_object_samples and not the rbnn min vals!
public static List<AugmentableObjectSample> AugmentableSampleResultFormat(string augmentable_format_content)
{
// id position scale shape airplane_position distance_from_transitive_floor
// int x,y,z x,y,z BIRD x,y,z double
// space separated
List<AugmentableObjectSample> samples = new List<AugmentableObjectSample>();
string[] lines = augmentable_format_content.Split("\n");
foreach (var line in lines)
{
if (line.Length < 5)
continue;
string[] parts = line.Split(" ");
int id = int.Parse(parts[0]);
string[] pos_string = parts[1].Split(",");
Vector3 pos = new Vector3(float.Parse(pos_string[0]), float.Parse(pos_string[1]), float.Parse(pos_string[2]));
string[] scale_string = parts[2].Split(",");
Vector3 scale = new Vector3(float.Parse(scale_string[0]), float.Parse(scale_string[1]), float.Parse(scale_string[2]));
string name = parts[3];
AugmentableObjectSample samp = new AugmentableObjectSample(name, scale, pos, Numpy.MaxDimension(scale));
samples.Add(samp);
}
return samples;
}
