I would like to calculate a scaled polygon, such that its sides would be evenly distanced from the original polygon ones.

I’ve tried to use scaling, but it looks like I don’t get a perfect result:

For rectangles, it works just fine, but with polygons, it seems that the sides are not spaced evenly. Furthermore, the angles don’t look equal.

- Is this a normal situation with scaling?
- Is there any better way to achieve my goal?
- Maybe there’s something wrong with my calculations?

Here are the listings of code which I used:

```
public static float() getBypassPoints(Polygon polygon, float offsetX, float offsetY) {
Rectangle bbox = polygon.getBoundingRectangle();
float width = bbox.getWidth();
float height = bbox.getHeight();
float origScaleX = polygon.getScaleX();
float origScaleY = polygon.getScaleY();
float xScale = ((width + offsetX * 2) / width) * origScaleX;
float yScale = ((height + offsetY * 2) / height) * origScaleY;
setPolygonOrigin(polygon);
polygon.setScale(xScale, yScale);
float() transformedVertices = polygon.getTransformedVertices();
float() bypassPoints = transformedVertices.clone();
polygon.setScale(origScaleX, origScaleY);
return bypassPoints;
}
public static void setPolygonOrigin(Polygon polygon) {
float() vertices = polygon.getVertices();
int countOfCoords = vertices.length;
Vector2 centroid = polygonCentroid(
vertices, 0, countOfCoords, new Vector2(polygon.getX(), polygon.getY()));
polygon.setOrigin(centroid.x, centroid.y);
}
```

```
public float() getTransformedVertices () {
if (!dirty) return worldVertices;
dirty = false;
final float() localVertices = this.localVertices;
if (worldVertices == null || worldVertices.length != localVertices.length) worldVertices = new float(localVertices.length);
final float() worldVertices = this.worldVertices;
final float positionX = x;
final float positionY = y;
final float originX = this.originX;
final float originY = this.originY;
final float scaleX = this.scaleX;
final float scaleY = this.scaleY;
final boolean scale = scaleX != 1 || scaleY != 1;
final float rotation = this.rotation;
final float cos = MathUtils.cosDeg(rotation);
final float sin = MathUtils.sinDeg(rotation);
for (int i = 0, n = localVertices.length; i < n; i += 2) {
float x = localVertices(i) - originX;
float y = localVertices(i + 1) - originY;
// scale if needed
if (scale) {
x *= scaleX;
y *= scaleY;
}
// rotate if needed
if (rotation != 0) {
float oldX = x;
x = cos * x - sin * y;
y = sin * oldX + cos * y;
}
worldVertices(i) = positionX + x + originX;
worldVertices(i + 1) = positionY + y + originY;
}
return worldVertices;
}
```