Advanced fault-tolerant visual multi-secret sharing scheme

INTRODUCTION

A secret-sharing scheme (SSS) is ideal for storing information and is highly essential for ensuring information security. The primary idea behind an SSS is that a secret is distributed among a group of participants, among whom only qualified participants can reconstruct the secret. A visual SSS (VSSS) is also crucial for information security, and its most attractive feature is that the confidential content in a secret image can be deciphered by the human visual system. Compared with an SSS, a VSSS requires no computation in the decoding phase; therefore, a VSSS is widely applicable in many fields. In 1994, Noar and Shamir ^[1] first developed the concept of visual cryptography (VC), and they demonstrated a $$ (k, n) $$ -threshold VSSS, where a secret image $$ S $$ is divided into $$ n(\geq 2) $$ image shares; each share does not reveal information about the original image. The secret image can be seen only when any $$ k(\leq n) $$ shares are stacked together.

The performance of the $$ (k, n) $$ -threshold VSSS^[1] is limited for two reasons. The first reason is pixel expansion; specifically, the size of shares is larger than the original secret images. The second reason is the necessity of a codebook, which would require additional storage space. Kafri and Keren^[2] proposed a random grid (RG)-based VSSS (RG-based VSSS) that uses the random variable mechanism and encodes a binary image into two RGs. The RG-based VSSS is not marred by the above two drawbacks affecting the $$ (k, n) $$ -threshold VSSS; therefore, the RG-based VSSS is the superior approach. Some RG-based schemes have been proposed^{[3, 4]}. Thus far, RG-based VSSS is a well-known SSS that provides this novel stacking-to-see property and prevents pixel scaling while requiring no codebook. Furthermore, Yang^[5] introduced a probabilistic model to solve the problem of pixel expansion, called probabilistic visual cryptography scheme (PVCS), in 2004. In a PVCS, the reconstruction of the image, however, is probabilistic, meaning that a secret pixel will be correctly reconstructed only with a certain probability. Since then, several studies have considered PVCS^[6-8]. However, from the quality of reconstructed image, pixel expansion, recognized region size, and image types to be considered for evaluating PVCSs and RGs, Yang et al.^[9] pointed out that RG and PVCS have no difference other than the terminology.

Encoding more than one image simultaneously is efficient with respect to time and space costs. Several studies have proposed and discussed schemes for encoding multiple images simultaneously^[10-27]. The scheme proposed by Shyu^[10] in 2009 is an extension of that proposed by Shyu^[3] in 2007, which can encode two images simultaneously. In 2008, Chen et al.^[11] proposed an RG-based visual multi-SSS (VMSSS) that entails using a rotating RG to encode two images into two shares. Furthermore, Chen et al.^[12] presented another VMSSS that can embed four secret images into two shares by using four specific angles, namely $$ 0^{\circ}, 90^{\circ}, 180^{\circ} $$ , and $$ 270^{\circ} $$ . Liu et al.^[13] adopted the idea presented by Chen et al.^[12] and proposed a scheme that can encode three images into two meaningful shares. However, in those approaches, a restraint is imposed on the shape of the input images^[11-13]; that is, only square images can be input. To ensure more flexibility regarding the size, Chang et al.^{[14, 15]} proposed RG-based VMSSSs that can encrypt rectangular images. In these schemes, the confidential content can be reconstructed when users stack two shares with a specific offset and roll them into a cylinder. In 2014, Salehi and Balafar^[16] proposed several VMSSSs that involve using a cylindrical RG. They provided two recovery operations, namely XOR and OR (the logical XOR, OR operations, or the Boolean XOR, OR operation); compared with OR, XOR produces images with superior quality after restoration^[16]. The OR operation does not require any computation during the restoration of secret images, but the XOR operation does. Furthermore, in these schemes, the distortions are fixed according to the number of input secret images. In 2015, Tsao et al.^[17] proposed an advanced VMSSS for a general access structure. In this scheme, the extraction of secret data can be prevented by stacking specific shares; however, any two shares cannot restore two different secrets. In 2016, Siva Reddy and Prasad^[18] proposed an efficient share generation scheme that ensures the recovery of multiple secrets without any losses. However, this scheme is marred by two disadvantages. One of the disadvantages is that it requires the number of shares to be three times the number of secret images. The other disadvantage is that it applies the XOR recovery operation. Some studies have also considered using XOR operation to design their schemes^{[19, 20]}.

