CN103942095B - Two-dimensional phase position unwrapping method based on heterogeneous accelerating platform - Google Patents

Abstract

The invention discloses a two-dimensional phase position unwrapping method based on a heterogeneous accelerating platform. Local matching is added in the Branch cut step, and the parallel realization bottleneck is overcome; the Block dynamic organizing method is adopted in the FloodFill step of the algorithm, and the data dependence problem is solved; the executing speed is increased, and the hardware resource is utilized to the maximum extent through the optimizing methods such as merging, compression storing, and data fake boundary creating. The real-time performance requirement of the two-dimensional phase unwrapping algorithm is met, and certain guiding significance is provided for parallel programming and data dependence overcoming.

Description

A 2D Phase Unwrapping Method Based on Heterogeneous Acceleration Platform

technical field

The invention relates to the fields of computer vision and image processing, in particular, the invention relates to an accelerated two-dimensional unwrapping method based on a heterogeneous acceleration platform.

Background technique

Many applications require phase data, such as microscopic interferometry, synthetic aperture radar (SAR), magnetic resonance imaging (MRI), and adaptive optics. The arctangent function is generally used to calculate the phase, and its value range is (-π, π), so the calculated phase is limited to (-π, π), and the directly calculated phase is "truncated" (also known as To be "wrapped" or "wrapped", wrapped). In the actual process, the truncated (wrapped) phases must be connected, that is, the phase "truncation" is released, and the wrapped phases are restored to the actual phase value. This process is called phase unwrap (unwrap), phase unwrapping or phase Expand etc.

Two-dimensional phase unwrapping (Phase unwrapping, PU) is a commonly used method in digital image processing, which is a computationally intensive and time-consuming process. There are dozens of algorithms to solve the two-dimensional unwrapping problem, mainly divided into two categories: Path following methods and Minimum-Norm methods. Path following methods mainly include Goldstein's algorithm, Quality-guided algorithm, Flynns minimum inconsistency algorithm, PCG algorithm and Multigrid algorithm. The Minimum-Norm method includes the Minimum L _p -norm algorithm, the Unweighted least-squares algorithm, and the Weighted least-squares algorithm. Among these algorithms, the Goldstein algorithm is fast in operation, simple in input, and easy to implement, and is usually used as the first choice for two-dimensional unwrapping problems.

The Goldstein algorithm is divided into three processes. First define the inconsistency points in the phase data (usually a matrix), indicating the start and end of possible discontinuous positions, marked with Residue values, and using +/-1 Residue values to represent these inconsistencies and their attributes. Then use a branch cut process to connect the points of opposite polarity to form possible inconsistencies. This operation constitutes a barrier in the image to prevent the passage of the propagation path during the unwrapping operation and prevent the propagation of local inconsistencies. Finally, a FloodFill process is used to achieve unwrapping to obtain continuous phase data.

(1) Definition of inconsistencies: Figure 2 and Equations 1 to 4 describe the process of defining inconsistencies. In Figure 2, a, b, c, and d are four adjacent phase points in the image data, and Δi represents the phase gradient, which is the value of "unwrapping" the phase difference between adjacent phases to (-π, π). First find out the four phase differences (Formula 1, δ represents the phase difference, P represents the phase), and then unwrap to the range of (-π, +π) (Formula 2, Formula 3, W is the unwrapping operation), called is the phase gradient: Δ, and finally accumulate four phase gradients (Equation 4). The phase gradient sum can be {-2π,0,2π}, that is, n in formula 4 may be {-1,0,1}, if n=1 or n=-1 means that there is a discontinuity at this point, which is Residue Points with a value other than 0.

δ _i =Ρ _i -Ρ _i-1 Formula 1

W(Ρ _i )＝Ρ _i +2k _i πk _i ∈ Z Formula 2

Δ _i =W(δ _i ) Formula 3

Formula 4

