コード例 #1
0
ファイル: dwt.py プロジェクト: diogopmonteiro/wm
    def embed_specific(self, image, image_file, watermark=None):
        i_width = image.shape[0]
        i_height = image.shape[1]

        wm = watermark
        wm_width = wm.shape[0]
        wm_height = wm.shape[1]

        if not (wm_width == i_width / 2 and wm_height == i_height / 2):
            raise WmError("Watermark size must be half of image size. For now.")

        ir, ig, ib = self.split_image(image)

        img = self.split_image(wm)
        dcts_wm = self.rgb_to_dct(*img)

        dwts_i = self.rgb_to_dwt(ir, ig, ib)

        for color in range(3):
            dct = dcts_wm[color]
            hh = TwoDimensionalDCT.forward(dwts_i[color][1][2])
            for j in range(len(dct)):
                for k in range(len(dct[0])):
                    hh[j][k] += dct[j][k] * self.alpha

            ihh = TwoDimensionalDCT.inverse(hh)
            hh = dwts_i[color][1][2]
            for j in range(len(dct)):
                for k in range(len(dct[0])):
                    hh[j][k] = ihh[j][k]

        rgb = self.dwt_to_rgb(*dwts_i)

        img = self.join_image(*rgb)
        return img
コード例 #2
0
ファイル: cox.py プロジェクト: diogopmonteiro/wm
    def embed_specific(self, image, image_file, watermark=None):
        # Compute DCT
        f_dct = TwoDimensionalDCT.forward(image)

        # Sort DCT
        size_dct = int(f_dct.__len__()*self.watermark_size_percentage)
        sorted_dct_indexes = f_dct.ravel().argsort()[-size_dct:]
        sorted_dct_indexes = (numpy.unravel_index(indx, f_dct.shape) for indx in sorted_dct_indexes)
        sorted_unraveled = [(f_dct[indx], indx) for indx in sorted_dct_indexes]

        nbits = numpy.random.normal(self.mu, self.sigma, size_dct)

        # Construct the Watermark
        for i in range(len(nbits)):
            f_dct[sorted_unraveled[i][1]] += self.alpha * nbits[i]

        self.export_image(sorted_unraveled, image_file, nbits)
        inverse = TwoDimensionalDCT.inverse(f_dct)
        return inverse
コード例 #3
0
ファイル: test_dct.py プロジェクト: diogopmonteiro/wm
    def test_dct_solid_gray(self):
        dct = TwoDimensionalDCT.forward(self.solid_gray)
        for channel in range(3):
            self.assertTrue(self.closeEnough(dct[0][0][channel], 800))

        for channel in range(3):
            for i in range(len(dct)):
                for j in range(len(dct[i])):
                    if i != 0 and j != 0:
                        self.assertTrue(self.closeEnough(dct[i][j][channel], 0))
コード例 #4
0
ファイル: cox.py プロジェクト: diogopmonteiro/wm
    def extract_specific(self, image, watermark):
        f_dct = TwoDimensionalDCT.forward(image)
        w = self.load_watermark(watermark)

        xi = []
        xo = []

        for entry in w:
            xo.append( entry[self.INSERTED_WATERMARK_VALUE_KEY] )
            xi.append( (f_dct[tuple(entry[self.INDEX_KEY])] - entry[self.ORIGINAL_VALUE_KEY]) /\
                       (self.alpha))

        return None, Metrics.gamma(xi, xo)
コード例 #5
0
ファイル: dwt.py プロジェクト: diogopmonteiro/wm
    def extract_specific(self, image, watermark):
        wm = self.open_image(watermark)

        RED, GREEN, BLUE = (0,1,2)

        image_rgb = self.split_image(image)
        wm_rgb = self.split_image(wm)

        image_dwt = list(self.rgb_to_dwt(*image_rgb))
        wm_dwt = list(self.rgb_to_dwt(*wm_rgb))

        for color in range(3):
            dct_image_dwt = TwoDimensionalDCT.forward(image_dwt[color][1][2])
            dct_wm_dwt = TwoDimensionalDCT.forward(wm_dwt[color][1][2])
            for i in range(len(image_dwt[RED][1][2])):
                for j in range(len(image_dwt[RED][1][2][0])):
                    dct_image_dwt[i][j] = (dct_wm_dwt[i][j] - dct_image_dwt[i][j])/self.alpha

            for i in range(len(image_dwt[RED][1][2])):
                for j in range(len(image_dwt[RED][1][2][0])):
                    image_dwt[color][1][2][i][j] = dct_image_dwt[i][j]

        return self.join_image(*self.dct_to_rgb(image_dwt[RED][1][2], image_dwt[GREEN][1][2], image_dwt[BLUE][1][2])), 0
コード例 #6
0
ファイル: dwt.py プロジェクト: diogopmonteiro/wm
 def dct_to_rgb(self, cr, cg, cb):
     return TwoDimensionalDCT.inverse(cr), TwoDimensionalDCT.inverse(cg), TwoDimensionalDCT.inverse(cb)
コード例 #7
0
ファイル: dwt.py プロジェクト: diogopmonteiro/wm
 def rgb_to_dct(self, r, g, b):
     return TwoDimensionalDCT.forward(r), TwoDimensionalDCT.forward(g), TwoDimensionalDCT.forward(b)
コード例 #8
0
ファイル: test_dct.py プロジェクト: diogopmonteiro/wm
 def test_idct_close_values(self):
     img = TwoDimensionalDCT.inverse(TwoDimensionalDCT.forward(self.close_values))
     self._test_inverse(img, self.close_values)
コード例 #9
0
ファイル: test_dct.py プロジェクト: diogopmonteiro/wm
 def test_idct_solid_gray(self):
     img = TwoDimensionalDCT.inverse(TwoDimensionalDCT.forward(self.solid_gray))
     self._test_inverse(img, self.solid_gray)
コード例 #10
0
ファイル: test_dct.py プロジェクト: diogopmonteiro/wm
 def test_dct_close_values(self):
     dct = TwoDimensionalDCT.forward(self.close_values)
     self.assertTrue(self.closeEnough(dct[0][0][0], 407))