AISDK/AIDiagnosisSystem/Vinno.AISDKForVet/Vinno.AI.VetHeartDiagnosisSDK/Tools/AIConvertHelper.cs

using System;
using System.Collections.Generic;
using Vinno.AI.CommonSDK.Enums;
using Vinno.AI.CommonSDK.Interfaces;
using Vinno.AI.CommonSDK.Models;
using Vinno.AI.CommonSDK.Models.Contours;
using Vinno.AI.CommonSDK.Models.Data;
using Vinno.AI.CommonSDK.Models.Descriptions;
using Vinno.AI.CommonSDK.Models.DetectedObjects;
using Vinno.AI.CommonSDK.Models.Geomtries;
using Vinno.AI.CommonSDK.Models.LabelExtraInfos;
using Vinno.AI.CommonSDK.Models.LabelGroups;
using Vinno.AI.CommonSDK.Models.Labels;
using Vinno.AI.CommonSDK.Models.Measurements;
using Vinno.AI.CommonSDK.Models.MeasureValues;
using Vinno.AI.CommonSDK.Models.ResultDatas;
using Vinno.AI.CommonSDK.Tools;
using Vinno.AI.VetHeartDiagnosisSDK.Models;

namespace Vinno.AI.VetHeartDiagnosisSDK.Tools
{
    internal class AIConvertHelper
    {
        internal static IReadOnlyDictionary<AIImageDataId, IReadOnlyList<IAIResultData>> ConvertTransResultListToAIResultDict(List<TransAIResultInfo> transResultList)
        {
            if (transResultList == null)
            {
                return null;
            }
            Dictionary<AIImageDataId, IReadOnlyList<IAIResultData>> result = new Dictionary<AIImageDataId, IReadOnlyList<IAIResultData>>();
            foreach (var item in transResultList)
            {
                AIImageDataId imageDataId = ConvertTransAIDataIdsToAIImageDataId(item.DataId);
                if (imageDataId == null)
                {
                    continue;
                }
                List<IAIResultData> resultDataList = new List<IAIResultData>();
                if (item.ResultDatas != null)
                {
                    foreach (var resultItem in item.ResultDatas)
                    {
                        var resultData = ConvertTransAIResultDatasToIAIResultData(resultItem);
                        if (resultData != null)
                        {
                            resultDataList.Add(resultData);
                        }
                    }
                }
                result.Add(imageDataId, resultDataList);
            }
            return result;
        }

        private static AIImageDataId ConvertTransAIDataIdsToAIImageDataId(TransAIDataIds item)
        {
            if (item == null)
            {
                return null;
            }
            switch (item.DataIdType)
            {
                case AIEnumDataIdType.ImageDataId:
                    return item.ImageDataId;

                default:
                    return null;
            }
        }

        private static IAIResultData ConvertTransAIResultDatasToIAIResultData(TransAIResultDatas transAIResultDatas)
        {
            if (transAIResultDatas == null)
            {
                return null;
            }
            switch (transAIResultDatas.ResultDataType)
            {
                case AIEnumResultDataType.RecognizedObjectsPerLabelGroup:
                    var transAIRecognizedObjectsPerLabelGroup = transAIResultDatas.RecognizedObjectsPerLabelGroup;
                    return ConvertTransAIRecognizedObjectsPerLabelGroupToAIRecognizedObjectsPerLabelGroup(transAIRecognizedObjectsPerLabelGroup);

                case AIEnumResultDataType.VetHeartLVArea:
                    var transAIVetHeartLVArea = transAIResultDatas.VetHeartLVArea;
                    return ConvertTransAIVetHeartLVAreaToAIVetHeartLVArea(transAIVetHeartLVArea);

                case AIEnumResultDataType.VetBRecognizedCardiacCycle:
                    var transVetBRecognizedCardiacCycle = transAIResultDatas.VetBRecognizedCardiacCycle;
                    return ConvertTransAIVetBRecognizedCardiacCycleToAIVetBRecognizedCardiacCycle(transVetBRecognizedCardiacCycle);

                default:
                    return null;
            }
        }