(2) Branch Cut: Figure 3 describes the "integral fence" formed during the branch cut process, which can prevent the passage of the integral path, where the black circle represents the point with a Residue value of +1, and the gray circle represents a Residue value of - 1, the arrow indicates the possible correct integration direction. For each point with a Residue value of +1 in the first step, find the nearest -1 point or boundary around it, and then these two points and all points on their connection line are cut by Branch to form a line "fence". Next, look for +1 points (or borders) around the point with a Residue value of -1.

Before the Branch cut, a preprocessing step can be added: Dipole cut to improve the processing speed. Adjacent points with Residue values of opposite polarity are called dipoles. After obtaining the Residue value, search for dipoles immediately, and mark these two points as BranchCut points.

(3) The FloodFill process is a relatively mature algorithm, which is included in many function libraries. Figure 4 describes the process of FloodFill. First select a seed point, this point must be a "good" point (cannot be cut by branch), generally choose the center of the phase matrix. Immediately, the four points (up, down, left, and right) around the seed point perform unwrapping work, and then these four points are added to the list of seed points. This is performed iteratively until all points have either been unwrapped or are BranchCut points. In Figure 4, the black points represent BranchCut points, and the gray points represent seed points or points that have been unwrapped.

In recent years, the heterogeneous acceleration platform represented by GPGPU has become an increasingly important computing trend, and its platform covers a wide range of high-performance computing, desktop computing and mobile computing. The integration of increasingly rich application fields and heterogeneous acceleration platforms can greatly improve the overall energy efficiency of the system. In particular, if the program to be developed conforms to a large-scale parallel structure, using GPU-CUDA technology can greatly improve operating efficiency. Although the Goldstein algorithm is the fastest algorithm for solving two-dimensional unwrapping, it still has a large amount of calculation and requires a long running time, which has become the bottleneck of system performance in many cases. Using GPGPU technology can improve the performance of Goldstein algorithm. However, the Branch cut step and the FloodFill step have serious data dependence, which restricts the parallelization and parallel efficiency of the algorithm. Therefore, the present invention is just an innovation aimed at the Branch cut step and the FloodFill step.

Contents of the invention

The technology of the present invention solves the problem: overcomes the shortcomings of the existing technology, provides a two-dimensional phase unwrapping method based on a heterogeneous acceleration platform, and uses the heterogeneous platform parallel acceleration processing technology to improve the real-time performance of the algorithm without reducing the accuracy , and has good scalability.

The technical solution of the present invention: a two-dimensional phase unwrapping method based on a heterogeneous acceleration platform, each step of which is implemented on the heterogeneous platform, and the steps are as follows:

(1) Define inconsistent points in the phase data on the heterogeneous acceleration platform, that is, points with a Residue value of +/-1.

(11) Divide the phase data into blocks and read them into the shared memory. Each thread in the thread group (Block) in the shared memory calculates the Residue value of a point and saves it; for the last row and the last column of each Block can follow the same According to the rule calculation, each block needs to read one more row and one column of data;

(12) After calculating the Residue value, search and match the dipole operation (Dipole cut), the dipole refers to the point adjacent to the Residue value with the opposite polarity, if the Residue value of the point is +1, look for points with opposite polarities around this point, if there are points with opposite polarities, mark these two points as BranchCut points, and mark the two corresponding Residue values as +2 or -2 respectively, Get Residue data;

(2) The process of matching inconsistent points on the heterogeneous acceleration platform, that is, the branch cut step, which is divided into two processes: local matching and global matching.

(21) First perform partial matching, divide the Residue data into blocks and read it into the shared memory, perform a Branch cut operation in each Block, and first find the nearest Residue value whose polarity is negative (-1, -2) point or data boundary, until it exceeds the search range; after the synchronization operation, go to the point with positive polarity from the point of -1, and each block reads more than N circles of Residue input data, that is, up, down, left, and right respectively. Read N lines, where N is a positive integer parameter to improve precision; if the Block has a non-zero Residue point that does not match, write the block flag (BlockFlag) as +1 or -1, and its polarity is the same as Residue The values have the same polarity;

