CN104463769A - Figure scrambling method based on 3D DFS labyrinth - Google Patents

Abstract

The present invention provides a digital scrambling method based on a 3D DFS maze. The DFS maze generation area is artificially limited in advance, so that it can be used in any artificially designated 3D closed connected area. Each node is given a unique number, which produces the arrangement of all nodes in the maze setting area. On this basis, a scrambling method based on the 3D DFS maze node update sequence and the node update sequence composite is constructed, so that all nodes can be scrambled. The scrambling method given by the present invention has universality and flexibility, and there is no restriction in the use process. It can not only be applied to the regular areas targeted by traditional scrambling methods, such as square and rectangular areas, but also to any The selected 3D closed connected irregular regions are scrambled. The invention also provides image scrambling methods for image plane cube, RGB cube and RGB channel cube.

Description

A Digital Scrambling Method Based on 3D DFS Maze

technical field

The present invention mainly relates to cross-research fields such as information security and digital signal processing, and specifically relates to a digital scrambling method based on a DFS maze generation strategy, in particular to a digital scrambling method based on a 3D DFS maze. the

Background technique

In recent years, with the development of computer and network technology, more and more images are transmitted on the network, which brings a series of security risks while providing convenience to users. Improper use and malicious tampering of images not only involve personal privacy, but also have serious negative impacts on society. The core technology to protect images is digital image encryption. the

In the field of digital image encryption, the most widely studied and flexible image encryption method is the re-encoding technology of images in the same space, that is, image scrambling technology. the

With the rapid development of computer technology, digital image scrambling technology has become the main means of digital security transmission and confidentiality. The basic idea is to transform an image into another image beyond recognition through a certain mathematical transformation, so as to play a role in the security and confidentiality of the image. the

Digital image scrambling is also a key preprocessing technology in steganography, digital watermarking, information sharing and visual cryptography. It has been widely valued by scholars at home and abroad, and has achieved fruitful research results. the

Digital image scrambling originally originated from cable TV signal encryption. Early scrambling was performed in position space to scramble image pixel positions. These scrambling methods include line inversion scrambling, line translation scrambling, line permutation scrambling, Row cycle scrambling, row component cutting scrambling, etc. With the continuous development of scrambling technology, various scrambling methods have been proposed, which can be used for both position replacement and grayscale replacement. the

The currently proposed scrambling methods mainly include: scrambling method based on discrete element sequence, scrambling method based on scanning route, scrambling method based on traversal matrix, scrambling method based on iterative function system, scrambling method based on discrete chaotic map The scrambling method, the scrambling method based on Chinese jigsaw puzzle and the scrambling method based on matrix transformation, etc. the

Although a variety of scrambling methods have been proposed, most of the traditional scrambling methods can only be used to scramble regular areas, such as square and rectangular areas, but cannot scramble any irregular area selected by the image. the

For example, the scrambling method based on Fibonacci sequence and Lucas sequence restricts the width and height of the scrambled image to Fibonacci sequence and Lucas sequence elements; the scrambling method based on SCAN language and Hilbert curve restricts the size of the scrambled image to 2 ⁿ × 2 ⁿ square image; since not all images have a knight parade path, the scrambling method based on the knight parade can only be used for images with image width and height on a specific scale; for odd-order magic squares, the scrambled image The side length is an odd number. For a double-even order magic square, the side length of the scrambled image is an integer multiple of 4; since Latin squares of any order do not exist, the scrambling method based on the Latin square can only be used to scramble the side length of the image. is an image of a specific scale, such as an image whose side length is p ⁿ and p is a prime number; for discrete Kolmogorov Flows Map and subaffine transformation, it can only be used to scramble square images; traditional matrix-based image scrambling methods, its The basic expression is X ^[i] = (AX ^[i-1] ) mod N, but since there is only one scale parameter N, it is determined that the matrix-based image scrambling method can only be used to scramble images of a specific scale, Examples include square images or scrambling the grayscale of rectangular images.

In the literature two-dimensional non-equal-length image scrambling transformation (Acta Electronics, 2007, 35 (7): 1290-1294), two-dimensional triangular mapping and its application in image scrambling (Information Technology Journal, 2008, 7 (1 ):40-47), two-dimensional dual-scale rectangular mapping and its application in image scrambling (Journal of Computer-Aided Design and Graphics, 2009,21(7):1026-1034) and multi-scale triangular mapping and its The application of scale scrambling (International Journal of Computer Applications in Technology, 2010, 38(1-3):74-85), we expand X ^[i] = (AX ^[i-1] ) modN to X ^{[i ]} = (AX ^[i-1] ) modN, where N is a scale vector composed of finite scales, the existence criterion of 2-dimensional non-equal-length transformation is proposed, the special form of 2-dimensional double-scale rectangular mapping-2-dimensional triangular mapping, As well as general construction methods for 2D dual-scale rectangular maps and multi-scale triangular maps. Although X ^[i] = (AX ^[i-1] ) mod N can be used to scramble any rectangular image, and can scramble the image position and gray level at the same time, the proposed method can only scramble the regular area and cannot Used to scramble any arbitrary selected irregular region.

The traditional maze generation method is widely used in the field of artificial intelligence and optimization computing. It is generally used for the simulation and simulation of dynamic and complex scenes. It is less involved in the field of information security. Application, 2014,34(7):1902-1908), we discussed the method of efficiently generating permutations based on the stacking order of DFS maze nodes and the row-first scanning order, and applied the maze generation method to any rectangular image encryption, but the proposed The method cannot be applied to any connected irregular closed area encryption of the image. the

Contents of the invention

The purpose of the present invention is to overcome the defects of the prior art and provide a digital scrambling method based on a 3D DFS maze, which can be used for data scrambling in 3D arbitrary connected closed areas. the

To achieve the above object, the present invention adopts the following technical solutions:

A digital scrambling method based on 3D DFS maze, comprising the following steps:

Step 1: Set the initial range of the maze S _init ＝() _m×n×l and the effective area of the maze S _maze ＝(si _,j,k ) _m×n×l , for i=0,...,m-1,j=0,...,n-1,k=0,...,l-1, if Then mark s _{i, j, k} =-1, otherwise, mark s _{i, j, k} = 0 to indicate that the node has not been visited, and if s _{i, j, k} > 0 to indicate that the node has been visited;

Step 2: For i=0,...,m-1,j=0,...,n-1,k=0,...,l-1, record s _i,j,k .d,d=0,1,2,3, 4,5 are the bottom, right, top, left, bottom and top walls of nodes s _{i,j,k in turn} , initialize s _i,j,k .d=-1,d=0,1,2,3 ,4,5, that is, all nodes within the range of S _maze are separated by walls, s _i,j,k .d=-1 means there is a wall, s _i,j,k .d=0 means no wall;

Step 3: Select the random number generator y=RG(x), set the initial value of the random number generator RG.init=seed, initialize Stack=Φ, set the node update sequence A _update =Φ;

Step 4: Random Pick x=x ₀ , y=y ₀ , z=z ₀ , mark s _{x, y, z} = 1, add ( _{x, y, z} ) of s x, y, z to the node update sequence A _update = A _update . add((x,y,z));

