praktikum-holons/src/algorithms/geneticAlgorithm/holegGA/GenAlgoHandler.java

package algorithms.geneticAlgorithm.holegGA;

import java.util.ArrayList;

import classes.AbstractCpsObject;
import classes.Category;
import classes.CpsEdge;
import classes.Position;
import ui.controller.Control;
import ui.model.Model;
import algorithms.geneticAlgorithm.Components.GAResultListener;
import algorithms.geneticAlgorithm.Components.GeneticAlgo;
import algorithms.geneticAlgorithm.Components.Selections.TournamentRankSelection;
import algorithms.geneticAlgorithm.Components.Selections.TournamentSelectionStrategy;
import algorithms.geneticAlgorithm.holegGA.Components.HolegCrossover;
import algorithms.geneticAlgorithm.holegGA.Components.HolegFactory;
import algorithms.geneticAlgorithm.holegGA.Components.HolegFittnessFkt;
import algorithms.geneticAlgorithm.holegGA.Components.HolegFittnessScenario;
import algorithms.geneticAlgorithm.holegGA.Components.HolegGeneration;
import algorithms.geneticAlgorithm.holegGA.Components.HolegIndividual;
import algorithms.geneticAlgorithm.holegGA.Components.HolegMutation;

public class GenAlgoHandler {
	
	ArrayList<GAResultListener<HolegIndividual>> listeners = new ArrayList<GAResultListener<HolegIndividual>>();
	HolegFactory factory;
	Control controller;
	Model model;
	int genCount;
	public int popSize;
	public int tournamentSize;
	public double tournamentProb;
	boolean onlyNodes;
	GeneticAlgo<HolegIndividual> holegGA;
	TournamentRankSelection<HolegIndividual> tRS;
	HolegMutation hM;
	HolegCrossover hC;
	ArrayList<AbstractCpsObject> objSpace;
	
	public GenAlgoHandler(Control controller, Model model){
		this.controller = controller;
		this.model = model;
		genCount = 1;
		popSize = 100;
		objSpace = new ArrayList<AbstractCpsObject>();
		for(Category cat : model.getCategories()){
			for(AbstractCpsObject obj : cat.getObjects()){
				objSpace.add(obj);
			}
		}
		ArrayList<AbstractCpsObject> origin = model.getObjectsOnCanvas();
		factory = new HolegFactory(objSpace, 0, 0);
		factory.originObjects = origin;
		onlyNodes = false;
		
		hC = new HolegCrossover();
		//HolegFittnessFkt hF = new HolegFittnessFkt(controller);
		HolegFittnessScenario hF = new HolegFittnessScenario(controller);
		hM = new HolegMutation(0.01);
		hM.setObjectSpace(objSpace);
		tRS = new TournamentRankSelection<HolegIndividual>();
		holegGA = new GeneticAlgo<HolegIndividual>(tRS, hC, hM, hF, factory, popSize);
	}
	
	public void createGeneration(int objAmount, int edgeAmount){
		factory.maxObjects = objAmount;
		factory.maxConnections = edgeAmount;
		factory.onlyNodes = onlyNodes;
		holegGA.popSize = popSize;
		tRS.tournamentSize = tournamentSize;
		
		if(genCount == 1){
			holegGA.generateRandomPopulation();
			HolegGeneration holegGen = new HolegGeneration(genCount);
			holegGen.setGeneration(holegGA.getSortedPopulation());
			addPopulationListeners(holegGen);
			//addPopulationListeners(genCount, sortPopulation(holegGA.getPopulation()));
			//addPopulationListeners(genCount, holegGA.getPopulation());
		}else{
			holegGA.createNextGeneration();
			HolegGeneration holegGen = new HolegGeneration(genCount);
			holegGen.setGeneration(holegGA.getSortedPopulation());
			addPopulationListeners(holegGen);
			//addPopulationListeners(genCount, sortPopulation(holegGA.getPopulation()));
		}
		genCount++;
	}
	
