source: branches/CEDMA-Refactoring-Ticket419/HeuristicLab.CEDMA.Core/Results.cs @ 1104

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using HeuristicLab.Core;
using System.Collections;
using HeuristicLab.CEDMA.DB.Interfaces;
using System.Xml;
using System.Runtime.Serialization;
using System.IO;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Data;
using HeuristicLab.DataAnalysis;
using System.Drawing;

namespace HeuristicLab.CEDMA.Core {
  public class Results : IViewable, IEnumerable<Record> {
    private Dictionary<Record, Dataset> datasets;

    private IStore store;
    public IStore Store {
      get { return store; }
      set {
        store = value;
      }
    }

    private void ReloadList() {
      var results = store.Select(new Statement(Ontology.AnyEntity, Ontology.PredicateInstanceOf, Ontology.TypeGeneticProgrammingFunctionTree))
      .Select(x => store.Select(new SelectFilter(
        new Entity[] { new Entity(x.Subject.Uri) },
        new Entity[] { Ontology.PredicateModelAttribute },
          new Resource[] { Ontology.AnyEntity })));

      Random random = new Random();
      foreach(Statement[] ss in results) {
        if(ss.Length > 0) {
          Record r = new Record(this, ss[0].Subject.Uri);
          r.Set(Record.X_JITTER, random.NextDouble() * 2.0 - 1.0);
          r.Set(Record.Y_JITTER, random.NextDouble() * 2.0 - 1.0);
          foreach(Statement s in ss) {
            string varName;
            predicateToVariableName.TryGetValue(s.Predicate, out varName);
            if(varName != null) {
              if(varName == Record.TREE_HEIGHT || varName == Record.TREE_SIZE || varName == Record.TARGET_VARIABLE) {
                r.Set(varName, (double)(int)((Literal)s.Property).Value);
              } else {
                r.Set(varName, (double)((Literal)s.Property).Value);
              }
            }
          }
          lock(records) {
            records.Add(r);
          }
          FireRecordAdded(r);
        }
      }
      FireChanged();
    }

    public Results(IStore store)
      : base() {
      this.store = store;
      records = new List<Record>();
      datasets = new Dictionary<Record, Dataset>();
      //predicateToVariableName = new Dictionary<Entity, string>();
      //predicateToVariableName[targetVariablePredicate] = Record.TARGET_VARIABLE;
      //predicateToVariableName[treeSizePredicate] = Record.TREE_SIZE;
      //predicateToVariableName[treeHeightPredicate] = Record.TREE_HEIGHT;
      //predicateToVariableName[selectionPressurePredicate] = Record.SELECTIONPRESSURE;
      //predicateToVariableName[trainingMAPEPredicate] = Record.MAPE_TRAINING;
      //predicateToVariableName[validationMAPEPredicate] = Record.MAPE_VALIDATION;
      //predicateToVariableName[testMAPEPredicate] = Record.MAPE_TEST;
      //predicateToVariableName[trainingR2Predicate] = Record.R2_TRAINING;
      //predicateToVariableName[validationR2Predicate] = Record.R2_VALIDATION;
      //predicateToVariableName[testR2Predicate] = Record.R2_TEST;
    }

    public override IView CreateView() {
      return new ResultsView(this);
    }

    //internal void OpenModel(Record record) {
    //  IList<Statement> modelResults = store.Select(new Statement(new Entity(record.Uri), Ontology.PredicateSerializedData, Ontology.AnyEntity));
    //  if(modelResults.Count == 1) {
    //    string rawData = ((SerializedLiteral)modelResults[0].Property).RawData;
    //    XmlDocument doc = new XmlDocument();
    //    doc.LoadXml(rawData);
    //    IFunctionTree tree = (IFunctionTree)PersistenceManager.Restore(doc.ChildNodes[1], new Dictionary<Guid, IStorable>());
    //    int targetVariable = (int)record.Get(Record.TARGET_VARIABLE);
    //    Dataset dataset = GetDataset(record);

    //    ModelView modelView = new ModelView(record, dataset, tree, targetVariable);
    //    PluginManager.ControlManager.ShowControl(modelView);
    //  }
    //}

    //private Dataset GetDataset(Record record) {
    //  if(!datasets.ContainsKey(record)) {
    //    IList<Statement> result = store.Select(new Statement(Ontology.AnyEntity, Ontology.PredicateHasModel, new Entity(record.Uri)));
    //    if(result.Count == 1) {
    //      IList<Statement> datasetResult = store.Select(new Statement(result[0].Subject, Ontology.PredicateSerializedData, Ontology.AnyEntity));
    //      if(datasetResult.Count == 1) {
    //        string rawData = ((SerializedLiteral)datasetResult[0].Property).RawData;
    //        XmlDocument doc = new XmlDocument();
    //        doc.LoadXml(rawData);
    //        Dataset dataset = (Dataset)PersistenceManager.Restore(doc.ChildNodes[1], new Dictionary<Guid, IStorable>());
    //        datasets.Add(record, dataset);
    //      }
    //    }
    //  }
    //  return datasets[record];
    //}

    //internal void OpenAlgorithm(Record record) {
    //  IList<Statement> generatedBy = store.Select(new Statement(new Entity(record.Uri), Ontology.PredicateGeneratedBy, Ontology.AnyEntity));
    //  if(generatedBy.Count == 1) {
    //    IList<Statement> algoResult = store.Select(new Statement((Entity)generatedBy[0].Property, Ontology.PredicateSerializedData, Ontology.AnyEntity));
    //    if(algoResult.Count == 1) {
    //      string rawData = ((SerializedLiteral)algoResult[0].Property).RawData;
    //      XmlDocument doc = new XmlDocument();
    //      doc.LoadXml(rawData);
    //      IItem algo = (IItem)PersistenceManager.Restore(doc.ChildNodes[1], new Dictionary<Guid, IStorable>());
    //      PluginManager.ControlManager.ShowControl(algo.CreateView());
    //    }
    //  }
    //}

    internal void FilterDataSet(Entity entity) {

    }

    #region IEnumerable<Record> Members

    public IEnumerator<Record> GetEnumerator() {
      throw new NotImplementedException();
    }

    #endregion

    #region IEnumerable Members

    IEnumerator IEnumerable.GetEnumerator() {
      return this.GetEnumerator();
    }

    #endregion
  }
}