        private static AIRecognizedObjectsPerLabelGroup ConvertTransAIRecognizedObjectsPerLabelGroupToAIRecognizedObjectsPerLabelGroup(TransAIRecognizedObjectsPerLabelGroup transAIRecognizedObjectsPerLabelGroup)
        {
            if (transAIRecognizedObjectsPerLabelGroup == null)
            {
                return null;
            }
            var labelGroup = ConvertTransAILabelGroupsToIAILabelGroup(transAIRecognizedObjectsPerLabelGroup.LabelGroup);
            IAIDetectedObject[] detectedObjectList;
            if (transAIRecognizedObjectsPerLabelGroup.DetectedObjects == null)
            {
                detectedObjectList = null;
            }
            else
            {
                detectedObjectList = new IAIDetectedObject[transAIRecognizedObjectsPerLabelGroup.DetectedObjects.Count];
                int index = 0;
                foreach (var transDetectedObject in transAIRecognizedObjectsPerLabelGroup.DetectedObjects)
                {
                    var detectedObject = ConvertTransAIDetectedObjectsToIAIDetectedObject(transDetectedObject);
                    detectedObjectList[index] = detectedObject;
                    index++;
                }
            }
            return new AIRecognizedObjectsPerLabelGroup(labelGroup, detectedObjectList);
        }

        private static IAILabelGroup ConvertTransAILabelGroupsToIAILabelGroup(TransAILabelGroups transLabelGroup)
        {
            if (transLabelGroup == null)
            {
                return null;
            }
            switch (transLabelGroup.LabelGroupType)
            {
                case AIEnumILabelGroupType.LabelGroup:
                    return ConvertTransAILabelGroupToAILabelGroup(transLabelGroup.LabelGroup);

                default:
                    return null;
            }
        }

        private static AILabelGroup ConvertTransAILabelGroupToAILabelGroup(TransAILabelGroup transLabelGroup)
        {
            if (transLabelGroup == null)
            {
                return null;
            }
            var name = transLabelGroup.Name;
            List<IAILabel> labels = new List<IAILabel>();
            if (transLabelGroup.Labels != null)
            {
                labels = new List<IAILabel>();
                foreach (var transLabel in transLabelGroup.Labels)
                {
                    var label = ConvertTransAILabelsToIAILabel(transLabel);
                    if (label != null)
                    {
                        labels.Add(label);
                    }
                }
            }
            List<Type> validLabelExtraInfoTypes;
            if (transLabelGroup.ValidLabelExtraInfoTypes == null)
            {
                validLabelExtraInfoTypes = null;
            }
            else
            {
                validLabelExtraInfoTypes = new List<Type>();
                foreach (var extraInfoType in transLabelGroup.ValidLabelExtraInfoTypes)
                {
                    switch (extraInfoType)
                    {
                        case AIEnumLabelExtraInfoType.LesionMalignantDegreeLabelExtraInfo:
                            validLabelExtraInfoTypes.Add(typeof(AILesionMalignantDegreeLabelExtraInfo));
                            break;

                        case AIEnumLabelExtraInfoType.LesionInvolvedScopeLabelExtraInfo:
                            validLabelExtraInfoTypes.Add(typeof(AILesionInvolvedScopeLabelExtraInfo));
                            break;
                    }
                }
            }
            var labelGroup = new AILabelGroup(name, validLabelExtraInfoTypes);
            int index = 0;
            foreach (var label in labels)
            {
                labelGroup.RegistLabel(index, label.Name, label.ExtraInfos);
                index++;
            }
            return labelGroup;
        }

        private static IAILabel ConvertTransAILabelsToIAILabel(TransAILabels transLabel)
        {
            if (transLabel == null)
            {
                return null;
            }
            switch (transLabel.LabelType)
            {
                case AIEnumLabelType.Label:
                    return ConvertTransAILabelToAILabel(transLabel.Label);
            }
            return null;
        }