(22) Then perform global matching. Global matching and local matching have the same thread configuration. Use one thread to read the BlockFlag flag. If the BlockFlag flag is 0, it will end. If the BlockFlag flag is not 0, it means that the Block needs to be globally Matching; during the global matching process, if the BlockFlag value is 1, find the nearest BlockFlag of -1 or the Block on the boundary, calculate the farthest distance and the shortest distance between them as the search range, and definitely find a match in this range points, get the matched BranchCut data, and BranchCut is the value of each point after the Branch cut operation;

(3) Implement the FloodFill step on the heterogeneous acceleration platform, and output the unwrapped phase data. The specific implementation is as follows:

Input the matched BranchCut data, select the seed point (what is the seed point) as the starting point in the BranchCut data, mark it as unwound, the seed point cannot be the point cut by Branch, restart the device function Kernel for a limited number of times, and use a A dynamic block organization spreads the seed state from the center to the surroundings; inside the block, each thread processes one row or one column of data at a time, and then four directions, namely, from left to right, from top to bottom, from right to Left, and from bottom to top, the unwrapping process is performed sequentially. One thread needs to be synchronized once after processing a row or a column, and the iteration stops when there are no points that need to be unwrapped in the entire block, and the phase data after unwrapping is output.

In each step, all kinds of data used and obtained in the calculation are compressed and stored to improve the operation speed.

The two steps (11) and (12) are combined, that is, they are executed in the same device function Kenel.

In the partial matching of step (21), before the Residue data is divided into blocks and read into the shared memory, a boundary is forged for the Residue data, which is called a pseudo boundary, that is, when the number of rows or columns is not a multiple of 16, it is expanded to A multiple of 16, fill the completed part with a value outside the Residue value range; in each Block, use the same method to fill N circles for the Residue data.

In step (3), the implementation process of spreading the seed state from the center to the surroundings in a dynamic block organization is as follows: divide the input matched BranchCut data into blocks of fixed size, called small_block, a Block Processing data composed of 4 adjacent small_Blocks is called a big_Block; the distribution of small_Block in big_Block is in the shape of "field"; big_Block has two different organization methods, restarting the Kernel twice in a row, and small_Block processed by the Block at the corresponding position Not exactly the same, that is, the organization of big_Block will change, so that small_Block will rotate between different big_Blocks, and some small_Blocks will be spread into another big_Block as a seed block after being wound, so that the seed state can be made from the center to the surrounding Diffusion; two flags are required in the above operation: Block_flag and Pixel_flag respectively record the state of the Block and each point, Block_flag indicates whether the small_Block has been unwrapped, and Pixel_flag indicates whether the point is unwrapped.

Inside the Block in step (3), the unwinding operation is performed in four directions from right to left, from top to bottom, from left to right and from bottom to top, and the Block_flags of the four small_Blocks are read. Not only can it be determined whether the Block is to be unwound, but also it can be determined from which corner of the big_Block the seed point is propagated, and then the order of execution in the four directions can be determined.

The beneficial effect of the present invention compared with prior art is:

(1) The present invention completely realizes the two-dimensional unwrapping method using the Goldstein algorithm on a heterogeneous platform, which significantly improves the execution speed of the two-dimensional unwrapping algorithm. When the input data size is 8192*8192 phase data, it reaches A speedup of more than 500 times was achieved.

(2) The present invention performs partial matching in the Branch cut step, confining the matching process within a certain range, so that the entire two-dimensional unwrapping process can complete parallel computing on a heterogeneous platform. D.

(3) The FloodFill step in the present invention has reached nearly 800 times of speedup, and it is also a commonly used algorithm in itself, which is included in many function libraries; the dynamic organization method in its implementation process is also very important for parallel programming and overcoming data Dependence has certain guiding value.

Description of drawings

Fig. 1 is the realization flowchart of the present invention;

Fig. 2 is the schematic diagram of defining Residue in the present invention;

