Não estou ciente de nada na API do arcpy que fará o dimensionamento para você, mas escrever uma função para fazer isso seria relativamente simples.
O código abaixo faz o dimensionamento para recursos 2D e não leva em consideração os valores M ou Z:
import arcpy
import math
def scale_geom(geom, scale, reference=None):
"""Returns geom scaled to scale %"""
if geom is None: return None
if reference is None:
# we'll use the centroid if no reference point is given
reference = geom.centroid
refgeom = arcpy.PointGeometry(reference)
newparts = []
for pind in range(geom.partCount):
part = geom.getPart(pind)
newpart = []
for ptind in range(part.count):
apnt = part.getObject(ptind)
if apnt is None:
# polygon boundaries and holes are all returned in the same part.
# A null point separates each ring, so just pass it on to
# preserve the holes.
newpart.append(apnt)
continue
bdist = refgeom.distanceTo(apnt)
bpnt = arcpy.Point(reference.X + bdist, reference.Y)
adist = refgeom.distanceTo(bpnt)
cdist = arcpy.PointGeometry(apnt).distanceTo(bpnt)
# Law of Cosines, angle of C given lengths of a, b and c
angle = math.acos((adist**2 + bdist**2 - cdist**2) / (2 * adist * bdist))
scaledist = bdist * scale
# If the point is below the reference point then our angle
# is actually negative
if apnt.Y < reference.Y: angle = angle * -1
# Create a new point that is scaledist from the origin
# along the x axis. Rotate that point the same amount
# as the original then translate it to the reference point
scalex = scaledist * math.cos(angle) + reference.X
scaley = scaledist * math.sin(angle) + reference.Y
newpart.append(arcpy.Point(scalex, scaley))
newparts.append(newpart)
return arcpy.Geometry(geom.type, arcpy.Array(newparts), geom.spatialReference)
Você pode chamá-lo com um objeto de geometria, um fator de escala (1 = mesmo tamanho, 0,5 = metade do tamanho, 5 = 5 vezes maior etc.) e um ponto de referência opcional:
scale_geom(some_geom, 1.5)
Use isso em conjunto com os cursores para dimensionar uma classe de recurso inteira, assumindo que a classe de recurso de destino já exista:
incur = arcpy.da.SearchCursor('some_folder/a_fgdb.gdb/orig_fc', ['OID@','SHAPE@'])
outcur = arcpy.da.InsertCursor('some_folder/a_fgdb.gdb/dest_fc', ['SHAPE@'])
for row in incur:
# Scale each feature by 0.5 and insert into dest_fc
outcur.insertRow([scale_geom(row[1], 0.5)])
del incur
del outcur
edit: veja um exemplo usando uma aproximação da sua geometria de teste, por 0,5 e 5 vezes:
Também testado com polígonos com vários anéis (orifícios)!
Uma explicação, conforme solicitado:
scale_geom
pega um único polígono e percorre cada vértice, medindo a distância até um ponto de referência (por padrão, o centróide do polígono).
Essa distância é então dimensionada pela escala fornecida para criar o novo vértice 'dimensionado'.
O dimensionamento é feito basicamente desenhando uma linha no comprimento dimensionado do ponto de referência até o vértice original, com o final da linha se tornando o vértice dimensionado.
O material de ângulo e rotação existe porque é mais direto calcular a posição do final da linha ao longo de um único eixo e depois girá-lo 'no lugar'.