Перевести код с Python на С++

Здравствуйте!

Необходимо перевести код с Python на С++

_________________________________________________

Весь код представлен ниже:

import math

n_pattern=int(input()) #ввод количества точек в паттерне

listPattern=[] #лист с координатами всех точек паттерна

for i in range(n_pattern): #ввод и заполнение точек паттерна

a_t_1=input().split(' ',maxsplit = 1) #ввод координат одной точки, конверт строки в временный лист

listPattern.append([int(a_t_1[0]),int(a_t_1[1])]) #добавление точки в лист

n_img=int(input()) #количество распознанных точек в фото

listImg=[] #лист с координатами всех точек на изображении

for i in range (n_img):

a_t_1=input().split(' ',maxsplit = 1) #ввод координат одной точки, конверт строки в временный лист

listImg.append([int(a_t_1[0]),int(a_t_1[1])]) #добавление точки в лист

dmax=0 # Hасстояние между двумя самыми отдаленными точками в паттерне (для уменьшения погрешности)

dm=0 # Среднее расстояние между точками в паттерне

dmin=2000 # Минимальное расстояние между точками в паттерне

pm=[0,0] #лист с индексами максимально удаленных точек (из листа listPatten)

for i in range(n_pattern): # Вычисляем максимальное, минимальное и среднее растояния

for j in range(i+1,n_pattern):

d0=math.sqrt((listPattern[0]-listPattern[j][0])**2+(listPattern[1]-listPattern[j][1])**2) #находим промежуточное расстояние между точками listPattern и

dm+=d0 # Суммируем расстояния

if d0

dmin=d0

if d0>dmax:

dmax=d0

pm[0]=i

pm[1]=j

dm=dm*2/(n_pattern*(n_pattern-1)) # Вычисляем среднее

#для удобства в паттерне сдвигается начало координат в нулевую точку (listPattern[0])

XshiftPattern = listPattern[pm[0]][0]

YshiftPattern = listPattern[pm[0]][1]

#координаты 0-й точки

# Перемещение всех координат в listPattern на XshiftPattern и YshiftPattern влево и вниз

for i in range (len(listPattern)):

listPattern[0]=listPattern[0]-XshiftPattern

listPattern[1]=listPattern[1]-YshiftPattern

anglePattern = math.atan2(listPattern[pm[1]][1],listPattern[pm[1]][0]) #угол между горизонталью и прямой, образованной 0-й и 1-й точками в паттерне

dPattern = dmax #расстояние между теми же точками

det=False # Флаг нахождения группы подходящих точек

isEnd = False # Флаг остановки цикла после нахождения всех точек

detectedPoints = [] # Лист с координатами найденных точек за один цикл

nFound=[] # Лист с номерами найденных точек за один цикл

d_sol=[] # Лист с погрешностями по каждой точке (обнуляется каждый цикл

n_sol=0 # Количесво найденных решений (полных комплектов)

all_sol=[] # Лист со всеми решениями

all_d=[] # Лист со среднеквадратичными погрешностями отобранных решений

Kc=1 # Коэффициент погрешности

trig=False

while isEnd==False:

if trig==True:

isEnd=True

for i in range (n_img):

p0=listImg #считаем, что некая i-я точка из множества найденных точек соответствует 0-й точке из паттерна

for j in range (n_img):

if i!=j:

p1=listImg[j] #считаем, что некая j-я точка из множества найденных точек соответствует 1-й точке из паттерна

angle_b=math.atan2((p1[1]-p0[1]),(p1[0]-p0[0])) #угол между прямой p0p1 и горизонталью

delta_angle = angle_b-anglePattern #угол поворота

dImg = math.sqrt((p0[0]-p1[0])**2+(p0[1]-p1[1])**2) #расстояние между p0 и p1

R = dImg/dPattern #масштаб

dK=Kc*4*R # Расчет радиуса поиска точек

det = True

delta=0 # Суммарная погрешность

detectedPoints.clear()

nFound.clear() #чистка листа найденных точек за один цикл

d_sol.clear()

for k in range(n_pattern):

if det==True:

xP = round(p0[0] + R*(listPattern[k][0]*math.cos(delta_angle)-listPattern[k][1]*math.sin(delta_angle)))

yP = round(p0[1] + R*(listPattern[k][1]*math.cos(delta_angle)+listPattern[k][0]*math.sin(delta_angle))) #преобразование координат, нахождение примерного расположения следующей точки

dd=dK #маскимальная погрешность, константа, определенная из здравого смысла

for kk in range(0,n_img):

dd0=math.sqrt((xP-listImg[kk][0])**2+(yP-listImg[kk][1])**2) #расстояние между (xP; yP) и listImg[kk]

if dd0

dd=dd0

mP=kk

if dd

detectedPoints.append(listImg[mP])

d_sol.append(dd)

nFound.append(mP)

delta+=dd

else: # Если точка не найдена чистим списки и выключаем флаг дальнейшего поиска

detectedPoints.clear()

nFound.clear()

d_sol.clear()

det = False

if len(detectedPoints)==n_pattern and len(d_sol)==n_pattern: # Если все точки найдены добавляем их в список решений

n_sol+=1

d2=0

for ii in range(n_pattern):

all_sol.append(detectedPoints[ii])

d2+=d_sol[ii]**2 # Суммируем квадраты погрешностей

delta=math.sqrt(d2/(n_pattern+1))/R # Вычисляем среднеквадратичную погрешность

all_d.append(delta)

detectedPoints.clear()

isEnd=True

trig=True

Kc*=3 # Увеличивем коэффициент погрешности на случай если решения не найдены

min_d=dK

min_sol=0

for i in range(n_sol): # Отбираем лучшее решение

if all_d

min_d=all_d

min_sol=i

for ii in range(n_pattern):

print(all_sol[min_sol*n_pattern+ii][0],all_sol[min_sol*n_pattern+ii][1]) # Выводим