Взаимное влияние точек

point_1 = [150,150]
point_2 = [90,90]
point_3 = [250,330]
point_4 = [400,300]
point_5 = [100,250]
point_6 = [400,100]
point_7 = [250,400]

# сила воздействия от 0,99 до 0
power = [i/100 for i in range(100)]
power.sort(reverse=True) # сила нужна по убыванию, чем дальше от точки воздействия тем меньше сила
probit_point_1 = [power,[i for i in range(100)]] # [[сила воздействия],[на расстоянии от точки]]
probit_point_2 = [power,[i for i in range(100)]]
probit_point_3 = [power,[i for i in range(100)]]
probit_point_4 = [power,[i for i in range(100)]]
probit_point_5 = [power,[i for i in range(100)]]
probit_point_6 = [power,[i for i in range(100)]]
probit_point_7 = [power,[i for i in range(100)]]

# цвета для отображения результата
red = (255, 0, 0, 70)
yellow = (255, 255, 0, 70)
light_blue = (0, 255, 255, 70)
green = (0, 255, 0, 70)
blue = (0, 0, 255, 70)
purple = (255, 0, 255, 70)

# возьмем чистую картинку
im = Image.open('image.jpg')
# измерим размер
width, height = im.size
# загрузим в память
px = im.load()

# Сделаем несколько точек и покажем их воздействие
# точки с координатами
point_1 = [150,150]
point_2 = [90,90]
point_3 = [250,330]
point_4 = [400,300]
point_5 = [100,250]
point_6 = [400,100]
point_7 = [250,400]
# сила воздействия от 0,99 до 0
power = [i/100 for i in range(100)]
power.sort(reverse=True) # сила нужна по убыванию, чем дальше от точки воздействия тем меньше сила
probit_point_1 = [power,[i for i in range(100)]] # [[сила воздействия],[на расстоянии от точки]]
probit_point_2 = [power,[i for i in range(100)]]
probit_point_3 = [power,[i for i in range(100)]]
probit_point_4 = [power,[i for i in range(100)]]
probit_point_5 = [power,[i for i in range(100)]]
probit_point_6 = [power,[i for i in range(100)]]
probit_point_7 = [power,[i for i in range(100)]]
# список всех точек (их координат) и список их влияния (силы воздействия)
coord_all = [point_1, point_2, point_3, point_4, point_5, point_6, point_7]
probit_all = [probit_point_1, probit_point_2, probit_point_3, probit_point_4,
                  probit_point_5, probit_point_6, probit_point_7]

# сделаем нулевую матрицу по размерам картинки
zeors_array = np.zeros((width, height))

# создадим функцию которая по суммарному воздейсатвию определяет цвет пикселя
def color_px(x,y):
    if zeors_array[x, y] >= 0.9:
        px[x, y] = red
    elif 0.9 > zeors_array[x, y] >= 0.7:
        px[x, y] = yellow
    elif 0.7 > zeors_array[x, y] >= 0.5:
        px[x, y] = light_blue
    elif 0.5 > zeors_array[x, y] >= 0.3:
        px[x, y] = green
    elif 0.3 > zeors_array[x, y] >= 0.2:
        px[x, y] = blue
    elif 0.2 > zeors_array[x, y] >= 0.1:
        px[x, y] = purple

# создадим функцию которая принимает высоту, ширину картинки, список координат,
# координаты точек и силу их воздействия вокруг себя
def calc_el_zeors_array_for_point(width, height, coord, probit):
    # для каждой точки картинки определим силу воздействия заданных точек
    for x in range(width):
        for y in range(height):
            # определим расстояние от перебираемой точки картинки до
            # заданной точки coord
            dist = round(Point(x, y).distance(Point(coord[0], coord[1])))
            # крайний случай, когда перебираемая точка и заданная точка coord равны
            # тогда воздействие максимально
            if dist == 0:
                zeors_array[x, y] = zeors_array[x, y] + probit[0][0]
                color_px(x,y)
            # если расстояние есть в дистанции силы воздействия
            elif dist in probit[1]:
                # найдем индекс
                find_index = probit[1].index(dist)
                # запишем силу воздействия в матрицу (т.е. если в этой точке воздействие от другой точки уже
                # было, то воздействия суммируются)
                zeors_array[x, y] = zeors_array[x, y] + probit[0][find_index]
                color_px(x, y)

