8332707534

Committed 12 Nov 2022 07:18PM UTC coverage: 70.59% (-0.3%) from 70.922%

Build # 8332707534

Build Type

push

github

Committed by

hahnec

Commit Message

refactor(var): rename variable to lfp_img_align for consistency

Run Details

648 of 1231 branches covered (52.64%)

Branch coverage included in aggregate %.

2 of 3 new or added lines in 1 file covered. (66.67%)

19 existing lines in 4 files now uncovered.

3670 of 4886 relevant lines covered (75.11%)

1.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.73

/plenopticam/lfp_extractor/hex_corrector.py

#!/usr/bin/env python

__author__ = "Christopher Hahne"
__email__ = "info@christopherhahne.de"
__license__ = """
    Copyright (c) 2019 Christopher Hahne <info@christopherhahne.de>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

"""

import numpy as np
import os
from scipy.interpolate import interp1d

from plenopticam import misc
from plenopticam.lfp_extractor import LfpViewpoints
from plenopticam.lfp_aligner.lfp_local_resampler import LfpLocalResampler


class HexCorrector(LfpViewpoints):

    def __init__(self, *args, **kwargs):
        super(HexCorrector, self).__init__(*args, **kwargs)

        self.ref_img = kwargs['ref_img'] if 'ref_img' in kwargs else self.central_view
        self.method = kwargs['method'] if 'method' in kwargs else 'cubic'

        if self.cfg.calibs[self.cfg.mic_list] is not None:
            # analyse
            self.hex_odd = LfpLocalResampler.get_hex_direction(np.asarray(self.cfg.calibs[self.cfg.mic_list]))
        else:
            # reset pattern type to skip hex correction process
            self.cfg.calibs[self.cfg.pat_type] = 'rec'

    def main(self):

        # check interrupt status
        if self.sta.interrupt:
            return False

        # remove hexagonal artifact
        if self.cfg.calibs[self.cfg.pat_type] == 'hex':
            self.proc_vp_arr(self.ver_hex_bulge, msg='Hexagonal artifact removal')

        # normalize light-field
        self.vp_img_arr = misc.Normalizer(self.vp_img_arr).uint16_norm()

        return True

    def hex_interp_1d(self, img):

        hex_stretch = 2 / np.sqrt(3)
        m, n, ch = img.shape if len(img.shape) == 3 else img.shape + (1,)
        s_check = [0, 1] if self.hex_odd else [1, 0]
        final = np.zeros([m, int(np.round(n * hex_stretch)), ch])
        new_l = int(np.round(img.shape[1] * hex_stretch))

        img = img.astype('float')/img.max()
        for p in range(ch):
            for j in range(2):
                s = -0.5 * s_check[j]
                for i in range(img.shape[0])[j::2]:
                    fun = interp1d(np.arange(len(img[i, :, p])), img[i, :, p], kind=self.method, fill_value="extrapolate")
                    final[i, ..., p] = fun(np.linspace(0, len(img[i, :, p])-1, new_l)+s)

        return final

    def ver_hex_bulge(self, img):

        # variable init
        img = np.divide(img.astype('float'), img.max(), out=np.zeros_like(img), where=img != 0)
        m, n, ch = img.shape if len(img.shape) == 3 else img.shape + (1,)

        # j for shifted and i represents truth (unshifted)
        i, j = [1, 0] if self.hex_odd else [0, 1]

        # gradient between shifted and unshifted (responsive to hex artifacts)
        if img[i::2, ...].shape[0] == img[j::2, ...].shape[0]:
            dif = img[j::2, ...]-img[i::2, ...]
        elif img[j::2, ...].shape[0] == img[i::2, ...].shape[0]+1:
            dif = img[j::2, ...][:-1]-img[i::2, ...]
        elif img[j::2, ...].shape[0]+1 == img[i::2, ...].shape[0]:
            dif = img[j::2, ...] - img[i::2, ...][:-1]
        else:
            self.sta.error('Image dimension mismatch')
            return False

        # gradient between unshifted (responsive to real object edges)
        edg = img[i::2, ...][:-1]-img[i+2::2, ...]
        edg *= 0.75

        # absolute values
        dif = abs(dif)
        edg = abs(edg)

        # (don't throw away channel information)
        dif = dif.sum(2)
        edg = edg.sum(2)

        # deduct actual edges
        karr = dif - edg if dif.shape[0] == edg.shape[0] else dif[:-1, ...] - edg
        karr = np.divide(karr, karr.max(), out=np.zeros_like(karr), where=karr != 0)
        karr[karr < 0] = 0
        if self.cfg.params[self.cfg.opt_dbug]:
            misc.save_img_file(karr, os.path.join(self.cfg.exp_path, 'karr.png'))

        # replicate mask to 3 color channels
        arr = np.zeros(karr.shape+(3,))
        for p in range(ch):
            arr[..., p] = karr

        # threshold values with insufficient difference
        mask = np.divide(arr, arr.max(), out=np.zeros_like(arr), where=arr != 0)
        th = 0.1
        mask[mask < th] = 0
        mask[mask >= th] = 1

        # ignore small regions
        mask = self.retain_connected(mask, n=4)

        # generate mask
        if self.cfg.params[self.cfg.opt_dbug]:
            full_mask = np.zeros(img.shape)
            if full_mask[j::2, ...].shape[0] == mask.shape[0]:
                full_mask[j::2, ...] = mask
            else:
                full_mask[j::2, ...][:mask.shape[0], ...] = mask
            misc.save_img_file(full_mask, os.path.join(self.cfg.exp_path, 'hex_filter_mask.png'), tag=True)

        # generate image indicating which pixels were treated
        if self.cfg.params[self.cfg.opt_dbug]:
            tes = img.copy()
            for p in range(ch):
                if tes[j::2, ...].shape[0] == mask.shape[0]:
                    tes[j::2, :, p][mask[..., p] != 0] = tes.max()
                else:
                    tes[j::2, :, p][:mask.shape[0], ...][mask[..., p] != 0] = tes.max()
            tes_out = np.divide(tes, tes.max(), out=np.zeros_like(tes), where=tes != 0)
            misc.save_img_file(tes_out, os.path.join(self.cfg.exp_path, 'ident.png'), tag=True)

        idxs = np.array(mask.nonzero())
        r = 1
        valid_idx = np.where((idxs[0] > r) & (idxs[1] > r) & (img[j::2].shape[0]-idxs[0] > r) & (img.shape[1]-idxs[1] > r))[0]
        idxs_vals = list(zip(idxs[0][valid_idx], idxs[1][valid_idx], idxs[2][valid_idx]))

        res = img.copy()
        for idx in idxs_vals:
            new_val = np.mean(img[i::2, ...][idx[0]:idx[0]+2, idx[1], idx[2]], axis=0)
            res[j::2, ...][idx[0], idx[1], idx[2]] = new_val

        if self.cfg.params[self.cfg.opt_dbug]:
            misc.save_img_file(res, os.path.join(self.cfg.exp_path, 'hex-corr.png'))

        return res

    @staticmethod
    def retain_connected(mask, n):

        w = mask.copy().T.ravel().astype('bool')

        idx = np.flatnonzero(np.r_[True, ~w, True])
        lens = np.diff(idx) - 1
        comb = np.vstack(list(zip(idx, lens)))
        filt = comb[comb[:, 1] >= n]
        vals = np.zeros_like(w)
        for f in filt:
            vals[f[0]:f[0]+f[1]] = 1

        return np.reshape(vals, mask.T.shape).T.astype('uint8')