Step 5: If the adjacent nodes around s _x,y,z are s _{x+1,y,z ,} s _x,y+1,z ,s _{x-1,y,z ,} s _{x,y-1, z} , s _{x, y, z-1} , s _{x, y, z+1} have unvisited nodes within the range of S _maze , then randomly select 1 unvisited node, recorded as s _{x′, y′, z′} , mark the dividing wall between s _{x, y, z} and s _{x', y', z'} as 0, put s _{x, y, z} into the stack push(Stack, s _{x, y, z} ), update x =x', y=y', z=z', mark s _{x, y, z} =1, add (x, y, z) to the node update sequence A _update = A _update .add((x, y, z ));

Step 6: If s _{x, y, z} surrounding adjacent nodes s _{x+1,y,z ,} s _x,y+1,z ,s _x-1,y,z ,s _{x,y-1, z} , s _{x, y, z-1} , s _{x, y, z+1} do not have unvisited nodes within the scope of S _maze , then pop the top element of the stack as the current node, that is, s _{x, y, z} = pop (Stack);

Step 7, repeat steps 5-6 until Stack=Φ;

Step 8: Use A _update to construct the mapping relationship between all nodes in the range of S _maze =(s _i,j,k ) _m×n×l , so that S _maze =(s _i,j,k ) _m×n× All nodes in _l range are scrambled.

As a further preferred solution of the present invention, the mapping method specifically includes the following steps in the 8th step:

Step 8.1: Select an integer as the mapping offset ll, llmodA _{update.length} ≠0, standardize it to an integer within the range of (-A _{update.length} , A _{update.length} ) according to formula (1), and press formula (2 ) to calculate the index;

ll = llmodA _{update.length} (1)

$\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&CenterDot;</span>\mathrm{<span\; class="notranslate">\; length</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; <</span>\mathrm{<span\; class="notranslate">\; 0</span>}\\ \mathrm{<span\; class="notranslate">\; ll</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; ></span>\mathrm{<span\; class="notranslate">\; 0</span>}\end{array}\right.<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 2</span>}<span\; class="notranslate">\; )</span>$

Step 8.2: Copy S _init as T=(t _i,j,k ) _m×n×l ;

Step 8.3: For Assign s _{i, j, k} to t _{x, y, z} according to formula (3);

(i,j,k)=A _update (ii),ii=0,...,A _update .length-1

(x,y,z)=A _update (kk),kk=0,...,A _{update.length} -1 (3)

kk＝(ii+index)modA _{update.length}

Step 8.4: Output T=(t _i,j,k ) _m×n×l .

As a further preferred solution of the present invention, select two random number generators y=RG ₀ (x), y=RG ₁ (x), and set random initial values RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ Generating maze node update sequences separately

The mapping method in step 8 specifically includes the following steps:

Step 8.1: Input any integer as the mapping offset ll, and standardize it according to formula (4) to Integer within the range, calculate index according to formula (5);

$\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; ll</span>}{\mathrm{<span\; class="notranslate">\; mod</span>}\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 4</span>}<span\; class="notranslate">\; )</span>$

$\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&CenterDot;</span>\mathrm{<span\; class="notranslate">\; length</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; <</span>\mathrm{<span\; class="notranslate">\; 0</span>}\\ \mathrm{<span\; class="notranslate">\; ll</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; ></span>\mathrm{<span\; class="notranslate">\; 0</span>}\end{array}\right.<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 5</span>}<span\; class="notranslate">\; )</span>$

Step 8.2: Copy S _init as T=(t _i,j,k ) _m×n×l ;

Step 8.3: For $\&ForAll;(i,j,k)\&Element;A_{\mathrm{update}}^0,\&Exists;(x,\mathrm{the\; y},z)\&Element;A_{\mathrm{update}}^1,$ Assign s _{i, j, k} to t _{x, y, z} according to formula (6);

$\begin{array}{c}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; j</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; k</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; \&CenterDot;</span><span\; class="notranslate">\; \&CenterDot;</span><span\; class="notranslate">\; \&CenterDot;</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; \&CenterDot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ <span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; x</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; the\; y</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; z</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; \&CenterDot;</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ \mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; =</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}\end{array}<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 6</span>}<span\; class="notranslate">\; )</span>$

Step 8.4: Output T=(t _i,j,k ) _m×n×l .

As a further preferred solution of the present invention, when performing image scrambling, specifically include the following steps:

Step (1): Read the bit plane cube of the image to be scrambled. For an 8-bit image P ₈ , take P ₈ .W=(w _i,j,k ) _m×n×8 as S _init , for a 24-bit image Image P ₂₄ , take P ₂₄ .W=(w _i,j,k ) _m×n×24 as S _init , select a specific area on S _init as S _maze ;

Step (2): Select As the initial node of the maze, select the random number generator y=RG(x), set the initial value RG.init=seed and the mapping offset ll;

Step (3): Output the scrambled bit-plane cube. For an 8-bit image, write (w′ _i,j,k ) _m×n×8 as the scrambled image. For a 24-bit image, write ( w′ _i,j,k ) _m×n×24 is written as the scrambled image.

As a further preferred solution of the present invention, when performing image scrambling, specifically include the following steps:

Step (1): Read the bit plane cube of the image to be scrambled. For an 8-bit image P ₈ , take P ₈ .W=(w _i,j,k ) _m×n×8 as S _init , for a 24-bit image Image P ₂₄ , take P ₂₄ .W=(w _i,j,k ) _m×n×24 as S _init , select a specific area on S _init as S _maze ;

Step (2): Select As the initial node of the maze, select the random number generator y=RG ₀ (x), y=RG ₁ (x), set the initial value RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ and mapping offset volume ll;

Step (3): Output the scrambled bit-plane cube. For an 8-bit image, write (w′ _i,j,k ) _m×n×8 as the scrambled image. For a 24-bit image, write ( w′ _i,j,k ) _m×n×24 is written as the scrambled image.

As a further preferred solution of the present invention, when performing image scrambling, specifically include the following steps:

Step (1): Read the RGB cube P ₂₄ of the 24-bit image P ₂₄ to be scrambled .C=(ci _,j,k ) _m×n×3 as S _init , select a specific area on S _init as S _maze ;

Step (2): Select As the initial node of the maze, select the random number generator y=RG(x), set the initial value RG.init=seed and the mapping offset ll;

Step (3): Output the scrambled RGB cube (c′ _i,j,k ) _m×n×3 and write it as a scrambled image.

As a further preferred solution of the present invention, when performing image scrambling, specifically include the following steps:

Step (1): Read the RGB cube P ₂₄ of the 24-bit image P ₂₄ to be scrambled .C=(ci _,j,k ) _m×n×3 as S _init , select a specific area on S _init as S _maze ;

Step (2): Select As the initial node of the maze, select the random number generator y=RG ₀ (x), y=RG ₁ (x), set the initial value RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ and mapping offset volume ll;

Step (3): Output the scrambled RGB cube (c′ _i,j,k ) _m×n×3 and write it as a scrambled image.

As a further preferred solution of the present invention, when performing image scrambling, specifically include the following steps:

Step (1): Read the RGB channel cube of the 24-bit image P ₂₄ to be scrambled $P_{\mathrm{twenty\; four}}\&Center\; Dot;C_G={\left(c_{i,j,k}^G\right)}_{m\&times;\mathrm{no}\&times;8}$ and $P_{\mathrm{twenty\; four}}\&CenterDot;C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}$ make it the initial scope respectively exist Select a specific area as the valid area

Step (2): Select $\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^R\&Element;S_{\mathrm{maze}}^R,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^G\&Element;S_{\mathrm{maze}}^G,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^B\&Element;S_{\mathrm{maze}}^B$ As the initial node of the maze, select the random number generator y=RG ^R (x), y=RG ^G (x), y=RG ^B (x), and set the initial value RG ^R .init=seed ^R ,RG ^G . init=seed ^G , RG ^B .init=seed ^B and mapping offsets ll ^R , ll ^G , ll ^B ;

Step (3): output scrambled R, G, B channel cubes and Write it as a scrambled image.

