from krita import Krita

def active_doc_node_roi():
    app = Krita.instance()
    doc = app.activeDocument()
    if not doc:
        return None, None, (0,0,0,0)
    node = doc.activeNode()
    sel = doc.selection()
    if sel:
        x,y,w,h = sel.x(), sel.y(), sel.width(), sel.height()
    else:
        x,y,w,h = 0, 0, doc.width(), doc.height()
    return doc, node, (x,y,w,h)

def clamp(v, lo, hi):
    return lo if v < lo else hi if v > hi else v

def mirror(i, lo, hi):
    # zrcadlení do [lo,hi] včetně krajů
    span = hi - lo
    if span <= 0: return lo
    t = (i - lo) % (2*span)
    if t > span:
        t = 2*span - t
    return lo + t

def convolve_bgra_block(src_bytes, w, h, kernel, ksize=3, border='clamp'):
    """
    src_bytes: bytes/bytearray BGRA (w*h*4)
    vrací nový bytearray BGRA
    """
    assert ksize in (3,5)
    dst = bytearray(len(src_bytes))
    src = memoryview(src_bytes)
    out = memoryview(dst)

    half = ksize // 2
    # předpočítej součet jádra a normalizaci
    ksum = sum(kernel)
    norm = 1.0
    if abs(ksum) > 1e-9:
        norm = 1.0 / ksum  # Normalize sum
    # vyber funkci okraje
    edgef = clamp if border == 'clamp' else mirror

    # hlavní smyčka po řádcích
    for y in range(h):
        for x in range(w):
            accB = accG = accR = 0.0
            for ky in range(ksize):
                sy = y + ky - half
                sy = edgef(sy, 0, h-1)
                for kx in range(ksize):
                    sx = x + kx - half
                    sx = edgef(sx, 0, w-1)
                    k = kernel[ky*ksize + kx]
                    idx = (sy*w + sx) * 4
                    b = src[idx + 0]
                    g = src[idx + 1]
                    r = src[idx + 2]
                    accB += k * b
                    accG += k * g
                    accR += k * r
            # normalizace
            accB *= norm; accG *= norm; accR *= norm
            # clamp to 0..255
            B = 0 if accB < 0 else 255 if accB > 255 else int(accB + 0.5)
            G = 0 if accG < 0 else 255 if accG > 255 else int(accG + 0.5)
            R = 0 if accR < 0 else 255 if accR > 255 else int(accR + 0.5)

            di = (y*w + x)*4
            out[di + 0] = B
            out[di + 1] = G
            out[di + 2] = R
            out[di + 3] = src[di + 3]  # alfa kopie 1:1
    return dst

def apply_kernel_to_active_layer(kernel, ksize=3, border='clamp'):
    doc, node, (x,y,w,h) = active_doc_node_roi()
    if not node or w==0 or h==0: return
    src = bytearray(node.pixelData(x, y, w, h))
    dst = convolve_bgra_block(src, w, h, kernel, ksize, border)
    node.setPixelData(bytes(dst), x, y, w, h)
    doc.refreshProjection()

import math

def gaussian_kernel_1d(sigma, radius=None):
    if sigma <= 0: return [1.0]
    if radius is None:
        radius = int(math.ceil(3.0 * sigma))  # ~99.7 % hmoty
    w = 2*radius + 1
    k = [0.0]*w
    s2 = 2.0 * sigma * sigma
    acc = 0.0
    for i in range(w):
        x = i - radius
        v = math.exp(-(x*x)/s2)
        k[i] = v
        acc += v
    # normalizace na 1.0
    for i in range(w):
        k[i] /= acc
    return k, radius

