my helping scripts

scripts/colormapdiffimgs.py

@@ -0,0 +1,48 @@
+from PIL import Image
+
+def diffimage(name1, name2, colour="RGB"):
+    img1 = Image.open(name1).convert(colour)
+    img2 = Image.open(name2).convert(colour)
+    new_image = Image.new(colour, (img1.size[0], img1.size[1]), color=(255,255,255))
+    color_image = Image.new(colour, (img1.size[0], img1.size[1]), color=(255,255,255))
+
+    for i in range(img1.size[0]):
+        for j in range(img1.size[1]):
+            if (img1.getpixel((i,j)) != img2.getpixel((i,j))):
+                i1 = img1.getpixel((i,j))
+                i2 = img2.getpixel((i,j))
+                new_image.putpixel((i, j), tuple([i1[0]-i2[0],i1[1]-i2[1],i1[2]-i2[2]])) 
+                
+                if 0 <= i1[0]-i2[0] < 0:
+                    color_image.putpixel((i, j), (0,255,255))
+                if 1 <= i1[0]-i2[0] < 2:
+                    color_image.putpixel((i, j), (255,50,0))
+                if 2 <= i1[0]-i2[0] < 3:
+                    color_image.putpixel((i, j), (255,100,0))
+                if i1[0]-i2[0] > 3:
+                    color_image.putpixel((i, j), (255,0,0))
+                if 0 <= i1[1]-i2[1] < 1:
+                    color_image.putpixel((i, j), (0,255,0))
+                if 1 <= i1[1]-i2[1] < 2:
+                    color_image.putpixel((i, j), (0,255,50))
+                if 2 <= i1[1]-i2[1] < 3:
+                    color_image.putpixel((i, j), (0,255,100))
+                if i1[1]-i2[1] > 3:
+                    color_image.putpixel((i, j), (255,51,255))
+                if 0 <= i1[2]-i2[2] < 1:
+                    color_image.putpixel((i, j), (0,0,255))
+                if 1 <= i1[2]-i2[2] < 2:
+                    color_image.putpixel((i, j), (50,0,255)) # синий
+                if 2 <= i1[2]-i2[2] < 3:
+                    color_image.putpixel((i, j), (100,0,255)) # фиолетовый
+                if i1[2]-i2[2] > 3:
+                    color_image.putpixel((i, j), (51,255,51))
+    # color_image.show()
+    # new_image.show()
+    new_image.save(f"diff_for_{name1[7:-4]}_and_{name2[12:-4]}.png")
+    color_image.save(f"colordiff_for_{name1[7:-4]}_and_{name2[12:-4]}.png")
+
+name1 = "60.jpg"
+name2 = "60wm.jpg"
+
+diffimage(name1, name2)

scripts/imgsdiff.py

@@ -0,0 +1,24 @@
+from PIL import Image
+
+img1 = Image.open('60.jpg')#.convert("RGB")
+img2 = Image.open('60wm.jpg')#.convert("RGB")
+ 
+N = 0
+new_image = Image.new("RGB", (img1.size[0], img1.size[1]), color=(255,255,255))
+
+for i in range(img1.size[0]):
+    for j in range(img1.size[1]):
+        if (img1.getpixel((i,j)) != img2.getpixel((i,j))):
+            N += 1
+            i1 = img1.getpixel((i,j))
+            i2 = img2.getpixel((i,j))
+            #print(i1)
+            new_image.putpixel((i, j), tuple([i1[0]-i2[0],i1[1]-i2[1],i1[2]-i2[2]])) # for "RGB"
+            # new_image.putpixel((i, j), tuple([i1-i2]))
+
+print("diff pixls = ", N) # diff pixls =  179958
+print(f"{N*100/(img1.size[0]*img1.size[1]):.2f}%")
+
+
+new_image.show()
+new_image.save(f"diff_encryption={N*100/(img1.size[0]*img1.size[1]):.2f}%.png")

scripts/movefortest.py