As a further preferred solution of the present invention, when performing image scrambling, specifically include the following steps:

Step (1): Read the RGB channel cube of the 24-bit image P ₂₄ to be scrambled $P_{\mathrm{twenty\; four}}\&Center\; Dot;C_G={\left(c_{i,j,k}^G\right)}_{m\&times;\mathrm{no}\&times;8}$ and $P_{\mathrm{twenty\; four}}\&Center\; Dot;C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}$ make it the initial scope respectively exist Select a specific area as the valid area

Step (2): Select $\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^R,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^R\&Element;S_{\mathrm{maze}}^R,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^G,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^G\&Element;S_{\mathrm{maze}}^G,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^B,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^B\&Element;S_{\mathrm{maze}}^B$ As the initial node of the maze, choose a random number generator $\mathrm{the\; y}=R{G}_0^R\left(x\right),\mathrm{the\; y}=R{G}_1^R\left(x\right),\mathrm{the\; y}=R{G}_0^G\left(x\right),\mathrm{the\; y}=R{G}_1^G\left(x\right),\mathrm{the\; y}=R{G}_0^B\left(x\right),\mathrm{the\; y}=R{G}_1^B\left(x\right),$ set initial value ${\mathrm{RG}}_0^R.\mathrm{init}={\mathrm{seeds}}_0^R,{\mathrm{RG}}_1^R.\mathrm{init}={\mathrm{seeds}}_1^R,R{G}_0^G.\mathrm{init}={\mathrm{seeds}}_0^G,R{G}_1^G.\mathrm{init}={\mathrm{seeds}}_1^G,R{G}_0^B.\mathrm{init}={\mathrm{seeds}}_0^B,R{G}_1^B.\mathrm{init}={\mathrm{seeds}}_1^B$ and mapping offsets ll ^R , ll ^G , ll ^B ;

Step (3): output scrambled R, G, B channel cubes and Write it as a scrambled image.

The present invention is analyzed with prior art advantage:

(1) The traditional maze generation method is widely used in the field of artificial intelligence and optimization computing. It is generally used for the simulation and simulation of dynamic and complex scenes, but it is less involved in the field of information security. The traditional scrambling method generally scrambles the space It is limited to a specific scale and is used for scrambling regular areas of images, such as square images and rectangular images, and regular area encryption that is only applicable to images of specific scales. The method is not universal, and there are limitations in the implementation process. In the present invention, the traditional maze generation method is introduced into the scrambling processing method in information security, and the maze effective area S _maze constraint is added in the DFS maze generation method, so that it is only in the previously selected 3D closed connected area A maze is generated on the S _maze , and the node update order of the DFS maze is output as the node update sequence A _update to generate an arrangement, and the arrangement is used to construct the mapping relationship between all nodes, thereby scrambling all nodes.

On this basis, the present invention also provides a digital scrambling method combining node update sequence and node update sequence composite. Compared with the existing methods, the scrambling method provided by the present invention has universality and flexibility, and there is no use restriction in the use process, and it can not only be used to scramble the regular area of the traditional scrambling method, such as square and Rectangular regions can also be used for arbitrarily selected 3D arbitrarily closed connected selective regions. the

(2) The scrambling method provided by the present invention can be used alone, or iterated multiple times, and different methods can also be used in combination, and can also be combined with existing information hiding, digital watermarking, secret sharing and encryption strategies, Combining with an arbitrarily set random number generator, it provides multiple protections of different security levels for any selected 3D connected closed area data, which has high practical application value. the

(3) At the same time, the objects targeted by the present invention are not only images, but can be used for scrambling and restoring data in any closed connected region. the

Description of drawings

Fig. 1 is a specific embodiment of the present invention: method 1 a kind of flow chart of digital scrambling method based on 3D DFS maze;

Fig. 2 is a specific embodiment of the present invention: method 2 in conjunction with the digital scrambling method flowchart of specific mapping method;

Fig. 3 is a specific embodiment of the present invention: method 3 combines the digital scrambling method flowchart of another kind of mapping method;

Fig. 4 embodiment of the present invention: test image (contains 24 true-color portrait photographs and labyrinth effective area setting image and comprises pentagon, hexagon, pentagram, heart shape, lightning shape, hollow cloud figure and portrait foreground etc. Monochrome images, where black is the effective area of the maze, and the resolution of all images is 80×60);

Figure 5 is a traditional DFS maze method to generate an 80×60 maze;

Fig. 6 is that the present invention adds the maze that the DFS maze method of effective area restriction to traditional DFS maze method generates (with the portrait foreground area in Fig. 4 as setting area, the 3rd dimension of 3D maze is set as 2);

Fig. 7 Embodiment of the present invention: the arrangement produced by the pentagon setting area in Fig. 4 is arranged by the first 30 elements produced by the DFS maze method in method 1;

Fig. 8 embodiment of the present invention: taking 5 * 2 * 3 mazes as an example verification method 2 (original matrix, maze generation arrangement, positive mapping, inverse mapping, scrambling matrix and recovery matrix);

Fig. 9 embodiment of the present invention: taking 5 × 2 × 3 maze as an example verification method 3 (original matrix, maze generation arrangement 1, maze generation arrangement 2, forward mapping, inverse mapping, scrambling matrix and recovery matrix);

Fig. 10 this method embodiment: based on the test example in Fig. 4 to the verification pattern of method 4;

Fig. 11 Embodiment of this method: the verification pattern of method 5 based on the test example in Fig. 4;

Fig. 12 Embodiment of this method: the verification pattern of method 6 based on the test example in Fig. 4;

Fig. 13 embodiment of this method: the verification pattern of method 7 based on the test example in Fig. 4;

Figure 14 Embodiment of this method: the verification pattern of method 8 based on the test example in Figure 4;

Fig. 15 Embodiment of this method: a verification pattern for method 9 based on the test example in Fig. 4 . the

Detailed ways

The method of the present invention is described in detail below in conjunction with the specific embodiment of accompanying drawing:

The DFS maze generation strategy is a typical maze generation strategy. The traditional DFS maze starts from any node on the m×n scale grid to generate a maze that connects all network nodes and has complex circuitous passages. the

The classic DFS maze generation method is widely used in the field of artificial intelligence and optimization computing, and is generally used for simulation and simulation of dynamic and complex scenes, but it is less involved in the field of information security. the

The present invention artificially limits the DFS maze generation area in advance, and the DFS generation maze can not only be applied to regular areas, such as square areas and rectangular areas, but also can be applied to any artificially designated areas, such as 3D closed connected areas. Each node in the limited area of the maze is assigned a unique number according to the update sequence of the maze nodes, thus an arrangement can be generated, and the mapping relationship between all nodes is constructed by using the arrangement, so that all nodes are scrambled. the

A kind of digital scrambling method based on 3D DFS maze of the present invention (recorded as method 1) specific steps are as follows:

Step 1: Set the initial range of the maze as S _init = () _m×n×l and the effective area of the maze S _maze =(si _,j,k ) _m×n×l , for i=0,...,m-1,j=0,...,n-1,k=0,...,l-1, if Then mark s _{i, j, k} =-1, otherwise, mark s _{i, j, k} = 0 to indicate that the node has not been visited, and if s _{i, j, k} > 0 to indicate that the node has been visited;

Step 2: For i=0,...,m-1,j=0,...,n-1,k=0,...,l-1, record s _i,j,k .d,d=0,1,2,3, 4,5 are the bottom, right, top, left, bottom and top walls of nodes s _{i,j,k in turn} , initialize s _i,j,k .d=-1,d=0,1,2,3 ,4,5, that is, all nodes within the range of S _maze are separated by walls, -1 means that there is a wall, and 0 means that there is no wall;

