//[Fact]
public void MiniEndToEnd()
{
// Building the graph
var g = new FGraph();
var input = g.New("input").AsInput().As2D(32, 32);
var label = g.New("label").AsInput().As1D(10);
var hidden1 = g.Do(Layers.Dense(), input).As1D(128);
var hidden2 = g.Do(Layers.Dense(), hidden1).As1D(128);
var res = g.Do(Layers.Dense(), hidden2).As("res").As1D(10);
var err = g.Do(Layers.SquareError(), input, label).AsCriterion();
var graph = g.Build();
// Geometric inference
var solver = new GeometricSolver();
solver.Solve(graph);
// Optimizing the flow
var optimizer = new AdamOptimizer(new MyTileCompiler(), new MyTensorAllocator());
var reader = new MyImageReader(/* dummy */ null);
var flow = optimizer.Optimize(graph, reader);
// Evaluating with the flow
var writer = new MyDigitReader(/* dummy */ 0);
flow.Evaluate(reader, writer);
}
public ParallelLineMatch(GeometricSolver solver, double precision)
: base(solver)
{
_precision = precision;
_oxDir = gp.OX.Direction;
_oyDir = gp.OY.Direction;
_ozDir = gp.OZ.Direction;
}
/// <summary>
/// Возвращает список пар точек(отрезков/соединений) которые принадлежат переданному соединению
/// </summary>
/// <param name="net"></param>
/// <returns></returns>
private List <Tuple <Point, Point> > GetSegmentListFromNet(Net net)
{
List <Tuple <Point, Point> > list = new List <Tuple <Point, Point> >();
var notVisited = net.Pads.ToList();
Pad nextPad = notVisited[0];
while (true)
{
notVisited.Remove(nextPad);
Point curPoint = new Point(nextPad.Position + nextPad.Module.Position);
var minDistance = double.MaxValue;
foreach (var e in notVisited)
{
Point ePoint = new Point(e.Position + e.Module.Position);
var curDistance = GeometricSolver.GetDistance(curPoint, ePoint);
if (GeometricSolver.GetDistance(curPoint, ePoint) < minDistance)
{
minDistance = curDistance;
nextPad = e;
}
}
if (notVisited.Count == 0)
{
list.Add(new Tuple <Point, Point>(new Point(curPoint), new Point(list[0].Item1)));
list = list.OrderBy(x => GeometricSolver.GetDistance(x.Item1, x.Item2))
.Take(list.Count - 1)
.ToList();
break;
}
list.Add(new Tuple <Point, Point>(new Point(curPoint), new Point(nextPad.Position + nextPad.Module.Position)));
}
#region comments
//Point curPoint = null;
//for (int i = 0; i < net.Pads.Count; i++)
//{
// double minDistance = double.MaxValue;
// Point p1 = new Point(net.Pads[i].Position + net.Pads[i].Module.Position);
// for (int j = i+1; j < net.Pads.Count; j++)
// {
// Point p2 = new Point(net.Pads[j].Position + net.Pads[j].Module.Position);
// curDistance = GeometricSolver.GetDistance(p1, p2);
// if (curDistance < minDistance && !list.Contains(new Tuple<Point, Point>(p1, p2)))
// {
// curPoint = p2;
// minDistance = curDistance;
// }
// }
// if (minDistance != double.MaxValue)
// list.Add(new Tuple<Point, Point>(p1, curPoint));
//}
#endregion
return(list);
}
public void RotateTest3()
{
Point point = GeometricSolver.RotatePoint(new Point(0, -1), Math.PI / 2);
double x = -1;
double y = 0;
Assert.AreEqual(point.X, x, 10e-6);
Assert.AreEqual(point.Y, y, 10e-6);
}
public void RectaglesIntersectionTest4()
{
var res = GeometricSolver.AreModuleInBounds(
new Point(0, 0),
new Point(10, 10),
new Point(-5, -5),
new Point(20, 20));
Assert.IsTrue(res);
}
public void RectaglesIntersectionTest2()
{
var res = GeometricSolver.AreModuleInBounds(
new Point(0, 0),
new Point(10, 10),
new Point(11, 11),
new Point(20, 20));
Assert.IsFalse(res);
}
public void SegmentIntersctionTest3()
{
var res = GeometricSolver.AreSegmentsIntersect(
new Point(10, 10),
new Point(100, 100),
new Point(50, 0),
new Point(50, 60));
Assert.IsTrue(res);
}
public void SegmentIntersctionTest2()
{
var res = GeometricSolver.AreSegmentsIntersect(
new Point(152.4, 133.35),
new Point(205.7, 114.30),
new Point(160, 140),
new Point(180, 114));
Assert.IsTrue(res);
}
public void SegmentIntersctionTest1()
{
var res = GeometricSolver.AreSegmentsIntersect(
new Point(0, 0),
new Point(5, 5),
new Point(0, 5),
new Point(5, 0));
Assert.IsTrue(res);
}
public void RandomPointInRange()
{
var rnd = new Random();
for (int i = 0; i < 10; i++)
{
Point p1 = GeometricSolver.GetRandomPointInRange(400, 400, rnd);
Assert.IsTrue(p1.X < 400 && p1.X > 0);
Assert.IsTrue(p1.Y < 400 && p1.Y > 0);
}
}
public PolarLineMatch(GeometricSolver solver, double getDoubleValue)
: base(solver)
{
_directions = new List <gpDir>();
for (var angle = 0.0; angle < 359; angle += getDoubleValue)
{
_directions.Add(
new gpDir(new gpXYZ(Math.Cos(GeomUtils.DegreesToRadians(angle)),
Math.Sin(GeomUtils.DegreesToRadians(angle)), 0)));
}
_precision = 5.0 / 180 * Math.PI;
}
/// <summary>
/// Поворот модуля на заданный градус
/// </summary>
/// <param name="module"></param>
/// <param name="angle"></param>
public static void RotateModule(Module module, double angle)
{
double radians = angle * Math.PI / 180;
Point newCoordinate1 = GeometricSolver.RotatePoint(module.LeftUpperBound, radians);
Point newCoordinate2 = GeometricSolver.RotatePoint(module.RighLowerBound, radians);
module.LeftUpperBound = GeometricSolver.GetMin(newCoordinate1, newCoordinate2.X, newCoordinate2.Y);
module.RighLowerBound = GeometricSolver.GetMax(newCoordinate2, newCoordinate1.X, newCoordinate1.Y);
foreach (var pad in module.Pads)
{
pad.Position = GeometricSolver.RotatePoint(pad.Position, radians);
}
module.Rotate += angle;
}
/// <summary>
/// Создание новой хромосомы по образцу, с случайным разположением модулей
/// </summary>
public Chromosome()
{
Age = 0;
Valuation = int.MaxValue;
PrintCircuitBoard = new PrintedCircuitBoard(ExamplePrintedCircuitBoard);
var rnd = new Random();
foreach (var module in PrintCircuitBoard.Modules)
{
module.Position = GeometricSolver.GetRandomPointInRange(WorkspaceWidth, WorkspaceHeight, rnd) +
LeftUpperPoint;
if (!module.IsLocked())
{
var angle = rnd.Next(0, 4) * Angle;
RotateModule(module, angle);
}
}
PrintCircuitBoard.LeadToCorrectForm(PrintCircuitBoard.Modules);
}
/// <summary>
/// Подсчет всех пересечений в данной конфигурации платы
/// </summary>
/// <returns></returns>
public int GetIntersectionsNumber()
{
// TODO: get number of the intersections
var netlist = GetAllNets(this);
int intersectionCount = 0;
for (int i = 0; i < netlist.Count; i++)
{
for (int j = i + 1; j < netlist.Count; j++)
{
if (GeometricSolver.AreSegmentsIntersect(netlist[i].Item1, netlist[i].Item2, netlist[j].Item1,
netlist[j].Item2))
{
intersectionCount++;
}
}
}
#region
//for (int i =0; i < NetList.Count; i++)
//{
// Point p1 = new Point(NetList[i].Pad1.Module.Position + NetList[i].Pad1.Position);
// if (NetList[i].Pad2 == null)
// continue;
// Point p2 = new Point(NetList[i].Pad2.Module.Position + NetList[i].Pad2.Position);
// for (int j = i+1; j < NetList.Count; j++)
// {
// Point q1 = new Point(NetList[j].Pad1.Module.Position + NetList[j].Pad1.Position);
// if (NetList[j].Pad2 ==null)
// continue;
// Point q2 = new Point(NetList[j].Pad2.Module.Position + NetList[j].Pad2.Position);
// if (PrintedCircuitBoard.AreSegmentsIntersect(p1, p2, q1, q2))
// intersectionCount++;
// }
//}
#endregion
return(intersectionCount);
}
public HorizontalLineMatch(GeometricSolver solver, double range)
: base(solver)
{
_range = range;
}
public PrintedCircuitBoard MakePcBoardFromTree()
{
PrintedCircuitBoard pcBoard = new PrintedCircuitBoard();
pcBoard.Modules = new List <Module>();
pcBoard.NetList = new List <Net>();
foreach (Node curModule in Tree.Head.Nodes.Where(x => x.Text.Contains("module")))
{
Point min = new Point(double.MaxValue, double.MaxValue);
Point max = new Point(double.MinValue, double.MinValue);
Module module = new Module(curModule.Text.Split(' ')[1]);
foreach (Node character in curModule.Nodes)
{
List <string> values = character.Text.Split(' ').ToList();
switch (values[0])
{
case "path":
module.Path = values[1];
break;
case "at":
List <double> position = GetCoordinates(new List <Node> {
character
});
module.Position.X = position[0];
module.Position.Y = position[1];
module.Rotate = (position.Count == 3) ? position[2] : 0;
break;
case "fp_line":
List <double> list = GetCoordinates(character.Nodes.Take(2).ToList());
min = GeometricSolver.GetMin(GeometricSolver.GetMin(min, list[0], list[1]), list[2], list[3]);
max = GeometricSolver.GetMax(GeometricSolver.GetMax(max, list[0], list[1]), list[2], list[3]);
break;
case "fp_circle":
break;
case "pad":
Pad pad = new Pad();
int n;
if (int.TryParse(values[1], out n))
{
pad.Number = int.Parse(values[1]);
}
else
{
pad.Name = values[1];
}
List <double> pos = GetCoordinates(character.Nodes.Where(x => x.Text.Contains("at")).ToList());
pad.Position.X = pos[0];
pad.Position.Y = pos[1];
List <double> size = GetCoordinates(character.Nodes.Where(x => x.Text.Contains("size")).ToList());
List <string> curNet = character.Nodes.Where(x => x.Text.Contains("net")).SelectMany(x => x.Text.Split(' ')).ToList();
Net net = null;
if (curNet.Count != 0)
{
foreach (var edge in pcBoard.NetList)
{
if (edge.Number == int.Parse(curNet[1]) && edge.Name == curNet[2])
{
net = edge;
}
}
if (net == null)
{
pad.Net = new Net(curNet[2], int.Parse(curNet[1]));
pad.Net.Pad1 = pad;
pad.Net.Pads.Add(pad);
pcBoard.NetList.Add(pad.Net);
}
else
{
pad.Net = net;
pad.Net.Pad2 = pad;
pad.Net.Pads.Add(pad);
}
}
pad.Module = module;
min = GeometricSolver.GetMin(min, pos[0] - size[0] / 2, pos[1] - size[1] / 2);
max = GeometricSolver.GetMax(max, pos[0] + size[0] / 2, pos[1] + size[1] / 2);
module.Pads.Add(pad);
break;
}
}
module.LeftUpperBound = min;
module.RighLowerBound = max;
var temp = module.Rotate;
Chromosome.RotateModule(module, module.Rotate);
module.Rotate = temp;
pcBoard.Modules.Add(module);
}
return(pcBoard);
}
public VerticalLineMatch(GeometricSolver solver, double range) : base(solver)
{
_range = range;
}
/// <summary>
/// Приводит плату к корректному виду без пересечений модулей
/// </summary>
/// <param name="modules"> Список модулей которые нужно проверить на пересечение</param>
public void LeadToCorrectForm(List <Module> modules)
{
int swapCount = 0;
var notVisited = modules.ToList();
foreach (var e in notVisited)
{
if (!Modules.Contains(e))
{
throw new Exception("Invalid arguments for lead to correct form");
}
}
var rnd = new Random();
while (true)
{
if (notVisited.Count == 0)
{
break;
}
var curModule = notVisited[notVisited.Count - 1];
notVisited.Remove(curModule);
foreach (var module in Modules)
{
if (curModule.Equals(module))
{
continue;
}
if (AreModulesIntersect(curModule, module))
{
swapCount++;
if (module.IsLocked())
{
DivideModules(module, curModule);
}
else
{
DivideModules(curModule, module);
}
if (!notVisited.Contains(module))
{
notVisited.Add(module);
}
if (!GeometricSolver.AreModuleInBounds(module.LeftUpperBound + module.Position,
module.RighLowerBound + module.Position,
Chromosome.LeftUpperPoint,
new Point(Chromosome.LeftUpperPoint.X + Chromosome.WorkspaceWidth,
Chromosome.LeftUpperPoint.Y + Chromosome.WorkspaceHeight)))
{
module.Position = GeometricSolver.GetRandomPointInRange(Chromosome.WorkspaceWidth, Chromosome.WorkspaceHeight, rnd) + Chromosome.LeftUpperPoint;
}
}
}
if (swapCount > 500)
{
break;
}
}
}
public SolverExtractLogic(Document document, GeometricSolver solver)
{
_document = document;
_solver = solver;
}
public SameCoordinatePoints(GeometricSolver solver, double coincidencePrecision)
: base(solver)
{
_precision = coincidencePrecision;
}
public EdgeMatch(GeometricSolver solver, double precision) : base(solver)
{
_precision = precision;
}
protected RuleBase(GeometricSolver solver)
{
_solver = solver;
Enabled = true;
}
public OrthogonalLineMatch(GeometricSolver solver, double precision)
: base(solver)
{
_precision = precision;
}
public PointMatch(GeometricSolver solver, double coincidencePrecision)
: base(solver)
{
_precision = coincidencePrecision;
}