def convolve_rows_bgr(src_bytes, w, h, kernel, radius, border='clamp'):
    src = memoryview(src_bytes)
    dst = bytearray(len(src_bytes))
    out = memoryview(dst)
    edgef = clamp if border == 'clamp' else mirror

    for y in range(h):
        row_off = y * w * 4
        for x in range(w):
            accB = accG = accR = 0.0
            for k in range(-radius, radius+1):
                sx = edgef(x + k, 0, w-1)
                i = row_off + sx*4
                # BGRA
                b = src[i+0]; g = src[i+1]; r = src[i+2]
                wgt = kernel[k + radius]
                accB += wgt * b
                accG += wgt * g
                accR += wgt * r
            di = row_off + x*4
            out[di+0] = 0 if accB<0 else 255 if accB>255 else int(accB+0.5)
            out[di+1] = 0 if accG<0 else 255 if accG>255 else int(accG+0.5)
            out[di+2] = 0 if accR<0 else 255 if accR>255 else int(accR+0.5)
            out[di+3] = src[di+3]  # alfa
    return dst

def convolve_cols_bgr(src_bytes, w, h, kernel, radius, border='clamp'):
    src = memoryview(src_bytes)
    dst = bytearray(len(src_bytes))
    out = memoryview(dst)
    edgef = clamp if border == 'clamp' else mirror

    for y in range(h):
        for x in range(w):
            accB = accG = accR = 0.0
            for k in range(-radius, radius+1):
                sy = edgef(y + k, 0, h-1)
                i = (sy*w + x)*4
                b = src[i+0]; g = src[i+1]; r = src[i+2]
                wgt = kernel[k + radius]
                accB += wgt * b
                accG += wgt * g
                accR += wgt * r
            di = (y*w + x)*4
            out[di+0] = 0 if accB<0 else 255 if accB>255 else int(accB+0.5)
            out[di+1] = 0 if accG<0 else 255 if accG>255 else int(accG+0.5)
            out[di+2] = 0 if accR<0 else 255 if accR>255 else int(accR+0.5)
            out[di+3] = src[di+3]
    return dst

def gaussian_blur_separable(src_bytes, w, h, sigma, radius=None, border='clamp'):
    kernel, radius = gaussian_kernel_1d(sigma, radius)
    tmp = convolve_rows_bgr(src_bytes, w, h, kernel, radius, border)
    out = convolve_cols_bgr(tmp, w, h, kernel, radius, border)
    return out

def apply_gaussian_to_active_layer(sigma, radius=None, border='clamp'):
    doc, node, (x,y,w,h) = active_doc_node_roi()
    if not node or w==0 or h==0: return
    src = bytearray(node.pixelData(x, y, w, h))
    dst = gaussian_blur_separable(src, w, h, sigma, radius, border)
    node.setPixelData(bytes(dst), x, y, w, h)
    doc.refreshProjection()

SOBEL_X = [-1,0,1, -2,0,2, -1,0,1]
SOBEL_Y = [-1,-2,-1, 0,0,0, 1,2,1]

def rgb_to_luma(r,g,b):
    # Rec.709
    return 0.2126*r + 0.7152*g + 0.0722*b

def sobel_luma_bgra(src_bytes, w, h, border='clamp', want='magnitude'):
    src = memoryview(src_bytes)
    out = bytearray(len(src_bytes))
    dst = memoryview(out)
    edgef = clamp if border == 'clamp' else mirror
    kx = SOBEL_X; ky = SOBEL_Y

    for y in range(h):
        for x in range(w):
            gx = gy = 0.0
            # 3x3 okno
            idxk = 0
            for ky_off in (-1,0,1):
                sy = edgef(y+ky_off, 0, h-1)
                for kx_off in (-1,0,1):
                    sx = edgef(x+kx_off, 0, w-1)
                    i = (sy*w + sx)*4
                    b,g,r = src[i+0], src[i+1], src[i+2]
                    yv = rgb_to_luma(r,g,b)
                    gx += kx[idxk] * yv
                    gy += ky[idxk] * yv
                    idxk += 1
            mag = (gx*gx + gy*gy) ** 0.5
            # normalizace jednoduchým škálováním
            m = int(max(0, min(255, mag)))
            di = (y*w + x)*4
            if want == 'gx':
                v = int(max(0, min(255, gx + 128)))  # posun kvůli vizualizaci
                dst[di+0]=dst[di+1]=dst[di+2]=v
            elif want == 'gy':
                v = int(max(0, min(255, gy + 128)))
                dst[di+0]=dst[di+1]=dst[di+2]=v
            elif want == 'orientation':
                # orientace v rozsahu 0..180° → mapujte do 0..255
                import math
                ang = math.degrees(math.atan2(gy, gx))  # -180..180
                ang = abs(ang)                           # 0..180
                v = int(ang * (255.0/180.0))
                dst[di+0]=dst[di+1]=dst[di+2]=v
            else:  # magnitude (default)
                dst[di+0]=dst[di+1]=dst[di+2]=m
            dst[di+3] = src[di+3]  # alfa
    return out