1	#!/usr/bin/env python
2
3	__author__ = "Christopher Hahne"	2✔
4	__email__ = "info@christopherhahne.de"	2✔
5	__license__ = """	2✔
6	Copyright (c) 2019 Christopher Hahne <info@christopherhahne.de>
7
8	This program is free software: you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation, either version 3 of the License, or
11	(at your option) any later version.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21	"""
22
23	import numpy as np	2✔
24	import os	2✔
25	from scipy.interpolate import interp1d	2✔
26
27	from plenopticam import misc	2✔
28	from plenopticam.lfp_extractor import LfpViewpoints	2✔
29	from plenopticam.lfp_aligner.lfp_local_resampler import LfpLocalResampler	2✔
30
31
32	class HexCorrector(LfpViewpoints):	2✔
33
34	def __init__(self, args, *kwargs):	2✔
35	super(HexCorrector, self).__init__(args, *kwargs)	2✔
36
37	self.ref_img = kwargs['ref_img'] if 'ref_img' in kwargs else self.central_view	2✔
38	self.method = kwargs['method'] if 'method' in kwargs else 'cubic'	2✔
39
40	if self.cfg.calibs[self.cfg.mic_list] is not None:	2!
41	# analyse
42	self.hex_odd = LfpLocalResampler.get_hex_direction(np.asarray(self.cfg.calibs[self.cfg.mic_list]))	2✔
43	else:
44	# reset pattern type to skip hex correction process
45	self.cfg.calibs[self.cfg.pat_type] = 'rec'	×
46
47	def main(self):	2✔
48
49	# check interrupt status
50	if self.sta.interrupt:	2!
51	return False	×
52
53	# remove hexagonal artifact
54	if self.cfg.calibs[self.cfg.pat_type] == 'hex':	2!
55	self.proc_vp_arr(self.ver_hex_bulge, msg='Hexagonal artifact removal')	2✔
56
57	# normalize light-field
58	self.vp_img_arr = misc.Normalizer(self.vp_img_arr).uint16_norm()	2✔
59
60	return True	2✔
61
62	def hex_interp_1d(self, img):	2✔
63
64	hex_stretch = 2 / np.sqrt(3)	×
65	m, n, ch = img.shape if len(img.shape) == 3 else img.shape + (1,)	×
66	s_check = [0, 1] if self.hex_odd else [1, 0]	×
67	final = np.zeros([m, int(np.round(n * hex_stretch)), ch])	×
68	new_l = int(np.round(img.shape[1] * hex_stretch))	×
69
70	img = img.astype('float')/img.max()	×
71	for p in range(ch):	×
72	for j in range(2):	×
73	s = -0.5 * s_check[j]	×
74	for i in range(img.shape[0])[j::2]:	×
75	fun = interp1d(np.arange(len(img[i, :, p])), img[i, :, p], kind=self.method, fill_value="extrapolate")	×
76	final[i, ..., p] = fun(np.linspace(0, len(img[i, :, p])-1, new_l)+s)	×
77
78	return final	×
79
80	def ver_hex_bulge(self, img):	2✔
81
82	# variable init
83	img = np.divide(img.astype('float'), img.max(), out=np.zeros_like(img), where=img != 0)	2✔
84	m, n, ch = img.shape if len(img.shape) == 3 else img.shape + (1,)	2✔
85
86	# j for shifted and i represents truth (unshifted)
87	i, j = [1, 0] if self.hex_odd else [0, 1]	2✔
88
89	# gradient between shifted and unshifted (responsive to hex artifacts)
90	if img[i::2, ...].shape[0] == img[j::2, ...].shape[0]:	2✔
91	dif = img[j::2, ...]-img[i::2, ...]	1✔
UNCOV 92	elif img[j::2, ...].shape[0] == img[i::2, ...].shape[0]+1:	1!
UNCOV 93	dif = img[j::2, ...][:-1]-img[i::2, ...]	1✔
94	elif img[j::2, ...].shape[0]+1 == img[i::2, ...].shape[0]:	×
95	dif = img[j::2, ...] - img[i::2, ...][:-1]	×
96	else:
97	self.sta.error('Image dimension mismatch')	×
98	return False	×
99
100	# gradient between unshifted (responsive to real object edges)
101	edg = img[i::2, ...][:-1]-img[i+2::2, ...]	2✔
102	edg *= 0.75	2✔
103
104	# absolute values
105	dif = abs(dif)	2✔
106	edg = abs(edg)	2✔
107
108	# (don't throw away channel information)
109	dif = dif.sum(2)	2✔
110	edg = edg.sum(2)	2✔
111
112	# deduct actual edges
113	karr = dif - edg if dif.shape[0] == edg.shape[0] else dif[:-1, ...] - edg	2✔
114	karr = np.divide(karr, karr.max(), out=np.zeros_like(karr), where=karr != 0)	2✔
115	karr[karr < 0] = 0	2✔
116	if self.cfg.params[self.cfg.opt_dbug]:	2!
117	misc.save_img_file(karr, os.path.join(self.cfg.exp_path, 'karr.png'))	2✔
118
119	# replicate mask to 3 color channels
120	arr = np.zeros(karr.shape+(3,))	2✔
121	for p in range(ch):	2✔
122	arr[..., p] = karr	2✔
123
124	# threshold values with insufficient difference
125	mask = np.divide(arr, arr.max(), out=np.zeros_like(arr), where=arr != 0)	2✔
126	th = 0.1	2✔
127	mask[mask < th] = 0	2✔
128	mask[mask >= th] = 1	2✔
129
130	# ignore small regions
131	mask = self.retain_connected(mask, n=4)	2✔
132
133	# generate mask
134	if self.cfg.params[self.cfg.opt_dbug]:	2!
135	full_mask = np.zeros(img.shape)	2✔
136	if full_mask[j::2, ...].shape[0] == mask.shape[0]:	2!
137	full_mask[j::2, ...] = mask	×
138	else:
139	full_mask[j::2, ...][:mask.shape[0], ...] = mask	2✔
140	misc.save_img_file(full_mask, os.path.join(self.cfg.exp_path, 'hex_filter_mask.png'), tag=True)	2✔
141
142	# generate image indicating which pixels were treated
143	if self.cfg.params[self.cfg.opt_dbug]:	2!
144	tes = img.copy()	2✔
145	for p in range(ch):	2✔
146	if tes[j::2, ...].shape[0] == mask.shape[0]:	2!
147	tes[j::2, :, p][mask[..., p] != 0] = tes.max()	×
148	else:
149	tes[j::2, :, p][:mask.shape[0], ...][mask[..., p] != 0] = tes.max()	2✔
150	tes_out = np.divide(tes, tes.max(), out=np.zeros_like(tes), where=tes != 0)	2✔
151	misc.save_img_file(tes_out, os.path.join(self.cfg.exp_path, 'ident.png'), tag=True)	2✔
152
153	idxs = np.array(mask.nonzero())	2✔
154	r = 1	2✔
155	valid_idx = np.where((idxs[0] > r) & (idxs[1] > r) & (img[j::2].shape[0]-idxs[0] > r) & (img.shape[1]-idxs[1] > r))[0]	2✔
156	idxs_vals = list(zip(idxs[0][valid_idx], idxs[1][valid_idx], idxs[2][valid_idx]))	2✔
157
158	res = img.copy()	2✔
159	for idx in idxs_vals:	2✔
160	new_val = np.mean(img[i::2, ...][idx[0]:idx[0]+2, idx[1], idx[2]], axis=0)	2✔
161	res[j::2, ...][idx[0], idx[1], idx[2]] = new_val	2✔
162
163	if self.cfg.params[self.cfg.opt_dbug]:	2!
164	misc.save_img_file(res, os.path.join(self.cfg.exp_path, 'hex-corr.png'))	2✔
165
166	return res	2✔
167
168	@staticmethod	2✔
169	def retain_connected(mask, n):	2✔
170
171	w = mask.copy().T.ravel().astype('bool')	2✔
172
173	idx = np.flatnonzero(np.r_[True, ~w, True])	2✔
174	lens = np.diff(idx) - 1	2✔
175	comb = np.vstack(list(zip(idx, lens)))	2✔
176	filt = comb[comb[:, 1] >= n]	2✔
177	vals = np.zeros_like(w)	2✔
178	for f in filt:	2✔
179	vals[f[0]:f[0]+f[1]] = 1	2✔
180
181	return np.reshape(vals, mask.T.shape).T.astype('uint8')	2✔

hahnec / plenopticam / 8332707534

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous