// Постоение расстояния от центра до каждой точки фигуры.
double minimalAngle = 0.0;
double maximalAngle = 0.0;
double maximalDistance = 0.0;

for (Distance distance : distancies) {
	minimalAngle = Math.min(distance.angle, minimalAngle);
	maximalAngle = Math.max(distance.angle, maximalAngle);
	maximalDistance = Math.max(distance.distance, maximalDistance);
}

for (Distance distance : distancies) {
	distance.normalized = distance.distance / maximalDistance;
	distance.position = values.length * (distance.angle - minimalAngle) / (maximalAngle - minimalAngle);
}

// Пересчет расстояний в зависимости от угла относительно центра.

for (int index = 0; index < values.length; index += 1) {
	Distance dd = new Distance();
	dd.position = index;

	int found = Collections
			.binarySearch(distancies, dd, Comparator.comparingDouble((Distance d) -> d.position));

	if (found >= 0) {
		values[index] = distancies.get(found).normalized;
	} else {
		int point = -found - 1;
		Distance left = distancies.get(point - 1);
		Distance right = distancies.get(point);
		double factor = (index - left.position) / (left.position - right.position);

		values[index] = left.normalized + factor * (left.normalized - right.normalized);

		if (factor < 0.5) {
			indexes[index] = point - 1;
		} else {
			indexes[index] = point;
		}
	}
}

int size = dataSize / (2 * 5 + 1);
int center = (size / 2) | 1;
double values[] = new double[size];
double value = 1.0 / size;

for (int index = 0; index < size; index += 1) {
	values[index] = value;
}

return new Kernel(values, center);

int agnleIndex = 0;
double agnleValue = Double.MIN_VALUE;
double[] filtered = new double[values.length];

flatKernel.apply(values, filtered);

// Нахождение угла, соответствующего максимальному расстоянию.
for (int index = 0; index < filtered.length; index += 1) {
	double value = filtered[index];

	if (value > agnleValue) {
		agnleIndex = index;
		agnleValue = value;
	}
}

Distance widthA = distances.get(indexes[agnleIndex]);
Distance widthB = distances.get(indexes[(agnleIndex + indexes.length / 2) % indexes.length]);
Distance heightA = distances.get(indexes[(agnleIndex + 1 * indexes.length / 4) % indexes.length]);
Distance heightB = distances.get(indexes[(agnleIndex + 3 * indexes.length / 4) % indexes.length]);

// Расчет параметров эллипса по углу и четырем точкам.
ellipseWidth = (int) ((widthA.distance + widthB.distance) / 2.0);
ellipseHeight = (int) ((heightA.distance + heightB.distance) / 2.0);
ellipseAngle = 2.0 * Math.PI * agnleIndex / Algorithm.DATA_SIZE + Math.PI / 2.0;

Базовый отрезок — некое начальное приближение ломанной линии или многоугольника, он содержит всего две точки. В данный отрезок алгоритм будет добавлять по одной точке, пока не достигнет приемлемой точности или заданного числа точек.

// Первая точка отрезка равна начальной точке фигуры.
pointIndexes.clear();
polygonPoints.clear();

pointIndexes.add(0);
polygonPoints.add(points.get(0));

int farIndex = 0;
double farDistance = Double.MIN_VALUE;

// Найдем максимально удаленную точку от первой.
for (int index = 0; index < points.size(); index += 1) {
	Point point = points.get(index);
	double dstance = Math.pow(point.x - polygonPoints.get(0).x, 2.0)
			+ Math.pow(point.y - polygonPoints.get(0).y, 2.0);

	if (farDistance < dstance) {
		farIndex = index;
		farDistance = dstance;
	}
}

// Выберем ее второй точкой отрезка. Будем считать, что точек больше одной.
pointIndexes.add(farIndex);
polygonPoints.add(points.get(farIndex));