Step 3: Select a specific random number generator y=RG(x), set the initial value of the random number generator RG.init=seed, initialize the stack Stack=Φ, set the node update sequence A _update =Φ;

Step 4: Random Pick x=x ₀ , y=y ₀ , z=z ₀ , mark s _{x, y, z} =1, add (x, y, z) to the node update sequence A _update ＝A _update .add((x, y, z));

Step 5: If the adjacent nodes around s _x,y,z are s _{x+1,y,z ,} s _x,y+1,z ,s _{x-1,y,z ,} s _{x,y-1, z} , s _{x, y, z-1} , s _{x, y, z+1} have unvisited nodes within the range of S _maze , then randomly select 1 unvisited node, recorded as s _{x′, y′, z′} , mark the dividing wall between s _{x, y, z} and s _{x', y', z'} as 0, put s _{x, y, z} into the stack push(Stack, s _{x, y, z} ), update x =x', y=y', z=z', mark s _{x, y, z} =1, add (x, y, z) to the node update sequence A _update = A _update .add((x, y, z ));

Step 6: If s _{x, y, z} surrounding adjacent nodes s _{x+1,y,z ,} s _x,y+1,z ,s _x-1,y,z ,s _{x,y-1, z} , s _{x, y, z-1} , s _{x, y, z+1} do not have unvisited nodes within the scope of S _maze , then pop the top element of the stack as the current node, that is, s _{x, y, z} = pop (Stack)

Step 7, repeatedly execute steps 5-6 until Stack=Φ, and output A _update ;

Step 8: Use A _update to construct the mapping relationship between all nodes in the range of S _maze =(s _i,j,k ) _m×n×l , so that S _maze =(s _i,j,k ) _m×n All nodes within the range of _×l are scrambled.

A _update (0) in method 1 of the present invention is the first element in the sequence, which is the initial node of the maze, and A _update .length is equivalent to the number of all nodes in the effective area of the maze. For the same S _maze , input different Different selections of y=RG(x) and RG.init will produce different A _update .

Combining the above methods and different mapping methods to obtain scrambling methods for arbitrary closed connected regions, such as method 2 and method 3. the

Method 2 is based on the scrambling method of 3D DFS maze node update sequence, including the following steps:

Step 1: Set S _init = () _m×n×l and S _maze =(si _,j,k ) _m×n×l , for …,m-1,j=0,…,n-1,k=0,…,l-1, if s _i,j,k ∈S _maze , then the initial s _i,j,k =0, otherwise Mark s _{i, j, k} =-1, copy S _init as T=(t _{i, j, k} ) _m×n×l ;

Step 2: Pick at random As the initial node of the maze, select the random number generator y=RG(x), set the initial value RG.init=seed to generate A _update by method 1;

Step 3: Input an integer as the mapping offset ll, llmodA _{update.length} ≠0, standardize it to an integer within the range of (-A _{update.length} , A _{update.length} ) according to formula (1), and press formula (2 ) to calculate the index;

ll = llmodA _{update.length} (1)

$\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&CenterDot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; <</span>\mathrm{<span\; class="notranslate">\; 0</span>}\\ \mathrm{<span\; class="notranslate">\; ll</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; ></span>\mathrm{<span\; class="notranslate">\; 0</span>}\end{array}\right.<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 2</span>}<span\; class="notranslate">\; )</span>$

Step 4: For According to formula (3), t _{x, y, z} = s _{i, j, k} (if t _{x, y, z} = s _{i, j, k} is changed to s _{i, j, k} = t _{x, y, z} , it corresponds to the inverse transformation of method 2);

(i,j,k)=A _update (ii),ii=0,...,A _update .length-1

(x,y,z)=A _update (kk),kk=0,...,A _{update.length} -1 (3)

kk＝(ii+index)modA _{update.length}

Step 5: Output T=(t _i,j,k ) _m×n×l .

In the third step of method 2, if llmodA _{update.length} =0, it corresponds to s _i,j,k =t _i,j,k , which is a mapping from itself to itself and cannot be used for scrambling.

Method 3 is a scrambling method based on 3D DFS maze node update sequence compound, including the following steps:

Step 1: Set S _init = () _m×n×l and S _maze =(si _,j,k ) _m×n×l , for i=0,...,m-1,j=0,...,n-1,k=0,...,l-1, if s _i,j,k ∈S _maze , then initial s _i,j,k = 0, otherwise mark s _{i, j, k} =-1, copy S _init as T=(t _{i, j, k} ) _m×n×l ;

Step 2: Pick at random As the initial node of the maze, select random number generator y=RG ₀ (x), y=RG ₁ (x), set random initial value RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ according to method 1 Generating maze node update sequences separately

Step 3: Input any integer as the mapping offset ll, and standardize it according to formula (4) to Integer within the range, calculate index according to formula (5);

$\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; ll</span>}{\mathrm{<span\; class="notranslate">\; mod</span>}\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 4</span>}<span\; class="notranslate">\; )</span>$

$\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&CenterDot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; <</span>\mathrm{<span\; class="notranslate">\; 0</span>}\\ \mathrm{<span\; class="notranslate">\; ll</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; ></span>\mathrm{<span\; class="notranslate">\; 0</span>}\end{array}\right.<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 5</span>}<span\; class="notranslate">\; )</span>$

Step 4: For According to formula (6), t _{x, y, z} = _{si, j, k} (if t _{x, y, z} = si _{, j, k} is changed to si _{, j, k} = t _{x, y, z} , it corresponds to the inverse transformation of method 3);

$\begin{array}{c}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; j</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; k</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ <span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; x</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; the\; y</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; z</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; \&Center\; Dot;</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ \mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; =</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; \&Center\; Dot;</span>\mathrm{<span\; class="notranslate">\; length</span>}\end{array}<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 6</span>}<span\; class="notranslate">\; )</span>$

Step 5: Output T=(t _i,j,k ) _m×n×l .

If the same initial node of the maze is input in the second step of method 3, the same random generator is selected, and the same initial value is set, then method 3 degenerates into method 2. the

Traditional scrambling research generally focuses on digital images. A digital image is a discrete sampling of a natural image. Note that the pixel matrix of the image P is P=(p _i,j ) _m×n , and the R, G, and B channel matrices of the 24-bit image P ₂₄ are respectively P ₂₄ .R=(r _i,j ) _m×n , P ₂₄ .G＝(g _i,j ) _m×n and P ₂₄ .B＝(b _i,j ) _m×n ; record the 8-bit and 24-bit images P ₈ , and the bit-plane cubes of P ₂₄ are P ₈ .W=(w _i,j,k ) _m×n×8 and P ₂₄ .W=(w _i,j,k ) _m×n×24 ; for an 8-bit image P ₈ , the corresponding bit planes can be sequentially recorded as For a 24-bit image P ₂₄ , its corresponding bit plane can be recorded as Each bit plane is equivalent to the pixel matrix of a monochrome image; record the RGB cube corresponding to the 24-bit image P ₂₄ as P ₂₄ .C=(ci _,j,k ) _m×n×3 ; record the 24-bit image P _{The 24} corresponding RGB channel cubes are and $P_{\mathrm{twenty\; four}}\&CenterDot;C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}.$

The present invention combines method 2 and method 3 with digital scrambling methods based on 3D DFS maze update sequence and composite update sequence, and proposes six image scrambling methods, as shown in method 4 to method 9. the

Method 4. Image plane cube scrambling method based on 3D DFS maze update sequence:

Step 1: Read the bit plane cube of the image to be scrambled. For an 8-bit image P ₈ , set P ₈ .W=(w _i,j,k ) _m×n×8 as S _init , for a 24-bit image P ₂₄ , take P ₂₄ .W=(w _i,j,k ) _m×n×24 as S _init , select a specific area on S _init as S _maze ;

Step 2: Select As the initial node of the maze, select the random number generator y=RG(x), set the initial value RG.init=seed and the mapping offset ll;

Step 3: Use method 2 to output the scrambled bit plane cube. For an 8-bit image, write (w′ _i,j,k ) _m×n×8 as the scrambled image. For a 24-bit image, write (w′ _i,j,k ) _m×n×24 is written as the scrambled image (if the method 2 in step 3 is changed to the inverse transformation of method 2, it corresponds to the inverse transformation of method 4).

Method 5 Based on the 3D DFS maze update sequence compound image plane cube scrambling method:

Step 1: Read the bit plane cube of the image to be scrambled. For an 8-bit image P ₈ , set P ₈ .W=(w _i,j,k ) _m×n×8 as S _init , for a 24-bit image P ₂₄ , take P ₂₄ .W=(w _i,j,k ) _m×n×24 as S _init , select a specific area on S _init as S _maze ;

Step 2: Select As the initial node of the maze, select the random number generator y=RG ₀ (x), y=RG ₁ (x), set the initial value RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ and mapping offset volume ll;

Step 3: Use method 3 to output the scrambled bit plane cube. For an 8-bit image, write (w′ _i,j,k ) _m×n×8 as the scrambled image. For a 24-bit image, write (w′ _i,j,k ) _m×n×24 is written as the scrambled image (if the method 3 in step 3 is changed to the inverse transformation of method 3, it corresponds to the inverse transformation of method 5).

Method 6 Image RGB cube scrambling method based on 3D DFS maze update sequence:

Step 1: Read the RGB cube P ₂₄ of the 24-bit image P ₂₄ to be scrambled. C=(c _i,j,k ) _m×n×3 as S _init , select a specific area on S _init as S _maze ;

Step 2: Select As the initial node of the maze, select the random number generator y=RG(x), set the initial value RG.init=seed and the mapping offset ll;

Step 3: Use method 2 to output the scrambled RGB cube (c′ _i,j,k ) _m×n×3 , and write it as a scrambled image (if method 2 in step 3 is changed to method 2 inverse transformation, it corresponds to the inverse transformation of method 6).

Method 7 is based on the image RGB cube scrambling method based on the 3D DFS maze update sequence, comprising the following steps:

Step 1: Read the RGB cube P ₂₄ of the 24-bit image P ₂₄ to be scrambled. C=(c _i,j,k ) _m×n×3 as S _init , select a specific area on S _init as S _maze ;

Step 2: Select As the initial node of the maze, select the random number generator y=RG ₀ (x), y=RG ₁ (x), set the initial value RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ and mapping offset volume ll;

Step 3: Use method 3 to output the scrambled RGB cube (c′ _i,j,k ) _m×n×3 , and write it as a scrambled image (if the method 3 in step 3 is changed to method 3 inverse transformation, it corresponds to the inverse transformation of method 7).

Method 8. Image R, G, B channel cube scrambling method based on 3D DFS maze update sequence:

Step 1: Read the RGB channel cube of the 24-bit image P ₂₄ to be scrambled $P_{\mathrm{twenty\; four}}\&CenterDot;C_G={\left(c_{i,j,k}^G\right)}_{m\&times;\mathrm{no}\&times;8}$ and $P_{\mathrm{twenty\; four}}\&Center\; Dot;C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}$ treat them as exist Select a specific area as

Step 2: Select $\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^R\&Element;S_{\mathrm{maze}}^R,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^G\&Element;S_{\mathrm{maze}}^G,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^B\&Element;S_{\mathrm{maze}}^B$ As the initial node of the maze, select the random number generator y=RG ^R (x), y=RG ^G (x), y=RG ^B (x), and set the initial value RG ^R .init=seed ^R ,RG ^G . init=seed ^G , RG ^B .init=seed ^B and mapping offsets ll ^R , ll ^G , ll ^B ;

Step 3: Use method 2 to output scrambled R, G, B channel cubes and Write it as a scrambled image (if the method 2 in step 3 is modified to the inverse transformation of method 2, it corresponds to the inverse transformation of method 8).

Method 9 Based on the 3D DFS maze update sequence compound image R, G, B channel cube scrambling method:

Step 1: Read the RGB channel cube of the 24-bit image P ₂₄ to be scrambled $P_{\mathrm{twenty\; four}}\&CenterDot;C_G={\left(c_{i,j,k}^G\right)}_{m\&times;\mathrm{no}\&times;8}$ and $P_{\mathrm{twenty\; four}}\&CenterDot;C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}$ treat them as exist Select a specific area as

