eari-package 0.1.0__tar.gz

eari_package-0.1.0/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: eari_package
+Version: 0.1.0
+Summary: EARI image demosaicking implementation
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: opencv-python>=4.13.0.92
+Requires-Dist: scipy>=1.17.1

eari_package-0.1.0/eari_package/__init__.py

@@ -0,0 +1,2 @@
+from .eari import CEARI, MEARI
+from .ri import ri, make_cfa

eari_package-0.1.0/eari_package/eari.py

@@ -0,0 +1,141 @@
+import numpy as np
+import cv2
+from fast_ri import guidedfilter, bilinear_RB, ri,standardize_input
+def MEARI(MPFA):
+    eps=1e-32
+    Fn=np.array([[1,2,1],[1,2,1],[0,0,0]], dtype=np.float32)/8
+    Fs=np.array([[0,0,0],[1,2,1],[1,2,1]], dtype=np.float32)/8
+    Fw=Fn.T
+    Fe=Fs.T
+
+    Hn=np.array([[-1,2,-1],[1,-2,1],[0,0,0]], dtype=np.float32)/2
+    Hs=np.array([[0,0,0],[1,-2,1],[-1,2,-1]], dtype=np.float32)/2
+    Hw=Hn.T
+    He=Hs.T
+
+    Mn=np.ones((5,5), dtype=np.float32)/15
+    Mn[3:,:]=0
+    Ms=Mn[::-1,:]
+    Mw=Mn.T
+    Me=Ms.T
+
+    MPFA32 = standardize_input(MPFA)
+
+    Xn = cv2.filter2D(MPFA32, -1, Fn, borderType=cv2.BORDER_REFLECT_101)
+    Xs = cv2.filter2D(MPFA32, -1, Fs, borderType=cv2.BORDER_REFLECT_101)
+    Xe = cv2.filter2D(MPFA32, -1, Fe, borderType=cv2.BORDER_REFLECT_101)
+    Xw = cv2.filter2D(MPFA32, -1, Fw, borderType=cv2.BORDER_REFLECT_101)
+
+    Dn = cv2.filter2D(MPFA32, -1, Hn, borderType=cv2.BORDER_REFLECT_101)
+    Ds = cv2.filter2D(MPFA32, -1, Hs, borderType=cv2.BORDER_REFLECT_101)
+    De = cv2.filter2D(MPFA32, -1, He, borderType=cv2.BORDER_REFLECT_101)
+    Dw = cv2.filter2D(MPFA32, -1, Hw, borderType=cv2.BORDER_REFLECT_101)
+
+    sDn = cv2.filter2D(np.abs(Dn), -1, Mn, borderType=cv2.BORDER_REFLECT_101)
+    sDs = cv2.filter2D(np.abs(Ds), -1, Ms, borderType=cv2.BORDER_REFLECT_101)
+    sDe = cv2.filter2D(np.abs(De), -1, Me, borderType=cv2.BORDER_REFLECT_101)
+    sDw = cv2.filter2D(np.abs(Dw), -1, Mw, borderType=cv2.BORDER_REFLECT_101)
+
+    Wn = 1 / (sDn + eps)
+    Ws = 1 / (sDs + eps)
+    We = 1 / (sDe + eps)
+    Ww = 1 / (sDw + eps)
+
+    W = Wn + Ws + We + Ww
+
+    G = (Wn*Xn + Ws*Xs + We*Xe + Ww*Xw) / W
+
+    M = np.zeros_like(MPFA)
+    M90 = np.copy(M)
+    M00 = np.copy(M)
+    M45 = np.copy(M)
+    M135 = np.copy(M)
+
+    M90[0::2,0::2] = 1
+    M00[1::2,1::2] = 1
+    M45[0::2,1::2] = 1
+    M135[1::2,0::2] = 1
+    
+    I90_sparse = np.copy(M)
+    I00_sparse = np.copy(M)
+    I45_sparse = np.copy(M)
+    I135_sparse = np.copy(M)
+    
+    I90_sparse[0::2,0::2] = MPFA[0::2,0::2]
+    I00_sparse[1::2,1::2] = MPFA[1::2,1::2]
+    I45_sparse[0::2,1::2] = MPFA[0::2,1::2]
+    I135_sparse[1::2,0::2] = MPFA[1::2,0::2]
+    
+    I90_t = guidedfilter(G, I90_sparse, M90, 5, 5)
+    I00_t = guidedfilter(G, I00_sparse, M00, 5, 5)
+    I45_t = guidedfilter(G, I45_sparse, M45, 5, 5)
+    I135_t = guidedfilter(G, I135_sparse, M135, 5, 5)
+
+    I90_res = M90 * (MPFA - I90_t)
+    I00_res = M00 * (MPFA - I00_t)
+    I45_res = M45 * (MPFA - I45_t)
+    I135_res = M135 * (MPFA - I135_t)
+
+    I90 = bilinear_RB(I90_res) + I90_t
+    I00 = bilinear_RB(I00_res) + I00_t
+    I45 = bilinear_RB(I45_res) + I45_t
+    I135 = bilinear_RB(I135_res) + I135_t
+
+    return I90, I00, I45, I135
+
+def make_mpfa(rgb90,rgb00,rgb45,rgb135):
+    R90,G90,B90=rgb90[:,:,0],rgb90[:,:,1],rgb90[:,:,2]
+    R00,G00,B00=rgb00[:,:,0],rgb00[:,:,1],rgb00[:,:,2]
+    R45,G45,B45=rgb45[:,:,0],rgb45[:,:,1],rgb45[:,:,2]
+    R135,G135,B135=rgb135[:,:,0],rgb135[:,:,1],rgb135[:,:,2]
+    x,y=rgb90.shape[:2]
+    
+    RMPFA=np.empty((2*x,2*y), dtype=np.float32)
+    GMPFA=np.empty((2*x,2*y), dtype=np.float32)
+    BMPFA=np.empty((2*x,2*y), dtype=np.float32)
+    
+    RMPFA[::2,::2]=R90
+    RMPFA[1::2,1::2]=R00
+    RMPFA[0::2,1::2]=R45
+    RMPFA[1::2,0::2]=R135
+    
+    GMPFA[::2,::2]=G90
+    GMPFA[1::2,1::2]=G00
+    GMPFA[0::2,1::2]=G45
+    GMPFA[1::2,0::2]=G135
+    
+    BMPFA[::2,::2]=B90
+    BMPFA[1::2,1::2]=B00
+    BMPFA[0::2,1::2]=B45
+    BMPFA[1::2,0::2]=B135
+    
+    return RMPFA,GMPFA,BMPFA
+    
+def CEARI(CPFA,pattern):
+    CPFA_standard = standardize_input(CPFA)
+    cfa90=CPFA_standard[0::2,0::2]
+    cfa00=CPFA_standard[1::2,1::2]
+    cfa45=CPFA_standard[0::2,1::2]
+    cfa135=CPFA_standard[1::2,0::2]
+    #if speed is importnat you can use a faster color demosaicking algo
+    rgb90=ri(cfa90,pattern)
+    rgb00=ri(cfa00,pattern)
+    rgb45=ri(cfa45,pattern)
+    rgb135=ri(cfa135,pattern)
+    
+    RMPFA,GMPFA,BMPFA=make_mpfa(rgb90,rgb00,rgb45,rgb135)
+    
+    R90,R00,R45,R135=MEARI(RMPFA)
+    G90,G00,G45,G135=MEARI(GMPFA)
+    B90,B00,B45,B135=MEARI(BMPFA)
+    
+    RGB90=np.stack((R90,G90,B90),axis=-1)
+    RGB00=np.stack((R00,G00,B00),axis=-1)
+    RGB45=np.stack((R45,G45,B45),axis=-1)
+    RGB135=np.stack((R135,G135,B135),axis=-1)
+        
+    RGB90=np.clip(RGB90,0,1)
+    RGB00=np.clip(RGB00,0,1)
+    RGB45=np.clip(RGB45,0,1)
+    RGB135=np.clip(RGB135,0,1)
+    return RGB90,RGB00,RGB45,RGB135