In VC, each share can be printed on a separate transparent sheet, and each input image can be decrypted by overlapping these shares. However, if the scheme lacks fault tolerance, then the reconstructed image may have severely poor visual quality in the event of misalignment. In 2002, Nakajima and Yamaguchi^[21] proposed an enhanced VSS scheme that allows slight misalignment by reserving some space for fault tolerance. On the basis of the idea presented by Nakajima and Yamaguchi^[21], Juan et al. proposed two schemes with no pixel expansion in 2016^[22] and 2018^[23], respectively. Al-Tamimi and Gaafar^[24] designed a scheme that entails using four-pixel blocks to encrypt a secret. Although no pixel expansion occurred, they did not discuss a security analysis of their scheme. In 2016, Lin and Juan used the ideas described by Chang and Juan^[14] in 2012, and Juan et al.^[22] in 2016 to propose an advanced scheme^[25] that can encode two images into two shares, and the images can be reconstructed by stacking two imperfectly aligned shares. In the present paper, we combine the ideas presented by Chang et al.^[15] in 2018, and Juan and Chen^[23] in 2018 and propose a fault-tolerant multi-SSS that encodes more than two secret images into two shares simultaneously without pixel expansion.

The rest of this paper is organized as follows. Related work and the proposed scheme are presented in Sections 2 and 3, respectively. The experimental results are presented in Section 4. Analysis and comparisons are presented in Section 5.

RELATED WORK

In 1987, Kafri and Keren^[2] first introduced the idea of RG that can be used to classify any pixel in an image as black (opaque) or white (transparent). An imager pixel $$ S $$ is denoted as $$ {{S}(i, j)} $$ , where $$ (i, j) $$ is the pixel position in the image. We define a black pixel as $$ {{S}(i, j)}=1 $$ and a white pixel as $$ S(i, j)=0 $$ . The probability of generating a white or black pixel in an RG is the same because of the inherent random mechanism of an RG; that is, the probability is equal to $$ 1 / 2 $$ .

The transmittance of an image $$ G $$ , denoted as $$ T(G) $$ , is the ratio of the number of white pixels to all the pixels in $$ G $$ . Therefore, the transmittance of each RG is 1/2. A secret image $$ S $$ can be encrypted into two shares $$ G_1 $$ and $$ G_2 $$ , and the confidential content can be entirely restored according to the stacking rules, as presented in Table 1, where $$ p_i $$ represents a pixel in $$ G_i $$ for $$ i = 1, 2 $$ and $$ p_1 \otimes p_2 $$ represents the result of superimposing two pixels. On the basis of these definitions, three different RG algorithms were proposed by Kafri and Keren^[2], one of which (called KK1) is presented as follows. Table 2 presents the transmittance of $$ G_1 \otimes G_2 $$ in KK1.

KK1 algorithm (proposed in ^[2])

Input: secret image with size $$ {m} \times {n} $$ pixels.

Output: two cipher-shares $$ {G}_{1} $$ and $$ {G}_{2} \cdot $$

Generate an $$ {m} \times {n} {\rm{\;RG\;}} {G_{1}} $$

$$ \; \; \; \; \; \; $$ for (int $$ {i}=0 ; {i} < m ; {i}++ $$ )

$$ \; \; \; \; \; \; \; \; \; \; \; \; $$ for (int $$ j=0 ; j< {n} ; j++) $$

$$ \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; $$ if $$ ( {S}[i][j]==0) $$

$$ \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; $$ $$ {G_{2}}[ {i}][j] = {G_{1}}[ {i}][j] $$

$$ \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; $$ else

$$ \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; \; $$ $$ {G_{2}}[i][j]=1- {G_{1}}[ {i}][j] $$

Return $$ {G_{1}} $$ and $$ {G}_{2} $$

Using the basic model of VC first introduced by Noar and Shamir^[1], Nakajima and Yamaguchi^[21] proposed a fault-tolerant scheme with pixel expansion in which diamond patterns are designed for encoding; this allows slight deviations during stacking while enabling the classification of the original color of the secret image. In 2016, Juan et al.^[22] proposed a fault-tolerant scheme without pixel expansion. This scheme considers $$ u \times u $$ pixels as a unit; therefore, the images are divided into several units ($$ u = 3, 4, 5, {\rm{or\;}} 6 $$ ). During the generation of the first share, a unit is selected randomly from the design patterns in the codebook. The unit in the second share is then selected from a specific pattern according to the number of black and white pixels of the secret image. Using the patterns designed by the authors will make the algorithm fault-tolerant. Next, Juan and Chen^[23] proposed an improved algorithm to increase the value of $$ u $$ to 7 in 2018. They designed the $$ 7 \times 7 $$ patterns shown in Figure 1, which made their scheme more fault-tolerant. The transmittance of stacking results in terms of the black and white pixels is presented in Table 3. For details of these analyses, please refer to Juan and Chen's scheme^[23].

