/*********************************************************************/
/// <summary>
/// Sucht nach einem Attribut, welches für den Knoten optimal ist
/// </summary>
/// <param name="vertex">Vertex für den der Typ gefunden werden soll</param>
/// <returns>gefundener AttributTyp</returns>
private CAttributeType findBestAttribute(CTreeVertex vertex)
{
double bestEntropy = double.MaxValue;
CAttributeType bestAttrType = null;
List <CAttributeType> attrTypeList = mTableLogic.getAttributeTypes();
foreach (CAttributeType type in attrTypeList)
{
if ((type.Used == true) && (type.TargetAttribute == false) &&
(mTreeLogic.isAttributeUsedByParent(vertex, type) == false))
{
mTreeLogic.setVertexAttribute(vertex, type);
mTreeLogic.updateVertexValues();
// Verhindern das ein Kindknoten alle Einträge enthält wie der Parent,
// dann können wir uns das auch sparen
if (childDoesOwnAllParentObjects(vertex) == false)
{
double entropy = calculateWeightedEntropy(vertex);
if (entropy < bestEntropy)
{
bestEntropy = entropy;
bestAttrType = type;
}
}
}
}
return(bestAttrType);
}
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="attributyType">Typ der Spalte</param>
public CTableColumn(CAttributeType attributyType)
{
mAttributeType = attributyType;
Header = attributyType.Name;
Binding = new Binding("[" + attributyType.Index + "].TableValue");
}
/*********************************************************************/
/// <summary>
/// fügt eine zusätzliche Spalte in die Tabelle ein
/// </summary>
/// <param name="name"></param>
/// <param name="targetAttribute"></param>
/// <returns></returns>
public CAttributeType addTableAttribute(string sName, bool bTargetAttribute = false)
{
if (isAttributExistent(sName) == false)
{
CAttributeType attrType = getNextAvailableAttibuteType();
if (attrType != null)
{
attrType.setUsed(sName, E_DATATYPE.E_STRING, bTargetAttribute);
return(attrType);
}
}
return(null);
#region altcode .. kann eventuell noch gebraucht werden
/*
* string sSQLCommand = "UPDATE " + CTableConstants.TABLE_ATTRIBUTE_TYPES + " SET " +
* CTableConstants.ATTR_TYPES_NAME + "='" + sName + "', " +
* CTableConstants.ATTR_TYPES_USED + "=1, " +
* CTableConstants.ATTR_TYPES_TARGET_ATTR + "=" + Convert.ToInt16(bTargetAttribute) +
* " WHERE " + CTableConstants.ATTR_TYPES_INTERNAL_NAME + "='" + sInternalName + "'";
* mConnection.sqlExecuteStatement(sSQLCommand);
*
* return true;
*/
#endregion
}
/*********************************************************************/
/// <summary>
/// Setzt für einen Vertex das Attribut welches dieser Repräsentiert
/// </summary>
/// <param name="vertex">Vertex dessen Attribut geändert werden soll</param>
/// <param name="attributeType">neues Attribut des Vertex</param>
public bool setVertexAttribute(CTreeVertex vertex, CAttributeType attributeType)
{
if (mTreeLogic.setVertexAttribute(vertex, attributeType) == true)
{
mTreeLogic.updateVertexValues();
return(true);
}
return(false);
}
/*********************************************************************/
/// <summary>
/// Fügt eine Spalte für das Datagrid ein, aus einem AttributTypen
/// </summary>
/// <param name="columnData">Attributtype für den eine Spalte eingefügt
/// werden soll</param>
void addDatagridColumn(CAttributeType columnData)
{
if (columnData != null)
{
DataGridTextColumn column = new CTableColumn(columnData);
//column.Header = columnData.Name;
//column.Binding = new Binding("[ " + columnData.Index + "].TableValue");
datagrid1.Columns.Add(column);
}
}
public void testTypes()
{
CAttributeType typeNumber = new CAttributeType(0);
Assert.IsTrue(typeNumber.Used == false);
typeNumber.setUsed("Number", E_DATATYPE.E_INT, true);
Assert.IsTrue(typeNumber.DataType == E_DATATYPE.E_INT);
Assert.IsTrue(typeNumber.Name == "Number");
Assert.IsTrue(typeNumber.TargetAttribute == true);
}
public void testAttributeGeneration()
{
CAttributeType typeNumber = new CAttributeType(0);
typeNumber.setUsed("Number", E_DATATYPE.E_INT, false);
CAttributeType typeString = new CAttributeType(0);
typeString.setUsed("String", E_DATATYPE.E_STRING, false);
CAttributeType typeFloat = new CAttributeType(0);
typeFloat.setUsed("Float", E_DATATYPE.E_FLOAT, false);
// Attributwerte mit unterschiedlichen Typen erstellen
CAttributeValue[] values = new CAttributeValue[10];
for (int i = 0; i < 10; i++)
{
switch (i % 2)
{
case 0:
values[i] = new CAttributeValue(typeString, i.ToString(), i.ToString(), null);
break;
case 1:
values[i] = new CAttributeValue(typeNumber, i.ToString(), i.ToString(), null);
break;
case 2:
values[i] = new CAttributeValue(typeFloat, i.ToString(), i.ToString(), null);
break;
}
}
// testen ob die Werte korrekt eingetragen wurden
for (int i = 0; i < 10; i++)
{
switch (values[i].AttributeType.DataType)
{
case E_DATATYPE.E_STRING:
Assert.IsTrue(values[i].StringValue == i.ToString());
break;
case E_DATATYPE.E_INT:
Assert.IsTrue(values[i].IntegerValue == i);
break;
case E_DATATYPE.E_FLOAT:
Assert.IsTrue(values[i].FloatValue == i);
break;
}
}
}
/*********************************************************************/
/// <summary>
/// Erstellt einen Vertex und fügt ihn in den Baum ein.
/// </summary>
/// <param name="parent">Übergeordneter Knoten im Baum</param>
/// <param name="attributeType">Attributtyp nach dem aufgeteilt werden soll</param>
/// <returns>Hinzugefügter Vertex</returns>
public CTreeVertex addVertex(CTreeVertex parent, CAttributeType attributeType = null)
{
CTreeVertex vertex = new CTreeVertex(parent, mGraph, attributeType);
mVertexList.Add(vertex);
mGraph.AddVertex(vertex);
if (parent != null)
{
parent.ChildList.Add(vertex);
}
return(vertex);
}
/*********************************************************************/
/// <summary>
/// Setzt für einen Vertex das Attribut welches dieser Repräsentiert
/// </summary>
/// <param name="vertex">Vertex dessen Attribut geändert werden soll</param>
/// <param name="attributeType">neues Attribut des Vertex</param>
internal bool setVertexAttribute(CTreeVertex vertex, CAttributeType attributeType)
{
// sollte das Attribut bereits von einem Parent-Knoten verwendet werden
// darf der Benutzer dieser Attribut nicht verwenden
if (isAttributeUsedByParent(vertex, attributeType) == true)
{
return(false);
}
// wenn das Attribut bereits das ist welches der Vertex repräsentiert,
// müssen wir nichts machen.
if (vertex.AttributeType != attributeType)
{
mTreeHandler.removeChildVertices(vertex);
// Attribut des Vertex setzen
vertex.AttributeType = attributeType;
if (vertex.AttributeType != null)
{
// TODO Kindknoten erzeugen und Verbindungen anlegen:
//diskreter Wert (Splitwerte zurzeit nicht verfügbar -> ||true)
if (attributeType.DataType.Equals(E_DATATYPE.E_STRING) || true)
{
//alte Children löschen
mTreeHandler.removeChildVertices(vertex);
//Werte für die Kindknoten erhalten
CValueList childVertices = mTableLogic.getChildVertices(vertex);
//Knoten und Verbindungen hinzufügen
foreach (CAttributeValue value in childVertices)
{
CTreeVertex childVertex = addVertex(vertex, null);
childVertex.ParentEdge = addEdge(vertex, childVertex, value);
}
}
else //stetiger Wert
{
//Splitwert abfragen
//Datenbankabfrage, GROUP BY?
//
}
}
return(true);
}
return(false);
}
/*********************************************************************/
/// <summary>
/// Setzt das Zielattribut auf den übergebenen Typen
/// </summary>
/// <param name="targetAttributeType">Attributtyp der zum Zielattribut
/// werden soll</param>
/// <returns>Erfolg des Setztens</returns>
public bool setTargetAttribute(CAttributeType targetAttributeType)
{
if (isValidTargetAttribut(targetAttributeType) == false)
{
return(false);
}
foreach (CAttributeType attributeType in mAttributeTypeList)
{
attributeType.TargetAttribute = false;
}
targetAttributeType.TargetAttribute = true;
return(true);
}
private static CAttributeType getTargetAttribute(Logic.CTableLogic tableLogic)
{
List <CAttributeType> attributeTypeList = tableLogic.getAttributeTypes();
CAttributeType targetAttribute = null;
foreach (CAttributeType type in attributeTypeList)
{
if (type.TargetAttribute == true)
{
targetAttribute = type;
break;
}
}
return(targetAttribute);
}
/*********************************************************************/
/// <summary>
/// Prüft ob ein AttributType bereits von ein ParentKnoten des
/// übergebenen Kontens verwendet wird
/// </summary>
/// <param name="vertex">Vertex dessen Parentes geprüft werden</param>
/// <param name="type">zu Prüfender Type</param>
/// <returns>True - wird von Parent benutzt, False - sonst</returns>
public bool isAttributeUsedByParent(CTreeVertex vertex, CAttributeType type)
{
// Durch alle Parentelemente des Knotenes gehen und prüfen ob dieses Attribut
// nicht schon verwendet wurde
CTreeVertex parent = vertex.ParentVertex;
while (parent != null)
{
if (parent.AttributeType == type)
{
return(true);
}
parent = parent.ParentVertex;
}
return(false);
}
public void TesthandleDataTypeofValue()
{
CAttributeType typeNumber = new CAttributeType(0);
typeNumber.setUsed("Number", E_DATATYPE.E_INT, true);
CAttributeValue myValue = new CAttributeValue(typeNumber, "1", "1", null);
CDataTypeChecker checker = new CDataTypeChecker();
checker.handleDataTypeofValue(myValue, "1.3");
Assert.IsTrue(myValue.AttributeType.DataType == E_DATATYPE.E_FLOAT, "float hinzufügen");
checker.handleDataTypeofValue(myValue, "2");
Assert.IsTrue(myValue.AttributeType.DataType == E_DATATYPE.E_INT, "int hinzufügen");
checker.handleDataTypeofValue(myValue, "wer");
Assert.IsTrue(myValue.AttributeType.DataType == E_DATATYPE.E_STRING, "string hinzufügen");
}
public void testValuesList()
{
CValueList valueList = new CValueList();
CAttributeType typeNumber = new CAttributeType(0);
typeNumber.setUsed("Number", E_DATATYPE.E_INT, false);
CAttributeType typeString = new CAttributeType(0);
typeString.setUsed("String", E_DATATYPE.E_STRING, false);
CAttributeType typeFloat = new CAttributeType(0);
typeFloat.setUsed("Float", E_DATATYPE.E_FLOAT, false);
// Attributwerte mit unterschiedlichen Typen erstellen und in die Liste einfügen
for (int i = 0; i < 10; i++)
{
switch (i % 2)
{
case 0:
valueList.addValue(new CAttributeValue(typeString, i.ToString(), i.ToString(), null));
break;
case 1:
valueList.addValue(new CAttributeValue(typeNumber, i.ToString(), i.ToString(), null));
break;
case 2:
valueList.addValue(new CAttributeValue(typeFloat, i.ToString(), i.ToString(), null));
break;
}
}
Assert.IsTrue(valueList.Size == 10);
// Zugriff per foreach auf Elemente der Liste
foreach (CAttributeValue value in valueList)
{
value.ToString();
}
// Zugriff per Index auf ein Element
valueList[0].ToString();
}
/*********************************************************************/
/// <summary>
/// führt den TDIDT Algorithmus für einen Knoten durch und sucht nach
/// dem Optimalen Attribut für diesen Knoten und seine Kindknoten
/// </summary>
/// <param name="vertex"></param>
private void doTDIDT(CTreeVertex vertex)
{
mTreeLogic.updateVertexValues();
if (stopCriteriaMet(vertex) == false)
{
// wir suchen das Optimale Attribut für diesen Knoten
CAttributeType bestType = findBestAttribute(vertex);
// nur wenn noch Attribute vorhanden sind machen wir weiter
// if (bestType != null)
{
mTreeLogic.setVertexAttribute(vertex, bestType);
foreach (CTreeVertex child in vertex.ChildList)
{
doTDIDT(child);
}
}
}
}
private void updateVertexClassCount(CTreeVertex vertex, Logic.CTableLogic tableLogic)
{
CTableEntryList entryList = tableLogic.getFilteredTableData(vertex);
CAttributeType targetAttribute = getTargetAttribute(tableLogic);
int[] counts = new int[2];
counts[CTreeVertex.YES_INDEX] = 0;
counts[CTreeVertex.NO_INDEX] = 0;
if (targetAttribute != null)
{
bool bFirst = true;
int targetAttributeIndex = 0;
foreach (CTableEntry entry in entryList)
{
if (bFirst == true)
{
for (int i = 0; i < entry.Size; i++)
{
if (entry[i].AttributeType.InternalName == targetAttribute.InternalName)
{
targetAttributeIndex = i;
}
}
bFirst = false;
}
// TODO Bei Zielattr nicht nur Binär Verzweigen
if (entry[targetAttributeIndex].TableValue == "j")
{
counts[CTreeVertex.YES_INDEX]++;
}
else if (entry[targetAttributeIndex].TableValue == "n")
{
counts[CTreeVertex.NO_INDEX]++;
}
}
}
vertex.CountObjectsPerClass = counts;
}
public void ItemTestIndex()
{
CTableEntryList list = new CTableEntryList();
CAttributeType attrType = new CAttributeType(0);
attrType.setUsed("asd", E_DATATYPE.E_STRING, false);
for (int i = 0; i < 10; i++)
{
CTableEntry entry = new CTableEntry(i.ToString());
entry.addValue(new CAttributeValue(attrType, i.ToString(), i.ToString(), null));
list.addEntry(entry);
}
CTableEntry singleEntry;
singleEntry = list[5];
Assert.IsTrue(singleEntry.Size == 1);
Assert.IsTrue(singleEntry[0].EntryIndex == "5");
Assert.IsTrue(singleEntry[0].StringValue == "5");
}
private bool isValidTargetAttribut(CAttributeType type)
{
bool bRet = true;
string sSqlCommand = "SELECT DISTINCT " + type.InternalName + " FROM " + CTableConstants.TABLE_ATTRIBUTES;
SQLiteDataReader reader;
CValueList entryList = new CValueList();
if (mConnection.sqlRequestStatement(sSqlCommand, out reader) == true)
{
while (reader.Read() == true)
{
string sValue = reader[0] as string;
if ((sValue != "j") && (sValue != "n"))
{
bRet = false;
}
}
closeReader(reader);
}
return(bRet);
}
protected CTreeVertex addVertex(CTreeVertex parent, CAttributeType type = null)
{
return(mTreeHandler.addVertex(parent, type));
}
/*protected int mNumObjects;
* protected int mNumObjectsYes;
* protected int mNumObjectsNo;
* protected double mEntropy;
*
* public void setDemoData(string vertexName, int countObjects, int countObjectsYes, int countObjectsNo, double entropy)
* {
* if (vertexName != "")
* {
* mAttributeType = new CAttributeType(0);
* mAttributeType.Name = vertexName;
* }
*
* mNumObjects = countObjects;
* mNumObjectsYes = countObjectsYes;
* mNumObjectsNo = countObjectsNo;
* mEntropy = entropy;
* }*/
#endregion
/*********************************************************************/
/// <summary>
/// Konstruktor
/// </summary>
/// <param name="parent">Übergeordneter Knoten im Baum</param>
/// <param name="attributeType">Attributtyp nach dem aufgeteilt werden soll</param>
public CTreeVertex(CTreeVertex parent, CTreeGraph graph, CAttributeType attributeType = null)
{
mParentVertex = parent;
mGraph = graph;
AttributeType = attributeType;
}
/*********************************************************************/
/// <summary>
/// Fügt einen Knoten zum Graphen hinzu
/// </summary>
/// <param name="parent">Parent-Knoten des Knotens</param>
/// <param name="type">Typ des Attributes welches der Knoten
/// repräsentiert</param>
/// <returns>erstellter Vertex</returns>
public CTreeVertex addVertex(CTreeVertex parent, CAttributeType type)
{
return(mActiveTree.addVertex(parent, type));
}
/*********************************************************************/
/// <summary>
/// Setzt das Zielattribut auf den übergebenen Typen
/// </summary>
/// <param name="targetAttributeType">Attributtyp der zum Zielattribut
/// werden soll</param>
/// <returns>Erfolg des Setztens</returns>
public bool setTargetAttribute(CAttributeType targetAttributeType)
{
return(mDBAccess.setTargetAttribute(targetAttributeType));
}
/*********************************************************************/
/// <summary>
/// Wird aufgrufen wenn ein Button von der Tabellenansicht geklickt wurde
/// </summary>
private void RibbonButtonTableView_Click(object sender, RoutedEventArgs e)
{
// Spalte hinzufügen Button
if (sender.Equals(btnAddColumn) == true)
{
string name = Microsoft.VisualBasic.Interaction.InputBox("Geben Sie den Namen des Attributs ein", "Attributname", "");
if (!name.Equals(""))
{
CAttributeType columnData = mBusinessLogic.addAttribute(name);
addDatagridColumn(columnData);
}
}
// selektierte Spalte löschen Button
else if (sender.Equals(btnRemoveColumn) == true)
{
if (datagrid1.CurrentColumn != null)
{
DataGridColumn column = datagrid1.CurrentColumn;
if (mBusinessLogic.removeAttribute((string)column.Header) == true)
{
datagrid1.Columns.Remove(column);
}
}
}
// Neue Zeile hinzufügen
else if (sender.Equals(btnAddRow) == true)
{
mTableEntryList.addEntry(mBusinessLogic.addDataset());
}
// Selektierte Zeile Löschen
else if (sender.Equals(btnRemoveRow) == true)
{
if (datagrid1.SelectedItem != null)
{
CTableEntry selectedEntry = (CTableEntry)datagrid1.SelectedItem;
if (mBusinessLogic.removeDataset(selectedEntry) == true)
{
mTableEntryList.Remove(selectedEntry);
}
}
}
// Selektierte Zeile als Zielattribut setzen
else if (sender.Equals(btnSetTargetAttribute) == true)
{
CTableColumn selectedColumn = datagrid1.CurrentColumn as CTableColumn;
if (selectedColumn != null)
{
if (mBusinessLogic.setTargetAttribute(selectedColumn.ColumnDataType) == true)
{
foreach (CTableColumn column in datagrid1.Columns)
{
//column.HeaderStyle = FindResource("DefaultColumnHeaderStyle") as Style;
column.HeaderStyle = null;
}
selectedColumn.HeaderStyle = FindResource("TargetValueColumnHeaderStyle") as Style;
CTableEntry entry = (CTableEntry)datagrid1.CurrentItem;
setTreeViewsEnabled(true);
}
else
{
MessageBox.Show("Das Attribut \"" + selectedColumn.ColumnDataType.Name + "\" kann nicht als Zielattribut gesetzt werden, da nur Datensätze mit den Einträgen \"j\" und \"n\" zugelassen sind.", "Ungültiges Zielattribut", MessageBoxButton.OK, MessageBoxImage.Warning);
}
}
}
}
/*********************************************************************/
/// <summary>
/// Setzt das Zielattribut auf den übergebenen Typen
/// </summary>
/// <param name="cAttributeType">Attributtyp der zum Zielattribut werden soll</param>
/// <returns>Erfolg des Setztens</returns>
public bool setTargetAttribute(CAttributeType targetAttributeType)
{
mTreeLogic.setTableSetupChanged();
return(mTableLogic.setTargetAttribute(targetAttributeType));
}