public ImageVM(string imagePath)
{
ImagePath = imagePath;
var slots = FeatureLoader.LoadSlots(imagePath).Select(ps => new ParkingSlotVM(ps));
ParkingSlots = new ObservableCollection <ParkingSlotVM>(slots);
}
private async Task <Dictionary <DatasetInformation, IList <UMCLight> > > GetFeatures(IEnumerable <DatasetInformationViewModel> datasets)
{
var featureCache = new FeatureLoader {
Providers = this.analysis.DataProviders
};
var datasetFeatures = new Dictionary <DatasetInformation, IList <UMCLight> >();
foreach (var file in datasets)
{ // Select only datasets with features.
IList <UMCLight> feat;
if (this.featuresByDataset.ContainsKey(file.Dataset))
{
feat = this.featuresByDataset[file.Dataset];
}
else
{
var fileInstance = file;
feat = await Task.Run(() => UmcLoaderFactory.LoadUmcFeatureData(
fileInstance.Dataset,
featureCache.Providers.FeatureCache));
this.featuresByDataset.Add(file.Dataset, feat);
}
datasetFeatures.Add(file.Dataset, feat);
}
return(datasetFeatures);
}
public void LoadContours()
{
var parkingSlots = FeatureLoader.LoadSlots(ContourDataPath);
ParkingSlots = new ObservableCollection <ParkingSlotVM>(parkingSlots.Select(ps => new ParkingSlotVM(ps)));
SelectedSlot = ParkingSlots?.FirstOrDefault();
}
public FeatureFindingSettingsViewModel(
MultiAlignAnalysis analysis,
FeatureLoader featureCache,
IFeatureWindowFactory msFeatureWindowFactory = null,
IProgress <int> progressReporter = null)
{
this.analysis = analysis;
this.featureCache = featureCache;
this.msFeatureWindowFactory = msFeatureWindowFactory ?? new MSFeatureViewFactory();
this.progress = progressReporter ?? new Progress <int>();
this.selectedDatasets = new ReadOnlyCollection <DatasetInformation>(new List <DatasetInformation>());
this.msFeatureWindowFactory = new MSFeatureViewFactory();
MessengerInstance.Register <PropertyChangedMessage <IReadOnlyCollection <DatasetInformation> > >(this, sds =>
{
this.selectedDatasets = sds.NewValue;
this.FindMSFeaturesCommand.RaiseCanExecuteChanged();
this.PlotMSFeaturesCommand.RaiseCanExecuteChanged();
});
FindMSFeaturesCommand = new RelayCommand(
async() => await LoadMSFeaturesAsync(),
() => this.selectedDatasets != null &&
this.selectedDatasets.Count > 0 &&
this.selectedDatasets.Any(file => !file.DoingWork));
PlotMSFeaturesCommand = new RelayCommand(
async() => await PlotMSFeatures(),
() => this.selectedDatasets.Any(file => file.FeaturesFound));
}
public void LoadFeaturesByType_Returns_Instance_Of_Specified_Type()
{
var featureType = typeof(AspNetMvcFeature);
var feature = FeatureLoader.LoadFeaturesByType(featureType);
Assert.NotNull(feature);
Assert.True(feature.GetType() == featureType);
}
public void LoadFeaturesFromNamespace_Returns_An_Empty_Collection_When_Parameters_Are_Invalid2()
{
var validAssembly = Assembly.GetAssembly(typeof(AspNetMvcFeature));
var invalidNamespaceSuffix = string.Empty;
var loadedFeatures = FeatureLoader.LoadFeaturesFromNamespace(validAssembly, invalidNamespaceSuffix);
CollectionAssert.IsEmpty(loadedFeatures);
}
public void LoadFeaturesFromNamespace_Returns_An_Empty_Collection_When_Parameters_Are_Invalid1()
{
Assembly invalidAssembly = null;
var validNamespaceSuffix = "ProjectType";
var loadedFeatures = FeatureLoader.LoadFeaturesFromNamespace(invalidAssembly, validNamespaceSuffix);
CollectionAssert.IsEmpty(loadedFeatures);
}
public static void AddBeatrice(this IServiceCollection services, IConfiguration configuration)
{
services.Configure <DeviceConfiguration>(configuration);
services.AddSingleton <DeviceInstanceProvider>();
services.AddSingleton <DeviceFeatureProvider>();
services.AddSingleton <AutomationService>();
FeatureLoader.Register(services, Array.Empty <string>());
}
public void LoadFeaturesByTypes_Returns_Instances_Of_Specified_Types()
{
var featureTypes = new[] { typeof(AspNetMvcFeature), typeof(AspNetWebApiFeature) };
var features = FeatureLoader.LoadFeaturesByTypes(featureTypes);
var returnedFeatureTypes = features.Select(f => f.GetType());
Assert.True(features.Count() == 2);
CollectionAssert.Contains(returnedFeatureTypes, typeof(AspNetMvcFeature));
CollectionAssert.Contains(returnedFeatureTypes, typeof(AspNetWebApiFeature));
}
public void LoadFromFile(string directoryPath)
{
var files = FeatureLoader.GetPhotos(directoryPath)
.Select(path => new ImageVM(path));
Images = new ObservableCollection <ImageVM>(files);
SelectedImage = Images.FirstOrDefault();
SelectedSlot = SelectedImage?.ParkingSlots?.FirstOrDefault();
}
public void LoadFeaturesByTypes_Returns_An_Empty_Collection_When_Parameters_Are_Invalid()
{
var invalidTypes = new List <Type>
{
typeof(StringBuilder),
typeof(Array)
};
var loadedFeatures = FeatureLoader.LoadFeaturesByTypes(invalidTypes);
CollectionAssert.IsEmpty(loadedFeatures);
}
public static BehaviorGraph Build(FubuRegistry registry, IPerfTimer perfTimer,
IEnumerable<Assembly> packageAssemblies, IActivationDiagnostics diagnostics, IFubuApplicationFiles files)
{
var featureLoader = new FeatureLoader();
featureLoader.LookForFeatures();
if (registry.Mode.InDevelopment())
{
registry.AlterSettings<DiagnosticsSettings>(_ => _.TraceLevel = TraceLevel.Verbose);
registry.AlterSettings<AssetSettings>(_ => _.SetupForDevelopment());
}
var graph = new BehaviorGraph
{
ApplicationAssembly = registry.ApplicationAssembly,
PackageAssemblies = packageAssemblies
};
var accessorRules = AccessorRulesCompiler.Compile(graph, perfTimer);
var config = registry.Config;
perfTimer.Record("Applying Settings", () => applySettings(config, graph, diagnostics, files));
perfTimer.Record("Enable built in polling jobs", () => enableBuiltInJobs(graph));
perfTimer.Record("Applying Feature Settings", () => featureLoader.ApplyAll(graph.Settings, registry).Wait());
perfTimer.Record("Local Application BehaviorGraph", () => config.BuildLocal(graph, perfTimer));
perfTimer.Record("Explicit Configuration", () => config.Global.Explicits.RunActions(graph));
perfTimer.Record("Global Policies", () => config.Global.Policies.RunActions(graph));
perfTimer.Record("Inserting Conneg and Authorization Nodes",
() => insertConnegAndAuthorizationNodes(graph));
perfTimer.Record("Applying Global Reorderings", () => config.ApplyGlobalReorderings(graph));
if (registry.Mode.InDevelopment() || graph.Settings.Get<DiagnosticsSettings>().TraceLevel != TraceLevel.None)
{
perfTimer.Record("Applying Tracing", () => ApplyTracing.Configure(graph));
}
accessorRules.Wait();
new AutoImportModelNamespacesConvention().Configure(graph);
return graph;
}
public void LoadTrainData(string trainDataPath)
{
TrainDataPath = trainDataPath;
if (!Directory.GetFiles(trainDataPath).Any())
{
return;
}
var features = FeatureLoader.GetObservations(trainDataPath);
SvmClassifier = SVMClassifier.Create(features);
}
public void SaveToFileHandler(object o)
{
var data = ParkingSlots
.Select(slot => new ParkingSlot()
{
IsOccupied = slot.IsOccupied,
Contour = new Contour(slot.Pts
.Select(point => new Contour.Point()
{
X = point.X,
Y = point.Y,
}))
});
FeatureLoader.SaveSlots(ContourDataPath, data);
}
private IEnumerator BuildBlocks(Chunk chunk, IncrementalTimer timer)
{
foreach (var builder in _blockBuilders)
{
var position = builder.Position;
var blockType = BlockTypes.None;
var featureToBuild = FeatureTypes.None;
if (builder.IsFill)
{
builder.SetType(FillBlock);
}
blockType = builder.GetBlock();
featureToBuild = builder.GetFeature();;
Block block = null;
if (blockType != BlockTypes.None)
{
block = BlockLoader.CreateBlock(blockType, position);
chunk.Register(block);
}
if (featureToBuild != FeatureTypes.None)
{
var feature = FeatureLoader.CreateFeature(featureToBuild, position);
chunk.Register(feature);
if (block != null)
{
feature.Assign(block);
}
feature.Assign(builder.Space);
feature.Initialize();
}
if (timer.CheckIncrement(Time.realtimeSinceStartup))
{
yield return(null);
timer.AdvanceIncrement(Time.realtimeSinceStartup);
}
}
}
public void LoadFeaturesFromNamespace_Loads_All_Features_In_Namespace()
{
var namespaceSuffix = nameof(global::CTA.FeatureDetection.ProjectType.CompiledFeatures);
var assembly = Assembly.GetAssembly(typeof(AspNetMvcFeature));
var loadedFeatures = FeatureLoader.LoadFeaturesFromNamespace(assembly, namespaceSuffix);
var loadedFeatureNames = loadedFeatures.Select(f => f.Name);
var expectedFeatureNames = new[]
{
nameof(AspNetMvcFeature),
nameof(AspNetWebApiFeature),
nameof(AspNetCoreMvcFeature),
nameof(AspNetCoreWebApiFeature),
nameof(WebClassLibraryFeature)
};
CollectionAssert.AreEquivalent(expectedFeatureNames, loadedFeatureNames);
}
public void SaveToFileHandler(object o)
{
foreach (var imageVM in Images)
{
var data = imageVM.ParkingSlots
.Select(slot => new ParkingSlot()
{
IsOccupied = slot.IsOccupied,
Contour = new Contour(slot.Pts
.Select(point => new Contour.Point()
{
X = point.X,
Y = point.Y,
}))
});
FeatureLoader.SaveSlots(imageVM.ImagePath, data);
}
}
public static void Main(string[] args)
{
string content = "this is some content that will be processed by this crazy sample code to replace umlauts like ä, ö, ü";
int maxLineLength = 15;
Console.WriteLine($"input = {content}");
// build up
var timeProvider = new TransientTypeDependency<ITimeProvider, LocalLongTimeProvider>();
var kernel = new StandardKernel();
var featureModuleLoader = new FeatureLoader(kernel);
featureModuleLoader.Load(new WorkflowFeature(timeProvider));
// run
var appFactory = kernel.Get<WorkflowFeature.IWorkflowFactory>();
var workflow = appFactory.CreateWorkflow();
var processedContent = workflow.Process(content, maxLineLength);
Console.WriteLine($"output = {processedContent}");
}
static void Main(string[] args)
{
if (!Prompt.FolderPrompt(out var path))
{
return;
}
var reloadCache = Prompt.YesNo("Odświeżyć cache?");
var observations = FeatureLoader.GetObservations(path, reloadCache, StatusBar.DrawTextProgressBar).ToList();
Console.WriteLine($"Liczba obserwacji: {observations.Count}");
CrossValidation(observations);
NsubOneValidation(observations);
Console.WriteLine("Naciśnij dowolny klawisz aby zamknąć");
while (Console.KeyAvailable)
{
Console.ReadKey(true); //discard stacked keyboard events
}
Console.ReadKey(true);
}
public void ProcessDocument(
WorkflowFeature.IWorkflowFactory factory,
string output)
{
const string Input = "some text to process with ä, Ö and ü to replace.";
const int MaxLineLength = 10;
const int ExtraCharactersInLine = 5; // brackets, space + \r\n
"establish the document workflow feature"._(() =>
{
var timeProvider = new TransientTypeDependency<ITimeProvider, FakeTimeProvider>();
var kernel = new StandardKernel();
var loader = new FeatureLoader(kernel);
loader.Load(new WorkflowFeature(timeProvider));
factory = kernel.Get<WorkflowFeature.IWorkflowFactory>();
});
"when processing a document"._(() =>
output = factory.CreateWorkflow().Process(Input, MaxLineLength));
"it should replace all umlauts"._(() =>
output
.Should().NotContain("ä")
.And.NotContain("ö")
.And.NotContain("ü"));
"it should wrap lines"._(() =>
output.GetLines()
.Should().OnlyContain(x => x.Length < MaxLineLength + FakeTimeProvider.FakeTime.Length + ExtraCharactersInLine));
"it should stamp each line with local time"._(() =>
output.GetLines()
.Should().OnlyContain(x => x.StartsWith($"[{FakeTimeProvider.FakeTime}] ")));
}
/// <summary>
/// Loads baseline data for alignment.
/// </summary>
private IList <UMCLight> LoadBaselineData(DatasetInformation baselineInfo,
MsFeatureFilteringOptions msFilterOptions,
LcmsFeatureFindingOptions lcmsFindingOptions,
LcmsFeatureFilteringOptions lcmsFilterOptions,
DataLoadingOptions dataLoadOptions,
FeatureDataAccessProviders dataProviders,
MassTagDatabase database,
bool shouldUseMassTagDbAsBaseline)
{
IList <UMCLight> baselineFeatures = null;
UpdateStatus("Loading baseline features.");
if (!shouldUseMassTagDbAsBaseline)
{
if (baselineInfo == null)
{
throw new Exception("The baseline dataset was never set.");
}
var cache = new FeatureLoader
{
Providers = dataProviders
};
RegisterProgressNotifier(cache);
UpdateStatus("Loading baseline features from " + baselineInfo.DatasetName + " for alignment.");
baselineFeatures = cache.LoadDataset(baselineInfo,
msFilterOptions,
lcmsFindingOptions,
lcmsFilterOptions,
dataLoadOptions,
m_scanSummaryProviderCache,
this.m_identificationsProvider);
cache.CacheFeatures(baselineFeatures);
if (BaselineFeaturesLoaded != null)
{
BaselineFeaturesLoaded(this,
new BaselineFeaturesLoadedEventArgs(baselineInfo, baselineFeatures.ToList()));
}
DeRegisterProgressNotifier(cache);
}
else
{
if (database == null)
{
throw new NullReferenceException(
"The mass tag database has to have data in it if it's being used for drift time alignment.");
}
UpdateStatus("Setting baseline features for post drift time alignment from mass tag database.");
var tags = FeatureDataConverters.ConvertToUMC(database.MassTags);
if (BaselineFeaturesLoaded == null)
{
return(tags);
}
if (tags != null)
{
BaselineFeaturesLoaded(this, new BaselineFeaturesLoadedEventArgs(null, tags.ToList(), database));
}
}
return(baselineFeatures);
}
public Feature ToObject() => FeatureLoader.CreateFeature(_type, _position);
/// <summary>
/// Perform alignment.
/// </summary>
/// <param name="workFlowDatasets">Datasets to run on when being called externally form this view model.</param>
/// <param name="workflowProgress">The progress reporter for when this method is called externally from this view model.</param>
internal void AlignToBaseline(List <DatasetInformationViewModel> workFlowDatasets = null, IProgress <ProgressData> workflowProgress = null)
{
// Use Promiscuous points when aligning to an AMT tag database
// Do not use Promiscuous points when aligning to a baseline dataset
this.analysis.Options.AlignmentOptions.UsePromiscuousPoints = !this.ShouldAlignToBaseline;
// Flag whether we are aligning to an AMT tag database
this.analysis.Options.AlignmentOptions.LCMSWarpOptions.AlignToMassTagDatabase = !this.ShouldAlignToBaseline;
// Show the progress bar
this.ShowAlignmentProgress = true;
var taskBarProgress = TaskBarProgress.GetInstance();
taskBarProgress.ShowProgress(this, true);
// Update algorithms and providers
var featureCache = new FeatureLoader {
Providers = this.analysis.DataProviders
};
this.algorithms = this.builder.GetAlgorithmProvider(this.analysis.Options);
////this.algorithms.DatabaseAligner.Progress += aligner_Progress;
////this.algorithms.DatasetAligner.Progress += aligner_Progress;
this.aligner.m_algorithms = this.algorithms;
var baselineFeatures = new List <UMCLight>();
if (this.ShouldAlignToBaseline)
{
baselineFeatures = featureCache.Providers.FeatureCache.FindByDatasetId(this.selectedBaseline.DatasetId);
this.SelectedBaseline.DatasetState = DatasetInformationViewModel.DatasetStates.Baseline;
var priorAlignment = (from x in this.alignmentInformation where x.DatasetID == this.selectedBaseline.DatasetId select x).ToList();
if (priorAlignment.Any())
{
this.alignmentInformation.Remove(priorAlignment.Single());
}
}
var alignmentData = new AlignmentDAOHibernate();
alignmentData.ClearAll();
var selectedFiles = workFlowDatasets ??
this.Datasets.Where(file => file.IsSelected && !file.DoingWork &&
(this.ShouldAlignToAMT || !file.IsBaseline)).ToList();
foreach (var file in selectedFiles)
{
file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligning;
}
workflowProgress = workflowProgress ?? new Progress <ProgressData>();
IProgress <ProgressData> totalProgress = new Progress <ProgressData>(pd =>
{
this.AlignmentProgress = pd.Percent;
workflowProgress.Report(pd);
taskBarProgress.SetProgress(this, pd.Percent);
});
var totalProgressData = new ProgressData(totalProgress);
DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path);
DatabaseIndexer.IndexFeaturesDrop(NHibernateUtil.Path);
var i = 1;
foreach (var file in selectedFiles)
{
ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged());
if ((file.Dataset.IsBaseline || !file.FeaturesFound) && this.ShouldAlignToBaseline)
{
file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned;
continue;
}
this.analysis.DataProviders.DatabaseLock.EnterReadLock();
IList <UMCLight> features = featureCache.Providers.FeatureCache.FindByDatasetId(file.DatasetId);
this.analysis.DataProviders.DatabaseLock.ExitReadLock();
AlignmentData alignment;
totalProgressData.StepRange((100.0 * i++) / selectedFiles.Count);
var fileInstance = file;
var datasetProgress =
new Progress <ProgressData>(
pd =>
{
fileInstance.Progress = pd.Percent;
totalProgressData.Report(pd.Percent);
});
if (this.ShouldAlignToBaseline)
{
// Aligning to a baseline dataset
alignment = this.aligner.AlignToDataset(ref features, file.Dataset, baselineFeatures, datasetProgress);
alignment.BaselineIsAmtDB = false;
}
else
{
// Aligning to a database
alignment = this.aligner.AlignToDatabase(ref features, file.Dataset, this.analysis.MassTagDatabase, datasetProgress);
alignment.BaselineIsAmtDB = true;
}
// Check if there is information from a previous alignment for this dataset. If so, replace it. If not, just add the new one.
var priorAlignment = this.alignmentInformation.Where(x => x.DatasetID == alignment.DatasetID).ToList();
if (priorAlignment.Any())
{
this.alignmentInformation.Remove(priorAlignment.Single());
this.alignmentInformation.Add(alignment);
}
else
{
this.alignmentInformation.Add(alignment);
}
file.Dataset.AlignmentData = alignment;
this.analysis.DataProviders.DatabaseLock.EnterWriteLock();
featureCache.CacheFeatures(features);
this.analysis.DataProviders.DatabaseLock.ExitWriteLock();
file.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned;
ThreadSafeDispatcher.Invoke(() => this.AlignCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.DisplayAlignmentCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.SaveAlignmentPlotsCommand.RaiseCanExecuteChanged());
file.Progress = 0;
}
if (this.ShouldAlignToBaseline)
{
this.SelectedBaseline.DatasetState = DatasetInformationViewModel.DatasetStates.Aligned;
}
DatabaseIndexer.IndexFeatures(NHibernateUtil.Path);
taskBarProgress.ShowProgress(this, false);
this.ShowAlignmentProgress = false;
this.AlignmentProgress = 0;
}
public void CreateFeatureDatabase(string directoryPath, string databasePath)
{
var directory = GetPath(directoryPath);
databasePath = GetPath(databasePath);
// Loads the supported MultiAlign types
var supportedTypes = DatasetLoader.SupportedFileTypes;
var extensions = new List <string>();
supportedTypes.ForEach(x => extensions.Add("*" + x.Extension));
// Find our datasets
var datasetLoader = new DatasetLoader();
var datasets = datasetLoader.GetValidDatasets(directory, extensions, SearchOption.TopDirectoryOnly);
// Options setup
var instrumentOptions = InstrumentPresetFactory.Create(InstrumentPresets.LtqOrbitrap);
var featureTolerances = new FeatureTolerances
{
Mass = instrumentOptions.Mass + 6,
Net = instrumentOptions.NetTolerance,
DriftTime = instrumentOptions.DriftTimeTolerance
};
var featureFindingOptions = new LcmsFeatureFindingOptions(featureTolerances)
{
MaximumNetRange = .002,
MaximumScanRange = 50
};
var lcmsFilters = new LcmsFeatureFilteringOptions
{
FeatureLengthRangeScans = new FilterRange(50, 300)
};
var msFilterOptions = new MsFeatureFilteringOptions
{
MinimumIntensity = 5000,
ChargeRange = new FilterRange(1, 6),
ShouldUseChargeFilter = true,
ShouldUseDeisotopingFilter = true,
ShouldUseIntensityFilter = true
};
var spectralOptions = new SpectralOptions
{
ComparerType = SpectralComparison.CosineDotProduct,
Fdr = .01,
IdScore = 1e-09,
MzBinSize = .5,
MzTolerance = .5,
NetTolerance = .1,
RequiredPeakCount = 32,
SimilarityCutoff = .75,
TopIonPercent = .8
};
var finder = FeatureFinderFactory.CreateFeatureFinder(FeatureFinderType.TreeBased);
NHibernateUtil.CreateDatabase(databasePath);
// Synchronization and IO for serializing all data to the database.
var providers = DataAccessFactory.CreateDataAccessProviders(databasePath, true);
var cache = new FeatureLoader
{
Providers = providers
};
var datasetId = 0;
foreach (var dataset in datasets)
{
dataset.DatasetId = datasetId++;
var features = FindFeatures(dataset,
featureFindingOptions,
msFilterOptions,
lcmsFilters,
spectralOptions,
finder);
cache.CacheFeatures(features);
}
providers.DatasetCache.AddAll(datasets);
}
internal void LoadFeatures(List <DatasetInformationViewModel> workFlowDatasets = null, IProgress <ProgressData> workflowProgress = null)
{
var featureCache = new FeatureLoader {
Providers = this.analysis.DataProviders
};
this.ShouldShowProgress = true;
var selectedFiles = workFlowDatasets ?? this.Datasets.Where(file => !file.DoingWork).Where(ds => ds.IsSelected).ToList();
foreach (var file in selectedFiles)
{
file.DatasetState = DatasetInformationViewModel.DatasetStates.FindingFeatures;
ThreadSafeDispatcher.Invoke(() => this.PlotMsFeaturesCommand.RaiseCanExecuteChanged());
ThreadSafeDispatcher.Invoke(() => this.FindMsFeaturesCommand.RaiseCanExecuteChanged());
}
var taskBarProgress = TaskBarProgress.GetInstance();
taskBarProgress.ShowProgress(this, true);
workflowProgress = workflowProgress ?? new Progress <ProgressData>();
IProgress <ProgressData> totalProgressRpt = new Progress <ProgressData>(pd =>
{
this.TotalProgress = pd.Percent;
taskBarProgress.SetProgress(this, pd.Percent);
workflowProgress.Report(pd);
});
var totalProgressData = new ProgressData(totalProgressRpt);
DatabaseIndexer.IndexClustersDrop(NHibernateUtil.Path);
DatabaseIndexer.IndexFeaturesDrop(NHibernateUtil.Path);
var i = 1;
foreach (var file in selectedFiles)
{
// Set range based on file
totalProgressData.StepRange((i++ *100.0) / selectedFiles.Count);
var fileInstance = file;
var progData = new ProgressData(new Progress <ProgressData>(pd =>
{
fileInstance.Progress = pd.Percent;
// Report file progress
totalProgressData.Report(fileInstance.Progress);
}));
var progressRpt = new Progress <ProgressData>(pd => progData.Report(pd.Percent));
progData.StepRange(30);
IList <UMCLight> features;
// Load features from the database.
try
{
this.analysis.DataProviders.DatabaseLock.EnterReadLock();
features = featureCache.LoadDataset(
file.Dataset,
this.analysis.Options.MsFilteringOptions,
this.analysis.Options.LcmsFindingOptions,
this.analysis.Options.LcmsFilteringOptions,
this.analysis.Options.DataLoadOptions,
this.analysis.DataProviders.ScanSummaryProviderCache,
this.analysis.DataProviders.IdentificationProviderCache,
progressRpt);
}
finally
{ // Always close read lock, even during failure condition so we don't have a recursive lock error.
this.analysis.DataProviders.DatabaseLock.ExitReadLock();
}
if (!this.featuresByDataset.ContainsKey(file.Dataset))
{
this.featuresByDataset.Add(file.Dataset, new List <UMCLight>());
}
this.featuresByDataset[file.Dataset] = features;
file.DatasetState = DatasetInformationViewModel.DatasetStates.PersistingFeatures;
ThreadSafeDispatcher.Invoke(() => this.PlotMsFeaturesCommand.RaiseCanExecuteChanged());
// TODO: We were using this log file to track speed changes for writing the database. We probably don't need it anymore.
using (var logger = new StreamWriter("nhibernate_stats.txt", true))
{
logger.WriteLine();
var stopWatch = new Stopwatch();
stopWatch.Start();
var scanSumProvider =
this.analysis.DataProviders.ScanSummaryProviderCache.GetScanSummaryProvider(
file.Dataset.DatasetId);
if (scanSumProvider.IsBackedByFile)
{
var ssDao = this.analysis.DataProviders.ScanSummaryDao;
ssDao.DeleteByDatasetId(file.Dataset.DatasetId);
// Add all of the Scan Summaries for this dataset to the database, but first properly set the dataset ID
ssDao.AddAllStateless(
scanSumProvider.GetScanSummaries().Select(
summ =>
{
summ.DatasetId = file.Dataset.DatasetId;
return(summ);
}).ToList());
}
progData.StepRange(100);
// Cache features to database.
try
{
this.analysis.DataProviders.DatabaseLock.EnterWriteLock();
featureCache.CacheFeatures(features, progressRpt);
}
catch (NonUniqueObjectException ex)
{
MessageBox.Show("Could not completely persist features: " + ex.Message);
}
catch (Exception ex) // TODO: Figure out which exception should actually be caught here
{
MessageBox.Show("Could not persist features to database: " + ex.Message);
file.DatasetState = DatasetInformationViewModel.DatasetStates.Loaded;
continue;
}
finally
{ // Always close write lock, even during failure condition so we don't have a recursive lock error.
this.analysis.DataProviders.DatabaseLock.ExitWriteLock();
}
stopWatch.Stop();
logger.WriteLine("Writing: {0}s", stopWatch.Elapsed.TotalSeconds);
}
file.DatasetState = DatasetInformationViewModel.DatasetStates.FeaturesFound;
ThreadSafeDispatcher.Invoke(() => this.FindMsFeaturesCommand.RaiseCanExecuteChanged());
file.Progress = 0;
}
DatabaseIndexer.IndexFeatures(NHibernateUtil.Path);
taskBarProgress.ShowProgress(this, false);
this.ShouldShowProgress = false;
}
/// <summary>
/// Load the data from the dataset information objects to the cache at the analysis Path
/// </summary>
private void PerformDataLoadAndAlignment(AnalysisConfig config)
{
UmcLoaderFactory.Status += UMCLoaderFactory_Status;
UpdateStatus("Loading data.");
var analysisOptions = config.Analysis.Options;
var datasets = config.Analysis.MetaData.Datasets.ToList();
var lcmsFilterOptions = analysisOptions.LcmsFilteringOptions;
var msFilterOptions = analysisOptions.MsFilteringOptions;
var dataLoadOptions = analysisOptions.DataLoadOptions;
var baselineDataset = config.Analysis.MetaData.BaselineDataset;
var baselineFeatures = LoadBaselineData(baselineDataset,
msFilterOptions,
analysisOptions.LcmsFindingOptions,
lcmsFilterOptions,
dataLoadOptions,
config.Analysis.DataProviders,
config.Analysis.MassTagDatabase,
config.Analysis.Options.AlignmentOptions.IsAlignmentBaselineAMasstagDB);
var alignmentData = new AlignmentDAOHibernate();
alignmentData.ClearAll();
var providers = config.Analysis.DataProviders;
var featureCache = new FeatureLoader
{
Providers = providers
};
RegisterProgressNotifier(featureCache);
MassTagDatabase database = null;
if (config.Analysis.MassTagDatabase != null)
{
database = new MassTagDatabase(config.Analysis.MassTagDatabase,
config.Analysis.Options.AlignmentOptions.MassTagObservationCount);
}
SingletonDataProviders.Providers = config.Analysis.DataProviders;
foreach (var dataset in datasets)
{
if (dataset.IsBaseline)
{
continue;
}
var features = featureCache.LoadDataset(dataset,
analysisOptions.MsFilteringOptions,
analysisOptions.LcmsFindingOptions,
analysisOptions.LcmsFilteringOptions,
analysisOptions.DataLoadOptions,
m_scanSummaryProviderCache,
m_identificationsProvider);
features = AlignDataset(features,
baselineFeatures,
database,
dataset,
baselineDataset);
featureCache.CacheFeatures(features);
}
UmcLoaderFactory.Status -= UMCLoaderFactory_Status;
}
