private void fixedPointSimplestCaseNonCyclicFillRaster(int[] pixels,
                                                           int off,
                                                           int adjust,
                                                           int x, int y,
                                                           int w, int h) {
        float iSq = 0;  // Square distance index
        final float indexFactor = fastGradientArraySize / radius;

        //constant part of X and Y coordinates for the entire raster
        final float constX = (a00 * x) + (a01 * y) + constA;
        final float constY = (a10 * x) + (a11 * y) + constB;
        final float deltaX = indexFactor * a00; //incremental change in dX
        final float deltaY = indexFactor * a10; //incremental change in dY
        float dX, dY; //the current distance from center
        final int fixedArraySizeSq =
                (fastGradientArraySize * fastGradientArraySize);
        float g, gDelta, gDeltaDelta, temp; //gradient square value
        int gIndex; // integer number used to index gradient array
        int iSqInt; // Square distance index

        int end, j; //indexing variables
        int indexer = off;//used to index pixels array

        temp = ((deltaX * deltaX) + (deltaY * deltaY));
        gDeltaDelta = ((temp * 2));

        if (temp > fixedArraySizeSq) {
            // This combination of scale and circle radius means
            // essentially no pixels will be anything but the end
            // stop color.  This also avoids math problems.
            final int val = gradientOverflow;
            for (j = 0; j < h; j++) { //for every row
                //for every column (inner loop begins here)
                for (end = indexer + w; indexer < end; indexer++)
                    pixels[indexer] = val;
                indexer += adjust;
            }
            return;
        }

        // For every point in the raster, calculate the color at that point
        for (j = 0; j < h; j++) { //for every row
            //x and y (in user space) of the first pixel of this row
            dX = indexFactor * ((a01 * j) + constX);
            dY = indexFactor * ((a11 * j) + constY);

            // these values below here allow for an incremental calculation
            // of dX^2 + dY^2

            //initialize to be equal to distance squared
            g = (((dY * dY) + (dX * dX)));
            gDelta = (deltaY * dY + deltaX * dX) * 2 + temp;

            //for every column (inner loop begins here)
            for (end = indexer + w; indexer < end; indexer++) {
                //determine the distance to the center

                //since this is a non cyclic fill raster, crop at "1" and 0
                if (g >= fixedArraySizeSq) {
                    pixels[indexer] = gradientOverflow;
                }

                // This should not happen as gIndex is a square
                // quantity. Code commented out on purpose, can't underflow.
                // else if (g < 0) {
                //    gIndex = 0;
                // }

                else {
                    iSq = (g * invSqStepFloat);

                    iSqInt = (int) iSq; //chop off fractional part
                    iSq -= iSqInt;
                    gIndex = sqrtLutFixed[iSqInt];
                    gIndex += (int) (iSq * (sqrtLutFixed[iSqInt + 1] - gIndex));
                    pixels[indexer] = gradient[gIndex];
                }


                //incremental calculation
                g += gDelta;
                gDelta += gDeltaDelta;
            }
            indexer += adjust;
        }
    }