Improving Point Cloud Slice Parameter's Adjusting loop This part of the function is adjusting the sliceDepthSubtractor and startDepthSlice parameters that are used in order to take a geometrical slice (h) of a point cloud object (a[i]), that it will be used for determining if the object is a circle or not. 

If the slice it is containing too few points in order to make a circle determination, the slice is retaken with different parameters before throwing an exception. 

sliceDepthSubtractor and startDepthSlice are local parameters that are filled with data from XML file parsing class (The XML file is read at the application initialization inside of a dedicated class). Initial values are 1 (sliceDepthSubtractor) and 0.98 (startDepthSlice). 

The list of point cloud object (a) is given as a parameter to this method.

As I hate nested loops, I would like to improve this code. 

double sliceDepthSubtractor =  xlmClass.sliceDepthSubtractor; 
double startDepthSlice      =  xlmClass.startDepthSlice;
bool adjustSliceDepthSubtractor = true;
while (adjustSliceDepthSubtractor)
{
   adjustSliceDepthSubtractor = false;
   bool adjustingStartDepthSlice = true;
   while (adjustingStartDepthSlice)
   {
     adjustingStartDepthSlice = false;
     for (int i = 0; i &lt; Count; i++) 
     {     
        PointCloud h = TakeSlice(a[i],sliceDepthSubtractor, 
                     startDepthSlice);

       if ((h.PointCount &lt; 100) &amp;&amp; (startDepthSlice &gt; 0.10))
       {
         startDepthSlice  -= 0.1;
         adjustingStartDepthSlice  = true;
         break;    
       } 
       if ((h.PointCount &lt; 100) &amp;&amp; (sliceDepthSubtractor &lt; 3)) 
       { 
         sliceDepthSubtractor += 1;
         adjustSliceDepthSubtractor = true;
         break;    
       } 
       if (h.PointCount &lt; 100)
       {
         throw new ComputationException("Insufficient Points");
       }
       LmsSolver(h, a[i]);
     }      
   }
   if (adjustSliceDepthSubtractor) {continue;}
   Save(a);
}
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 :)