public IEnumerable <TLayout> Evolve(TLayout initialLayout, IList <TNode> chain, int count)
        {
            for (int i = 0; i < NumberOfAttemptsTotal; i++)
            {
                var layout     = initialLayout.SmartClone();
                var nodesCount = 0;

                foreach (var node in chain)
                {
                    if (TryLayoutNode(layout, node, out var newLayout))
                    {
                        layout = newLayout;
                        nodesCount++;
                    }
                    else
                    {
                        break;
                    }
                }

                if (nodesCount == chain.Count)
                {
                    OnValid?.Invoke(layout);
                    yield return(layout);
                }
            }

            yield break;
        }
Beispiel #2
0
        public Task <bool> Verify(int offset, IEnumerable <int> trails)
        {
            var ret = Math.Abs(offset - OriginX) < Offset && CalcStddev(trails);

            OnValid?.Invoke(ret);
            return(Task.FromResult(ret));
        }
Beispiel #3
0
        public void Launch()
        {
            IsLaunched = true;

            OnLaunch?.Invoke();

            while (IsLaunched)
            {
                if (int.TryParse(Console.ReadLine(), out int index))
                {
                    try
                    {
                        if (index == _exitCode)
                        {
                            Stop();
                            break;
                        }

                        TElement element = _elements[index - LeftOffset];

                        OnValid?.Invoke(element);
                    }
                    catch (IndexOutOfRangeException)
                    {
                        OnIndexOut?.Invoke(index);
                    }
                    catch (Exception exception)
                    {
                        OnError?.Invoke(exception);
                    }
                }
                else
                {
                    Console.WriteLine(LocalizationService.CurrentReader["InvalidInputData"]);
                }
            }
        }
        private void SetupGenerator()
        {
            var mapping       = mapDescription.GetMapping();
            var chainsGeneric = configuration.Chains;

            if (chainsGeneric == null)
            {
                var chainDecomposition = new TwoStageChainDecomposition <TNode>(mapDescriptionOriginal, new BreadthFirstChainDecomposition <TNode>(configuration.ChainDecompositionConfiguration ?? new ChainDecompositionConfiguration()));
                chainsGeneric = chainDecomposition.GetChains(mapDescriptionOriginal.GetGraph());
            }

            var chains = chainsGeneric
                         .Select(x => new Chain <int>(x.Nodes.Select(y => mapping[y]).ToList(), x.Number))
                         .ToList();

            var generatorPlanner = new GeneratorPlanner <Layout <Configuration <CorridorsData> >, int>(configuration.SimulatedAnnealingMaxBranching);

            var configurationSpacesGenerator = new ConfigurationSpacesGenerator(
                new PolygonOverlap(),
                DoorHandler.DefaultHandler,
                new OrthogonalLineIntersection(),
                new GridPolygonUtils());
            var configurationSpaces = configurationSpacesGenerator.GetConfigurationSpaces <Configuration <CorridorsData> >(mapDescription);

            //var corridorConfigurationSpaces = mapDescription.IsWithCorridors ? configurationSpacesGenerator.Generate<TNode, Configuration<CorridorsData>>(mapDescription, mapDescription.CorridorsOffsets) : configurationSpaces;
            var corridorConfigurationSpaces = configurationSpaces;

            var averageSize    = configurationSpaces.GetAverageSize();
            var polygonOverlap = new FastPolygonOverlap();

            var stageOneConstraints =
                new List <INodeConstraint <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>,
                                           CorridorsData> >
            {
                new BasicConstraint <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>,
                                     CorridorsData, IntAlias <PolygonGrid2D> >(
                    new FastPolygonOverlap(),
                    averageSize,
                    configurationSpaces
                    ),
                new CorridorConstraints <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, CorridorsData, IntAlias <PolygonGrid2D> >(
                    mapDescription,
                    averageSize,
                    corridorConfigurationSpaces
                    ),
            };

            if (!configuration.RoomsCanTouch)
            {
                stageOneConstraints.Add(new TouchingConstraints <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, CorridorsData, IntAlias <PolygonGrid2D> >(
                                            mapDescription,
                                            polygonOverlap
                                            ));
            }

            var stageOneConstraintsEvaluator = new ConstraintsEvaluator <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, IntAlias <PolygonGrid2D>, CorridorsData>(stageOneConstraints);

            //if (mapDescription.IsWithCorridors)
            //{
            //    layoutOperations.AddNodeConstraint(new CorridorConstraints<Layout<Configuration<CorridorsData>>, int, Configuration<CorridorsData>, CorridorsData, IntAlias<GridPolygon>>(
            //        mapDescription,
            //        averageSize,
            //        corridorConfigurationSpaces
            //    ));

            //    if (!false) // TODO:
            //    {
            //        var polygonOverlap = new FastPolygonOverlap();
            //        layoutOperations.AddNodeConstraint(new TouchingConstraints<Layout<Configuration<CorridorsData>>, int, Configuration<CorridorsData>, CorridorsData, IntAlias<GridPolygon>>(
            //            mapDescription,
            //            polygonOverlap
            //        ));
            //    }
            //}


            var roomShapesHandler = new RoomShapesHandler <int, Configuration <CorridorsData> >(
                configurationSpaces,
                configurationSpaces.GetIntAliasMapping(),
                mapDescription,
                configuration.RepeatModeOverride
                );

            var layoutOperations = new LayoutOperations <Layout <Configuration <CorridorsData> >, int, Configuration <CorridorsData>, IntAlias <PolygonGrid2D>, CorridorsData>(corridorConfigurationSpaces, configurationSpaces.GetAverageSize(), mapDescription, stageOneConstraintsEvaluator, stageOneConstraintsEvaluator, roomShapesHandler, configuration.ThrowIfRepeatModeNotSatisfied);

            var initialLayout   = new Layout <Configuration <CorridorsData> >(mapDescription.GetGraph());
            var layoutConverter =
                new BasicLayoutConverter <Layout <Configuration <CorridorsData> >, TNode,
                                          Configuration <CorridorsData> >(mapDescription, configurationSpaces,
                                                                          configurationSpaces.GetIntAliasMapping());

            var layoutEvolver =
                new PlatformersEvolver <Layout <Configuration <CorridorsData> >, int,
                                        Configuration <CorridorsData> >(layoutOperations);

            generator = new ChainBasedGenerator <Layout <Configuration <CorridorsData> >, MapLayout <TNode>, int>(initialLayout, generatorPlanner, chains, layoutEvolver, layoutConverter);

            generator.OnRandomInjected += (random) =>
            {
                ((IRandomInjectable)configurationSpaces).InjectRandomGenerator(random);
                ((IRandomInjectable)layoutOperations).InjectRandomGenerator(random);
                ((IRandomInjectable)layoutEvolver).InjectRandomGenerator(random);
                ((IRandomInjectable)layoutConverter).InjectRandomGenerator(random);
            };

            generator.OnCancellationTokenInjected += (token) =>
            {
                ((ICancellable)generatorPlanner).SetCancellationToken(token);
                ((ICancellable)layoutEvolver).SetCancellationToken(token);
            };

            // layoutEvolver.OnEvent += (sender, args) => OnSimulatedAnnealingEvent?.Invoke(sender, args);
            layoutEvolver.OnPerturbed          += (sender, layout) => OnPerturbed?.Invoke(layoutConverter.Convert(layout, false));
            layoutEvolver.OnPerturbed          += (sender, layout) => OnPerturbedInternal?.Invoke(layout);
            layoutEvolver.OnValid              += (sender, layout) => OnPartialValid?.Invoke(layoutConverter.Convert(layout, true));
            generatorPlanner.OnLayoutGenerated += layout => OnValid?.Invoke(layoutConverter.Convert(layout, true));
        }
        /// <inheritdoc />
        public IEnumerable <TLayout> Evolve(TLayout initialLayout, Chain <TNode> chain, int count)
        {
            var configuration = GetConfiguration(chain.Number);

            if (!chain.IsFromFace && configuration.HandleTreesGreedily)
            {
                var iters          = 0;
                var lastEventIters = 0;

                for (int i = 0; i < 2; i++)
                {
                    if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
                    {
                        yield break;
                    }

                    for (int k = 0; k < 1; k++)
                    {
                        if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
                        {
                            yield break;
                        }

                        var copy = initialLayout.SmartClone();
                        LayoutOperations.AddChain(copy, chain.Nodes, true, out var addChainIterationsCount);

                        iters += addChainIterationsCount;

                        // An event must be sent in order for the early stopping handler to work
                        OnPerturbed?.Invoke(this, copy);

                        if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
                        {
                            yield break;
                        }

                        if (LayoutOperations.IsLayoutValid(copy))
                        {
                            if (LayoutOperations.TryCompleteChain(copy, chain.Nodes))
                            {
                                OnPerturbed?.Invoke(this, copy);

                                if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
                                {
                                    yield break;
                                }

                                OnEvent?.Invoke(this, new SimulatedAnnealingEventArgs()
                                {
                                    Type = SimulatedAnnealingEventType.LayoutGenerated,
                                    IterationsSinceLastEvent = iters - lastEventIters,
                                    IterationsTotal          = iters,
                                    LayoutsGenerated         = -1,
                                    ChainNumber = chain.Number,
                                });

                                lastEventIters = iters;

                                yield return(copy);

                                break;
                            }
                        }

                        OnEvent?.Invoke(this, new SimulatedAnnealingEventArgs()
                        {
                            Type = SimulatedAnnealingEventType.OutOfIterations,
                            IterationsSinceLastEvent = iters - lastEventIters,
                            IterationsTotal          = iters,
                            LayoutsGenerated         = -1,
                            ChainNumber = chain.Number,
                        });

                        lastEventIters = iters;
                    }
                }

                yield break;
            }

            if (addNodesGreedilyBeforeEvolve)
            {
                LayoutOperations.AddChain(initialLayout, chain.Nodes, true, out var addChainIterationsCount);
            }

            const double p0                = 0.2d;
            const double p1                = 0.01d;
            var          t0                = -1d / Math.Log(p0);
            var          t1                = -1d / Math.Log(p1);
            var          ratio             = Math.Pow(t1 / t0, 1d / (configuration.Cycles - 1));
            var          deltaEAvg         = 0d;
            var          acceptedSolutions = 1;

            var t = t0;

            var layouts        = new List <TLayout>();
            var originalLayout = initialLayout;
            var currentLayout  = originalLayout;

            #region Debug output

            //if (withDebugOutput)
            //{
            //	Console.WriteLine($"Initial energy: {layoutOperations.GetEnergy(currentLayout)}");
            //}

            #endregion

            var numberOfFailures = 0;
            var stageTwoFailures = 0;

            var iterations          = 0;
            var lastEventIterations = 0;

            var shouldStop = false;

            for (var i = 0; i < configuration.Cycles; i++)
            {
                var wasAccepted = false;

                #region Random restarts

                if (enableRandomRestarts)
                {
                    if (ShouldRestart(numberOfFailures))
                    {
                        OnEvent?.Invoke(this, new SimulatedAnnealingEventArgs()
                        {
                            Type = SimulatedAnnealingEventType.RandomRestart,
                            IterationsSinceLastEvent = iterations - lastEventIterations,
                            IterationsTotal          = iterations,
                            LayoutsGenerated         = layouts.Count,
                            ChainNumber = chain.Number,
                        });
                        yield break;
                    }
                }

                #endregion

                if (iterations - lastEventIterations > configuration.MaxIterationsWithoutSuccess)
                {
                    break;
                }

                if (shouldStop)
                {
                    break;
                }

                for (var j = 0; j < configuration.TrialsPerCycle; j++)
                {
                    if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
                    {
                        yield break;
                    }

                    if (stageTwoFailures > configuration.MaxStageTwoFailures)
                    {
                        shouldStop = true;
                        break;
                    }

                    iterations++;
                    var perturbedLayout = PerturbLayout(currentLayout, chain.Nodes, out var energyDelta);

                    OnPerturbed?.Invoke(this, perturbedLayout);

                    // TODO: can we check the energy instead?
                    if (LayoutOperations.IsLayoutValid(perturbedLayout, chain.Nodes))
                    {
                        #region Random restarts
                        if (enableRandomRestarts && randomRestartsSuccessPlace == RestartSuccessPlace.OnValid)
                        {
                            wasAccepted = true;

                            if (randomRestartsResetCounter)
                            {
                                numberOfFailures = 0;
                            }
                        }
                        #endregion

                        // TODO: wouldn't it be too slow to compare againts all?
                        if (IsDifferentEnough(perturbedLayout, layouts))
                        {
                            // TODO 2SG: should we clone before TryCompleteChain or should TryCompleteChain not change the layout?
                            var newLayout      = perturbedLayout.SmartClone();
                            var shouldContinue = LayoutOperations.TryCompleteChain(newLayout, chain.Nodes);

                            if (shouldContinue)
                            {
                                layouts.Add(newLayout);
                                OnValid?.Invoke(this, newLayout);

                                #region Random restarts
                                if (enableRandomRestarts && randomRestartsSuccessPlace == RestartSuccessPlace.OnValidAndDifferent)
                                {
                                    wasAccepted = true;

                                    if (randomRestartsResetCounter)
                                    {
                                        numberOfFailures = 0;
                                    }
                                }
                                #endregion

                                OnEvent?.Invoke(this, new SimulatedAnnealingEventArgs()
                                {
                                    Type = SimulatedAnnealingEventType.LayoutGenerated,
                                    IterationsSinceLastEvent = iterations - lastEventIterations,
                                    IterationsTotal          = iterations,
                                    LayoutsGenerated         = layouts.Count,
                                    ChainNumber = chain.Number,
                                });

                                yield return(newLayout);

                                lastEventIterations = iterations;
                                stageTwoFailures    = 0;

                                #region Debug output

                                //if (withDebugOutput)
                                //{
                                //	Console.WriteLine($"Found layout, cycle {i}, trial {j}, energy {layoutOperations.GetEnergy(perturbedLayout)}");
                                //}

                                #endregion

                                if (layouts.Count >= count)
                                {
                                    #region Debug output

                                    //if (withDebugOutput)
                                    //{
                                    //	Console.WriteLine($"Returning {layouts.Count} partial layouts");
                                    //}

                                    #endregion

                                    yield break;
                                }
                            }
                            else
                            {
                                stageTwoFailures++;

                                OnEvent?.Invoke(this, new SimulatedAnnealingEventArgs()
                                {
                                    Type = SimulatedAnnealingEventType.StageTwoFailure,
                                    IterationsSinceLastEvent = iterations - lastEventIterations,
                                    IterationsTotal          = iterations,
                                    LayoutsGenerated         = layouts.Count,
                                    ChainNumber = chain.Number,
                                    ResetsIterationsSinceLastEvent = false,
                                });
                            }
                        }
                    }

                    var deltaAbs = Math.Abs(energyDelta);
                    var accept   = false;

                    if (energyDelta > 0)
                    {
                        if (i == 0 && j == 0)
                        {
                            deltaEAvg = deltaAbs * 15;
                        }

                        var p = Math.Pow(Math.E, -deltaAbs / (deltaEAvg * t));
                        if (Random.NextDouble() < p)
                        {
                            accept = true;
                        }
                    }
                    else
                    {
                        accept = true;
                    }

                    if (accept)
                    {
                        acceptedSolutions++;
                        currentLayout = perturbedLayout;
                        deltaEAvg     = (deltaEAvg * (acceptedSolutions - 1) + deltaAbs) / acceptedSolutions;

                        #region Random restarts
                        if (enableRandomRestarts && randomRestartsSuccessPlace == RestartSuccessPlace.OnAccepted)
                        {
                            wasAccepted = true;

                            if (randomRestartsResetCounter)
                            {
                                numberOfFailures = 0;
                            }
                        }
                        #endregion
                    }
                }

                if (!wasAccepted)
                {
                    numberOfFailures++;
                }

                t = t * ratio;
            }

            OnEvent?.Invoke(this, new SimulatedAnnealingEventArgs()
            {
                Type = SimulatedAnnealingEventType.OutOfIterations,
                IterationsSinceLastEvent = iterations - lastEventIterations,
                IterationsTotal          = iterations,
                LayoutsGenerated         = layouts.Count,
                ChainNumber = chain.Number,
            });
        }
        private List <Layout> GetExtendedLayouts(Layout layout, List <int> chain, bool lastChain)
        {
            var cycles         = 50;
            var trialsPerCycle = 500;

            var p0                = 0.2d;
            var p1                = 0.01d;
            var t0                = -1d / Math.Log(p0);
            var t1                = -1d / Math.Log(p1);
            var ratio             = Math.Pow(t1 / t0, 1d / (cycles - 1));
            var deltaEAvg         = 0d;
            var acceptedSolutions = 1;

            var t = t0;

            var layouts        = new List <Layout>();
            var originalLayout = layout;             //AddChainToLayout(layout, chain);
            var currentLayout  = originalLayout;

            if (WithDebug)
            {
                Console.WriteLine($"Initial energy: {currentLayout.GetEnergy()}");
            }

            var numFailures = 0;

            for (var i = 0; i < cycles; i++)
            {
                var wasAccepted = false;

                if (numFailures > 8 && Random.Next(0, 2) == 0)
                {
                    if (WithDebug)
                    {
                        Console.WriteLine($"Break, we got {numFailures} failures");
                    }
                    break;
                }

                if (numFailures > 6 && Random.Next(0, 3) == 0)
                {
                    if (WithDebug)
                    {
                        Console.WriteLine($"Break, we got {numFailures} failures");
                    }
                    break;
                }

                if (numFailures > 4 && Random.Next(0, 5) == 0)
                {
                    if (WithDebug)
                    {
                        Console.WriteLine($"Break, we got {numFailures} failures");
                    }
                    break;
                }

                if (numFailures > 2 && Random.Next(0, 7) == 0)
                {
                    if (WithDebug)
                    {
                        Console.WriteLine($"Break, we got {numFailures} failures");
                    }
                    break;
                }

                for (var j = 0; j < trialsPerCycle; j++)
                {
                    iterationsCount++;
                    var perturbedLayout = PerturbLayout(currentLayout, chain, out var energyDelta);                     // TODO: locally perturb the layout

                    OnPerturbed?.Invoke((ILayout <TNode, TPolygon, TPosition, IntLine>)perturbedLayout);

                    // TODO: should probably check only the perturbed node - other nodes did not change
                    if (IsLayoutValid(perturbedLayout))
                    {
                        OnValid?.Invoke((ILayout <TNode, TPolygon, TPosition, IntLine>)perturbedLayout);

                        // TODO: wouldn't it be too slow to compare againts all?
                        if (layouts.TrueForAll(x => x.GetDifference(perturbedLayout, chain) > 2 * MinimumDifference))
                        {
                            wasAccepted = true;
                            AddDoors(new List <Layout>()
                            {
                                perturbedLayout
                            });
                            layouts.Add(perturbedLayout);
                            OnValidAndDifferent?.Invoke((ILayout <TNode, TPolygon, TPosition, IntLine>)perturbedLayout);

                            if (WithDebug)
                            {
                                Console.WriteLine($"Found layout, cycle {i}, trial {j}, energy {perturbedLayout.GetEnergy()}");
                            }

                            if (layouts.Count >= 15)
                            {
                                if (WithDebug)
                                {
                                    Console.WriteLine($"Returning {layouts.Count} partial layouts");
                                }

                                return(layouts);
                            }
                        }
                    }

                    var deltaAbs = Math.Abs(energyDelta);
                    var accept   = false;

                    if (energyDelta > 0)
                    {
                        if (i == 0 && j == 0)
                        {
                            deltaEAvg = deltaAbs * 15;
                        }

                        var p = Math.Pow(Math.E, -deltaAbs / (deltaEAvg * t));
                        if (Random.NextDouble() < p)
                        {
                            accept = true;
                        }
                    }
                    else
                    {
                        accept = true;
                    }

                    if (accept)
                    {
                        acceptedSolutions++;
                        currentLayout = perturbedLayout;
                        deltaEAvg     = (deltaEAvg * (acceptedSolutions - 1) + deltaAbs) / acceptedSolutions;
                    }
                }

                if (!wasAccepted)
                {
                    numFailures++;
                }

                t = t * ratio;
            }

            if (WithDebug)
            {
                Console.WriteLine($"Returning {layouts.Count} partial layouts");
            }

            return(layouts);
        }
