U235U235

Тебе просто надо сохранить файл в нормальной Utf-8 кодировке, а не в 1251

Быстрое преобразование Фурье - это алгоритм вычисления дискретного преобразования фурье. От интеграллов на картинках оно отличается тем, что там не функция от которой береться интеграл, а массив данных, которые как-то суммируются. Оно называется быстрым, потому что там идет вычисление не в лоб по формуле из википедии, а чуть хитрее, за счет чего оно работает быстрее.

В компьютерах используется дискретное преобразование, потому что ну не могут компьютеры работать с бесконечным неприрывным объектом, коим является функция.

И да, там результат - это массив комплексных чисел, поэтому выходные данные в 2 раза больше входных, которые являются вещественными.

Вопрос и впрямь не по питону, алгоритм легко портируется.
Если нужно детектить именно пересечение любой из точек границы, и именно для круга и квадрата, то это очень просто. Уменьши квадрат, сдвинь каждую сторону внутрь на радиус круга.
Например, у тебя был квадрат от (0;0) до (100;100), круг радиусом 10 (диаметром 20). Новый квадрат будет от (10;10) до (90;90).
После этого проверяй, входит ли центр круга внутрь нового квадрата. Если входит - круг внутри исходного квадрата. Если центр на стороне - круг касается стороны исходного квадрата. Если центр вне нового квадрата - круг вышел за границу исходного.
Проверка вхождения точки внутрь ортогонального (стороны параллельны осям координат) прямоугольника выполняется тривиально, сам догадаешься как.

Есть второй способ, базируется на массивах numpy (python-opencv их использует для хранения массивов пикселей изображения).
Делаешь два изображения-маски (одноканальных, одного размера), одно для одного объекта, другое для другого. В твоём случае одно (A) будет содержать белый круг на чёрном фоне, а другое (B) - чёрный квадрат на белом фоне.
Тогда можно будет сделать так:

intersection = numpy.logical_and(A, B)
if intersection.any():
    print('Collision!')

logical_and() вернёт логический массив того же размера, что A и B. Элемент массива будет истиннен только если соотвествующие элементы в A и B будут ненулевыми.
Таким образом, если два объекта пересекаются, то logical_and() вернёт True для пересёкшихся пикселей.
А метод any() вернёт True если любой элемент массива истинен, т.е. если есть хоть один пересёкшийся пиксель.

Этот метод куда более ресурсоёмкий, чем то что я описал в выше,но зато работает для объектов произвольной формы. Только нарисуй их.
Кроме того, можно сделать numpy.count_nonzero(intersection), чтобы узнать, насколько велико пересечение (сколько пикселей в нём). Это тоже может быть полезно если ты хочешь "прощать" небольшие пересечения.

Открой для себя метод str.join() и генераторные выражения
",".join( f"'{n}'" for n in glob.iglob(...) )
Я надеюсь, в имени файла у тебя не попадётся апострофов.

for a in self.weights a будет не индексами, а элементами списка. В твоём случае - массивами numpy. Аналогично
for b in a: будет не индексами строк массива, а самими строками
for c in b: будет не индексами столбцов, а значениями ячеек. Так что
self.weights[a][b][c] получит вместо чисел-индексов массивы и сойдёт с ума.

А вообще, то что ты пытаешься сделать, делается тривиальнейше.

x = np.randint(-1000, 1000, size = (2, 3), dtype=np.float32)  # массив случайных чисел, две строки, три столбца
x /= 100.0  # делим поэлементно на сто

В список завернёшь сам, хотя я не понимаю почему список, а не еще одно измерение в массиве.

H-мост

float(i[0])
Ты выбираешь нулевой (т.е. начальный) символ строки, и только его превращаешь в число, игнорируя остальные.
Как следствие, у тебя '5.615780770566875e-5' обрезается до '5'.
Как чаще всего и бывает, компьютер делает именно то, что ты просишь, а не то, что ты хочешь.

А мне нравится такое на комплексных числах считать. То же, что и с синусами, но элегантнее.
Вот пример на питоне:

from math import e, pi
f=lambda c, r, n=3, fi0=0: [c+r*e**(1j*(2*pi/n*i+fi0)) for i in range(n)]

Получим функцию f которая может рассчитать точки любого вписанного n-угольника:

>>> f(c=250+250j, r=250)
[(500+250j),
 (375+466.50635094610965j),
 (125.00000000000006+466.5063509461097j),
 250.00000000000003j,
 (124.99999999999989+33.49364905389041j),
 (374.99999999999983+33.49364905389024j)]

А если надо обяательно кортежами, а не комплексными точками. то вот:

>>> [(round(p.real), round(p.imag)) for p in f(c=250+250j, r=250, n=5, fi0=pi/2)]
[(250, 500), (12, 327), (103, 48), (397, 48), (488, 327)]

Тут, заметьте, пятиугольник, причем вершинкой вниз (при оси Y, направленной вниз).

Чтобы было понятно как это работает...
Представим, что центр окружности в нуле координат. Нам нужно 6 точек, смещенных относительно нуля на радиус под нужными углами: 0, 60, 120, 180, 240 и 300 градусов. В формулах мы. конечно используем радианы: pi - это 180 градусов.
Чтобы повернуть единичный вектор на какой-то угол, нужно его просто домножить на e в степени мнимая единица, умноженная на угол. Поскольку единичный вектор на комплексной плоскости это просто 1, то его даже писать не надо. Просто возводим e в нужную степень и получаем нужный вектор в виде комплексного числа. Осталось его домножить на требуемый радиус (он при этом удлинится: был длиной 1, а станет r) и добавить к нему желаемый центр (тоже в виде комплексного числа, где реальная часть - X, а мнимая - Y).
Вот и всё!
Красота же?..

Да, забыл сказать, что если нужно повернуть весь n-угольник на какой-то угол, то для этого есть там параметр fi0, который по умолчанию ноль.
c - это координаты центра в комплексной форме. Например если X=30, а Y=40, то c=30+40j.
n - это число вершин.
r - радиус.
И да, в javascript'е нет такого элегантного способа работать с комплексными числами, как в питоне. Но для js есть много библиотек для работы с комплексными числами. Будет не так компактно и красиво, как на питоне, но в целом всё точно так же в плане математики.

UPD: Исправил функцию. Там скобочек не хватало, поэтому поворот на fi0 работал неверно. Теперь все как надо.

Банально-наколенный вариант: находим среднюю арифметическую координату, пересчитываем координаты всех точек в радиальные относительно этой средней, сортируем по углу (а при равенстве углов - по удаленности) - и соединяем в этом самом порядке.

Этот оператор может быть перегружен, а потому имеет разную семантику для разных типов данных.
Для множеств этот оператор возвращает их пересечение.
Ты можешь добавить поддержку этого оператора в свой класс, объявив магический метод __and__().

a = eval("1+1")
print(a) # 2

это для примера

Разобрать, определить модель микроконтроллера, найти программатор под него, считать прошивку, провести реверс-инжиниринг и найти, где там пароль, поменять его, залить обратно программатором.

За пару месяцев для вас вполне реально.