eari_package-0.1.0/eari_package/ri.py

@@ -0,0 +1,231 @@
+import numpy as np
+from scipy import ndimage as nd
+import cv2
+
+offsets = {
+        'RGGB': {'R': (0,0), 'Gr': (0,1), 'Gb': (1,0), 'B': (1,1)},
+        'BGGR': {'R': (1,1), 'Gr': (1,0), 'Gb': (0,1), 'B': (0,0)},
+        'GRBG': {'R': (0,1), 'Gr': (0,0), 'Gb': (1,1), 'B': (1,0)},
+        'GBRG': {'R': (1,0), 'Gr': (1,1), 'Gb': (0,0), 'B': (0,1)},
+    }
+def standardize_input(img):
+    if img.dtype == np.uint8:
+        return img.astype(np.float32) / 255.0
+    elif img.dtype == np.float32:
+        return img
+    else:
+        return img.astype(np.float32)
+        
+def getRGB_known(cfa,pattern):
+    R=np.zeros(cfa.shape, dtype=np.float32)
+    G=np.copy(R)
+    B=np.copy(R)
+    channels={'R':R,'G':G,'B':B}
+    for ch, (r0, c0) in offsets[pattern].items():
+        channels[ch[0]][r0::2,c0::2]=cfa[r0::2,c0::2]
+    return R,G,B
+
+def make_cfa(img_path, pattern):
+    channel={'B':0,'Gr':1,'Gb':1,'R':2}
+    bgr_img=cv2.imread(img_path).astype(np.float32)/255.0
+    cfa=np.zeros(bgr_img.shape[:2], dtype=np.float32) 
+    for ch, (r0, c0) in offsets[pattern].items():
+        cfa[r0::2,c0::2]=bgr_img[r0::2,c0::2,channel[ch]]
+    return cfa
+
+def bilinear_1D(C_known_h,C_known_v,channel,pattern):
+    C_h=np.zeros_like(C_known_h)
+    C_v=np.zeros_like(C_known_v)
+    r,c=offsets[pattern][channel]
+    
+    kernel_h = np.array([[0.5,1.0,0.5]], dtype=np.float32)
+    kernel_v=kernel_h.T
+
+    C_h[r::2,:]=cv2.filter2D(C_known_h[r::2,:].astype(np.float32), -1, kernel_h, borderType=cv2.BORDER_REFLECT_101)
+    C_v[:,c::2]=cv2.filter2D(C_known_v[:,c::2].astype(np.float32), -1, kernel_v, borderType=cv2.BORDER_REFLECT_101)
+
+    return C_h,C_v
+
+def get_residuals(C_known,C_tent,channel,pattern):
+    r,c=offsets[pattern][channel]
+    C_res=np.zeros(C_known.shape, dtype=np.float32)
+    C_res[r::2,c::2]=C_known[r::2,c::2]-C_tent[r::2,c::2]
+    return C_res
+
+def overlap(C,channel,pattern):
+    r,c=offsets[pattern][channel]
+    C_overlap=np.zeros(C.shape, dtype=np.float32)
+    C_overlap[r::2,c::2]=C[r::2,c::2]
+    return C_overlap
+    
+def half_gaussian_kernel(size, sigma):
+    x = np.arange(size) 
+    kernel = np.exp(-x**2 / (2 * sigma**2))
+    return kernel / kernel.sum()
+    
+def get_delta(delta_h,delta_v,channel,pattern,N=5,sigma=1e+8):
+    delta_h_pad=np.pad(delta_h,((0,0),(1,1)),mode='symmetric')
+    delta_v_pad=np.pad(delta_v,((1,1),(0,0)),mode='symmetric')
+    
+    Dh=np.abs(delta_h_pad[:,:-2]-delta_h_pad[:,2:])
+    Dv=np.abs(delta_v_pad[:-2,:]-delta_v_pad[2:,:])
+    eps=1e-5
+
+    wn = 1/(nd.uniform_filter(Dv, size=N, mode='mirror', origin=(2, 0))+eps)**2
+    ws = 1/(nd.uniform_filter(Dv, size=N, mode='mirror', origin=(-2, 0))+eps)**2
+    ww = 1/(nd.uniform_filter(Dh, size=N, mode='mirror', origin=(0, 2))+eps)**2
+    we = 1/(nd.uniform_filter(Dh, size=N, mode='mirror', origin=(0, -2))+eps)**2
+    
+    wt=wn+ws+we+ww
+    f=half_gaussian_kernel(N, sigma)
+    
+    delta_s=ws*nd.correlate1d(delta_v,f,origin=-2,axis=0,mode='mirror')
+    delta_e=we*nd.correlate1d(delta_h,f,origin=-2,axis=1,mode='mirror')
+    delta_w=ww*nd.correlate1d(delta_h,f[::-1],origin=2,axis=1,mode='mirror')
+    delta_n=wn*nd.correlate1d(delta_v,f[::-1],origin=2,axis=0,mode='mirror')
+    
+    delta=np.zeros(delta_h.shape, dtype=np.float32)
+    r,c=offsets[pattern][channel]
+    delta[r::2,c::2]=((delta_n+delta_s+delta_e+delta_w)/wt)[r::2,c::2]
+
+    return delta
+    
+def guidedfilter(I,p,M,h,v,eps=0):
+    size_v=2*v+1 if v!=0 else 1
+    size_h=2*h+1 if h!=0 else 1
+    
+    I32 = I.astype(np.float32, copy=False)
+    p32 = p.astype(np.float32, copy=False)
+    M32 = M.astype(np.float32, copy=False)
+
+    def boxfilter(img):
+        return cv2.boxFilter(img, cv2.CV_32F, (size_h, size_v), normalize=False, borderType=cv2.BORDER_REFLECT_101)
+
+    N = boxfilter(M32)
+    N[N==0]=1
+    N2 = boxfilter(np.ones_like(I32))
+    
+    mean_I = boxfilter(I32*M32)/N
+    mean_p = boxfilter(p32)/N      
+    mean_Ip = boxfilter(I32*p32)/N  
+    
+    cov_Ip = mean_Ip - mean_I*mean_p
+    
+    mean_II = boxfilter(I32*I32*M32)/N
+    var_I = mean_II - mean_I*mean_I
+    
+    th=1e-5 
+    var_I = np.maximum(var_I, th)
+    
+    a = cov_Ip/(var_I+eps)
+    b = mean_p - a*mean_I
+    
+    mean_a = boxfilter(a)/N2
+    mean_b = boxfilter(b)/N2
+    
+    q = mean_a*I32 + mean_b
+    return q
+
+def guided_1D(G_d,C_known,d,channel,pattern,ep=0):
+    r,c=offsets[pattern][channel]
+    M=np.zeros_like(C_known)
+    M[r::2,c::2]=1.0
+    p=C_known*M
+    
+    h=5 if d==1 else 0
+    v=5 if d==0 else 0
+    
+    C_tent=guidedfilter(G_d,p,M,h,v,ep)
+    
+    C_d=np.zeros_like(G_d)
+    if d==0:
+        C_d[:,c::2]=C_tent[:,c::2]
+    elif d==1:
+        C_d[r::2,:]=C_tent[r::2,:]
+        
+    return C_d
+
+def guided_upsampling(C,G,channel,pattern,ep=0):
+    r,c=offsets[pattern][channel]
+    M=np.zeros_like(C)
+    M[r::2,c::2]=1.0
+    p=C*M
+    return guidedfilter(G,p,M,5,5,ep)
+
+def bilinear_RB(C):
+    kernel=np.array([[.25,.5,.25],
+                    [.5,1,.5],
+                    [.25,.5,.25]], dtype=np.float32)
+    return cv2.filter2D(C.astype(np.float32), -1, kernel, borderType=cv2.BORDER_REFLECT_101)    
+    
+def ri(cfa,pattern):
+    cfa_standard = standardize_input(cfa)
+    R,G,B=getRGB_known(cfa_standard, pattern)
+    
+    Grh_lin,Grv_lin=bilinear_1D(G,G,'R',pattern) 
+    Rgh_lin,Rgv_lin=bilinear_1D(R,R,'R',pattern)
+    Gbh_lin,Gbv_lin=bilinear_1D(G,G,'B',pattern) 
+    Bgh_lin,Bgv_lin=bilinear_1D(B,B,'B',pattern)
+
+    Rh_tent=guided_1D(Grh_lin,R,1,'R',pattern)
+    Rv_tent=guided_1D(Grv_lin,R,0,'R',pattern)
+    Grh_tent=guided_1D(Rgh_lin,G,1,'Gr',pattern)
+    Grv_tent=guided_1D(Rgv_lin,G,0,'Gb',pattern)
+    Bh_tent=guided_1D(Gbh_lin,B,1,'B',pattern)
+    Bv_tent=guided_1D(Gbv_lin,B,0,'B',pattern)
+    Gbh_tent=guided_1D(Bgh_lin,G,1,'Gb',pattern)
+    Gbv_tent=guided_1D(Bgv_lin,G,0,'Gr',pattern)
+
+    Rh_res=get_residuals(R,Rh_tent,'R',pattern)
+    Rv_res=get_residuals(R,Rv_tent,'R',pattern)
+    Grh_res=get_residuals(G,Grh_tent,'Gr',pattern)
+    Grv_res=get_residuals(G,Grv_tent,'Gb',pattern)
+    Bh_res=get_residuals(B,Bh_tent,'B',pattern)
+    Bv_res=get_residuals(B,Bv_tent,'B',pattern)
+    Gbh_res=get_residuals(G,Gbh_tent,'Gb',pattern)
+    Gbv_res=get_residuals(G,Gbv_tent,'Gr',pattern)
+
+    Rh_resin,Rv_resin=bilinear_1D(Rh_res,Rv_res,'R',pattern)
+    Grh_resin,Grv_resin=bilinear_1D(Grh_res,Grv_res,'R',pattern)
+    Bh_resin,Bv_resin=bilinear_1D(Bh_res,Bv_res,'B',pattern)
+    Gbh_resin,Gbv_resin=bilinear_1D(Gbh_res,Gbv_res,'B',pattern)
+
+    Rh=Rh_resin+Rh_tent
+    Rv=Rv_resin+Rv_tent
+    Grh=Grh_resin+Grh_tent
+    Grv=Grv_resin+Grv_tent
+    Bh=Bh_resin+Bh_tent
+    Bv=Bv_resin+Bv_tent
+    Gbh=Gbh_resin+Gbh_tent
+    Gbv=Gbv_resin+Gbv_tent
+
+    delta_gr_h=overlap(Grh,'R',pattern)-R+overlap(G,'Gr',pattern)-overlap(Rh,'Gr',pattern)
+    delta_gr_v=overlap(Grv,'R',pattern)-R+overlap(G,'Gb',pattern)-overlap(Rv,'Gb',pattern)
+    delta_gb_h=overlap(Gbh,'B',pattern)-B+overlap(G,'Gb',pattern)-overlap(Bh,'Gb',pattern)
+    delta_gb_v=overlap(Gbv,'B',pattern)-B+overlap(G,'Gr',pattern)-overlap(Bv,'Gr',pattern)
+
+    delta_gr=get_delta(delta_gr_h,delta_gr_v,'R',pattern)
+    delta_gb=get_delta(delta_gb_h,delta_gb_v,'B',pattern)
+
+    G_demosaicked=(R+delta_gr)+(B+delta_gb)+G
+    G_demosaicked = np.clip(G_demosaicked, 0, 1)
+
+    R_tent=guided_upsampling(R,G_demosaicked,'R',pattern)
+    B_tent=guided_upsampling(B,G_demosaicked,'B',pattern)
+
+    R_res=R-overlap(R_tent,'R',pattern)
+    B_res=B-overlap(B_tent,'B',pattern)
+
+    R_resin=bilinear_RB(R_res)
+    B_resin=bilinear_RB(B_res)
+
+    R_demosaicked=R_resin+R_tent
+    R_demosaicked=np.clip(R_demosaicked,0,1)
+
+    B_demosaicked=B_resin+B_tent
+    B_demosaicked=np.clip(B_demosaicked,0,1)
+
+    color_image=np.stack((R_demosaicked,G_demosaicked,B_demosaicked),axis=-1)
+    
+    return color_image
+

eari_package-0.1.0/eari_package.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: eari_package
+Version: 0.1.0
+Summary: EARI image demosaicking implementation
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.4.4
+Requires-Dist: opencv-python>=4.13.0.92
+Requires-Dist: scipy>=1.17.1

eari_package-0.1.0/eari_package.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+eari_package/__init__.py
+eari_package/eari.py
+eari_package/ri.py
+eari_package.egg-info/PKG-INFO
+eari_package.egg-info/SOURCES.txt
+eari_package.egg-info/dependency_links.txt
+eari_package.egg-info/requires.txt
+eari_package.egg-info/top_level.txt

eari_package-0.1.0/eari_package.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eari_package-0.1.0/eari_package.egg-info/requires.txt

@@ -0,0 +1,3 @@
+numpy>=2.4.4
+opencv-python>=4.13.0.92
+scipy>=1.17.1

eari_package-0.1.0/eari_package.egg-info/top_level.txt

@@ -0,0 +1 @@
+eari_package

eari_package-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eari_package"
+version = "0.1.0"
+description = "EARI image demosaicking implementation"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy>=2.4.4",
+    "opencv-python>=4.13.0.92",
+    "scipy>=1.17.1"
+]

eari_package-0.1.0/setup.cfg

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