Index: Riskeer/Common/src/Riskeer.Common.Service/RiskeerCommonDataSynchronizationService.cs
===================================================================
diff -u -rae6913dc9e65387cd005077a2f056b5cd2fd159f -r74be61490932801465aed774fde44995db15dffc
--- Riskeer/Common/src/Riskeer.Common.Service/RiskeerCommonDataSynchronizationService.cs	(.../RiskeerCommonDataSynchronizationService.cs)	(revision ae6913dc9e65387cd005077a2f056b5cd2fd159f)
+++ Riskeer/Common/src/Riskeer.Common.Service/RiskeerCommonDataSynchronizationService.cs	(.../RiskeerCommonDataSynchronizationService.cs)	(revision 74be61490932801465aed774fde44995db15dffc)
@@ -58,6 +58,39 @@
         }
 
         /// <summary>
+        /// Clears the illustration points of the provided hydraulic boundary location calculations.
+        /// </summary>
+        /// <param name="calculations">The calculations for which the illustration points need to be cleared.</param>
+        /// <returns>All objects changed during the clear.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculations"/> is <c>null</c>.</exception>
+        public static IEnumerable<IObservable> ClearHydraulicBoundaryLocationCalculationIllustrationPoints(IEnumerable<HydraulicBoundaryLocationCalculation> calculations)
+        {
+            if (calculations == null)
+            {
+                throw new ArgumentNullException(nameof(calculations));
+            }
+
+            var affectedCalculations = new List<HydraulicBoundaryLocationCalculation>();
+            foreach (HydraulicBoundaryLocationCalculation calculation in calculations)
+            {
+                if (calculation.HasOutput && calculation.Output.HasGeneralResult)
+                {
+                    HydraulicBoundaryLocationCalculationOutput originalOutput = calculation.Output;
+                    calculation.Output = new HydraulicBoundaryLocationCalculationOutput(originalOutput.Result,
+                                                                                        originalOutput.TargetProbability,
+                                                                                        originalOutput.TargetReliability,
+                                                                                        originalOutput.CalculatedProbability,
+                                                                                        originalOutput.CalculatedReliability,
+                                                                                        originalOutput.CalculationConvergence,
+                                                                                        null);
+                    affectedCalculations.Add(calculation);
+                }
+            }
+
+            return affectedCalculations;
+        }
+
+        /// <summary>
         /// Clears the output of the given <see cref="StructuresCalculation{T}"/>.
         /// </summary>
         /// <param name="calculation">The <see cref="StructuresCalculation{T}"/> to clear the output for.</param>
Index: Riskeer/Common/test/Riskeer.Common.Service.Test/RiskeerCommonDataSynchronizationServiceTest.cs
===================================================================
diff -u -rae6913dc9e65387cd005077a2f056b5cd2fd159f -r74be61490932801465aed774fde44995db15dffc
--- Riskeer/Common/test/Riskeer.Common.Service.Test/RiskeerCommonDataSynchronizationServiceTest.cs	(.../RiskeerCommonDataSynchronizationServiceTest.cs)	(revision ae6913dc9e65387cd005077a2f056b5cd2fd159f)
+++ Riskeer/Common/test/Riskeer.Common.Service.Test/RiskeerCommonDataSynchronizationServiceTest.cs	(.../RiskeerCommonDataSynchronizationServiceTest.cs)	(revision 74be61490932801465aed774fde44995db15dffc)
@@ -30,6 +30,7 @@
 using Riskeer.Common.Data.Hydraulics;
 using Riskeer.Common.Data.Structures;
 using Riskeer.Common.Data.TestUtil;
+using Riskeer.Common.Data.TestUtil.IllustrationPoints;
 
 namespace Riskeer.Common.Service.Test
 {
@@ -63,7 +64,7 @@
                 Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble())
             };
 
-            var calculations = new ObservableList<HydraulicBoundaryLocationCalculation>
+            HydraulicBoundaryLocationCalculation[] calculations =
             {
                 new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation()),
                 calculationWithOutput1,
@@ -85,6 +86,87 @@
         }
 
         [Test]