Figure 1. Designed patterns for $$ n = 7 $$ . This figure is quoted with permission from Juan and Chen^[23].

Table 3

Transmittance for $$ n = 7 $$

$$ \mathit{\boldsymbol{C}} $$	Stack	Shift 1 pixel	Shift 2 pixels	Diagonal shift 1 pixel
$$ T_W(C) $$	1/2	73/196	60/196	69/196
$$ T_B(C) $$	0	25/196	38/196	29/196

With respect to RG, Lin and Juan^[25] proposed a visual two-secret sharing scheme with no pixel expansion; the scheme has fault-tolerant mechanisms and combines the advantages of Juan et al.'s scheme^[22] and Chang and Juan's scheme^[14]. The encryption phase is divided into three parts, namely scale down, encryption, and tolerance. In the scale down part, an input image of size $$ m \times n $$ pixels is partitioned into $$ m/6 \times n/6 $$ units, where the size of each unit is $$ 6 \times 6 $$ pixels ($$ u = 6 $$ ). In the other two parts, the design patterns in Juan et al.'s scheme^[22] are used for fault tolerance, and a concept similar to that in Chang and Juan's scheme^[14] is then used for encoding. In our scheme, we set $$ u = 7 $$ and adopt the well-established design patterns in Juan and Chen's scheme^[23]to ensure misalignment tolerance. Since the transmittance of stacking results in Juan and Chen's scheme^[23] is better than those in Juan et al.'s scheme^[22], we believe that using the patterns in Juan and Chen's scheme^[23] to design our algorithm will yield better results than Lin and Juan's^[25].

For multiple-image encryption, Chen et al.^[12] proposed a scheme that encodes four secret images into two square shares. Through a rotating mechanism, the four confidential secret images can be restored by stacking one share on the other share after rotating by $$ 0^{\circ}, 90^{\circ}, 180^{\circ}, \rm { or } 270^{\circ} $$ . Some disadvantages of the mentioned scheme^[12] are as follows: the distortions are fixed, the input secret image should be a square, and the number of input secret images should be ≤ 4. To address these disadvantages, Chang et al.^{[14, 15]} proposed some advanced schemes.

We briefly introduce Chang and Juan's scheme^[14] that encodes two images into two shares. The main idea of the algorithm^[14] is as follows. Two images are divided into $$ p $$ partitions, where $$ p $$ is the positive factor of the width of the image (which can be determined by users). Every $$ 2p $$ pixels (in the same position of each subset of the partition) can be considered as a set and can be encrypted together in the next step. Next, an unencrypted pixel from one image is randomly selected to be the basis of the encoding process; subsequently, the corresponding $$ 2p-2 $$ pixels can be encrypted (one of the pixels in this set is not encrypted). In addition, two images serve as the basis alternately; therefore, the unencrypted pixel is evenly distributed into two shares in the encoding process. Finally, the steps are repeated until two cipher-shares are generated. Therefore, all the secret data are evenly encrypted into two shares.

In the $$ \operatorname{VMSSS} $$ ^[15], the input images $$ {S}_{0}, {S}_{1}, \cdots, {S}_{ {N}-1} $$ of size $$ {m} \times {n} $$ pixels are encoded into two shares $$ {G}_1 $$ and $$ {G}_2 $$ , and integer $$ {p} $$ is selected according to user requirements (must be a positive factor of the width of the image $$ {m} $$ ). Two consecutive images are randomly selected, and each set ($$ 2 p $$ pixels) is processed using Chang and Juan's scheme ^[14]. Thus, $$ {N} $$ input images are evenly selected, ensuring that each share contains the confidential data of every secret image. Figure 2 shows the main idea of how their scheme forms $$ 2p $$ pixels in $$ G_1 $$ and $$ G_2 $$ when one pixel ($$ i, j $$ ) and two consecutive secret images $$ S_A $$ and $$ S_{A + 1} $$ are randomly selected (here, we let $$ A = 1 $$ and $$ p = 4 $$ ).

Figure 2. The diagram of the processes in the encryption phase of the VMSSS^[15] for $$ A = 1 $$ and $$ p = 4 $$ .

The study by Chang et al.^[15] is an extension of Chang and Juan's scheme^[14]; the schemes proposed by both studies involve the same recovery operation. During the restoration of secret images $$ S_i $$ for $$ i = 0, 1, \cdots, N - 1 $$ , $$ G_1 $$ is horizontally shifted by $$ im/p $$ pixels and then stacked with $$ G_2 $$ . These two schemes involve shifting instead of rotating the RG to repair the shape problem of the input images and adopting $$ p $$ for adjustable distortion. The distortion ($$ DT $$ ) is defined as the ratio of the number of pixels that are not used in the encryption phase to the total number of pixels in all secret images. The distortion of the schemes in Chang and Juan's scheme^[14] and Chang et al.'s scheme^[15] can be calculated as $$ 1/(2p) $$ and $$ ([N - 2]p + 1)/(N p) $$ , respectively.

On the basis of the ideas presented in Chang et al.'s scheme^[15], and Juan and Chen's scheme^[23], we propose a more advanced scheme than Lin and Juan's scheme^[25]. Specifically, our proposed scheme uses design patterns^[23] to ensure fault tolerance and encrypts multiple secret images by shifting the RG. The scheme is introduced in detail in the next section. To make the relationship between the above schemes clearer, we list them in Table 4.

Table 4

The relationship between the proposed scheme and some related schemes

$$ \mathit{\boldsymbol{N}} $$ = the number of secret images	Has no fault-tolerant mechanisms	Has lower fault-tolerantmechanisms$$ \mathit{\boldsymbol{(n = 6)}} $$	Has higher fault-tolerantmechanisms$$ \mathit{\boldsymbol{(n = 7)}} $$
$$ N = 1 $$	Kafri and Keren[2]	Juan et al.[22]	Juan and Chen[23]
	Noar and Shamir[1]
$$ N = 2 $$	Chang and Juan[14]	Lin and Juan[25]
$$ N \geq 2 $$	Chang et al.[15]		This paper

OUR SCHEME

In this section, we describe the proposed scheme for encrypting multi-secret images by shifting RGs through a fault-tolerant mechanism. Therefore, the proposed scheme can be denoted as fault-tolerant RG-based VMSSS (FT-VMSSS).

In our scheme, there are four functions and one procedure that help us build the main algorithm. The first three functions are defined as follows. They are used below in the procedure and main algorithm.

Definition 1. $$ f_{RSP}(.): Y \leftarrow f_{R S P}(X) $$ , $$ Y $$ is the output of the function $$ f_{RSP}(.) $$ with the inputs $$ X $$ , where $$ f_{RSP}(.) $$ is randomly selecting a pixel of $$ X $$ .

Definition 2. $$ f_{R G}(.): Y \| Z \leftarrow f_{R G}(X) $$ , $$ Y $$ and $$ Z $$ are the outputs of the function $$ f_{RG}(.) $$ with the input $$ X $$ , where $$ f_{RG}(.) $$ is KK1 algorithm that inputs a pixel of the secret image, and then outputs two cipher-pixels for two shares.

Definition 3. $$ f_{\overline{RG}}(.): Z \leftarrow f_{\overline{RG}}(X, Y) $$ , $$ Z $$ is the output of the function $$ f_{\overline{RG}}(.) $$ with the inputs $$ X $$ and $$ Y $$ , where $$ f_{\overline{RG}}(.) $$ is the function according to $$ f_{RG}(.) $$ (as in Definition 2) which inputs a cipher-pixel of one share $$ Y $$ and a pixel of the secret image $$ X $$ , and then outputs the other cipher-pixel.

Figure 3 shows the model of the proposed encrypt method. The main concept of our approach is as follows: first, we divide each secret image into several blocks with pixels of size $$ 7 \times 7 $$ , thus resulting in $$ 49 $$ pixels per block. Second, we label each block as "black" or "white" according to the number of pixels in the block. If $$ > 24 $$ (half of 49) pixels in a block are black, then the block is labeled as black; otherwise, it is labeled as white. These two steps are what the function Scale-Down in the algorithm does. Then, similar to Chang et al.'s VMSSS^[15], we repeat the encryption process until two cipher-shares are generated randomly using the aforementioned step and Figure 1 (from Juan and Chen's scheme^[23]). Thus, when the images are restored, they consist of several design patterns, as presented in Figure 1. This process ensures that secret data are decipherable because of the sufficient transmittance difference, as presented in Table 3; for example, the transmittance differences are $$ 73/196 $$ and $$ 25/196 $$ in the case of "shift 1 pixel". This important step is done by Procedure E-VMSS.

Figure 3. The model of proposed encrypt method.

Therefore, using the Scale-Down function, we obtain $$ N $$ resized images $$ S_0^\prime, \ S_1^\prime, \cdots, \ S_{N-1}^\prime $$ with pixels of size $$ m/7 \times n/7 $$ from the input $$ N $$ secret images $$ S_0, S_1, \cdots, S_{N - 1} $$ with pixels of size $$ m \times n $$ . We separate the primary procedure E-VMSS into two parts. In the first part (Encrypt part), we encrypt the scaled-down images $$ S_i^\prime, \ S_{i+1}^\prime $$ into encoded contents $$ G_1^\prime $$ and $$ G_2^\prime $$ with pixels of size $$ m/7 \times n/7 $$ according to the E-VMSS. In the second part (Scale-Up part), each pixel in $$ G_1^\prime $$ and $$ G_2^\prime $$ is restored to the corresponding pattern in Figure 1 to obtain $$ G_1 $$ and $$ G_2 $$ , according to the pattern $$ X $$ randomly selected at the beginning. Then, $$ G_1 $$ and $$ G_2 $$ are obtained, which preserve the size of the input secret images, and the problem of pixel expansion is avoided. In other words, in procedure E-VMSS, we first encrypt the reduced secret images into two reduced shares (Encrypt part), and then restore the reduced shares back to the size we want, namely the size of the original secret images (Scale-Up part). Since such steps are performed pixel by pixel, the instructions of these two parts are not consecutive in procedure E-VMSS. For each pair of encrypted pixels in $$ S_i^\prime, \ S_{i+1}^\prime $$ , we first generate a pair of relative pixels in reduced shares $$ G_1^\prime $$ and $$ G_2^\prime $$ , and then use this pair of pixels to immediately restore $$ 7 \times 7 $$ pixels in shares $$ G_1 $$ and $$ G_2 $$ (with the same size as secret images $$ S_i $$ ). Therefore, the algorithm FT-VMSSS can be performed using four basic functions and one procedure; the algorithmic codes are well constructed as described in the following subsection. The related notations are listed in Table 5.

EXPERIMENTAL RESULTS

This section describes three experiments performed in this study. In the first experiment, we encoded three images into two shares, where the size of the input images was $$ 980 \times 980 $$ pixels, as presented in Figure 4A-C. By setting $$ N $$ to 3 and $$ p $$ to 7 in the FT-VMSSS algorithm, we generated two cipher-shares $$ G_1 $$ and $$ G_2 $$ , as presented in Figure 4D and E. The first secret was restored by stacking $$ G_1 $$ and $$ G_2 $$ directly. The second (third) secret was obtained by superimposing $$ G_2 $$ with $$ G_1 $$ that had being horizontally shifted by a width of $$ 1/7 (2/7) $$ to the left, as presented in Figure 4F-H. The results of imperfect stacking and one-pixel right shift are presented in Figure 4I-K. For example, when $$ G_2 $$ was stacked with $$ G_1 $$ that had shifted to the right by one pixel, the first restored image could still be obtained, as depicted in Figure 4I. The results for the other stacking cases involving misalignment and one-pixel diagonal shift are presented in Figure 4L-N.

Figure 4. Results of Experiment 1: (A-C) secret images; (D) share $$ G_1 $$ ; (E) share $$ G_2 $$ ; (F-H) restored images; (I-K) restored images (one-pixel right shift); and (L-N) restored images (one-pixel diagonal shift).

In the second experiment, four images with pixels of size $$ 980\times 980 $$ , as presented in Figure 5A and Figure 4A-C, were used, $$ N $$ was set to 4, and $$ p $$ was set to 7. The two shares $$ G_1 $$ and $$ G_2 $$ were generated after the FT-VMSS algorithm was applied, as depicted in Figure 5B and C. Perfect stacking of the reconstructed four secret images is presented in Figure 5D-G. Figure 5H-K presents the restored images for imperfect stacking (with a one-pixel right shift). Restored images for one-pixel diagonal shift are presented in Figure 5L-O.

