示例#1
0
        public void TestConvertColorArrayValid(string colorArrayString)
        {
            var expectedRGBColors = new[] { new RGBColorOption(0xFF, null, null), new RGBColorOption(0xFF, 0x80, null), new RGBColorOption(0xFF, 0x80, 0x40) };
            var actualRGBColors   = RTConverters.GetRGBColorArrayFromString(colorArrayString);

            Assert.AreEqual(expectedRGBColors, actualRGBColors);
        }
示例#2
0
        public void TestConvertStringArray(string stringArrayString)
        {
            var expectedStrings = new[] { "External", "parotid_l", "parotid_r" };
            var actualStrings   = RTConverters.GetStringArrayFromString(stringArrayString);

            Assert.AreEqual(expectedStrings, actualStrings);
        }
示例#3
0
        public void TestConvertColorInvalid(string colorString)
        {
            var exception = Assert.Throws <ArgumentException>(() => RTConverters.ConvertColor(colorString));

            Assert.True(exception.Message.Contains("Cannot parse "));
            Assert.True(exception.Message.Contains(" is not a hexadecimal string"));
        }
示例#4
0
        public void TestConvertBoolArrayInvalid()
        {
            var exception = Assert.Throws <ArgumentException>(() =>
                                                              RTConverters.GetBoolArrayFromString(" [ True, F, 1 ] "));

            Assert.True(exception.Message.Contains("Cannot parse array at index: 2"));
        }
示例#5
0
        public void TestConvertBoolArrayLastMissingValid(string boolArrayString)
        {
            var expectedBools = new bool?[] { true, false, null };
            var actualBools   = RTConverters.GetBoolArrayFromString(boolArrayString);

            Assert.AreEqual(expectedBools, actualBools);
        }
示例#6
0
        public void TestConvertBoolValid(
            bool expected, string value)
        {
            var actual = RTConverters.ConvertBool(value);

            Assert.AreEqual(expected, actual);
        }
示例#7
0
        public void TestConvertColorArrayInvalid()
        {
            var exception = Assert.Throws <ArgumentException>(() =>
                                                              RTConverters.GetRGBColorArrayFromString(" [ #ff,  FF80HH , #ff8040 ] "));

            Assert.True(exception.Message.Contains("Cannot parse array at index: 2"));
        }
示例#8
0
        public void TestConvertColorValid(
            byte r, byte?g, byte?b, string colorString)
        {
            var expectedRGBColour = new RGBColorOption(r, g, b);
            var actualRGBColor    = RTConverters.ConvertColor(colorString);

            Assert.AreEqual(expectedRGBColour, actualRGBColor);
        }
示例#9
0
        private string StatusRegToString(ushort statusReg)
        {
            List <int>    bitList    = RTConverters.UInt16ToIntList(statusReg);
            string        res        = "";
            List <String> bitStrings = new List <string>();
            int           tmp        = statusReg;

            tmp      &= ~RTConst.STAT_BATT_MASK;
            statusReg = (ushort)tmp;

            if (statusReg == 0)
            {
                return("(none)");
            }

            bitList = RTConverters.UInt16ToIntList(statusReg);

            if (bitList.Contains(RTConst.STAT_MEMFULL_LSH))
            {
                bitStrings.Add("mem full");
            }

            if (bitList.Contains(RTConst.STAT_ETA_ALARM_LSH))
            {
                bitStrings.Add("ETA alarm");
            }

            if (bitList.Contains(RTConst.STAT_BIN_ALARM_LSH))
            {
                bitStrings.Add("BIN alarm");
            }

            if (bitList.Contains(RTConst.STAT_MKT_ALARM_LSH))
            {
                bitStrings.Add("MKT alarm");
            }

            if (bitList.Contains(RTConst.STAT_SHL_ALARM_LSH))
            {
                bitStrings.Add("SHL alarm");
            }

            int i    = 0;
            int last = bitStrings.Count - 1;

            foreach (string s in bitStrings)
            {
                res += s;
                if (i < last)
                {
                    res += ", ";
                }
            }

            return(res);
        }