        private static AILabel ConvertTransAILabelToAILabel(TransAILabel transLabel)
        {
            if (transLabel == null)
            {
                return null;
            }
            var name = transLabel.Name;
            var groupName = transLabel.GroupName;
            var index = transLabel.Index;
            List<IAILabelExtraInfo> extraInfos;
            if (transLabel.ExtraInfos == null)
            {
                extraInfos = null;
            }
            else
            {
                extraInfos = new List<IAILabelExtraInfo>();
                foreach (var transExtraInfo in transLabel.ExtraInfos)
                {
                    var extraInfo = ConvertTransAILabelExtraInfosToIAILabelExtraInfo(transExtraInfo);
                    if (extraInfo != null)
                    {
                        extraInfos.Add(extraInfo);
                    }
                }
            }
            return new AILabel(name, index, groupName, extraInfos);
        }

        private static IAILabelExtraInfo ConvertTransAILabelExtraInfosToIAILabelExtraInfo(TransAILabelExtraInfos transExtraInfo)
        {
            if (transExtraInfo == null)
            {
                return null;
            }
            switch (transExtraInfo.LabelExtraInfoType)
            {
                case AIEnumLabelExtraInfoType.LesionMalignantDegreeLabelExtraInfo:
                    return transExtraInfo.LesionMalignantDegreeLabelExtraInfo;

                case AIEnumLabelExtraInfoType.LesionInvolvedScopeLabelExtraInfo:
                    return transExtraInfo.LesionInvolvedScopeLabelExtraInfo;
            }
            return null;
        }

        private static IAIDetectedObject ConvertTransAIDetectedObjectsToIAIDetectedObject(TransAIDetectedObjects transDetectedObject)
        {
            if (transDetectedObject == null)
            {
                return null;
            }
            switch (transDetectedObject.DetectedObjectType)
            {
                case AIEnumDetectedObjectType.DetectedObject:
                    return ConvertTransAIDetectedObjectToAIDetectedObject(transDetectedObject.DetectedObject);

                case AIEnumDetectedObjectType.ModuleRecognizedObject:
                    return ConvertTransAIModuleRecognizedObjectToAIModuleRecognizedObject(transDetectedObject.ModuleRecognizedObject);

                case AIEnumDetectedObjectType.ModuleStandardSectionResult:
                    return ConvertTransAIModuleStandardSectionResultToAIModuleStandardSectionResult(transDetectedObject.ModuleStandardSectionResult);
            }
            return null;
        }

        private static AIDetectedObjectV2 ConvertTransAIDetectedObjectToAIDetectedObject(TransAIDetectedObjectV2 transDetectedObject)
        {
            if (transDetectedObject == null)
            {
                return null;
            }
            var iAILabel = ConvertTransAILabelsToIAILabel(transDetectedObject.Label);
            var score = transDetectedObject.Score;
            var iAIGeomtry = ConvertTransAIGeomtriesToIAIGeometry(transDetectedObject.BoundingBox);
            var iAIContour = ConvertTransAIContoursToIAIContour(transDetectedObject.Contour);
            var iAIDescription = ConvertTransAIDescriptionsToIAIDescriptions(transDetectedObject.Description);
            IAIMeasurement[] iAIMeasurementsArray;
            if (transDetectedObject.Measurements == null)
            {
                iAIMeasurementsArray = null;
            }
            else
            {
                iAIMeasurementsArray = new IAIMeasurement[transDetectedObject.Measurements.Length];
                for (int i = 0; i < transDetectedObject.Measurements.Length; i++)
                {
                    iAIMeasurementsArray[i] = ConvertTransAIMeasurementsToIAIMeasurement(transDetectedObject.Measurements[i]);
                }
            }
            return new AIDetectedObjectV2(iAILabel, score, iAIGeomtry, iAIContour, iAIDescription, iAIMeasurementsArray);
        }