Beispiel #7
0
        /// <inheritdoc />
        public IEnumerable <TLayout> Evolve(TLayout initialLayout, IList <TNode> chain, int count)
        {
            const double p0                = 0.2d;
            const double p1                = 0.01d;
            var          t0                = -1d / Math.Log(p0);
            var          t1                = -1d / Math.Log(p1);
            var          ratio             = Math.Pow(t1 / t0, 1d / (Cycles - 1));
            var          deltaEAvg         = 0d;
            var          acceptedSolutions = 1;

            var t = t0;

            var layouts        = new List <TLayout>();
            var originalLayout = initialLayout;
            var currentLayout  = originalLayout;

            #region Debug output

            //if (withDebugOutput)
            //{
            //	Console.WriteLine($"Initial energy: {layoutOperations.GetEnergy(currentLayout)}");
            //}

            #endregion

            var numberOfFailures = 0;

            for (var i = 0; i < Cycles; i++)
            {
                var wasAccepted = false;

                #region Random restarts

                if (enableRandomRestarts)
                {
                    if (ShouldRestart(numberOfFailures))
                    {
                        break;
                    }
                }

                #endregion

                for (var j = 0; j < TrialsPerCycle; j++)
                {
                    if (CancellationToken.HasValue && CancellationToken.Value.IsCancellationRequested)
                    {
                        yield break;
                    }

                    var perturbedLayout = PerturbLayout(currentLayout, chain, out var energyDelta);

                    OnPerturbed?.Invoke(perturbedLayout);

                    // TODO: can we check the energy instead?
                    if (LayoutOperations.IsLayoutValid(perturbedLayout, chain))
                    {
                        #region Random restarts
                        if (enableRandomRestarts && randomRestartsSuccessPlace == RestartSuccessPlace.OnValid)
                        {
                            wasAccepted = true;

                            if (randomRestartsResetCounter)
                            {
                                numberOfFailures = 0;
                            }
                        }
                        #endregion

                        // TODO: wouldn't it be too slow to compare againts all?
                        if (IsDifferentEnough(perturbedLayout, layouts))
                        {
                            var shouldContinue = true;

                            // TODO: should it be like this?
                            if (LayoutOperations is ILayoutOperationsWithCorridors <TLayout, TNode> layoutOperationsWithCorridors)
                            {
                                shouldContinue = layoutOperationsWithCorridors.AddCorridors(perturbedLayout, chain);
                            }

                            if (shouldContinue)
                            {
                                layouts.Add(perturbedLayout);
                                OnValid?.Invoke(perturbedLayout);

                                #region Random restarts
                                if (enableRandomRestarts && randomRestartsSuccessPlace == RestartSuccessPlace.OnValidAndDifferent)
                                {
                                    wasAccepted = true;

                                    if (randomRestartsResetCounter)
                                    {
                                        numberOfFailures = 0;
                                    }
                                }
                                #endregion

                                yield return(perturbedLayout);

                                #region Debug output

                                //if (withDebugOutput)
                                //{
                                //	Console.WriteLine($"Found layout, cycle {i}, trial {j}, energy {layoutOperations.GetEnergy(perturbedLayout)}");
                                //}

                                #endregion

                                if (layouts.Count >= count)
                                {
                                    #region Debug output

                                    //if (withDebugOutput)
                                    //{
                                    //	Console.WriteLine($"Returning {layouts.Count} partial layouts");
                                    //}

                                    #endregion

                                    yield break;
                                }
                            }
                        }
                    }

                    var deltaAbs = Math.Abs(energyDelta);
                    var accept   = false;

                    if (energyDelta > 0)
                    {
                        if (i == 0 && j == 0)
                        {
                            deltaEAvg = deltaAbs * 15;
                        }

                        var p = Math.Pow(Math.E, -deltaAbs / (deltaEAvg * t));
                        if (Random.NextDouble() < p)
                        {
                            accept = true;
                        }
                    }
                    else
                    {
                        accept = true;
                    }

                    if (accept)
                    {
                        acceptedSolutions++;
                        currentLayout = perturbedLayout;
                        deltaEAvg     = (deltaEAvg * (acceptedSolutions - 1) + deltaAbs) / acceptedSolutions;

                        #region Random restarts
                        if (enableRandomRestarts && randomRestartsSuccessPlace == RestartSuccessPlace.OnAccepted)
                        {
                            wasAccepted = true;

                            if (randomRestartsResetCounter)
                            {
                                numberOfFailures = 0;
                            }
                        }
                        #endregion
                    }
                }

                if (!wasAccepted)
                {
                    numberOfFailures++;
                }

                t = t * ratio;
            }
        }
        private void SetupGenerator()
        {
            var mapping       = levelDescriptionMapped.GetMapping();
            var chainsGeneric = configuration.Chains;

            // Create chain decomposition
            if (chainsGeneric == null)
            {
                var chainDecomposition = new Common.TwoStageChainDecomposition <TRoom>(levelDescription, new BreadthFirstChainDecomposition <TRoom>(configuration.ChainDecompositionConfiguration ?? new ChainDecompositionConfiguration()));
                chainsGeneric = chainDecomposition.GetChains(levelDescription.GetGraph());
            }

            var chains = chainsGeneric
                         .Select(x => new Chain <RoomNode <TRoom> >(x.Nodes.Select(y => mapping[y]).ToList(), x.Number)
            {
                IsFromFace = x.IsFromFace
            })
                         .ToList();

            // Create generator planner
            var generatorPlanner = new GeneratorPlanner <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom> >(configuration.SimulatedAnnealingMaxBranching);

            // Create configuration spaces
            var configurationSpacesGenerator = new ConfigurationSpacesGenerator(
                new PolygonOverlap(),
                DoorHandler.DefaultHandler,
                new OrthogonalLineIntersection(),
                new GridPolygonUtils());

            // var configurationSpaces = configurationSpacesGenerator.GetConfigurationSpaces<ConfigurationNew2<CorridorsDataNew>>(mapDescription);
            var simpleConfigurationSpaces = new ConfigurationSpacesGrid2D <ConfigurationGrid2D <TRoom, EnergyData>, RoomNode <TRoom> >(levelDescriptionMapped);

            // Needlessly complex for backwards compatibility

            #region IntAliasMapping

            var roomDescriptions             = levelDescriptionMapped.GetGraph().Vertices.ToDictionary(x => x, x => (RoomDescriptionGrid2D)levelDescriptionMapped.GetRoomDescription(x));
            var roomTemplates                = roomDescriptions.Values.SelectMany(x => x.RoomTemplates).Distinct().ToList();
            var roomTemplateInstances        = roomTemplates.ToDictionary(x => x, configurationSpacesGenerator.GetRoomTemplateInstances);
            var roomTemplateInstancesMapping = roomTemplateInstances.SelectMany(x => x.Value).CreateIntMapping();
            var intAliasMapping              = new TwoWayDictionary <RoomTemplateInstanceGrid2D, IntAlias <PolygonGrid2D> >();

            foreach (var shape1 in roomTemplateInstancesMapping.Keys)
            {
                foreach (var shape2 in roomTemplateInstancesMapping.Keys)
                {
                    if (!intAliasMapping.ContainsKey(shape1))
                    {
                        var newAlias = new IntAlias <PolygonGrid2D>(intAliasMapping.Count, shape1.RoomShape);
                        intAliasMapping.Add(shape1, newAlias);
                        shape1.RoomShapeAlias = newAlias;
                    }
                    if (!intAliasMapping.ContainsKey(shape2))
                    {
                        var newAlias = new IntAlias <PolygonGrid2D>(intAliasMapping.Count, shape2.RoomShape);
                        intAliasMapping.Add(shape2, newAlias);
                        shape2.RoomShapeAlias = newAlias;
                    }
                }
            }

            // TODO: remove when possible
            foreach (var pair in intAliasMapping)
            {
                pair.Key.RoomShapeAlias = pair.Value;
            }

            var shapesForNodes = new Dictionary <RoomNode <TRoom>, List <WeightedShape> >();
            foreach (var vertex in levelDescriptionMapped.GetGraph().Vertices)
            {
                shapesForNodes.Add(vertex, new List <WeightedShape>());
                // var roomDescription = levelDescriptionMapped.GetRoomDescription(vertex);
                var roomDescription = roomDescriptions[vertex];

                foreach (var roomTemplate in roomDescription.RoomTemplates)
                {
                    var instances = roomTemplateInstances[roomTemplate];

                    foreach (var roomTemplateInstance in instances)
                    {
                        shapesForNodes[vertex].Add(new WeightedShape(intAliasMapping[roomTemplateInstance], 1d / instances.Count));
                    }
                }
            }

            var usedShapes = new HashSet <int>();
            var allShapes  = new List <IntAlias <PolygonGrid2D> >();
            foreach (var vertex in levelDescriptionMapped.GetGraph().Vertices)
            {
                var shapes = shapesForNodes[vertex];

                foreach (var shape in shapes)
                {
                    if (!usedShapes.Contains(shape.Shape.Alias))
                    {
                        allShapes.Add(shape.Shape);
                        usedShapes.Add(shape.Shape.Alias);
                    }
                }
            }

            var averageSize = (int)allShapes.Select(x => x.Value.BoundingRectangle).Average(x => (x.Width + x.Height) / 2);

            #endregion



            // var averageSize = configurationSpaces.GetAverageSize();

            var energyUpdater     = new BasicEnergyUpdater <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData> >(10 * averageSize);
            var roomShapeGeometry = new FastGridPolygonGeometry <ConfigurationGrid2D <TRoom, EnergyData>, RoomNode <TRoom> >();

            // Create generator constraints
            var stageOneConstraints =
                new List <INodeConstraint <ILayout <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>,
                                           EnergyData> >
            {
                new BasicConstraint <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(
                    roomShapeGeometry,
                    simpleConfigurationSpaces,
                    levelDescriptionMapped,
                    configuration.OptimizeCorridorConstraints
                    ),
                new CorridorConstraint <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(
                    levelDescriptionMapped,
                    simpleConfigurationSpaces,
                    roomShapeGeometry
                    ),
            };

            if (levelDescription.MinimumRoomDistance > 0)
            {
                stageOneConstraints.Add(new MinimumDistanceConstraint <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(
                                            levelDescriptionMapped,
                                            roomShapeGeometry,
                                            levelDescription.MinimumRoomDistance
                                            ));
            }

            var constraintsEvaluator = new ConstraintsEvaluator <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, EnergyData>(stageOneConstraints, energyUpdater);

            var roomShapesHandler = new RoomShapesHandlerGrid2D <RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData> >(
                intAliasMapping,
                levelDescriptionMapped,
                shapesForNodes,
                levelDescription.RoomTemplateRepeatModeOverride,
                levelDescription.RoomTemplateRepeatModeDefault
                );

            // Create layout operations
            var layoutOperations = new LayoutController <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom>, ConfigurationGrid2D <TRoom, EnergyData>, RoomTemplateInstanceGrid2D, EnergyData>(averageSize, levelDescriptionMapped, constraintsEvaluator, roomShapesHandler, configuration.ThrowIfRepeatModeNotSatisfied, simpleConfigurationSpaces, roomShapeGeometry);

            var initialLayout   = new Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >(levelDescriptionMapped.GetGraph());
            var layoutConverter =
                new BasicLayoutConverterGrid2D <TRoom,
                                                ConfigurationGrid2D <TRoom, EnergyData> >(levelDescription, simpleConfigurationSpaces,
                                                                                          intAliasMapping);

            // Create simulated annealing evolver
            var layoutEvolver =
                new Common.SimulatedAnnealingEvolver <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, RoomNode <TRoom>,
                                                      ConfigurationGrid2D <TRoom, EnergyData> >(layoutOperations, configuration.SimulatedAnnealingConfiguration, true);

            // Create the generator itself
            generator = new ChainBasedGenerator <Layout <TRoom, ConfigurationGrid2D <TRoom, EnergyData> >, LayoutGrid2D <TRoom>, RoomNode <TRoom> >(initialLayout, generatorPlanner, chains, layoutEvolver, layoutConverter);

            // Register event handlers
            generator.OnRandomInjected += (random) =>
            {
                // ((IRandomInjectable)configurationSpaces).InjectRandomGenerator(random);
                ((IRandomInjectable)layoutOperations).InjectRandomGenerator(random);
                ((IRandomInjectable)layoutEvolver).InjectRandomGenerator(random);
                ((IRandomInjectable)layoutConverter).InjectRandomGenerator(random);
                ((IRandomInjectable)simpleConfigurationSpaces).InjectRandomGenerator(random);
                ((IRandomInjectable)roomShapesHandler).InjectRandomGenerator(random);
            };

            generator.OnCancellationTokenInjected += (token) =>
            {
                ((ICancellable)generatorPlanner).SetCancellationToken(token);
                ((ICancellable)layoutEvolver).SetCancellationToken(token);
            };

            layoutEvolver.OnEvent              += (sender, args) => OnSimulatedAnnealingEvent?.Invoke(sender, args);
            layoutEvolver.OnPerturbed          += (sender, layout) => OnPerturbed?.Invoke(layoutConverter.Convert(layout, false));
            layoutEvolver.OnPerturbed          += (sender, layout) => OnPerturbedInternal?.Invoke(layout);
            layoutEvolver.OnValid              += (sender, layout) => OnPartialValid?.Invoke(layoutConverter.Convert(layout, true));
            generatorPlanner.OnLayoutGenerated += layout => OnValid?.Invoke(layoutConverter.Convert(layout, true));
        }
 private void ValidLayoutsHandler(TLayout layout)
 {
     OnValid?.Invoke(layoutConverter.Convert(layout, true));
 }