示例#10
0
        private string TryGetTempConversion(ushort temp)
        {
            try
            {
                return(RTConverters.FixedToString(temp));
            }
            catch
            {
            }

            return("(invalid)");
        }
示例#11
0
 private void AddRegItem(uint addr, string regName, ushort regValue, string noteStr)
 {
     string [] strArr = new string[]
     {
         RTConverters.HexUInt16((ushort)addr),
         regName,
         RTConverters.HexUInt16(regValue),
         regValue.ToString(),
         noteStr
     };
     RegList.Items.Add(new ListViewItem(strArr));
 }
示例#12
0
        /// <summary>
        /// Handle options, if no errors.
        /// </summary>
        /// <param name="opts">Command line options</param>
        /// <returns>Exit code.</returns>
        static int RunOptionsAndReturnExitCode(Options opts)
        {
            try
            {
                RTConverters.ConvertNiftiToDicom(opts.InFile, opts.ReferenceSeries, opts.StructureNames,
                                                 opts.StructureColors, opts.FillHoles, opts.ROIInterpretedTypes, opts.OutFile, opts.ModelNameAndVersion, opts.Manufacturer, opts.Interpreter);

                Console.WriteLine($"Successfully written {opts.OutFile}");
            }
            catch (Exception e)
            {
                Console.Error.WriteLine($"Error while processing: {e}");
                return(1);
            }

            return(0);
        }
示例#13
0
 private void ErrorItem(uint addr, string regStr, string errorStr)
 {
     RegList.Items.Add(new ListViewItem(new string[] { RTConverters.HexUInt16((ushort)addr), regStr, "0", "0", errorStr }));
 }
示例#14
0
        private void ReadRegs()
        {
            SetupGrid();
            ushort[] regs;
            uint     curAddr;
            string   tmp = "";

            curAddr = RTRegs.CONTROL;
            try
            {
                regs = mTag.ReadMultipleRegs(curAddr, 2);
                tmp  = "";
                if ((regs[0] & (RTConst.CTL_LOGEN_MASK | RTConst.CTL_DLYEN_MASK)) != 0)
                {
                    tmp = "Enabled: ";
                    if ((regs[0] & RTConst.CTL_LOGEN_MASK) != 0)
                    {
                        tmp += "logging";
                    }

                    if ((regs[0] & RTConst.CTL_DLYEN_MASK) != 0)
                    {
                        if ((regs[0] & RTConst.CTL_LOGEN_MASK) != 0)
                        {
                            tmp += ", ";
                        }
                        tmp += "start delay";
                    }
                }
                else
                {
                    tmp = "Logging not enabled";
                }

                AddRegItem(curAddr++, "Control", regs[0], tmp);
                AddRegItem(curAddr, "Sampling delay", regs[1], "Seconds");
            }
            catch (Exception e)
            {
                ErrorItem(curAddr++, "Control enable", e.Message);
                ErrorItem(curAddr, "Sampling delay", e.Message);
            }

            curAddr = RTRegs.BIN_ENABLE;
            try
            {
                regs = mTag.ReadMultipleRegs(curAddr, 3);
                AddRegItem(curAddr++, "BIN enable", regs[0], "Enabled: " + RTConverters.IntListToString(RTConverters.UInt16ToIntList(regs[0])));
                AddRegItem(curAddr++, "BIN sample store", regs[1], "Enabled: " + RTConverters.IntListToString(RTConverters.UInt16ToIntList(regs[1])));
                AddRegItem(curAddr, "BIN timestamp store", regs[2], "Enabled: " + RTConverters.IntListToString(RTConverters.UInt16ToIntList(regs[2])));
            }
            catch (Exception e)
            {
                ErrorItem(curAddr++, "BIN enable", e.Message);
                ErrorItem(curAddr++, "BIN sample store", e.Message);
                ErrorItem(curAddr, "BIN timestamp store", e.Message);
            }

            curAddr = RTRegs.SAMPLES_NUM;
            try
            {
                regs = mTag.ReadMultipleRegs(curAddr, 1);
                AddRegItem(curAddr, "Sample count", regs[0], "");
            }
            catch (Exception e)
            {
                ErrorItem(curAddr, "Sample count", e.Message);
            }

            curAddr = RTRegs.BIN_SAMPLETIME_BASE;
            try
            {
                regs = mTag.ReadMultipleRegs(curAddr, 1);
                AddRegItem(curAddr, "Sample time[0]", regs[0], "Seconds");
            }
            catch (Exception e)
            {
                ErrorItem(curAddr, "Sample time[0]", e.Message);
            }

            curAddr = RTRegs.BIN_THRESHOLD_BASE;
            try
            {
                regs = mTag.ReadMultipleRegs(curAddr, 1);
                AddRegItem(curAddr, "BIN threshold[0]", regs[0], "Celsius: " + TryGetTempConversion(regs[0]));
            }
            catch (Exception e)
            {
                ErrorItem(curAddr, "BIN threshold[0]", e.Message);
            }

            curAddr = RTRegs.BIN_HLIMIT_BASE;
            try
            {
                regs = mTag.ReadMultipleRegs(curAddr, 1);
                AddRegItem(curAddr, "BIN high limit[0]", regs[0], "Celsius: " + TryGetTempConversion(regs[0]));
            }
            catch (Exception e)
            {
                ErrorItem(curAddr, "BIN high limit[0]", e.Message);
            }

            curAddr = RTRegs.BIN_ALARM;
            try
            {
                regs = mTag.ReadMultipleRegs(curAddr, 1);
                AddRegItem(curAddr, "BIN alarms", regs[0], "Set: " + RTConverters.IntListToString(RTConverters.UInt16ToIntList(regs[0])));
            }
            catch (Exception e)
            {
                ErrorItem(curAddr, "BIN alarms", e.Message);
            }

            curAddr = RTRegs.STATUS;
            try
            {
                ushort batt;
                regs = mTag.ReadMultipleRegs(curAddr, 1);
                batt = (ushort)(regs[0] & RTConst.STAT_BATT_MASK);
                //AddRegItem(curAddr, "Status", regs[0], "Set: " + RTConverters.IntListToString(RTConverters.UInt16ToIntList(regs[0])));
                AddRegItem(curAddr, "Status", regs[0], "Set: " + StatusRegToString(regs[0]));
                AddRegItem(curAddr, "STAT: battery", batt, "Level = " + batt.ToString());
            }
            catch (Exception e)
            {
                ErrorItem(curAddr, "Status", e.Message);
            }
        }