@@ -0,0 +1,69 @@
+'''
+DATASET/:
+    test/:
+        0/ # without watermark
+        1/ # with
+    train/:
+        0/
+        1/
+    validation/:
+        0/
+        1/
+'''
+
+from PIL import Image
+import os, PIL, shutil, time
+from glob import glob
+
+
+def renameimg(path):
+    os.getcwd()
+    for i, filename in enumerate(os.listdir(path)):
+        try:
+            os.rename(path + "/" + filename, path + "/" + str(i) + ".jpeg")
+        
+        except FileExistsError:
+            pass
+
+def resize(path, color_mode):
+    dirs = os.listdir(path)
+    print('before resize ', len(dirs))
+    for item in dirs:
+        try:
+            # print(item)
+            with Image.open(fr'{path}/{item}') as im:
+                resized = im.convert(f'{color_mode}').resize((Width,Height))
+                resized.save(fr'{path}/{item[:-5]}.jpg')
+                time.sleep(0.0003)
+                # print(fr'for {item} have been done')
+        except PIL.UnidentifiedImageError:
+            print(fr"Confirmed: This image {path}/{item} cannot be opened!")
+            # os.remove(f'{path}{item}')
+        except OSError:
+            im = Image.open(fr'{path}/{item}').convert(f'{color_mode}').resize((Width,Height))
+            im.save(fr'{path}/{item[:-5]}.jpg')
+            print(fr"Chanched by hands for {path}/{item}")
+    dirs = os.listdir(path)
+    print('after resize ', len(dirs))
+
+def moveimg(fromdir, todir, STOP):
+    for i, filename in enumerate(os.listdir(fromdir)):
+        if i == STOP:
+            break
+        else:
+            shutil.move(fromdir + "/" + filename, todir + "/" + filename)
+            i += 1
+
+def removejpeg(fromdir):
+    images = glob(f'{fromdir}/*.jpeg')
+    for image in images:
+        os.remove(image)
+
+Width, Height = 1120, 1120
+path = "fortestfromcoco" 
+color_mode = "RGB" 
+# renameimg(path)
+# resize(path, color_mode)
+# removejpeg(path)
+
+# moveimg(path, '0', 494)

scripts/split_image.py

@@ -0,0 +1,17 @@
+from PIL import Image
+from glob import glob
+
+path = '11wm/*.jpg'
+
+N = 5 # разделить на N**2
+
+images = glob(path)
+k = 1
+for image in images:
+    im = Image.open(image)
+    for i in range(N):
+        for j in range(N):
+            if i!=N and j!=N:
+                im.crop(box=(im.size[0]/N*i, im.size[1]/N*j, im.size[0]/N*(i+1), im.size[1]/N*(j+1))).\
+                save(f'1/{k}.jpg')
+                k += 1

scripts/test.py

@@ -0,0 +1,67 @@
+"""Простой скрипт для тестирования работы водяных знаков"""
+
+from glob import glob
+from watermark import WaterMark
+
+
+def embed_watermark(
+    src_img_filename: str, dst_img_filename: str, wm_content: str, password: int
+) -> int:
+    """Внедрить водяной знак в изображение"""
+
+    watermark = WaterMark()
+
+    return watermark.embed_and_save(
+        src_img_filename, wm_content, password, dst_img_filename
+    )
+
+
+def extract_watermark(filename: str, wm_size: int, password: int) -> str:
+    """Извлечь водяной знак из изображения"""
+
+    watermark = WaterMark()
+
+    return watermark.extract_img_filename(filename, password, wm_size)
+
+
+SRC_IMG_PATHNAME_PATTERN = "11/*.jpg"
+SRC_TXT = "101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010"
+PASSWORD = 123456789
+
+
+def main():
+    """Точка входа"""
+
+    # watermark_size = embed_watermark(
+    #     "photos/2.jpg", DST_IMG_FILENAME, SRC_TXT, PASSWORD
+    # )
+
+    # dst_txt = extract_watermark(DST_IMG_FILENAME, watermark_size, PASSWORD)
+
+    # if dst_txt != SRC_TXT:
+    #     print(False, dst_txt)
+
+    # return
+
+    src_img_filenames = glob(SRC_IMG_PATHNAME_PATTERN)
+    i = 1
+    for src_img_filename in src_img_filenames:
+        DST_IMG_FILENAME = f"11wm/{src_img_filename[2:]}"
+        watermark_size = embed_watermark(
+            src_img_filename, DST_IMG_FILENAME, SRC_TXT, PASSWORD
+        )
+
+        dst_txt = extract_watermark(DST_IMG_FILENAME, watermark_size, PASSWORD)
+
+        if dst_txt != SRC_TXT:
+            print(False, dst_txt)
+            continue
+
+        # break
+
+        print(i, True)
+        i += 1
+
+
+if __name__ == "__main__":
+    main()

