Chapter 3 Fast Weighted Secret Image Sharing
3.3 Experimental results, comparisons, and security analysis
3.3.3 Security analysis
3.3.3 Security analysis
The security analysis is divided into two parts: 1) a group of shadows with total weights t-1 cannot reveal the secret image and 2) shadows of different weights are not equally secure.
Firstly, suppose that the tʺ obtained shadows are {(~[1]
hk , wk[1]), (~[2]
hk , wk[2]), ..., (~[ ]
t
hk ′′ ,
] [t
wk ′′ )} and the sum of their weights is tʺ −1 (i.e. 1
1 ]
[ = −
∑
′′=
t w
t
j j
k ), then we analyze the probability of obtaining the secret image by guessing. According the Chinese Remainder Theorem for polynomials, we can construct a unique polynomial ~( )
x
f ′ with degree is less
61
than 1
1 ]
[ = −
∑
′′=
t w
t
j j
k from these m' shadows. After obtaining~( ) x
f ′ , to reveal the ~( ) x f in Eq. (3.7) by~( )
x
f ′ , we have
)
~( ])
[ ( )
~(
1
]
[ f x
j k x x
f
t
j
wk j
+ ′
−
=
∏
′′=
α
where α is a non-negative integer less than 28 =256 (because GF(28) is used in our experiments). Since there are 28 =256 possible values of α, the possibility of guessing the right solution~( )
x
f is 1/256. For a 512×512 secret image, because there are 512×512/tpolynomials, the possibility of obtaining the right secret image is 256−(512×512/t), which is a form similar to the 251−(512×512/t) given in Thien and Lin’s chapter.
Secondly, we analyze below the probability of obtaining the secret image by using only one shadow. Given a shadow
wi
h of weight wi, then the polynomialgiwi(x) can be obtained using the shadow
wi
h . Now, to use giwi(x) to reveal the ~( ) x
f in Eq. (3.7), we have )
( )
)(
( )
~(
x g i x x Q x
f = ′ − wi + iwi whereQ′(x)is an unknown polynomial with degree is less than t−wi. Therefore, there is
1/
256t−wichance to find out the polynomialQ′(x) by guessing. On the other hand, there are 512×512/tpolynomials for a given 512×512 secret image, so the possibility of obtaining finding out the secret image is256−(512×512×(1−wi/t)). This shows that shadows of different weights are not equally secure, for the security of each shadow is weight-dependent. To find out the secret image by guessing, the owner of a larger-weight shadow has more chance than the owner of a smaller-weight has. This agrees with our daily-life experience: a higher-rank manager (having heavier weight) has more chance to uncover the company’s secret than a lower-rank employee has.3.4 Conclusions
In this chapter, a fast weighted secret image sharing with (t, n) threshold method is proposed. The method shares the secret image among the weighted participants, and the secret image can be losslessly recovered if the sum of the weights of the participants is greater than or equal to the threshold t. Besides, the execution time in the weighted secret image sharing phase is improved by using the properties of GF(2k). As shown in Fig. 3.5, our execution time is better than that of Thien and Lin whenwi > . The executives of a company can use our 1
62
method to share the secret image.
63
Chapter 4
Weighted-Sum Function (WSF) − A Gray-scale Image Hiding Method with Competitive PSNR over a Wide
Range of Embedding Rates
This chapter proposes an embedding method based on a weighted-sum function. A gray-scale host image is divided into blocks of n pixels, and each block embeds m secret bits in it. The stego-pixel values in each block are obtained by calculating the weighted-sum function with minimal distortions. The advantages of this method include: (1) Wide range of embedding rate (such as 0.5 to 4 bits per pixel), (2) Competitive image quality over the whole wide range, (3) Once the embedding rate (bits per pixel) is given, our look-up table can predict the PSNR value, even before the actual embedding.
The remainder of the chapter is organized as follows. The method is introduced in Sec.
4.1. Experimental results are presented in Sec. 4.2. Sec. 4.3 compares our method with previous works. Sec. 4.4 provides a discussion, and. Sec. 4.5 is the summary.
Notations in this chapter:
H The gray-scale host image (After embedding, we obtain its stego-image H'.).
z Number of pixels in each block of the host image.
m Number of secret bits to be embedded in a block.
Bm An m-bits binary value to be embedded in a block.
pi The i-th pixel value in a block of host image H (After embedding, we obtain its stego-pixel p′ .). i
pmax The upper bound of host pixels and stego-pixels (each pixel value is between 0 and pmax −1).
pi
∆ The distortion between the stego-pixel p′ and the host pixel pi i. (1=c0,c1,...,cz-1) The z weights repeatedly used by all blocks to extract their data Bm
by the weighted-sum function
64 which is required to have the value
)
Rm-constraint in optimization).
Rm
T The vector which has minimal sum of squares under the constraint )
4.1 The proposed method
Divide the gray-scale host image H into blocks of z pixels each. Also divide the data to be embedded into sectors of m bits each. Without a loss of generality, focus on one block and one sector. In other words, we show below how to embed an m-bits binary value Bm in an z-pixels block (p0, p1,..., pz-1) of H. Let
; i=0, 1, …, z−1,
be the values of z stego-pixels, i.e. the pixel values after embedding Bm. Also assume that pixel values must be in the gray value range [0, pmax) where pmax −1 is the maximal possible gray value. For example, if each gray has 8 bits, then pmax =28=256. In the future, we want to extract Bm from the stego-pixels simply by a weighted-sum function
)
f . In some studies for embedding, such as [8, 38], the base of modulus function is not necessarily a power of two. However, since the embedded data is often a binary stream, we set the modulus value to 2m. Now, Eq. (4.1) reads
)
So, the weighted error sum
i i
i p p
p′= +∆
65
Notably, Rm can be evaluated by Eq. (4.4) in the embedding phase whenever the weights (1,c1,...,cz-1) are given or determined, since the secret data Bm and host pixel values {p0, p1,..., which minimizes the sum of squares under constraint (4.3). In symbols,
This is a time-consuming combinatorial problem, and we use a dynamic programming skill to obtain a solution quickly. First, for the given (1, c1,..., cz-1), we generate table T based on Eq.
(4.5). In other words, table T should list the suitable
Rm
Some recursive formulas are used in the dynamic programming (Algorithm 4.1). For k 2m
( obtained under the (j+1)-terms constraint
) In symbols,
Eq. (4.7) implies that our original minimization goal is equivalent to getting Q[k, z−1] for each k∈[0,2m). (The parameter values also the parameter values utilized to solve Eq. (4.5).) Now, in order to get Q[k, z−1], we start from the 0th column Q[•,0]. Then we get the 1st column Q[•, 1] , and then the 2nd column Q[•, 2]; ….; until we get the (z−1)th column Q [•, z−1] . In other words, we need a recursive
66
formula to evaluate Q [k, j]. By observation, the value of Q[k, 0] is
{ }
is equivalent to the (j+1)-terms constraint Eq. (4.6).
By definition Eq. (4.7), Q[k−cjl (mod2m),j−1] is the minimal sum of squares
More precisely, Q[k, j] can be obtained from
{
[ (mod2 ), 1] 0, 1,..., (2 1)}
67 Define table T as a matrix whose entries are
To obtain T from table Q, the selected value l of Eq. (4.10) is recorded in an auxiliary table L.
In symbols, record
{
[ (mod2 ), 1] 0, 1,..., (2 1)}
The value of L[k, j] is simultaneously updated with Q[k, j], so table L is obtained once table Q is obtained. Then, table T is constructed by a loop function. Firstly, because of Eq. (4.11) and Eq. (4.12), we have the proof is similar, and hence, it is omitted. These steps are repeated until table T is complete.
68
Algorithm 4.1 below describes the details.
Algorithm 4.1. An auxiliary algorithm to construct table T by dynamic-programming.
Input: Two positive integers m and z, and z weights (1, c1,..., cz−1).
Output: A table T containing 2m vectors (each vector is of the form(∆p0∗,∆p1∗,...,∆pn∗−1)), and an predicted PSNR value PSNRest.
Remark: The Q, L and T in the algorithm are tables of size 2m×z each.
69
27 28 29 30 31 32 33 34 35
end for
for k = 0 to 2m−1 do k
l⇐
for j = z−1 to 0 do ] , [ ] ,
[k j Ll j
T ⇐
) 2 (mod ]
,
[ m
jLl j c l l⇐ − end for end for
Calculate MSEest (the expected value of MSE) and PSNRest (the predicted PSNR) by
∑
−=
−
= 2 1
0
] 1 , 2 [
1 m
k
est m Q k z
MSE n , (4.13)
est
est MSE
PSNR X
2 10
) 1 log (
10 −
= . (4.14)
Remarks: In Lines 15−25 above, the condition of the while loop isl2<Q[k,j], rather than l<2m, because if l2 ≥Q[k, j], then the two “if” conditions in Lines 16−19 and Lines 20−23, i.e. Q[k, j]≥Q[k+cjl (mod2m), j−1]+l2 and Q[k, j]≥Q[k−cjl (mod2m), j−1]+l2 , will never be satisfied.
Example 4.1: Assume (m, z)= (4, 3), and the z weights are (1, c1, c2)=(1, 2, 6). Table 4.1 is the three tables Q, L and the table T generated by Algorithm 4.1 above. The predicted PSNR provided by Algorithm 4.1 is =10log2552 =51.14
est
est MSE
PSNR dB where
∑
−=
−
= 2 1
0
] 1 , 2 [
1 m
k
est m Q k z
MSE n =0.5 is evaluated at Step 4 of Algorithm 4.1.
Table 4.1. The tables Q, L, and T for (m, z)=(4, 3) when z given weights are (1, c1, c2)=(1, 2, 6). (a): Table Q generated in the intermediate process of Algorithm 1. (b): Table L generated in the intermediate process of Algorithm 1. (c): The final output table T of Algorithm 1.
70
(a) i table Q 0 0 0 0 1 1 1 1 2 4 1 1 3 9 2 2 4 16 4 2 5 25 5 2 6 36 8 1 7 49 10 2 8 64 13 2 9 49 10 2 10 36 8 1 11 25 5 2 12 16 4 2 13 9 2 2 14 4 1 1 15 1 1 1
(b) i table L 0 0 0 0 1 1 0 0 2 2 1 0 3 3 1 0 4 4 2 1 5 5 2 1 6 6 2 1 7 7 3 1 8 8 3 1 9 −7 −3 −1 10 −6 −2 −1 11 −5 −2 −1 12 −4 −2 −1 13 −3 −1 0 14 −2 −1 0 15 −1 0 0
(c) table T Rm ∆p0∗ ∆p 1∗ ∆p 2∗
0 0 0 0
1 1 0 0
2 0 1 0
3 1 1 0
4 0 −1 1
5 −1 0 1
6 0 0 1
7 1 0 1
8 0 1 1
9 −1 0 −1
10 0 0 −1
11 1 0 −1
12 0 1 −1
13 −1 −1 0
14 0 −1 0
15 −1 0 0
Table 4.2. Suggested weights (1, c1,..., cz−1) for certain embedding rate values. For the listed (m, z), the estimated PSNR (i.e. value of Eq. (4.14)) is optimal if users adopt these suggested weights.
No. Embedding rate m, z Estimated PSNR 1, c1,..., cz−1
0 0.500 bpp 4, 8 57.44 dB 1, 2, 3, 4, 5, 6, 7, 8
1 0.571 4, 7 56.58 1, 2, 3, 4, 5, 6, 7
2 0.667 4, 6 55.40 1, 2, 3, 4, 5, 6
3 0.750 6, 8 54.81 1, 2, 3, 4, 5, 6, 13, 26 4 0.875 7, 8 54.25 1, 2, 8, 12, 24, 29, 47, 62
5 1.000 6, 6 53.33 1, 2, 5, 12, 20, 28
6 1.167 7, 6 52.26 1, 3, 8, 18, 42, 54
7 1.200 6, 5 52.04 1, 6, 10, 18, 31
8 1.250 5, 4 51.64 1, 2, 6, 11
9 1.333 8, 6 51.40 1, 3, 9, 27, 50, 93
10 1.400 7, 5 50.97 1, 3, 9, 28, 52
11 1.500 6, 4 50.34 1, 3, 8, 22
12 1.600 8, 5 49.75 1, 3, 58, 87, 124
13 1.667 5, 3 49.09 1, 4, 10
14 1.750 7, 4 48.65 1, 4, 40, 58
15 1.800 9, 5 48.46 1, 36, 86, 146, 215
16 2.000 10, 5 47.31 1, 9, 23, 243, 324
17 2.250 9, 4 45.73 1, 13, 149, 232
18 2.500 10, 4 44.23 1, 26, 33, 221
19 2.750 11, 4 42.72 1, 364, 559, 986
20 3.000 12, 4 41.22 1, 9, 350, 491
21 3.333 10, 3 39.10 1, 20, 195
22 3.500 7, 2 38.00 1, 12
23 3.667 11, 3 37.10 1, 61, 597
24 4.000 12, 3 35.10 1, 1210, 2026
Algorithm 4.1 above needs the user to provide z weights (1, c1,..., cz-1). For the reader’s benefit, some suggested weights for different combinations of (m, z) are provided in Table 4.2.
71
Notably, the value of bpp (bits per pixel) is always bpp= m/z,
which is the number of embedded bits in each pixel of each block. The weights shown in Table 4.2 yield the optimal expected value of MSE for each pair of (m, z) specified there.
These weights are found by an exhaustive search (i.e. all possible (1, c1,..., cz-1) in the searching domain (each ci∈[0,2m)) has been tested for the specified (m, z)). Notably, there is no need to test other values ci∉[0,2m), because they will be normalized to the scope [0,2m) by the modulus operator (mod 2m).
Table 4.2 enables the readers to easily decide the weights (1, c1,..., cz-1). For example, if the host image is 512×512, and the size of embedded data is 500000 bits, then the embedding rate is 500000/(512×512)=1.91 bpp, which is between the 1.8 bpp and 2.0 bpp of Table 5.2.
To get enough embedding space, the embedding rate cannot be smaller than 1.91, so we use 2.0 bpp. Therefore, from Table 4.2, use (m, z)=(10, 5), and choose
) 2 (mod 324
243 23
9 1 ) , , , ,
(p0 p1 p2 p3 p4 p0 p1 p2 p3 p4 10
f ′ ′ ′ ′ ′ = ′ + ′+ ′ + ′+ ′ as the desired
weighted-sum function Eq. (4.1) to extract embedded data from each stego-block )
,..., ,
(p0′ p1′ p4′ . Of course, since (1, c1,...,cz-1)=(1, 9, 23, 243, 324) are known, the corresponding table T can be constructed by Algorithm 4.1, and the data-embedding can be done by Algorithm 4.2 below. The optimal weights {1, c1,...,cz-1} in Table 4.2 may not be unique for each pair of m and z. For example, when m=z=6, to obtain PSNR = 53.33 dB, the readers can either use the weights (1, 2, 4, 12, 21, 28) or (1, 2, 5, 12, 20, 28) or (1, 3, 6, 12, 20, 28) or …; these optimal weights all give the predicted PSNR = 53.33 dB. Notably, there are two layers of optimization to construct Table 4.2, as listed below.
1. Inner layer: Given the z weights (c0=1, c1,…,cz−1); then, for each integer Rm∈[0,2m), find the vector
Rm
pz
p
p , ,..., )
(∆ 0∗ ∆ 1∗ ∆ ∗−1 that yields the minimal sum of squares
∑
−=
∆ ∗ 1
0
)2
(
n
i
pi
under the constraint (mod2 )
1
0
m m
n
i
i
i p R
c∆ =
∑
−=
(see Eq. (4.5)). This is resolved by dynamic programming (Algorithm 4.1).
2. Outer layer: Given a pair of values (m, z), find the z weights (1, c1,…,cz−1) which have a minimal expected value of MSE. This is resolved by an exhaustive search, and the results are listed in Table 4.2.
The details of the embedding algorithm are listed in Algorithm 4.2, which uses Algorithms
72
4.1 and 4.3 (Algorithm 4.3 is an auxiliary algorithm to handle the overflow/underflow case).
Algorithm 4.2. Main embedding algorithm.
Input: The embedded data S and host image H.
Output: A gray stego-image H'; the two values m, z and the z weights (1, c1,..., cz−1).
1. Calculate the embedding rate er= |S|/|H|, where |S| is the bit-length of S and |H| is the number of pixels of H.
2. Use the embedding rate er to look up the “Embedding rate” column in Table 4.2. Find an embedding rate er′ which is the one closest to er, but still not less than er. For er′, grab its corresponding (m, z) and the corresponding z weights (1, c1,..., cz−1) from Table 4.2.
3. For the z weights (1, c1,..., cz−1), if its table T was recorded earlier in the off-line process when Table 4.2 was constructed, then go to Step 4. Otherwise construct table T by Algorithm 4.1.
4. Let the z pixels (p0,..., pz−1) be the z not-yet-processed pixels taken from the host image H. Then let the m-bits value Bm be the m not-yet-processed bits taken from the bit stream S.
5. Calculate Rm =Bm −(1p0 +c1p1+...+cz−1pz−1) (mod2m). 6. Grab the Rm-th row
Rm
pz
p
p , ,..., )
(∆ 0∗ ∆ 1∗ ∆ ∗−1 of the table T. Calculate the z stego-pixels of the stego-image H′ by (p0′,p1′,...,p′z−1)=(p0 +∆p0∗,p1 +∆p1∗,..., pz−1 +∆p∗z−1).
7. If any stego-pixel p′ is out of boundary (<0 or ≥pi max), then re-calculate the z stego-pixels by calling the out-of-bound algorithm (Algorithm 4.3).
8. Go to step 4 if unprocessed data bits remain. Otherwise, output image H′, the values of m, z, and the z weights (1, c1,..., cz−1).
In Algorithm 4.2 above, should some of the z generated stego-pixels (p0′,p1′,...,p′z−1)in Step 6 be out of bound (i.e. <0 or ≥pmax.), then Algorithm 4.3 below is called in Step 7 of Algorithm 4.2 to re-generate (p0′,p1′,...,p′z−1) which always stay within the gray-level range [0, pmax). Here, for each pixel pi, to ensure pi+∆pi∈[0,pmax) after embedding; the formula
{
[ (mod2 ), 1] 0, 1,..., (2 1)}
min ] ,
[k j = Q k−cjl m j− +l2l= ± ± m−
Q in Eq. (4.10) is rewritten as
{
[ (mod2 ), 1] 2 0, 1,..., (2 1) with 0 max}
min ] ,
[k j Q k c l j l l l p p
Q = − j m − + = ± ± m − ≤ + j <
so that the new stego-values created by Algorithm 4.3 can stay in bound by dynamical modification according to the given host pixel values (p0, p1,..., pn−1). (In opposition, Table 4.2
73
and Algorithm 4.1 do not need any host pixel value.)
Algorithm 4.3. The out-of-bound algorithm to deal with the case when the gray value generated in Step 6 of Embedding Algorithm 5.2 is <0 or ≥pmax.
Input: Two positive integers m and z, the z weights (1, c1,..., cz−1), the z host pixels (p0, p1,...,
74
26 27 28 29 30 31 32 33 34
+1 l⇐ l end while end for end for
Rm
l⇐
for j = z−1 to 0 do ] , [ jl L p p′j ⇐ j+
) 2 (mod ]
,
[ m
jLl j c l l⇐ − end for
The extraction of the hidden data is easy; just use Algorithm 4.4 below.
Algorithm 4.4. Extraction algorithm.
Input: The stego-image H′, and the value d which indices the d-th row in Table 4.2.
Output: The embedded data S.
1. Grab z not-yet-processed pixels of the stego-image H', denote the z pixel values as )
,..., ,
(p0′ p1′ p′z−1 .
2. CalculateBm =1p0′ +c1p1′ +...+cz−1pz′−1 (mod2m), and append the m-bits value Bm to the tail of data S.
3. Go to step 1 until all pixels in stego-image H′ are processed.
Example 4.2: If (m, z) = (4, 3), and the weights are (1, c1, c2) = (1, 2, 6), then use Algorithm 4.1 to establish table T, which is shown in Table 4.1. Then use Table 4.1 throughout the embedding phase. Assume the z=3 pixels of a host block are (p0, p1, p2) = (128, 127, 125), and an m-bits secret value is Bm=(0111)2=7. Below we show how to embed 7 in the block. Firstly, calculateRm=7−(1×128+2×127+6×125)=11 (mod24) by Step 5 of Algorithm 4.2.
Since Rm=11, take from Table 4.1 the row with Rm=11, which reads )
1 , 0 , 1 ( ) , ,
(∆ 0∗ ∆ 1∗ ∆ 2∗ = −
Rm
p p
p . Finally, calculate the z=3 stego-pixels values as (p0′,p1′,p2′)
=(128+1, 127+0, 125−1)=(129, 127, 124). In the future, secret data Bm is extracted by calculating B =1×129+2×127+6×124 = 7 (mod 16). m
4.2 Experimental results
This section presents the experimental results. When data is embedded in a ht×wh host
75
image H to get its stego-image H', a PSNR value is computed to measure the quality of H'.
The definitions is
MSE PSNR p
2 max 1) log(
10 −
= where
∑∑
−=
−
=
− ′
= × 1
0 1
0
)]2
, ( ) , ( 1 wh [
i ht
j
j i H j i ht H
MSE wh .
In our first experiment, let the host image be the 512×512 gray image Lena. Let the data to be embedded be a string generated by a random number generator. Fig. 4.1 shows six stego-versions of Lena with various embedding rates. The PSNR of the experimental results is extremely close to the theoretically-predicted PSNRest values (listed in Table 4.2), which are predicted by Algorithm 4.1. Thus, the PSNR value before embedding can really be predicted by Table 4.2. The actual PSNR values are still very close to the predicted PSNR values (Table 4.2) when the image Baboon in Fig. 4.2 is used as the host image.
Table 4.3 compares ours with other papers [8-10, 35, 38, 48, 49, 51, 52]. The host image is Lena, which is a common image found in all referenced experiments. It can be seen from Table 4.3 that our method achieves competitive PSNR values for each embedding rate. When the image is Baboon, Table 4.4 again shows that ours are very competitive. Among many embedding methods, [8, 9, 35] are very competitive to ours. A comparison of the three methods [8, 9, 35] is discussed below.
The LSB Matching method given by Li et al. [9] has very good stego-image quality, but the choice of the embedding rate (bits per pixel, i.e. bpp) is very limited. [9] uses 1 bpp as the embedding rate, and it has no algorithm or experiment to deal with the case when bpp≠1 (for example, when the embedding rate is 3.5 bpp). On the contrary, our new product is an all-in-one method with competitive quality everywhere over a wide range of embedding rates, for example, from 0.5 bpp to 4 bpp. (Our embedding rates include, but are not limited to, rates which are non-integer or smaller than one). In the embedding method given by Lin et al. [35], as shown in Tables 4.3 and 4.4, although [35] can almost keep up with ours when the embedding rate is 2, 3 or 4, the method cannot compete with ours when the bpp is 1 or non-integer. For example, we lead by a difference of about 2.2 dB when the embedding rate is 1.5, and we lead by a difference of about 3.3 dB when the embedding rate is 0.5. (In fact, the method in [35] only deals with the integer embedding rate. Hence, if the specified embedding rate is a non-integer, for example, 1.5 bpp, then embed 1 bits per pixel in one half of the image, and then 2 bits per pixel in the remaining half of the image). In the embedding method of Thein and Lin [8], as shown in Tables 4.3 and 4.4, although [8] can almost keep up with ours when the embedding rate is larger than 1 bpp, the method cannot compete with ours
76
when the embedding rate is 1 or less than 1 (for example, we win by 2.2 dB when the embedding rate is 1, and we win by 3.3 dB when the bpp is 0.5). In summary, the embedding rates of our method can have a wide range of embedding rate (from 4.0 to, say, 0.5 bpp), including rates which are non-integer or even smaller than 1 bpp. For the whole range of embedding rates, our method provides competitive PSNR values. In the less-than-1-bpp case, our PSNR values are very competitive (see Tables 4.3 and 4.4).
In Tables 4.5 and 4.6, some experiments are conducted to determine the PSNR values when the embedded data is real data rather than random. The host images are {Lena, Baboon, Jet, Sailboat, Peppers, Boat, Elaine, House}, all of which are 512×512, and the embedded data is the resized images decided by the embedding rate. In Tables 4.5-4.6, the real PSNRs (using real data) and the predicted values (PSNRest) are still very close; the difference is at most 0.02 dB.
The following two experiments were also conducted to test the PSNR values of all possible weights (1, c1,…, cz−1). The host image is Lena, and the embedded data is random data. Firstly, we selected (m, z)=(5, 3) and tested the weights (1, c1, c2) for c1∈[1,2m)=[1,32) and c2 ∈[1,2m)=[1,32). The other values of c1 and c2 need not be tested because they would be normalized to the range [0, 2m) by the modulus operation (mod 2m). The cases c1=0 or c2=0 need not be considered, because they are equal to embedding m bits in z−1 pixels rather than z pixels (see Eq. (4.1), and the corresponding pixels p1 (when c1=0) or p2 (when c2=0) can be removed from Eq. (4.1)). The 31×31 PSNRest values (the 31×31 predicted PSNR values evaluated by Algorithm 4.1) were inspected for these 31×31 sets of (1, c1, c2), and the global maximum was found to have occurred eight times. More precisely, when (c1,c2) are respectively, (4,10), (4,22), (10,4), (10,28), (22,4), (22,28), (28,10), (28,22), the eight corresponding PSNRest values are all 49.087, and 49.087 is the maximum among all 31×31 PSNRest values given by Algorithm 4.1 (it should be noted that 49.087 is also the 49.09 listed in Table 4.2 if it is rounded to 4 significant digits.) Then, in Fig. 4.3, the 31×31=961 “real”
PSNR values were sketched when the random data was embedded in Lena. The maximum of the 312 =991 real PSNR values was 49.094, which occurred at the (1,c1,c2)= (1,4, 10). It should be noted that 49.094 is very close to the predictedvalue of 49.087. It should also be noted that (1,c1,c2)= (1,4, 10) happens to be the weights listed in Table 4.2. For the reader’s benefit, in Fig. 4.3, eight blue points are marked where (c1,c2) are, respectively, (4,10), (4,22), (10,4), (10,28), (22,4), (22,28), (28,10), (28,22). It can be seen that the real PSNR values at these eight theoretically-optimal points are also very high. Their actual PSNR values are at
77
least 49.081.
In the other experiment, let (m, z)=(7, 2) and test the weights (1, c1) for c1∈[1,2m)=
[1,128). The maximum of the 127 PSNRest values evaluated by Algorithm 4.1 is 37.999, which is also the 38.00 listed in Table 4.2 if it is rounded to 4 significant digits. Then, in Fig.
4.4, the 127 “real” PSNR values were sketched when random data was embedded in Lena.
The maximum of these 127 real PSNR values was 38.002, which occurred at the weight c1=116. Again, 38.002 is very close to 37.999. For the reader’s benefit, the two blue points (c1=12 and 116) were also marked in Fig. 4.4 which are the places which generate 37.999 (the maximum of PSNRest). It can be seen that the real PSNR values at these two points are also very high (one is 38.002 and the other is 37.995) From the two experiments above for real embedding, it was observed that the suggested weights listed in Table 4.2 can provide very high PSNR values (optimal or nearly optimal PSNR values, if they are compared with other weights). The real PSNR values are also very close to the predicted PSNR values listed in Table 4.2.
(a) (b) (c)
(d) (e) (f)
Fig. 4.1. The six Lena stego-images with various embedding rates. The embedding rates and the values of PSNR of the stego-images are (a): 0.5 bpp, 57.45 dB. (b): 1.0 bpp, 53.33dB. (c): 2.0 bpp, 47.30dB. (d): 3.0 bpp, 41.22 dB. (e): 3.33 bpp, 39.11dB.
(f): 4.0 bpp, 35.10 dB.
78
(a) (b) (c)
(d)
Fig. 4.2. The Baboon stego-images with various embedding rates. The embedding rates and the values of PSNR of the stego-images are (a): 1.0 bpp, 53.33 dB. (b): 2.0 bpp, 47.30 dB. (c): 3.0 bpp, 41.21 dB. (d): 4.0 bpp, 35.11dB.
Fig. 4.3. The PSNR of embedding random data in Lena, for (m, z)=(5, 3), c1∈[1,2m)= [1,32), and c2∈[1,2m) = [1,32). The real maximal PSNR for all possible combination of weights is
79
49.094 which is very close to 49.087. (The eight blue points are the places that generate
49.094 which is very close to 49.087. (The eight blue points are the places that generate