Removed loops to Stream functions not sure if that improves performance
Removed loops to Stream functions not sure if that improves performance
Removed loops to Stream functions not sure if that improves performance

And would like to improve performance efficiency

import java.util.Arrays;
import java.util.stream.IntStream;

public class Regions {

    public static Object[] getORegion(double[] Xs, double[] Ys, double[] radii, double thicknessBy2, double[] azimuths, double[] beamwidths, double delta, int nCircles) {
        if (nCircles == 0) {
            nCircles = Xs.length;
        }
        if (nCircles > 3) {
            nCircles = 3;
        }

        Xs = Arrays.copyOfRange(Xs, 0, nCircles);
        Ys = Arrays.copyOfRange(Ys, 0, nCircles);
        radii = Arrays.copyOfRange(radii, 0, nCircles);

        double xMin = Arrays.stream(Xs).min().orElse(Double.NaN) - Arrays.stream(radii).max().orElse(Double.NaN);
        double yMin = Arrays.stream(Ys).min().orElse(Double.NaN) - Arrays.stream(radii).max().orElse(Double.NaN);
        double xMax = Arrays.stream(Xs).max().orElse(Double.NaN) + Arrays.stream(radii).max().orElse(Double.NaN);
        double yMax = Arrays.stream(Ys).max().orElse(Double.NaN) + Arrays.stream(radii).max().orElse(Double.NaN);

        double[] xValues = IntStream.iterate((int) xMin, x -> x + (int) delta)
                                    .limit((int) Math.ceil((xMax - xMin) / delta) + 1)
                                    .mapToDouble(x -> x)
                                    .toArray();
        double[] yValues = IntStream.iterate((int) yMin, y -> y + (int) delta)
                                    .limit((int) Math.ceil((yMax - yMin) / delta) + 1)
                                    .mapToDouble(y -> y)
                                    .toArray();

        int nXValues = xValues.length;
        int nYValues = yValues.length;

        double[][] aggregateRegion = new double[nYValues][nXValues];

        for (int circleNum = 0; circleNum < nCircles; circleNum++) {
            double x = Xs[circleNum];
            double y = Ys[circleNum];
            double r = radii[circleNum];

            double[][] xGrid = new double[nYValues][nXValues];
            double[][] yGrid = new double[nYValues][nXValues];

            for (int i = 0; i < nYValues; i++) {
                Arrays.fill(xGrid[i], xValues[i] - x);
            }

            for (int j = 0; j < nXValues; j++) {
                for (int i = 0; i < nYValues; i++) {
                    yGrid[i][j] = yValues[i] - y;
                }
            }

            double[][] gridRadiiSquared = new double[nYValues][nXValues];
            boolean[][] annulusSelector = new boolean[nYValues][nXValues];

            for (int i = 0; i < nYValues; i++) {
                for (int j = 0; j < nXValues; j++) {
                    gridRadiiSquared[i][j] = Math.pow(xGrid[i][j], 2) + Math.pow(yGrid[i][j], 2);
                    annulusSelector[i][j] = gridRadiiSquared[i][j] >= Math.pow(r - thicknessBy2, 2) &&
                                            gridRadiiSquared[i][j] <= Math.pow(r + thicknessBy2, 2);
                }
            }

            double[][] ranges = getQuadrantLimits(r - thicknessBy2, r + thicknessBy2, azimuths[circleNum], beamwidths[circleNum]);

            for (int quadrant = 0; quadrant < ranges.length; quadrant++) {
                double[] limit = ranges[quadrant];
                if (limit.length == 0) continue;

                double xMinLimit = limit[0];
                double xMaxLimit = limit[1];
                double yMinLimit = limit[2];
                double yMaxLimit = limit[3];
                double angleMinLimit = limit[4];
                double angleMaxLimit = limit[5];

                for (int i = 0; i < nYValues; i++) {
                    for (int j = 0; j < nXValues; j++) {
                        boolean xSelector = xGrid[i][j] >= xMinLimit && xGrid[i][j] <= xMaxLimit;
                        boolean ySelector = yGrid[i][j] >= yMinLimit && yGrid[i][j] <= yMaxLimit;
                        boolean angleSelector = true;

                        if (!Double.isNaN(angleMinLimit) && !Double.isNaN(angleMaxLimit)) {
                            if (angleMinLimit != angleMaxLimit) {
                                angleSelector = yGrid[i][j] >= xGrid[i][j] * angleMinLimit &&
                                                yGrid[i][j] <= xGrid[i][j] * angleMaxLimit;
                            }
                        }

                        if (annulusSelector[i][j] && xSelector && ySelector && angleSelector) {
                            aggregateRegion[i][j] += 1;
                        }
                    }
                }
            }
        }

        return new Object[]{aggregateRegion,xValues, yValues};
    }

Cleaner output
Null Array coming out as output