scripts/watermark.py

@@ -0,0 +1,225 @@
+"""Файл, хранящий класс WaterMark и функции для шифрования"""
+
+import numpy as np
+import cv2
+
+from cv2.typing import MatLike
+
+from watermarkcore import WaterMarkCore
+
+
+class WaterMark:
+    """Класс-обёртка для работы с водяными знаками"""
+
+    def __init__(self):
+        self.wm_core = WaterMarkCore()
+
+    def embed_and_save(
+        self,
+        src_img_filename: str,
+        wm_content: str,
+        password: str,
+        img_path: str,
+        compression_ratio: int = 100,
+    ) -> int:
+        """Внедрить водяной знак в изображение и сохранить его"""
+
+        img, wm_size = self.embed(src_img_filename, wm_content, password)
+
+        cv2.imwrite(
+            img_path,
+            img,
+            params=[cv2.IMWRITE_JPEG_QUALITY, compression_ratio],
+        )
+
+        return wm_size
+
+    def embed(
+        self, src_img_filename: str, wm_content: str, password: str
+    ) -> tuple[MatLike, int]:
+        """Внедрить водяной знак в изображение"""
+
+        self.prepare_img_filename(src_img_filename)
+        wm_size = self.prepare_wm(wm_content, password)
+        img = self.wm_core.embed(password)
+
+        # print(
+        #     "\nFill percentage without duplication",
+        #     wm_size
+        #     / (
+        #         img.shape[0]
+        #         * img.shape[1]
+        #         / (
+        #             self.wm_core.BLOCK_SHAPE[0]
+        #             * self.wm_core.BLOCK_SHAPE[1]
+        #             * np.dtype(np.float32).itemsize
+        #         )
+        #     ),
+        # )
+
+        return (img, wm_size)
+
+    def prepare_img_filename(self, filename: str) -> MatLike:
+        """Подготовить изображение из файла"""
+
+        img = cv2.imread(filename, flags=cv2.IMREAD_UNCHANGED)
+        assert img is not None, f"Image file \"'{filename}'\" is unreadable!"
+
+        self.wm_core.prepare_img_arr(img)
+
+    def prepare_wm(
+        self, wm_content: str, password: int, encoding: str = "utf-8"
+    ) -> int:
+        """Зашифровать и подготовить водяной знак"""
+
+        wm_bit = encrypt_wm_content(wm_content, password, encoding)
+        self.wm_core.prepare_wm(wm_bit)
+
+        return wm_bit.size
+
+    def extract_img_filename(self, filename: str, password: int, wm_size: int) -> str:
+        """Извлечь водяной знак из файла"""
+
+        img = cv2.imread(filename, flags=cv2.IMREAD_COLOR)
+        assert img is not None, f"Image file \"'{filename}'\" is unreadable!"
+
+        return self.extract_img(img, password, wm_size)
+
+    def extract_img(self, img: MatLike, password: int, wm_size: int) -> str:
+        """Извлечь водяной знак из изображения"""
+
+        wm_avg = self.wm_core.extract_with_kmeans(img, wm_size, password)
+
+        return decrypt_wm_content(wm_avg, password, wm_size)
+
+
+def encrypt_wm_content(
+    wm_content: str, password: int, encoding: str = "utf-8"
+) -> np.ndarray[bool]:
+    """Зашифровать водяной знак"""
+
+    bits = txt_to_bits(wm_content, encoding)
+    shuffle_array(bits, password)
+
+    return bits
+
+
+def decrypt_wm_content(
+    wm_bits: np.ndarray[bool], password: int, wm_size: int, encoding: str = "utf-8"
+) -> str:
+    """Дешифровать водяной знак"""
+
+    deshuffle_array(wm_bits, password, wm_size)
+    wm_content = bits_to_txt(wm_bits, encoding)
+
+    return wm_content
+
+
+def shuffle_array(array: np.ndarray, seed: int):
+    """Перемешать случайные блоки массива битов"""
+
+    random_state = np.random.RandomState(seed)
+    random_state.shuffle(array)
+
+
+def deshuffle_array(array: np.ndarray, seed: int, wm_size: int):
+    """Восстановить блоки перемешанного массива"""
+
+    indexes_for_deshuffle = np.arange(wm_size)
+    shuffle_array(indexes_for_deshuffle, seed)
+    array[indexes_for_deshuffle] = array.copy()
+
+
+def txt_to_bits(txt: str, encoding: str = "utf-8") -> np.ndarray[bool]:
+    """Преобразовать водяной знак ("abc") в массив битов [True, False].
+    txt -> hex_str -> num -> bin_str -> bin_chars -> bits"""
+
+    hex_str = hex_encode(txt, encoding)
+    num = hex_str_to_num(hex_str)
+    bin_str = num_to_bin_str(num)
+    bin_chars = str_to_chars(bin_str)
+    bits = bin_chars_to_bits(bin_chars)
+
+    return bits
+
+
+def bits_to_txt(bits: np.ndarray[bool], encoding: str = "utf-8"):
+    """Преобразовать массив битов [True, False] в водяной знак ("abc").
+    bits -> bin_chars -> bin_str -> num -> hex_str -> txt"""
+
+    bin_chars = bits_to_bin_chars(bits)
+    bin_str = chars_to_str(bin_chars)
+    num = bin_str_to_num(bin_str)
+    hex_str = num_to_hex_str(num)
+    txt = hex_decode(hex_str, encoding)
+
+    return txt
+
+
+def hex_encode(txt: str, encoding: str = "utf-8") -> str:
+    """Побайтово кодировать строку ("abc") в заданной кодировке (по умолчанию: "utf-8"),
+    а затем преобразовать в строку с 16-ми представлениями этих байтов ("123F")"""
+
+    encoded_txt = txt.encode(encoding)
+
+    return encoded_txt.hex()
+
+
+def hex_decode(hex_str: str, encoding: str = "utf-8") -> str:
+    """Преобразовать строку с 16-ми представлениями символов в байты,
+    а затем побайтово декодировать строку из символов ("abc") в заданной кодировке (по умолчанию: "utf-8").
+    Заменяет нечитаемые символы символом (�)"""
+
+    hex_bytes = bytes.fromhex(hex_str)
+
+    return hex_bytes.decode(encoding, errors="replace")
+
+
+def hex_str_to_num(hex_str: str) -> int:
+    """Преобразовать строку с 16-м числом ("67F") в 10-е число (123)"""
+
+    return int(hex_str, base=16)
+
+
+def num_to_hex_str(num: int) -> str:
+    """Преобразовать 10-е число (123) в строку с 16-м числом ("67F")"""
+
+    return hex(num)[2:]
+
+
+def num_to_bin_str(num: int) -> str:
+    """Преобразовать 10-е число (123)
+    в 2-е число в виде строки без указания системы счисления в начале строки ("10101")
+    """
+
+    return bin(num)[2:]
+
+
+def bin_str_to_num(bin_str: str) -> int:
+    """Преобразовать 2-е число в виде строки без указания системы счисления в начале строки ("10101")
+    в 10-е число (123)"""
+
+    return int(bin_str, base=2)
+
+
+def str_to_chars(txt: str) -> np.ndarray[str]:
+    """Преобразовать строку ('abc') в массив символов ['a', 'b', 'c']"""
+
+    return np.array(list(txt))
+
+
+def chars_to_str(bin_chars: list[str]) -> str:
+    """Преобразовать массив символов ['a', 'b', 'c'] в строку ('abc')"""
+
+    return "".join(bin_chars)
+
+
+def bin_chars_to_bits(bin_chars: np.ndarray[str]) -> np.ndarray[bool]:
+    """Преобразовать бинарные символы ['1', '0'] в массив битов [True, False]"""
+
+    return bin_chars == "1"
+
+
+def bits_to_bin_chars(bits: np.ndarray[bool]) -> list[str]:
+    """Преобразовать массив битов [True, False] в бинарные символы ['1', '0']"""
+    return [str(int(bit)) for bit in bits]

