Successive inward closed polygon offsetting.

[adnan-saood]

Hello all,

I am trying to create the following geometric operation (this was achieved using MATLAB's polybuffer function:

MATLAB code for the figure:

input: [X,Y] arrays of size [1,N]

layerPolygon= polyshape(X,Y);

dr = 0.01;
index = 1;
buf = {};
buf{index} = layerPolygon;
while(index < Numoffsets)
	buf{index+1}  = polybuffer(buf{index},-(dr));
	index = index+1;
end

The input is the outer polygon shape and the operation is a successive inward offset operation using delta values.
I am having some trouble regarding that. I tried to create the following code:

input: layerPolygon_: std::vector<Eigen::Vector<float, 3>>
        std::vector<float> X, Y, Z;
	for (size_t i = 0; i < this->layerPolygon_.size(); i++)
	{
		X.push_back(layerPolygon_.at(i).x());
		Y.push_back(layerPolygon_.at(i).y());
		Z.push_back(layerPolygon_.at(i).z());
	}

	// Define the polygon vertices
	PathD polygon;
	for (size_t i = 0; i < X.size(); i++) {
		polygon.push_back(PointD(X.at(i), Y.at(i)));
	}
	PathsD polygons;
	polygons.push_back(polygon);

	const int nums = 4;

	for(int num = 0; num < nums; num++)
	{
		auto in_p = polygons.at(num);
		PathsD polys;
		polys.push_back(in_p);
		const double scale = std::pow(10, 6);
		ClipperOffset clip_offset(0.001, 0, false, false);
		clip_offset.AddPaths(ScalePaths<int64_t, double>(polys, scale), JoinType::Miter, EndType::Polygon);
		Paths64 tmp = clip_offset.Execute(-0.001 * scale);
		PathsD solution = ScalePaths<double, int64_t>(tmp, 1 / scale);
		polygons.push_back(solution.at(0));
	}

I have several problems with that.

• First: I did not know why the delta value in ClipperOffset::Execute() is not allowed to be negative if the EndType was not EndType::polygon
• When I perform the operation as coded in c++, the output polygons are not closed.
• The output polygons have many added vertices in unexpected behavior.

You can see 2 examples of execution here in the figures.

Same matlab polygon:

Square

std::vector<float> sx = { 0.0,0.01,0.01,0.0,0.0};
std::vector<float> sy = { 0.0,0.0,0.01,0.01,0.0 };

[adnan-saood]

I want to clarify that the problem is from the function StripDuplicates inside the offset logic.
I suspect this is from me misusing the library rather than a bug.

The only workaround for me now is to add a point to each offset iteration

solution.at(0).push_back(solution.at(0).at(0));
polygons.push_back(solution.at(0));

but this seems arbitrary to me. Is there a better way to do that?

This only solves the open polygon answer. It does not solve the added vertices behavior.

[AngusJohnson]

I did not know why the delta value in ClipperOffset::Execute() is not allowed to be negative if the EndType was not EndType::polygon

Because you can't deflate/shrink open paths (ie lines).
What you've illustrated in your first image is a polygon, and that you can deflate/shrink using a negative offset.

When I perform the operation as coded in c++, the output polygons are not closed.

Polygons are only closed implicitly by the context.
The library does not add endpoints to match start points.
If that's important to you, you could easily do that outside the library's code.

The output polygons have many added vertices in unexpected behavior.

Without some sample data, I can't really comment or explain.

[adnan-saood]

You are right, the closeness of the polygon depends on the context. Sometimes we have to specify the first and last point to match in order to consider it closed and sometimes closeness is implied.

For the added vertices, I solved this problem by re-sampling the resultant polygons to force them to be equilateral.

If anyone is interested in that workaround, here it is:

std::vector<double> linspace_(double start, double end, int num) {
	std::vector<double> result(num);
	double step = (end - start) / (num - 1);
	for (int i = 0; i < num; i++) {
		result[i] = start + i * step;
	}
	return result;
}

void make_equilateral(const std::vector<double>& x, const std::vector<double>& y,
	std::vector<double>& x_, std::vector<double>& y_, int num_points) {

	// Compute the cumulative distance between points
	std::vector<double> dist(x.size());
	dist[0] = 0;
	for (int i = 1; i < x.size(); i++) {
		double dx = x[i] - x[i - 1];
		double dy = y[i] - y[i - 1];
		dist[i] = dist[i - 1] + std::sqrt(dx * dx + dy * dy);
	}

	// Define the new set of uniformly spaced points
	std::vector<double> new_dist = linspace(0, dist.back(), num_points);

	// Interpolate the x and y values to the new set of points
	x_.resize(num_points);
	y_.resize(num_points);
	for (int i = 0; i < new_dist.size(); i++) {
		int j = std::lower_bound(dist.begin(), dist.end(), new_dist[i]) - dist.begin();
		if (j == 0) {
			x_[i] = x[0];
			y_[i] = y[0];
		}
		else if (j == dist.size()) {
			x_[i] = x.back();
			y_[i] = y.back();
		}
		else {
			double t = (new_dist[i] - dist[j - 1]) / (dist[j] - dist[j - 1]);
			x_[i] = (1 - t) * x[j - 1] + t * x[j];
			y_[i] = (1 - t) * y[j - 1] + t * y[j];
		}
	}
}