Improving Point Cloud Slice Parameter's Adjusting loop
You are using the same pattern in both your loops - enable some flag before the loop, and disable that flag immediately as you enter the loop. So basically you want to always enter the loop and always exit loop unless something will enable the flag. 

bool flag = true;
while (flag)
{
    flag = false;
    // ...
    // some condition can set flag to true

    if (flag)
      continue;
}


Same can be achieved without using a flag - use infinite loop and break it only when your exit condition happen

while (true)
{
    // ...
    if (sliceDepthSubstractorAdjusted)
       break;        
}


Now, what about nested loop? I stick to single indentation level rule of thumb. To avoid arrow anti-pattern. You can move loop logic to separate method and return outer exit loop condition from that method. Thus you can keep loop even without a body:

while (!TryAdjustSliceDepthSubstructor()) {}


Pretty descriptive - repeat adjustment until it done. But you should pass different values to that method - a, sliceDepthSubtractor, startDepthSlice. And this code will not look so good with all these parameters flying around. The reason is that we keep data and logic separated. So simply put logic (points adjustment with some parameters) and data (parameters) into the class.

public class Butcher// Of course, you should change the name
{
     private double sliceDepthSubtractor;
     private double startDepthSlice;

     public Butcher(double sliceDepthSubtractor, double startDepthSlice)
     {
         // initialize fields here
     }

     public void AdjustForSlicing(List&lt;PointCloud&gt; points) { ... }

     // TakeSlice
     // lmsSolver
}


Now you can initialize this class and your code with outer loop will look like

var points // List&lt;PointCloud&gt;
var butcher = new Butcher(xlm.sliceDepthSubtractor, xlm.startDepthSlice);
butcher.AdjustForSlicing(points);
Save(points); // use PascalCase names for methods




Looks clean. Let's look inside

public void AdjustForSlicing(List&lt;PointCloud&gt; points)
{
    while(!AllSlicesContainEnoughPoints(points)) // surprise - single loop here
    {
        if (CanAdjustStartDepthSlice)
        {
            startDepthSlice -= 0.1;
            continue;
        }

        if (CanAdjustDepthSubstractor)
        {
            // NOTE: Consider to reset startDepthSlice here
            sliceDepthSubtractor += 1;
            continue;
        }

        throw new ComputationException("Insufficient Points");        
    }
}

private bool AllSlicesContainEnoughPoints(List&lt;PointCloud&gt; points)
{
    const int minCountOfPointsInSlice = 100;

    foreach(var point in points)
    {
        var slice = TakeSlice(point, sliceDepthSubtractor, startDepthSlice);

        if (slice.PointCount &lt; minCountOfPointsInSlice)
            return false;

        lmsSolver(slice, point);
    }

    return true;
}


And a couple of helper methods. Consider replacing magic numbers with constants

private bool CanAdjustStartDepthSlice =&gt; startDepthSlice &gt; 0.1;
private bool CanAdjustDepthSubstractor =&gt; sliceDepthSubtractor &lt; 3;


Now you can read this code as a specification.

Note: Probably we should not modify initial values of startDepthSlice and  sliceDepthSubtractor when we are adjusting points in order to be able to call butcher serveral times. But I'll leave this exercise for you :)