Exemple #1
0
        private List <Entity> binarizationValues(List <Entity> values, int paramId, int newSelectionId, int parameterPosition)
        {
            DataHelper    helper        = new DataHelper();
            List <Entity> selectionRows = SelectionRow.where (new Query("SelectionRow").addTypeQuery(TypeQuery.select)
                                                              .addCondition("SelectionID", "=", newSelectionId.ToString()), typeof(SelectionRow));

            List <Entity> listValues = new List <Entity>();

            List <string> valueStr = new List <string>();

            foreach (Entity value in values)
            {
                valueStr.Add(((ValueParameter)value).Value);
            }
            EnumeratedParameter p = new EnumeratedParameter(valueStr);

            int index = 0;

            foreach (string value in valueStr)
            {
                int    i   = p.GetInt(value);
                string val = binarization(parameterPosition == i);
                listValues.Add(helper.addValueParameter(selectionRows[index].ID, paramId, val));
                index++;
            }
            DatabaseManager.SharedManager.insertMultipleEntities(listValues);

            return(listValues);
        }
        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);
        }
Exemple #3
0
        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);
        }