public static List<ExportTableDataRow> TransformToTableRows(SimpleSentenceStats stats)
{
var converter = new ModelConverter();
converter._fillRows(stats);
return converter._rows;
}
private static Dictionary<SentenceWordChain, List<LinguisticObject>> _getProperGroupCollection(
SentenceWordType chainMasterType, SimpleSentenceStats stats)
{
switch (chainMasterType)
{
case SentenceWordType.Subject:
return stats.ChainsFromSubjects;
case SentenceWordType.Predicate:
return stats.ChainsFromPredicates;
default:
return stats.ChainsFromMeaningParts;
}
}
private static Dictionary<LinguisticObjectType, List<LinguisticObjectDetectionMetrics>> _getErrorObjects(
SimpleSentenceStats stats)
{
var result = new Dictionary<LinguisticObjectType, List<LinguisticObjectDetectionMetrics>>();
var errors = _getErrorObjects(stats.Subjects.Objects);
if (errors.Any())
{
result[LinguisticObjectType.Subject] = errors;
}
errors = _getErrorObjects(stats.Predicates.Objects);
if (errors.Any())
{
result[LinguisticObjectType.Predicate] = errors;
}
errors = _getErrorObjects(stats.Uniforms.Objects);
if (errors.Any())
{
result[LinguisticObjectType.Uniform] = errors;
}
errors = _getErrorObjects(stats.MeaningAuxParts.Objects);
if (errors.Any())
{
result[LinguisticObjectType.MeaningPart] = errors;
}
errors = _getErrorObjects(stats.ChainsFromSubjects);
if (errors.Any())
{
result[LinguisticObjectType.ChainFromSubject] = errors;
}
errors = _getErrorObjects(stats.ChainsFromPredicates);
if (errors.Any())
{
result[LinguisticObjectType.ChainFromPredicate] = errors;
}
errors = _getErrorObjects(stats.ChainsFromMeaningParts);
if (errors.Any())
{
result[LinguisticObjectType.ChainFromMeaningPart] = errors;
}
return result;
}
private static SimpleSentenceStats _correctErrors(SimpleSentenceStats result, List<ClasterizedSentenceError> clasterizedSentenceErrors, int correctionClass)
{
var emulatedStats = new SimpleSentenceStats
{
Subjects =
_correctErrorsInObjectsGroup(result.Subjects,
clasterizedSentenceErrors.Where(error => error.ObjectType == LinguisticObjectType.Subject), correctionClass),
Predicates =
_correctErrorsInObjectsGroup(result.Predicates,
clasterizedSentenceErrors.Where(error => error.ObjectType == LinguisticObjectType.Predicate), correctionClass),
Uniforms =
_correctErrorsInObjectsGroup(result.Uniforms,
clasterizedSentenceErrors.Where(error => error.ObjectType == LinguisticObjectType.Uniform), correctionClass),
MeaningAuxParts =
_correctErrorsInObjectsGroup(result.MeaningAuxParts,
clasterizedSentenceErrors.Where(error => error.ObjectType == LinguisticObjectType.MeaningPart), correctionClass),
ChainsFromSubjects =
_correctErrorsInObjectsGroup(result.ChainsFromSubjects,
clasterizedSentenceErrors.Where(
error => error.ObjectType == LinguisticObjectType.ChainFromSubject), correctionClass),
ChainsFromPredicates =
_correctErrorsInObjectsGroup(result.ChainsFromPredicates,
clasterizedSentenceErrors.Where(
error => error.ObjectType == LinguisticObjectType.ChainFromPredicate), correctionClass),
ChainsFromMeaningParts =
_correctErrorsInObjectsGroup(result.ChainsFromMeaningParts,
clasterizedSentenceErrors.Where(
error => error.ObjectType == LinguisticObjectType.ChainFromMeaningPart), correctionClass)
};
emulatedStats.WasEmulated =
(new[]
{
emulatedStats.Subjects, emulatedStats.Predicates, emulatedStats.Uniforms, emulatedStats.MeaningAuxParts
}).Any(group => group.WasEmulated) || emulatedStats.AllLinkedChains.Any(o => o.WasEmulated);
emulatedStats.CalculateQuality();
return emulatedStats;
}
private void _writeThirdHeaderRow(SimpleSentenceStats sample)
{
XlHelper.WriteValue(Labels.LoSubNum);
sample.Subjects.Objects.Select((chain, i) =>
{
XlHelper.WriteValue(i + 1, Colors.SubjectHeader);
return chain;
}).ToArray();
sample.Predicates.Objects.Select((chain, i) =>
{
XlHelper.WriteValue(i + 1, Colors.PredicateHeader);
return chain;
}).ToArray();
sample.Uniforms.Objects.Select((chain, i) =>
{
XlHelper.WriteValue(i + 1, Colors.UniformsHeader);
return chain;
}).ToArray();
sample.MeaningAuxParts.Objects.Select((chain, i) =>
{
XlHelper.WriteValue(i + 1, Colors.MeaningHeader);
return chain;
}).ToArray();
sample.ChainsFromSubjects.Values.SelectMany(list => list).Select((chain, i) =>
{
XlHelper.WriteValue(i + 1, _getChainHeaderColor(SentenceWordType.Subject));
return chain;
}).ToArray();
sample.ChainsFromPredicates.Values.SelectMany(list => list).Select((chain, i) =>
{
XlHelper.WriteValue(i + 1, _getChainHeaderColor(SentenceWordType.Predicate));
return chain;
}).ToArray();
sample.ChainsFromMeaningParts.Values.SelectMany(list => list).Select((chain, i) =>
{
XlHelper.WriteValue(i + 1, _getChainHeaderColor(SentenceWordType.MeaningPart));
return chain;
}).ToArray();
}
private void _writeSummaryByLoType(SimpleSentenceStats stats)
{
XlHelper.WriteRow(() =>
{
XlHelper.WriteValue(Labels.MeanLoDetectionQuality, Colors.SummaryRow);
_writeObjectsAverage(stats.Subjects.Objects, stats.Subjects.AverageDetectionQuality);
_writeObjectsAverage(stats.Predicates.Objects, stats.Predicates.AverageDetectionQuality);
_writeObjectsAverage(stats.Uniforms.Objects, stats.Uniforms.AverageDetectionQuality);
_writeObjectsAverage(stats.MeaningAuxParts.Objects, stats.MeaningAuxParts.AverageDetectionQuality);
_writeObjectsAverage(stats.AllLinkedChains, stats.ChainsAverageDetectionQuality);
});
}
private void _writeSimpleSentenceStats(SimpleSentenceStats stats, SimpleSentence simpleSentence, int santenceId,
int? samepleSSId, int? targetSSId)
{
XlHelper.AddMargin();
_writeHeader(stats, simpleSentence, santenceId, samepleSSId, targetSSId);
_writeBody(stats);
_writeSummaryByLoType(stats);
_writeSentenceSummary(stats);
}
private void _writeSentenceSummary(SimpleSentenceStats stats)
{
XlHelper.WriteRow(() =>
{
XlHelper.WriteValue(Labels.MeanSampleDetectionQuality, Colors.SummaryRow, XlsxHelper.PercentageFormat);
_writeObjectsAverage(stats.AllObjects, stats.AverageDetectionQuality);
});
}
private void _writeSecontHeaderRow(SimpleSentenceStats sample)
{
XlHelper.WriteValue(Labels.LoName);
sample.Subjects.Objects.ForEach(chain => XlHelper.WriteValue(Labels.LoLableSubject, Colors.SubjectHeader));
sample.Predicates.Objects.ForEach(chain => XlHelper.WriteValue(Labels.LoLablePredicate, Colors.PredicateHeader));
sample.Uniforms.Objects.ForEach(chain => XlHelper.WriteValue(Labels.LoLableUniform, Colors.UniformsHeader));
sample.MeaningAuxParts.Objects.ForEach(chain => XlHelper.WriteValue(Labels.LoLableMeaning, Colors.MeaningHeader));
_writeLinkedChainSecondHeader(sample.ChainsFromSubjects, SentenceWordType.Subject);
_writeLinkedChainSecondHeader(sample.ChainsFromPredicates, SentenceWordType.Predicate);
_writeLinkedChainSecondHeader(sample.ChainsFromMeaningParts, SentenceWordType.MeaningPart);
}
private void _writeHeader(SimpleSentenceStats stats, SimpleSentence simpleSentence, int id, int? samepleSSId, int? targetSSId)
{
XlHelper.WriteRow(() =>
{
XlHelper.WriteValue(Labels.SentenceNum, Colors.SummaryHeader);
XlHelper.WriteValue(id, Colors.SummaryHeader);
});
XlHelper.WriteRow(() =>
{
XlHelper.WriteValue(Labels.SampleSSNum, Colors.SummaryHeader);
if (samepleSSId != null)
{
XlHelper.WriteValue((int)samepleSSId, Colors.SummaryHeader);
}
else
{
XlHelper.WriteValue("нет", Colors.SummaryHeader);
}
});
XlHelper.WriteRow(() =>
{
XlHelper.WriteValue(Labels.TargetSSNum, Colors.SummaryHeader);
if (targetSSId != null)
{
XlHelper.WriteValue((int)targetSSId, Colors.SummaryHeader);
}
else
{
XlHelper.WriteValue("нет", Colors.SummaryHeader);
}
});
XlHelper.WriteRow(() =>
{
XlHelper.WriteValue(Labels.SampleSentence);
XlHelper.WriteValue(simpleSentence.Text);
});
XlHelper.WriteRow(() => _writeFirstHeaderRow(stats));
XlHelper.WriteRow(() => _writeSecontHeaderRow(stats));
XlHelper.WriteRow(() => _writeThirdHeaderRow(stats));
}
private void _writeFirstHeaderRow(SimpleSentenceStats sample)
{
XlHelper.WriteValue(Labels.LoNum);
sample.Subjects.Objects.ForEach(chain => XlHelper.WriteValue("1", Colors.SubjectHeader));
sample.Predicates.Objects.ForEach(chain => XlHelper.WriteValue("2", Colors.PredicateHeader));
sample.Uniforms.Objects.ForEach(chain => XlHelper.WriteValue("3", Colors.UniformsHeader));
sample.MeaningAuxParts.Objects.ForEach(chain => XlHelper.WriteValue("4", Colors.MeaningHeader));
sample.ChainsFromSubjects.Values.SelectMany(list => list)
.ForEach(o => XlHelper.WriteValue("5", _getChainHeaderColor(SentenceWordType.Subject)));
sample.ChainsFromPredicates.Values.SelectMany(list => list)
.ForEach(o => XlHelper.WriteValue("5", _getChainHeaderColor(SentenceWordType.Predicate)));
sample.ChainsFromMeaningParts.Values.SelectMany(list => list)
.ForEach(o => XlHelper.WriteValue("5", _getChainHeaderColor(SentenceWordType.MeaningPart)));
}
private void _writeBody(SimpleSentenceStats stats)
{
var bodyRows = ModelConverter.TransformToTableRows(stats);
var cellsCount = stats.AllObjects.Count();
_writeRows(bodyRows, cellsCount);
}
private static List<SentenceErrors> _getErrors(SimpleSentenceStats stats, int i)
{
var errorObjects = _getErrorObjects(stats);
return new List<SentenceErrors>
{
new SentenceErrors
{
SentenceId = i,
ErrorsType = ErrorType.MissedLinguisticObject,
ErrorObjects = _selectErrors(errorObjects, ErrorType.MissedLinguisticObject)
},
new SentenceErrors
{
SentenceId = i,
ErrorsType = ErrorType.SurplusLinguisticObject,
ErrorObjects = _selectErrors(errorObjects, ErrorType.SurplusLinguisticObject)
},
new SentenceErrors
{
SentenceId = i,
ErrorsType = ErrorType.DetectionDefect,
ErrorObjects = _selectErrors(errorObjects, ErrorType.DetectionDefect)
}
};
}
private void _chargePenalties(SimpleSentenceStats obj)
{
_chargePenalties(obj.Subjects.Objects);
_chargePenalties(obj.Predicates.Objects);
_chargePenalties(obj.Uniforms.Objects);
_chargePenalties(obj.MeaningAuxParts.Objects);
obj.ChainsFromMeaningParts.Values.ForEach(_chargePenalties);
obj.ChainsFromPredicates.Values.ForEach(_chargePenalties);
obj.ChainsFromSubjects.Values.ForEach(_chargePenalties);
}
private void _fillRows(SimpleSentenceStats stats)
{
_fillRowsFromObjectsGroup(stats.Subjects.Objects);
_fillRowsFromObjectsGroup(stats.Predicates.Objects);
_fillRowsFromObjectsGroup(stats.Uniforms.Objects);
_fillRowsFromObjectsGroup(stats.MeaningAuxParts.Objects);
stats.ChainsFromSubjects.Values.ForEach(_fillRowsFromObjectsGroup);
stats.ChainsFromPredicates.Values.ForEach(_fillRowsFromObjectsGroup);
stats.ChainsFromMeaningParts.Values.ForEach(_fillRowsFromObjectsGroup);
}