Fig. 3 is the Branch Cut process schematic diagram among the present invention;

Fig. 4 is a schematic diagram of the FloodFill process in the present invention, wherein the black points represent the points located in BranchCut, the white points represent the points that need to be unwound, and the gray points represent the points that have been unwound; counting from left to right, the first The first picture is the initial state, the second picture is the state after selecting the seed point, the third picture is the state of unwrapping, and the fourth picture is the state after all unwrapping;

Fig. 5 is a schematic diagram of the dynamic organizational structure of the FloodFill process Block in the present invention, wherein the left figure is the state of the Block after selecting the seed point, and the figure is the state after completing the Kernel for the first time;

Fig. 6 is a schematic diagram of the state of a certain Block in the FloodFill process in the present invention;

Figure 7 shows the usage of shared memory after using different compression storage methods, where "None" means no compressed storage, "A" means merging input and output data, "B" means merging BranchCut and PixelFlag, and "C" means 1 byte Store intermediate variables;

Figure 8 shows the number of simultaneously activated blocks after using different compression storage methods.

detailed description

Before introducing the present invention, some basic concepts and terms are explained.

Description of technical terms and proper nouns:

GPGPU: Graphics Processing Unit General Computing Technology

Block: CUDA-specific term, representing a thread group

Kernel: CUDA-specific term, representing a device function

Phase unwrap: Phase unwrapping

Residue: Inconsistent points in phase data

Dipole: Dipole, a pair of points that are adjacent and have opposite Residue polarity.

Dipole cut: the process of dipole matching

Branch cut: the process of matching inconsistent points (two words)

BranchCut: the result obtained in the Branch cut step (one word)

FloodFill: flood filling, used in the unwrapping process in the phase unwrapping algorithm

The present invention will be described in further detail below in conjunction with the accompanying drawings and embodiments.

As shown in Figure 1, the specific implementation steps of the present invention are as follows:

The present invention is divided into three parts, all implemented in parallel on heterogeneous platforms: defining Residue and Dipole cut, Branch cut and FloodFill.

(1) Define Residue and Dipole cut.

These two processes are placed in one Kernel, which can reduce the number of times to read the global memory and improve performance. Block configuration is 16*16 threads (adjustable). The specific steps are:

(11) Read the phase data into the shared memory. Since each point needs four Phase data of itself, bottom, bottom right, and right, for the convenience of processing the boundary, each Block needs to read 17*17 Phase data, that is, read one more row and one column. Phase data can only be read but not written, and no conflicts will occur.

(12) Calculate the Residue value of a point for each thread, and define the Residue according to Figure 2 and formulas 1-4.

(13) A synchronous operation is required to ensure that all points in the Block have obtained the value of Residue.

(14) Then execute the Dipole cut operation: from the point with a value of +1 to the eight points around it, find whether there is a point of -1, if there is, match it, and mark its Residue value as 2 or -2 respectively. In the process of Dipole cut matching, it may be used again in the Branchcut step, which can improve the accuracy. Synchronize every time you look for a direction, which can avoid conflicts in the Block. Both phase data and residue data are read/written in the shared memory of the device, which greatly improves the execution speed.

(2) Branch cut step.

The process enters Residue data and reads it into shared memory. In order to solve data dependence and obtain good performance, the present invention divides this step into two processes: local matching and global matching. After the block is divided, the number of threads in the block is equal to the number of data (for example, both are 16*16).

(21) PARTIAL MATCHING. Limit the Branch cut operation to the Block so that this step can be executed in parallel. The steps are:

(211) Create a "pseudo boundary". The size of the phase data may not be an integer multiple of the block size, for example, the phase data size is 135*135 (row*column), while the block is 16*16. Since all blocks perform the same operation, the control logic of the block on the phase data boundary to the data boundary is relatively complicated, and all blocks need to perform boundary judgment operations. No boundary judgment logic is required after creating a pseudo-boundary:

Assuming that the thread configuration of Block is 16*16, and the size of phase data is Row*Column, use an unused value (such as 9) to complete the Residue data as: (16*k _r +N)*(16*k _c + N), which creates a pseudo boundary, thereby omitting the control logic of the boundary and simplifying the program. Satisfy: Row<16*k _r +0N<Row+16, Column<16*k _c +N<Column+16, where k _r and k _c are positive integers. This step can be done by directly filling in the shared memory, without increasing the size of the used device memory, and thus not increasing redundant operations. BranchCut completes in the same way.

(212) Read Residue data into shared memory. After limiting the matching range to the Block, it may generate a wrong orientation to match the "wrong" point (the best match may be in the next Block), so it is similar to the previous step, read N circles more for each Block Data, N is an integer less than 4. In the experiment, when N is 2, good results can be achieved. If it is at the data boundary Block, directly use the "pseudo-boundary method" in the previous step to complete it in the shared memory.

(213) Each thread reads the Residue value at the specified position. If it is +1, then go around to find a -1 point or data boundary (not the Block boundary, and it will not be processed after exceeding the Block boundary), and if it is 0, it will end .

(214) If found, in the matrix storing the BranchCut data, write 1 at the position corresponding to the point on the connecting line between these two points, indicating that these points are Branch cut points. And set the Residue values of these two points to +2 and -2 respectively.

(215) If not found, set the BlockFlag of the Block to +1, indicating that the Block is not completely matched.

(216) After synchronization, perform operations similar to 2.1.3-2.1.5 for the case where the Residue value is -1.

(217) Write back data. However, there may be write conflicts: when writing Branchcut data at the corresponding position of the multi-read N circle data, since adjacent blocks may write this value at the same time, it will cause write conflicts. But notice that the value of Branch cut is only written into Branch cut when the value is 0 and 1 so that the value is 1, which can solve the problem of avoiding conflicts. On the other hand, due to the speed relationship between blocks, the same conflict occurs at the corresponding position when writing the Residue value. Also, writing only to values that have changed avoids conflicts.

(22) GLOBAL MATCHING. If there are unmatched points left in Local matching (for example, the Residue points read into the Block are all +1, and these points are not matched), it will make global matching necessary, that is, to find in the entire phase data points that can match. The detailed steps are:

(221) The BlockFlag flag is read by a thread. In steps 2.1.5 and 2.1.6 of local matching, the value of BlockFlag is written, which can determine whether the Block needs to perform global matching operations. If BlockFlag is 0, then end.

(222) If the BlockFlag value is 1, then find the nearest Block with a BlockFlag of -1, or a Block on the boundary, and calculate the farthest and shortest distances between them as the search range, in which a match can definitely be found point.

(223) If the BlockFlag value is -1, the operation is similar to the previous step.

(3) FloodFill step.

The process is like throwing a stone into a lake, and then the ripples spread round and round until the lake shore. The entire lake surface is like phase data, stones are like seed points, and the propagation of ripples is the function of FloodFill. Figure 4 briefly describes this step.

(31) Organization of dynamic blocks:

The entire phase data is divided into blocks (for example, 16*16), according to the algorithm, a seed point needs to be selected, and the present invention first selects the seed point in the most middle Block. When there are already unwrapped points in a Block, this Block can be activated to perform the unwrapping operation. In this way, an important issue is how to propagate the seed state (points that have been disentangled) between Blocks and activate other Blocks for calculation.

In order to solve the propagation of the seed state, the present invention creates a dynamic organization method of Block. This mode of propagation is depicted in Figure 5. The above-mentioned block is called small_Block. A Block processes data composed of 4 adjacent small_Blocks. It may be called a big_Block. As shown in Figure 5, the thin line is divided into small_Block, and the thick line is divided into big_Block. Small_Block is in big_Block The distribution is in the shape of "Tian". big_Block has two different organization methods. If the Kernel is restarted twice in a row, the small_Block processed by the corresponding block is not exactly the same, that is, the organization method of big_Block will change. In this way, the small_Block will rotate between different big_Blocks. Some small_Blocks will be spread into another big_Block as a seed block after being unwrapped, so that the seed state can spread from the center to the surrounding.