# переберем все точки
for elem in coord_all:
    # определим индекс
    find_index = coord_all.index(elem)
    # вызовем функцию суммарного воздействия
    calc_el_zeors_array_for_point(width, height, coord_all[find_index], probit_all[find_index])

Traceback (most recent call last):
  File "C:/Users/Konstantin_user/Desktop/neft_calc_030621/tst_shapely/shapely_tst.py", line 68, in <module>
    zeors_array = np.zeros((width, height))
MemoryError

расстояние от точки   сила воздействия
          0                                0,99
          1                                0,98
          2                                0,97
          ..                                ..
          99                              0

px = im.load()

zeors_array = np.zeros((width, height))

import numpy as np
zeors_array = np.zeros((10000, 10000))
print(zeors_array)

import sys
import numpy as np
np.set_printoptions(threshold=sys.maxsize)
 
# "радиус силы"
k = 100
 
# размер поля
s = 10000
 
# количество точек
m = 1000
 
# цвета для отображения результата
# их нужно "улаковать" в двумерный массив,
# добавив первым белый цвет
red = np.array([255, 0, 0, 70])
yellow = np.array([255, 255, 0, 70])
light_blue = np.array([0, 255, 255, 70])
green = np.array([0, 255, 0, 70])
blue = np.array([0, 0, 255, 70])
purple = np.array([255, 0, 255, 70])
 
a = np.zeros((s,s), dtype=int)
power = np.ones((3,3), dtype=int)*(k-1)
power[1, 1] = k
 
# формирование "поля силы точки"
p = k - 1
for _ in range(k-2):
    p -= 1
    power = np.pad(power, pad_width=1, mode='constant', constant_values=p) 
 
 
# здесь массив точек с координатами [x,y] в пикселях
point = [[0,45]] * m
 
for i in range(m):
    row, col = point[i]
    
    row_p0 = 0
    row_p1 = 2*k
    col_p0 = 0
    col_p1 = 2*k
    
    row_0 = row - k + 1
    if row_0 < 0:
        row_p0 = -row_0
        row_0 = 0
        
    row_1 = row + k
    if row_1 > s-1:
        row_p1 = 2*k  - (row_1 - s + 1)
        row_1 = s
    
    col_0 = col - k + 1
    if col_0 < 0:
        col_p0 = -col_0
        col_0 = 0
    
    col_1 = col + k
    if col_1 > s-1:
        col_p1 = 2*k  - (col_1 - s + 1)
        col_1 = s
 
    a[row_0:row_1, col_0:col_1] += power[row_p0:row_p1, col_p0:col_p1]
    
a[a>0.9*k] = -1
a[(a<=0.9*k) & (a>0.7*k)] = -2
a[(a<=0.7*k) & (a>0.5*k)] = -3
a[(a<=0.5*k) & (a>0.3*k)] = -4
a[(a<=0.3*k) & (a>0.2*k)] = -5
a[(a<=0.2*k) & (a>0.1*k)] = -6
a[(a<=0.1*k) & (a>0)] = 0
a *= -1
# значение каждого элемента -> индекс цвета в массиве цветов

import numpy as np
from scipy.signal import fftconvolve
import matplotlib.pyplot as plt
 
points=np.array([[150,150],[90,90], [250,330], [400,300], [100,250],[400,100],[250,400]])
width, height = 500,500
im=np.zeros((width, height))
im[points[:,1], points[:,0]]=1.0 # set points
x=np.arange(0, 201)
y=np.arange(0, 201)
X,Y=np.meshgrid(x,y)
distance=((X-100)**2+(Y-100)**2)**.5
power=1-distance/100
power[power<0]=0 # cut off power function
power=power/np.sum(power) # normalization
result=fftconvolve(im, power, mode='same') # convolutions
plt.imshow(result, cmap='jet', aspect='equal')

from shapely.geometry import Point 
dist = round(Point(x, y).distance(Point(coord[0], coord[1])))