	public void mutationTest(int objAmount, int edgeAmount){
		factory.maxObjects = objAmount;
		factory.maxConnections = edgeAmount;
		factory.onlyNodes = onlyNodes;
		HolegIndividual parent = factory.createRandomIndividual();
		ArrayList<HolegIndividual> jo = new ArrayList<HolegIndividual>();
		jo.add(parent);
		jo.add(parent);
		HolegGeneration joGen = new HolegGeneration(genCount);
		joGen.setGeneration(jo);
		addPopulationListeners(joGen);
		genCount++;
		
		ArrayList<HolegIndividual> jo2 = new ArrayList<HolegIndividual>();
		HolegIndividual removeObject = hC.crossOver(jo).get(0);
		HolegIndividual addObject = hC.crossOver(jo).get(0);
		HolegIndividual changeObject = hC.crossOver(jo).get(0);
		HolegIndividual removeEdge = hC.crossOver(jo).get(0);
		HolegIndividual addEdge = hC.crossOver(jo).get(0);
		HolegIndividual changeEdge = hC.crossOver(jo).get(0);
		hM.removeObject(removeObject);
		hM.addObject(addObject);
		hM.changeObject(changeObject);
		hM.removeEdge(removeEdge);
		hM.addEdge(addEdge);
		hM.changeEdge(changeEdge);
		jo2.add(removeObject);
		jo2.add(addObject);
		jo2.add(changeObject);
		jo2.add(removeEdge);
		jo2.add(addEdge);
		jo2.add(changeEdge);
		HolegGeneration jo2Gen = new HolegGeneration(genCount);
		jo2Gen.setGeneration(jo2);
		addPopulationListeners(jo2Gen);
		genCount++;
	}
	
	public void drawIndividual(HolegIndividual hI){
		if(hI.drawn){
			//draws Individual with the positions in the objects
			drawIndividualWithPos(hI);
		}else{
			//draws Individual as a default grid
			drawIndividualWithoutPos(hI);
			hI.drawn = true;
		}
	}
	
	public void drawIndividualWithPos(HolegIndividual hI){
		model.setObjectsOnCanvas(new ArrayList<AbstractCpsObject>());
		model.setEdgesOnCanvas(new ArrayList<CpsEdge>());
		
		for(int i = 0; i < hI.getIndexes().size(); i++){
			controller.addObjectCanvas(hI.getObjectAt(i));
		}
		
		for(CpsEdge e : hI.getEdges()){
			controller.addEdgeOnCanvas(e);
		}
	}
	
	public void drawIndividualWithoutPos(HolegIndividual hI){
		model.setObjectsOnCanvas(new ArrayList<AbstractCpsObject>());
		model.setEdgesOnCanvas(new ArrayList<CpsEdge>());
		
		int originBound = (int) Math.ceil(Math.sqrt(hI.originIndexes.size()));
		int row = -1;
		
		int x = 50;
		int y = 50;
		int dist = 100;
		boolean isX = true;
		
		int allBound = (int) Math.ceil(Math.sqrt(hI.indexes.size()));
		
		ArrayList<ArrayList<Integer>> objectField = new ArrayList<ArrayList<Integer>>();
		for(int i = 0; i < hI.originIndexes.size(); i++){
			if(i % originBound == 0){
				row++;
				objectField.add(new ArrayList<Integer>());
			}
			objectField.get(row).add(hI.originIndexes.get(i));
		}
		
		row = 0;
		for(int j = hI.originIndexes.size(); j < hI.indexes.size(); j++){
			boolean inserted = false;
			while(!inserted){
				if(objectField.size() <= row){
					objectField.add(new ArrayList<Integer>());
					objectField.get(row).add(hI.indexes.get(j));
					inserted = true;
				}else{
					if(objectField.get(row).size() < allBound){
						objectField.get(row).add(hI.indexes.get(j));
						inserted = true;
					}else{
						row++;
					}
				}
			}
		}
		
		for(int k = 0; k < objectField.size(); k++){
			for(int l = 0; l < objectField.get(k).size(); l++){
				AbstractCpsObject toDraw = hI.getObjectWithIndex(objectField.get(k).get(l));
				toDraw.setPosition(new Position(x + (l*dist), y +(k*dist)));
				controller.addObjectCanvas(toDraw);
			}
		}
		
		for(CpsEdge e : hI.getEdges()){
			controller.addEdgeOnCanvas(e);
		}
	}
	
	public void addListener(GAResultListener<HolegIndividual> listener){
		listeners.add(listener);
	}
	
	public void addPopulationListeners(HolegGeneration holegGen){
		for(GAResultListener<HolegIndividual> listener : listeners){
			listener.populationCreated(holegGen);
		}
	}
	
	public ArrayList<HolegIndividual> sortPopulation(ArrayList<HolegIndividual> individuals){
		ArrayList<HolegIndividual> sortedList = new ArrayList<HolegIndividual>();
		for(HolegIndividual hI : individuals){
			for(int i = 0; i <= sortedList.size(); i++){
				if(i == sortedList.size()){
					sortedList.add(hI);
					break;
				}else if(sortedList.get(i).getFittness() < hI.getFittness()){
					sortedList.add(i, hI);
					break;
				}
			}
		}
		return sortedList;
	}
	
	

}