optiklear 0.1.0__py3-none-any.whl

optiklear/conv.py

@@ -0,0 +1,103 @@
+import math
+
+def rotate_kernel(h):
+
+    for i in h:
+        i.reverse()
+
+    h.reverse()
+    return h
+
+def get_kernel_mid(h):
+
+    h_length = len(h)
+
+    h_mid_arr = math.floor(h_length / 2)
+    mid_idx = math.floor(len(h[h_mid_arr]) / 2)
+
+    return h_mid_arr, mid_idx
+
+def pad_matrix(h, B):
+
+    h = rotate_kernel(h)
+
+    row_count = len(h)
+    col_count = len(h[0])
+
+    side_pad = (col_count - 1) // 2
+    across_pad = (row_count - 1) // 2
+
+    # Side Padding
+    for i in range(len(B)):
+        for j in range(side_pad):
+            B[i].append([0, 0, 0])
+            B[i].insert(0, [0, 0, 0])
+
+    # Create top/bottom padding row
+    my_pad = [[0, 0, 0] for i in range(len(B[0]))]
+
+    # Top and bottom padding
+    for i in range(across_pad):
+        B.insert(0, my_pad.copy())
+        B.append(my_pad.copy())
+
+    return h, B
+
+def convolution(h, B):
+
+    # Rotate kernel and pad B
+    h, B = pad_matrix(h, B)
+
+    # Get kernel midpoint indexes
+    h_mid_arr, mid_idx = get_kernel_mid(h)
+
+    output = []
+
+    # Move the kernel across B
+    for i in range(h_mid_arr, len(B) - h_mid_arr):
+
+        row = []
+
+        for j in range(mid_idx, len(B[i]) - mid_idx):
+
+            total_B = 0
+            total_G = 0 
+            total_R = 0
+
+             
+            # Multiply kernel elements with B elements
+            for k in range(len(h)):
+
+                for l in range(len(h[k])):
+
+                    pixel =  B[i - h_mid_arr + k][j - mid_idx + l]
+
+                    total_B += pixel[0] * h[k][l]
+                    total_G += pixel[1] * h[k][l]
+                    total_R += pixel[2] * h[k][l]
+                    
+
+            row.append([total_B, total_G, total_R])
+
+        output.append(row)
+
+    return output
+
+# Client Code
+'''
+result = convolution(
+    [
+        [1/9, 1/9, 1/9],
+        [1/9, 1/9, 1/9],
+        [1/9, 1/9, 1/9]
+    ],
+    [
+        [1, 0, 1, 2, 2],
+        [1, 1, 2, 2, 3],
+        [1, 2, 2, 6, 3],
+        [1, 1, 2, 2, 3]
+    ]
+)
+
+print(result)
+'''

optiklear/mat_trans.py