        private static IAIGeometry ConvertTransAIGeomtriesToIAIGeometry(TransAIGeomtries transAIGeomtries)
        {
            if (transAIGeomtries == null)
            {
                return null;
            }
            switch (transAIGeomtries.GeometryType)
            {
                case AIEnumGeometryType.Sector:
                    return AICommonConvertHelperV2.ConvertTransAISectorToAISector(transAIGeomtries.Sector);

                case AIEnumGeometryType.Rectangle:
                    return AICommonConvertHelperV2.ConvertTransAIRectangleToAIRectangle(transAIGeomtries.Rectangle);

                case AIEnumGeometryType.Rect:
                    return transAIGeomtries.Rect;

                case AIEnumGeometryType.RotatedRect:
                    return AICommonConvertHelperV2.ConvertTransAIRotatedRectToAIRotatedRect(transAIGeomtries.RotatedRect);

                case AIEnumGeometryType.Parallelogram:
                    return AICommonConvertHelperV2.ConvertTransAIParallelogramToAIParallelogram(transAIGeomtries.Parallelogram);

                case AIEnumGeometryType.Line:
                    return AICommonConvertHelperV2.ConvertTransAILineToAILine(transAIGeomtries.Line);

                case AIEnumGeometryType.Point:
                    return AICommonConvertHelperV2.ConvertTransAIPointToAIPoint(transAIGeomtries.Point);

                case AIEnumGeometryType.ConvexArrayUltrasoundImageRegion:
                    return AICommonConvertHelperV2.ConvertTransAIUltrasoundImageRegionToIAIUltrasoundImageRegion(transAIGeomtries.UltrasoundImageRegion);

                case AIEnumGeometryType.LinearArrayUltrasoundImageRegion:
                    return AICommonConvertHelperV2.ConvertTransAIUltrasoundImageRegionToIAIUltrasoundImageRegion(transAIGeomtries.UltrasoundImageRegion);
            }
            return null;
        }

        private static IAIContour ConvertTransAIContoursToIAIContour(TransAIContours transAIContours)
        {
            if (transAIContours == null)
            {
                return null;
            }
            switch (transAIContours.ContourType)
            {
                case AIEnumContourType.SimpleContour:
                    return AICommonConvertHelperV2.ConvertTransAISimpleContourToAISimpleContour(transAIContours.SimpleContour);

                case AIEnumContourType.AnnularContour:
                    return AICommonConvertHelperV2.ConvertTransAIAnnularContourToAIAnnularContour(transAIContours.AnnularContour);

                case AIEnumContourType.MultiHoleContour:
                    return AICommonConvertHelperV2.ConvertTransAIMultiHoleContourToAIMultiHoleContour(transAIContours.MultiHoleContour);

                case AIEnumContourType.MModeEPSSContour:
                    return ConvertTransAIMModeEPSSContourToAIMModeEPSSContour(transAIContours.MModeEPSSContour);

                case AIEnumContourType.VetMModeLVStudyContour:
                    return ConvertTransAIVetMModeLVStudyContourToAIVetMModeLVStudyContour(transAIContours.VetMModeLVStudyContour);
            }
            return null;
        }

        private static AIMModeEPSSContour ConvertTransAIMModeEPSSContourToAIMModeEPSSContour(TransAIMModeEPSSContour mModeEPSSContour)
        {
            if (mModeEPSSContour == null)
            {
                return null;
            }
            return new AIMModeEPSSContour(mModeEPSSContour.IVSDownContour);
        }
        private static AIVetMModeLVStudyContour ConvertTransAIVetMModeLVStudyContourToAIVetMModeLVStudyContour(TransAIVetMModeLVStudyContour vetMModeLVStudyContour)
        {
            if (vetMModeLVStudyContour == null)
            {
                return null;
            }
            return new AIVetMModeLVStudyContour(vetMModeLVStudyContour.IVSUpContour, vetMModeLVStudyContour.IVSDownContour, vetMModeLVStudyContour.LPWUPContour, vetMModeLVStudyContour.LPWDownContour);
        }

        private static IAIDescriptionV2 ConvertTransAIDescriptionsToIAIDescriptions(TransAIDescriptions transDescription)
        {
            if (transDescription == null)
            {
                return null;
            }
            return null;
        }