Step 2: Select $\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^R,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^R\&Element;S_{\mathrm{maze}}^R,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^G,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^G\&Element;S_{\mathrm{maze}}^G,\&ForAll;{\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^B,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^B\&Element;S_{\mathrm{maze}}^B$ As the initial node of the maze, choose a random number generator $\mathrm{the\; y}=R{G}_0^R\left(x\right),\mathrm{the\; y}=R{G}_1^R\left(x\right),\mathrm{the\; y}=R{G}_0^G\left(x\right),\mathrm{the\; y}=R{G}_1^G\left(x\right),\mathrm{the\; y}=R{G}_0^B\left(x\right),\mathrm{the\; y}=R{G}_1^B\left(x\right),$ set initial value ${\mathrm{RG}}_0^R.\mathrm{init}={\mathrm{seeds}}_0^R,{\mathrm{RG}}_1^R.\mathrm{init}={\mathrm{seeds}}_1^R,R{G}_0^G.\mathrm{init}={\mathrm{seeds}}_0^G,R{G}_1^G.\mathrm{init}={\mathrm{seeds}}_1^G,R{G}_0^B.\mathrm{init}={\mathrm{seeds}}_0^B,R{G}_1^B.\mathrm{init}={\mathrm{seeds}}_1^B$ and mapping offsets llR, llG, llB;

Step 3: Use method 3 to output scrambled R, G, B channel cubes Write it as a scrambled image (if the method 3 in step 3 is modified to the inverse transformation of method 3, it corresponds to the inverse transformation of method 9).

The method of the present invention is described in detail below in conjunction with the specific embodiment of accompanying drawing:

Taking Delphi XE5 as a case implementation environment, the embodiment of the present invention is described in detail in conjunction with the accompanying drawings, but not limited to this implementation case, wherein Fig. 1 is a flow chart of method 1, Fig. 2 is a flow chart of method 2, and Fig. 3 is a flow chart of method 3 picture. the

Referring to Figure 1, the process is as follows:

Step 1: Assume that the initial range of the maze is set to S _init = () _3×3×2 , and the effective area of the maze S _maze =( _si,j,k ) _m×n×l is set to the upper left corner of S _init 2× In the 2×2 grid area, then:

${\mathrm{<span\; class="notranslate">\; S</span>}}_{\mathrm{<span\; class="notranslate">\; maze</span>}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; k</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; )</span>}<span\; class="notranslate">\; =</span>\left[\begin{array}{ccc}\mathrm{<span\; class="notranslate">\; 0</span>}& \mathrm{<span\; class="notranslate">\; 0</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ \mathrm{<span\; class="notranslate">\; 0</span>}& \mathrm{<span\; class="notranslate">\; 0</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\end{array}\right]<span\; class="notranslate">\; ,</span>$ ${\mathrm{<span\; class="notranslate">\; S</span>}}_{\mathrm{<span\; class="notranslate">\; maze</span>}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; k</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; )</span>}<span\; class="notranslate">\; =</span>\left[\begin{array}{ccc}\mathrm{<span\; class="notranslate">\; 0</span>}& \mathrm{<span\; class="notranslate">\; 0</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ \mathrm{<span\; class="notranslate">\; 0</span>}& \mathrm{<span\; class="notranslate">\; 0</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}& <span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\end{array}\right]$

Wherein, S _{maze (k=0)} represents the maze setting area when k=0, and S _{maze (k=1)} represents the maze setting area when k=1;

Step 2: For i=0,...,2,j=0,...,2,k=0,1, initialize s _i,j,k .d=-1,d=0,1,2,3,4,5 and since s _0,0,0 ,s _0,1,0 ,s _1,0,0 , _s 1,1,0 ,s _0,0,1 ,s _0,1,1 ,s _1,0,1 ,s _1,1,1 ∈ S _maze , so (i,j,k)={(0,0,0),(0,1,0),(1,0,0),(1,1,0) ,(0,0,1),(0,1,1),(1,0,1),(1,1,1)}, after the above processing, the initial maze is equivalent to Table 1 (main diagonal direction Dashed lines represent 4-direction walls, diagonal dotted lines represent 5-direction walls):

Table 1

Step 3: Select y=RG(x), set the initial value RG.init=seed, here take the Delphi XE5 linear congruential generator as an example, the random initial value of the linear congruential generator is randseed, which can be set For different integers, different random number generators will generate different pseudo-random numbers, thus generating different mazes, corresponding to different maze arrangements;

Step 4: Select x=x ₀ , y=y ₀ , z=z ₀ , initialize Stack=Φ and node update sequence A _update =Φ, where s _0,0,0 is the initial node of the maze, then x=0,y=0, z=0, mark s _0,0,0 =1, that is, s _0,0,0 has been visited, then the current maze is equivalent to Table 2;

Table 2

Step 5: If the adjacent nodes around s _x,y,z are s _{x+1,y,z ,} s _x,y+1,z ,s _{x-1,y,z ,} s _{x,y-1, z} , s _{x, y, z-1} , s _{x, y, z+1} have unvisited nodes within the range of S _maze , then randomly select 1 unvisited node s _{x′, y′} from the random number generator _,z′ , where the adjacent nodes of s _0,0,0 are s _1,0,0 ,s _0,1,0 ,s _0,0,1 and s _1,0,0 ＝0,s _{0,1, 0} ＝0 and s _0,0,1 ＝0, if s _1,0,0 is selected, then x′=1, y′=0, z′=0, s _{x, y, z} and s _x′, The dividing wall between _{y', z'} is marked as 0, push s _{x, y, z} into the stack (Stack, s _{x, y, z} ), update x=x', y=y', z=z' , mark s _{x, y, z} = 1, add (x, y, z) to the node update sequence A _update = A _update .add((x, y, z)), here delete s _{0, 0, 0} and s The partition wall between _1,0,0 , mark s _1,0,0 =1, put s _0,0,0 into the stack, then Stack=[s _0,0,0 , A _update =<(0,0 ,0)>, the current maze is equivalent to Table 3:

table 3

Step 6, if the adjacent nodes around s _x,y,z s _{x+1,y,z ,} s _x,y+1,z ,s _{x-1,y,z ,} s _{x,y-1, If} there is no unvisited node within the scope of S _maze , the top element of the stack is taken out of the stack as the current node, assuming Stack=[s _0,0,0 ,s _1,0,0 , at this time s _1,0,0 is The top element of the stack, then s _1,0,0 is popped out of the stack as s _x,y,z , at this time Stack=[s _0,0,0 ;

Step 7: Repeat Steps 5-6 until Stack=Φ, and output A _update , so that all nodes S _maze =(si _,j,k ) _m×n×l can be arranged in update order.

Since the traditional DFS maze generation method often does not limit the maze generation area, the generated maze is often a regular area maze, as shown in Figure 5; Figure 6 is the generation of the traditional DFS maze generation method with the portrait foreground in Figure 4 as the set area. 3D connected closed area maze, the third dimension l takes 2 (because the image itself is a 2D image, so in the present invention there is no complicated 3D verification example, only the third dimension l is simply set to 2, wherein the gray square indicates the top or There is only one wall at the bottom, the black square indicates that there are walls at the bottom and the top, the white indicates that there is no wall, and the black line indicates that there is a wall); Fig. 7 is generated according to method 1 by setting the area with the pentagon in Fig. 4 (1 is taken as 8) Arrange the corresponding first 30 elements. the

Referring to Figure 2, the process is as follows:

Step 1: Assuming that S _init is set as the 5×2×3 matrix corresponding to Figure 8a (the 0th row is the x coordinate, the 1st row is the y coordinate, the 2nd row is the z coordinate, and the 3rd row is the matrix element value), set S _maze is set to the entire area of S _init , then S _maze =(0) _5×2×3 , copy S _init as T=(t _i,j,k ) _5×2×3 , then T=(t _{i,j , k} ) _5×2×3 corresponds to the matrix in Figure 8a;

Step 2: Assume that the A _update generated by method 1 is as shown in Figure 8b, the 0th line in Figure 8b is the x coordinate, the 1st line is the y coordinate, the 2nd line is the z coordinate, and the 3rd line is the node in A _update serial number;

The 3rd step: suppose input ll=3, then get ll=3mod 30=3 by formula (1) and formula (2), because ll>0, so index=3;

Step 4: By A _update and index=3, the mapping rule constructed by formula (3) can be described as Figure 8c, the first 3 lines correspond to (x, y, z), and the last 3 lines correspond to (i, j, k), the equivalent inverse mapping can be described as Figure 8d, the first 3 lines correspond to (i, j, k), and the last 3 lines correspond to (x, y, z), then according to formula (3) can be Fig. 8a is scrambled into Fig. 8e, then Fig. 8e can be scrambled into Fig. 8f according to the inverse mapping corresponding to formula (3), and Fig. 8a and Fig. 8f are equivalent, that is, the matrix after scrambling can be completely recovered;

Step 5: Output the mapped result T=(t _i,j,k ) _5×2×3 .

Referring to Figure 3, the process is as follows:

Step 1: Assuming that S _init is set to the corresponding 5×2×3 matrix in Figure 9a, and S _maze is set to the entire area of S _init , then S _maze =(0) _5×2×3 , and S _init is copied as T=(t _i,j,k ) _5×2×3 , then T=(t _i,j,k ) _5×2×3 corresponds to the matrix in Figure 9a;

Step 2: Assume the generated by method 1 As shown in Figures 9b and 9c, the 0th row of Figure 9b and 9c is the x coordinate, the 1st row is the y coordinate, the 2nd row is the z coordinate, and the 3rd row is respectively The node number in ;

The 3rd step: suppose input ll=3, then get ll=3mod 30=3 by formula (4) and formula (5), because ll>0, so index=3;

Step 4: by and index=3, the mapping rule constructed by formula (6) can be described as Figure 9d, the first 3 lines correspond to (x, y, z), and the last 3 lines correspond to (i, j, k), which is equivalent to The inverse mapping of can be described as Figure 9e, the first 3 lines correspond to (i, j, k), and the last 3 lines correspond to (x, y, z), then according to formula (6), Figure 9a can be scrambled into Figure 9f , then according to the inverse mapping corresponding to formula (6), Figure 9f can be scrambled into Figure 9g, and Figure 9a and Figure 9g are equivalent, that is, the matrix after the scrambling can be completely restored;

Step 5: Output the mapped result T=(t _i,j,k ) _5×2×3 .

Method 4 is to use the plane cube of the image to be scrambled as S _init , select a specific area on S _init as S _maze , and apply method 2 on this basis to scramble the results. Figures 10a-10g are based on Figures 4b-4h The test case verifies the result of method 4, and Figure 10h corresponds to the recovery result.

Method 5 is to use the plane cube of the image to be scrambled as S _init , select a specific area on S _init as S _maze , and apply method 3 on this basis to scramble the results. Figures 11a-11g are based on Figures 4b-4h The test case verifies the result of method 5, and Figure 11h corresponds to the recovery result.

Method 6 is to use the RGB cube P ₂₄ .C=( _ci,j,k ) _m×n×3 of the 24-bit image P ₂₄ to be scrambled as S _init , select a specific area on S _init as S _maze , where Based on the scrambling results of method 2, Figures 12a to 12g are the results of verifying method 6 using Figures 4b to 4h as test cases, and Figure 12h corresponds to the recovery results.

Method 7 is to use the RGB cube P ₂₄ .C=( _ci,j,k ) _m×n×3 of the 24-bit image P ₂₄ to be scrambled as S _init , select a specific area on S _init as S _maze , where Based on the results of method 3 scrambling, Figures 13a to 13g are the results of verifying method 7 with Figures 4b to 4h as test cases, and Figure 13h corresponds to the recovery results.

Method 8 is to scramble the RGB channel cube of the 24-bit image P ₂₄ and respectively as exist Select a specific area as On this basis, the scrambling results of method 2 are applied. Figures 14a-14g are the results of verifying method 8 using Figures 4b-4h as test cases, and Figure 14h corresponds to the recovery results.

Method 9 is to scramble the RGB channel cube of the 24-bit image P ₂₄ $P_{\mathrm{twenty\; four}}\&CenterDot;C_G={\left(c_{i,j,k}^G\right)}_{m\&times;\mathrm{no}\&times;8}$ and $P_{\mathrm{twenty\; four}}\&Center\; Dot;C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}$ respectively as exist Select a specific area as On this basis, the scrambling results of method 3 are applied. Figures 15a-15g are the results of verifying method 9 with Figures 4b-4h as test cases, and Figure 15h corresponds to the recovery results.

Claims (9)

1. A digital scrambling method based on 3D DFS maze, it is characterized in that comprising the following steps: Step 1: Set the initial range of the maze S _init ＝() _m×n×l and the effective area of the maze S _maze ＝(si _,j,k ) _m×n×l , for ${\&ForAll;\mathrm{the\; s}}_{i,j,k},i=0,...,m-1,j=0,...,\mathrm{no}-1,k=0,...,l-1,$ like ${\mathrm{the\; s}}_{i,j,k}\&NotElement;S_{\mathrm{maze}},$ Then mark s _{i, j, k} =-1, otherwise, mark S _{i, j, k} = 0 to indicate that the node has not been visited, and if s _{i, j, k} > 0 to indicate that the node has been visited; Step 2: For ${\&ForAll;\mathrm{the\; s}}_{i,j,k}\&Element;S_{\mathrm{maze}},i=0,...,m-1j=0,...,\mathrm{no}-1,k=0,...l-1,$ Note s _{i, j, k} .d, d = 0, 1, 2, 3, 4, 5 are the bottom, right, top, left, bottom and top walls of nodes s _{i, j, k in turn} , initialize s _i,j,k .d=-1,d=0,1,2,3,4,5, that is, all nodes within the range of S _maze are separated by walls, s _i,j,k .d=-1 means There is a wall, s _i,j,k .d=0 means no wall; Step 3: Select the random number generator y=RG(x), set the initial value of the random number generator RG.init=seed, initialize the stack Stack=Φ, set the node update sequence A _update =Φ; Step 4: Random Pick Mark s _{x, y, z} = 1, add ( _{x, y, z) of S x} , y, z to the node update sequence A _update = A _update .add((x, y, z)); Step 5: If the adjacent nodes around s _x,y,z are s _{x+1,y,z ,} s _x,y+1,z ,s _{x-1,y,z ,} s _{x,y-1, z} , s _{x, y, z-1} , s _{x, y, z+1} have unvisited nodes within the range of S _maze , then randomly select 1 unvisited node, recorded as s _{x′, y′, z′} , mark the dividing wall between s _{x, y, z} and s _{x', y', z'} as 0, put s _{x, y, z} into the stack push(Stack, s _{x, y, z} ), update x =x', y=y', z=z', mark s _{x, y, z} =1, add (x, y, z) to the node update sequence A _update = A _update .add((x, y, z )); Step 6: If s _{x, y, z} surrounding adjacent nodes s _{x+1,y,z ,} s _x,y+1,z ,s _x-1,y,z ,s _{x,y-1, z} , s _{x, y, z-1} , s _{x, y, z+1} do not have unvisited nodes within the scope of S _maze , then pop the top element of the stack as the current node, that is, s _{x, y, z} = pop (Stack); Step 7: Repeat steps 5-6 until Stack=Φ; Step 8: Use A _update to construct the mapping relationship between all nodes in the range of S _maze =(s _i,j,k ) _m×n×l , so that S _maze =(s _i,j,k ) _m×n× All nodes in _l range are scrambled. 2. the digital scrambling method based on 3D DFS maze as claimed in claim 1, is characterized in that mapping method specifically comprises the following steps in the 8th step: Step 8.1: Select an integer as the mapping offset ll, llmodA _{update.length} ≠0, standardize it to an integer within the range of (-A _{update.length} , A _{update.length} ) according to formula (1), and press formula (2 ) to calculate the index; ll = llmodA _{update.length} (1) $\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; <</span>\mathrm{<span\; class="notranslate">\; 0</span>}\\ \mathrm{<span\; class="notranslate">\; ll</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; ></span>\mathrm{<span\; class="notranslate">\; 0</span>}\end{array}\right.<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 2</span>}<span\; class="notranslate">\; )</span>$ Step 8.2: Copy S _init as T=(t _i,j,k ) _m×n×l ; Step 8.3: For Assign s _{i, j, k} to t _{x, y, z} according to formula (3); (i,j,k)=A _update (ii),ii=0,...,A _update .length-1 (x,y,z)=A _update (kk),kk=0,...,A _{update.length} -1 (3) kk＝(ii+index)modA _{update.length} Step 8.4: Output T=(t _i,j,k ) _m×n×l . 3. the digital scrambling method based on 3D DFS maze as claimed in claim 1, is characterized in that: choose two random number generators y=RG ₀ (x), y=RG ₁ (x), set random initial Values RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ respectively generate maze node update sequence The mapping method in step 8 specifically includes the following steps: Step 8.1: Input any integer as the mapping offset ll, and standardize it according to formula (4) to Integer within the range, calculate index according to formula (5); $\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; ll</span>}\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 4</span>}<span\; class="notranslate">\; )</span>$ $\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; =</span>\left\{\begin{array}{cc}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; +</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; <</span>\mathrm{<span\; class="notranslate">\; 0</span>}\\ \mathrm{<span\; class="notranslate">\; ll</span>}& \mathrm{<span\; class="notranslate">\; ll</span>}<span\; class="notranslate">\; ></span>\mathrm{<span\; class="notranslate">\; 0</span>}\end{array}\right.<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 5</span>}<span\; class="notranslate">\; )</span>$ Step 8.2: Copy S _init as T=(t _i,j,k ) _m×n×l ; Step 8.3: For Assign s _{i, j, k} to t _{x, y, z} according to formula (6); $\begin{array}{c}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; j</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; k</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 0</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ <span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; x</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; the\; y</span>}<span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; z</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; =</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; )</span><span\; class="notranslate">\; ,</span>\mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; =</span>\mathrm{<span\; class="notranslate">\; 0</span>}<span\; class="notranslate">\; ,</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; .</span><span\; class="notranslate">\; ,</span>{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}<span\; class="notranslate">\; -</span>\mathrm{<span\; class="notranslate">\; 1</span>}\\ \mathrm{<span\; class="notranslate">\; kk</span>}<span\; class="notranslate">\; =</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; i</span>}<span\; class="notranslate">\; +</span>\mathrm{<span\; class="notranslate">\; index</span>}<span\; class="notranslate">\; )</span>\mathrm{<span\; class="notranslate">\; mod</span>}{\mathrm{<span\; class="notranslate">\; A</span>}}_{\mathrm{<span\; class="notranslate">\; update</span>}}^{\mathrm{<span\; class="notranslate">\; 1</span>}}<span\; class="notranslate">\; .</span>\mathrm{<span\; class="notranslate">\; length</span>}\end{array}<span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; -</span><span\; class="notranslate">\; (</span>\mathrm{<span\; class="notranslate">\; 6</span>}<span\; class="notranslate">\; )</span>$ Step 8.4: Output T=(t _i,j,k ) _m×n×l . 4. the digital scrambling method based on 3D DFS maze as claimed in claim 2, is characterized in that, when carrying out image scrambling, specifically comprises the following steps: Step (1): Read the bit plane cube of the image to be scrambled. For an 8-bit image P ₈ , take P ₈ .W=(w _i,j,k ) _m×n×8 as S _init , for a 24-bit image Image P ₂₄ , take P ₂₄ .W=(w _i,j,k ) _m×n×24 as S _init , select a specific area on S _init as S _maze ; Step (2): Select As the initial node of the maze, select the random number generator y=RG(x), set the initial value RG.init=seed and the mapping offset ll; Step (3): Output the scrambled bit-plane cube. For an 8-bit image, write (w′ _i,j,k ) _m×n×8 as the scrambled image. For a 24-bit image, write ( w′ _i,j,k ) _m×n×24 is written as the scrambled image. 5. the digital scrambling method based on 3D DFS maze as claimed in claim 3, is characterized in that, when carrying out image scrambling, specifically comprises the following steps: Step (1): Read the bit plane cube of the image to be scrambled. For an 8-bit image P ₈ , take P ₈ .W=(w _i,j,k ) _m×n×8 as S _init , for a 24-bit image Image P ₂₄ , take P ₂₄ .W=(w _i,j,k ) _m×n×24 as S _init , select a specific area on S _init as S _maze ; Step (2): Select As the initial node of the maze, select the random number generator y=RG ₀ (x), y=RG ₁ (x), set the initial value RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ and mapping offset volume ll; Step (3): Output the scrambled bit-plane cube. For an 8-bit image, write (w′ _i,j,k ) _m×n×8 as the scrambled image. For a 24-bit image, write ( w′ _i,j,k ) _m×n×24 is written as the scrambled image. 6. the digital scrambling method based on 3D DFS maze as claimed in claim 2, is characterized in that, when carrying out image scrambling, specifically comprises the following steps: Step (1): Read the RGB cube P ₂₄ of the 24-bit image P ₂₄ to be scrambled .C=(ci _,j,k ) _m×n×3 as S _init , select a specific area on S _init as S _maze ; Step (2): Select As the initial node of the maze, select the random number generator y=RG(x), set the initial value RG.init=seed and the mapping offset ll; Step (3): Output the scrambled RGB cube (c′ _i,j,k ) _m×n×3 and write it as a scrambled image. 7. the digital scrambling method based on 3D DFS maze as claimed in claim 3, is characterized in that, when carrying out image scrambling, specifically comprises the following steps: Step (1): Read the RGB cube P ₂₄ of the 24-bit image P ₂₄ to be scrambled .C=(ci _,j,k ) _m×n×3 as S _init , select a specific area on S _init as S _maze ; Step (2): Select As the initial node of the maze, select the random number generator y=RG ₀ (x), y=RG ₁ (x), set the initial value RG ₀ .init=seed ₀ , RG ₁ .init=seed ₁ and mapping offset volume ll; Step (3): Output the scrambled RGB cube (c′ _i,j,k ) _m×n×3 and write it as a scrambled image. 8. the digital scrambling method based on 3D DFS maze as claimed in claim 2, is characterized in that, when carrying out image scrambling, specifically comprises the following steps: Step (1): Read the RGB channel cube of the 24-bit image P ₂₄ to be scrambled $P_{\mathrm{twenty\; four}}.C_G={\left(c_{i,j,k}^G\right)}_{m\&times;\mathrm{no}\&times;8}$ and $P_{\mathrm{twenty\; four}}.C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}$ make it the initial scope respectively exist Select a specific area as the valid area Step (2): Select As the initial node of the maze, select the random number generator y=RG ^R (x), y=RG ^G (x), y=RG ^B (x), and set the initial value RG ^R .init=seed ^R , RG ^G . init=seed ^G , RG ^B .init=seed ^B and mapping offsets ll ^R , ll ^G , ll ^B ; Step (3): output scrambled R, G, B channel cubes and Write it as a scrambled image. 9. the digital scrambling method based on 3D DFS maze as claimed in claim 3, is characterized in that, when carrying out image scrambling, specifically comprises the following steps: Step (1): Read the RGB channel cube of the 24-bit image P ₂₄ to be scrambled $P_{\mathrm{twenty\; four}}.C_G={\left(c_{i,j,k}^G\right)}_{m\&times;\mathrm{no}\&times;8}$ and $P_{\mathrm{twenty\; four}}.C_B={\left(c_{i,j,k}^B\right)}_{m\&times;\mathrm{no}\&times;8}$ make it the initial scope respectively exist Select a specific area as the valid area Step (2): Select ${\&ForAll;\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^R,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^R\&Element;S_{\mathrm{maze}}^G,{\&ForAll;\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^G{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^G{\&Element;S}_{\mathrm{maze}}^G,{\&ForAll;\mathrm{the\; s}}_{x_0,{\mathrm{the\; y}}_0,z_0}^B,{\mathrm{the\; s}}_{x_1,{\mathrm{the\; y}}_1,z_1}^B{\&Element;S}_{\mathrm{maze}}^B$ As the initial node of the maze, choose a random number generator $\mathrm{the\; y}={\mathrm{RG}}_0^R\left(x\right),\mathrm{the\; y}={\mathrm{RG}}_1^R\left(x\right),\mathrm{the\; y}={\mathrm{RG}}_0^G\left(x\right),\mathrm{the\; y}={\mathrm{RG}}_1^G\left(x\right),\mathrm{the\; y}={\mathrm{RG}}_0^B\left(x\right),\mathrm{the\; y}={\mathrm{RG}}_1^B\left(x\right),$ set initial value ${\mathrm{RG}}_0^R.\mathrm{init}={\mathrm{seeds}}_0^R,{\mathrm{RG}}_1^R.\mathrm{init}={\mathrm{seeds}}_1^R,{\mathrm{RG}}_0^G.\mathrm{init}={\mathrm{seeds}}_0^G,{\mathrm{RG}}_1^G.\mathrm{int}={\mathrm{seeds}}_1^G,$ ${\mathrm{RG}}_0^B.\mathrm{init}={\mathrm{seeds}}_0^B,{\mathrm{RG}}_1^B.\mathrm{init}={\mathrm{seeds}}_1^B$ and mapping offsets ll ^R , ll ^G , ll ^B ; Step (3): output scrambled R, G, B channel cubes and Write it as a scrambled image.