예제 #1
0
    def main(self):

        # reduce light field in angular domain (depending on settings)
        if self._Mn < self._M and isint(self._M):
            self.proc_lens_iter(self.crop_micro_image, msg='Render angular domain')
        elif self._Mn == self._M:
            self.new_lfp_img = self._lfp_img_align
예제 #2
0
    def main(self):

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

        # reduce light field in angular domain (depending on settings)
        if self._Mn < self._M and isint(self._M):
            self.proc_lens_iter(self.crop_micro_image,
                                msg='Render angular domain')
        elif self._Mn == self._M:
            self.new_lfp_img = self._lfp_img_align
예제 #3
0
    def rectify_candidates_channel(self, channel, ref_img=None, med_img=None, n=2, sig_lev=4):

        ref_img = channel if ref_img is None else ref_img
        med_img = channel if med_img is None else med_img

        # pre-select outlier candidates (narrow-down search area to speed-up the process)
        m_val = np.mean(ref_img)
        s_val = np.std(ref_img)
        candidate_idxs = np.where(ref_img > m_val + s_val * sig_lev)

        ref_img = np.zeros_like(channel)
        ref_img[candidate_idxs[0], candidate_idxs[1]] = channel[candidate_idxs[0], candidate_idxs[1]]
        ref_img[ref_img < .3] = 0
        candidate_idxs = np.where(ref_img != 0)
        candidates = list(zip(candidate_idxs[0], candidate_idxs[1]))

        if n < 1 or not misc.isint(n):
            self.sta.status_msg('Skip hot-pixel detection due to wrong settings', self.cfg.params[self.cfg.opt_prnt])
            return channel

        for num, idx in enumerate(candidates):

            j, i = idx

            adj_cands = (candidate_idxs[0] > j-n**2) & (candidate_idxs[0] < j+n**2) & \
                        (candidate_idxs[1] > i-n**2) & (candidate_idxs[1] < i+n**2)

            if np.count_nonzero(adj_cands) < n:

                if n < j < ref_img.shape[0]-n and n < i < ref_img.shape[1]-n:
                    win = channel[j-n:j+n+1, i-n:i+n+1]
                else:
                    # treat candidates being too close to image border
                    alt_n = min(j, abs(ref_img.shape[0]-j), i, abs(ref_img.shape[1]-i))
                    win = channel[j-alt_n:j+alt_n+1, i-alt_n:i+alt_n+1]

                m_val = np.mean(win)
                s_val = np.std(win)

                if channel[j, i] < m_val - s_val * sig_lev or channel[j, i] > m_val + s_val * sig_lev:

                    # replace outlier
                    channel[j, i] = med_img[j, i]

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

        return channel