Beispiel #1
0
        /// <summary>
        /// Construct the comparison object that we'll be using for this current run. Once
        /// we have it, we need only call the `Run` method on the result.
        /// </summary>
        /// <param name="fromRequest"><see cref="ComparisonRequest"/>: The representation of the current request.</param>
        /// <param name="withOptions"><see cref="ComparisonOptions"/>: The options that will be used for the request.</param>
        /// <returns>The comparison object, that will handle the current request.</returns>
        /// <exception cref="ArgumentOutOfRangeException">Throws if we get a <see cref="ComparisonWith"/>
        /// value that isn't recognized.</exception>
        public ICompareImages Construct(ComparisonRequest fromRequest, ComparisonOptions withOptions)
        {
            ICompareImages imageComparer;

            switch (fromRequest.With)
            {
            case ComparisonWith.All:
                imageComparer = new DirectoryComparison(
                    new BasicHashProvider(),
                    new HashComparison(withOptions.BiasPercent),
                    withOptions);
                break;

            case ComparisonWith.Pair:
                imageComparer = new PairComparison(
                    new BasicHashProvider(),
                    new PixelComparison(withOptions),
                    withOptions);
                break;

            case ComparisonWith.Single:
                imageComparer = new SingleComparison(
                    new BasicHashProvider(),
                    new HashComparison(withOptions.BiasPercent),
                    withOptions);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            return(imageComparer);
        }
        public void CompareWithNullException()
        {
            var dta = new Dta(false, 0, 0);
            var ret = new SingleComparison(dta, 0, 0, 0);

            Assert.ThrowsException <ArgumentNullException>(() => ret.Equals(null));
        }
        public void InitializationTestTotalFailed()
        {
            var dta = new Dta(false, 0, 0);
            var ret = new SingleComparison(dta, 100, 10, 1);

            Assert.AreEqual(1, ret.TotalFailed);
        }
        public void EqualsTrueTest()
        {
            var dta = new Dta(false, 0, 0);
            var ret = new SingleComparison(dta, 0, 0, 0);

            Assert.IsTrue(ret.Equals(ret));
        }
        public void CanInitialize()
        {
            var dta = new Dta(false, 0, 0);
            var ret = new SingleComparison(dta, 0, 0, 0);

            Assert.IsNotNull(ret);
        }
        public void EqualsFalseTest1()
        {
            var dta  = new Dta(false, 0, 0);
            var ret  = new SingleComparison(dta, 0, 0, 0);
            var ret2 = new SingleComparison(dta, 1, 0, 0);

            Assert.IsFalse(ret2.Equals(ret));
        }
        public void CompareRelativeResult()
        {
            sourceFile = DSCTests.Properties.Resources.RD_UnitTest_P1_5_mm_X_100A_10_0_5;

            source = new Model.DoseMatrixOptimal(new EvilDICOM.RT.DoseMatrix(EvilDICOM.Core.DICOMObject.Read(sourceFile)));
            SingleComparison result1 = mathematics.CompareRelative(source, source, dta00a);

            Assert.AreEqual(0, result1.TotalFailed);              // confirm all voxels are compared
            Assert.AreEqual(source.Count, result1.TotalCompared); //confirms the number of failed voxels is zero
        }
        public void  CompareParallelVsAbsoluteThreadMax1_2()
        {
            byte[] refFile    = DSCTests.Properties.Resources.RD_UnitTest_P1_5_mm_X_100A_10_0_5;
            byte[] targetFile = DSCTests.Properties.Resources.RD_UnitTest_P1_5_mm_X_100A_10_0_5;

            refDose    = new Model.DoseMatrixOptimal(new EvilDICOM.RT.DoseMatrix(EvilDICOM.Core.DICOMObject.Read(refFile)));
            targetDose = new Model.DoseMatrixOptimal(new EvilDICOM.RT.DoseMatrix(EvilDICOM.Core.DICOMObject.Read(targetFile)));
            SingleComparison result1 = mathematics.CompareAbsolute(refDose, targetDose, dtas[DtaTypes.t0d0p0mm]);
            SingleComparison result2 = mathematics.CompareParallel(refDose, targetDose, dtas[DtaTypes.t0d0p0mm], threadMax);

            System.Diagnostics.Debug.WriteLine("Compared");
            Assert.AreEqual(result1.TotalCompared, result2.TotalCompared); // confirm all voxels are compared
        }
Beispiel #9
0
        public void SelfComparison()
        {
            sourceFile = DSCcoreTest.Properties.Resources.RD_UnitTest_P1Ref_X_100A_10_0_1;
            source     = new DoseMatrixOptimal(new EvilDICOM.RT.RTDose(EvilDICOM.Core.DICOMObject.Read(sourceFile)));
            SingleComparison result1 = mathematics.CompareAbsolute(source, source, dta00a);

            System.Diagnostics.Debug.WriteLine("Count");
            Assert.AreEqual(8080200, result1.TotalCount);
            System.Diagnostics.Debug.WriteLine("Compared");
            Assert.AreEqual(8080200, result1.TotalCompared);
            System.Diagnostics.Debug.WriteLine("Failed");
            Assert.AreEqual(0, result1.TotalFailed);
        }
        public void CompareRelativeSampleTest()
        {
            byte[] refFile    = DSCTests.Properties.Resources.RD_UnitTest_P1Ref_X_100A_10_0_1;
            byte[] targetFile = DSCTests.Properties.Resources.RD_UnitTest_P1Ref_X_100A_10_0_1;

            refDose    = new Model.DoseMatrixOptimal(new EvilDICOM.RT.DoseMatrix(EvilDICOM.Core.DICOMObject.Read(refFile)));
            targetDose = new Model.DoseMatrixOptimal(new EvilDICOM.RT.DoseMatrix(EvilDICOM.Core.DICOMObject.Read(targetFile)));
            SingleComparison result = mathematics.CompareRelative(refDose, targetDose, dtas[DtaTypes.t0d0p0mm]);
            int expectedFail        = 0;

            System.Diagnostics.Debug.WriteLine("Compared");
            Assert.AreEqual(targetDose.Count, result.TotalCompared); // confirm all voxels are compared
            System.Diagnostics.Debug.WriteLine("Failed");
            Assert.AreEqual(expectedFail, result.TotalFailed);       //confirms the number of failed voxels is zero
        }
Beispiel #11
0
        public void CompareParallelVsAbsoluteThreadMax2()
        {
            byte[] refFile    = DSCcoreTest.Properties.Resources.RD_UnitTest_P1Ref_X_100A_10_0_1;
            byte[] targetFile = DSCcoreTest.Properties.Resources.RD_UnitTest_P5_Varied_MU_X_095A_10_0_1;

            refDose    = new Model.DoseMatrixOptimal(new EvilDICOM.RT.RTDose(EvilDICOM.Core.DICOMObject.Read(refFile)));
            targetDose = new Model.DoseMatrixOptimal(new EvilDICOM.RT.RTDose(EvilDICOM.Core.DICOMObject.Read(targetFile)));
            SingleComparison result1 = mathematics.CompareAbsolute(refDose, targetDose, dtas[DtaTypes.t0d0p0mm]);
            SingleComparison result2 = mathematics.CompareParallel(refDose, targetDose, dtas[DtaTypes.t0d0p0mm], ThreadMax);

            System.Diagnostics.Debug.WriteLine("Compared");
            Assert.AreEqual(result1.TotalCompared, result2.TotalCompared); // confirm all voxels are compared
            System.Diagnostics.Debug.WriteLine("Failed");
            Assert.AreEqual(result1.TotalFailed, result2.TotalFailed);     //confirms the number of failed voxels is zero
        }
Beispiel #12
0
        public void Mu100vs101_SNC002()
        {
            // Compares algorithm result to SNC patient
            // RD.UnitTest.P1Ref.X-100A-10.0-1	RD.UnitTest.P5 Varied MU.X-101A-10.0-1	29	15523	15552	DTA     10	0.1	0	Abs
            Dta dta = new Dta(false, 0.1, 0.001, 0, false, false, 0);

            sourceFile = DSCcoreTest.Properties.Resources.RD_UnitTest_P1Ref_X_100A_10_0_1;
            targetFile = DSCcoreTest.Properties.Resources.RD_UnitTest_P5_Varied_MU_X_101A_10_0_1;
            source     = new DoseMatrixOptimal(new EvilDICOM.RT.RTDose(EvilDICOM.Core.DICOMObject.Read(sourceFile)));
            target     = new DoseMatrixOptimal(new EvilDICOM.RT.RTDose(EvilDICOM.Core.DICOMObject.Read(targetFile)));


            SingleComparison result1 = mathematics.CompareRelative(source, target, dta);

            System.Diagnostics.Debug.WriteLine("Compared");
            Assert.AreEqual(8080200, result1.TotalCompared);
        }