diff --git a/.gitignore b/.gitignore
index a348e50..b848bc5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,5 @@
 /__pycache__/
+/data/
+/sim_data/
+
+*.pyc
\ No newline at end of file
diff --git a/README.md b/README.md
index 8f53bee..e73fe95 100644
--- a/README.md
+++ b/README.md
@@ -5,3 +5,6 @@ This Simulator is used for paper **"DeepInSAR: A Deep Learning Framework for SAR
 
 
 
+```
+python3 simulator.py
+```
\ No newline at end of file
diff --git a/data_utils_3vG.py b/data_utils_3vG.py
index 2d3527f..06c0bf7 100644
--- a/data_utils_3vG.py
+++ b/data_utils_3vG.py
@@ -11,20 +11,20 @@
 import numpy as np
 
 def readShortComplex(fileName, width=1):
-    return np.fromfile(fileName, '>i2').astype(np.float).view(np.complex).reshape(-1, width)
+    return np.fromfile(fileName, '>i2').astype(float).view(complex).reshape(-1, width)
 
 
 def readFloatComplex(fileName, width=1):
-    return np.fromfile(fileName, '>c8').astype(np.complex).reshape(-1, width)
+    return np.fromfile(fileName, '>c8').astype(complex).reshape(-1, width)
 
 
 def readFloat(fileName, width=1):
-    return np.fromfile(fileName, '>f4').astype(np.float).reshape(-1, width)
+    return np.fromfile(fileName, '>f4').astype(float).reshape(-1, width)
 
 
 def writeShortComplex(fileName, data):
     out_file = open(fileName, 'wb')
-    data.copy().view(np.float).astype('>i2').tofile(out_file)
+    data.copy().view(float).astype('>i2').tofile(out_file)
     out_file.close()
 
 
@@ -55,7 +55,7 @@ def readFloatComplexRandomPathces(fileName, width=1, num_sample=1, patch_size=1,
             img = []
             for p_row in range(patch_size):
                 fin.seek(8 * (width * (row + p_row) + col))
-                img.append(np.frombuffer(fin.read(8 * patch_size), dtype=">c8").astype(np.complex))
+                img.append(np.frombuffer(fin.read(8 * patch_size), dtype=">c8").astype(complex))
             patches.append(np.reshape(img, [patch_size, patch_size]))
     return patches, rows, cols, height
 
@@ -75,7 +75,7 @@ def readShortFloatComplexRandomPathces(fileName, width=1, num_sample=1, patch_si
             img = []
             for p_row in range(patch_size):
                 fin.seek(4 * (width * (row + p_row) + col))
-                img.append(np.frombuffer(fin.read(4 * patch_size), dtype=">i2").astype(np.float).view(np.complex))
+                img.append(np.frombuffer(fin.read(4 * patch_size), dtype=">i2").astype(float).view(complex))
             patches.append(np.reshape(img, [patch_size, patch_size]))
     return patches, rows, cols, height
 
@@ -93,7 +93,7 @@ def readFloatRandomPathces(fileName, width=1, num_sample=1, patch_size=1, rows=N
             img = []
             for p_row in range(patch_size):
                 fin.seek(4 * (width * (row + p_row) + col))
-                img.append(np.frombuffer(fin.read(4 * patch_size), dtype=">f4").astype(np.float))
+                img.append(np.frombuffer(fin.read(4 * patch_size), dtype=">f4").astype(float))
             patches.append(np.reshape(img, [patch_size, patch_size]))
     return patches, rows, cols, height
 
diff --git a/main.ipynb b/main.ipynb
new file mode 100644
index 0000000..7dc3aa9
--- /dev/null
+++ b/main.ipynb
@@ -0,0 +1,464 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import cv2"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-0.09971257+0.1291539j , -0.05994629-0.06141148j],\n",
+       "       [-0.18550311-0.16877884j, -0.11968184-0.03227559j],\n",
+       "       [-0.29614028-0.12297402j, -0.14123768+0.00378711j],\n",
+       "       ...,\n",
+       "       [ 0.3670685 +0.98624635j, -0.26551104+0.9474458j ],\n",
+       "       [-0.50366235+0.70318925j, -0.8244081 +0.44975278j],\n",
+       "       [-1.024294  -0.3125827j , -0.7771321 -0.6728663j ]], dtype='>c8')"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rslc = np.fromfile('sim_data/S1-FH-FS-Train/ifg_fr/0slc2.rslc', dtype='>c8')\n",
+    "rslc.reshape((-1, 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[0.33344448+0.34748882j, 0.3524792 +0.36493275j],\n",
+       "       [0.36493275+0.36493275j, 0.39797613+0.41264695j],\n",
+       "       [0.4331815 +0.43854025j, 0.44224516+0.44224516j],\n",
+       "       ...,\n",
+       "       [0.9739431 +0.9740299j , 0.9745853 +0.97480965j],\n",
+       "       [0.975457  +0.97695076j, 0.97783417+0.9784724j ],\n",
+       "       [0.9792272 +0.981388j  , 0.9824143 +0.9837617j ]], dtype='>c8')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "coh = np.fromfile('sim_data/S1-FH-FS-Train/ifg_fr/0slc1_0slc2.filt.coh', dtype='>c8')\n",
+    "coh.reshape((-1, 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([], shape=(0, 2), dtype='>c8')"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "coh = np.fromfile('sim_data/S1-FH-FS-Train/ifg_fr/0slc2.rslc.bar.norm', dtype='>c8')\n",
+    "coh.reshape((-1, 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "flit = np.fromfile('sim_data/S1-FH-FS-Train/ifg_fr/0slc1_0slc2.filt', dtype='>c8')\n",
+    "flit = flit.reshape((512, 512))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "2.3009748"
+      ]
+     },
+     "execution_count": 46,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "np.angle(flit[0,0])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[-0.00667003+7.4505531e-03j, -0.00858577+6.3962424e-03j,\n",
+       "        -0.00973895+4.7998889e-03j, ..., -1.0529262 +2.2283271e-02j,\n",
+       "        -1.0644995 -3.5523048e-01j, -0.95587325-7.4189371e-01j],\n",
+       "       [-0.00903053+4.2952932e-03j, -0.01039218+2.5748818e-03j,\n",
+       "        -0.010838  +6.5118371e-04j, ..., -1.0450547 +1.3042487e-01j,\n",
+       "        -1.0957017 -2.4245735e-01j, -1.0287895 -6.3693970e-01j],\n",
+       "       [-0.00998086+6.1838265e-04j, -0.01060185-1.4927083e-03j,\n",
+       "        -0.01029554-3.4479059e-03j, ..., -1.0247501 +2.4297585e-01j,\n",
+       "        -1.1157056 -1.2061795e-01j, -1.0932881 -5.1847982e-01j],\n",
+       "       ...,\n",
+       "       [-0.00915949-4.0129488e-03j, -0.00722588-7.9002501e-03j,\n",
+       "        -0.00374468-1.0191347e-02j, ..., -1.05022   -7.8663073e-02j,\n",
+       "        -1.0177414 +4.7281095e-01j, -0.7020002 +9.8554337e-01j],\n",
+       "       [-0.00963663-2.6711924e-03j, -0.00830508-6.7566945e-03j,\n",
+       "        -0.0052372 -9.5109381e-03j, ..., -1.0277387 -2.3000686e-01j,\n",
+       "        -1.073275  +3.2776305e-01j, -0.8251054 +8.8504297e-01j],\n",
+       "       [-0.00993269-1.1582873e-03j, -0.0092697 -5.3572352e-03j,\n",
+       "        -0.00671351-8.5331677e-03j, ..., -0.98190594-3.8080281e-01j,\n",
+       "        -1.1090747 +1.7117564e-01j, -0.9378816 +7.6451170e-01j]],\n",
+       "      dtype='>c8')"
+      ]
+     },
+     "execution_count": 30,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "flit"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "FileNotFoundError",
+     "evalue": "[Errno 2] No such file or directory: 'sim_data/S1-FH-FS-Train/ifg_fr/0slc1_0slc2.filt.png'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[1;32m/home/amir/Documents/clony/InSAR-Simulator/main.ipynb Cell 8\u001b[0m line \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/home/amir/Documents/clony/InSAR-Simulator/main.ipynb#X10sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m png \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39;49mfromfile(\u001b[39m'\u001b[39;49m\u001b[39msim_data/S1-FH-FS-Train/ifg_fr/0slc1_0slc2.filt.png\u001b[39;49m\u001b[39m'\u001b[39;49m)\n",
+      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'sim_data/S1-FH-FS-Train/ifg_fr/0slc1_0slc2.filt.png'"
+     ]
+    }
+   ],
+   "source": [
+    "png = np.fromfile('sim_data/S1-FH-FS-Train/ifg_fr/0slc1_0slc2.filt.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([ 5.29239778e-260,  2.01737825e+088,  2.78134232e-309, ...,\n",
+       "        1.94968847e+000, -6.02327261e+196,  1.11678969e+021])"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "png"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(61232,)"
+      ]
+     },
+     "execution_count": 24,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "png.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "png.reshape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "png = cv2.imread('sim_data/S1-FH-FS-Train/ifg_fr/0slc1_0slc2.filt.png')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(512, 512, 3)"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "png.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "array([[[  0,  40, 255],\n",
+       "        [  0,  11, 245],\n",
+       "        [  0,   0, 209],\n",
+       "        ...,\n",
+       "        [  0,   0, 127],\n",
+       "        [186,   0,   0],\n",
+       "        [245,   0,   0]],\n",
+       "\n",
+       "       [[  0,   0, 209],\n",
+       "        [  0,   0, 168],\n",
+       "        [  0,   0, 136],\n",
+       "        ...,\n",
+       "        [  0,   0, 150],\n",
+       "        [163,   0,   0],\n",
+       "        [227,   0,   0]],\n",
+       "\n",
+       "       [[  0,   0, 136],\n",
+       "        [150,   0,   0],\n",
+       "        [186,   0,   0],\n",
+       "        ...,\n",
+       "        [  0,   0, 168],\n",
+       "        [145,   0,   0],\n",
+       "        [209,   0,   0]],\n",
+       "\n",
+       "       ...,\n",
+       "\n",
+       "       [[200,   0,   0],\n",
+       "        [255,   4,   0],\n",
+       "        [255,  68,   0],\n",
+       "        ...,\n",
+       "        [141,   0,   0],\n",
+       "        [  0,   0, 204],\n",
+       "        [  0,  55, 255]],\n",
+       "\n",
+       "       [[177,   0,   0],\n",
+       "        [250,   0,   0],\n",
+       "        [255,  44,   0],\n",
+       "        ...,\n",
+       "        [163,   0,   0],\n",
+       "        [  0,   0, 182],\n",
+       "        [  0,  37, 255]],\n",
+       "\n",
+       "       [[145,   0,   0],\n",
+       "        [222,   0,   0],\n",
+       "        [255,  16,   0],\n",
+       "        ...,\n",
+       "        [195,   0,   0],\n",
+       "        [  0,   0, 154],\n",
+       "        [  0,  15, 250]]], dtype=uint8)"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "png"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/amir/miniconda3/lib/python3.11/site-packages/numpy/lib/function_base.py:1653: RuntimeWarning: invalid value encountered in arctan2\n",
+      "  a = arctan2(zimag, zreal)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "3.141592653589793"
+      ]
+     },
+     "execution_count": 56,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "max(np.angle(np.fromfile('sim_data/S1-Flow-FS-Train/ifg_fr/1slc1_1slc2.filt_unwrap.png')))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate Wrap Count\n",
+    "\n",
+    "k = (unwrap phase - wrap phase)/2pi"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "range = np.load('sim_data/S1-Flow-FS-Train/ifg_fr/0slc1_0slc2.filt_range.npy')\n",
+    "azimuth = np.load('sim_data/S1-Flow-FS-Train/ifg_fr/0slc1_0slc2.filt_azimuth.npy')\n",
+    "wrapped = np.load('sim_data/S1-Flow-FS-Train/ifg_fr/0slc1_0slc2.filt.npy')\n",
+    "unwrapped = np.load('sim_data/S1-Flow-NS-Train/ifg_fr/2slc1_2slc2.filt_unwrapped.npy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f8c55262fd0>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(unwrapped, cmap='jet')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x7f8c552b1350>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.imshow(range, cmap='jet')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "insar-sim",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/simulator.py b/simulator.py
index 5de44b1..4eea48b 100644
--- a/simulator.py
+++ b/simulator.py
@@ -14,6 +14,7 @@
 import numpy as np
 import os
 
+
 def normalize_slc_by_tanhmz(img, norm=False):
     phase = np.angle(img)
     points = img
@@ -65,24 +66,25 @@ def generate_band_mask(width, height, thickness=1):
 
 
 class IfgSim():
-    """stores simulated data with and without noise and allows to add specific types of signals
-  Attributes:
-    width and height:
-    rayleigh_scale: all amplitudes are randomly drawn according to this parameter
-    signal_gauss_bubbles: the phase signal
-    signal: the phase signal
-    signal_buildings: the phase signal model parameters
-    signal_faults: the phase signal model parameters
-    signal: the phase signal model parameters
-    amp1: the underlying amplitude of slc1
-    amp2: the underlying amplitude of slc2
-    slc1: a phasor of zero phase and amp1 amplitude
-    slc2: a phasor of signal phase and amp2 amplitude
-    noise1: complex normal gaussian added to slc1
-    noise2: complex normal gaussian added to slc2
-    ifg: ifg = (slc1+noise1)*np.conj(slc2+noise2)
-    x,y: 2D arrays with the x and y indices
-  """
+    """
+    stores simulated data with and without noise and allows to add specific types of signals
+    Attributes:
+        width and height:
+        rayleigh_scale: all amplitudes are randomly drawn according to this parameter
+        signal_gauss_bubbles: the phase signal
+        signal: the phase signal
+        signal_buildings: the phase signal model parameters
+        signal_faults: the phase signal model parameters
+        signal: the phase signal model parameters
+        amp1: the underlying amplitude of slc1
+        amp2: the underlying amplitude of slc2
+        slc1: a phasor of zero phase and amp1 amplitude
+        slc2: a phasor of signal phase and amp2 amplitude
+        noise1: complex normal gaussian added to slc1
+        noise2: complex normal gaussian added to slc2
+        ifg: ifg = (slc1+noise1)*np.conj(slc2+noise2)
+        x,y: 2D arrays with the x and y indices
+    """
 
     def __init__(self, width, height, rayleigh_scale=1.0, amp_rayleigh_scale=0.3):
         np.random.seed(np.random.randint(1, 1000000 + 1))
@@ -90,8 +92,8 @@ def __init__(self, width, height, rayleigh_scale=1.0, amp_rayleigh_scale=0.3):
         self.height = height
         self.rayleigh_scale = rayleigh_scale
         self.x, self.y = np.meshgrid(range(self.width), range(self.height))
-        self.x = self.x.astype(np.float)
-        self.y = self.y.astype(np.float)
+        self.x = self.x.astype(float)
+        self.y = self.y.astype(float)
         self.signal = np.zeros((height, width))
         self.signal_gauss_bubbles = []
         self.signal_buildings = []
@@ -105,17 +107,17 @@ def __init__(self, width, height, rayleigh_scale=1.0, amp_rayleigh_scale=0.3):
         self.amp1 = amp.copy()
         self.amp2 = amp.copy()
         self.slc1 = np.exp(1j * np.zeros((height, width)))
-        self.slc2 = np.zeros((height, width)).astype(np.complex)
-        self.noise1 = np.zeros((height, width)).astype(np.complex)
-        self.noise2 = np.zeros((height, width)).astype(np.complex)
-        self.ifg = np.zeros((height, width)).astype(np.complex)
-        self.noisy_ifg = np.zeros((height, width)).astype(np.complex)
+        self.slc2 = np.zeros((height, width)).astype(complex)
+        self.noise1 = np.zeros((height, width)).astype(complex)
+        self.noise2 = np.zeros((height, width)).astype(complex)
+        self.ifg = np.zeros((height, width)).astype(complex)
+        self.noisy_ifg = np.zeros((height, width)).astype(complex)
 
     def add_gauss_bubble(self, sigma_range=[20, 300], amp_range=[-1, 1]):
         """
-    :param sigma_range: the range of spatial scales for the gaussians
-    :param amp_range: the range of amplitudes for the gaussians
-    """
+        :param sigma_range: the range of spatial scales for the gaussians
+        :param amp_range: the range of amplitudes for the gaussians
+        """
         amp = (np.random.random() * (amp_range[1] - amp_range[0]) + amp_range[0])
         x_mean = float(np.random.randint(int(0), int(self.width - 1)))
         y_mean = float(np.random.randint(int(0), int(self.height - 1)))
@@ -126,19 +128,19 @@ def add_gauss_bubble(self, sigma_range=[20, 300], amp_range=[-1, 1]):
 
     def add_n_gauss_bubbles(self, sigma_range=[20, 300], amp_range=[-1, 1], nps=100):
         """
-    :param sigma_range: the range of spatial scales for the gaussians
-    :param amp_range: the range of amplitudes for the gaussians
-    :param nps: number of random gaussians
-    """
+        :param sigma_range: the range of spatial scales for the gaussians
+        :param amp_range: the range of amplitudes for the gaussians
+        :param nps: number of random gaussians
+        """
         for i in range(nps):
             self.add_gauss_bubble(sigma_range, amp_range)
 
     def add_building(self, width_range=[10, 100], height_range=[10, 100], depth_factor=0.2):
         """
-    :param width_range: range of wedge widths 
-    :param height_range: range of wedge heights
-    :param depth_factor: the height of the building is proportional to the width of the wedge by this factor
-    """
+        :param width_range: range of wedge widths 
+        :param height_range: range of wedge heights
+        :param depth_factor: the height of the building is proportional to the width of the wedge by this factor
+        """
         w = (np.random.random() * (width_range[1] - width_range[0]) + width_range[0])
         h = (np.random.random() * (height_range[1] - height_range[0]) + height_range[0])
         d = w * depth_factor
@@ -149,18 +151,18 @@ def add_building(self, width_range=[10, 100], height_range=[10, 100], depth_fact
 
     def add_n_buildings(self, width_range=[10, 100], height_range=[10, 100], depth_factor=0.2, nps=100):
         """
-    :param width_range: range of wedge widths 
-    :param height_range: range of wedge heights
-    :param depth_factor: the height of the building is proportional to the width of the wedge by this factor
-    :param nps: number of buildings to add 
-    """
+        :param width_range: range of wedge widths 
+        :param height_range: range of wedge heights
+        :param depth_factor: the height of the building is proportional to the width of the wedge by this factor
+        :param nps: number of buildings to add 
+        """
         for i in range(nps):
             self.add_building(width_range, height_range, depth_factor)
 
     def add_amp_stripe(self, thickness=1, rayleigh_scale=0.9):
         """ alters the amplitude in a band region (excluding buildings)
-    :param thickness: approximate thickness of the bands
-    """
+        :param thickness: approximate thickness of the bands
+        """
         # amplitude = np.random.rayleigh(self.rayleigh_scale)
         amplitude = np.random.rayleigh(rayleigh_scale)
         mask = generate_band_mask(self.width, self.height, thickness)
@@ -169,8 +171,8 @@ def add_amp_stripe(self, thickness=1, rayleigh_scale=0.9):
 
     def add_amp_stripe_hard(self, thickness=1, rayleigh_scale=0.9):
         """ alters the amplitude in a band region (excluding buildings)
-    :param thickness: approximate thickness of the bands
-    """
+        :param thickness: approximate thickness of the bands
+        """
         # amplitude = np.random.rayleigh(self.rayleigh_scale)
         amplitude = rayleigh_scale
         mask = generate_band_mask(self.width, self.height, thickness)
@@ -179,16 +181,17 @@ def add_amp_stripe_hard(self, thickness=1, rayleigh_scale=0.9):
 
     def add_n_amp_stripes(self, thickness=1, nps=5, rayleigh_scale=0.9):
         """
-    :param thickness: approximate thickness of the bands 
-    :param amplitude: new amplitude in the bands
-    :param nps: number of bands to add
-    """
+        :param thickness: approximate thickness of the bands 
+        :param amplitude: new amplitude in the bands
+        :param nps: number of bands to add
+        """
         for i in range(nps):
             self.add_amp_stripe_hard(thickness, rayleigh_scale=rayleigh_scale)
 
     def compile(self):
-        """ takes all the model parameters and generates the signals in the amplitude and phase based on them
-    """
+        """
+        takes all the model parameters and generates the signals in the amplitude and phase based on them
+        """
 
         # first add the gaussian bubbles
         self.signal = np.zeros((self.height, self.width))
@@ -196,7 +199,7 @@ def compile(self):
             self.signal += eval_2d_gauss(self.x, self.y, params)
 
         # then add the buildings
-        vacant_lots = np.ones((self.height, self.width)).astype(np.bool)
+        vacant_lots = np.ones((self.height, self.width)).astype(bool)
         for params in sorted(self.signal_buildings):
             _, amp, w, h, d, px, py = params
             print(params)
@@ -213,9 +216,47 @@ def compile(self):
 
             vacant_lots = (vacant_lots) & (cur_building_mask == False)
 
+    def itoh_condition(self, phase_array):
+        unwrapped = np.zeros_like(phase_array)
+        unwrapped[0] = phase_array[0]
+
+        for i in range(1, len(phase_array)):
+            delta = phase_array[i] - phase_array[i - 1]
+            if delta > np.pi:
+                unwrapped[i] = unwrapped[i - 1] + delta - 2 * np.pi
+            elif delta < -np.pi:
+                unwrapped[i] = unwrapped[i - 1] + delta + 2 * np.pi
+            else:
+                unwrapped[i] = unwrapped[i - 1] + delta
+
+        return unwrapped
+
+    def unwrap(self, phase_array_2d):
+        phase_array_2d = np.angle(phase_array_2d)
+        # Unwrap horizontally (row-wise)
+        unwrapped_range = np.zeros_like(phase_array_2d)
+        for i in range(phase_array_2d.shape[0]):
+            unwrapped_range[i, :] = self.itoh_condition(phase_array_2d[i, :])
+
+        # Unwrap vertically (column-wise)
+        unwrapped_azimuth = np.zeros_like(phase_array_2d)
+        for j in range(phase_array_2d.shape[1]):
+            unwrapped_azimuth[:, j] = self.itoh_condition(phase_array_2d[:, j])
+
+        # Unwrap 2D (both horizontally and vertically)
+        unwrapped_2d = np.zeros_like(phase_array_2d)
+        for i in range(phase_array_2d.shape[0]):
+            unwrapped_2d[i, :] = self.itoh_condition(unwrapped_range[i, :])
+        for j in range(phase_array_2d.shape[1]):
+            unwrapped_2d[:, j] = self.itoh_condition(unwrapped_2d[:, j])
+
+        return unwrapped_range, unwrapped_azimuth, unwrapped_2d
+
+
     def update(self, sigma=0.2):
-        """ combines the simulated amplitudes and phases with a constant amount of noise to be added to each slc pixel
-    """
+        """ 
+        combines the simulated amplitudes and phases with a constant amount of noise to be added to each slc pixel
+        """
         self.compile()
         self.slc1 = self.amp1 * self.slc1
         self.slc2 = self.amp2 * np.exp(1j * (self.signal))
@@ -264,7 +305,7 @@ def get_coh_dict(amp_range=[0.0, 10.0, 1000], sigma=0.2, N=100000):
 
 
 def get_coherence(amps, cohs, amp_range=[0.0, 10.0, 10000]):
-    indices = ((amps - amp_range[0]) * (amp_range[2] - 1.) / (amp_range[1] - amp_range[0])).astype(np.int)
+    indices = ((amps - amp_range[0]) * (amp_range[2] - 1.) / (amp_range[1] - amp_range[0])).astype(int)
     return cohs[indices]
 
 
@@ -568,7 +609,16 @@ def generate_fix_dataset_by_config(config):
         writeFloatComplex(filename, sim.ifg_noisy)
 
         filename = "%s/%s_%s%s" % (config['filt_path'], slc1_name, slc2_name, config['filt_ext'])
+
         plt.imsave("%s.png" % filename, np.angle(sim.ifg), cmap="jet")
+        np.save('%s.npy' % filename, np.angle(sim.ifg))
+        ranged, azimuth, unwrapped = sim.unwrap(sim.ifg)
+        np.save('%s_range.npy' % filename, ranged)
+        np.save('%s_azimuth.npy' % filename, azimuth)
+        np.save('%s_unwrapped.npy' % filename, unwrapped)
+        plt.imsave("%s_range.png" % filename, ranged, cmap="jet")
+        plt.imsave("%s_azimuth.png" % filename, azimuth, cmap="jet")
+        plt.imsave("%s_unwrapped.png" % filename, unwrapped, cmap="jet")
         # plt.imsave("%s_amp.png" % filename, np.abs(sim.ifg), cmap="gray")
         writeFloatComplex(filename, sim.ifg)
 
@@ -589,9 +639,9 @@ def gen(db_name, modify={}):
             "filt_ext": ".filt",
             "coh_path": SIM_DIR + db_name + "/ifg_fr",
             "coh_ext": ".filt.coh",
-            "width": 1000,
-            "height": 1000,
-            "num_of_samples": 50,
+            "width": 512,
+            "height": 512,
+            "num_of_samples": 10,
             "sigma": 0.1,
             "rayleigh_scale": 0.9,
             "min_b_w": 10,