This is called polygon offsetting rather than scaling.
In the general case, this is much harder than it seems, as different parts of the inflated polygon can overlap each other, letting holes appear, and some edges may completely disappear. The way to handle corners isn't so well defined either.
For an exact solution, have a look at Clipper.
For a simple solution not guaranteed to work on all shapes, you have to consider all vertices in turn, draw lines parallel to the abutting edges, at the desired distance on the right side, and find their intersection.
Step1. Reorganize your data a bit. Let us store the coordinates $(x_j, y_j)$ of the vertices of the polygon your points in a $2 \times n$ array called $P$, like this
$$ P =
\begin{bmatrix}
x_1 & x_2 & x_{3} & \dots & x_{n} \\
y_1 & y_2 & y_{3} & \dots & y_{n} \\
\end{bmatrix}$$
Step2. Compute the centroid $(a,b)$ that you need. If you are looking for the centroid of the vertices of the polygon you can do it as follows
$$\begin{bmatrix}
a \\
b \\
\end{bmatrix} = \frac{1}{n} \, \left( \, \, \begin{bmatrix}
x_1 \\
y_1 \\
\end{bmatrix} + \begin{bmatrix}
x_2 \\
y_2 \\
\end{bmatrix} + \begin{bmatrix}
x_3 \\
y_3 \\
\end{bmatrix} + ... + \begin{bmatrix}
x_n \\
y_n \\
\end{bmatrix} \, \, \right)$$
Note that there are various notions of centroid, depending on how you view your polygon -- a finite set of mass-points, a frame (a set of points and struts) or as a whole object with equally distributed mass inside the polygon. You can check the formulas on the net.
Step 3. Fill up another $2 \times n$ array
$$ C =
\begin{bmatrix}
a & a & a & \dots & a \\
b & b & b & \dots & b \\
\end{bmatrix}$$
Step 4. Define the $2 \times 2$ rotation matrix of angle $\theta$ (the angle of rotation you choose)
$$ R =
\begin{bmatrix}
\cos{\theta} & - \sin{\theta} \\
\sin{\theta} & \cos{\theta} \\
\end{bmatrix}$$
Step 5. The rotated polygon around the centroid $(a,b)$ with rotation angle $\theta$ as follows
$$P_{new} = R\cdot \left( P - C \right) + C$$
where $\,\, \cdot \,\,$ is matrix multiplication and $-$ and $+$ are matrix subtraction and addition (basically component-wise).
$P_{new}$ contains the vertices of the rotated polygon.
import numpy as np
def R(angle):
cos_a = np.cos(angle)
sin_a = np.sin(angle)
return np.array([[cos_a, -sin_a],
[sin_a, cos_a]])
def rotate(poly, angle, Center):
poly_new = (poly - Center).dot(R(angle).T) + Center
return poly_new
def organize(poly):
P = np.empty(( len(poly), 2), dtype=float)
for i in range(len(poly)):
P[i,0] = poly[i]['x']
P[i,1] = poly[i]['y']
return P
Poly = [{"x":301.1848472789287,"y":216.523742955658},
{"x":299.92410285162424,"y":241.37037128550003},
{"x":296.227787218953,"y":264.523742955658},
{"x":290.347798182831,"y":284.40599394956655},
{"x":282.68484727892877,"y":299.6621817189641},
{"x":273.761151947722,"y":309.25262227940857},
{"x":264.18484727892877,"y":312.523742955658},
{"x":254.60854261013552,"y":309.25262227940857},
{"x":245.6848472789288,"y":299.6621817189641},
{"x":238.02189637502653,"y":284.40599394956655},
{"x":232.14190733890456,"y":264.523742955658},
{"x":228.44559170623327,"y":241.37037128550003},
{"x":227.1848472789288,"y":216.52374295565804},
{"x":228.44559170623327,"y":191.67711462581605},
{"x":232.14190733890456,"y":168.52374295565807},
{"x":238.02189637502653,"y":148.64149196174952},
{"x":245.68484727892877,"y":133.38530419235195},
{"x":254.60854261013552,"y":123.79486363190748},
{"x":264.18484727892877,"y":120.52374295565804},
{"x":273.761151947722,"y":123.79486363190746},
{"x":282.68484727892877,"y":133.38530419235192},
{"x":290.347798182831,"y":148.64149196174947},
{"x":296.2277872189529,"y":168.52374295565798},
{"x":299.92410285162424,"y":191.67711462581596}]
P = organize(Poly)
Cntr = np.array([0., 0.])
P_new = rotate(P, np.pi/3, Cntr)
Best Answer
I think your best bet will be to convert the self-intersecting polygon into a set of non-self-intersecting polygons and apply the algorithm that you linked to to each of them. I don't think it's possible to solve your problem without finding the intersections, and if you have to find the intersections anyway, the additional effort of using them as new vertices in a rearranged vertex list is small compared to the effort of finding them.
To answer your subquestion: Yes, the order of the nodes does matter, especially if the polygon is allowed to be self-intersecting since in that case the order is an essential part of the specification of the polygon and different orders specify different polygons -- for instance, the "square" with the ordering you describe would be the polygon on the right-hand side of the two examples of self-intersecting polygons that the page you linked to gives (rotated by $\pi/2$).
P.S.: I just realized that different orders can also specify different non-self-intersecting (but not convex) polygons, so the only case where you could specify a polygon by its vertices alone is if you know it's convex. But even then you have to use the vertices in the right order in the algorithm you linked to.