        private static IAIMeasurement ConvertTransAIMeasurementsToIAIMeasurement(TransAIMeasurements transAIMeasurements)
        {
            if (transAIMeasurements == null)
            {
                return null;
            }
            switch (transAIMeasurements.MeasurementType)
            {
                case AIEnumMeasurementType.TransverseLongitudinalDiameterMeasurement:
                    return AICommonConvertHelperV2.ConvertTransAITransverseLongitudinalDiameterMeasurementToAITransverseLongitudinalDiameterMeasurement(transAIMeasurements.TransverseLongitudinalDiameterMeasurement);

                case AIEnumMeasurementType.LongAxisLeftVentricleVolumeMeasurement:
                    return AICommonConvertHelperV2.ConvertTransAILongAxisLeftVentricleVolumeMeasurementToAILongAxisLeftVentricleVolumeMeasurement(transAIMeasurements.LongAxisLeftVentricleVolumeMeasurement);

                case AIEnumMeasurementType.VetBModeCalMeasurement:
                    return ConvertTransAIVetBModeCalMeasurementToAIVetBModeCalMeasurement(transAIMeasurements.VetBModeCalMeasurement);

                case AIEnumMeasurementType.VetLVAreaMeasurement:
                    return ConvertTransAIVetLVAreaMeasurementToAIVetLVAreaMeasurement(transAIMeasurements.VetLVAreaMeasurement);

                case AIEnumMeasurementType.VetLAAOMeasurement:
                    return ConvertTransAIVetLAAOMeasurementToAIVetLAAOMeasurement(transAIMeasurements.VetLAAOMeasurement);

                case AIEnumMeasurementType.VetBModeEPSSMeasurement:
                    return ConvertTransAIVetBModeEPSSMeasurementToAIVetBModeEPSSMeasurement(transAIMeasurements.VetBModeEPSSMeasurement);

                case AIEnumMeasurementType.VetLVInnerDiameterMeasurement:
                    return ConvertTransAIVetLVInnerDiameterMeasurementToAIVetLVInnerDiameterMeasurement(transAIMeasurements.VetLVInnerDiameterMeasurement);

                case AIEnumMeasurementType.VetMModeEPSSMeasurement:
                    return ConvertTransAIVetMModeEPSSMeasurementToAIVetMModeEPSSMeasurement(transAIMeasurements.VetMModeEPSSMeasurement);

                case AIEnumMeasurementType.VetMModeLVStudyMeasurement:
                    return ConvertTransAIVetMModeLVStudyMeasurementToAIVetMModeLVStudyMeasurement(transAIMeasurements.VetMModeLVStudyMeasurement);
            }
            return null;
        }