@@ -0,0 +1,418 @@
+import numpy as np
+from math import *
+
+
+
+
+def matmax_multiply(A, B):
+
+    C = [
+        [
+            sum(A[i][j] * B[j][k] for j in range(len(B)))
+            for k in range(len(B[0]))
+        ]
+        for i in range(len(A))
+    ]
+
+    return C
+
+
+# --------------------------------------------------
+# HORIZONTAL SHEAR
+# --------------------------------------------------
+
+def horizontal_shear2D(image, k):
+
+    A = [
+        [1, k],
+        [0, 1]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    new_width = width + int(abs(k) * height)
+    new_height = height
+
+    transformed_image = np.zeros(
+        (new_height, new_width, image.shape[2]),
+        dtype=image.dtype
+    )
+
+    for row in range(height):
+
+        for col in range(width):
+
+            coordinate = [
+                [col],
+                [row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            new_col = int(new_coordinate[0][0])
+            new_row = int(new_coordinate[1][0])
+
+            if 0 <= new_col < new_width and 0 <= new_row < new_height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+# --------------------------------------------------
+# VERTICAL SHEAR
+# --------------------------------------------------
+
+def vertical_shear2D(image, k):
+
+    A = [
+        [1, 0],
+        [k, 1]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    new_width = width
+    new_height = height + int(abs(k) * width)
+
+    transformed_image = np.zeros(
+        (new_height, new_width, image.shape[2]),
+        dtype=image.dtype
+    )
+
+    for row in range(height):
+
+        for col in range(width):
+
+            coordinate = [
+                [col],
+                [row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            new_col = int(new_coordinate[0][0])
+            new_row = int(new_coordinate[1][0])
+
+            if 0 <= new_col < new_width and 0 <= new_row < new_height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+# --------------------------------------------------
+# SCALING
+# --------------------------------------------------
+
+def scale2D(image, Sx, Sy):
+
+    A = [
+        [Sx, 0],
+        [0, Sy]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    new_width = int(width * abs(Sx))
+    new_height = int(height * abs(Sy))
+
+    transformed_image = np.zeros(
+        (new_height, new_width, image.shape[2]),
+        dtype=image.dtype
+    )
+
+    for row in range(height):
+
+        for col in range(width):
+
+            coordinate = [
+                [col],
+                [row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            new_col = int(new_coordinate[0][0])
+            new_row = int(new_coordinate[1][0])
+
+            if 0 <= new_col < new_width and 0 <= new_row < new_height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+
+def clockwise_rotate2D(image, ang_deg):
+
+    theta = radians(ang_deg)
+
+    c = cos(theta)
+    s = sin(theta)
+
+    A = [
+        [c, -s],
+        [s, c]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    # Center of the original image
+    center_col = (width - 1) / 2
+    center_row = (height - 1) / 2
+
+    # Size of the rotated image
+    new_width = int(
+        abs(width * c) + abs(height * s)
+    )
+
+    new_height = int(
+        abs(height * c) + abs(width * s)
+    )
+
+    transformed_image = np.zeros(
+        (new_height, new_width, image.shape[2]),
+        dtype=image.dtype
+    )
+
+    # Center of the new image
+    new_center_col = (new_width - 1) / 2
+    new_center_row = (new_height - 1) / 2
+
+    for row in range(height):
+
+        for col in range(width):
+
+            # Move the pixel coordinate so that
+            # the image center becomes the origin
+            coordinate = [
+                [col - center_col],
+                [row - center_row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            rotated_col = new_coordinate[0][0]
+            rotated_row = new_coordinate[1][0]
+
+            # Move the coordinate back to the image
+            # and place it relative to the new image center
+            new_col = int(round(rotated_col + new_center_col))
+            new_row = int(round(rotated_row + new_center_row))
+
+            if 0 <= new_col < new_width and 0 <= new_row < new_height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+def antiClockwise_rotate2D(image, ang_deg):
+
+    theta = radians(ang_deg)
+
+    c = cos(theta)
+    s = sin(theta)
+
+    A = [
+        [c, s],
+        [-s, c]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    # Center of the original image
+    center_col = (width - 1) / 2
+    center_row = (height - 1) / 2
+
+    # Size of the rotated image
+    new_width = int(
+        abs(width * c) + abs(height * s)
+    )
+
+    new_height = int(
+        abs(height * c) + abs(width * s)
+    )
+
+    transformed_image = np.zeros(
+        (new_height, new_width, image.shape[2]),
+        dtype=image.dtype
+    )
+
+    # Center of the new image
+    new_center_col = (new_width - 1) / 2
+    new_center_row = (new_height - 1) / 2
+
+    for row in range(height):
+
+        for col in range(width):
+
+            # Move the pixel coordinate so that
+            # the image center becomes the origin
+            coordinate = [
+                [col - center_col],
+                [row - center_row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            rotated_col = new_coordinate[0][0]
+            rotated_row = new_coordinate[1][0]
+
+            # Move the coordinate back to the image
+            # and place it relative to the new image center
+            new_col = int(round(rotated_col + new_center_col))
+            new_row = int(round(rotated_row + new_center_row))
+
+            if 0 <= new_col < new_width and 0 <= new_row < new_height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+
+# --------------------------------------------------
+# FLIP LEFT ↔ RIGHT
+# Reflection about the Y-axis
+# --------------------------------------------------
+
+def flipX2D(image):
+
+    A = [
+        [-1, 0],
+        [0, 1]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    transformed_image = np.zeros(
+        image.shape,
+        dtype=image.dtype
+    )
+
+    for row in range(height):
+
+        for col in range(width):
+
+            coordinate = [
+                [col],
+                [row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            new_col = int(
+                new_coordinate[0][0] + (width - 1)
+            )
+
+            new_row = int(
+                new_coordinate[1][0]
+            )
+
+            if 0 <= new_col < width and 0 <= new_row < height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+# --------------------------------------------------
+# FLIP TOP ↔ BOTTOM
+# Reflection about the X-axis
+# --------------------------------------------------
+
+def flipY2D(image):
+
+    A = [
+        [1, 0],
+        [0, -1]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    transformed_image = np.zeros(
+        image.shape,
+        dtype=image.dtype
+    )
+
+    for row in range(height):
+
+        for col in range(width):
+
+            coordinate = [
+                [col],
+                [row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            new_col = int(
+                new_coordinate[0][0]
+            )
+
+            new_row = int(
+                new_coordinate[1][0] + (height - 1)
+            )
+
+            if 0 <= new_col < width and 0 <= new_row < height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+
+def translate2D(image, translation):
+
+    tx = translation[0]
+    ty = translation[1]
+
+    A = [
+        [1, 0],
+        [0, 1]
+    ]
+
+    height = image.shape[0]
+    width = image.shape[1]
+
+    transformed_image = np.zeros(
+        image.shape,
+        dtype=image.dtype
+    )
+
+    for row in range(height):
+
+        for col in range(width):
+
+            coordinate = [
+                [col],
+                [row]
+            ]
+
+            new_coordinate = matmax_multiply(A, coordinate)
+
+            new_col = int(
+                new_coordinate[0][0] + tx
+            )
+
+            new_row = int(
+                new_coordinate[1][0] + ty
+            )
+
+            if 0 <= new_col < width and 0 <= new_row < height:
+
+                transformed_image[new_row, new_col] = image[row, col]
+
+    return transformed_image
+
+
+

optiklear/mat_vec.py

@@ -0,0 +1,73 @@
+from math import cos, radians, sin
+
+# A is a transformation matrix
+def matvec_multiply(A, x):
+    b = [ sum (x[j] * A[i][j] for j in range(len(x)))for i in range(len(A))]
+    return b
+
+# u is a vector
+def horizontal_shear2D(u, k):
+    # k is shear factor, u is vector
+    A = [[1, k], [0, 1]] # A is horizontal shear matrix
+    b =  matvec_multiply(A, u)
+    return b
+#print(horizontal_shear2D([0, 2], -1))
+
+def vertical_shear2D(u, k):
+    A = [[1, 0], [k, 1]] # A is vertical shear matrix
+    b =  matvec_multiply(A, u)
+    return b
+#print(vertical_shear2D([2, 2], 1))   
+
+
+def scale2D(u, Sx, Sy):
+    #Sx and Sy are scalar constants
+    A = [[Sx, 0], [0, Sy]] # A is scale  matrix
+    b = matvec_multiply(A, u)
+    return b
+#print(scale([2, 2], 5, 0.5))
+
+def clockwise_rotate2D(u, ang_deg):
+    theta = radians(ang_deg)
+    c = cos(theta)
+    s = sin(theta)
+
+    A = [[c, s],[-s,  c]]
+
+    #A = [[cos(radians(ang_deg)), sin(radians(ang_deg))], [-sin(radians(ang_deg)), cos(radians(ang_deg))]]
+    b = matvec_multiply(A, u)
+    return b
+#print(clockwise_rotate2D([1, 2], 30))
+
+
+def antiClockwise_rotate2D(u, ang_deg):
+   # A = [[cos(radians(ang_deg)), -sin(radians(ang_deg))], [sin(radians(ang_deg)), cos(radians(ang_deg))]]
+    theta = radians(ang_deg)
+    c = cos(theta)
+    s = sin(theta)
+    A = [[c, -s],[s,  c]]
+    b = matvec_multiply(A, u)
+    return b
+#print(clockwise_rotate2D([1, 2], 30))
+
+def flipX2D(u):
+ #reflect along the y-axis
+ A = [[-1, 0], [0, 1]]
+ b = matvec_multiply(A, u)
+ return b
+#print(flipX2D([1, 2]))
+
+def flipY2D(u):
+ #reflect along the x-axis
+ A = [[1, 0], [0, -1]]
+ b = matvec_multiply(A, u)
+ return b
+#print(flipY2D([1, 2]))
+
+def translate2D(u, translation):
+   # translation is a 2d vector
+   A = [[1, 0], [0, 1]]
+   b = matvec_multiply(A, u)
+   translated =  [b[0] + translation[0], b[1] + translation[1]]
+   return translated
+#print(translate2D([1, 2], [1, -1]))

optiklear/noise_gen.py

@@ -0,0 +1,45 @@
+import random
+import numpy as np
+import copy
+
+
+def unif_noise(image, lower, upper):
+    for i in range(image.shape[0]):
+        for j in range(image.shape[1]):
+            noise = random.uniform(lower, upper)
+            noisy_pixel = image[i, j] + noise
+            noisy_pixel = np.clip(noisy_pixel, 0, 255)
+            image[i, j] = np.uint8(np.round(noisy_pixel))
+            
+    return image
+
+
+
+def gauss_noise(image, std):
+    for i in range(image.shape[0]):
+        for j in range(image.shape[1]):
+            noise = random.gauss(mu=0.0, sigma=std)
+            noisy_pixel = image[i, j] + noise
+            noisy_pixel = np.clip(noisy_pixel, 0, 255)
+            image[i, j] = np.uint8(np.round(noisy_pixel))
+    return image
+
+
+
+
+def salt_pepper_noise(image, prob_pepper, prob_salt):
+
+    copied_image = copy.deepcopy(image)
+
+    for i in range(len(copied_image)):
+        for j in range(len(copied_image[i])):
+
+            rand_num = random.random()
+
+            if rand_num < prob_pepper:
+                copied_image[i][j] = 0
+
+            elif rand_num > 1 - prob_salt:
+                copied_image[i][j] = 255
+
+    return copied_image

optiklear/non_linear.py

@@ -0,0 +1,83 @@
+import copy
+
+
+def pad_matrix(B, row_count, col_count):
+
+    window_size = row_count * col_count
+
+    side_pad = (col_count - 1) // 2
+    across_pad = (row_count - 1) // 2
+
+    # Side Padding
+    for i in range(len(B)):
+        for j in range(side_pad):
+            B[i].append([0, 0, 0])
+            B[i].insert(0, [0, 0, 0])
+
+    # Create top/bottom padding row
+    my_pad = [[0, 0, 0] for i in range(len(B[0]))]
+
+    # Top and bottom padding
+    for i in range(across_pad):
+        B.insert(0, my_pad.copy())
+        B.append(my_pad.copy())
+
+    return B, window_size
+
+
+def med_filter(input_image, row_count, col_count):
+
+    # Make a copy so the original image is not modified
+    image_copy = copy.deepcopy(input_image)
+
+    # Pad the image
+    B, window_size = pad_matrix(
+        image_copy,
+        row_count,
+        col_count
+    )
+
+    output_image = []
+
+    # Move the window across B
+    for i in range(len(B) - row_count + 1):
+
+        row = []
+
+        for j in range(len(B[0]) - col_count + 1):
+
+            # Lists for the three RGB channels
+            red_values = []
+            green_values = []
+            blue_values = []
+
+            # Extract the window
+            for k in range(row_count):
+                for l in range(col_count):
+
+                    pixel = B[i + k][j + l]
+
+                    red_values.append(pixel[0])
+                    green_values.append(pixel[1])
+                    blue_values.append(pixel[2])
+
+            # Sort each channel
+            red_values.sort()
+            green_values.sort()
+            blue_values.sort()
+
+            # Get median of each channel
+            median_red = red_values[window_size // 2]
+            median_green = green_values[window_size // 2]
+            median_blue = blue_values[window_size // 2]
+
+            # Construct the output pixel
+            row.append([
+                median_red,
+                median_green,
+                median_blue
+            ])
+
+        output_image.append(row)
+
+    return output_image

optiklear/vec_operations.py

@@ -0,0 +1,87 @@
+import math
+
+# Add more than 2 vectors
+def add2D_multi(*vectors):
+    return (sum([v[0] for v in vectors]), sum([v[1] for v in vectors]))
+
+
+
+def vec_add2D(u, v):
+    w = [u[0] + v[0], u[1] + v[1]]
+    return w
+#print(vec_add([2, 4], [5, 10]))
+
+
+def vec_subtract2D(u, v):
+      w = [u[0]- v[0], u[1] - v[1]]
+      return w
+
+
+def mag_v2D(v):
+   # return math.floor(math.sqrt(v[0]**2 + v[1]**2))
+     return  math.sqrt(v[0]**2 + v[1]**2)
+#print(mag_v([5, 10]))
+
+def dis_vecs2D(u, v):
+    return math.sqrt((v[0]-u[0])**2 + (v[1]-u[1])**2)
+
+
+
+def dot_product2D(u, v):
+     uv = u[0] * v[0] + u[1] * v[1]
+     return uv
+
+
+
+def ang_vectors2D(u, v):
+    uv = dot_product2D(u, v)
+    cos_val = uv/(mag_v2D(u) * mag_v2D(v))
+    ang_between = math.degrees(math.acos(cos_val))
+    return ang_between
+
+
+
+def scale(weight, v):
+     v = [weight * i for i in v]
+     return v
+
+
+
+# use for single polar coordinates
+def pole_to_cart(radius, angle):
+      x = radius * math.cos(math.radians(angle))
+      y = radius * math.sin(math.radians(angle))
+      return (x, y)
+
+
+def polar_vector_to_cart(polar_vector):
+    length, angle = polar_vector
+    return (length*math.cos(angle), length*math.sin(angle))
+
+# use for single vector
+def cart_to_pole(x, y):
+     radius = math.sqrt(x**2 + y**2)
+    # tan_theta = y/x
+     theta = math.atan2(y, x)    
+     return (radius,  theta)
+
+# use for multiple vectors
+def cart_to_polar(vector):
+    x, y = vector[0], vector[1]
+    angle = math.atan2(y,x)
+    return (mag_v2D(vector), angle)
+
+
+def rotate(angle, vectors):
+    polars = [cart_to_polar(v) for v in vectors]
+    return [polar_vector_to_cart((length, a+angle)) for length,a in polars]
+
+
+def translate(translation, vectors):
+    return [add2D_multi(translation, v) for v in vectors]
+ 
+
+def cross_prod(u, v):
+   u_cross_v = [u[1]* v[2] - u[2] * v[1] ,  u[2] * v[0]  - u[0] * v[2] , u[0] * v[1] - u[1] * v[0] ]
+   return u_cross_v
+#print(cross_prod([1, 2, -1], [2, -1, 2]))

optiklear-0.1.0.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.5
+Name: optiklear
+Version: 0.1.0
+Summary: A Python library for mathematical operations and image processing
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# OptiKlear
+
+**OptiKlear** is a Python library for mathematical operations and digital image processing.
+
+It provides reusable functions for vector operations, matrix-vector transformations, image transformations, noise generation and spatial filtering.
+
+## Features
+
+Current functionality includes:
+
+- **Convolution:** Spatial convolution for image filtering.
+- **Nonlinear filtering:** Median filtering.
+- **Noise generation:** Uniform, Gaussian and salt-and-pepper noise.
+- **Geometric transformations:** Scaling, rotation, shearing, flipping and translation.
+- **Matrix-vector operations:** Matrix multiplication and 2D vector transformations.
+- **Vector operations:** Vector addition, subtraction, magnitude, distance, dot product, cross product and rotation.
+
+## Installation
+
+Install OptiKlear using pip:
+
+```bash
+pip install optiklear
+```
+
+**Note:** OptiKlear is currently under development. The package will be available on PyPI following its initial release.
+
+## Requirements
+
+- Python 3.10 or later
+- NumPy
+
+## Package Structure
+
+| Module | Description |
+|---|---|
+| `conv` | Convolution operations |
+| `non_linear` | Nonlinear image filtering |
+| `noise_gen` | Image noise generation |
+| `mat_trans` | 2D image transformations |
+| `mat_vec` | Matrix-vector operations and transformations |
+| `vec_operations` | Mathematical vector operations |
+
+## Usage
+
+Import individual functions from their respective modules.
+
+For example, to use vector operations:
+
+```python
+from optiklear.vec_operations import vec_add2D, mag_v2D
+
+u = [3, 4]
+v = [2, 5]
+
+result = vec_add2D(u, v)
+magnitude = mag_v2D(u)
+
+print(result)
+print(magnitude)
+```
+
+To use image noise generation:
+
+```python
+from optiklear.noise_gen import gauss_noise
+
+noisy_image = gauss_noise(image, 9)
+```
+
+The image-processing functions currently use NumPy arrays and/or Python lists according to their individual implementations. Check each function's input requirements before use.
+
+## Development Roadmap
+
+Planned additions for future versions include:
+
+- Point operations
+- Edge detection
+

optiklear-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+optiklear/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+optiklear/conv.py,sha256=sfds5VAoO_cDkZTLRDsO0UzoDPGmpd7dbZnD_AzhWqc,1991
+optiklear/mat_trans.py,sha256=YpQ_TsQ_TvcJDMahM54zXzF6Hny8pCXCQkozDNlowJw,8854
+optiklear/mat_vec.py,sha256=2u_Krzng3yad_gQzJQloJTD12CpIbbUghrivDjjD6i0,1898
+optiklear/noise_gen.py,sha256=SRtmN2m0tnUruHwA7Q3LHYlpSmNaRMZaeupqUaBqLwk,1147
+optiklear/non_linear.py,sha256=wDjX_QzgGjBvdhUQvAGQsHlJutgjBbQUoh86DXBkra0,2016
+optiklear/vec_operations.py,sha256=TSfe-CR-GhQXGnATMm3iHJSXxf28Eapma_e2b-b0840,1946
+optiklear-0.1.0.dist-info/METADATA,sha256=d9aq_mnRtMJVVRxun1BzfSgv2go757PQi-MUVGf8yY4,2272
+optiklear-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+optiklear-0.1.0.dist-info/RECORD,,

optiklear-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any