/*private async void hideUI(bool res)
* {
* if (res)
* {
* RadioButtonKurz.Visibility = Visibility.Collapsed;
* RadioButtonMittel.Visibility = Visibility.Collapsed;
* RadioButtonLang.Visibility = Visibility.Collapsed;
*
* await Task.Delay(100);
*
* }
* else
* {
* RadioButtonKurz.Visibility = Visibility.Visible;
* RadioButtonMittel.Visibility = Visibility.Visible;
* RadioButtonLang.Visibility = Visibility.Visible;
* }
* }*/
private async void evaluateClick()
{
// speicher den Zustand und die Zeit die benötigt wurde um das Signal zu erkennen
rootPage.setup.saveSignalTyp(untypedSignal, this.endTime - this.startTime, countReplay);
countReplay = 0;
// kurzes Delay (in ms)
await Task.Delay(400);
// setze den Wert wieder auf ungesetzt (also leere die Eingabe auf dem Bildschirm)
switch (untypedSignal)
{
case SignalTyp.KURZ:
RadioButtonKurz.IsChecked = false;
break;
case SignalTyp.MITTEL:
RadioButtonMittel.IsChecked = false;
break;
case SignalTyp.LANG:
RadioButtonLang.IsChecked = false;
break;
default:
Debug.WriteLine("ERROR in der -EvaluateSignal- Methode");
break;
}
// setzte den Wert wieder auf NODATA
untypedSignal = SignalTyp.NODATA;
}
/**
* Konstruktor des Signals
* @param sType Signaltyp
* @param sTime Zeit in ms, die sich in dem Intervall des Signaltyps befinden soll
*/
public Signal(SignalTyp sType, int sTime)
{
type = sType;
time = sTime;
//cSignalCode = new char [(end/5)];
init();
}
// zeigt den Text an, nach dem auf ein Button gedrueckt wurde
private void afterClick(SignalTyp type)
{
countButtonClicks++;
sList.Add(type);
long tempTime = Environment.TickCount;
sTime.Add(tempTime - this.startTime);
printOnScreen();
if (countButtonClicks < (signalList.Count / 2))//5)
{
// Wenn es kleiner als 5 Zeichen ist, dann soll erst noch weiter bewertet werden
commitButton.Visibility = Visibility.Collapsed;
}
else
{
// wenn es 5 Zeichen sind, dann sollen die Buttons verschwinden und der Commit Button erscheinen
// erst wenn auf den Comitt Button gedrück wird, dann soll es gespeichert werden
// Committ Button aktivieren
commitButton.Visibility = Visibility.Visible;
// die 3 Buttons disablen
ButtonKurz.Visibility = Visibility.Collapsed;
ButtonMittel.Visibility = Visibility.Collapsed;
ButtonLang.Visibility = Visibility.Collapsed;
}
}
// generiert ein generiertes Signal anhand dem Typen
private Signal generateSignal(int typ)
{
SignalTyp type = (SignalTyp)typ;
Signal s = new Signal();
switch (type)
{
case SignalTyp.KURZ:
// Typ, Random Zeit, Random Strength, iBegin, iEnd
s = new Signal(SignalTyp.KURZ, TimeK, (SignalStrength)StrengthK, KTime[0], KTime[1]);
break;
case SignalTyp.MITTEL:
// Typ, Random Zeit, Random Strength, iBegin, iEnd
s = new Signal(SignalTyp.MITTEL, TimeM, (SignalStrength)StrengthM, MTime[0], MTime[1]);
break;
case SignalTyp.LANG:
// Typ, Random Zeit, Random Strength, iBegin, iEnd
s = new Signal(SignalTyp.LANG, TimeL, (SignalStrength)StrengthL, LTime[0], LTime[1]);
break;
default:
Debug.WriteLine("Error in der generateSignal Methode in Muster.cs");
break;
}
return(s);
}
private void RadioButtonKurz_Clicked(object sender, RoutedEventArgs e)
{
this.endTime = Environment.TickCount;
RadioButtonKurz.IsChecked = true;
untypedSignal = SignalTyp.KURZ;
afterClick(true);
}
private void RadioButtonLang_Click(object sender, RoutedEventArgs e)
{
endTimeSignal = Environment.TickCount;
RadioButtonLang.IsChecked = true;
untypedSignal = SignalTyp.LANG;
bType = true;
afterClick();
}
public void setSignalAlgo(SignalTyp signalTyp, SignalRating rating, SignalStrength signalStrength, long timeSignal, long timeRating, long timeStrength, int countReplay)
{
signal.setRecognizeType(signalTyp);
signal.setTimeToRecognizeType(timeSignal);
signal.setRating(rating);
signal.setTimeToRecognizeRating(timeRating);
signal.setRecognizeStrength(signalStrength);
signal.setTimeToRecognizeStrength(timeStrength);
signal.setAlgoCountReplay(countReplay);
}
/**
* Konstruktor des Signals
* @param sType Signaltyp
* @param sTime Zeit in ms, die sich in dem Intervall des Signaltyps befinden soll
*/
public Signal(SignalTyp sType, int sTime, SignalStrength sStrength)
{
// alle Variablen initialisieren
defaultVariables();
// setzen der Variablen
this.type = sType;
this.time = sTime;
this.strength = sStrength;
//cSignalCode = new char [(end/5)];
init();
}
/**
* Dieser Konstruktor ist extra fuer den letzten Schritt (erkennungs Page gedacht)
**/
public Signal(SignalTyp type, int sTime, SignalStrength strength, int begin, int end)
{
defaultVariables();
// setzen der Variablen
this.type = type;
this.time = sTime;
this.strength = strength;
this.begin = begin;
this.end = end;
// init beinhaltet noch eine right Time Methode die ich nicht benoetige daher die einzelnen Aufrufe.
calculate();
createString();
}
private void setVariablesDefault()
{
untypedSignal = SignalTyp.NODATA;
signalRating = SignalRating.NODATA;
signalStrength = SignalStrength.NODATA;
bType = false;
bRating = false;
bStrength = false;
startTime = Environment.TickCount;
endTimeSignal = -1;
endTimeRating = -1;
endTimeStrength = -1;
diffTimeSignal = -1;
diffTimeRating = -1;
diffTimeStrength = -1;
countReplay = 0;
}
// setzt alle Signale der Liste mit Generierten Werten
private List <Signal> setAllValuesGeneriert(List <Signal> list)
{
List <Signal> newList = new List <Signal>();
Signal s = new Signal();
for (int i = 0; i < list.Count; i++)
{
if ((i % 2) == 0) // wenn es ein Signal ist, dann soll der Wert angepasst werden
{
SignalTyp type = list[i].getType();
switch (type)
{
case SignalTyp.KURZ:
s = new Signal(SignalTyp.KURZ, TimeK, (SignalStrength)StrengthK, KTime[0], KTime[1]);
//list[i].setTime(TimeK);
//list[i].setStrength((SignalStrength)StrengthK);
break;
case SignalTyp.MITTEL:
s = new Signal(SignalTyp.MITTEL, TimeM, (SignalStrength)StrengthM, MTime[0], MTime[1]);
//list[i].setTime(TimeM);
//list[i].setStrength((SignalStrength)StrengthM);
break;
case SignalTyp.LANG:
s = new Signal(SignalTyp.LANG, TimeL, (SignalStrength)StrengthL, LTime[0], LTime[1]);
//list[i].setTime(TimeL);
//list[i].setStrength((SignalStrength)StrengthL);
break;
default:
Debug.WriteLine("Error in der setAllValuesGeneriert Methode in Muster.cs");
break;
}
}
else // Signal der Pause
{
int t = list[i].getTime();
s = new Signal(SignalTyp.KURZ, t, list[i].getStrength(), t - 20, t + 20);
}
newList.Add(s);
}
return(newList);
}
// setzt alle Signale der Liste mit Standardwerten
private List <Signal> setAllValuesStandard(List <Signal> list)
{
List <Signal> newList = new List <Signal>();
Signal s = new Signal();
for (int i = 0; i < list.Count; i++)
{
if ((i % 2) == 0) // wenn es ein Signal ist, dann soll der Wert angepasst werden
{
SignalTyp type = list[i].getType();
switch (type)
{
case SignalTyp.KURZ:
s = new Signal(SignalTyp.KURZ, KURZSTANDARD, KURZSTRENGTH, KURZSTANDARD - 20, KURZSTANDARD + 20);
//list[i].setTime(KURZSTANDARD);
//list[i].setStrength(SignalStrength.STRONG);
break;
case SignalTyp.MITTEL:
s = new Signal(SignalTyp.MITTEL, MITTELSTANDARD, MITTELSTRENGTH, MITTELSTANDARD - 20, MITTELSTANDARD + 20);
//list[i].setTime(MITTELSTANDARD);
//list[i].setStrength(SignalStrength.STRONG);
break;
case SignalTyp.LANG:
s = new Signal(SignalTyp.LANG, LANGSTANDARD, LANGSTRENGTH, LANGSTANDARD - 20, LANGSTANDARD + 20);
//list[i].setTime(LANGSTANDARD);
//list[i].setStrength(SignalStrength.STRONG);
break;
default:
Debug.WriteLine("Error in der setAllValuesStandard Methode in Muster.cs");
break;
}
}
else // Pause
{
int t = list[i].getTime();
s = new Signal(SignalTyp.KURZ, t, list[i].getStrength(), t - 20, t + 20);
}
newList.Add(s);
}
return(newList);
}
/**
* initialisiert alle Werte
*/
private void defaultVariables()
{
type = SignalTyp.NODATA;
strength = SignalStrength.NODATA;
recognizeType = SignalTyp.NODATA;
rating = SignalRating.NODATA;
recognizeStrength = SignalStrength.NODATA;
time = -1;
signalCode = "empty";
iNull = -1;
iEins = -1;
begin = -1;
end = -1;
timeToRecognizeType = -1;
timeToRecognizeRating = -1;
timeToRecognizeStrength = -1;
replayCountInitSignalPage = -1;
replayCountAlgoPage = -1;
}
public InitSignalPage()
{
this.InitializeComponent();
// Variablen initialisieren
untypedSignal = SignalTyp.NODATA;
times = new List <long>();
countReplay = 0;
// Erklärungstext aufrufen und Zeit starten
initialize();
/*
* long startTime = Environment.TickCount;
* // Do things
* long endTime = Environment.TickCount;
* Debug.WriteLine(endTime + " benötigte Zeit " + (endTime - startTime) + " ms");
*/
#region UI Initialisierung
FirstLineText.Text = "Bitte bewerten Sie das Signal, wie Sie es empfunden haben.";
#endregion
}
// gibt an welcher Knopf gedrueckt wird und gibt den string zurueck
private string getStringFrom(SignalTyp type)
{
string res = "";
switch (type)
{
case SignalTyp.KURZ:
res = "K";
break;
case SignalTyp.MITTEL:
res = "M";
break;
case SignalTyp.LANG:
res = "L";
break;
default:
Debug.WriteLine("Error in ErrkennungsPage - getStringFrom() Methode ");
break;
}
return(res);
}
/**
* setzt den Typen des Signals
* @param sType ist der Typ der gesetzt werden soll
*/
public void setType(SignalTyp sType)
{
type = sType;
}
public void saveSignalType(SignalTyp signal, long time, int countReplay)
{
population[randomIndex].setSignalType(signal, time, countReplay);
}
public void saveSignalAlgo(SignalTyp signaltyp, SignalRating rating, SignalStrength signalStrength, long timeSignal, long timeRating, long timeStrength, int countReplay)
{
population[randomIndex].setSignalAlgo(signaltyp, rating, signalStrength, timeSignal, timeRating, timeStrength, countReplay);
}
/*public int getInputType() {
* return inputType;
* }*/
public void setSignalType(SignalTyp signalTyp, long time, int countReplay)
{
signal.setType(signalTyp);
signal.setTimeToRecognizeType(time);
signal.setReplayInitSignal(countReplay);
}
private int end; // MaximalZeit für den Typ von Signal
/**
* erzeugt ein Signal, dass mit der genannten Zeit
* @param sTime Zeit in ms
*/
public Signal(int sTime)
{
type = SignalTyp.NODATA;
time = sTime;
init();
}
public void saveSignalAlgo(SignalTyp untypedSignal, SignalRating signalRating, SignalStrength signalStrength,
long timeSignal, long timeRating, long timeStrength, int countReplay)
{
pAlgo.saveSignalAlgo(untypedSignal, signalRating, signalStrength, timeSignal, timeRating, timeStrength, countReplay);
}
/**
* setzt den erkannten Typen
*/
public void setRecognizeType(SignalTyp recognizedTyp)
{
this.recognizeType = recognizedTyp;
}
// diese Methode liefert das speichert den näachsten Signaltypen und die Zeit die benötigt wurde um es zu erkennen
public void saveSignalTyp(SignalTyp signalTyp, long time, int countReplay)
{
p.saveSignalType(signalTyp, time, countReplay);
}
