image-math 1.0.0__py3-none-any.whl

image_math/__init__.py

@@ -0,0 +1,3 @@
+from .main import image_function, img_func
+from .main import escher_function, rotate, zoom_into_corner 
+from .main import kaleidoscope, assymetrical_kaleidoscope, logarithm, inverse, weierstrass

image_math/main.py

@@ -0,0 +1,160 @@
+"""
+Provide the vectorised inverted function. e.g. 
+Droste-to-Escher Image:
+
+z` = e ^ (ln(z) * c)
+where, c = e ^ (i * arctan(ln(scale)/2pi))
+
+Inverted function:
+z = e ^ (ln(z`) * (1/c))
+
+The second (i.e. inverted function) is what we want
+
+Vectorised: Uses numpy functions, allowing a tremendous speed up.
+"""
+
+import numpy as np
+from PIL import Image
+from skimage.draw import polygon
+from tqdm import tqdm
+
+def image_function(my_func):
+    def apply_function(input_image:str, output_image:str, zoom = 1.0, output_scale = 1.0, *args, **kwargs):
+        """
+        scale: refers to range of z to try out. Input is mapped from f(± 1 ± i) * scale. Output is always mapped from ± 1 ± i 
+        """
+        img = Image.open(input_image)
+        arr = np.array(img)
+        
+        
+        h,w,channels = arr.shape
+        ho,wo = int(h*output_scale),int(w*output_scale)
+        arr2 = np.zeros((ho,wo,channels), dtype=arr.dtype)
+        
+        
+        empty_pixel = (0,0,0,255) if channels == 4 else (0,0,0)
+
+        x = np.linspace(-1,1, wo+1)
+        y = np.linspace(-1,1,ho+1)
+
+        mesh_output = x[None, :] + 1j * y[:,None]
+        mesh_input = my_func(mesh_output/zoom, *args, **kwargs) # Gets input mesh
+
+        #Convert mesh to pixel borders
+        mesh_inp_x = (mesh_input.real * ((w-1)/2)) + ((w-1)/2)
+        mesh_inp_y = (mesh_input.imag * ((h-1)/2)) + ((h-1)/2)
+
+        for y in tqdm(range(ho)):
+            for x in range(wo):
+                x_l = np.array([mesh_inp_x[y,x], mesh_inp_x[y,x+1], mesh_inp_x[y+1,x+1], mesh_inp_x[y+1,x]])
+                y_l = np.array([mesh_inp_y[y,x], mesh_inp_y[y,x+1], mesh_inp_y[y+1,x+1], mesh_inp_y[y+1,x]])
+
+                if not (np.isfinite(x_l).all() and np.isfinite(y_l).all()):
+                    arr2[y, x] = empty_pixel
+                    continue
+                                
+                #Draw mask
+                rr, cc = polygon(y_l, x_l, shape=(h,w))
+
+                #Get final pixel
+                if len(rr):
+                    arr2[y,x] = arr[rr,cc].mean(axis=0)
+                else:
+                    inside = ((0 <= x_l) & (x_l <= w-1) & (0 <= y_l) & (y_l <= h-1)).any()
+                    if inside:
+                        ix = np.clip(x_l.mean(), 0, w-1)
+                        iy = np.clip(y_l.mean(), 0, h-1)
+                        arr2[y,x] = arr[int(round(iy)), int(round(ix))]
+                    else:
+                        arr2[y,x] = empty_pixel
+
+        Image.fromarray(arr2).save(output_image)
+
+
+
+    return apply_function
+
+def img_func(my_func):
+    return image_function(my_func) #For pylance
+
+def escher_function(scale:float, center = (0,0), subject = (0,0), rev_warp = False):
+    """
+    Creates a function to convert a repeating picture into an escher-style image
+    scale: size of edge of image compared to 1st nested image.
+    center: center of repeating pattern in droste image (center = 0,0; top right = (1,1))
+    subject: subject position (remains stationary-ish)
+    """
+    b = 1 + 1j*(np.log(scale)/(2*np.pi)) * (-1 if rev_warp else 1)
+    c = center[0] + 1j* center[1]
+
+    d = 0 + 0j if subject == (0,0) else np.log(subject[0] + 1j * subject[1])
+
+    @image_function
+    def f(z):
+        w = z-c
+        w = np.where(w == 0, 1e-8 + 1e-8j, w) #Buffer
+
+        log_w_new = np.log(w)
+        low_w_old = b * (log_w_new - d) + d
+        z_raw = np.exp(low_w_old)
+
+        mag = np.abs(z_raw)
+        wrap_p = np.floor(-np.log(mag)/np.log(scale))
+        return z_raw * (scale ** wrap_p) + c        
+
+    return f
+
+def wp_lattice(w1 = 1, w2 = np.exp(1j * np.pi / 3), N = 10, scale = 5):
+    w1 *= scale
+    w2 *= scale
+
+    m = np.arange(-N, N+1)
+    n = np.arange(-N, N+1)
+
+    A, B = np.meshgrid(m,n, indexing='ij')
+
+    w = A*w1 + B*w2 
+    return w[~((A==0)&(B==0))]
+
+# ----
+# Cool functions to try out
+@image_function
+def rotate(z):
+    return z * 1j
+
+@image_function
+def zoom_into_corner(z):
+    return (z/3) + 2j/3 + 2/3
+
+@image_function
+def kaleidoscope(z):
+    return np.pow(z,6)
+
+@image_function
+def assymetrical_kaleidoscope(z):
+    return np.pow(z,3) - 3*np.pow(z,2)
+
+@image_function
+def logarithm(z):
+    return np.exp(z)
+
+@image_function
+def inverse(z):
+    return 1/z
+
+WP_LATTICE = None
+@image_function
+def weierstrass(z):
+    global WP_LATTICE
+    if WP_LATTICE is None:
+        WP_LATTICE = wp_lattice()
+
+    w = WP_LATTICE[:,None,None]
+    r = (1/(z**2)) 
+    
+    for wi in w:
+        r += (1/((z-wi)**2)) - (1/(wi**2)) #For memory reasons
+    
+    return r
+
+

image_math-1.0.0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: image_math
+Version: 1.0.0
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: Pillow>=10.0.0
+Requires-Dist: tqdm>=4.0.0
+Requires-Dist: scikit-image>=0.24.0
+

image_math-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+image_math/__init__.py,sha256=0KK7QkqDaBS5fLL7Gudrq7xY78EQN-U10Um_Ecyt0fk,196
+image_math/main.py,sha256=cvzh9xei0DXN0B3Lr-jXritl3w4N4cUs3Wu2Er4vf_g,4669
+image_math-1.0.0.dist-info/METADATA,sha256=z4fWKOkugdBtouS8xzyfIfaJjIODy7RxEDQtyzIXeuk,184
+image_math-1.0.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+image_math-1.0.0.dist-info/top_level.txt,sha256=bAtBRWKz0Z_rTr0U4DlCusY2TL_yl_uXEyRKJS43V1w,11
+image_math-1.0.0.dist-info/RECORD,,

image_math-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

image_math-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+image_math