public void MsaglMoveToMaximizeMinimumAngle()

in GraphLayout/MSAGL/GraphmapsWithMesh/Tiling.cs [281:381]
84 lines of code
26 McCabe index (conditional complexity)

        public void MsaglMoveToMaximizeMinimumAngle()
        {
#if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=340
            throw new InvalidOperationException();
#else
            int[,] listNeighbors = new int[20, 3];
            double[] d = new double[10];
            int a = 0, b = 0, mincostA = 0, mincostB = 0;
            bool localRefinementsFound = true;
            int iteration = 10;
            int offset = iteration * 2;

            while (localRefinementsFound && iteration > 0)
            {
                iteration--;
                localRefinementsFound = false;


                for (int index = N; index < NumOfnodes; index++)
                {
                    Vertex w = VList[index];

                    int numNeighbors = 0;
                    double profit = 0;

                    for (int k = 0; k < DegList[w.Id]; k++)
                    {
                        numNeighbors++;
                        listNeighbors[numNeighbors, 1] = EList[w.Id, k].NodeId;
                        listNeighbors[numNeighbors, 2] = k;
                    }

                    if (numNeighbors <= 1) continue;

                    for (int counter = 1; counter <= 9; counter++)
                    {
                        d[counter] = 0;

                        if (counter == 1) { a = 1; b = 1; }
                        if (counter == 2) { a = 0; b = 1; }
                        if (counter == 3) { a = -1; b = 1; }
                        if (counter == 4) { a = -1; b = 0; }
                        if (counter == 5) { a = -1; b = -1; }
                        if (counter == 6) { a = 0; b = -1; }
                        if (counter == 7) { a = 1; b = -1; }
                        if (counter == 8) { a = 1; b = 0; }
                        if (counter == 9) { a = 0; b = 0; }


                        for (int k = 1; k <= numNeighbors; k++)
                        {
                            double length = Math.Sqrt((w.XLoc + a - VList[listNeighbors[k, 1]].XLoc) *
                                          (w.XLoc + a - VList[listNeighbors[k, 1]].XLoc)
                                          +
                                          (w.YLoc + b - VList[listNeighbors[k, 1]].YLoc) *
                                          (w.YLoc + b - VList[listNeighbors[k, 1]].YLoc)
                                    );
                            if (length < 1)
                            {
                                mincostA = 0; mincostB = 0;
                                break;
                            }

                            // *try to maximize min angle
                            d[counter] = 3.1416;
                            for (int l = 1; l <= numNeighbors; l++)
                            {
                                if (l == k) continue;
                                d[counter] = Math.Min(d[counter],
                                    Angle.getAngleIfSmallerThanPIby2(new Vertex(w.XLoc + a, w.YLoc + b),
                                        VList[listNeighbors[k, 1]], VList[listNeighbors[l, 1]]));
                            }

                        }
                        // *try to maximize min angle
                        if (profit < d[counter])
                        {
                            profit = d[counter]; mincostA = a; mincostB = b;
                        }


                    }
                    if (!(mincostA == 0 && mincostB == 0))
                    {
                        w.XLoc += mincostA;
                        w.YLoc += mincostB;
                        if (GetNode(w.XLoc, w.YLoc) == -1 || MsaglGoodResolution(w, listNeighbors, numNeighbors, offset) == false || noCrossings(w) == false)
                        {
                            w.XLoc -= mincostA;
                            w.YLoc -= mincostB;
                        }
                        else
                        {
                            localRefinementsFound = true;
                        }
                    }

                }
            }
#endif
        }