Two flags are required: Block_flag and Pixel_flag respectively record the status of Block and each point, Block_flag indicates whether the small_Block has been unwrapped, and Pixel_flag indicates whether the point is unwrapped.

(32) Inside the Block:

In the original algorithm, it is the four-neighbor-joining method, that is, after a certain point is unwrapped, activate the upper, lower, left, and right four points, and then these four points can be unwound, but this is not conducive to parallel processing. In order to achieve smooth parallelization and achieve good results, one thread can process one row (or one column) of data at a time. For example, the previous point in the row has been unwrapped, and the point to be processed is not a BranchCut point, then the point can be Unwrapped. After a thread processes a line from left to right, it then processes it sequentially from top to bottom, right to left, and bottom to top until all points are unwrapped. A synchronization operation is required after each row is processed.

If in a Block, if each case follows the method from left to right, then from top to bottom, from right to left, and finally from bottom to top, and then iterates continuously, it may result in "empty" iterations (that is, when a row is processed, no new unwrapped points are added). In the case shown in Figure 6, three iterations are required to unwrap the entire block. But if you go from right to left, then from top to bottom, then from left to right, and finally from bottom to top, it only takes two iterations to complete. As can be seen from the Block level, the seed point can only be passed in from the four corners of the matrix, so use a flag to record the position where the seed point propagates, and select the starting direction of unwrapping according to the flag, which can greatly reduce the number of iterations and improve performance.

(4) Compressed storage

Compressed storage can save storage space, especially the space of shared storage to increase the number of blocks activated at the same time; and compressed storage can also reduce the number of memory accesses and calculations, greatly improving the performance of the program.

(41) In the present invention, the input data (phase data to be unwrapped) and the output data (phase data that has been unwrapped) use the same piece of storage, that is, the unwrapping operation is performed directly on the input data.

(42) Use only 1 byte to store intermediate data and some flags, such as using char type to store BranchCut data, BlockFlag data, etc.

(43) Merge the Branch cut data with PixelFlag, and add a value of 2 on the basis of Branch cut to indicate the meaning when PixelFlag is 1.

Since these data must be read into the shared memory when they are used, the shared memory is reduced and the number of simultaneously activated Blocks is increased by compressing the storage. Figure 7 and Figure 8 list the usage of shared memory and the number of simultaneously activated blocks after using different compression methods in the FloodFill process.

Parts not described in detail in the present invention belong to the known techniques of those skilled in the art.

Although the specific implementation methods of the present invention have been described above, those skilled in the art should understand that these are only examples, and various changes or modifications can be made to these embodiments without departing from the principle and realization of the present invention. Therefore, the protection scope of the present invention is defined by the appended claims.

Claims (6)

1. a kind of based on isomery accelerate platform two-dimensional phase unwrapping method it is characterised in that：Each step of methods described is equal Accelerate to realize on platform in isomery, realize step as follows：

(1) isomery accelerates to define inconsistent point in phase data on platform, and that is, Residue value is the point of +/- 1；

(11) phase data piecemeal, read in shared drive, each thread in sets of threads Block calculates a point Residue value, and preserve；Last column in order to ensure each Block can be according to the same rule calculating, often with last string Individual Block needs many reading a line and a column data；

(12) after obtaining Residue value, found and mated dipole child-operation (Dipole cut), described dipole is Refer to the point of Residue value that is adjacent and having opposite polarity, if the Residue value of this point is+1, find around this point Opposite polarity, if there are opposite polarity point, then this two points are labeled as BranchCut point, and a Residue value It is labeled as+2, another Residue value is labeled as -2, obtains Residue data；

(2) isomery accelerates to mate the process of inconsistent point, i.e. Branch cut step on platform, and this step is divided into two processes： Local matching and global registration；