Figure 5. Results of Experiment 2: (A) secret image; (B) share $$ G_1 $$ ; (C) share $$ G_2 $$ ; (D-G) restored images; (H-K) restored images (one-pixel right shift); and (L-O) restored images (one-pixel diagonal shift).

In the third experiment, images with pixels of size $$ {1960 \times 1400} $$ were used, as presented in Figure 6A-D. For this simulation, $$ N $$ was set to 4 and $$ p $$ was set to 20. Figure 6E and F presents the two cipher-shares generated. The first (second, third, and fourth) secrets were obtained using the decryption process described in Section 3, as indicated in Figure 6G (Figure 6H-J, respectively). Experimental results for the case of imperfect alignment and one-pixel right shift are displayed in Figure 6K-N. The results for the case of misaligned stacking and one-pixel diagonal shift are presented in Figure 6O-R.

Figure 6. Results of Experiment 3: (A-D) secret images; (E) share $$ G_1 $$ ; (F) share $$ G_2 $$ ; (G-J) restored images; (K-N) restored images (one-pixel right shift); and (O-R) restored images (one-pixel diagonal shift).

ANALYSIS AND CONCLUSIONS

In this paper, we present the design of an FT-VMSSS for sharing multiple secret images simultaneously, as described in Section 3. In the proposed scheme, multiple secrets can be embedded into two cipher shares, and the distortion is evenly distributed across the two shares.

Let $$ T_W(R) $$ be the transmittance of the area in the restored image $$ R $$ , which corresponds to the white area in the secret image and $$ T_B(R) $$ be the transmittance of the area in the restored image $$ R $$ , which corresponds to the black area in the secret images. We then recalculate the problem of transmittance because of the effect of distortion. The transmittance of the successfully encrypted part is not affected. However, the distortion part $$ [(N - 2)p + 1) / Np] $$ is not encrypted. The probability of the distortion part being black (or white) is $$ 1/2 $$ . Therefore, the transmittance of the recovered image $$ R $$ can be derived as follows, where $$ T_W(C) $$ and $$ T_B(C) $$ are described in Table 3.

Therefore, when $$ N, p \geq 1, T_{W}(R)>T_{B}(R) $$ because $$ T_{W}(C)>T_{B}(C) $$ in Table 3 (from Juan and Chen's scheme^[23]) for any stacked restored image (perfect alignment or imperfect alignment with one-pixel shift, two-pixel shift, or diagonal one-pixel shift). Thus, the white and black pixel areas in each secret image can be visually distinguished (or the information of secret images can be observed) from the restored image $$ R $$ . Conversely, $$ T\left(G_{1}\right)=T\left(G_{2}\right)=1 / 2 $$ , since any unit is randomly selected in Figure 1 for any $$ (i, j) $$ in $$ G_1^\prime $$ to construct the corresponding units of $$ G_1 $$ and $$ G_2 $$ . Thus, no information of any $$ S_i $$ for $$ i = 0, 1, \cdots, N - 1 $$ can be obtained from $$ G_1 $$ or $$ G_2 $$ individually. That means that our algorithm is correct and secure.

Through the encryption process described in Section 3 and Chang et al.'s scheme^[15], we can calculate the distortion of the restored images $$ R $$ as follows, where $$ N $$ is the number of input secret images and $$ p $$ is the specified positive factor of the width $$ m $$ of the input image.

According to our experimental results, fault-tolerant performance can permit a shift of only one pixel. Figures 7-9 indicate that, for the transmittance analysis for sharing three or four secret images, p = 7 or 20, the difference between white and black transmittance decreased gradually from the case of perfect stacking to that of imperfect stacking (but $$ T_W(R) > T_B(R) $$ in any case). Therefore, to address the fault caused by more pixel shifting, the input secret images must be set in a larger size.

Figure 7. Transmittance analysis for $$ N = 3 $$ and $$ p = 7 $$ .

Figure 8. Transmittance analysis for $$ N = 4 $$ and $$ p = 7 $$ .

Figure 9. Transmittance analysis for $$ N = 4 $$ and $$ p = 20 $$ .

Table 6 presents a comparison of the performance of our scheme and those of schemes proposed in related studies. Among the schemes proposed in related studies, those with a fault-tolerant mechanism can encrypt at most two secret images at a time, and those that can encrypt any multiple secret images lack the mechanism of fault tolerance. Our scheme is the first MVSSS to be fault-tolerant and can really encrypt any number of secret images. Therefore, compared with these schemes, our scheme is more practical.

DECLARATIONS