public void Ommitsteps(Model m_mod)
{
GC.Collect();
//ms.AddModel(m_mod.DeepCopy());
Model deepCopy = m_mod.DeepCopy();
List <Model> allModels = new List <Model>()
{
deepCopy
};
List <Model> lastModel = new List <Model>()
{
deepCopy
};
while (lastModel.Any())
{
List <Model> currentModels = new List <Model>();
foreach (Model currentModel in lastModel)
{
List <Model> allPossibleOneOmmits = OmmitOne(currentModel);
allModels.AddRange(allPossibleOneOmmits);
allModels.Add(currentModel);
currentModels.AddRange(allPossibleOneOmmits);
}
lastModel = currentModels;
}
//MessageBox.Show(allModels.Count+" models in ommit step");
foreach (Model allModel in allModels)
{
//ms.AddModel(allModel);
SaveHistoryModel(allModel, GenerateModelNameFromState(allModel));
}
}
public List <Model> MergeAllRoomPairs(Model m_mod)
{
int missinglargest = 0;
m_mod.CalculateAllRooms();
IEnumerable <int> enumerable = fullist.Except(m_mod.modelRooms.Select(i => i.GetNumberAsInt()));
if (enumerable.Any())
{
missinglargest = enumerable.Max();
}
//missinglargest = m_mod.modelRooms.Select(i => int.Parse(i.Number)).Union(fullist).Max();
List <Model> returnList = new List <Model>();
for (var i = 0; i < m_mod.modelRooms.Count; i++)
{
MyRoom room = m_mod.modelRooms[i];
if (room.GetNumberAsInt() < missinglargest)
{
continue;
}
for (var j = i + 1; j < m_mod.modelRooms.Count; j++)
{
MyRoom modelRoom = m_mod.modelRooms[j];
if (modelRoom.GetNumberAsInt() < missinglargest)
{
continue;
}
//if (room2.Guid == room1.Guid) continue;
bool a = DoTheyHaveCommmonWall(room, modelRoom);
if (!a)
{
continue;
}
else
{
MyRoom room2;
MyRoom modelRoom2;
Model m_mod2 = m_mod.DeepCopy(room, modelRoom, out room2, out modelRoom2);
Model newModel = MergeRooms(m_mod2, room2, modelRoom2);
returnList.Add(newModel);
}
}
}
return(returnList);
}
private void SimulationStep()
{
int moveDistance = int.Parse(this.textBox2.Text);
//Dictionary<MyLine, double> Costs = new Dictionary<MyLine, double>();
double mincost = 100000;
MyLine minline = null;
//make threadpool like - room pool
//fix number of modells, (number of threads) move elemnet, calculate cost
//https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/how-to-write-a-simple-parallel-foreach-loop
double actualCost = model.CalculateCost().First();
foreach (MyLine line in model.modelLines)
{
MyLine newMyLine;
Model tempModel = model.DeepCopy(line, out newMyLine);
tempModel.MoveLine(moveDistance, newMyLine);
double cost = tempModel.CalculateCost().First();
//Costs.Add(myLine, cost);
if (mincost > cost)
{
mincost = cost;
minline = line;
}
}
if (mincost >= actualCost)
{
actualSimulationThreshold++;
}
//model.MoveLine(moveDistance, model.GetRandomLine());
model.MoveLine(moveDistance, minline);
}
private List <Model> OmmitOne(Model currentModel)
{
if (currentModel.modelRooms.Count < 2)
{
return(new List <Model>());
}
List <Model> returns = new List <Model>()
{
};
GC.Collect();
foreach (var room in currentModel.modelRooms)
{
int missinglargest = 0;
IEnumerable <int> enumerable = fullist.Except(currentModel.modelRooms.Select(i => i.GetNumberAsInt()));
if (enumerable.Any())
{
missinglargest = enumerable.Max();
}
if (room.GetNumberAsInt() < missinglargest || room.GetNumberAsInt() == 2)
{
continue;
}
MyRoom room2;
Model m_mod2 = currentModel.DeepCopy(room, out room2);
foreach (MyLine line in room2.BoundaryLines)
{
line.relatedRooms.Remove(room2);
}
m_mod2.modelRooms.Remove(room2);
foreach (MyLine line in m_mod2.modelLines)
{
line.relatedRooms.Remove(room2);
}
List <MyLine> toremove = new List <MyLine>();
foreach (MyLine line in m_mod2.modelLines)
{
if (!line.relatedRooms.Any())
{
toremove.Add(line);
}
}
foreach (MyLine line in toremove)
{
m_mod2.modelLines.Remove(line);
foreach (var rooms in model.modelRooms)
{
rooms.BoundaryLines.Remove(line);
}
line.StartMyPoint.RelatedLines.Remove(line);
line.EndMyPoint.RelatedLines.Remove(line);
}
returns.Add(m_mod2);
}
return(returns);
}