示例#15
0
        /// <summary>
        /// Test Nifti file to DICOM-RT translation.
        /// </summary>
        /// <param name="niftiFilename">Source Nifti file.</param>
        /// <param name="referenceSeries">Reference DICOM series folder.</param>
        /// <param name="structureNames">List of structure names for DICOM-RT.</param>
        /// <param name="structureColors">List of structure colours for DICOM-RT.</param>
        /// <param name="fillHoles">List of fill hole flags for DICOM-RT.</param>
        /// <param name="roiInterpretedType">List of roiInterpretedType for DICOM-RT.</param>
        /// <param name="debugFolderName">If present, create a full set of debug images.</param>
        /// <param name="testVolumesMatch">If true, check the volumes match.</param>
        /// <param name="expectedNiftiFilename">Expect volume to match Nifti file.</param>
        public static void DoTestNiftiToDicom(
            string niftiFilename,
            string referenceSeries,
            string[] structureNames,
            RGBColorOption?[] structureColors,
            bool?[] fillHoles,
            ROIInterpretedType[] roiInterpretedTypes,
            string debugFolderName,
            bool testVolumesMatch,
            string expectedNiftiFilename)
        {
            var outputFileName = Path.GetRandomFileName() + ".dcm";

            RTConverters.ConvertNiftiToDicom(
                niftiFilename,
                referenceSeries,
                structureNames,
                structureColors,
                fillHoles,
                roiInterpretedTypes,
                outputFileName,
                "modelX:1",
                "manufacturer",
                "interpreter");

            // Open the newly created DICOM-RT file
            var dicomRTFile = DicomFile.Open(outputFileName);

            // Get the medical volume from the reference
            var acceptanceTests         = new ModerateGeometricAcceptanceTest(string.Empty, string.Empty);
            var referenceMedicalVolumes = MedIO.LoadAllDicomSeriesInFolderAsync(referenceSeries, acceptanceTests).Result;

            Assert.AreEqual(1, referenceMedicalVolumes.Count);

            var referenceMedicalVolume = referenceMedicalVolumes.First().Volume;

            var referenceIdentifiers = referenceMedicalVolume.Identifiers.First();

            // Extract the RTStruct from the DICOM-RT file
            var reloaded = RtStructReader.LoadContours(
                dicomRTFile.Dataset,
                referenceMedicalVolume.Volume.Transform.DicomToData,
                referenceIdentifiers.Series.SeriesInstanceUid,
                referenceIdentifiers.Study.StudyInstanceUid);

            Assert.IsNotNull(reloaded);

            var reloadedRTStruct = reloaded.Item1;

            Assert.AreEqual(referenceIdentifiers.Patient.Id, reloadedRTStruct.Patient.Id);
            Assert.AreEqual(referenceIdentifiers.Study.StudyInstanceUid, reloadedRTStruct.Study.StudyInstanceUid);
            Assert.AreEqual(DicomRTSeries.RtModality, reloadedRTStruct.RTSeries.Modality);

            // Load the nifti file
            var sourceVolume = MedIO.LoadNiftiAsByte(expectedNiftiFilename);

            // Split this volume from segment id to a set of mask volumes
            var labels = VolumeMetadataMapper.MultiLabelMapping(sourceVolume, structureNames.Length);

            // Make tuples of mask volume, color, names, fill holes.
            var volumesWithMetadata = VolumeMetadataMapper.MapVolumeMetadata(labels, structureNames, structureColors, fillHoles, roiInterpretedTypes).ToArray();

            Assert.AreEqual(structureNames.Length, reloadedRTStruct.Contours.Count);

            for (int i = 0; i < reloadedRTStruct.Contours.Count; i++)
            {
                var contourVolumes = new Volume3D <byte>(
                    referenceMedicalVolume.Volume.DimX,
                    referenceMedicalVolume.Volume.DimY,
                    referenceMedicalVolume.Volume.DimZ,
                    referenceMedicalVolume.Volume.SpacingX,
                    referenceMedicalVolume.Volume.SpacingY,
                    referenceMedicalVolume.Volume.SpacingZ,
                    referenceMedicalVolume.Volume.Origin,
                    referenceMedicalVolume.Volume.Direction);

                contourVolumes.Fill(reloadedRTStruct.Contours[i].Contours, (byte)1);

                var v = volumesWithMetadata[i];

                if (!string.IsNullOrWhiteSpace(debugFolderName))
                {
                    for (var z = 0; z < referenceMedicalVolume.Volume.DimZ; z++)
                    {
                        var actualFileName = Path.Combine(debugFolderName, "actual", $"slice_{v.name}_{z}.png");
                        var actualSlice    = contourVolumes.Slice(SliceType.Axial, z);
                        actualSlice.SaveBinaryMaskToPng(actualFileName);

                        var expectedFileName = Path.Combine(debugFolderName, "expected", $"slice_{v.name}_{z}.png");
                        var expectedSlice    = v.volume.Slice(SliceType.Axial, z);
                        expectedSlice.SaveBinaryMaskToPng(expectedFileName);
                    }
                }

                if (testVolumesMatch)
                {
                    VolumeAssert.AssertVolumesMatch(v.volume, contourVolumes, $"Loaded mask {i}");
                }

                Assert.AreEqual(v.name, reloadedRTStruct.Contours[i].StructureSetRoi.RoiName, $"Loaded mask name {i}");

                var expectedColor = Tuple.Create(v.color.R, v.color.G, v.color.B);
                Assert.AreEqual(expectedColor, reloadedRTStruct.Contours[i].DicomRtContour.RGBColor, $"Loaded color {i}");
            }
        }
示例#16
0
        public void TestConvertBoolInvalid(string value)
        {
            var exception = Assert.Throws <ArgumentException>(() => RTConverters.ConvertBool(value));

            Assert.True(exception.Message.Contains("Cannot parse bool "));
        }