(21) carry out local matching first, reading in shared drive after Residue deblocking, carry out in each Block Branch cut operates, first by Residue value for+1 looking for nearest Residue value polarity be bear (- 1, -2) point or Data boundary, until exceeding hunting zone；Looking for polarity by -1 point again after simultaneously operating is positive point, each Reading the Residue input data of N circle Block, i.e. each up and down many reading N row, N is a positive integer parameter, improves precision more； If the point that this Block has Residue value non-zero does not mate ,+1 or -1 is written as to mark BlockFlag of each Block, Its polarity is identical with Residue value polarity；

(22) thread configuration as and then carry out global registration, global registration is used with local matching, is read using a thread Take BlockFlag to indicate, if this BlockFlag is masked as 0, terminate；Explanation if this BlockFlag mark is not 0 This Block needs to carry out global registration；During global registration process, if BlockFlag value is+1, find nearest BlockFlag is -1 or borderline Block, calculates maximum distance between them and minimum distance as hunting zone, The sure point finding coupling in this range, the BranchCut data after being mated, BranchCut is that each point passes through Value after Branch cut operation；

(3) accelerate to realize FloodFill step, the phase data after output unwrapping on platform in isomery, be implemented as follows：

BranchCut data after input coupling, in BranchCut data, selected seed point, as starting point, is labeled as By unwrapping；Described seed point can not be by the point of Branch cut, by limited number of time restarting equipment function Kernel, with one kind The organizational form of dynamic Block spreads from center sub-states toward surrounding；Wherein inside Block, each thread is once Process a line or a column data, then four direction, that is, from left to right, from top to bottom, from right to left, enter successively from top to bottom Row unwrapping is processed, and carries out unwrapping process needs one subsynchronous, until whole Block after a thread process a row or column In do not need by when uncoiled stop iteration, output unwrapping after phase data.

2. according to claim 1 based on isomery accelerate platform two-dimensional phase unwrapping method it is characterised in that：Institute State in each step of method, the various data using and obtain all are stored using compression, to improve arithmetic speed in calculating.

3. according to claim 1 based on isomery accelerate platform two-dimensional phase unwrapping method it is characterised in that：Institute State (11) and (12) two steps merge, complete in same Kernel.

4. according to claim 1 based on isomery accelerate platform two-dimensional phase unwrapping method it is characterised in that：Institute State in the local matching of step (21), before reading in shared drive after Residue deblocking, first give Residue data pseudo- Make a border, referred to as pseudo- border, to the number of row or column be not 16 multiple when, be extended for 16 multiple, with one Value outside Residue codomain fills the part of completion；In each Block, mend N circle with same method to Residue data.

5. according to claim 1 based on isomery accelerate platform two-dimensional phase unwrapping method it is characterised in that：Described In step (3), process is realized from center toward surrounding diffusion type sub-states with a kind of organizational form of dynamic Block For：BranchCut data after input coupling is divided into the block of fixed size, referred to as small_block, a Block processes 4 The data of individual adjacent small_Block composition, referred to as one big_Block；Small_Block in big_Block point Cloth is in sphere of movements for the elephants type；Big_Block has two kinds of different organizational forms, double restarts Kernel, the Block of correspondence position The small_Blcok processing is incomplete same, and that is, the organizational form of big_Block can change, such small_Block meeting Rotation between different big_Block, some small_Block are just propagated into as seed Block after unwrapping immediately Another big_Block, thus can make sub-states spread toward surrounding from center；Two marks are needed in aforesaid operations： The state that Block_flag and Pixel_flag records Block respectively and each is put, Block_flag identifies this small_ Whether Block is twined by solution, and Pixel_flag identifies whether this point is twined by solution.

6. according to claim 5 based on isomery accelerate platform two-dimensional phase unwrapping method it is characterised in that：Described In step (3), described Block_flag can not only determine whether this Block will execute unwrapping operation and plant additionally it is possible to determine Son point is from which corner of big_Block to propagate, it is then determined that the execution sequence of four direction.