scripts/watermarkcore.py

@@ -0,0 +1,332 @@
+"""Файл, хранящий класс WaterMarkCore и функцию-кластеризатор (метод k-средних)"""
+
+from random import Random
+
+import copy
+import numpy as np
+import cv2
+
+from cv2 import dct, idct
+from cv2.typing import MatLike
+from numpy.linalg import svd
+from pywt import dwt2, idwt2
+
+
+class WaterMarkCore:
+    """Класс-ядро для работы с водяными знаками"""
+
+    # Размер блока
+    # Чем больше размер, тем выше стойкость, но тем больше искажается выходное изображение
+    BLOCK_SHAPE: np.ndarray[np.int32] = np.array([3, 3])
+
+    MIN_D = 2  # Нижний порог интервала квантования
+    MAX_D = 9  # Верхний порог интервала квантования
+    DUPLICATE_NUM = 10
+
+    def __init__(self):
+        self.ca_block = [np.array([])] * 3  # Результаты для: dct на канал
+        self.block_num = 0  # Количество фрагментов информации, которые могут быть вставлены в исходное изображение
+        self.wm_size = 0  # Высота и ширина водяного знака
+        self.img_shape = None  # Размер изображения
+        self.part_shape = None  # Это округленный двумерный размер ca, который используется для игнорирования смещения элементов справа и снизу при встраивании
+        self.block_index = None  # Декартово произведение всех индексов блоков
+        self.ca_block_shape = None  # Кортеж (кол-во блоков в высоту, кол-во блоков в ширину, высота блока, ширина блока)
+        self.wm_bits = None  # Водяной знак (массив битов)
+
+        # Аппроксимация от двумерного дискретного вейвлет-преобразования
+        self.ca = [np.array([])] * 3
+
+        # Коэффициенты от двумерного дискретного вейвлет-преобразования
+        # (horizontal detail, vertical detail and diagonal detail coefficients respectively)
+        self.hvd = [np.array([])] * 3
+
+    def embed(self, password: int) -> MatLike:
+        """Внедрить подготовленный водяной знак в подготовленное изображение"""
+
+        self.init_block_index()
+        embed_ca = copy.deepcopy(self.ca)
+        embed_yuv = [np.array([])] * 3
+        seed1 = str(password)[::2]
+        seed2 = str(password)[1::2]
+
+        for channel in range(3):
+            random1 = Random(seed1)
+            random2 = Random(seed2)
+            blocks_args = [
+                (
+                    self.ca_block[channel][self.block_index[i]],
+                    i,
+                    random1.randint(WaterMarkCore.MIN_D, WaterMarkCore.MAX_D),
+                    random2.randint(WaterMarkCore.MIN_D, WaterMarkCore.MAX_D),
+                )
+                for i in range(self.block_num)
+            ]
+            tmp = list(map(self.block_add_wm, blocks_args))
+
+            for i in range(self.block_num):
+                self.ca_block[channel][self.block_index[i]] = tmp[i]
+
+            # Четырехмерное преобразование в двухмерное
+            # Каждый канал хранит четырехмерный массив,
+            # представляющий результат четырехмерной разбивки.
+            # После четырехмерной разбивки иногда часть отсутствует из-за нецелочисленного деления.
+            # ca_part - это часть ca, которая отсутствует в данном канале
+            ca_part = np.concatenate(np.concatenate(self.ca_block[channel], 1), 1)
+
+            # При 4-мерном разбиении правая и нижняя часть длинной полосы,
+            # которая не является делимой, сохраняется,
+            # а остальное - это основная часть данных,
+            # которая после встраивания преобразуется в частотную область.
+            embed_ca[channel][: self.part_shape[0], : self.part_shape[1]] = ca_part
+
+            # инверсия
+            embed_yuv[channel] = idwt2((embed_ca[channel], self.hvd[channel]), "haar")
+
+        # Объединить 3 канала
+        embed_img_yuv = np.stack(embed_yuv, axis=2)
+
+        # Ранее, если оно не было целым числом 2, оно добавляло белую рамку, которая здесь удалена
+        embed_img_yuv = embed_img_yuv[: self.img_shape[0], : self.img_shape[1]]
+        embed_img = cv2.cvtColor(embed_img_yuv, cv2.COLOR_YUV2BGR)
+        embed_img = np.clip(embed_img, a_min=0, a_max=255)
+
+        return embed_img
+
+    def extract_with_kmeans(
+        self, img: MatLike, wm_size: int, password: int
+    ) -> np.ndarray[bool]:
+        """Извлечь кластеризированный водяной знак из изображения"""
+
+        wm_avg = self.extract(img, wm_size, password)
+
+        return one_dim_kmeans(wm_avg)
+
+    def extract(
+        self, img: MatLike, wm_size: int, password: int
+    ) -> np.ndarray[np.float64]:
+        """Извлечь водяной знак из изображения"""
+
+        wm_raw_bits = self.extract_raw(img, password)
+
+        return extract_avg(wm_raw_bits, wm_size)
+
+    def extract_raw(self, img: MatLike, password: int) -> np.ndarray[np.float64]:
+        """Извлечь необработанные биты, из каждого блока"""
+
+        self.prepare_img_arr(img)
+        self.init_block_index()
+        wm_raw_bits = np.zeros(shape=(3, self.block_num))
+        seed1 = str(password)[::2]
+        seed2 = str(password)[1::2]
+
+        for channel in range(3):
+            random1 = Random(seed1)
+            random2 = Random(seed2)
+            blocks_args = [
+                (
+                    self.ca_block[channel][self.block_index[i]],
+                    random1.randint(WaterMarkCore.MIN_D, WaterMarkCore.MAX_D),
+                    random2.randint(WaterMarkCore.MIN_D, WaterMarkCore.MAX_D),
+                )
+                for i in range(self.block_num)
+            ]
+            wm_raw_bits[channel, :] = list(map(self.block_get_wm, blocks_args))
+
+        return wm_raw_bits
+
+    def prepare_img_arr(self, img: MatLike):
+        """Подготовить изображение.
+        Считывание изображения ->
+        YUVise ->
+        добавление белой границы, чтобы сделать пиксели равномерными ->
+        4D чанкинг"""
+
+        img = img.astype(np.float32)
+
+        # shape (высота, ширина, кол-во цветов), img_shape (высота, ширина)
+        self.img_shape = img.shape[:2]
+
+        # Y (яркость) UV (цвет)
+        img_yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV)
+
+        # Дополнить изображение чёрной рамкой в 1 пиксель в нижней и/или левой части,
+        # чтобы ширина и высота были чётными
+        img_yuv_with_border = cv2.copyMakeBorder(
+            img_yuv,
+            0,
+            img.shape[0] % 2,
+            0,
+            img.shape[1] % 2,
+            cv2.BORDER_CONSTANT,
+            value=(0, 0, 0),
+        )
+
+        ca_shape = [(i + 1) // 2 for i in self.img_shape]  # центр
+        self.ca_block_shape = (
+            ca_shape[0] // WaterMarkCore.BLOCK_SHAPE[0],
+            ca_shape[1] // WaterMarkCore.BLOCK_SHAPE[1],
+            WaterMarkCore.BLOCK_SHAPE[0],
+            WaterMarkCore.BLOCK_SHAPE[1],
+        )
+
+        # Размер/шаг в байтах для построения свёртки
+        strides = np.dtype(np.float32).itemsize * np.array(
+            [
+                ca_shape[1] * WaterMarkCore.BLOCK_SHAPE[0],
+                WaterMarkCore.BLOCK_SHAPE[1],
+                ca_shape[1],
+                1,  # Сдвиг по каналам
+            ]
+        )
+
+        for channel in range(3):
+            # haar, db1, bior1/1, rbio1/1
+            self.ca[channel], self.hvd[channel] = dwt2(
+                img_yuv_with_border[:, :, channel], "haar"
+            )  # Двумерное дискретное вейвлет-преобразование (Тип вейвлет: "haar")
+            # Переход к 4 измерениям
+            self.ca_block[channel] = np.lib.stride_tricks.as_strided(
+                self.ca[channel].astype(np.float32), self.ca_block_shape, strides
+            )  # Построение свёртки исходного изображения (разделение на блоки)
+
+    def prepare_wm(self, wm_bits: np.ndarray[bool]):
+        """Подготовить водяной знака"""
+
+        self.wm_bits = wm_bits
+        self.wm_size = wm_bits.size
+
+    def init_block_index(self):
+        """Подготовить информацию о блоках"""
+
+        self.block_num = self.ca_block_shape[0] * self.ca_block_shape[1]
+
+        assert self.wm_size < self.block_num, IndexError(
+            f"До {self.block_num * 3 / 128} кб встроенной информации, \
+            более {self.wm_size * 3 / 128} кб информации с водяными знаками, переполнение"
+        )
+
+        self.part_shape = self.ca_block_shape[:2] * WaterMarkCore.BLOCK_SHAPE
+
+        self.block_index = [
+            (i, j)
+            for i in range(self.ca_block_shape[0])
+            for j in range(self.ca_block_shape[1])
+        ]
+
+    def block_add_wm(self, args) -> MatLike:
+        """Внедрить информацию о водяном знаке в блок.
+        d1, d2 ∊ N; d1, d2 > 1"""
+
+        block: np.ndarray[np.ndarray[np.float64]]
+        i: int
+        d1: int
+        d2: int
+        block, i, d1, d2 = args
+
+        if (
+            WaterMarkCore.DUPLICATE_NUM is not None
+            and i >= self.wm_size * WaterMarkCore.DUPLICATE_NUM
+        ):
+            return block
+
+        bit: bool = self.wm_bits[i % self.wm_size]
+
+        block_dct = dct(block)  # Дискретное косинус-преобразование
+
+        u: np.ndarray[np.ndarray[np.float32]]
+        s: np.ndarray[np.float32]
+        v: np.ndarray[np.ndarray[np.float32]]
+        u, s, v = svd(block_dct)  # Сингулярное разложение
+
+        s[0] = quantization(s[0], d1, bit)
+        s[1] = quantization(s[1], d2, bit)
+
+        inverse_block_dct = isvd(u, s, v)
+        inverse_block = idct(
+            inverse_block_dct
+        )  # Обратное дискретное косинус-преобразование
+
+        return inverse_block
+
+    def block_get_wm(self, args):
+        """Извлечь информацию о водяном знаке из блока.
+        d1, d2 ∊ N; d1, d2 > 1"""
+
+        block: np.ndarray[np.ndarray[np.float64]]
+        d1: int
+        d2: int
+        block, d1, d2 = args
+
+        dct_block = dct(block)
+
+        s: np.ndarray[np.float32]
+        _, s, _ = svd(dct_block)
+
+        bit1 = reverse_quantization(s[0], d1)
+        bit2 = reverse_quantization(s[1], d2)
+
+        # Первый столбец более устойчив к помехам
+        # и имеет больший коэффициент, чем второй (3 к 1)
+        bit = (bit1 * 3 + bit2 * 1) / 4
+
+        return bit
+
+
+def quantization(num: np.float32, d: int, bit: bool) -> np.float32:
+    """Квантовать сигнал в число с заданным коэффициентом"""
+    return (num // d + 0.25 + 0.5 * bit) * d
+
+
+def reverse_quantization(num: np.float32, d: int) -> bool:
+    """Восстановить квантованный сигнал из числа с заданным коэффициентом"""
+    return num % d > d / 2
+
+
+def isvd(u, s, v):
+    """Обратное сингулярное разложение"""
+    return np.dot(u, np.dot(np.diag(s), v))
+
+
+def extract_avg(array: np.ndarray[np.float64], wm_size: int) -> np.ndarray[np.float64]:
+    """Извлечь массив средних арифметических дубликатов битов водяного знака.
+    Каждый элемент массива является средним арифметическим между дубликатами
+    квантованного числа от отдельного бита исходного водяного знака из каждого канала(2),
+    каждого блока (Кол-во блоков // размер водяного знака)
+    и каждого из используемых коэффициентов сингулярного разложения (2)"""
+
+    wm_bits_avg = np.zeros(np.int32(wm_size))
+
+    for i in range(wm_size):
+        repeated_wm_bit = array[:, i::wm_size]
+        if WaterMarkCore.DUPLICATE_NUM is not None:
+            repeated_wm_bit = repeated_wm_bit[:, : WaterMarkCore.DUPLICATE_NUM]
+        wm_bits_avg[i] = repeated_wm_bit.mean()
+
+    return wm_bits_avg
+
+
+def one_dim_kmeans(inputs: np.ndarray[np.float64], iter_num=300) -> np.ndarray[bool]:
+    """Кластеризировать входные точки (метод k-средних)"""
+
+    threshold = 0
+    e_tol = 10 ** (-6)
+    center = [inputs.min(), inputs.max()]  # 1. Инициализация центральной точки
+
+    for _ in range(iter_num):
+        threshold = (center[0] + center[1]) / 2
+
+        # 2. Проверка расстояния между всеми точками и этими k точками,
+        # каждая из которых классифицирована до ближайшего центра
+        is_class01 = inputs > threshold
+
+        # 3. Вычисление новой центральной точки
+        center = [inputs[~is_class01].mean(), inputs[is_class01].mean()]
+
+        # 4. Условие остановки
+        if np.abs((center[0] + center[1]) / 2 - threshold) < e_tol:
+            threshold = (center[0] + center[1]) / 2
+            break
+
+    is_class01 = inputs > threshold
+
+    return is_class01