private void saveSolutions()
{
Selection selection = (Selection)Selection.where (new Query("Selection").addTypeQuery(TypeQuery.select)
.addCondition("Name", "=", SelectedSolution), typeof(Selection))[0];
models.TaskTemplate template = (models.TaskTemplate)models.TaskTemplate.getById(selection.TaskTemplateID, typeof(models.TaskTemplate));
models.Parameter parameter = (models.Parameter)models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", Convert.ToString(template.ID)), typeof(models.Parameter))[0];
for (int i = 0; i < SolvingList.Count; i++)
{
var item = SolvingList[i];
SelectionRow sr = new SelectionRow()
{
SelectionID = selection.ID,
Number = i
};
sr.save();
List <string> values = new List <string>();
values.AddRange(item.X.Select(x => x.Value));
values.Add(outputValues[i]);
foreach (string value in values)
{
TaskSLAnswer vp = new TaskSLAnswer()
{
SelectionRowID = sr.ID,
Value = value,
ParameterID = parameter.ID,
LearnedSolverID = this.SelectedLearning.LearnedSolver.ID
};
vp.save();
}
}
}
public List <Entity> getNewParametersForBinarizationType(int oldSelectionId, int newTemplateId, int oldParamId)
{
models.Parameter oldParam = ((models.Parameter)services.DatabaseManager.SharedManager.entityById(oldParamId, typeof(models.Parameter)));
List <string> classes = getClasses(oldSelectionId, newTemplateId, oldParamId);
List <Entity> listNewParams = new List <Entity>(classes.Count);
int index = 0;
foreach (string cl in classes)
{
index++;
models.Parameter parameter = new DataHelper().addParameter(cl, oldParam.Comment, newTemplateId, index, oldParam.IsOutput, TypeParameter.Int);
listNewParams.Add(parameter);
}
DatabaseManager.SharedManager.insertMultipleEntities(listNewParams);
List <Entity> parameters = models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", newTemplateId.ToString()), typeof(models.Parameter));
List <Entity> lst = new List <Entity>();
foreach (Entity en in parameters)
{
if (classes.Contains(((models.Parameter)en).Name))
{
lst.Add(en);
}
}
return(lst);
}
private TypeParameter getTypeParameter(string prepType, int paramId)
{
switch (prepType)
{
case "Линейная нормализация 1 (к float)":
return(TypeParameter.Real);
case "Нелинейная нормализация 2 (к float)":
return(TypeParameter.Real);
case "нормализация 3 (к int)":
return(TypeParameter.Int);
case "бинаризация":
return(TypeParameter.Int);
case "без предобработки":
models.Parameter param = ((models.Parameter)services.DatabaseManager.SharedManager.entityById(paramId, typeof(models.Parameter)));
TypeParameter type = param.Type;
return(type);
default:
return(TypeParameter.Real);
}
}
public ArchiveParameter(models.Parameter par)
{
this.ID = par.ID;
this.Name = par.Name;
this.Index = par.Index;
this.Type = par.Type;
this.Comment = par.Comment;
this.IsOutput = par.IsOutput;
}
private void updateTable(int taskTemplateId)
{
//рисуем заголовки
List <Entity> parameters = models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", taskTemplateId.ToString()), typeof(models.Parameter));
originalColumns = new string[parameters.Count];
for (int i = 0; i < parameters.Count; i++)
{
models.Parameter parameter = (models.Parameter)parameters[i];
originalColumns[i] = parameter.Name;
}
//рисуем содержимое
int rows = 100;
if (CountRows < 100)
{
rows = CountRows;
}
originalData = new string[rows][];
for (int i = 0; i < rows; i++)
{
originalData[i] = new string[parameters.Count];
}
List <Entity> sels = Selection.where (new Query("Selection").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", taskTemplateId.ToString())
.addCondition("Name", "=", SelectionName), typeof(Selection));
if (sels.Count != 0)
{
List <Entity> selectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select)
.addCondition("SelectionID", "=", sels[0].ID.ToString()), typeof(SelectionRow));
int stepRow = 0;
foreach (Entity selRow in selectionRows)
{
List <Entity> valueParam = new List <Entity>();
int selectionRowId = selRow.ID;
int stepParam = 0;
foreach (Entity param in parameters)
{
int paramId = param.ID;
List <Entity> value = ValueParameter.where (new Query("ValueParameter").addTypeQuery(TypeQuery.select)
.addCondition("ParameterID", "=", paramId.ToString()).
addCondition("SelectionRowID", "=", selectionRowId.ToString()), typeof(ValueParameter));
originalData[stepRow][stepParam] = ((ValueParameter)value[0]).Value;
stepParam++;
}
stepRow++;
if (stepRow >= rows)
{
break;
}
}
}
}
public List <string> getClasses(int oldSelectionId, int newTemplateId, int oldParamId)
{
models.Parameter oldParam = ((models.Parameter)services.DatabaseManager.SharedManager.entityById(oldParamId, typeof(models.Parameter)));
List <Entity> oldSelectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select)
.addCondition("SelectionID", "=", oldSelectionId.ToString()), typeof(SelectionRow));
List <string> oldValuesForOldParamId = new List <string>();
foreach (Entity selRow in oldSelectionRows)
{
int selectionRowId = selRow.ID;
List <Entity> value = ValueParameter.where (new Query("ValueParameter").addTypeQuery(TypeQuery.select)
.addCondition("ParameterID", "=", oldParamId.ToString()).
addCondition("SelectionRowID", "=", selectionRowId.ToString()), typeof(ValueParameter));
oldValuesForOldParamId.Add(((ValueParameter)value[0]).Value);
}
EnumeratedParameter p = new EnumeratedParameter(oldValuesForOldParamId);
List <string> classes = p.getClasses();
return(classes);
}
private void updateTable(int taskTemplateId)
{
//рисуем заголовки
List <Entity> parameters = models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", taskTemplateId.ToString()), typeof(models.Parameter));
originalColumns = new string[parameters.Count];
for (int i = 0; i < parameters.Count; i++)
{
models.Parameter parameter = (models.Parameter)parameters[i];
originalColumns[i] = parameter.Name;
}
//рисуем содержимое
List <Entity> sels = Selection.where (new Query("Selection").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", taskTemplateId.ToString())
.addCondition("Name", "=", SelectionName), typeof(Selection));
if (sels.Count != 0)
{
originalData = Selection.valuesOfSelectionId(sels[0].ID);
updatePage();
}
}
public Dictionary <List <Entity>, IParameter> executePreprocessing(int newSelectionId, int oldSelectionId, int oldParamId, string prepType, int parameterPosition, int newParamId)
{
models.Parameter oldParam = ((models.Parameter)DatabaseManager.SharedManager.entityById(oldParamId, typeof(models.Parameter)));
TypeParameter type;
switch (prepType)
{
case "Линейная нормализация 1 (к float)":
type = TypeParameter.Real;
break;
case "Нелинейная нормализация 2 (к float)":
type = TypeParameter.Real;
break;
case "нормализация 3 (к int)":
type = TypeParameter.Int;
break;
case "бинаризация":
type = TypeParameter.Int;
break;
case "без предобработки":
type = oldParam.Type;
break;
default:
type = TypeParameter.Real;
break;
}
List <string> values = new List <string>();
List <Entity> valueParam = new List <Entity>();
List <Entity> oldSelectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select)
.addCondition("SelectionID", "=", oldSelectionId.ToString()), typeof(SelectionRow));
int index = 0;
foreach (Entity entity in oldSelectionRows)
{
int selectionRowId = entity.ID;
List <Entity> list = ValueParameter.where (new Query("ValueParameter").addTypeQuery(TypeQuery.select)
.addCondition("ParameterID", "=", oldParamId.ToString()).
addCondition("SelectionRowID", "=", selectionRowId.ToString()), typeof(ValueParameter));
valueParam = valueParam.Concat(list).ToList();
values.Add(((ValueParameter)valueParam[index]).Value);
index++;
}
List <Entity> valuesForParameter = new List <Entity>();
IParameter p = null;
switch (prepType)
{
case "Линейная нормализация 1 (к float)":
case "Нелинейная нормализация 2 (к float)":
case "нормализация 3 (к int)":
if (oldParam.Type == TypeParameter.Real)
{
p = new RealParameter(values);
valuesForParameter = normalizeValues(valueParam, p, newParamId, newSelectionId, prepType);
}
else if (oldParam.Type == TypeParameter.Int)
{
p = new IntegerParameter(values);
valuesForParameter = normalizeValues(valueParam, p, newParamId, newSelectionId, prepType);
}
else if (oldParam.Type == TypeParameter.Enum)
{
p = new EnumeratedParameter(values);
valuesForParameter = normalizeValues(valueParam, p, newParamId, newSelectionId, prepType);
}
break;
case "бинаризация":
valuesForParameter = binarizationValues(valueParam, newParamId, newSelectionId, parameterPosition);
break;
case "без предобработки":
valuesForParameter = processWithoutPreprocessing(valueParam, newParamId, newSelectionId);
break;
}
Dictionary <List <Entity>, IParameter> res = new Dictionary <List <Entity>, IParameter>();
res.Add(valuesForParameter, p);
return(res);
}
public Object[][] getValues(int selectionId)
{
Selection selection = ((Selection)dms.services.DatabaseManager.SharedManager.entityById(selectionId, typeof(Selection)));
int taskTemplateId = selection.ID;
List <Entity> parameters = dms.models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", taskTemplateId.ToString()), typeof(dms.models.Parameter));
List <Entity> inputParams = new List <Entity>();
List <Entity> outputParams = new List <Entity>();
foreach (Entity param in parameters)
{
models.Parameter p = (models.Parameter)param;
if (p.IsOutput == 0)
{
inputParams.Add(param);
}
else
{
outputParams.Add(param);
}
}
List <Entity> selectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select)
.addCondition("SelectionID", "=", selectionId.ToString()), typeof(SelectionRow));
Object[][] valuesX = new Object[selectionRows.Count][];
Object[][] valuesY = new Object[selectionRows.Count][];
int stepRow = 0;
foreach (Entity selRow in selectionRows)
{
for (int i = 0; i < 2; i++)
{
if (i == 0)
{
valuesX[stepRow] = new Object[inputParams.Count];
parameters = inputParams;
}
else
{
valuesY[stepRow] = new Object[outputParams.Count];
parameters = outputParams;
}
int selectionRowId = selRow.ID;
int stepParam = 0;
foreach (Entity param in parameters)
{
TypeParameter type = ((dms.models.Parameter)param).Type;
int paramId = param.ID;
List <Entity> value = ValueParameter.where (new Query("ValueParameter").addTypeQuery(TypeQuery.select)
.addCondition("ParameterID", "=", paramId.ToString()).
addCondition("SelectionRowID", "=", selectionRowId.ToString()), typeof(ValueParameter));
if (i == 0)
{
switch (type)
{
case TypeParameter.Real:
valuesX[stepRow][stepParam] = Convert.ToDouble((((ValueParameter)value[0]).Value).Replace(".", ","));
break;
case TypeParameter.Int:
valuesX[stepRow][stepParam] = Convert.ToInt32(((ValueParameter)value[0]).Value);
break;
case TypeParameter.Enum:
valuesX[stepRow][stepParam] = ((ValueParameter)value[0]).Value;
break;
default:
break;
}
}
else
{
switch (type)
{
case TypeParameter.Real:
valuesY[stepRow][stepParam] = Convert.ToDouble((((ValueParameter)value[0]).Value).Replace(".", ","));
break;
case TypeParameter.Int:
valuesY[stepRow][stepParam] = Convert.ToInt32(((ValueParameter)value[0]).Value);
break;
case TypeParameter.Enum:
valuesY[stepRow][stepParam] = ((ValueParameter)value[0]).Value;
break;
default:
break;
}
}
stepParam++;
}
}
stepRow++;
}
return(null);//values;
}
public void Create()
{
if (PerformedTemplate != null)
{
for (int i = 0; i < PerformedTemplateList.Count(); i++)
{
if (PerformedTemplateList[i].Equals(PerformedTemplate.Name))
{
PerformedTemplate.Id = PerformedTemplateIdList[i];
break;
}
}
}
if (BaseTemplate != null)
{
for (int i = 0; i < BaseTemplateList.Count(); i++)
{
if (BaseTemplateList[i].Equals(BaseTemplate.Name))
{
BaseTemplate.Id = BaseTemplateIdList[i];
break;
}
}
List <Entity> ps = models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", BaseTemplate.Id.ToString()), typeof(models.Parameter));
for (int i = 0; i < PreprocessingParameters.Count(); i++)
{
PreprocessingParameters[i].ParameterId = ps[i].ID;
PreprocessingParameters[i].ParameterName = ((models.Parameter)ps[i]).Name;
}
List <Entity> selections = Selection.where (new Query("Selection").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", BaseTemplate.Id.ToString()), typeof(Selection));
int newTaskTemplateId;
PreprocessingTemplate pp = new PreprocessingTemplate();
if (IsUsingExitingTemplate)
{
newTaskTemplateId = TemplateId;
}
else
{
pp.PreprocessingName = PreprocessingName;
pp.BaseTemplate = BaseTemplate;
string templateName = (NewTemplateName == null || NewTemplateName == "") ? "New Preprocessing Template" : NewTemplateName;
newTaskTemplateId = new DataHelper().addTaskTemplate(templateName, Task.ID, pp);
}
List <PreprocessingParameterViewModel> preprocessingParametersTemp = new List <PreprocessingParameterViewModel>();
List <string> types = new List <string>();
List <Parameter> parameters = new List <Parameter>();
List <services.preprocessing.normalization.IParameter> listOfIParameters = new List <services.preprocessing.normalization.IParameter>();
List <int> paramIds = new List <int>();
foreach (Entity sel in selections)
{
int newSelectionId = PreprocessingManager.PrepManager.addNewEntitiesForPreprocessing(
((Selection)sel).Name, ((Selection)sel).RowCount, Task.ID, newTaskTemplateId);
int oldSelectionId = sel.ID;
foreach (PreprocessingParameterViewModel prepParam in PreprocessingParameters)
{
string prepType = prepParam.Type;
int oldParamId = prepParam.ParameterId;
if ("бинаризация".Equals(prepType))
{
bool canCreate = true;
List <Entity> newParameters = models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", newTaskTemplateId.ToString()), typeof(models.Parameter));
List <Entity> newAddedParameters = new List <Entity>();
List <string> classes = PreprocessingManager.PrepManager.getClasses(oldSelectionId, newTaskTemplateId, oldParamId);
foreach (Entity entity in newParameters)
{
//TypeParameter type = getTypeParameter(prepType, oldParamId);
if (classes.Contains(((models.Parameter)entity).Name))
//(((models.Parameter)entity).Name.Equals(prepParam.ParameterName)) && ((models.Parameter)entity).Type.Equals(type)) ?????
{
newAddedParameters.Add(entity);
canCreate = false;
}
}
if (canCreate)
{
newParameters = PreprocessingManager.PrepManager.getNewParametersForBinarizationType(oldSelectionId, newTaskTemplateId, oldParamId);
}
else
{
newParameters = newAddedParameters;
}
int i = 0;
foreach (Entity entity in newParameters)
{
PreprocessingParameterViewModel ppVM = new PreprocessingParameterViewModel();
ppVM.Position = i + 1;
ppVM.ParameterId = entity.ID;
ppVM.ParameterName = ((models.Parameter)entity).Name;
ppVM.Type = "бинаризация";
if (canCreate)
{
preprocessingParametersTemp.Add(ppVM);
types.Add("бинаризация");
parameters.Add(new view_models.Parameter(ppVM.ParameterName, ppVM.Type, ((models.Parameter)entity).Comment, entity.ID));
}
i++;
services.preprocessing.normalization.IParameter p = PreprocessingManager.PrepManager.executePreprocessing(newSelectionId, oldSelectionId, oldParamId, prepType, i - 1, entity.ID);
continue;
}
}
else
{
models.Parameter oldParam = ((models.Parameter)services.DatabaseManager.SharedManager.entityById(oldParamId, typeof(models.Parameter)));
TypeParameter type = getTypeParameter(prepType, oldParamId);
bool canCreate = true;
int newParamId = -1;
List <Entity> newParameters = models.Parameter.where (new Query("Parameter").addTypeQuery(TypeQuery.select)
.addCondition("TaskTemplateID", "=", newTaskTemplateId.ToString()), typeof(models.Parameter));
foreach (Entity entity in newParameters)
{
if (((models.Parameter)entity).Name.Equals(prepParam.ParameterName) && ((models.Parameter)entity).Type.Equals(type))
{
newParamId = entity.ID;
canCreate = false;
break;
}
}
if (canCreate)
{
newParamId = new DataHelper().addOneParameter(prepParam.ParameterName, oldParam.Comment, newTaskTemplateId, prepParam.Position,
oldParam.IsOutput, type);
PreprocessingParameterViewModel ppVM = new PreprocessingParameterViewModel();
ppVM.ParameterName = prepParam.ParameterName;
ppVM.Position = prepParam.Position;
ppVM.Type = prepParam.Type;
ppVM.ParameterId = newParamId;
parameters.Add(new view_models.Parameter(prepParam.ParameterName, prepParam.Type, oldParam.Comment, newParamId));
types.Add(prepType);
preprocessingParametersTemp.Add(ppVM);
}
services.preprocessing.normalization.IParameter p = PreprocessingManager.PrepManager.executePreprocessing(newSelectionId, oldSelectionId, oldParamId, prepType, prepParam.Position, newParamId);
listOfIParameters.Add(p);
paramIds.Add(newParamId);
}
}
SerializableList list = new SerializableList();
list.selectionId = newSelectionId;
list.parameterIds = paramIds;
list.prepParameters = listOfIParameters;
pp.info.Add(list);
}
if (parameters != null && types != null)
{
pp.parameters = parameters;
pp.types = types;
PreprocessingManager.PrepManager.updateTaskTemplate(newTaskTemplateId, pp);
}
if (preprocessingParametersTemp != null)
{
PreprocessingParameters = preprocessingParametersTemp.ToArray();
}
}
OnClose?.Invoke(this, null);
}
