private void SetNewStatusValue(StartupConfigurationMode configMode, SolutionInfoViewModel localSlnInfo,
AnalysisStatus newStatus)
{
switch (configMode)
{
case StartupConfigurationMode.PvsVs2010:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2010 = newStatus);
break;
case StartupConfigurationMode.PvsVs2012:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2012 = newStatus);
break;
case StartupConfigurationMode.PvsVs2013:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2013 = newStatus);
break;
case StartupConfigurationMode.PvsVs2015:
RunInUiSynchronizationContext(() => localSlnInfo.LaunchStatusOnPvsVs2015 = newStatus);
break;
default:
throw new InvalidOperationException(
string.Format("Unsupported Visual Studio version: {0}", configMode));
}
}
public override int GetHashCode()
{
int hash = 1;
if (ContinuousAnalysis != 0)
{
hash ^= ContinuousAnalysis.GetHashCode();
}
if (AnalysisStatus != 0)
{
hash ^= AnalysisStatus.GetHashCode();
}
if (analysisStatusError_ != null)
{
hash ^= AnalysisStatusError.GetHashCode();
}
if (Cpe.Length != 0)
{
hash ^= Cpe.GetHashCode();
}
if (lastScanTime_ != null)
{
hash ^= LastScanTime.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
private void Execute(StartupConfigurationMode startupConfigurationMode, AnalysisStatus properInitialStatus,
SolutionInfoViewModel solutionInfo, string currentTestingDir)
{
var testSolutionInfo = solutionInfo.TestSolutionInfo;
var initialStatus = Utils.GetLaunchStatus(startupConfigurationMode, solutionInfo);
if (initialStatus == AnalysisStatus.None)
{
throw new InvalidOperationException("Unable to determine the analysis status");
}
if (initialStatus != properInitialStatus)
{
return;
}
var logFileName = Utils.GetLogFileName(currentTestingDir, testSolutionInfo);
var analysisManager = new AnalysisManager(
solutionInfo, startupConfigurationMode, initialStatus, logFileName, _currentHtmlLog);
lock (_syncAnalysisManagers)
{
AnalysisManagers.Add(analysisManager);
}
analysisManager.Run();
OnCurrentAnalysisDone(
new CurrentAnalysisDoneEventArgs(Interlocked.Increment(ref _totalFinishedCount)));
}
private void UpdateStatus(AnalysisStatus status, int percentComplete)
{
if (status == AnalysisStatus.NetFailed && MessageBox.Show("The server is not responding. Retry?",
"Error Contacting Server", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
EF.ljArchive.Plugins.Core.RIDAnalysis.RetryServer();
}
else if (status == AnalysisStatus.NetFailed)
{
pgb.Value = 0;
lblProgress.Text = "Failed.";
}
else if (status == AnalysisStatus.Success)
{
UpdateTreeView();
lblProgress.Text = "Done.";
if (EF.ljArchive.Plugins.Core.RIDAnalysis.Averages.Length > 1)
{
cmbBaseline.Enabled = true;
}
cmbBaseline.SelectedIndex = 0;
cmbPresets.Enabled = true;
cmbPresets.SelectedIndex = 0;
tabControl.TabPages.Add(tpSummary);
tabControl.TabPages.Add(tpOverTime);
tabControl.TabPages.Add(tpHTMLCode);
tabControl.SelectedIndex = 1;
}
pgb.Value = percentComplete;
}
private void InitializeNotSupportedVersions()
{
if (_testSolutionInfo.StartupMode == StartupConfigurationMode.All)
{
return;
}
switch (_testSolutionInfo.StartupMode)
{
case StartupConfigurationMode.PvsVs2010:
_launchStatusOnPvsVs2012 =
_launchStatusOnPvsVs2013 = _launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotSupported;
break;
case StartupConfigurationMode.PvsVs2012:
_launchStatusOnPvsVs2010 =
_launchStatusOnPvsVs2013 = _launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotSupported;
break;
case StartupConfigurationMode.PvsVs2013:
_launchStatusOnPvsVs2010 =
_launchStatusOnPvsVs2012 = _launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotSupported;
break;
case StartupConfigurationMode.PvsVs2015:
_launchStatusOnPvsVs2010 =
_launchStatusOnPvsVs2012 = _launchStatusOnPvsVs2013 = AnalysisStatus.VsVersionNotSupported;
break;
}
}
/// <summary>
/// Нужно ли создавать конфигурацию для запуска под конкретную версию
/// </summary>
/// <param name="testSolutionInfos">VS-решения</param>
/// <param name="vsVersion">Версия VS</param>
/// <param name="properInitialStatus">Статус, под которым нужно звапускать анализ</param>
/// <returns>true, если есть хотя бы один проект для запуска под конкретную версию, false - в противном случае</returns>
public static bool NeedToRun(IEnumerable <SolutionInfoViewModel> testSolutionInfos,
StartupConfigurationMode vsVersion, AnalysisStatus properInitialStatus)
{
var needToRun = false;
switch (vsVersion)
{
case StartupConfigurationMode.PvsVs2010:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2010 == properInitialStatus);
break;
case StartupConfigurationMode.PvsVs2012:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2012 == properInitialStatus);
break;
case StartupConfigurationMode.PvsVs2013:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2013 == properInitialStatus);
break;
case StartupConfigurationMode.PvsVs2015:
needToRun =
testSolutionInfos.Any(slnInfo => slnInfo.LaunchStatusOnPvsVs2015 == properInitialStatus);
break;
}
return(needToRun);
}
public override Dictionary <string, object> DumpBasicEventData()
{
var rv = new Dictionary <string, object>(base.DumpBasicEventData());
rv.Add("Analysis Status", AnalysisStatus.ToString());
rv.Add("Calories From Carbs", CaloriesFromCarbs.ToString());
rv.Add("Calories From Fat", CaloriesFromFat.ToString());
rv.Add("StressBalance", StressBalance.ToString());
rv.Add("Maximal VO2", MaximalVO2.ToString());
rv.Add("Training Effect", TrainingEffect.ToString());
rv.Add("Recovery Time (sec)", RecoveryTime.ToString());
rv.Add("Paused Time", PausedTime.ToString());
rv.Add("Heart Rate at Finish", HeartRate.AtFinish);
rv.Add("Recovery Heart Rate after 1 Minute", HeartRate.RecoveryHeartRate1Minute);
rv.Add("Recovery Heart Rate after 2 Minutes", HeartRate.RecoveryHeartRate1Minute);
rv.Add("Heart Rate Zone - Under", HeartRate.Zones.Under);
rv.Add("Heart Rate Zone - Aerobic", HeartRate.Zones.Aerobic);
rv.Add("Heart Rate Zone - Anaerobic", HeartRate.Zones.Anaerobic);
rv.Add("Heart Rate Zone - FitnessZone", HeartRate.Zones.FitnessZone);
rv.Add("Heart Rate Zone - RedLine", HeartRate.Zones.RedLine);
rv.Add("Heart Rate Zone - Over", HeartRate.Zones.Over);
return(rv);
}
public override int GetHashCode()
{
int hash = 1;
if (ContinuousAnalysis != global::Grafeas.V1.DiscoveryOccurrence.Types.ContinuousAnalysis.Unspecified)
{
hash ^= ContinuousAnalysis.GetHashCode();
}
if (AnalysisStatus != global::Grafeas.V1.DiscoveryOccurrence.Types.AnalysisStatus.Unspecified)
{
hash ^= AnalysisStatus.GetHashCode();
}
if (analysisStatusError_ != null)
{
hash ^= AnalysisStatusError.GetHashCode();
}
if (Cpe.Length != 0)
{
hash ^= Cpe.GetHashCode();
}
if (lastScanTime_ != null)
{
hash ^= LastScanTime.GetHashCode();
}
if (archiveTime_ != null)
{
hash ^= ArchiveTime.GetHashCode();
}
if (_unknownFields != null)
{
hash ^= _unknownFields.GetHashCode();
}
return(hash);
}
internal void SetContinuation(Continuation continueBehavior)
{
Assert.IsNotNull(continueBehavior);
this.continuation = continueBehavior;
if (this.continuation.Equals(Continuation.Done))
{
this.currentStatus = AnalysisStatus.Completed;
return;
}
switch (this.continuation.ContinuationType)
{
case ContinuationType.WaitForTime:
Assert.IsTrue(this.continuation.SuspendTimeout.HasValue, "Suspend Timeout should have value");
this.currentStatus = AnalysisStatus.Suspended;
this.nextActivationTime = DateTime.UtcNow.Add(this.continuation.SuspendTimeout.Value);
break;
case ContinuationType.WaitForFabricEvent:
this.currentStatus = AnalysisStatus.Suspended;
break;
case ContinuationType.WaitForInterest:
this.currentStatus = AnalysisStatus.Suspended;
break;
default:
throw new NotSupportedException(string.Format(
CultureInfo.InvariantCulture,
"Continuation Type: {0} is Unsupported",
this.continuation.ContinuationType));
}
}
private void SetInstalledConfiguration()
{
if (InstallationInfo.IsInstalledPvsStudio)
{
_launchStatusOnPvsVs2010 = InstallationInfo.IsInstalledVs2010
? AnalysisStatus.NotStarted
: AnalysisStatus.VsVersionNotInstalled;
_launchStatusOnPvsVs2012 = InstallationInfo.IsInstalledVs2012
? AnalysisStatus.NotStarted
: AnalysisStatus.VsVersionNotInstalled;
_launchStatusOnPvsVs2013 = InstallationInfo.IsInstalledVs2013
? AnalysisStatus.NotStarted
: AnalysisStatus.VsVersionNotInstalled;
_launchStatusOnPvsVs2015 = InstallationInfo.IsInstalledVs2015
? AnalysisStatus.NotStarted
: AnalysisStatus.VsVersionNotInstalled;
}
else
{
_launchStatusOnPvsVs2010 =
_launchStatusOnPvsVs2012 =
_launchStatusOnPvsVs2013 = _launchStatusOnPvsVs2015 = AnalysisStatus.PluginNotInstalled;
}
}
private void theInkCanvas_StrokeCollected(object sender, InkCanvasStrokeCollectedEventArgs e)
{
var stroke = GetCombinedStore(this.theInkCanvas.Strokes);
InkAnalyzer theInkAnalyzer = new InkAnalyzer();
//theInkAnalyzer.AddStrokes(this.theInkCanvas.Strokes, 0x0804);
//theInkAnalyzer.SetStrokesType(this.theInkCanvas.Strokes, StrokeType.Writing);
theInkAnalyzer.AddStroke(stroke, 0x0804);
theInkAnalyzer.SetStrokeType(stroke, StrokeType.Writing);
AnalysisStatus status = theInkAnalyzer.Analyze();
if (status.Successful)
{
List <StrokeWord> slist = new List <StrokeWord>();
//textBox1.Text = theInkAnalyzer.GetRecognizedString();
for (int i = 0; i < theInkAnalyzer.GetAlternates().Count; i++)
{
StrokeWord sw = new StrokeWord();
sw.StrokeName = theInkAnalyzer.GetAlternates()[i].RecognizedString;
slist.Add(sw);
}
this.StrokeWordList = new List <StrokeWord>();
this.StrokeWordList = slist;
}
else
{
MessageBox.Show("识别失败");
}
}
public DocumentData()
{
FilePath = string.Empty;
FileName = string.Empty;
IsChecked = true;
AnalysisStatusInstance = AnalysisStatus.NotStarted;
}
/// <summary>
/// Mark analysis as finished.
/// </summary>
/// <remarks>
/// Only NotStarted -> Queued or Suspended -> Queued are supported transitions.
/// </remarks>
internal void MarkQueued()
{
Assert.IsTrue(
this.currentStatus == AnalysisStatus.NotStarted || this.currentStatus == AnalysisStatus.Suspended,
() => string.Format(CultureInfo.InvariantCulture, "Current Status {0} -> Queued Not valid", this.currentStatus));
this.currentStatus = AnalysisStatus.Queued;
}
/// <summary>
/// Получение описания для статуса прохождения анализа
/// </summary>
/// <param name="analysisStatus">Статус прохождения анализа</param>
/// <returns>Описание для статуса прохождения анализа</returns>
public static string GetAnalysisStatusDescription(this AnalysisStatus analysisStatus)
{
return
(analysisStatus.GetType()
.GetField(analysisStatus.ToString())
.GetCustomAttributes(typeof(AnalysisStatusDescriptionAttribute), false)
.Cast <AnalysisStatusDescriptionAttribute>()
.First().AnalysisStatusDescription);
}
/// <summary>
/// Конструктор менеджера для тестового анализа
/// </summary>
/// <param name="slnInfoVm">Тестируемое решение</param>
/// <param name="startupConfigurationMode">Версия Visual Studion, для которой нужно запустить решение</param>
/// <param name="status">Начальный статус анализа</param>
/// <param name="logFileName">Файл лога с результатами работы анализатора</param>
/// <param name="htmlLog">Html-лог</param>
public AnalysisManager(SolutionInfoViewModel slnInfoVm, StartupConfigurationMode startupConfigurationMode,
AnalysisStatus status, string logFileName, string htmlLog)
{
SolutionInfo = slnInfoVm;
StartupMode = startupConfigurationMode;
_logFileName = logFileName;
_snapshotFilename = string.Format("{0}{1}", _logFileName, SnapshotExt);
_currentStatus = status;
_htmlLog = htmlLog;
}
/// <summary>
/// Конструктор аргументов события анализа
/// </summary>
/// <param name="newStatus">Новый статус анализа</param>
/// <param name="solutionInfoViewModel">Информация о VS-решении</param>
/// <param name="startupMode">Конфигурация запуска</param>
/// <param name="crashReason">Возможная причина сбоя</param>
/// <param name="devenvExitCode">Код завершения devenv.exe</param>
public TestAnalysisEventArgs(AnalysisStatus newStatus, SolutionInfoViewModel solutionInfoViewModel,
StartupConfigurationMode startupMode, CrashReason crashReason = default(CrashReason),
int devenvExitCode = default(int))
{
NewStatus = newStatus;
SolutionInfo = solutionInfoViewModel;
StartupMode = startupMode;
CrashReason = crashReason;
DevenvExitCode = devenvExitCode;
}
internal void MarkFailed()
{
Assert.IsTrue(
this.currentStatus == AnalysisStatus.InProgress,
() => string.Format(CultureInfo.InvariantCulture, "Transition From Current Status: {0} -> Failed Not valid", this.currentStatus));
this.currentStatus = AnalysisStatus.Failed;
this.analysisEndTime = DateTime.UtcNow.ToUniversalTime();
}
/// <summary>
/// Находится ли статус анализа в запущенном, но еще незавершенном состоянии
/// </summary>
/// <param name="status">Статус</param>
/// <param name="resetFail">Нужно ли сбрасывать статус аварийного завершения</param>
/// <returns>true, если статус анализа находится в запущенном, но еще незавершенном состоянии, false - в противном случае</returns>
public static bool IsInActiveStatus(this AnalysisStatus status, bool resetFail = false)
{
var actives = new List <AnalysisStatus>(ActiveStatuses.Length + 1);
actives.AddRange(ActiveStatuses);
if (resetFail)
{
actives.Add(AnalysisStatus.PluginCrashed);
}
return(actives.Any(activeStatus => activeStatus == status));
}
public TrackInfo(string fileName, int trackNum)
{
songName = fileName.Substring(0, fileName.LastIndexOf('.'));
this.trackNum = trackNum;
measures = new List <Measure>();
score = new List <Note>();
representatives = new Dictionary <int, KeyValuePair <int, MelodicContour> >();
clusterOutputs = new Dictionary <int, string>();
clusterIDs = new List <int>();
repeatedMelodicContourSequences = new List <KeyValuePair <int, List <int> > >();
status = AnalysisStatus.Wait;
}
/// <summary>
/// Create an instance of <see cref="AnalysisSchedulingInformation"/>
/// </summary>
/// <param name="maxAnalysisAttempts"></param>
public AnalysisSchedulingInformation(uint maxAnalysisAttempts = DefaultAnalysisAttempts)
{
if (maxAnalysisAttempts <= 0 || maxAnalysisAttempts > MaxAnalysisAttempts)
{
throw new ArgumentOutOfRangeException(
"maxAnalysisAttempts",
string.Format(CultureInfo.InvariantCulture, "Maximum Analysis attempt count is : '{0}'", MaxAnalysisAttempts));
}
this.maxAttempts = maxAnalysisAttempts;
this.instanceAnalysisAttemptedCount = 0;
this.currentStatus = AnalysisStatus.NotStarted;
this.continuation = null;
}
/// <summary>
/// Mark status as started
/// </summary>
/// <remarks>
/// Only NotStarted -> Started or Queued -> Started are supported.
/// TODO:: Fix Suspended???
/// </remarks>
internal void MarkStarted()
{
Assert.IsFalse(this.IsOutOfAttempts(), "Already out of Attempts. Can't be transitioned to started");
Assert.IsTrue(
this.currentStatus == AnalysisStatus.NotStarted || this.currentStatus == AnalysisStatus.Queued || this.currentStatus == AnalysisStatus.Suspended,
string.Format(CultureInfo.InvariantCulture, "Transition From Current Status: {0} -> Started Not valid", this.currentStatus));
this.currentStatus = AnalysisStatus.InProgress;
if (this.currentStatus == AnalysisStatus.NotStarted)
{
this.analysisStartTime = DateTime.UtcNow.ToUniversalTime();
}
}
private static Tuple <StartupConfigurationMode, SolutionInfoViewModel>[] FilterSolutions(
IEnumerable <Tuple <StartupConfigurationMode, SolutionInfoViewModel> > selectedSolutions,
AnalysisStatus filterStatus)
{
var filtered = new List <Tuple <StartupConfigurationMode, SolutionInfoViewModel> >();
foreach (var solution in selectedSolutions)
{
var configMode = solution.Item1;
var vm = solution.Item2;
switch (configMode)
{
case StartupConfigurationMode.PvsVs2010:
if (vm.LaunchStatusOnPvsVs2010 == filterStatus)
{
filtered.Add(solution);
}
break;
case StartupConfigurationMode.PvsVs2012:
if (vm.LaunchStatusOnPvsVs2012 == filterStatus)
{
filtered.Add(solution);
}
break;
case StartupConfigurationMode.PvsVs2013:
if (vm.LaunchStatusOnPvsVs2013 == filterStatus)
{
filtered.Add(solution);
}
break;
case StartupConfigurationMode.PvsVs2015:
if (vm.LaunchStatusOnPvsVs2015 == filterStatus)
{
filtered.Add(solution);
}
break;
}
}
return(filtered.ToArray());
}
static public bool IsChar(this Stroq stroke, string charset)
{
System.Windows.Ink.InkAnalyzer ia = new InkAnalyzer();
ia.AddStroke(stroke.BackingStroke);
//AnalysisHintNode node = ia.CreateAnalysisHint();
//node.Factoid = "IS_ONECHAR";
//node.CoerceToFactoid = true;
//node.Location.MakeInfinite();
AnalysisStatus astat = ia.Analyze();
string reco = ia.GetRecognizedString();
Console.WriteLine("Recognized:<" + reco + ">");
if (astat.Successful && reco != "Other")
{
return(charset.Contains(reco[0]));
}
return(false);
}
void theInkAnalyzer_ResultsUpdated(object sender, System.Windows.Ink.ResultsUpdatedEventArgs e)
{
AnalysisStatus status = e.Status;
if (status.Successful)
{
string resultStr = this.theInkAnalyzer.GetRecognizedString();
List <string> resultStrArray = resultStr.Split(' ').ToList();
if (resultStrArray.Count > 0)
{
Application.Current.Dispatcher.BeginInvoke((Action)(() =>
{
AnalyzResult(resultStrArray);
}));
}
}
}
/// <summary>
/// Запуск анализатора для всех наборов
/// </summary>
/// <returns>Менеджеры для анализа</returns>
public void RunAll(AnalysisStatus properInitialStatus = AnalysisStatus.NotStarted)
{
_startTestingTime = DateTime.Now;
_totalFinishedCount = 0;
var slnsByVersionMap = Utils.GroupSolutionsByVersion(SlnInfoVms);
var startupConfigurationModes = slnsByVersionMap.Keys.ToArray();
Array.Sort(startupConfigurationModes, (version1, version2) => (int)version1 - (int)version2);
foreach (var startupConfigurationMode in startupConfigurationModes)
{
var testSolutionInfos = slnsByVersionMap[startupConfigurationMode];
if (testSolutionInfos != null && testSolutionInfos.Count > 0)
{
RunAllByVersion(testSolutionInfos, startupConfigurationMode, properInitialStatus);
}
}
_finishTestingTime = DateTime.Now;
}
private void AddTextToReceiveBox(byte[] frame)
{
if (frame[0] == 0x02)
{
string dataOutPut = "";
for (int i = 7; i < frameIdx - 2; i++)
{
dataOutPut += (char)frame[i];
}
dataOutPut += '\n';
Dispatcher.BeginInvoke((Action)(() => ReceivedTextBox.Text += dataOutPut));
SendACK();
}
analysisStatus = AnalysisStatus.BEGIN;
}
/// <summary>
/// Установка свойств решения для запуска
/// </summary>
/// <param name="startupConfigurationMode">Конфигурация запуска</param>
/// <param name="slnInfo">Модель решения</param>
/// <param name="pendingStatus">Статус планирования к запуску</param>
/// <param name="currentTotalCount">Счетчик решений, запланированных к запуску</param>
public static void EstablishLaunchStatus(StartupConfigurationMode startupConfigurationMode,
SolutionInfoViewModel slnInfo, AnalysisStatus pendingStatus, ref int currentTotalCount)
{
switch (startupConfigurationMode)
{
case StartupConfigurationMode.PvsVs2010:
var pvsVs2010Stat = slnInfo.LaunchStatusOnPvsVs2010;
if (!pvsVs2010Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2010 = pendingStatus;
currentTotalCount++;
}
break;
case StartupConfigurationMode.PvsVs2012:
var pvsVs2012Stat = slnInfo.LaunchStatusOnPvsVs2012;
if (!pvsVs2012Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2012 = pendingStatus;
currentTotalCount++;
}
break;
case StartupConfigurationMode.PvsVs2013:
var pvsVs2013Stat = slnInfo.LaunchStatusOnPvsVs2013;
if (!pvsVs2013Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2013 = pendingStatus;
currentTotalCount++;
}
break;
case StartupConfigurationMode.PvsVs2015:
var pvsVs2015Stat = slnInfo.LaunchStatusOnPvsVs2015;
if (!pvsVs2015Stat.IsInDisablingStatus())
{
slnInfo.LaunchStatusOnPvsVs2015 = pendingStatus;
currentTotalCount++;
}
break;
}
}
private void ResetNotSupportedForNotInstalled()
{
if (_launchStatusOnPvsVs2010 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2010)
{
_launchStatusOnPvsVs2010 = AnalysisStatus.VsVersionNotInstalled;
}
if (_launchStatusOnPvsVs2012 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2012)
{
_launchStatusOnPvsVs2012 = AnalysisStatus.VsVersionNotInstalled;
}
if (_launchStatusOnPvsVs2013 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2013)
{
_launchStatusOnPvsVs2013 = AnalysisStatus.VsVersionNotInstalled;
}
if (_launchStatusOnPvsVs2015 == AnalysisStatus.VsVersionNotSupported && !InstallationInfo.IsInstalledVs2015)
{
_launchStatusOnPvsVs2015 = AnalysisStatus.VsVersionNotInstalled;
}
}
public MyInkAnalyzer(StrokeCollection strokeCollection)
{
if (strokeCollection.Count > 0)
{
_strokeCollection = strokeCollection;
analyze = new InkAnalyzer();
//2052：简体中文 1033：英语
analyze.AddStrokes(strokeCollection, GlobalValues.InkAnalyzerLanguageId);
//analyze.BackgroundAnalyze();
AnalysisStatus status = analyze.Analyze();
if (status.Successful)
{
analyzeResults = analyze.GetRecognizedString();
}
else
{
analyzeResults = "Recognition Failed";
}
analyze.RemoveStrokes(_strokeCollection);
}
}
/// <summary>
/// Update status.
/// </summary>
public void UpdateStatus()
{
foreach (Job m in m_jobs)
{
m.Update();
}
AnalysisStatus status = AnalysisStatus.Finished;
int count = 0;
foreach (Job m in m_jobs)
{
if (m.Status != JobStatus.RUNNING &&
m.Status != JobStatus.QUEUED)
count++;
if (m.Status == JobStatus.RUNNING ||
(m_isRunning && (m.Status == JobStatus.QUEUED || m.Status == JobStatus.NONE)))
{
status = AnalysisStatus.Running;
break;
}
if (status != AnalysisStatus.Running &&
(!m_isRunning && m.Status == JobStatus.QUEUED))
{
status = AnalysisStatus.Waiting;
break;
}
if (m.Status == JobStatus.STOPPED)
{
status = AnalysisStatus.Stopped;
}
else if (m.Status == JobStatus.ERROR &&
status == AnalysisStatus.Finished)
{
status = AnalysisStatus.Error;
}
}
if (count != m_jobs.Count)
{
// m_status = AnalysisStatus.Running;
}
else if (m_isRunning == true)
{
m_isRunning = false;
if (m_analysis != null && m_isAllRun)
m_analysis.NotifyAnalysisFinished();
}
if (m_isGroupError)
status = AnalysisStatus.WarnFinished;
m_status = status;
}
/// Initializes a new instance of the <see cref="CrossSectionWorkflowResult"/> class.
/// Constructor for no isomer result.
public CrossSectionWorkflowResult(
string datasetPath,
IImsTarget target,
AnalysisStatus analysisStatus,
AssociationHypothesisInfo associationHypothesisInfo,
PeakScores averageObservedPeakStatistics,
double averageVoltageGroupStability,
string analysisDirectory, string dateTime)
: this(datasetPath,
target,
analysisStatus,
associationHypothesisInfo,
new List<IdentifiedIsomerInfo>(),
averageObservedPeakStatistics,
averageVoltageGroupStability,
analysisDirectory,
dateTime)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CrossSectionWorkflowResult"/> class.
/// Multiple isomer result constructor
/// </summary>
/// <param name="datasetName">
/// The dataset name.
/// </param>
/// <param name="target">
/// The target.
/// </param>
/// <param name="analysisStatus">
/// The analysis status.
/// </param>
/// <param name="associationHypothesisInfo">
/// The analysis scores holder.
/// </param>
/// <param name="isomerResults">
/// The isomer results.
/// </param>
/// <param name="averageObservedPeakStatistics"></param>
/// <param name="averageVoltageGroupStability"></param>
/// <param name="datasetPath"></param>
/// <param name="analysisDirectory"></param>
/// <param name="dateTime"></param>
public CrossSectionWorkflowResult(
string datasetPath,
IImsTarget target,
AnalysisStatus analysisStatus,
AssociationHypothesisInfo associationHypothesisInfo,
IList<IdentifiedIsomerInfo> isomerResults,
PeakScores averageObservedPeakStatistics,
double averageVoltageGroupStability,
string analysisDirectory,
string dateTime)
{
this.Target = target;
this.AnalysisStatus = analysisStatus;
this.AssociationHypothesisInfo = associationHypothesisInfo;
this.isomerResults = isomerResults;
this.AverageObservedPeakStatistics = averageObservedPeakStatistics;
this.AverageVoltageGroupStability = averageVoltageGroupStability;
this.AnalysisDirectory = analysisDirectory;
this.DateTime = dateTime;
this.DatasetPath = datasetPath;
this.DatasetName = Path.GetFileNameWithoutExtension(datasetPath);
this.DateTime = dateTime;
}
internal void SetAnalysisStatus(AnalysisStatus status)
{
this.currentStatus = status;
}
/// <summary>
/// Initializes a new instance of the <see cref="LibraryMatchResult"/> class.
/// </summary>
/// <param name="peak">
/// The peak.
/// </param>
/// <param name="conlusion">
/// The conlusion.
/// </param>
/// <param name="distance">
/// The distance.
/// </param>
public LibraryMatchResult(StandardImsPeak peak, AnalysisStatus conlusion, DriftTimeFeatureDistance distance)
{
this.AnalysisStatus = conlusion;
this.ImsFeature = peak;
this.distance = distance;
}
/// <summary>
/// Initializes a new instance of the <see cref="IdentifiedIsomerInfo"/> class.
/// </summary>
/// <param name="numberOfFeaturePointsUsed">
/// The number of feature points used.
/// </param>
/// <param name="mzInDalton"></param>
/// <param name="rSquared">
/// The r squred.
/// </param>
/// <param name="mobility">
/// The mobility.
/// </param>
/// <param name="crossSectionalArea">
/// The cross sectional area.
/// </param>
/// <param name="averageVoltageGroupStabilityScore">
/// The average voltage group stability score.
/// </param>
/// <param name="arrivalTimeSnapShots">
/// The arrival time snap shots.
/// </param>
/// <param name="viperCompatibleMass">
/// The viper Compatible Mass.
/// </param>
/// <param name="analysisStatus"></param>
/// <param name="peakScores"></param>
/// <param name="target"></param>
public IdentifiedIsomerInfo(
int numberOfFeaturePointsUsed,
double mzInDalton,
double rSquared,
double mobility,
double crossSectionalArea,
double averageVoltageGroupStabilityScore,
IEnumerable<ArrivalTimeSnapShot> arrivalTimeSnapShots,
double viperCompatibleMass,
AnalysisStatus analysisStatus,
PeakScores peakScores,
IImsTarget target,
double t0,
double bestMzInPpm)
{
this.NumberOfFeaturePointsUsed = numberOfFeaturePointsUsed;
this.RSquared = rSquared;
this.Mobility = mobility;
this.CrossSectionalArea = crossSectionalArea;
this.AverageVoltageGroupStabilityScore = averageVoltageGroupStabilityScore;
this.ArrivalTimeSnapShots = arrivalTimeSnapShots;
this.ViperCompatibleMass = viperCompatibleMass;
this.AnalysisStatus = analysisStatus;
this.PeakScores = peakScores;
this.T0 = t0;
this.MzInDalton = mzInDalton;
this.MzInPpm = Metrics.DaltonToPpm(mzInDalton - target.MassWithAdduct, target.MassWithAdduct);
this.RelativeMzInPpm = Math.Abs(MzInPpm - bestMzInPpm);
}
/// <summary>
/// The is conclusive.
/// </summary>
/// <param name="status">
/// The status.
/// </param>
/// <returns>
/// The <see cref="bool"/>.
/// </returns>
private static bool IsConclusive(AnalysisStatus status)
{
if (status == AnalysisStatus.Positive || status == AnalysisStatus.Negative)
{
return true;
}
return false;
}
