chgnhyk 0.0.0__tar.gz

chgnhyk-0.0.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: chgnhyk
+Version: 0.0.0
+Summary: visual and audio engine of chgnhyk
+Requires-Python: >=3.9.0
+Description-Content-Type: text/markdown
+Requires-Dist: moderngl
+Requires-Dist: numpy
+Requires-Dist: pillow
+Requires-Dist: opencv-python
+Requires-Dist: csoundengine
+Requires-Dist: moviepy
+Requires-Dist: svgpathtools
+Requires-Dist: trimesh
+Requires-Dist: pyrr
+Requires-Dist: noise
+Requires-Dist: moderngl_window

chgnhyk-0.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "chgnhyk"
+version = "0.0.0"
+description = "visual and audio engine of chgnhyk"
+readme = "README.md"
+requires-python = ">=3.9.0"
+dependencies = [
+    "moderngl",
+    "numpy",
+    "pillow",
+    "opencv-python",
+    "csoundengine",
+    "moviepy",
+    "svgpathtools",
+    "trimesh",
+    "pyrr",
+    "noise",
+    "moderngl_window"
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

chgnhyk-0.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chgnhyk-0.0.0/src/chgnhyk/AreaPicker.py

@@ -0,0 +1,114 @@
+import math
+import random
+
+class AreaCell:
+    def __init__(self, x, y, idx):
+        self.filled = False
+        self.x = x
+        self.y = y
+        self.idx = idx
+        #seed(0)
+        pass
+
+class AreaPicker:
+    def __init__(self, w:int, h:int, seed:int=0):
+        self.reset(w, h, seed)
+        self.min_w = 0
+        
+
+    def reset(self, w:int, h:int, seed:int=0):
+        self.rects = []
+        self.depleted = False
+        self.seed = seed
+        random.seed(self.seed)
+        self.setGrid(w, h)
+        
+
+    def setGrid(self, w:int, h:int):
+        self.gw = w
+        self.gh = h
+        self.cells = []
+        self.pool = []
+        for x in range(self.gw):
+            for y in range(self.gh):
+                idx = x + y * self.gw
+                self.cells.append(AreaCell(x, y, idx))
+                self.pool.append(idx)
+
+    def pickArea(self):
+        if len(self.pool) == 0:
+            self.depleted = True
+            return
+        
+        pck_idx = random.randint(0, len(self.pool)-1)
+        pck_idx = self.pool[pck_idx]
+
+        pck_y_idx = math.floor(pck_idx/self.gw)
+        pck_x_idx = pck_idx % self.gw
+
+        x_dir = -1 if random.random() > 0.5 else 1
+        y_dir = -1 if random.random() > 0.5 else 1
+        avail_w = 0
+        avail_h = self.gh
+
+        x = pck_x_idx
+        while 0 <= x < self.gw:
+            xidx = x + pck_y_idx * self.gw
+            col_avail_h = 0
+            y = pck_y_idx
+            while 0 <= y < self.gh:
+                yidx = x + y * self.gw
+                if self.cells[yidx].filled:
+                    break
+                col_avail_h += 1
+                y += y_dir
+            
+            avail_h = min(avail_h, col_avail_h)
+            if self.cells[xidx].filled:
+                break
+            avail_w += 1
+            x += x_dir 
+
+        # TODO --> need to think about this
+        # if avail_w < self.min_w and avail_h < self.min_w:
+        #     self.cells[pck_idx].filled = True
+        #     if pck_idx in self.pool:
+        #         self.pool.remove(pck_idx)
+        #     return
+        
+        if avail_w > self.min_w:
+            rw = random.randint(self.min_w, avail_w-1)
+        else:
+            rw = max(0, min(self.min_w, avail_w-1))
+
+        if avail_h > self.min_w:
+            rh = random.randint(self.min_w, avail_h-1)
+        else:
+            rh = max(0, min(self.min_w, avail_h-1))
+
+        x_strt =  pck_x_idx if (x_dir == 1) else pck_x_idx-rw
+        x_end = pck_x_idx+rw if (x_dir == 1) else  pck_x_idx
+        y_strt = pck_y_idx if (y_dir == 1) else pck_y_idx-rh
+        y_end = pck_y_idx+rh if (y_dir == 1) else pck_y_idx
+
+        #print(x_strt, x_end, y_strt, y_end, x_dir, y_dir)
+
+        for x in range(x_strt, x_end+1, 1):
+            for y in range(y_strt, y_end+1, 1):
+                idx = x + y * self.gw
+                
+                self.cells[idx].filled = True
+                if idx in self.pool:
+                    self.pool.remove(idx)
+                    
+        self.rects.append({
+            "x": x_strt, 
+            "y": y_strt, 
+            "w": abs(x_end-x_strt)+1, 
+            "h": abs(y_end-y_strt)+1
+        })
+
+        if len(self.pool) == 0:
+            self.depleted = True
+            
+        

chgnhyk-0.0.0/src/chgnhyk/CCDIK.py

@@ -0,0 +1,93 @@
+import math
+
+def clamp(x, min_val, max_val):
+    return max(min(x, max_val), min_val)
+
+def rotate(x,y,a):
+    return (math.cos(a)*x-math.sin(a)*y, math.sin(a)*x+math.cos(a)*y)
+
+def fract(x):
+    return x-math.floor(x)
+
+def smoothstep(mi, mx, v):
+    x = max(0, min(1, (v-mi)/(mx-mi)))
+    return x*x*(3 - 2*x)
+
+def normalize(x, y):
+    vl = math.sqrt(x*x+y*y)
+    if vl < 1e-6:
+        return (0.0, 0.0)
+    else:
+        return (x/vl, y/vl)
+
+def get_dist(x1,y1,x2,y2):
+    dx = x2-x1
+    dy = y2-y1
+    return math.sqrt(dx*dx+dy*dy)
+
+def get_angle(v1:tuple,v2:tuple):
+    dot = v1[0]*v2[0]+v1[1]*v2[1]
+    crss = v1[0]*v2[1]-v1[1]*v2[0]
+    
+    dot = clamp(dot, -1.0, 1.0)
+
+    if abs(dot - 1.0) < 1e-6 and abs(crss) < 1e-6:
+        return 0.0
+    else:
+        angle = math.atan2(crss,dot)
+        return angle
+
+class Arm2D:
+    def __init__(self, num, l, ease = 1.0, angle = 0.0):
+        self.L = l
+        self.angles = []
+        self.positions = []
+        self.sx = 0
+        self.sy = 0
+
+        self.ease = ease
+
+        self.num = num
+        for i in range(self.num):
+            if i == 0:
+                self.angles.append(math.pi * 0.5 + angle)
+            else:
+                self.angles.append(0.0)
+            self.positions.append((0.0,0.0))
+
+
+    def get_arm_pos(self):
+        data = []
+        data = self.positions.copy()
+        self.update_arms()
+        data.append((self.ex,self.ey))
+        # print(len(data))
+        return data
+    
+    def update_arms(self):
+        _sx = self.sx
+        _sy = self.sy
+        _a = 0
+        for i in range(self.num):
+            _a += self.angles[i]            
+            self.positions[i] = (_sx,_sy)
+            _sx = _sx + math.cos(_a) * self.L
+            _sy = _sy + math.sin(_a) * self.L
+
+        self.ex = _sx
+        self.ey = _sy
+    
+    def set_target(self, tx, ty):
+        self.update_arms()
+
+        for i in range(self.num-1,-1,-1):
+            jx = self.positions[i][0]
+            jy = self.positions[i][1]
+
+            jd = normalize(self.ex-jx, self.ey-jy)
+            d = normalize(tx-jx, ty-jy)
+
+            angle = get_angle(jd, d)
+            self.angles[i] += angle * self.ease
+
+            self.update_arms()

chgnhyk-0.0.0/src/chgnhyk/DFT.py

@@ -0,0 +1,116 @@
+import math 
+
+class Cmplx:
+    def __init__(self, a, b):
+        self.re = a
+        self.im = b
+        pass
+
+    def add(self, c):
+        self.re += c.re
+        self.im += c.im
+    
+    def mult(self, c):
+        _re = self.re * c.re - self.im * c.im
+        _im = self.re * c.im + self.im * c.re
+        return Cmplx(_re, _im)
+
+def DFT(x:iter, w, h, compress=0):
+
+    X = []
+    N = len(x)
+    for i in range(N):
+        x[i] = Cmplx(x[i][0]-w*0.5,x[i][1]-h*0.5)
+
+    for k in range(N):
+        _sum = Cmplx(0, 0)
+        for n in range (N):
+            phi = (math.pi * 2 * k * n) / N
+            c = Cmplx(math.cos(phi), -math.sin(phi))
+            _sum.add(x[n].mult(c))
+        _sum.re = _sum.re / N
+        _sum.im = _sum.im / N
+
+        #freq = k
+        freq = k if k <= N//2 else k - N
+        amp = math.sqrt(_sum.re * _sum.re + _sum.im * _sum.im)
+        phase = math.atan2(_sum.im, _sum.re)
+
+        X.append({
+            "re": _sum.re,
+            "im": _sum.im,
+            "freq": freq,
+            "amp": amp,
+            "phase": phase
+        })
+
+    if compress > 0 and compress < len(x):
+        X.sort(key=lambda c: c["amp"], reverse=True)
+        X = X[:compress]
+
+    return X
+
+def MixF(X1, X2, t):
+    X = []
+    for i in range(len(X1)):
+        re1 = X1[i]["re"]
+        im1 = X1[i]["im"]
+
+        re2 = X2[i]["re"]
+        im2 = X2[i]["im"]
+
+        re = (1.0-t)*re1 + t*re2
+        im = (1.0-t)*im1 + t*im2
+        X.append({
+            "re": re,
+            "im": im,
+            "freq": X1[i]["freq"]
+        })
+    return X
+
+def MixSortedF(X1, X2, t):
+    X = []
+
+    # Build lookup tables by frequency
+    A = {c["freq"]: c for c in X1}
+    B = {c["freq"]: c for c in X2}
+
+    # Union of all frequencies
+    freqs = set(A.keys()) | set(B.keys())
+
+    for k in freqs:
+        c1 = A.get(k)
+        c2 = B.get(k)
+
+        # Zero-fill if missing
+        re1 = c1["re"] if c1 else 0.0
+        im1 = c1["im"] if c1 else 0.0
+
+        re2 = c2["re"] if c2 else 0.0
+        im2 = c2["im"] if c2 else 0.0
+
+        # Linear interpolation
+        re = (1.0 - t) * re1 + t * re2
+        im = (1.0 - t) * im1 + t * im2
+
+        X.append({
+            "re": re,
+            "im": im,
+            "freq": k
+        })
+
+    return X
+
+def epiCycle(x, y, timer, rotation, fourier:iter):
+    _x = x
+    _y = y
+    for i in range(len(fourier)):
+        re = fourier[i]["re"]
+        im = fourier[i]["im"]
+        freq = fourier[i]["freq"] #i if i <= len(fourier)//2 else i - len(fourier)
+        radius = math.sqrt(re * re + im * im)
+        phase = math.atan2(im, re)
+        _x += radius * math.cos(freq * timer + phase + rotation)
+        _y += radius * math.sin(freq * timer + phase + rotation)
+
+    return (_x,_y)

chgnhyk-0.0.0/src/chgnhyk/FBOParticlePass.py

@@ -0,0 +1,245 @@
+import numpy as np
+from PIL import Image
+import moderngl
+from pyrr import Matrix44
+import math
+from typing import Union
+from .utils import FakeUniform, EXT_MAP
+from pathlib import Path
+
+def particle(i, num):
+
+    x = np.random.uniform(-0.5, 0.5)
+    y = np.random.uniform(-0.5, 0.5)
+    z = 1 #np.random.uniform(-1.0, 1.0)
+
+    r = np.random.uniform(0.0, 1.0)
+    g = np.random.uniform(0.0, 1.0)
+    b = np.random.uniform(0.0, 1.0)
+    return [x, y, z, r, g, b]
+
+
+
+class ParticlesFBO:
+
+    quad_vertex_shader = '''
+    #version 330
+    in vec2 in_vert;
+    in vec2 in_uv;
+    out vec2 UV;
+    void main() {
+        gl_Position = vec4(in_vert, 0.0, 1.0);
+        UV = in_uv;
+    }
+    '''
+    copier_fragment_shader = '''
+    #version 330
+    out vec4 outputColor;
+    in vec2 UV;
+
+    uniform sampler2D copy_target;
+
+    void main()
+    {
+        vec4 copy = texture(copy_target,UV);
+        outputColor = copy;
+    }
+    '''
+
+    def __init__(self, ctx, size, vertex_shader, fragment_shader, transform_shader, enable_backbuffer = False, rest_time = 0.0, num = 10000, particle_func = None):
+        self.ctx = ctx
+        self.size = size
+        self.enable_backbuffer = enable_backbuffer
+
+        self.texture = self.ctx.texture(self.size, components=4, dtype="f4")
+        self.fbo = self.ctx.framebuffer(self.texture)
+        self.prog = self.ctx.program(
+            vertex_shader=vertex_shader, fragment_shader=fragment_shader)
+
+        vertex_data = np.array([
+            # x,    y,   z,    u,   v
+            -1.0, -1.0, 0.0,  0.0, 0.0,
+            +1.0, -1.0, 0.0,  1.0, 0.0,
+            -1.0, +1.0, 0.0,  0.0, 1.0,
+            +1.0, +1.0, 0.0,  1.0, 1.0,
+        ]).astype(np.float32)
+
+        content = [(
+            self.ctx.buffer(vertex_data),
+            '3f 2f',
+            'in_vert', 'in_uv'
+        )]
+
+        self.transform_prog = self.ctx.program(
+            vertex_shader = transform_shader, 
+            varyings = ['out_pos', 'out_col'])
+
+        self.particle_number = num
+
+        self.particle_func = particle_func
+
+        if callable(self.particle_func):
+            particles = np.array([self.particle_func(i, self.particle_number) for i in range(self.particle_number)], dtype='f4')
+        else:
+            particles = np.array([particle(i, self.particle_number) for i in range(self.particle_number)], dtype='f4')
+
+        self.vbo1 = self.ctx.buffer(particles.tobytes())
+        self.vbo2 = self.ctx.buffer(reserve=self.vbo1.size)
+
+        self.vao1 = self.ctx.vertex_array(self.transform_prog, [(self.vbo1, '3f 3f', 'in_pos', 'in_col')])
+        self.vao2 = self.ctx.vertex_array(self.transform_prog, [(self.vbo2, '3f 3f', 'in_pos', 'in_col')])
+        self.render_vao = self.ctx.vertex_array(self.prog, [(self.vbo1, '3f 3f', 'in_vert', 'in_col')])
+
+        self.aspect_ratio = self.size[0] / self.size[1]
+        self.mvp = self.prog.get('Mvp', FakeUniform())
+        self.campos = self.transform_prog.get('CAMPOS', FakeUniform())
+        self.real_cam = self.prog.get('CAMPOS', FakeUniform())
+        self.time = self.prog.get('time', FakeUniform())
+        self.resolution = self.prog.get('resolution', FakeUniform())
+
+        if self.resolution:
+            self.set_uniform("resolution", self.size)
+        else:
+            print(f'unable to set resolution uniform {self.resolution}')
+
+        if self.enable_backbuffer == True:
+            self.bck_texture = self.ctx.texture(
+                self.size, components=4, dtype="f4")
+            self.bck_fbo = self.ctx.framebuffer(self.bck_texture)
+            self.bck_prog = self.ctx.program(
+                vertex_shader=self.quad_vertex_shader, fragment_shader=self.copier_fragment_shader)
+            self.bck_vao = self.ctx.vertex_array(self.bck_prog, content)
+
+            self.backbuffer_uniform = self.prog.get(
+                'backbuffer', FakeUniform())
+            self.copy_target_uniform = self.bck_prog.get(
+                'copy_target', FakeUniform())
+        else:
+            self.bck_fbo = None
+
+        self.textures = {}
+        self.texture_uniforms = {}
+        self.textures_ = {}
+        self.texture_uniforms_ = {}
+
+
+        self.proj = Matrix44.perspective_projection(45.0, self.aspect_ratio, 0.1, 1000.0)
+        self.lookat = Matrix44.look_at(
+            (0.0, 0.0, 3.0),
+            (0.0, 0.0, 0.0),
+            (0.0, 1.0, 0.0),
+        )
+        self.set_cam((0.0, 0.0, 3.0))
+
+        self.clear_col = (0.0,0.0,0.0)
+
+    def set_clear_col(self, col:tuple = (0.0,0.0,0.0)):
+        self.clear_col = col
+
+    def release_all(self):
+        if hasattr(self, 'bck_texture'):
+            self.bck_texture.release()
+        for (name, texture) in self.textures.items():
+            self.textures[name].release()
+            self.textures_[name].release()
+        self.texture.release()
+
+    def set_uniform(self, name, value):
+        uniform = self.prog.get(name, FakeUniform())
+        uniform.value = value
+
+        uniform = self.transform_prog.get(name, FakeUniform())
+        uniform.value = value
+
+    def set_texture_uniform_from_path(self, path, name, id):
+        im = Image.open(path)
+        im_WIDTH, im_HEIGHT, im_DATA = im.size[0], im.size[1], im.convert(
+            'RGBA').tobytes("raw", "RGBA", 0, -1)
+        texture = self.ctx.texture(
+            (im.size[0], im.size[1]), components=4, data=im_DATA)
+        self.set_texture_uniform(texture, name, id)
+
+    def set_texture_uniform(self, texture, name, id):
+        if name not in self.textures:
+            self.texture_uniforms[name] = self.prog.get(name, FakeUniform())
+            self.textures[name] = texture
+
+            self.texture_uniforms_[name] = self.transform_prog.get(name, FakeUniform())
+            self.textures_[name] = texture
+        self.texture_uniforms[name].value = id
+        self.texture_uniforms_[name].value = id
+
+    def clear(self):
+        self.fbo.clear()
+        if self.bck_fbo:
+            self.bck_fbo.clear()
+
+    def extract_img(self, path: Union[str, Path], format='png', quality=100):
+        path_format = Path(path).suffix.lower().lstrip(".")
+        path_format = EXT_MAP.get(path_format)
+        if format != path_format:
+            format = path_format
+        
+        if format == 'jpeg':
+            image = Image.frombytes('RGB', self.size, self.fbo.read(components=3))
+        else:
+            image = Image.frombytes('RGBA', self.size, self.fbo.read(components=4))
+        image = image.transpose(Image.FLIP_TOP_BOTTOM)
+        image.save(str(path), format=format, quality=quality)
+
+    def extract_np_img(self) -> np.ndarray:
+        img_buf = self.fbo.read()
+        img_width = self.fbo.size[0]
+        img_height = self.fbo.size[1]
+        img = np.frombuffer(img_buf, np.uint8).reshape(img_height, img_width, 3)[::-1]
+        return img
+    
+    # def extract_vao(self, path, format='jpeg'):
+    #     image = Image.frombytes('LA', (self.particle_number, self.particle_number), self.vbo1.read(size=-1,offset=2))
+    #     image = image.transpose(Image.FLIP_TOP_BOTTOM)
+    #     image.save(path, format=format)
+
+    def set_cam(self, _campos, _lookat = (0,0,0), _up = (0,1,0)):
+        self.campos.value =  _campos
+        self.real_cam.value = _campos
+        self.lookat = Matrix44.look_at(
+            _campos,
+            _lookat,
+            _up,
+        )
+        self.mvp.write((self.proj * self.lookat).astype('f4'))
+
+    def render(self):
+        self.fbo.use()
+        
+        self.fbo.clear(*self.clear_col)
+        self.ctx.enable(moderngl.PROGRAM_POINT_SIZE)
+        self.ctx.enable(moderngl.BLEND)
+        #self.ctx.enable(moderngl.DEPTH_TEST)
+        self.ctx.blend_equation = moderngl.FUNC_ADD, moderngl.MAX
+        
+        for (name, texture) in self.textures.items():
+            # print(name, texture, self.texture_uniforms[name].value)
+            textureid = self.texture_uniforms[name].value
+            self.textures[name].use(textureid)
+            self.texture_uniforms[name].value = textureid
+
+            textureid_ = self.texture_uniforms_[name].value
+            self.textures_[name].use(textureid_)
+            self.texture_uniforms_[name].value = textureid_
+
+        if self.enable_backbuffer == True:
+            self.bck_texture.use(1)
+            self.backbuffer_uniform.value = 1
+
+        self.vao1.transform(self.vbo2, moderngl.POINTS, self.particle_number)
+        self.ctx.copy_buffer(self.vbo1, self.vbo2)
+        self.render_vao.render(moderngl.POINTS, self.particle_number)
+        
+        if self.enable_backbuffer == True:
+            self.bck_fbo.use()
+
+            self.texture.use(0)
+            self.copy_target_uniform.value = 0
+
+            self.bck_vao.render(moderngl.TRIANGLE_STRIP)