def apply_sobel_to_active_layer(mode='magnitude', border='clamp'):
    doc, node, (x,y,w,h) = active_doc_node_roi()
    if not node or w==0 or h==0: return
    src = bytearray(node.pixelData(x, y, w, h))
    dst = sobel_luma_bgra(src, w, h, border, want=mode)
    node.setPixelData(bytes(dst), x, y, w, h)
    doc.refreshProjection()

def try_import_numpy():
    try:
        import numpy as np
        return np
    except Exception:
        return None

NP = try_import_numpy()
HAS_NUMPY = NP is not None

from krita import Krita

def get_doc_node_roi():
    app = Krita.instance()
    doc = app.activeDocument()
    if not doc:
        return None, None, (0,0,0,0)
    node = doc.activeNode()
    sel = doc.selection()
    if sel:
        x,y,w,h = sel.x(), sel.y(), sel.width(), sel.height()
    else:
        x,y,w,h = 0,0,doc.width(), doc.height()
    return doc, node, (x,y,w,h)

def bgra_to_luma_bytes(bgra, w, h):
    # Rec.709 luma
    out = bytearray(w*h)
    mv = memoryview(bgra)
    for i in range(0, len(mv), 4):
        b = mv[i+0]; g = mv[i+1]; r = mv[i+2]
        y = 0.2126*r + 0.7152*g + 0.0722*b
        out[i//4] = 0 if y<0 else 255 if y>255 else int(y+0.5)
    return out

def fft_preview_numpy(gray_u8, w, h, window='none'):
    import numpy as np
    g = np.frombuffer(gray_u8, dtype=np.uint8).astype(np.float32).reshape(h, w)
    # okno (proti ringing)
    if window.lower().startswith('hann'):
        wy = np.hanning(h); wx = np.hanning(w)
        g = g * wy[:,None] * wx[None,:]
    # FFT
    F = np.fft.fft2(g)
    Fshift = np.fft.fftshift(F)
    mag = np.log1p(np.abs(Fshift))
    mag /= mag.max() if mag.max() > 1e-9 else 1.0
    return (mag * 255.0).astype(np.uint8)

def make_circular_mask(h, w, mode, r_in_px=0, r_out_px=10):
    import numpy as np
    cy, cx = h//2, w//2
    Y, X = np.ogrid[:h, :w]
    R = np.sqrt((Y-cy)**2 + (X-cx)**2)
    M = np.zeros((h,w), dtype=np.float32)
    if mode == 'lowpass':
        M[R <= r_out_px] = 1.0
    elif mode == 'highpass':
        M[R >= r_out_px] = 1.0
    else: # bandpass
        M[(R >= r_in_px) & (R <= r_out_px)] = 1.0
    return M

def apply_fft_filter_numpy(gray_u8, w, h, mode, r1, r2, window='none'):
    import numpy as np
    g = np.frombuffer(gray_u8, dtype=np.uint8).astype(np.float32).reshape(h, w)
    if window.lower().startswith('hann'):
        wy = np.hanning(h); wx = np.hanning(w)
        g = g * wy[:,None] * wx[None,:]
    F  = np.fft.fft2(g)
    Fs = np.fft.fftshift(F)
    if mode == 'bandpass':
        M = make_circular_mask(h, w, 'bandpass', r_in_px=r1, r_out_px=r2)
    elif mode == 'lowpass':
        M = make_circular_mask(h, w, 'lowpass', r_out_px=r2)
    else:
        M = make_circular_mask(h, w, 'highpass', r_out_px=r2)
    Fs_filtered = Fs * M
    Fi = np.fft.ifftshift(Fs_filtered)
    out = np.fft.ifft2(Fi).real
    # normalizace do 0..255
    mn, mx = float(out.min()), float(out.max())
    if mx - mn < 1e-9:
        out[:] = 0
    else:
        out = (out - mn) * (255.0/(mx-mn))
    return out.astype(np.uint8)

def merge_luma_into_bgra(bgra, luma_u8, w, h):
    # nahradí luminanci; jednoduchá varianta: přemapuje RGB do stejné Y
    mv = memoryview(bgra)
    out = bytearray(len(mv))
    for i in range(0, len(mv), 4):
        Y = luma_u8[i//4]
        # ponecháme barvu přibližně via scale ke stejné světlosti:
        # jednoduché: všem RGB dáme Y (grayscale look)
        out[i+0] = Y
        out[i+1] = Y
        out[i+2] = Y
        out[i+3] = mv[i+3]  # alfa
    return out

def tiny_dft_2d(gray_u8, n):
    # gray_u8: n*n uint8
    # návrat: komplexní 2D pole (separovaně re/im v Pythonu)
    import math
    g = [float(gray_u8[i]) for i in range(n*n)]
    F_re = [0.0]*(n*n); F_im = [0.0]*(n*n)
    two_pi = 2.0*math.pi
    for v in range(n):
        for u in range(n):
            sum_re = 0.0; sum_im = 0.0
            for y in range(n):
                for x in range(n):
                    idx = y*n + x
                    ang = two_pi*((u*x + v*y)/n)
                    val = g[idx]
                    sum_re += val*math.cos(-ang)
                    sum_im += val*math.sin(-ang)
            F_re[v*n + u] = sum_re
            F_im[v*n + u] = sum_im
    return F_re, F_im

def dft_log_magnitude(F_re, F_im, n):
    import math
    mag = [0.0]*(n*n)
    for i in range(n*n):
        mag[i] = math.log1p((F_re[i]**2 + F_im[i]**2)**0.5)
    mx = max(mag) if mag else 1.0
    out = bytearray(n*n)
    for i,m in enumerate(mag):
        out[i] = int(255.0*(m/mx)) if mx>1e-9 else 0
    return out

def get_doc_node_roi(app):
    doc = app.activeDocument()
    if not doc: return None, None, (0,0,0,0)
    node = doc.activeNode()
    sel  = doc.selection()
    if sel:
        x,y,w,h = sel.x(), sel.y(), sel.width(), sel.height()
    else:
        x,y,w,h = 0, 0, doc.width(), doc.height()
    return doc, node, (x,y,w,h)

def gray_pixel(r,g,b, mode="709"):
    if mode == "avg":
        return (r+g+b)//3
    if mode == "desat":
        return (max(r,g,b) + min(r,g,b))//2
    if mode == "601":
        return int(0.299*r + 0.587*g + 0.114*b + 0.5)
    # default 709
    return int(0.2126*r + 0.7152*g + 0.0722*b + 0.5)

def apply_grayscale_bgra_block(bytes_in, w, h, mode="709", strength=1.0):
    data = bytearray(bytes_in)
    mv = memoryview(data)
    for i in range(0, len(mv), 4):
        b,g,r,a = mv[i+0], mv[i+1], mv[i+2], mv[i+3]
        y = gray_pixel(r,g,b, mode)
        if strength >= 0.999:
            mv[i+0] = mv[i+1] = mv[i+2] = y
        else:
            mv[i+0] = int((1-strength)*b + strength*y + 0.5)
            mv[i+1] = int((1-strength)*g + strength*y + 0.5)
            mv[i+2] = int((1-strength)*r + strength*y + 0.5)
        mv[i+3] = a
    return data

SEPIA = (
    (0.393, 0.769, 0.189),
    (0.349, 0.686, 0.168),
    (0.272, 0.534, 0.131),
)

def mat3_apply(r,g,b, M):
    r2 = M[0][0]*r + M[0][1]*g + M[0][2]*b
    g2 = M[1][0]*r + M[1][1]*g + M[1][2]*b
    b2 = M[2][0]*r + M[2][1]*g + M[2][2]*b
    return int(min(255,max(0,r2))+0.5), int(min(255,max(0,g2))+0.5), int(min(255,max(0,b2))+0.5)

def apply_sepia_bgra_block(bytes_in, w, h, strength=1.0, M=SEPIA):
    data = bytearray(bytes_in); mv = memoryview(data)
    s = max(0.0, min(1.0, strength))
    for i in range(0, len(mv), 4):
        b,g,r,a = mv[i], mv[i+1], mv[i+2], mv[i+3]
        r2,g2,b2 = mat3_apply(r,g,b, M)
        if s >= 0.999:
            mv[i], mv[i+1], mv[i+2] = b2, g2, r2
        else:
            mv[i]   = int((1-s)*b + s*b2 + 0.5)
            mv[i+1] = int((1-s)*g + s*g2 + 0.5)
            mv[i+2] = int((1-s)*r + s*r2 + 0.5)
        mv[i+3] = a
    return data

def build_curve_lut(p0=(0,0), p1=(128,128), p2=(255,255)):
    # body jsou v rozsahu 0..255
    x0,y0 = p0; x1,y1 = p1; x2,y2 = p2
    lut = [0]*256
    for x in range(0, x1+1):
        t = (x - x0) / max(1, (x1 - x0))
        y = int((1-t)*y0 + t*y1 + 0.5)
        lut[x] = max(0, min(255, y))
    for x in range(x1+1, 256):
        t = (x - x1) / max(1, (x2 - x1))
        y = int((1-t)*y1 + t*y2 + 0.5)
        lut[x] = max(0, min(255, y))
    return lut

def apply_lut_bgra_block(bytes_in, w, h, lutR, lutG, lutB):
    data = bytearray(bytes_in); mv = memoryview(data)
    for i in range(0, len(mv), 4):
        b,g,r,a = mv[i], mv[i+1], mv[i+2], mv[i+3]
        mv[i]   = lutB[b]
        mv[i+1] = lutG[g]
        mv[i+2] = lutR[r]
        mv[i+3] = a
    return data

def rgb_to_hsv_i(r,g,b):
    mx = max(r,g,b); mn = min(r,g,b); diff = mx - mn
    v = mx
    s = 0 if mx == 0 else int(255 * diff / mx)
    if diff == 0: h = 0
    else:
        if mx == r: h = (60 * (g - b) // diff) % 360
        elif mx == g: h = (60 * (b - r) // diff) + 120
        else: h = (60 * (r - g) // diff) + 240
    return h, s, v

def hsv_to_rgb_i(h,s,v):
    if s == 0:
        return v, v, v
    s = s/255.0; v = v/255.0
    hi = int(h/60) % 6; f = (h/60) - int(h/60)
    p = v*(1-s); q = v*(1-s*f); t = v*(1-(1-f)*s)
    if hi==0: r,g,b = v,t,p
    elif hi==1: r,g,b = q,v,p
    elif hi==2: r,g,b = p,v,t
    elif hi==3: r,g,b = p,q,v
    elif hi==4: r,g,b = t,p,v
    else: r,g,b = v,p,q
    return int(r*255+0.5), int(g*255+0.5), int(b*255+0.5)

def apply_hsv_bgra_block(bytes_in, w, h, hue_shift_deg=0, sat_pct=100, val_pct=100):
    data = bytearray(bytes_in); mv = memoryview(data)
    for i in range(0, len(mv), 4):
        b,g,r,a = mv[i], mv[i+1], mv[i+2], mv[i+3]
        h,s,v = rgb_to_hsv_i(r,g,b)
        h = (h + hue_shift_deg) % 360
        s = int(s * (sat_pct/100.0)); s = 0 if s<0 else 255 if s>255 else s
        v = int(v * (val_pct/100.0)); v = 0 if v<0 else 255 if v>255 else v
        r2,g2,b2 = hsv_to_rgb_i(h,s,v)
        mv[i], mv[i+1], mv[i+2], mv[i+3] = b2, g2, r2, a
    return data

def lerp(a,b,t): return int(a + (b-a)*t + 0.5)

def gradient_color(stops, t):
    # stops: list[(t, (r,g,b))], t v asc. pořadí
    if t <= stops[0][0]: return stops[0][1]
    if t >= stops[-1][0]: return stops[-1][1]
    for i in range(len(stops)-1):
        t0,c0 = stops[i]; t1,c1 = stops[i+1]
        if t0 <= t <= t1:
            u = (t - t0) / max(1e-9, (t1 - t0))
            r = lerp(c0[0], c1[0], u)
            g = lerp(c0[1], c1[1], u)
            b = lerp(c0[2], c1[2], u)
            return (r,g,b)
    return stops[-1][1]

def apply_gradient_map_bgra_block(bytes_in, w, h, stops, gray_mode="709"):
    data = bytearray(bytes_in); mv = memoryview(data)
    for i in range(0, len(mv), 4):
        b,g,r,a = mv[i], mv[i+1], mv[i+2], mv[i+3]
        y = gray_pixel(r,g,b, gray_mode) / 255.0
        r2,g2,b2 = gradient_color(stops, y)
        mv[i], mv[i+1], mv[i+2], mv[i+3] = b2, g2, r2, a
    return data

from krita import Krita
from PyQt5.QtGui import QImage
from PyQt5.QtCore import QRect

def node_projection_qimage(doc, node):
    # Získejte bounds vrstvy v dokumentu (globální souřadnice):
    b = node.bounds()
    x, y, w, h = b.x(), b.y(), b.width(), b.height()
    if w <= 0 or h <= 0:
        return None, QRect()
    # Získejte BGRA byty dané vrstvy (projekce včetně efektů):
    data = node.projectionPixelData(x, y, w, h)
    img = QImage(data, w, h, QImage.Format_ARGB32)  # BGRA↔ARGB32 byte-order
    return img.copy(), QRect(x, y, w, h)

def alpha_trim_bbox(qimg: QImage, threshold=1):
    # Najde minimální obdélník s alfou > threshold
    w, h = qimg.width(), qimg.height()
    if w==0 or h==0: return QRect(0,0,0,0)
    ptr = qimg.bits(); ptr.setsize(h*qimg.bytesPerLine())
    import numpy as np
    a = np.frombuffer(ptr, dtype=np.uint8).reshape(h, qimg.bytesPerLine())[:, 3::4]  # alfa kanál
    ys, xs = np.where(a > threshold)
    if xs.size == 0 or ys.size == 0:
        return QRect(0,0,0,0)
    x0, x1 = int(xs.min()), int(xs.max())
    y0, y1 = int(ys.min()), int(ys.max())
    return QRect(x0, y0, x1 - x0 + 1, y1 - y0 + 1)

from PyQt5.QtGui import QImage, QPainter
from PyQt5.QtCore import Qt

def pad_qimage(qimg: QImage, pad: int, color=(0,0,0,0)):
    if pad <= 0: return qimg
    w, h = qimg.width()+2*pad, qimg.height()+2*pad
    out = QImage(w, h, QImage.Format_ARGB32)
    out.fill(Qt.transparent)
    p = QPainter(out)
    p.drawImage(pad, pad, qimg)
    p.end()
    return out

def scale_qimage(qimg: QImage, scale: float):
    if abs(scale - 1.0) < 1e-6: return qimg
    w = max(1, int(round(qimg.width()*scale)))
    h = max(1, int(round(qimg.height()*scale)))
    # u ikon/UI preferujeme nejbližšího souseda:
    return qimg.scaled(w, h, Qt.IgnoreAspectRatio, Qt.FastTransformation)

{
  "image": "atlas.png",
  "tileWidth":  64,
  "tileHeight": 64,
  "padding": 2,
  "frames": [
    {"name":"walk_000","x":0,"y":0,"w":64,"h":64,"anchor":[32,48]},
    {"name":"walk_001","x":66,"y":0,"w":64,"h":64,"anchor":[32,48]}
  ]
}