// Итеративно пробуем добавлять по одной точке в многоугольник.
for (int iteration = 0; iteration < N_ITERATIONS; iteration += 1) {
	double maxDistance = Double.MIN_VALUE;
	int bestIndex = 0;
	int bestPoint = 0;

  // Найдем точку максимально удаленную от сегиента и соответствубщий сегмент.
	for (int indexIndex = 0; indexIndex < pointIndexes.size(); indexIndex += 1) {
		int fromIndex = pointIndexes.get(indexIndex);
		int toIndex = pointIndexes.get((indexIndex + 1) % pointIndexes.size());
		Point pointA = points.get(fromIndex);
		Point pointB = points.get(toIndex);
		Function<Point, Double> callback;

		if (pointA.x == pointB.x) {
			callback = (point) -> (double) Math.abs(pointA.y - point.y);
		} else if (pointA.y == pointB.y) {
			callback = (point) -> (double) Math.abs(pointA.x - point.x);
		} else {
			double a = (double) (pointA.y - pointB.y) / (pointA.x - pointB.x);
			double b = pointA.y - a * pointA.x;
			double a21 = a * a + 1;

			callback = (point) -> Math.sqrt(Math.pow(b + a * point.x - point.y, 2.0) / a21);
		}

		while (fromIndex != toIndex) {
			Point point = points.get(fromIndex);
			double distance = callback.apply(point);

			if (maxDistance < distance) {
				maxDistance = distance;
				bestIndex = fromIndex;
				bestPoint = indexIndex;
			}

			fromIndex = (fromIndex + 1) % points.size();
		}
	}

	int fromIndex = pointIndexes.get(bestPoint);
	int toIndex = pointIndexes.get((bestPoint + 1) % pointIndexes.size());
	Point pointA = points.get(fromIndex);
	Point pointB = points.get(toIndex);

  // Если максимально расстояние до точки меньше порога - завершить построение.
	if (maxDistance < MAX_DISTANCE
			* Math.sqrt(Math.pow(pointA.y - pointB.y, 2.0) + Math.pow(pointA.x - pointB.x, 2.0))) {
		break;
	}

  // Найденная точка добавляется в многоугольник между точками соответствующего сегмента.
	pointIndexes.add(bestPoint + 1, bestIndex);
	polygonPoints.add(bestPoint + 1, points.get(bestIndex));
}

double mse = 0.0;

for (int indexIndex = 0; indexIndex < pointIndexes.size(); indexIndex += 1) {
	int fromIndex = pointIndexes.get(indexIndex);
	int toIndex = pointIndexes.get((indexIndex + 1) % pointIndexes.size());
	Point pointA = points.get(fromIndex);
	Point pointB = points.get(toIndex);
	Function<Point, Double> callback;

	if (pointA.x == pointB.x) {
		callback = (point) -> (double) Math.abs(pointA.y - point.y);
	} else if (pointA.y == pointB.y) {
		callback = (point) -> (double) Math.abs(pointA.x - point.x);
	} else {
		double a = (double) (pointA.y - pointB.y) / (pointA.x - pointB.x);
		double b = pointA.y - a * pointA.x;
		double a21 = a * a + 1;

		callback = (point) -> Math.sqrt(Math.pow(b + a * point.x - point.y, 2.0) / a21);
	}

	while (fromIndex != toIndex) {
		Point point = points.get(fromIndex);
		mse += callback.apply(point);

		fromIndex = (fromIndex + 1) % points.size();
	}
}

mse /= points.size();

return mse;

double mse = 0.0;

for (Point point : points) {
	double dx = (point.x - centerX) * Math.cos(ellipseAngle) - (point.y - centerY) * Math.sin(ellipseAngle);
	double dy = (point.x - centerX) * Math.sin(ellipseAngle) + (point.y - centerY) * Math.cos(ellipseAngle);
	double distance = Math.sqrt(Math.pow(dx / ellipseWidth, 2.0) + Math.pow(dy / ellipseHeight, 2.0));
	double delta = Math.pow(distance - 1.0, 2.0) * (Math.pow(dx, 2.0) + Math.pow(dy, 2.0));

	mse += delta;
}

mse /= points.size();

return mse;