Scaling QPolygon on its origin

Before considering the problem of the translation, there is a more important aspect that has to be considered: if you want to create a transformation based on the center of a polygon, you must find that center. That point is called centroid, the geometric center of any polygon.

While there are simple formulas for all basic geometric shapes, finding the centroid of a (possibly irregular) polygon with an arbitrary number of vertices is a bit more complex.

Using the arithmetic mean of vertices is not a viable option, as even in a simple square you might have multiple points on a single side, which would move the computed "center" towards those points.

The formula can be found in the Wikipedia article linked above, while a valid python implementation is available in this answer.

I modified the formula of that answer in order to accept a sequence of QPoints, while improving readability and performance, but the concept remains the same:

def centroid(points):
    if len(points) < 3:
        raise ValueError('At least 3 points are required')
    # https://en.wikipedia.org/wiki/Centroid#Of_a_polygon
    # https://en.wikipedia.org/wiki/Shoelace_formula
    # computation uses concatenated pairs from the sequence, with the
    # last point paired to the first one:
    # (p[0], p[1]), (p[1], p[2]) [...] (p[n], p[0])
    area = cx = cy = 0
    p1 = points[0]
    for p2 in points[1:] + [p1]:
        shoelace = p1.x() * p2.y() - p2.x() * p1.y()
        area += shoelace
        cx += (p1.x() + p2.x()) * shoelace
        cy += (p1.y() + p2.y()) * shoelace
        p1 = p2
    A = 0.5 * area
    factor = 1 / (6 * A)
    return cx * factor, cy * factor

Then, you have two options, depending on what you want to do with the resulting item.

Scale the item

In this case, you create a QGraphicsPolygonItem like the original one, then set its transform origin point using the formula above, and scale it:

    poly_2 = QtGui.QPolygonF(poly_2_coords)
    item2 = scene.addPolygon(poly_2, QtGui.QPen(QtGui.QColor(0, 20, 255)))
    item2.setTransformOriginPoint(*centroid(poly_2_coords))
    item2.setScale(1.5)

Use a QTransform

With Qt transformations some special care must be taken, as scaling always uses 0, 0 as origin point.

To scale around a specified point, you must first translate the matrix to that point, then apply the scale, and finally restore the matrix translation to its origin:

    poly_2 = QtGui.QPolygonF(poly_2_coords)
    cx, cy = centroid(poly_2_coords)
    trans = QtGui.QTransform()
    trans.translate(cx, cy)
    trans.scale(1.5, 1.5)
    trans.translate(-cx, -cy)
    poly_2_scaled = trans.map(poly_2)
    scene.addPolygon(poly_2_scaled, QtGui.QPen(QtGui.QColor(0, 20, 255)))

This is exactly what QGraphicsItems do when using the basic setScale() and setRotation() transformations.

Shape origin point and item position

Remember that QGraphicsItems are always created with their position at 0, 0.
This might not seem obvious especially for basic shapes: when you create a QGraphicsRectItem giving its x, y, width, height, the position will still be 0, 0. When dealing with complex geometry management, it's usually better to create basic shapes with the origin/reference at 0, 0 and then move the item at x, y.

For complex polygons like yours, a possibility could be to translate the centroid of the polygon at 0, 0, and then move it at the actual centroid coordinates:

    item = scene.addPolygon(polygon.translated(-cx, -cy))
    item.setPos(cx, cy)
    item.setScale(1.5)

This might make things easier for development (the mapped points will always be consistent with the item position), and the fact that you don't need to change the transform origin point anymore makes reverse mapping even simpler.