+        public void ClearHydraulicBoundaryLocationCalculationIllustrationPoints_CalculationsNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationIllustrationPoints(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("calculations", exception.ParamName);
+        }
+
+        [Test]
+        public void ClearHydraulicBoundaryLocationCalculationIllustrationPoints_CalculationsWithAndWithoutIllustrationPoints_ClearsIllustrationPointAndReturnsAffectedCalculations()
+        {
+            // Setup
+            var random = new Random(21);
+
+            var originalOutputWithIllustrationPoints1 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble(),
+                                                                                                           new TestGeneralResultSubMechanismIllustrationPoint());
+            var calculationWithIllustrationPoints1 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
+            {
+                Output = originalOutputWithIllustrationPoints1
+            };
+
+            var originalOutputWithIllustrationPoints2 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble(),
+                                                                                                           new TestGeneralResultSubMechanismIllustrationPoint());
+            var calculationWithIllustrationPoints2 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
+            {
+                Output = originalOutputWithIllustrationPoints2
+            };
+
+            var originalOutput1 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble());
+            var calculationWithOutput1 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
+            {
+                Output = originalOutput1
+            };
+
+            var originalOutput2 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble());
+            var calculationWithOutput2 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
+            {
+                Output = originalOutput2
+            };
+
+            HydraulicBoundaryLocationCalculation[] calculations =
+            {
+                new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation()),
+                calculationWithOutput1,
+                calculationWithIllustrationPoints1,
+                new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation()),
+                calculationWithOutput2,
+                calculationWithIllustrationPoints2,
+                new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
+            };
+
+            // Call
+            IEnumerable<IObservable> affectedCalculations = RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationIllustrationPoints(calculations);
+
+            // Assert
+            CollectionAssert.AreEquivalent(new[]
+            {
+                calculationWithIllustrationPoints1,
+                calculationWithIllustrationPoints2
+            }, affectedCalculations);
+
+            HydraulicBoundaryLocationCalculation[] calculationWithOutputs =
+            {
+                calculationWithOutput1,
+                calculationWithIllustrationPoints1,
+                calculationWithOutput2,
+                calculationWithIllustrationPoints2
+            };
+            Assert.IsTrue(calculationWithOutputs.All(calc => calc.HasOutput));
+            Assert.IsTrue(calculationWithOutputs.All(calc => !calc.Output.HasGeneralResult));
+
+            AssertHydraulicBoundaryLocationOutput(originalOutput1, calculationWithOutput1.Output);
+            AssertHydraulicBoundaryLocationOutput(originalOutput2, calculationWithOutput2.Output);
+
+            AssertHydraulicBoundaryLocationOutput(originalOutputWithIllustrationPoints1, calculationWithIllustrationPoints1.Output);
+            AssertHydraulicBoundaryLocationOutput(originalOutputWithIllustrationPoints2, calculationWithIllustrationPoints2.Output);
+        }
+
+        [Test]
         public void ClearCalculationOutput_CalculationNull_ThrowsArgumentNullException()
         {
             // Call
@@ -191,6 +273,17 @@
             }, affectedObjects);
         }
 
+        private static void AssertHydraulicBoundaryLocationOutput(HydraulicBoundaryLocationCalculationOutput expectedOutput,
+                                                                  HydraulicBoundaryLocationCalculationOutput actualOutput)
+        {
+            Assert.AreEqual(expectedOutput.Result, actualOutput.Result);
+            Assert.AreEqual(expectedOutput.CalculatedProbability, actualOutput.CalculatedProbability);
+            Assert.AreEqual(expectedOutput.CalculatedReliability, actualOutput.CalculatedReliability);
+            Assert.AreEqual(expectedOutput.TargetProbability, actualOutput.TargetProbability);
+            Assert.AreEqual(expectedOutput.TargetReliability, actualOutput.TargetReliability);
+            Assert.AreEqual(expectedOutput.CalculationConvergence, actualOutput.CalculationConvergence);
+        }
+
         private class TestStructureInput : StructuresInputBase<TestStructure>
         {
             public override bool IsStructureInputSynchronized