        private static AIVetBModeCalMeasurement ConvertTransAIVetBModeCalMeasurementToAIVetBModeCalMeasurement(TransAIVetBModeCalMeasurement vetBModeCalMeasurement)
        {
            if (vetBModeCalMeasurement == null)
            {
                return null;
            }
            var ivs = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetBModeCalMeasurement.IVSMeasurePosition);
            var lv = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetBModeCalMeasurement.LVMeasurePosition);
            var lpw = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetBModeCalMeasurement.LPWMeasurePosition);
            return new AIVetBModeCalMeasurement(ivs, lv, lpw, vetBModeCalMeasurement.CmPerPixel);
        }

        private static AIVetLVAreaMeasurement ConvertTransAIVetLVAreaMeasurementToAIVetLVAreaMeasurement(TransAIVetLVAreaMeasurement vetLVAreaMeasurement)
        {
            if (vetLVAreaMeasurement == null)
            {
                return null;
            }
            return new AIVetLVAreaMeasurement(vetLVAreaMeasurement.LVArea, vetLVAreaMeasurement.CmPerPixel, true);
        }

        private static AIVetLAAOMeasurement ConvertTransAIVetLAAOMeasurementToAIVetLAAOMeasurement(TransAIVetLAAOMeasurement vetLAAOMeasurement)
        {
            if (vetLAAOMeasurement == null)
            {
                return null;
            }
            var la = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetLAAOMeasurement.LAMarkPosition);
            var ao = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetLAAOMeasurement.AOMarkPosition);
            return new AIVetLAAOMeasurement(la, ao, vetLAAOMeasurement.CmPerPixel);
        }

        private static AIVetBModeEPSSMeasurement ConvertTransAIVetBModeEPSSMeasurementToAIVetBModeEPSSMeasurement(TransAIVetBModeEPSSMeasurement vetBModeEPSSMeasurement)
        {
            if (vetBModeEPSSMeasurement == null)
            {
                return null;
            }
            var epss = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetBModeEPSSMeasurement.EPSSMarkPosition);
            return new AIVetBModeEPSSMeasurement(epss, vetBModeEPSSMeasurement.CmPerPixel);
        }

        private static AIVetLVInnerDiameterMeasurement ConvertTransAIVetLVInnerDiameterMeasurementToAIVetLVInnerDiameterMeasurement(TransAIVetLVInnerDiameterMeasurement vetLVInnerDiameterMeasurement)
        {
            if (vetLVInnerDiameterMeasurement == null)
            {
                return null;
            }
            var lv = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetLVInnerDiameterMeasurement.LVInnerDiameterMarkPosition);
            return new AIVetLVInnerDiameterMeasurement(lv, vetLVInnerDiameterMeasurement.CmPerPixel);
        }

        private static AIVetMModeEPSSMeasurement ConvertTransAIVetMModeEPSSMeasurementToAIVetMModeEPSSMeasurement(TransAIVetMModeEPSSMeasurement vetMModeEPSSMeasurement)
        {
            if (vetMModeEPSSMeasurement == null)
            {
                return null;
            }
            var epss = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetMModeEPSSMeasurement.EPSSMarkPosition);
            return new AIVetMModeEPSSMeasurement(epss, vetMModeEPSSMeasurement.CmPerPixel);
        }

        private static AIVetMModeLVStudyMeasurement ConvertTransAIVetMModeLVStudyMeasurementToAIVetMModeLVStudyMeasurement(TransAIVetMModeLVStudyMeasurement vetMModeLVStudyMeasurement)
        {
            if (vetMModeLVStudyMeasurement == null)
            {
                return null;
            }
            var isved = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetMModeLVStudyMeasurement.IVSEDMeasurePosition);
            var isves = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetMModeLVStudyMeasurement.IVSESMeasurePosition);
            var lved = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetMModeLVStudyMeasurement.LVEDMeasurePosition);
            var lves = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetMModeLVStudyMeasurement.LVESMeasurePosition);
            var lpwed = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetMModeLVStudyMeasurement.LPWEDMeasurePosition);
            var lpwes = AICommonConvertHelperV2.ConvertTransAILineToAILine(vetMModeLVStudyMeasurement.LPWESMeasurePosition);
            return new AIVetMModeLVStudyMeasurement(isved, isves, lved, lves, lpwed, lpwes, vetMModeLVStudyMeasurement.CmPerPixel);
        }

        private static AIModuleRecognizedObject ConvertTransAIModuleRecognizedObjectToAIModuleRecognizedObject(TransAIModuleRecognizedObject transModuleRecognizedObject)
        {
            if (transModuleRecognizedObject == null)
            {
                return null;
            }
            var iAILabel = ConvertTransAILabelsToIAILabel(transModuleRecognizedObject.Label);
            var score = transModuleRecognizedObject.Score;
            var iAIGeomtry = ConvertTransAIGeomtriesToIAIGeometry(transModuleRecognizedObject.BoundingBox);
            var iAIContour = ConvertTransAIContoursToIAIContour(transModuleRecognizedObject.Contour);
            var iAIDescription = ConvertTransAIDescriptionsToIAIDescriptions(transModuleRecognizedObject.Description);
            IAIMeasurement[] iAIMeasurementsArray;
            if (transModuleRecognizedObject.Measurements == null)
            {
                iAIMeasurementsArray = null;
            }
            else
            {
                iAIMeasurementsArray = new IAIMeasurement[transModuleRecognizedObject.Measurements.Length];
                for (int i = 0; i < transModuleRecognizedObject.Measurements.Length; i++)
                {
                    iAIMeasurementsArray[i] = ConvertTransAIMeasurementsToIAIMeasurement(transModuleRecognizedObject.Measurements[i]);
                }
            }
            return new AIModuleRecognizedObject(iAILabel, score, iAIGeomtry, iAIContour, iAIDescription, iAIMeasurementsArray);
        }

        private static AIModuleStandardSectionResult ConvertTransAIModuleStandardSectionResultToAIModuleStandardSectionResult(TransAIModuleStandardSectionResult transModuleStandardSectionResult)
        {
            if (transModuleStandardSectionResult == null)
            {
                return null;
            }
            var iAILabel = ConvertTransAILabelsToIAILabel(transModuleStandardSectionResult.Label);
            var score = transModuleStandardSectionResult.Score;
            IAIMeasurement[] iAIMeasurementsArray;
            if (transModuleStandardSectionResult.Measurements == null)
            {
                iAIMeasurementsArray = null;
            }
            else
            {
                iAIMeasurementsArray = new IAIMeasurement[transModuleStandardSectionResult.Measurements.Length];
                for (int i = 0; i < transModuleStandardSectionResult.Measurements.Length; i++)
                {
                    iAIMeasurementsArray[i] = ConvertTransAIMeasurementsToIAIMeasurement(transModuleStandardSectionResult.Measurements[i]);
                }
            }
            return new AIModuleStandardSectionResult(iAILabel, score, iAIMeasurementsArray);
        }

        private static AIVetHeartLVArea ConvertTransAIVetHeartLVAreaToAIVetHeartLVArea(TransAIVetHeartLVArea transAIVetHeartLVArea)
        {
            if (transAIVetHeartLVArea == null)
            {
                return null;
            }
            var dataId = AICommonConvertHelperV2.ConvertTransDataIdToIAIDataId(transAIVetHeartLVArea.FrameId);
            return new AIVetHeartLVArea(dataId, transAIVetHeartLVArea.MeasureValue);
        }
        private static AIVetBRecognizedCardiacCycle ConvertTransAIVetBRecognizedCardiacCycleToAIVetBRecognizedCardiacCycle(TransAIVetBRecognizedCardiacCycle transVetBRecognizedCardiacCycle)
        {
            if (transVetBRecognizedCardiacCycle == null)
            {
                return null;
            }
            var cycleStartFrameId = AICommonConvertHelperV2.ConvertTransDataIdToIAIDataId(transVetBRecognizedCardiacCycle.StartFrameId);
            var cycleEndFrameId = AICommonConvertHelperV2.ConvertTransDataIdToIAIDataId(transVetBRecognizedCardiacCycle.EndFrameId);
            var endDiastoleFrameId = AICommonConvertHelperV2.ConvertTransDataIdToIAIDataId(transVetBRecognizedCardiacCycle.EndDiastoleFrame);
            var endSystoleFrameId = AICommonConvertHelperV2.ConvertTransDataIdToIAIDataId(transVetBRecognizedCardiacCycle.EndSystoleFrame);
            var edivsdia = AICommonConvertHelperV2.ConvertTransAIMeasureValuesToIAIMeasureValues(transVetBRecognizedCardiacCycle.EDIvsDia);
            var edlpwdia = AICommonConvertHelperV2.ConvertTransAIMeasureValuesToIAIMeasureValues(transVetBRecognizedCardiacCycle.EDLpwDia);
            var esivsdia = AICommonConvertHelperV2.ConvertTransAIMeasureValuesToIAIMeasureValues(transVetBRecognizedCardiacCycle.ESIvsDia);
            var eslpwdia = AICommonConvertHelperV2.ConvertTransAIMeasureValuesToIAIMeasureValues(transVetBRecognizedCardiacCycle.ESLpwDia);
            var score = transVetBRecognizedCardiacCycle.Score;
            if (edivsdia is AILengthMeasureValue && edlpwdia is AILengthMeasureValue && esivsdia is AILengthMeasureValue && eslpwdia is AILengthMeasureValue)
            {
                return new AIVetBRecognizedCardiacCycle(cycleStartFrameId, cycleEndFrameId, endDiastoleFrameId, endSystoleFrameId, (AILengthMeasureValue)edivsdia, (AILengthMeasureValue)edlpwdia, (AILengthMeasureValue)esivsdia, (AILengthMeasureValue)eslpwdia, score);
            }
            else
            {
                return null;
            }
        }
    }
}