1. Imageodesy for co-seismic shift study
Sequential Run Versus Parallel Run for Imageodesy algorithm

2. Team Members Members: Supervisor: Dr.Ahmed Shawky Moussa
Shreif Mohamed Abd El- Azem
Shaimaa Mohamed
Sally Sedkey Abd El Aziz
Hazem Karam
Supervisor:
Dr.Ahmed Shawky Moussa
In Collaboration:
NARSS

3. Agenda Introduction Previous Work Project Description
The Phase Correlation Algorithm
Running of the project (Sequential Implementation)
First Parallel Implementation
Second Parallel Implementation
Statistics and Comparison
Future Work
Conclusion
Acknowledgement
Questions

4. Introduction
Geo-hazard monitoring and assessment is one of the major application research fields.
These researches takes long time so its useful to make it via distributed high throughput devices or in other words using parallel programming.
MIT university researchers worked in 2004 with a research talk about “Discovery Net Project”.

5. Introduction (Cont.) Some Definitions:
Imageodesy: technique capable of detecting changes at sub-pixel level accuracy and robust to environmental conditions.
Applications:
It can calculate the mountains fault, Lakes expansion and Avalanches and many other applications

6. Previous Work
Discovery Net Project is a co-seismic shift project to detect and measure the movement and displacement of the mountings and sand dunes to prevent the geohazrads.
They implemented three types of this application using the Imageodesy technique.
Samples of the images taken using Landsat-7 ETM+ sensor system in MIT research. We took a sample image from the NARSS .

7. The implementation Algorithm
Previous Work (Cont.)
Disadvantages
Advantages
The implementation Algorithm
NCC algorithm takes long processing time (2500 calculation times for 125 *125 Search Window).
With M*M Search Window and N*N Moving calculation window it takes:
N*N (M – N -1) power 2 additions and 2 N*N (M-N-1) power 2 multiplications.
Implement the Imageodesy algorithm using local NCC
Using one UNIX processor, it takes more than 400 hours to complete the Imageodesy algorithm on one pair images.
High computing efficiency achieved .
It takes: N*N additions and (N*N) + (N*N)(M-N-1) power 2 multiplications.
Speed up the processing by 5 to 10 times.
Sequential implementation for the Imageodesy algorithm using NFCC

8. The implementation Algorithm
Previous Work (Cont.)
Disadvantages
Advantages
The implementation Algorithm
With small searching window the Phase Correlation algorithm is better.
Didn’t support the dynamic data re-distribution.
The most efficient approach that they implemented in this time.
Using a fixed data farming and running the algorithm on 24 processors gave hours for the same dataset.
Using FNCC with MPI programming
Disappointed performance because of the demand for data communication.
Using the advantages of the shared computing resources virtually of no limit.
Using FNCC with GRID
Not operational on parallel or GRID processing node.
The process of forward and inverse FFT save the time for searching window in FNCC in small windows.
Using Phase Correlation on single UNIX processor

9. Previous Work (Cont.) Using the FNCC with MPI algorithm:
Using FNCC only: 3.7 GB dataset they run sequential version in 400 hours over one UNIX processor.
With the same dataset using FNCC with MPI, they run the program in hours over 24 fast UNIX parallel processors
The only parallel program that apply this algorithm is implemented by MIT university until now.

10. Description for the project
Our Goal:
To Implement the Imageodesy algorithm with phase correlation with sequential implementation.
To implement the Imageodesy algorithm using the phase correlation and MPI programming.
Enhance in the simple parallel idea by parallelize the part of FFT algorithm to minimize its calculation time.

11. Description for the project (Cont.)
The flow chart for our sequential program.
Figure1 Phase Correlation flowchart

12. Description for the project (Cont.)
Figure3 Sample1
Figure2 Sample1

13. Steps of Phase Correlation Algorithm
1-Reading two image in different times with the same Landsat-7 sensor (We have the samples from NARSS).
2-Apply filter technique to improve the image quality and removing the noise (Hamming Window).
3-Apply Fast Fourier Transform(FFT) on the both images.
4-Run the phase correlation and compute the shift in coordinates.

14. 1-Reading two images in different times.
The first step we need to represent the images by matrix to start running the algorithm on it we read the pixel with three values (R, G, B).
We use a pre-created library “tiffio.h” for reading the images.
Note:
the time of reading the images part of the whole time of the algorithm running.

15. 2-Apply filter technique to improve the image.
Filters is used to improve images before using it to enhance its quality and to make result more reliable.
Using hamming window we need to delete noises in the input image and delete the small peaks(details) where it is supposed to be noise.

16. 2-Apply filter technique to improve the image (Cont.)
Figure4 Hamming Window

17. 3-Apply Fast Fourier Transform(FFT).
FFT make Fast Fourier Transform for the image after making hamming to work in real data to get accurate correlation from it.
We used the FFTW library that the MIT used it in their implementation to apply the forward and the backward transformation.

18. 4-Run the phase correlation and compute the shift in coordinates.
After running the Fourier Algorithm, we get 2 matrices for the pair of the images.
Given two input images Ga and Gb:
Calculate the cross-power spectrum by taking the complex conjugate of the second result, multiplying the Fourier transforms together.
R= GaGb* / (| GaGb*|)
Obtain the normalized cross-correlation by applying the inverse Fourier transform
r = F Power -1 {R}
Determine the location of the peak in (possibly using sub-pixel edge detection).
(∆X, ∆Y) = argmax {r}

19. 4-Run the phase correlation and compute the shift in coordinates.
Figure5 Phase Correlation between two images

20. Running of the project (Sequential Implementation)
Go to the Sequential Run for the program.

21. Running of the project (Sequential Implementation) (Cont.)
Figure6 Phase Correlation between two images

22. First Parallel Implementation
Reading Image2 on Processor2
Reading Image1 on Processor1
The simple idea for implement the previous sequential algorithm using MPI is to run each image on different processor then calculate the phase correlation on the master node.
Hamming Window
Hamming Window
FFTW
FFTW
Phase Correlation
Inverse FFTW
(∆X, ∆Y)

23. First Parallel Implementation (Cont.)
Go to the Parallel Run for the 1st program.

24. Second Parallel Implementation
The second flowchart to implement the algorithm using the MPI by divided the image itself to small parts and run the algorithm on each part of the image on a separated processor.

25. Second Parallel Implementation (Cont.)
Dived the Image1 and Image2 on Processor1
Hamming Window for part1 of Image1
Hamming Window for part2 of Image1
Hamming Window for part1 of Image2
Hamming Window for part2 of Image2
FFT
FFT
FFT
FFT
Inverse FFTW
(∆X, ∆Y)
Phase Correlation

26. Second Parallel Implementation (Cont.)
Go to the Parallel Run for the 2nd program.

27. Statistics and Comparisons
The time differences between the two implementation:

28. Statistics and Comparisons (Cont.)
Figure7 Time Comparison between the sequential and the simple parallel running time

29. Statistics and Comparisons (Cont.)
Phase Correlation Simple Parallel Idea
Phase Correlation Sequential
Time Measurement Function
3.01 minutes
6.075 minutes
Clock Function
3.19 minutes
6.5 minutes
Operating System (Ubuntu 9.10)
3.09 minutes
minutes
Stop Watch

30. Conclusions
Implementing the Imageodesy algorithm using the phase Correlation and FFTW with MPI on the whole images “as in 1st parallel program” gave high performance processing for the whole algorithm as shown in figures 8 and 9.
The 2nd parallel implementation gave different results in the FFTW phase and it can’t be implemented as inside this algorithm.
So we can’t divide the image in the phase of FFTW.

31. Conclusions (Cont.)
As implemented with MIT in the sequential algorithm using NCC, a sample with 3.75 GB took 400 hours to run.
So 3.75 * 1000 * 1000 = / 1650 = 2272 images
1850 image /400 hours =5.68 ~ 6 images per hour
6 images / 1* 60 minutes = each image take less than 10 minutes
With our Sequential implementation using Phase correlation, the pair of images took = minutes and this is less than the MIT algorithm using NCC.

32. Figure8 Sequential Run for FFT Phase
Conclusions (Cont.)
Figure8 Sequential Run for FFT Phase

33. Figure9 Parallel Run for FFT Phase
Conclusions (Cont.)
Figure9 Parallel Run for FFT Phase

34. Future Work
We can search for another implementation to parallelize the FFTW algorithm and this will gave us a huge enhancement in the algorithm’s performance.
We can test the program with the large and the full data from NARSS team.
We can test the enhanced algorithm on the (NARSS Blogin HPC).
Also another future work to enhance the FNCC with MPI by enable the dynamic re-distribution for the data while the running time.

35. Acknowledgement Many thanks for the NARSS center for helping us:
As they gave us a sample image to be used in our project.
Also they gave us access on NARSS Super Computer Unit (Blue-Gene) to run our code and test it.

36. Questions ?