diff --git a/.gitignore b/.gitignore
index 6a4dae103..9c7660a1f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
 .DS_Store
 __pycache__
+*vscode
\ No newline at end of file
diff --git a/depth-color-alignment-test/.gitignore b/depth-color-alignment-test/.gitignore
new file mode 100644
index 000000000..b694934fb
--- /dev/null
+++ b/depth-color-alignment-test/.gitignore
@@ -0,0 +1 @@
+.venv
\ No newline at end of file
diff --git a/depth-color-alignment-test/README.md b/depth-color-alignment-test/README.md
new file mode 100644
index 000000000..30af5709a
--- /dev/null
+++ b/depth-color-alignment-test/README.md
@@ -0,0 +1,49 @@
+# Depth-color alignment test
+## Controls
+| key | action |
+| :--- | :--- |
+| `q` | quit |
+| `s` | select the elevated plane area on the RGB image |
+
+## Usage
+The camera should look on a scene with ground plane and elevation plane of different colors.
+
+Press the `s` key to select the elevated area. Check if the segmentation looks correct. 
+
+The running average of the error ratio will be displayed. 
+
+## How it works
+When the user makes a selection the average depth of the elevated and ground plane is computed. Based on that measurement the depth image is into _elevated area_ (pixels between _top padding_ and _mid depth_) and _ground area_ (pixels between _mid depth_ and _bottom padding_).
+
+Similarly the color image is segmented based on the measured hue on the elevated and ground area.
+
+```                                                                                                                                                                                  
+                 ┌────────┐                                     
+                 │ camera │                                     
+                 └────────┘                                     
+                    /  \                                        
+                   /    \                                       
+                  /      \                                      
+                 /        \                                     
+                /          \                                    
+               /            \                                   
+              /              \                                  
+             /                \                                 
+            /                  \                                
+ ----------/--------------------\------------- top padding      
+          /                      \                              
+ ========/=======▒▒▒▒▒▒▒▒▒▒=======\=========== elevated plane   
+        /                          \                            
+       /                            \                           
+ -----/------------------------------\-------- mid depth        
+     /                                \                         
+    /                                  \                        
+ ██████████████████████████████████████████=== ground plane     
+                                                                
+ --------------------------------------------- bottom padding   
+
+```
+
+After segmentation the error ratio is computed.
+
+![test](demo.png)
\ No newline at end of file
diff --git a/depth-color-alignment-test/alignment_test.py b/depth-color-alignment-test/alignment_test.py
new file mode 100644
index 000000000..bf879115c
--- /dev/null
+++ b/depth-color-alignment-test/alignment_test.py
@@ -0,0 +1,132 @@
+import cv2
+import numpy as np
+from typing import Tuple, Optional
+from collections import deque
+import config
+
+class AlignmentTest:
+
+	def __init__(self):
+		self.alignments = deque(maxlen=20)
+		self.border_widths = deque(maxlen=20)
+		self.center_offsets = deque(maxlen=20)
+		self.roi: Optional[Tuple[int, int, int, int]] = None
+
+	def fit_rect(self, bin_img):
+		closing = cv2.morphologyEx(bin_img, cv2.MORPH_CLOSE, np.ones((3,3), np.uint8))
+		contours, hierarchy = cv2.findContours(closing, cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)
+		if len(contours) == 0:
+			return None
+		cnt = np.vstack(contours).squeeze()
+		if len(cnt) < 4:
+			return None
+		rect = cv2.minAreaRect(cnt)
+		box = cv2.boxPoints(rect)
+		box = np.int0(box)
+
+		return box
+
+	def update(self, depth_frame, image_frame):
+		image_elevated, image_floor = self.image_threshold(image_frame)
+		depth_elevated, depth_floor = self.depth_threshold(depth_frame)
+
+
+		error = (image_elevated != depth_elevated) & (image_floor != depth_floor)
+		selection = (depth_elevated & image_elevated) | (depth_floor & image_floor)
+
+		error_area = np.count_nonzero(error)
+		total_area = np.count_nonzero(selection)
+
+		if total_area != 0:
+			error_ratio = error_area / total_area
+			self.alignments.append(error_ratio)
+
+		# visualization
+		image_segmentation = np.stack((image_floor, np.zeros_like(image_elevated), image_elevated), axis=-1).astype(np.uint8) * 255
+		depth_segmentation = np.stack((depth_floor, np.zeros_like(depth_elevated), depth_elevated), axis=-1).astype(np.uint8) * 255
+
+		image_box = self.fit_rect(image_elevated.astype(np.uint8)*255)
+		depth_box = self.fit_rect(depth_elevated.astype(np.uint8)*255)
+
+		error_vis = np.stack((error, )*3, axis=-1).astype(np.uint8) * 255
+		selection_vis = np.stack((selection, )*3, axis=-1).astype(np.uint8) * 255
+
+
+		if image_box is not None and depth_box is not None:
+			cv2.drawContours(image_segmentation, [image_box], 0, (0,255,0), 2)
+			cv2.drawContours(depth_segmentation, [depth_box], 0, (0,255,0), 2)
+
+
+			# calculate border width
+			rectangle_perimeter_px = cv2.arcLength(image_box, True)
+			px_to_mm = config.rectangle_perimeter_mm / rectangle_perimeter_px
+			d_px = error_area / rectangle_perimeter_px
+			d_mm = d_px * px_to_mm
+			self.border_widths.append(d_mm)
+
+			# calculate center offset
+			d = np.linalg.norm(image_box.mean(axis=0) - depth_box.mean(axis=0))*px_to_mm
+			self.center_offsets.append(d)
+
+		
+		print(f"Center offset: {np.mean(self.center_offsets):.2f} mm")
+		print(f"Border width: {np.mean(self.border_widths):.2f} mm")
+		
+
+		return image_segmentation, depth_segmentation, error_vis, selection_vis
+
+	def image_threshold(self, image_frame: np.ndarray):
+		zeros = np.zeros(image_frame.shape[:2], dtype=np.bool_)
+		if self.roi is None: return zeros, zeros
+
+		hsv = cv2.cvtColor(image_frame, cv2.COLOR_RGB2HSV)
+		hue = hsv[:,:,0]
+
+		elevated = (hue < (self.avg_hue + 10)) & (hue > (self.avg_hue - 10))
+		floor = ~elevated
+
+		return elevated, floor
+
+
+	def depth_threshold(self, depth_frame: np.ndarray):
+		zeros = np.zeros(depth_frame.shape[:2], dtype=np.bool_)
+		if self.roi is None: return zeros, zeros
+
+		padding_top = 100 # mm
+		padding_bottom = 100 # mm
+		mid_depth = (self.avg_depth_elevated + self.avg_depth_floor) / 2
+		elevated = (mid_depth > depth_frame) & (depth_frame > (self.avg_depth_elevated - padding_top))
+		floor = ((self.avg_depth_floor + padding_bottom) > depth_frame) & (depth_frame > mid_depth)
+
+		return elevated, floor
+
+	def reset(self):
+		self.alignments = []
+
+	def get_results(self):
+		if len(self.alignments) == 0: 
+			print("No test frames added yet. Press `c` to capture a frame.")
+			return None
+		avg_alignment = sum(self.alignments) / len(self.alignments)
+		return avg_alignment
+
+	def set_roi(self, roi, image_frame: np.ndarray, depth_frame: np.ndarray):
+		self.roi = roi
+
+		hsv = cv2.cvtColor(image_frame, cv2.COLOR_RGB2HSV)
+		hue = hsv[:,:,0]
+
+		# Crop image and depth frame
+		hue_elevated = hue[roi[1]:roi[1]+roi[3], roi[0]:roi[0]+roi[2]]
+		depth_elevated = depth_frame[roi[1]:roi[1]+roi[3], roi[0]:roi[0]+roi[2]]
+
+		depth_elevated_sum = np.sum(depth_elevated)
+		depth_sum = np.sum(depth_frame)
+		depth_elevated_count = depth_elevated.shape[0] * depth_elevated.shape[1] - np.count_nonzero(depth_elevated == 0)
+		depth_count = depth_frame.shape[0] * depth_frame.shape[1] - np.count_nonzero(depth_frame == 0)
+
+		self.avg_depth_elevated = depth_elevated_sum / depth_elevated_count
+		self.avg_depth_floor = (depth_sum - depth_elevated_sum) / (depth_count - depth_elevated_count)
+
+
+		self.avg_hue = np.mean(hue_elevated)
diff --git a/depth-color-alignment-test/camera.py b/depth-color-alignment-test/camera.py
new file mode 100644
index 000000000..662518ffb
--- /dev/null
+++ b/depth-color-alignment-test/camera.py
@@ -0,0 +1,148 @@
+import depthai as dai
+import cv2
+import numpy as np
+from typing import List
+from host_sync import HostSync
+import config
+
+class Camera:
+    def __init__(self, device_info: dai.DeviceInfo, friendly_id: int, show_video: bool = True):
+        self.show_video = show_video
+        self.show_depth = False
+        self.device_info = device_info
+        self.friendly_id = friendly_id
+        self.mxid = device_info.getMxId()
+        self._create_pipeline()
+        self.device = dai.Device(self.pipeline, self.device_info)
+        # self.roi = (100, 100, 200, 400)
+        self.roi = None
+
+        self.device.setIrLaserDotProjectorBrightness(600)
+
+        self.image_queue = self.device.getOutputQueue(name="image", maxSize=10, blocking=False)
+        self.depth_queue = self.device.getOutputQueue(name="depth", maxSize=10, blocking=False)
+        self.mono_queue = self.device.getOutputQueue(name="mono", maxSize=10, blocking=False)
+        self.host_sync = HostSync(["image", "depth", "mono"])
+
+        self.image_frame = None
+        self.depth_frame = None
+        self.depth_visualization_frame = None
+
+        # camera window
+        self.image_window_name = f"[{self.friendly_id}] Camera RGB - mxid: {self.mxid}"
+        self.depth_window_name = f"[{self.friendly_id}] Camera depth - mxid: {self.mxid}"
+        if show_video:
+            cv2.namedWindow(self.image_window_name, cv2.WINDOW_NORMAL)
+            cv2.namedWindow(self.depth_window_name, cv2.WINDOW_NORMAL)
+            cv2.resizeWindow(self.image_window_name, 640, 360)
+            cv2.resizeWindow(self.depth_window_name, 640, 360)
+
+        self._load_calibration()
+
+        print("=== Connected to " + self.device_info.getMxId())
+
+    def __del__(self):
+        self.device.close()
+        print("=== Closed " + self.device_info.getMxId())
+
+    def _load_calibration(self):
+        calibration = self.device.readCalibration()
+        self.intrinsics = calibration.getCameraIntrinsics(
+            dai.CameraBoardSocket.RGB if config.COLOR else dai.CameraBoardSocket.RIGHT, 
+            dai.Size2f(*self.image_size)
+        )
+
+    def save_point_cloud_alignment(self):
+        np.save(f"{config.calibration_data_dir}/point_cloud_alignment_{self.mxid}.npy", self.point_cloud_alignment)
+    
+
+    def _create_pipeline(self):
+        pipeline = dai.Pipeline()
+
+        # Depth cam -> 'depth'
+        mono_left = pipeline.createMonoCamera()
+        mono_right = pipeline.createMonoCamera()
+        mono_left.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
+        mono_left.setBoardSocket(dai.CameraBoardSocket.LEFT)
+        mono_right.setResolution(dai.MonoCameraProperties.SensorResolution.THE_400_P)
+        mono_right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+        cam_stereo = pipeline.createStereoDepth()
+        cam_stereo.setDefaultProfilePreset(dai.node.StereoDepth.PresetMode.HIGH_DENSITY)
+        cam_stereo.initialConfig.setMedianFilter(config.median)
+        cam_stereo.initialConfig.setConfidenceThreshold(config.confidence_threshold)
+        cam_stereo.setLeftRightCheck(config.lrcheck)
+        cam_stereo.setExtendedDisparity(config.extended)
+        cam_stereo.setSubpixel(config.subpixel)
+        mono_left.out.link(cam_stereo.left)
+        mono_right.out.link(cam_stereo.right)
+
+        init_config = cam_stereo.initialConfig.get()
+        # init_config.postProcessing.speckleFilter.enable = False
+        # init_config.postProcessing.speckleFilter.speckleRange = 50
+        # init_config.postProcessing.temporalFilter.enable = True
+        # init_config.postProcessing.spatialFilter.enable = True
+        # init_config.postProcessing.spatialFilter.holeFillingRadius = 2
+        # init_config.postProcessing.spatialFilter.numIterations = 1
+        # init_config.postProcessing.thresholdFilter.minRange = config.min_range
+        # init_config.postProcessing.thresholdFilter.maxRange = config.max_range
+        # init_config.postProcessing.decimationFilter.decimationFactor = 1
+        cam_stereo.initialConfig.set(init_config)
+
+        xout_depth = pipeline.createXLinkOut()
+        xout_depth.setStreamName("depth")
+        cam_stereo.depth.link(xout_depth.input)
+
+        xout_mono = pipeline.createXLinkOut()
+        xout_mono.setStreamName("mono")
+        mono_left.out.link(xout_mono.input)
+
+        
+        # RGB cam or mono right -> 'image'
+        xout_image = pipeline.createXLinkOut()
+        xout_image.setStreamName("image")
+        if config.COLOR:
+            cam_rgb = pipeline.createColorCamera()
+            cam_rgb.setResolution(dai.ColorCameraProperties.SensorResolution.THE_1080_P)
+            cam_rgb.setColorOrder(dai.ColorCameraProperties.ColorOrder.RGB)
+            cam_rgb.setIspScale(1, 3)
+            cam_rgb.initialControl.setManualFocus(130)
+            cam_rgb.initialControl.setAutoWhiteBalanceLock(True)
+            cam_rgb.initialControl.setManualWhiteBalance(200)
+            cam_rgb.initialControl.setAutoExposureLock(True)
+            cam_rgb.initialControl.setManualExposure(10000, 1000)
+            cam_stereo.setDepthAlign(dai.CameraBoardSocket.RGB)
+            cam_rgb.isp.link(xout_image.input)
+            self.image_size = cam_rgb.getIspSize()
+        else:
+            cam_stereo.rectifiedRight.link(xout_image.input)
+            self.image_size = mono_right.getResolutionSize()
+
+        self.pipeline = pipeline
+
+    def update(self):
+        for queue in [self.depth_queue, self.image_queue, self.mono_queue]:
+            new_msgs = queue.tryGetAll()
+            if new_msgs is not None:
+                for new_msg in new_msgs:
+                    self.host_sync.add(queue.getName(), new_msg)
+
+        msg_sync = self.host_sync.get()
+        if msg_sync is None:
+            return
+        
+        self.depth_frame = msg_sync["depth"].getFrame()
+        self.image_frame = msg_sync["image"].getCvFrame()
+        self.mono_frame = msg_sync["mono"].getCvFrame()
+        r = self.roi
+        if r is not None:
+            self.depth_frame = self.depth_frame[r[0]:(r[0]+r[2]), r[1]:(r[1]+r[3])]
+            self.image_frame = self.image_frame[r[0]:(r[0]+r[2]), r[1]:(r[1]+r[3]), :]
+            self.mono_frame = self.mono_frame[r[0]:(r[0]+r[2]), r[1]:(r[1]+r[3])]
+
+        # scale the depth frame from 0-2000 to 0-255
+        self.depth_visualization_frame = np.interp(self.depth_frame, [0, 1000], [0, 255]).astype(np.uint8)
+        self.depth_visualization_frame = cv2.applyColorMap(self.depth_visualization_frame, cv2.COLORMAP_MAGMA)
+
+        if self.show_video:
+            cv2.imshow(self.depth_window_name, self.depth_visualization_frame)
+            cv2.imshow(self.image_window_name, self.image_frame)
\ No newline at end of file
diff --git a/depth-color-alignment-test/config.py b/depth-color-alignment-test/config.py
new file mode 100644
index 000000000..d72768214
--- /dev/null
+++ b/depth-color-alignment-test/config.py
@@ -0,0 +1,18 @@
+import depthai as dai
+
+COLOR = True 		# Use color camera of mono camera
+
+# DEPTH CONFIG
+lrcheck  = True   			# Better handling for occlusions
+extended = False  			# Closer-in minimum depth, disparity range is doubled
+subpixel = False   			# Better accuracy for longer distance, fractional disparity 32-levels
+confidence_threshold = 255 	# 0-255, 255 = low confidence, 0 = high confidence
+min_range = 100 			# mm
+max_range = 2000			# mm
+
+# Median filter
+# Options: MEDIAN_OFF, KERNEL_3x3, KERNEL_5x5, KERNEL_7x7
+median   = dai.StereoDepthProperties.MedianFilter.MEDIAN_OFF
+
+
+rectangle_perimeter_mm = (148+208)*2
\ No newline at end of file
diff --git a/depth-color-alignment-test/host_sync.py b/depth-color-alignment-test/host_sync.py
new file mode 100644
index 000000000..0134ad6b3
--- /dev/null
+++ b/depth-color-alignment-test/host_sync.py
@@ -0,0 +1,21 @@
+import numpy as np
+from functools import reduce
+from collections import deque
+from typing import List
+
+class HostSync:
+    def __init__(self, streams: List[str], maxlen=50):
+        self.queues = {stream: deque(maxlen=maxlen) for stream in streams}
+
+    def add(self, stream: str, msg):
+        self.queues[stream].append({'msg': msg, 'seq': msg.getSequenceNum()})
+
+    def get(self):
+        seqs = [np.array([msg['seq'] for msg in msgs]) for msgs in self.queues.values()]
+        matching_seqs = reduce(np.intersect1d, seqs)
+        if len(matching_seqs) == 0:
+            return None
+        seq = np.max(matching_seqs)
+        res = {stream: next(msg['msg'] for msg in msgs if msg['seq'] == seq) for stream, msgs in self.queues.items()}
+        self.queues = {stream: deque([msg for msg in msgs if msg['seq'] > seq], maxlen=msgs.maxlen) for stream, msgs in self.queues.items()}
+        return res
\ No newline at end of file
diff --git a/depth-color-alignment-test/main.py b/depth-color-alignment-test/main.py
new file mode 100644
index 000000000..24f0abf0f
--- /dev/null
+++ b/depth-color-alignment-test/main.py
@@ -0,0 +1,66 @@
+import cv2
+import numpy as np
+import depthai as dai
+from camera import Camera
+from alignment_test import AlignmentTest
+
+
+found, device_info = dai.Device.getAnyAvailableDevice()
+
+if not found:
+	print("No device found")
+	exit(1)
+
+camera = Camera(device_info, 0, show_video=False)
+
+alignmentTest = AlignmentTest()
+
+min_hue = 110
+max_hue = 130
+
+while True:
+	key = cv2.waitKey(1)
+
+	camera.update()
+
+	if camera.image_frame is not None and camera.depth_visualization_frame is not None:
+
+		image_segmentation, depth_segmentation, error, selection = alignmentTest.update(camera.depth_frame, camera.image_frame)
+
+		image_segmentation_vis = image_segmentation.copy()
+		depth_segmentation_vis = depth_segmentation.copy()
+
+		cv2.putText(image_segmentation_vis, "Image segmentation", (10, 20), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 255), 2)
+		cv2.putText(depth_segmentation_vis, "Depth segmentation", (10, 20), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 255), 2)
+		cv2.putText(selection, "Selection", (10, 20), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 0), 2)
+
+		res = alignmentTest.get_results()
+		if res is not None:
+			cv2.putText(error, f"Error: {res*100:.2f}%", (10, 20), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 0), 2)
+		else:
+			cv2.putText(error, "Error: N/A", (10, 20), cv2.FONT_HERSHEY_PLAIN, 1.5, (255, 255, 0), 2)
+
+		row1 = np.hstack((camera.image_frame, camera.depth_visualization_frame))
+		row2 = np.hstack((image_segmentation_vis, depth_segmentation_vis))
+		row3 = np.hstack((selection, error))
+		visualization = np.vstack((row1, row2, row3))
+		cv2.imshow("Visualization", visualization)
+
+	if key == ord('r'):
+		roi = cv2.selectROI(camera.image_window_name, camera.image_frame, False, False)
+		if(roi[2] > 0 and roi[3] > 0):
+			print(roi)
+			alignmentTest.set_roi(roi, camera.image_frame, camera.depth_frame)
+
+	if key == ord('s'):
+		cv2.imwrite("image.png", depth_segmentation)
+
+	if key == ord('q'):
+		result = "====================\n"
+		result += f"Camera {camera.mxid}:\n"
+		result += f"Center offset: {np.mean(alignmentTest.center_offsets):.2f} mm\n"
+		result += f"Border width: {np.mean(alignmentTest.border_widths):.2f} mm\n"
+
+		with open("results.txt", "a") as f:
+			f.write(result)
+		break
diff --git a/depth-color-alignment-test/requirements.txt b/depth-color-alignment-test/requirements.txt
new file mode 100644
index 000000000..28cb564cb
--- /dev/null
+++ b/depth-color-alignment-test/requirements.txt
@@ -0,0 +1,5 @@
+depthai-sdk
+depthai
+numpy
+opencv-python
+av
\ No newline at end of file
diff --git a/depth-color-alignment-test/v2/analyse.ipynb b/depth-color-alignment-test/v2/analyse.ipynb
new file mode 100644
index 000000000..4ef6f75ea
--- /dev/null
+++ b/depth-color-alignment-test/v2/analyse.ipynb
@@ -0,0 +1,542 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy\n",
+    "from matplotlib import pyplot as plt\n",
+    "from pathlib import Path\n",
+    "import numpy as np\n",
+    "import cv2"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Constants"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "RECTANGLE_WIDTH = 28.8 # mm\n",
+    "RECTANGLE_HEIGHT = 20.0 # mm\n",
+    "RECTANGLE_PERIMETER = (RECTANGLE_WIDTH + RECTANGLE_HEIGHT) * 2"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Load the recordings\n",
+    "`recordings` variable is a dictionary with device MxIDs as keys and a list of recordings as values.\n",
+    "List of recordings is a list of tuples (image, depth) where image is a 3D numpy array of shape (height, width, 3) and depth is a 2D numpy array of shape (height, width)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "recordings = {}\n",
+    "\n",
+    "recordings_path = Path(\"./recordings\")\n",
+    "for device_path in recordings_path.iterdir():\n",
+    "\tsamples = []\n",
+    "\tfor sample_path in device_path.iterdir():\n",
+    "\t\timage = numpy.load(sample_path / \"image.npy\")\n",
+    "\t\tcv2.cvtColor(image, cv2.COLOR_BGR2RGB, image)\n",
+    "\t\tdepth = numpy.load(sample_path / \"depth.npy\")\n",
+    "\t\tsamples.append((image, depth))\n",
+    "\n",
+    "\trecordings[device_path.name] = samples"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Display the first sample"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x228e336c940>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sample = list(recordings.values())[0][0]\n",
+    "image, depth = sample\n",
+    "\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(image)\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(depth, cmap=\"magma\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Crop the images"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x228e342b190>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def crop(img):\n",
+    "\ttop_margin = 35\n",
+    "\tbottom_margin = 45\n",
+    "\tleft_margin = 100\n",
+    "\tright_margin = 150\n",
+    "\n",
+    "\treturn img[top_margin:-bottom_margin, left_margin:-right_margin]\n",
+    "\t\n",
+    "image_crop = crop(image)\n",
+    "depth_crop = crop(depth)\n",
+    "\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(image_crop)\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(depth_crop, cmap=\"magma\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Threshold the images\n",
+    "\n",
+    "The color image is thresholded using the HSV color space. The depth image is thresholded using the depth value."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 45,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x228e7a44a90>"
+      ]
+     },
+     "execution_count": 45,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x1000 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# rgb image thershold\n",
+    "def rgb_threshold(img):\n",
+    "\t# convert to hsv\n",
+    "\thsv = cv2.cvtColor(img, cv2.COLOR_RGB2HSV)\n",
+    "\thsv[:,:,2] = 255\n",
+    "\trgb = cv2.cvtColor(hsv, cv2.COLOR_HSV2RGB)\n",
+    "\tgray = cv2.cvtColor(rgb, cv2.COLOR_RGB2GRAY)\n",
+    "\treturn gray > 220\n",
+    "\n",
+    "# depth image threshold\n",
+    "def depth_threshold(img):\n",
+    "\treturn (400 < img) & (img < 600)\n",
+    "\n",
+    "# alternative depth image threshold which clasifies the unknown values as the elevated plane\n",
+    "def depth_threshold_keep_unknown(depth_crop, image_crop):\n",
+    "\timage_bin = rgb_threshold(image_crop)\n",
+    "\timage_bin_30_dialated = cv2.dilate(image_bin.astype(np.uint8), np.ones((30, 30)))\n",
+    "\tdepth_masked = np.where(image_bin_30_dialated, depth_crop, 2000)\n",
+    "\n",
+    "\treturn depth_masked < 600\n",
+    "\n",
+    "image_bin = rgb_threshold(image_crop)\n",
+    "depth_bin = depth_threshold(depth_crop)\n",
+    "depth_bin_keep_unknown = depth_threshold_keep_unknown(depth_crop, image_crop)\n",
+    "\n",
+    "plt.figure(figsize=(20, 10))\n",
+    "plt.subplot(1, 3, 1)\n",
+    "plt.imshow(image_bin)\n",
+    "plt.subplot(1, 3, 2)\n",
+    "plt.imshow(depth_bin)\n",
+    "plt.subplot(1, 3, 3)\n",
+    "plt.imshow(depth_bin_keep_unknown)\n",
+    "\n"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Fit minimal rectangle\n",
+    "\n",
+    "One measurement of the depth-color alignment is the alignment of the minimal rectangle on the color image and the depth image. We compute it using the `cv2.minAreaRect` function.\n",
+    "\n",
+    "When we compute the minimal rectangle, we can find the ratio of the perimeter in pixels to the perimeter in meters (defined at the beginning of the script). We can use that to convert the measurements from pixels to meters."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "rect_distance: 1.977482795715332 px, 0.20157944376084008 mm\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def fit_minimal_rectangle(img_bin):\n",
+    "\tcontours, hierarchy = cv2.findContours(img_bin.astype(np.uint8), cv2.RETR_TREE, cv2.CHAIN_APPROX_NONE)\n",
+    "\tc = max(contours, key=cv2.contourArea) # use the biggest contour\n",
+    "\t# c = np.vstack(contours).squeeze() # join all contours together\n",
+    "\tbox = cv2.boxPoints(cv2.minAreaRect(c))\n",
+    "\n",
+    "\treturn box\n",
+    "\n",
+    "def get_px_to_mm(image_box):\n",
+    "\trectangle_perimeter_px = cv2.arcLength(image_box, True)\n",
+    "\treturn RECTANGLE_PERIMETER / rectangle_perimeter_px\n",
+    "\n",
+    "\n",
+    "def get_rect_distance(box1, box2):\n",
+    "\treturn np.linalg.norm(box1.mean(axis=0) - box2.mean(axis=0))\n",
+    "\n",
+    "\n",
+    "image_box = fit_minimal_rectangle(image_bin)\n",
+    "depth_box = fit_minimal_rectangle(depth_bin)\n",
+    "\n",
+    "px_to_mm = get_px_to_mm(image_box)\n",
+    "\n",
+    "\n",
+    "image_vis = image_crop.copy()\n",
+    "depth_vis =  np.interp(depth_crop, [0, 1000], [0, 255]).astype(np.uint8)\n",
+    "depth_vis = np.stack([depth_vis]*3, axis=2)\n",
+    "\n",
+    "cv2.drawContours(image_vis, [np.intp(image_box)], 0, (0,0,255), 1)\n",
+    "cv2.drawContours(depth_vis, [np.intp(depth_box)], 0, (0,0,255), 1)\n",
+    "\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(image_vis)\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(depth_vis)\n",
+    "\n",
+    "rect_distance = get_rect_distance(image_box, depth_box)\n",
+    "rect_distance_mm = rect_distance * px_to_mm\n",
+    "\n",
+    "print(f\"rect_distance: {rect_distance} px, {rect_distance_mm} mm\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Find centroids\n",
+    "\n",
+    "Another measurement of the depth-color alignment is the alignment of the centroids of the objects on the color image and the depth image. We compute it using the `cv2.moments` function."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "centroid_distance: 0.8251162842045121 px, 0.08411020412837021 mm\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x1000 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def get_centroid(img_bin):\n",
+    "\tM = cv2.moments(img_bin.astype(numpy.uint8) * 255)\n",
+    "\treturn np.array([(M[\"m10\"] / M[\"m00\"]), (M[\"m01\"] / M[\"m00\"])])\n",
+    "\n",
+    "image_center = get_centroid(image_bin)\n",
+    "depth_center = get_centroid(depth_bin)\n",
+    "\n",
+    "image_vis = image_crop.copy()\n",
+    "depth_vis =  np.interp(depth_crop, [0, 1000], [0, 255]).astype(np.uint8)\n",
+    "depth_vis = np.stack([depth_vis]*3, axis=2)\n",
+    "\n",
+    "cv2.circle(image_vis, (int(image_center[0]), int(image_center[1])), 5, (0,0,255), -1)\n",
+    "cv2.circle(depth_vis, (int(depth_center[0]), int(depth_center[1])), 5, (0,0,255), -1)\n",
+    "plt.figure(figsize=(10, 10))\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.imshow(image_vis)\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(depth_vis)\n",
+    "\n",
+    "\n",
+    "centroid_distance = np.linalg.norm(image_center - depth_center)\n",
+    "centroid_distance_mm = centroid_distance * px_to_mm\n",
+    "\n",
+    "print(f\"centroid_distance: {centroid_distance} px, {centroid_distance_mm} mm\")"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Compute border error width\n",
+    "\n",
+    "The last measurement of the depth-color alignment is the border error width. First, we find pixels where the thresholded depth image and color image do not match. Usualy the mismatch is on the border of the elevated plane. We know the perimeter of the minimal rectangle (computed in the previous step) so we compute the border error width as the ratio of the number of mismatched pixels to the perimeter."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 51,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "error width: 2.092014355319824 px, 0.2132544925289804 mm\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.image.AxesImage at 0x228ea5f78b0>"
+      ]
+     },
+     "execution_count": 51,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x2000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def get_border_error_width(image_bin, depth_bin):\n",
+    "\txor = (image_bin ^ depth_bin)\n",
+    "\n",
+    "\terror_area_px = np.count_nonzero(xor)\n",
+    "\tavg_error_width_px = error_area_px / (RECTANGLE_PERIMETER / px_to_mm)\n",
+    "\n",
+    "\treturn avg_error_width_px\n",
+    "\n",
+    "avg_error_width_px = get_border_error_width(image_bin, depth_bin)\n",
+    "\n",
+    "print(f\"error width: {avg_error_width_px} px, {avg_error_width_px * px_to_mm} mm\")\n",
+    "\n",
+    "xor = (image_bin ^ depth_bin)\n",
+    "plt.figure(figsize=(20,20))\n",
+    "plt.imshow(xor)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Process all samples\n",
+    "\n",
+    "For each device, we compute the average of the measurements for each sample and print the results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "device            \tcentroid_distances [mm]\trect_distances [mm]\terror_widths [mm]\n",
+      "1944301021A7751300\t0.08365517561217056\t0.20157944376084008\t0.2088999699406453\n",
+      "1944301031F7731300\t0.2815189119540645\t0.20157944376084008\t0.27362159051396884\n",
+      "1944301051D4751300\t0.18751638521511169\t0.20157944376084008\t0.26465702322942564\n",
+      "19443010813B771300\t0.06438325086996574\t0.20157944376084008\t0.2801161107557401\n",
+      "19443010A1AC731300\t0.22171734792252806\t0.20157944376084008\t0.17905711709198163\n",
+      "19443010A1D3731300\t0.1275882072289324\t0.20157944376084008\t0.2147024511402606\n",
+      "19443010A1EB7E1300\t0.3033583567482087\t0.20157944376084008\t0.2523706685425338\n",
+      "19443010C1FB7E1300\t0.3032463837064491\t0.20157944376084008\t0.2748992010533337\n",
+      "19443010D17E741300\t0.256204194741978\t0.20157944376084008\t0.2324718843919265\n",
+      "19443010E1C9731300\t0.20614324055676586\t0.20157944376084008\t0.2950428605573193\n"
+     ]
+    }
+   ],
+   "source": [
+    "def test_sample(sample):\n",
+    "\timage, depth = sample\n",
+    "\n",
+    "\t# crop\n",
+    "\timage_crop = crop(image)\n",
+    "\tdepth_crop = crop(depth)\n",
+    "\n",
+    "\n",
+    "\t# threshold\n",
+    "\timage_bin = rgb_threshold(image_crop)\n",
+    "\tdepth_bin = depth_threshold(depth_crop)\n",
+    "\n",
+    "\t# find centroid\n",
+    "\timage_center = get_centroid(image_bin)\n",
+    "\tdepth_center = get_centroid(depth_bin)\n",
+    "\tcentroid_distance = np.linalg.norm(image_center - depth_center)\n",
+    "\tcentroid_distance_mm = centroid_distance * px_to_mm\n",
+    "\t# print(f\"centroid_distance: {centroid_distance} px, {centroid_distance_mm} mm\")\n",
+    "\n",
+    "\trect_distance = get_rect_distance(image_box, depth_box)\n",
+    "\trect_distance_mm = rect_distance * px_to_mm\n",
+    "\t# print(f\"rect_distance: {rect_distance} px, {rect_distance_mm} mm\")\n",
+    "\n",
+    "\t# border error\n",
+    "\tavg_error_width_px = get_border_error_width(image_bin, depth_bin)\n",
+    "\tavg_error_width_mm = avg_error_width_px * px_to_mm\n",
+    "\t# print(f\"error width: {avg_error_width_px} px, {avg_error_width_mm} mm\")\n",
+    "\n",
+    "\n",
+    "\treturn centroid_distance_mm, rect_distance_mm, avg_error_width_mm\n",
+    "\n",
+    "\n",
+    "print(f\"device            \\tcentroid_distances [mm]\\trect_distances [mm]\\terror_widths [mm]\")\n",
+    "for id, device in recordings.items():\n",
+    "\tcentroid_distances = []\n",
+    "\trect_distances = []\n",
+    "\terror_widths = []\n",
+    "\tfor sample in device:\n",
+    "\t\tcentroid, rect, widths = test_sample(sample)\n",
+    "\t\tcentroid_distances.append(centroid)\n",
+    "\t\trect_distances.append(rect)\n",
+    "\t\terror_widths.append(widths)\n",
+    "\t\n",
+    "\tprint(f\"{id}\\t{np.mean(centroid_distances)}\\t{np.mean(rect_distances)}\\t{np.mean(error_widths)}\")\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.9.13"
+  },
+  "orig_nbformat": 4,
+  "vscode": {
+   "interpreter": {
+    "hash": "d5aff273cadca5907942115251fadeca1a08a1d7679a95aff41f265797748046"
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/1/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/1/depth.npy
new file mode 100644
index 000000000..a8769f1a0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/1/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/1/image.npy
new file mode 100644
index 000000000..17827e231
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/10/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/10/depth.npy
new file mode 100644
index 000000000..94b4cb3a1
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/10/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/10/image.npy
new file mode 100644
index 000000000..a48400783
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/2/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/2/depth.npy
new file mode 100644
index 000000000..a8769f1a0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/2/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/2/image.npy
new file mode 100644
index 000000000..17827e231
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/3/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/3/depth.npy
new file mode 100644
index 000000000..a8769f1a0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/3/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/3/image.npy
new file mode 100644
index 000000000..17827e231
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/4/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/4/depth.npy
new file mode 100644
index 000000000..d36b62214
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/4/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/4/image.npy
new file mode 100644
index 000000000..3d1e44527
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/5/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/5/depth.npy
new file mode 100644
index 000000000..d36b62214
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/5/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/5/image.npy
new file mode 100644
index 000000000..3d1e44527
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/6/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/6/depth.npy
new file mode 100644
index 000000000..94b4cb3a1
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/6/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/6/image.npy
new file mode 100644
index 000000000..a48400783
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/7/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/7/depth.npy
new file mode 100644
index 000000000..94b4cb3a1
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/7/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/7/image.npy
new file mode 100644
index 000000000..a48400783
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/8/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/8/depth.npy
new file mode 100644
index 000000000..94b4cb3a1
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/8/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/8/image.npy
new file mode 100644
index 000000000..a48400783
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/9/depth.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/9/depth.npy
new file mode 100644
index 000000000..94b4cb3a1
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301021A7751300/9/image.npy b/depth-color-alignment-test/v2/recordings/1944301021A7751300/9/image.npy
new file mode 100644
index 000000000..a48400783
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301021A7751300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/1/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/1/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/1/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/1/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/10/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/10/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/10/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/10/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/2/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/2/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/2/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/2/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/3/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/3/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/3/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/3/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/4/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/4/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/4/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/4/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/5/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/5/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/5/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/5/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/6/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/6/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/6/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/6/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/7/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/7/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/7/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/7/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/8/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/8/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/8/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/8/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/9/depth.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/9/depth.npy
new file mode 100644
index 000000000..f360df649
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301031F7731300/9/image.npy b/depth-color-alignment-test/v2/recordings/1944301031F7731300/9/image.npy
new file mode 100644
index 000000000..f30bfce5b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301031F7731300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/1/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/1/depth.npy
new file mode 100644
index 000000000..824cd3939
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/1/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/1/image.npy
new file mode 100644
index 000000000..b806cdb23
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/10/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/10/depth.npy
new file mode 100644
index 000000000..fd9c70aa0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/10/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/10/image.npy
new file mode 100644
index 000000000..2b18ccd21
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/2/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/2/depth.npy
new file mode 100644
index 000000000..824cd3939
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/2/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/2/image.npy
new file mode 100644
index 000000000..b806cdb23
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/3/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/3/depth.npy
new file mode 100644
index 000000000..c4de9ebbc
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/3/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/3/image.npy
new file mode 100644
index 000000000..07f9b7013
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/4/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/4/depth.npy
new file mode 100644
index 000000000..c4de9ebbc
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/4/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/4/image.npy
new file mode 100644
index 000000000..07f9b7013
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/5/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/5/depth.npy
new file mode 100644
index 000000000..c4de9ebbc
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/5/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/5/image.npy
new file mode 100644
index 000000000..07f9b7013
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/6/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/6/depth.npy
new file mode 100644
index 000000000..c4de9ebbc
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/6/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/6/image.npy
new file mode 100644
index 000000000..07f9b7013
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/7/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/7/depth.npy
new file mode 100644
index 000000000..fd9c70aa0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/7/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/7/image.npy
new file mode 100644
index 000000000..2b18ccd21
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/8/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/8/depth.npy
new file mode 100644
index 000000000..fd9c70aa0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/8/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/8/image.npy
new file mode 100644
index 000000000..2b18ccd21
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/9/depth.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/9/depth.npy
new file mode 100644
index 000000000..fd9c70aa0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/1944301051D4751300/9/image.npy b/depth-color-alignment-test/v2/recordings/1944301051D4751300/9/image.npy
new file mode 100644
index 000000000..2b18ccd21
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/1944301051D4751300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/1/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/1/depth.npy
new file mode 100644
index 000000000..9d8e247a8
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/1/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/1/image.npy
new file mode 100644
index 000000000..919890ad5
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/10/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/10/depth.npy
new file mode 100644
index 000000000..ea2f60e3e
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/10/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/10/image.npy
new file mode 100644
index 000000000..99bd4be1b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/2/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/2/depth.npy
new file mode 100644
index 000000000..da1e074cb
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/2/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/2/image.npy
new file mode 100644
index 000000000..8bfcf821b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/3/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/3/depth.npy
new file mode 100644
index 000000000..da1e074cb
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/3/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/3/image.npy
new file mode 100644
index 000000000..8bfcf821b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/4/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/4/depth.npy
new file mode 100644
index 000000000..da1e074cb
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/4/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/4/image.npy
new file mode 100644
index 000000000..8bfcf821b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/5/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/5/depth.npy
new file mode 100644
index 000000000..a484b17b7
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/5/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/5/image.npy
new file mode 100644
index 000000000..f87b5b5d8
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/6/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/6/depth.npy
new file mode 100644
index 000000000..a484b17b7
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/6/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/6/image.npy
new file mode 100644
index 000000000..f87b5b5d8
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/7/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/7/depth.npy
new file mode 100644
index 000000000..a484b17b7
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/7/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/7/image.npy
new file mode 100644
index 000000000..f87b5b5d8
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/8/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/8/depth.npy
new file mode 100644
index 000000000..a484b17b7
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/8/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/8/image.npy
new file mode 100644
index 000000000..f87b5b5d8
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/9/depth.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/9/depth.npy
new file mode 100644
index 000000000..ea2f60e3e
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010813B771300/9/image.npy b/depth-color-alignment-test/v2/recordings/19443010813B771300/9/image.npy
new file mode 100644
index 000000000..99bd4be1b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010813B771300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/1/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/1/depth.npy
new file mode 100644
index 000000000..e59153aaa
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/1/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/1/image.npy
new file mode 100644
index 000000000..6fbbd1ac8
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/10/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/10/depth.npy
new file mode 100644
index 000000000..3938f874d
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/10/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/10/image.npy
new file mode 100644
index 000000000..98b899be0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/2/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/2/depth.npy
new file mode 100644
index 000000000..e59153aaa
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/2/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/2/image.npy
new file mode 100644
index 000000000..6fbbd1ac8
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/3/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/3/depth.npy
new file mode 100644
index 000000000..f389b304f
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/3/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/3/image.npy
new file mode 100644
index 000000000..b5e8545d9
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/4/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/4/depth.npy
new file mode 100644
index 000000000..f389b304f
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/4/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/4/image.npy
new file mode 100644
index 000000000..b5e8545d9
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/5/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/5/depth.npy
new file mode 100644
index 000000000..f389b304f
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/5/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/5/image.npy
new file mode 100644
index 000000000..b5e8545d9
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/6/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/6/depth.npy
new file mode 100644
index 000000000..f389b304f
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/6/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/6/image.npy
new file mode 100644
index 000000000..b5e8545d9
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/7/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/7/depth.npy
new file mode 100644
index 000000000..f389b304f
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/7/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/7/image.npy
new file mode 100644
index 000000000..b5e8545d9
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/8/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/8/depth.npy
new file mode 100644
index 000000000..3938f874d
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/8/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/8/image.npy
new file mode 100644
index 000000000..98b899be0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/9/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/9/depth.npy
new file mode 100644
index 000000000..3938f874d
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1AC731300/9/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/9/image.npy
new file mode 100644
index 000000000..98b899be0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1AC731300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/1/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/1/depth.npy
new file mode 100644
index 000000000..396dbb4ef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/1/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/1/image.npy
new file mode 100644
index 000000000..f9481260c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/10/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/10/depth.npy
new file mode 100644
index 000000000..40b035883
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/10/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/10/image.npy
new file mode 100644
index 000000000..10bd14771
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/2/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/2/depth.npy
new file mode 100644
index 000000000..396dbb4ef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/2/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/2/image.npy
new file mode 100644
index 000000000..f9481260c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/3/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/3/depth.npy
new file mode 100644
index 000000000..396dbb4ef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/3/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/3/image.npy
new file mode 100644
index 000000000..f9481260c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/4/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/4/depth.npy
new file mode 100644
index 000000000..e8e8a57a2
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/4/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/4/image.npy
new file mode 100644
index 000000000..dcb859b66
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/5/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/5/depth.npy
new file mode 100644
index 000000000..e8e8a57a2
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/5/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/5/image.npy
new file mode 100644
index 000000000..dcb859b66
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/6/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/6/depth.npy
new file mode 100644
index 000000000..e8e8a57a2
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/6/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/6/image.npy
new file mode 100644
index 000000000..dcb859b66
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/7/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/7/depth.npy
new file mode 100644
index 000000000..e8e8a57a2
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/7/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/7/image.npy
new file mode 100644
index 000000000..dcb859b66
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/8/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/8/depth.npy
new file mode 100644
index 000000000..40b035883
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/8/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/8/image.npy
new file mode 100644
index 000000000..10bd14771
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/9/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/9/depth.npy
new file mode 100644
index 000000000..40b035883
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1D3731300/9/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/9/image.npy
new file mode 100644
index 000000000..10bd14771
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1D3731300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/1/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/1/depth.npy
new file mode 100644
index 000000000..a84bf1928
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/1/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/1/image.npy
new file mode 100644
index 000000000..0af4866bb
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/10/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/10/depth.npy
new file mode 100644
index 000000000..b8e018bef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/10/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/10/image.npy
new file mode 100644
index 000000000..60cbcd59c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/2/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/2/depth.npy
new file mode 100644
index 000000000..a84bf1928
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/2/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/2/image.npy
new file mode 100644
index 000000000..0af4866bb
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/3/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/3/depth.npy
new file mode 100644
index 000000000..90609da50
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/3/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/3/image.npy
new file mode 100644
index 000000000..32ee12418
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/4/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/4/depth.npy
new file mode 100644
index 000000000..90609da50
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/4/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/4/image.npy
new file mode 100644
index 000000000..32ee12418
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/5/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/5/depth.npy
new file mode 100644
index 000000000..90609da50
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/5/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/5/image.npy
new file mode 100644
index 000000000..32ee12418
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/6/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/6/depth.npy
new file mode 100644
index 000000000..b8e018bef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/6/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/6/image.npy
new file mode 100644
index 000000000..60cbcd59c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/7/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/7/depth.npy
new file mode 100644
index 000000000..b8e018bef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/7/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/7/image.npy
new file mode 100644
index 000000000..60cbcd59c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/8/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/8/depth.npy
new file mode 100644
index 000000000..b8e018bef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/8/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/8/image.npy
new file mode 100644
index 000000000..60cbcd59c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/9/depth.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/9/depth.npy
new file mode 100644
index 000000000..b8e018bef
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/9/image.npy b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/9/image.npy
new file mode 100644
index 000000000..60cbcd59c
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010A1EB7E1300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/1/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/1/depth.npy
new file mode 100644
index 000000000..cf4546920
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/1/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/1/image.npy
new file mode 100644
index 000000000..3690a4347
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/10/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/10/depth.npy
new file mode 100644
index 000000000..0096977a5
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/10/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/10/image.npy
new file mode 100644
index 000000000..e51a27e06
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/2/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/2/depth.npy
new file mode 100644
index 000000000..cf4546920
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/2/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/2/image.npy
new file mode 100644
index 000000000..3690a4347
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/3/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/3/depth.npy
new file mode 100644
index 000000000..cf4546920
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/3/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/3/image.npy
new file mode 100644
index 000000000..3690a4347
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/4/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/4/depth.npy
new file mode 100644
index 000000000..cf4546920
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/4/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/4/image.npy
new file mode 100644
index 000000000..3690a4347
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/5/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/5/depth.npy
new file mode 100644
index 000000000..cf4546920
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/5/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/5/image.npy
new file mode 100644
index 000000000..3690a4347
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/6/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/6/depth.npy
new file mode 100644
index 000000000..702a21c49
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/6/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/6/image.npy
new file mode 100644
index 000000000..d2488f114
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/7/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/7/depth.npy
new file mode 100644
index 000000000..702a21c49
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/7/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/7/image.npy
new file mode 100644
index 000000000..d2488f114
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/8/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/8/depth.npy
new file mode 100644
index 000000000..702a21c49
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/8/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/8/image.npy
new file mode 100644
index 000000000..d2488f114
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/9/depth.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/9/depth.npy
new file mode 100644
index 000000000..702a21c49
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/9/image.npy b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/9/image.npy
new file mode 100644
index 000000000..d2488f114
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010C1FB7E1300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/1/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/1/depth.npy
new file mode 100644
index 000000000..c43790bd0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/1/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/1/image.npy
new file mode 100644
index 000000000..772b5a164
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/10/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/10/depth.npy
new file mode 100644
index 000000000..820b31605
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/10/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/10/image.npy
new file mode 100644
index 000000000..a94f2973d
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/2/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/2/depth.npy
new file mode 100644
index 000000000..c43790bd0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/2/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/2/image.npy
new file mode 100644
index 000000000..772b5a164
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/3/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/3/depth.npy
new file mode 100644
index 000000000..c43790bd0
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/3/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/3/image.npy
new file mode 100644
index 000000000..772b5a164
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/4/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/4/depth.npy
new file mode 100644
index 000000000..9a6fa45df
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/4/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/4/image.npy
new file mode 100644
index 000000000..eaf930f97
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/5/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/5/depth.npy
new file mode 100644
index 000000000..9a6fa45df
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/5/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/5/image.npy
new file mode 100644
index 000000000..eaf930f97
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/6/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/6/depth.npy
new file mode 100644
index 000000000..9a6fa45df
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/6/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/6/image.npy
new file mode 100644
index 000000000..eaf930f97
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/7/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/7/depth.npy
new file mode 100644
index 000000000..9a6fa45df
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/7/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/7/image.npy
new file mode 100644
index 000000000..eaf930f97
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/8/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/8/depth.npy
new file mode 100644
index 000000000..820b31605
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/8/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/8/image.npy
new file mode 100644
index 000000000..a94f2973d
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/9/depth.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/9/depth.npy
new file mode 100644
index 000000000..820b31605
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010D17E741300/9/image.npy b/depth-color-alignment-test/v2/recordings/19443010D17E741300/9/image.npy
new file mode 100644
index 000000000..a94f2973d
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010D17E741300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/1/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/1/depth.npy
new file mode 100644
index 000000000..df591b828
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/1/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/1/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/1/image.npy
new file mode 100644
index 000000000..72d6012dc
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/1/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/10/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/10/depth.npy
new file mode 100644
index 000000000..726af501b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/10/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/10/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/10/image.npy
new file mode 100644
index 000000000..838811553
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/10/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/2/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/2/depth.npy
new file mode 100644
index 000000000..df591b828
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/2/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/2/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/2/image.npy
new file mode 100644
index 000000000..72d6012dc
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/2/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/3/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/3/depth.npy
new file mode 100644
index 000000000..df591b828
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/3/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/3/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/3/image.npy
new file mode 100644
index 000000000..72d6012dc
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/3/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/4/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/4/depth.npy
new file mode 100644
index 000000000..1978932ec
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/4/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/4/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/4/image.npy
new file mode 100644
index 000000000..8a9231940
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/4/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/5/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/5/depth.npy
new file mode 100644
index 000000000..1978932ec
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/5/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/5/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/5/image.npy
new file mode 100644
index 000000000..8a9231940
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/5/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/6/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/6/depth.npy
new file mode 100644
index 000000000..1978932ec
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/6/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/6/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/6/image.npy
new file mode 100644
index 000000000..8a9231940
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/6/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/7/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/7/depth.npy
new file mode 100644
index 000000000..726af501b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/7/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/7/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/7/image.npy
new file mode 100644
index 000000000..838811553
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/7/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/8/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/8/depth.npy
new file mode 100644
index 000000000..726af501b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/8/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/8/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/8/image.npy
new file mode 100644
index 000000000..838811553
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/8/image.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/9/depth.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/9/depth.npy
new file mode 100644
index 000000000..726af501b
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/9/depth.npy differ
diff --git a/depth-color-alignment-test/v2/recordings/19443010E1C9731300/9/image.npy b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/9/image.npy
new file mode 100644
index 000000000..838811553
Binary files /dev/null and b/depth-color-alignment-test/v2/recordings/19443010E1C9731300/9/image.npy differ
diff --git a/depth-color-alignment-test/v2/recoreder.py b/depth-color-alignment-test/v2/recoreder.py
new file mode 100644
index 000000000..e9f3da0e1
--- /dev/null
+++ b/depth-color-alignment-test/v2/recoreder.py
@@ -0,0 +1,42 @@
+from camera import Camera
+import cv2
+import depthai as dai
+import numpy as np
+from pathlib import Path
+
+found, device_info = dai.Device.getAnyAvailableDevice()
+
+if not found:
+    print("No device found")
+    exit(1)
+
+camera = Camera(device_info, 0, show_video=False)
+
+i = 0
+
+recordings_path = Path(f"./recordings/{camera.mxid}")
+recordings_path.mkdir(parents=True, exist_ok=True)
+
+while True:
+    key = cv2.waitKey(1)
+
+    camera.update()
+
+    if camera.image_frame is not None and camera.depth_visualization_frame is not None:
+        cv2.imshow("Image", camera.image_frame)
+        cv2.imshow("Depth", camera.depth_visualization_frame)
+
+        if i > 0:
+            print(f"Recording {i}...")
+            p = recordings_path / str(i)
+            p.mkdir(parents=True, exist_ok=True)
+            np.save(p / f"image.npy", camera.image_frame)
+            np.save(p / f"depth.npy", camera.depth_frame)
+            i -= 1
+
+    if key == ord('r'):
+        i = 10
+    
+
+    if key == ord('q'):
+        break
diff --git a/depth-testing/UI_focus_testing.py b/depth-testing/UI_focus_testing.py
new file mode 100644
index 000000000..350431b4c
--- /dev/null
+++ b/depth-testing/UI_focus_testing.py
@@ -0,0 +1,243 @@
+import cv2
+import argparse
+import numpy as np
+import depthai as dai
+import os
+import time
+
+# color codings
+red = (255, 0, 0)
+green = (0, 255, 0)
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-tm", "--testMode", type=str ,required=True,
+                            help="Define the type of test. ex: oak_d")
+args = parser.parse_args()
+test_type = args.testMode
+
+font = cv2.FONT_HERSHEY_SIMPLEX
+aruco_dictionary = cv2.aruco.Dictionary_get(cv2.aruco.DICT_4X4_1000)
+
+def create_blank(width, height, rgb_color=(0, 0, 0)):
+    """Create new image(numpy array) filled with certain color in RGB"""
+    # Create black blank image
+    image = np.zeros((height, width, 3), np.uint8)
+
+    # Since OpenCV uses BGR, convert the color first
+    color = tuple(reversed(rgb_color))
+    # Fill image with color
+    image[:] = color
+
+    return image
+
+def create_pipeline(enableLR, enableRgb):
+    pipeline = dai.Pipeline()
+
+    if enableLR:
+        cam_left = pipeline.createMonoCamera()
+        cam_right = pipeline.createMonoCamera()
+
+        xout_left = pipeline.createXLinkOut()
+        xout_right = pipeline.createXLinkOut()
+
+        cam_left.setBoardSocket(dai.CameraBoardSocket.LEFT)
+        cam_right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+                
+        cam_left.setResolution(
+            dai.MonoCameraProperties.SensorResolution.THE_800_P)
+
+        cam_right.setResolution(
+            dai.MonoCameraProperties.SensorResolution.THE_800_P)
+        cam_left.setFps(10)
+        cam_right.setFps(10)
+
+        xout_left.setStreamName("left")
+        cam_left.out.link(xout_left.input)
+
+        xout_right.setStreamName("right")
+        cam_right.out.link(xout_right.input)
+
+    if enableRgb:
+        rgb_cam = pipeline.createColorCamera()
+        controlIn = pipeline.createXLinkIn()
+
+        rgb_cam.setResolution(
+            dai.ColorCameraProperties.SensorResolution.THE_4_K)
+        rgb_cam.setInterleaved(False)
+        rgb_cam.setBoardSocket(dai.CameraBoardSocket.RGB)
+        rgb_cam.setFps(10)
+        rgb_cam.setIspScale(1, 3)
+        rgb_cam.initialControl.setAutoFocusMode(dai.CameraControl.AutoFocusMode.AUTO)
+
+        controlIn.setStreamName('control')
+        controlIn.out.link(rgb_cam.inputControl)
+
+        xout_rgb_isp = pipeline.createXLinkOut()
+        xout_rgb_isp.setStreamName("rgb")
+        rgb_cam.isp.link(xout_rgb_isp.input)        
+
+    return pipeline
+
+
+enabledLR = False
+enabledRGB = False
+
+focusThreshold = 20
+if 'oak_1' in test_type:
+    enabledRGB = True
+else:
+    enabledLR = True
+    enabledRGB = True
+
+# TODO(sachin): Add detection and acceptance of board in LR before continuing  focal check 
+device = dai.Device() 
+pipeline = create_pipeline(enabledLR, enabledRGB)
+device.startPipeline(pipeline)
+
+if enabledLR:
+    left_camera_queue = device.getOutputQueue("left", 5, False)
+    right_camera_queue = device.getOutputQueue("right", 5, False)
+if enabledRGB:
+    rgb_camera_queue = device.getOutputQueue("rgb", 5, False)
+    rgb_control_queue = device.getInputQueue("control", 5, False)
+
+max_count   = 90
+rgb_count   = 0
+left_count  = 0
+right_count = 0
+
+lens_position = 0
+
+is_left_focused = False
+is_right_focused = False
+is_rgb_focused = False
+ctrl = dai.CameraControl()
+ctrl.setAutoFocusMode(dai.CameraControl.AutoFocusMode.AUTO)
+ctrl.setAutoFocusTrigger()
+
+rgb_control_queue.send(ctrl)
+
+trig_count = 0
+while True:
+    if enabledLR:
+        left_frame = left_camera_queue.getAll()[-1]
+        right_frame = right_camera_queue.getAll()[-1]
+        
+        dst_left = cv2.Laplacian(left_frame.getCvFrame(), cv2.CV_64F)
+        # abs_dst_left = cv2.convertScaleAbs(dst_left)
+        mu, sigma_left = cv2.meanStdDev(dst_left)
+
+        dst_right = cv2.Laplacian(right_frame.getCvFrame(), cv2.CV_64F)
+        # abs_dst_right = cv2.convertScaleAbs(dst_right)
+        mu, sigma_right = cv2.meanStdDev(dst_right)
+        print("SdtDev of Left: {} and right: {}".format(sigma_left, sigma_right))
+
+        if sigma_right > focusThreshold:
+            is_right_focused = True
+        right_count += 1
+
+        if sigma_left > focusThreshold:
+            is_left_focused = True
+        left_count += 1
+
+    if enabledRGB:
+        rgb_frame = rgb_camera_queue.getAll()[-1]
+        recent_color = cv2.cvtColor(rgb_frame.getCvFrame(), cv2.COLOR_BGR2GRAY)
+
+        marker_corners, _, _ = cv2.aruco.detectMarkers(recent_color, aruco_dictionary)
+        if len(marker_corners) < 20:
+            print("Board not detected. Waiting...!!!")
+            trig_count += 1
+            rgb_count += 1
+            if trig_count > 31:
+                trig_count = 0
+                rgb_control_queue.send(ctrl)
+                time.sleep(1)
+            if rgb_count > max_count:
+                break
+            continue
+
+        dst_rgb = cv2.Laplacian(recent_color, cv2.CV_64F)
+        # abs_dst_rgb = cv2.convertScaleAbs(dst_rgb)
+        mu, sigma_rgb = cv2.meanStdDev(dst_rgb)
+        print("SdtDev of RGB: {} with lens position of {}".format(sigma_rgb, rgb_frame.getLensPosition()))
+        cv2.imshow(" Recent Color Image", recent_color)
+        cv2.waitKey(1)
+
+        if sigma_rgb > focusThreshold:
+            lens_position = rgb_frame.getLensPosition()
+            is_rgb_focused = True
+        else:
+            trig_count += 1
+            if trig_count > 31:
+                trig_count = 0
+                rgb_control_queue.send(ctrl)
+                time.sleep(1)
+            
+        rgb_count += 1
+
+    if enabledLR and enabledRGB:
+        print("right count: {}, left count: {} and rgb count: {}".format(right_count, left_count, rgb_count))
+        if right_count > max_count and left_count > max_count and rgb_count > max_count:
+            break
+    elif enabledRGB:
+        if rgb_count > max_count:
+            break
+    else:
+        raise RuntimeError("Invalid Option")
+
+
+if is_rgb_focused:
+    calibration_handler = dai.CalibrationHandler()
+    calibration_handler.setLensPosition(dai.CameraBoardSocket.RGB, lens_position)
+    device.flashCalibration(calibration_handler)
+    print("Calibration Flashed")
+
+image = create_blank(512, 512, rgb_color=red)
+if enabledLR and enabledRGB:
+    if is_rgb_focused and is_left_focused and is_right_focused:
+        image = create_blank(512, 512, rgb_color=green)
+        cv2.putText(image,'Focus TEST',(10,250), font, 2,(0,0,0),2)
+        cv2.putText(image,'PASSED',(10,300), font, 2,(0,0,0),2)
+    elif not is_rgb_focused:
+        image = create_blank(512, 512, rgb_color=red)
+        cv2.putText(image,'RGB Focus TEST ',(10,250), font, 2,(0,0,0),2)
+        cv2.putText(image,'FAILED',(10,300), font, 2,(0,0,0),2)
+    elif not is_right_focused:
+        image = create_blank(512, 512, rgb_color=red)
+        cv2.putText(image,'Right Focus TEST ',(10,250), font, 2,(0,0,0),2)
+        cv2.putText(image,'FAILED',(10,300), font, 2,(0,0,0),2)
+    elif not is_left_focused:
+        image = create_blank(512, 512, rgb_color=red)
+        cv2.putText(image,'Left Focus TEST ',(10,250), font, 2,(0,0,0),2)
+        cv2.putText(image,'FAILED',(10,300), font, 2,(0,0,0),2)
+
+elif enabledRGB:
+    if is_rgb_focused:
+        image = create_blank(512, 512, rgb_color=green)
+        cv2.putText(image,'Focus TEST',(10,250), font, 2,(0,0,0),2)
+        cv2.putText(image,'PASSED',(10,300), font, 2,(0,0,0),2)
+    else:
+        image = create_blank(512, 512, rgb_color=red)
+        cv2.putText(image,'RGB Focus TEST ',(10,250), font, 2,(0,0,0),2)
+        cv2.putText(image,'FAILED',(10,300), font, 2,(0,0,0),2)
+
+print("Current Lens Position is {}".format(lens_position))
+cv2.imshow("Result Image", image)
+cv2.waitKey(0)
+
+""" src_gray = cv2.imread(args.imgPath, cv2.IMREAD_GRAYSCALE)
+
+dst = cv2.Laplacian(src_gray, cv2.CV_64F)
+
+abs_dst = cv2.convertScaleAbs(dst)
+
+# cv2.Scalar mu, sigma;
+mu, sigma = cv2.meanStdDev(dst)
+
+print("Image Mean: {} and StdDev: {}".format(mu, sigma))
+
+cv2.imshow(" Blurred Image", blur)
+cv2.imshow("Laplace Image", abs_dst)
+cv2.waitKey(0)
+ """
diff --git a/depth-testing/Writer_testing.py b/depth-testing/Writer_testing.py
new file mode 100644
index 000000000..daf760c30
--- /dev/null
+++ b/depth-testing/Writer_testing.py
@@ -0,0 +1,110 @@
+import cv2
+import argparse
+import numpy as np
+import depthai as dai
+import os
+
+# color codings
+white  = [255, 255, 255]
+orange = [143, 122, 4]
+red    = [230, 9, 9]
+green  = [4, 143, 7]
+black  = [0, 0, 0]
+
+
+test_type = 'oak_1'
+font = cv2.FONT_HERSHEY_SIMPLEX
+
+def create_blank(width, height, rgb_color=(0, 0, 0)):
+    """Create new image(numpy array) filled with certain color in RGB"""
+    # Create black blank image
+    image = np.zeros((height, width, 3), np.uint8)
+
+    # Since OpenCV uses BGR, convert the color first
+    color = tuple(reversed(rgb_color))
+    # Fill image with color
+    image[:] = color
+
+    return image
+
+def create_pipeline(enableLR, enableRgb):
+    pipeline = dai.Pipeline()
+
+    if enableLR:
+        cam_left = pipeline.createMonoCamera()
+        cam_right = pipeline.createMonoCamera()
+
+        xout_left = pipeline.createXLinkOut()
+        xout_right = pipeline.createXLinkOut()
+
+        cam_left.setBoardSocket(dai.CameraBoardSocket.LEFT)
+        cam_right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+                
+        cam_left.setResolution(
+            dai.MonoCameraProperties.SensorResolution.THE_800_P)
+
+        cam_right.setResolution(
+            dai.MonoCameraProperties.SensorResolution.THE_800_P)
+        cam_left.setFps(10)
+        cam_right.setFps(10)
+
+        xout_left.setStreamName("left")
+        cam_left.out.link(xout_left.input)
+
+        xout_right.setStreamName("right")
+        cam_right.out.link(xout_right.input)
+
+    if enableRgb:
+        rgb_cam = pipeline.createColorCamera()
+        rgb_cam.setResolution(
+            dai.ColorCameraProperties.SensorResolution.THE_4_K)
+        rgb_cam.setInterleaved(False)
+        rgb_cam.setBoardSocket(dai.CameraBoardSocket.RGB)
+        rgb_cam.setFps(10)
+        rgb_cam.setIspScale(1, 3)
+
+        xout_rgb_isp = pipeline.createXLinkOut()
+        xout_rgb_isp.setStreamName("rgb")
+        rgb_cam.isp.link(xout_rgb_isp.input)        
+
+    return pipeline
+
+
+enabledLR = False
+enabledRGB = False
+
+focusThreshold = 20
+if 'oak_1' in test_type:
+    enabledRGB = True
+else:
+    enabledLR = True
+    enabledRGB = True
+
+# TODO(sachin): Add detection and acceptance of board in LR before continuing  focal check 
+
+device = dai.Device() 
+pipeline = create_pipeline(enabledLR, enabledRGB)
+device.startPipeline(pipeline)
+
+if enabledLR:
+    left_camera_queue = device.getOutputQueue("left", 5, False)
+    right_camera_queue = device.getOutputQueue("right", 5, False)
+if enabledRGB:
+    rgb_camera_queue = device.getOutputQueue("rgb", 5, False)
+
+max_count = 90
+rgb_count   = 0
+left_count  = 0
+right_count = 0
+
+lens_position = 0
+
+is_left_focused = False
+is_right_focused = False
+is_rgb_focused = False
+
+
+calibration_handler = dai.CalibrationHandler()
+calibration_handler.setLensPosition(dai.CameraBoardSocket.RGB, 135)
+device.flashCalibration(calibration_handler)
+print("Calibration Flashed")
diff --git a/depth-testing/depth_tester2.py b/depth-testing/depth_tester2.py
new file mode 100644
index 000000000..6e34e5351
--- /dev/null
+++ b/depth-testing/depth_tester2.py
@@ -0,0 +1,284 @@
+import numpy as np
+from matplotlib import pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import time
+import cv2
+import argparse
+import depthai as dai
+import math
+
+X = np.random.rand(100, 3)*10
+Y = np.random.rand(100, 3)*5
+
+sbox = None
+ebox = None
+localSbox = None
+localEbox = None
+isBoxCompleted = False
+
+color = (255, 0, 0)
+parser = argparse.ArgumentParser()
+parser.add_argument("-gt", "--groundTruth", type=float,required=True,
+                            help="Set the actual disatance of the destination flat textured surface in mtrs")
+args = parser.parse_args()
+gtNormal = np.array([0, 0, 1], dtype=np.float32)
+gtD = - args.groundTruth
+gtPlane = (gtNormal, gtD)
+
+def pixel_coord_np(startX, startY, endX, endY):
+    """
+    Pixel in homogenous coordinate
+    Returns:
+        Pixel coordinate:       [3, width * height]
+    """
+    print(startX, startY, endX, endY)
+    x = np.linspace(startX, endX - 1, endX - startX).astype(np.int32)
+    y = np.linspace(startY, endY - 1, endY - startY).astype(np.int32)
+    
+    [x, y] = np.meshgrid(x, y)
+    return np.vstack((x.flatten(), y.flatten(), np.ones_like(x.flatten())))
+
+def search_depth(x, y, depth):
+    up_x, up_y, status = search_depth_pos(x, y, depth)
+    if not status:
+        up_x, up_y, status = search_depth_neg(x, y, depth)
+    return up_x, up_y
+    
+def search_depth_pos(x, y, depth):
+    def_x = x
+    def_y = y
+    while depth[y, x] == 0:
+        if depth[y + 1, x] != 0:
+            y += 1
+        elif depth[y, x + 1] != 0:
+            x += 1
+        else:
+            y += 1
+            x += 1
+        if abs(def_x - x) > 10 or abs(def_y - y) > 10:
+            return x, y, False
+    return x, y, True
+
+def search_depth_neg(x, y, depth):
+    def_x = x
+    def_y = y
+    while depth[y, x] == 0:
+        if depth[y - 1, x] != 0:
+            y -= 1
+        elif depth[y, x - 1] != 0:
+            x -= 1
+        else:
+            y -= 1
+            x -= 1
+        if abs(def_x - x) > 10 or abs(def_y - y) > 10:
+            return x, y, False
+    return x, y, True
+
+
+def on_mouse(event, x, y, flags, params):
+    global localSbox, localEbox, isBoxCompleted 
+    if event == cv2.EVENT_LBUTTONDOWN:
+        print('Start Mouse Position: '+str(x)+', '+str(y))
+        localSbox = (x, y)
+        isBoxCompleted = False
+        # boxes.append(sbox)
+    elif event == cv2.EVENT_LBUTTONUP:
+        print('End Mouse Position: '+str(x)+', '+str(y))
+        localEbox = (x, y)
+        isBoxCompleted = True
+
+def fitPlaneLTSQ(XYZ):
+    (rows, cols) = XYZ.shape
+    G = np.ones((rows, 3))
+    G[:, 0] = XYZ[:, 0]  #X
+    G[:, 1] = XYZ[:, 1]  #Y
+    Z = XYZ[:, 2]
+    (a, b, c),resid,rank,s = np.linalg.lstsq(G, Z)
+    normal = (a, b, -1)
+    nn = np.linalg.norm(normal)
+    normal = normal / nn
+    return (c, normal)
+
+# Plot Setup
+plt.ion()
+x, y, z = [], [], []
+fig = plt.figure()
+ax = fig.add_subplot(111, projection='3d')
+sc = ax.scatter(x, y, z)
+ax.set_xlabel('x')
+ax.set_ylabel('y')
+ax.set_zlabel('z')
+ax.set_zlim(-1,5)
+ax.set_xlim(-0.3,0.3)
+ax.set_ylim(-0.3,0.3)
+
+plotFitPlane = None
+
+# stereo mode configs
+lrcheck = False
+extended = False
+subpixel = False
+
+# Create pipeline
+pipeline = dai.Pipeline()
+
+# Define sources and outputs
+monoLeft = pipeline.createMonoCamera()
+monoRight = pipeline.createMonoCamera()
+stereo = pipeline.createStereoDepth()
+
+xoutDepth = pipeline.createXLinkOut()
+
+# XLinkOut
+xoutDepth.setStreamName("depth")
+
+# Properties
+monoLeft.setResolution(dai.MonoCameraProperties.SensorResolution.THE_480_P)
+monoLeft.setBoardSocket(dai.CameraBoardSocket.LEFT)
+monoRight.setResolution(dai.MonoCameraProperties.SensorResolution.THE_480_P)
+monoRight.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+
+stereo.setConfidenceThreshold(200)
+stereo.setRectifyEdgeFillColor(0)  # black, to better see the cutout
+# stereo.setInputResolution(1280, 720)
+stereo.initialConfig.setMedianFilter(dai.StereoDepthProperties.MedianFilter.MEDIAN_OFF)
+stereo.setLeftRightCheck(lrcheck)
+stereo.setExtendedDisparity(extended)
+stereo.setSubpixel(subpixel)
+
+# Linking
+monoLeft.out.link(stereo.left)
+monoRight.out.link(stereo.right)
+stereo.depth.link(xoutDepth.input)
+
+cv2.namedWindow('depth')
+fig.show()
+
+with dai.Device(pipeline) as device:
+    calibObj = device.readCalibration()
+    # TODO(sachin): Change camera frame to right camera from rectified right.
+    depthQueue = device.getOutputQueue(name="depth", maxSize=8, blocking=False)
+
+    M_right = np.array(calibObj.getCameraIntrinsics(calibObj.getStereoRightCameraId(), 1280, 720))
+    R2 = np.array(calibObj.getStereoRightRectificationRotation())
+    H_right_inv = np.linalg.inv(np.matmul(np.matmul(M_right, R2), np.linalg.inv(M_right)))
+    inter_conv = np.matmul(np.linalg.inv(M_right), H_right_inv)
+    cv2.setMouseCallback('depth', on_mouse)
+
+    while True:
+        depth = depthQueue.get()
+        depth_img = depth.getCvFrame()
+        frame = depth_img.copy()
+
+        cv2.rectangle(frame, sbox, ebox, color, 2)
+        # if sbox is not None and ebox is not None:
+        #     cv2.rectangle(frame, sbox, ebox, color, 2)
+        # cv2.imshow("depth", frame.astype(np.uint16))
+        depthFrameColor = cv2.normalize(frame, None, 255, 0, cv2.NORM_INF, cv2.CV_8UC1)
+        depthFrameColor = cv2.equalizeHist(depthFrameColor)
+        depthFrameColor = cv2.applyColorMap(depthFrameColor, cv2.COLORMAP_HOT)        
+        cv2.imshow("depth", depthFrameColor)
+
+        key = cv2.waitKey(1)
+        if key == ord('q'):
+            break
+        
+        if isBoxCompleted:
+            sbox = (min(localSbox[0], localEbox[0]), min(localSbox[1], localEbox[1]))
+            ebox = (max(localSbox[0], localEbox[0]), max(localSbox[1], localEbox[1]))
+        else:
+            continue
+
+        if (ebox[0] - sbox[0]) < 50  and (ebox[1] - sbox[1]) < 50:
+            print("Requires the ROI to be of shapa greater than 50x50")
+
+        if sbox is not None and ebox is not None:
+            print("Start - {} and end - {}".format(sbox, ebox))
+            
+            coord = pixel_coord_np(*sbox, *ebox)
+            roi = depth_img.copy()
+            roi = roi[sbox[1] : ebox[1], sbox[0] : ebox[0]]
+            
+            camCoords = np.dot(inter_conv, coord) * roi.flatten() / 1000.0 # [x, y, z]
+            # Removing Zeros from coordinates
+            validCamCoords = np.delete(camCoords, np.where(camCoords[2, :] == 0.0), axis=1)
+            # Removing outliers from Z coordinates. top and bottoom 0.5 percentile of valid depth
+            validCamCoords = np.delete(validCamCoords, np.where(validCamCoords[2, :] <= np.percentile(validCamCoords[2, :], 0.5)), axis=1)
+            validCamCoords = np.delete(validCamCoords, np.where(validCamCoords[2, :] >= np.percentile(validCamCoords[2, :], 99.5)), axis=1)
+
+            # Subsampling 4x4 grid points in the selected ROI
+            subsampledPixels = []
+            subsampledPixelsDepth = []
+            x_diff = ebox[0] - sbox[0]
+            y_diff = ebox[1] - sbox[1]
+            for i in range(4):
+                x_loc = sbox[0] + int(x_diff * (i/3)) 
+                for j in range(4):
+                    y_loc = sbox[1] + int(y_diff * (j/3))
+                    subsampledPixels.append([x_loc, y_loc, 1])
+                    if depth_img[y_loc, x_loc] == 0:
+                        x_loc, y_loc = search_depth(x_loc, y_loc, depth_img)
+                    subsampledPixelsDepth.append(depth_img[y_loc, x_loc])
+                    # print("Coordinate at {}, {} is {} & {} with depth of {}".format(i, j, x_loc, y_loc, depth_img[y_loc, x_loc]))
+
+            subsampledPixelsDepth = np.array(subsampledPixelsDepth)
+            subsampledPixels = np.array(subsampledPixels).transpose()
+
+            sub_points3D = np.dot(inter_conv, subsampledPixels) * subsampledPixelsDepth.flatten() / 1000.0 # [x, y, z]
+            sub_points3D = sub_points3D.transpose()
+            sc._offsets3d = (sub_points3D[:, 0], sub_points3D[:, 1], sub_points3D[:, 2])
+            
+            # Fitting the plane to the subsampled RPOI points
+            c, normal = fitPlaneLTSQ(sub_points3D)
+            maxx = np.max(sub_points3D[:,0])
+            maxy = np.max(sub_points3D[:,1])
+            minx = np.min(sub_points3D[:,0])
+            miny = np.min(sub_points3D[:,1])
+
+            d = -np.array([0.0, 0.0, c]).dot(normal)
+            fitPlane = (normal, d)
+            xx, yy = np.meshgrid([minx, maxx], [miny, maxy])
+            z = (-normal[0]*xx - normal[1]*yy - d)*1. / normal[2]
+
+            # Plotting the fit plane
+            if plotFitPlane is None:
+                plotFitPlane = ax.plot_surface(xx, yy, z, alpha=0.2)
+            else:
+                fitPlaneCorners = np.vstack((xx.flatten(),yy.flatten(), z.flatten(), np.ones((1,4))))
+                temp_col3 = fitPlaneCorners[:, 2].copy()
+                fitPlaneCorners[:, 2] = fitPlaneCorners[:, 3]
+                fitPlaneCorners[:, 3] = temp_col3
+                plotFitPlane._vec = fitPlaneCorners
+
+
+            print("Distance of subpixel from plane")
+            print(sub_points3D[0].dot(normal) + d)
+
+            plt.draw()
+
+            # Calculating the error
+            planeOffsetError = 0
+            gtOffsetError = 0
+            planeRmsOffsetError = 0
+            gtRmsOffsetError = 0
+
+            for roiPoint in validCamCoords.transpose():
+                fitPlaneDist = roiPoint.dot(normal) + d
+                gtPlaneDist = roiPoint.dot(gtPlane[0]) + gtPlane[1]
+                planeOffsetError += fitPlaneDist
+                gtOffsetError += gtPlaneDist
+                planeRmsOffsetError += fitPlaneDist**2
+                gtRmsOffsetError += gtPlaneDist**2
+
+            print("Plane Fit MSE: Avg depth pixels deviation from the calculated Plane Fit = {}".format(planeOffsetError / validCamCoords.shape[1]))
+            print("GT Plane MSE: Avg depth pixels deviation from the GT plane = {}".format(gtOffsetError / validCamCoords.shape[1]))
+            print("Plane Fit RMSE: Avg distance of points in ROI from the fitted plane = {}".format(math.sqrt(planeRmsOffsetError / validCamCoords.shape[1])))
+            print("GT Plane RMSE: Avg distance of points in ROI from the GT plane = {}".format(math.sqrt(gtRmsOffsetError / validCamCoords.shape[1])))
+            
+            totalPixels = (ebox[0] - sbox[0]) * (ebox[1] - sbox[1])
+            flatRoi = roi.flatten()
+            sampledPixels = np.delete(flatRoi, np.where(flatRoi == 0))
+            fill_rate = 100 * sampledPixels.shape[0] / totalPixels
+            print('fill rate is {}'.format(fill_rate))
+
+            plt.pause(0.1)
diff --git a/depth-testing/focus_testing.py b/depth-testing/focus_testing.py
new file mode 100644
index 000000000..12e18960b
--- /dev/null
+++ b/depth-testing/focus_testing.py
@@ -0,0 +1,36 @@
+import cv2
+import argparse
+import numpy as np
+import depthai
+import pygame
+from pygame.locals import *
+
+os.environ['SDL_VIDEO_WINDOW_POS'] = '1000,10'
+pygame.init()
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-ip", "--imgPath", type=str ,required=True,
+                            help="Path of the image file on which blur is calculated")
+args = parser.parse_args()
+
+src_gray = cv2.imread(args.imgPath, cv2.IMREAD_GRAYSCALE)
+blur = cv2.blur(src_gray,(5,5))
+
+dst = cv2.Laplacian(src_gray, cv2.CV_64F)
+dst_blr = cv2.Laplacian(blur, cv2.CV_64F)
+
+abs_dst = cv2.convertScaleAbs(dst)
+abs_dst_blr = cv2.convertScaleAbs(dst_blr)
+
+# cv2.Scalar mu, sigma;
+mu, sigma = cv2.meanStdDev(dst)
+mu_b, sigma_b = cv2.meanStdDev(dst_blr)
+
+print("Image Mean: {} and StdDev: {}".format(mu, sigma))
+print("Image blurred Mean: {} and StdDev: {}".format(mu_b, sigma_b))
+
+cv2.imshow(" Blurred Image", blur)
+cv2.imshow("Laplace Image", abs_dst)
+cv2.imshow("Laplace Blurred Image", abs_dst_blr)
+
+cv2.waitKey(0)
\ No newline at end of file
diff --git a/depth-testing/len_pos_reader.py b/depth-testing/len_pos_reader.py
new file mode 100644
index 000000000..178ba64cf
--- /dev/null
+++ b/depth-testing/len_pos_reader.py
@@ -0,0 +1,185 @@
+import cv2
+import argparse
+import numpy as np
+import depthai as dai
+import pygame
+from pygame.locals import *
+from pygame_checkbox import Checkbox, pygame_render_text
+import os
+
+os.environ['SDL_VIDEO_WINDOW_POS'] = '1000,10'
+pygame.init()
+
+# color codings
+white  = [255, 255, 255]
+orange = [143, 122, 4]
+red    = [230, 9, 9]
+green  = [4, 143, 7]
+black  = [0, 0, 0]
+
+parser = argparse.ArgumentParser()
+parser.add_argument("-tm", "--testMode", type=str ,required=True,
+                            help="Define the type of test. ex: oak_d")
+args = parser.parse_args()
+test_type = args.testMode
+
+def create_pipeline(enableLR, enableRgb):
+    pipeline = dai.Pipeline()
+
+    if enableLR:
+        cam_left = pipeline.createMonoCamera()
+        cam_right = pipeline.createMonoCamera()
+
+        xout_left = pipeline.createXLinkOut()
+        xout_right = pipeline.createXLinkOut()
+
+        cam_left.setBoardSocket(dai.CameraBoardSocket.LEFT)
+        cam_right.setBoardSocket(dai.CameraBoardSocket.RIGHT)
+                
+        cam_left.setResolution(
+            dai.MonoCameraProperties.SensorResolution.THE_800_P)
+
+        cam_right.setResolution(
+            dai.MonoCameraProperties.SensorResolution.THE_800_P)
+        cam_left.setFps(10)
+        cam_right.setFps(10)
+
+        xout_left.setStreamName("left")
+        cam_left.out.link(xout_left.input)
+
+        xout_right.setStreamName("right")
+        cam_right.out.link(xout_right.input)
+
+    if enableRgb:
+        rgb_cam = pipeline.createColorCamera()
+        rgb_cam.setResolution(
+            dai.ColorCameraProperties.SensorResolution.THE_4_K)
+        rgb_cam.setInterleaved(False)
+        rgb_cam.setBoardSocket(dai.CameraBoardSocket.RGB)
+        rgb_cam.setFps(10)
+        rgb_cam.setIspScale(1, 3)
+
+        xout_rgb_isp = pipeline.createXLinkOut()
+        xout_rgb_isp.setStreamName("rgb")
+        rgb_cam.isp.link(xout_rgb_isp.input)        
+
+    return pipeline
+
+
+enabledLR = False
+enabledRGB = False
+
+focusThreshold = 20
+if 'oak_1' in test_type:
+    enabledRGB = True
+else:
+    enabledLR = True
+    enabledRGB = True
+
+# TODO(sachin): Add detection and acceptance of board in LR before continuing  focal check 
+
+device = dai.Device() 
+pipeline = create_pipeline(enabledLR, enabledRGB)
+device.startPipeline(pipeline)
+
+if enabledLR:
+    left_camera_queue = device.getOutputQueue("left", 5, False)
+    right_camera_queue = device.getOutputQueue("right", 5, False)
+if enabledRGB:
+    rgb_camera_queue = device.getOutputQueue("rgb", 5, False)
+
+max_count = 90
+rgb_count   = 0
+left_count  = 0
+right_count = 0
+
+lens_position = 0
+
+is_left_focused = False
+is_right_focused = False
+is_rgb_focused = False
+
+while True:
+    # pygame.display.update()
+
+    if enabledLR:
+        left_frame = left_camera_queue.getAll()[-1]
+        right_frame = right_camera_queue.getAll()[-1]
+        
+        dst_left = cv2.Laplacian(left_frame.getCvFrame(), cv2.CV_64F)
+        # abs_dst_left = cv2.convertScaleAbs(dst_left)
+        mu, sigma_left = cv2.meanStdDev(dst_left)
+
+        dst_right = cv2.Laplacian(right_frame.getCvFrame(), cv2.CV_64F)
+        # abs_dst_right = cv2.convertScaleAbs(dst_right)
+        mu, sigma_right = cv2.meanStdDev(dst_right)
+        print("SdtDev of Left: {} and right: {}".format(sigma_left, sigma_right))
+
+        if sigma_right > focusThreshold:
+            is_right_focused = True
+        right_count += 1
+
+        if sigma_left > focusThreshold:
+            is_left_focused = True
+        left_count += 1
+
+        
+    if enabledRGB:
+        rgb_frame = rgb_camera_queue.getAll()[-1]
+        recent_color = cv2.cvtColor(rgb_frame.getCvFrame(), cv2.COLOR_BGR2GRAY)
+
+        dst_rgb = cv2.Laplacian(recent_color, cv2.CV_64F)
+        # abs_dst_rgb = cv2.convertScaleAbs(dst_rgb)
+        mu, sigma_rgb = cv2.meanStdDev(dst_rgb)
+        print("SdtDev of RGB: {} with lens position of {}".format(sigma_rgb, rgb_frame.getLensPosition()))
+        cv2.imshow(" Recent Color Image", recent_color)
+        cv2.waitKey(1)
+
+        if sigma_rgb > focusThreshold:
+            lens_position = rgb_frame.getLensPosition()
+            is_rgb_focused = True
+        rgb_count += 1
+        
+
+    if enabledLR and enabledRGB:
+        print("right count: {}, left count: {} and rgb count: {}".format(right_count, left_count, rgb_count))
+        if right_count > max_count and left_count > max_count and rgb_count > max_count:
+            break
+    elif enabledRGB:
+        if rgb_count > max_count:
+            break
+    else:
+        raise RuntimeError("Invalid Option")
+
+
+if is_rgb_focused:
+    calibration_handler = dai.CalibrationHandler()
+    calibration_handler.setLensPosition(dai.CameraBoardSocket.RGB, lens_position)
+    device.flashCalibration(calibration_handler)
+    print("Calibration Flashed")
+
+if enabledLR and enabledRGB:
+    if is_rgb_focused and is_left_focused and is_right_focused:
+        pass
+elif enabledRGB:
+    if is_rgb_focused:
+        pass
+
+print("Current Lens Position is {}".format(lens_position))
+cv2.waitKey(0)
+
+""" src_gray = cv2.imread(args.imgPath, cv2.IMREAD_GRAYSCALE)
+
+dst = cv2.Laplacian(src_gray, cv2.CV_64F)
+
+abs_dst = cv2.convertScaleAbs(dst)
+
+# cv2.Scalar mu, sigma;
+mu, sigma = cv2.meanStdDev(dst)
+
+print("Image Mean: {} and StdDev: {}".format(mu, sigma))
+
+cv2.imshow(" Blurred Image", blur)
+cv2.imshow("Laplace Image", abs_dst)
+cv2.waitKey(0)
+ """
diff --git a/depth-testing/pygame_checkbox.py b/depth-testing/pygame_checkbox.py
new file mode 100644
index 000000000..72ecd65bf
--- /dev/null
+++ b/depth-testing/pygame_checkbox.py
@@ -0,0 +1,128 @@
+import pygame as pg
+
+white  = [255, 255, 255]
+orange = [143, 122, 4]
+red    = [230, 9, 9]
+green  = [4, 143, 7]
+black  = [0, 0, 0]
+
+def pygame_render_text(surface, text, pose, color=(0,0,0), font_size = 30 ):
+    font = pg.font.Font(None, font_size)
+    font_surf = font.render(text, True, color)
+    surface.blit(font_surf, pose)
+
+class Checkbox:
+    def __init__(self, surface, x, y, color=(230, 230, 230), caption="", outline_color=(0, 0, 0),
+                 check_color=(0, 0, 0), font_size=30, font_color=(0, 0, 0), text_offset=(28, 1),
+                disable_pass = False, check = False):
+        self.surface = surface
+        self.x = x
+        self.y = y
+        self.color = color
+        self.caption = caption
+        self.oc = outline_color
+        self.cc = check_color
+        self.fs = font_size
+        self.fc = font_color
+        self.to = text_offset
+        if not disable_pass:
+            self.test_pass     = "PASS        "
+            self.test_fail     = "FAIL        "
+            self.test_untested = "WAITING"
+        else:
+            self.test_pass = ""
+            self.test_fail = ""
+            self.test_untested = ""
+        # checkbox object
+        self.checkbox_obj = pg.Rect(self.x, self.y, 35, 35)
+        self.checkbox_outline = self.checkbox_obj.copy()
+        self.write_box =  pg.Rect(self.x + 42, self.y, 120, 35)
+        # variables to test the different states of the checkbox
+        self.checked = check    
+        if check:
+            self.unchecked = False
+            self.Unattended = False
+        else:
+            self.Unattended = True
+            self.unchecked = True
+        self.active = False
+        self.click = False
+
+    def _draw_button_text(self):
+        self.font = pg.font.Font(None, self.fs)
+        self.font_pos = (self.x + 45, self.y)
+        if self.checked:
+            pg.draw.rect(self.surface, (255,255,255), self.write_box)
+            self.font_surf = self.font.render(self.test_pass, True, green)
+            self.surface.blit(self.font_surf, self.font_pos)
+        else:
+            pg.draw.rect(self.surface, (255,255,255), self.write_box)
+            self.font_surf = self.font.render(self.test_fail, True, red)
+            self.surface.blit(self.font_surf, self.font_pos)
+        if self.Unattended:
+            pg.draw.rect(self.surface, (255,255,255), self.write_box)
+            self.font_surf = self.font.render(self.test_untested, True, orange)
+            self.surface.blit(self.font_surf, self.font_pos)
+        
+    def render_checkbox(self):
+        if self.checked:
+            pg.draw.rect(self.surface, self.color, self.checkbox_obj)
+            pg.draw.rect(self.surface, self.oc, self.checkbox_outline, 3)
+            pg.draw.circle(self.surface, self.cc, (self.x + 17, self.y + 17), 10)
+        elif self.unchecked:
+            pg.draw.rect(self.surface, self.color, self.checkbox_obj)
+            pg.draw.rect(self.surface, self.oc, self.checkbox_outline, 3)
+            self.checked = False
+        self._draw_button_text()
+
+    def _update(self, event_object):
+        x, y = event_object.pos
+        px, py, w, h = self.checkbox_obj  # getting check box dimensions
+        if px < x < px + w and py < y < py + h:
+            self.active = True
+        else:
+            self.active = False
+
+    def _mouse_up(self):
+            if self.active and not self.checked and self.click:
+                self.checked = True
+            elif self.active and self.checked and self.click:
+                self.checked = False
+                self.unchecked = True
+
+    def update_checkbox(self, event_object):
+        if event_object.type == pg.MOUSEBUTTONDOWN:
+            self.click = True
+        if event_object.type == pg.MOUSEBUTTONUP:
+            self._mouse_up()
+        if event_object.type == pg.MOUSEMOTION:
+            self._update(event_object)
+
+    def update_checkbox_rel(self, event_object, cb1, cb2):
+        if event_object.type == pg.MOUSEBUTTONDOWN:
+            self.click = True
+        if event_object.type == pg.MOUSEBUTTONUP:
+            self._mouse_up()
+        if event_object.type == pg.MOUSEMOTION:
+            self._update(event_object)
+        if self.checked:
+            cb1.uncheck()
+            cb2.uncheck()
+
+    def uncheck(self):
+        self.Unattended = False
+        self.checked = False
+        self.unchecked = True
+    
+    def check(self):
+        self.Unattended = False
+        self.checked = True
+        self.unchecked = False
+    
+    def setUnattended(self):
+        self.Unattended = True
+        self.checked = False
+        self.unchecked = True
+    
+    def is_checked(self):
+        return self.checked
diff --git a/depth-testing/requirements.txt b/depth-testing/requirements.txt
new file mode 100755
index 000000000..290d3e7ae
--- /dev/null
+++ b/depth-testing/requirements.txt
@@ -0,0 +1,2 @@
+--extra-index-url https://artifacts.luxonis.com/artifactory/luxonis-python-snapshot-local/
+depthai==2.17.3.1
diff --git a/parser/parseFiles.py b/parser/parseFiles.py
new file mode 100644
index 000000000..eb6846410
--- /dev/null
+++ b/parser/parseFiles.py
@@ -0,0 +1,468 @@
+import math
+import os
+import json
+import matplotlib.pyplot as plt
+
+
+def matrixToEuler(matrix):
+    if not matrix:
+        return []
+    sy = math.sqrt(matrix[0][0] * matrix[0][0] + matrix[1][0] * matrix[1][0])
+    singular = sy < 1e-6
+    if not singular:
+        x = math.atan2(matrix[2][1], matrix[2][2])
+        y = math.atan2(-matrix[2][0], sy)
+        z = math.atan2(matrix[1][0], matrix[0][0])
+    else:
+        x = math.atan2(-matrix[1][2], matrix[1][1])
+        y = math.atan2(-matrix[2][0], sy)
+        z = 0
+    return x, y, z
+
+
+def intrinsicData(matrix):
+    return matrix[0][0], matrix[0][2], matrix[1][1], matrix[1][2]
+
+
+class PoeData:
+    def __init__(self, boardName):
+        self.name = boardName
+
+        # sort all camera data into designated dictionaries
+        self.camera0 = dict()
+        self.camera1 = dict()
+        self.camera2 = dict()
+
+        # camera 0 specifications
+        self.camera0["distortionCoeff"] = []
+        self.camera0["rotationMatrix"] = dict()
+        self.camera0["rotationMatrix"]["r"] = []
+        self.camera0["rotationMatrix"]["p"] = []
+        self.camera0["rotationMatrix"]["y"] = []
+        self.camera0["specTranslation"] = dict()
+        self.camera0["specTranslation"]["x"] = []
+        self.camera0["specTranslation"]["y"] = []
+        self.camera0["specTranslation"]["z"] = []
+        self.camera0["translation"] = dict()
+        self.camera0["translation"]["x"] = []
+        self.camera0["translation"]["y"] = []
+        self.camera0["translation"]["z"] = []
+        self.camera0["height"] = []
+        self.camera0["intrinsicMatrix"] = dict()
+        self.camera0["intrinsicMatrix"]["f_x"] = []
+        self.camera0["intrinsicMatrix"]["f_y"] = []
+        self.camera0["intrinsicMatrix"]["c_x"] = []
+        self.camera0["intrinsicMatrix"]["c_y"] = []
+        self.camera0["specHfovDeg"] = []
+        self.camera0["width"] = []
+
+        # camera 1 specifications
+        self.camera1["distortionCoeff"] = []
+        self.camera1["rotationMatrix"] = dict()
+        self.camera1["rotationMatrix"]["r"] = []
+        self.camera1["rotationMatrix"]["p"] = []
+        self.camera1["rotationMatrix"]["y"] = []
+        self.camera1["specTranslation"] = dict()
+        self.camera1["specTranslation"]["x"] = []
+        self.camera1["specTranslation"]["y"] = []
+        self.camera1["specTranslation"]["z"] = []
+        self.camera1["translation"] = dict()
+        self.camera1["translation"]["x"] = []
+        self.camera1["translation"]["y"] = []
+        self.camera1["translation"]["z"] = []
+        self.camera1["height"] = []
+        self.camera1["intrinsicMatrix"] = dict()
+        self.camera1["intrinsicMatrix"]["f_x"] = []
+        self.camera1["intrinsicMatrix"]["f_y"] = []
+        self.camera1["intrinsicMatrix"]["c_x"] = []
+        self.camera1["intrinsicMatrix"]["c_y"] = []
+        self.camera1["specHfovDeg"] = []
+        self.camera1["width"] = []
+
+        # camera 2 specifications
+        self.camera2["distortionCoeff"] = []
+        self.camera2["rotationMatrix"] = dict()
+        self.camera2["rotationMatrix"]["r"] = []
+        self.camera2["rotationMatrix"]["p"] = []
+        self.camera2["rotationMatrix"]["y"] = []
+        self.camera2["specTranslation"] = dict()
+        self.camera2["specTranslation"]["x"] = []
+        self.camera2["specTranslation"]["y"] = []
+        self.camera2["specTranslation"]["z"] = []
+        self.camera2["translation"] = dict()
+        self.camera2["translation"]["x"] = []
+        self.camera2["translation"]["y"] = []
+        self.camera2["translation"]["z"] = []
+        self.camera2["height"] = []
+        self.camera2["intrinsicMatrix"] = dict()
+        self.camera2["intrinsicMatrix"]["f_x"] = []
+        self.camera2["intrinsicMatrix"]["f_y"] = []
+        self.camera2["intrinsicMatrix"]["c_x"] = []
+        self.camera2["intrinsicMatrix"]["c_y"] = []
+        self.camera2["specHfovDeg"] = []
+        self.camera2["width"] = []
+
+        # imu data
+        self.imuRotationMatrix = dict()
+        self.imuRotationMatrix["r"] = []
+        self.imuRotationMatrix["p"] = []
+        self.imuRotationMatrix["y"] = []
+        self.imuSpecTranslation = dict()
+        self.imuSpecTranslation["x"] = []
+        self.imuSpecTranslation["y"] = []
+        self.imuSpecTranslation["z"] = []
+        self.imuTranslation = dict()
+        self.imuTranslation["x"] = []
+        self.imuTranslation["y"] = []
+        self.imuTranslation["z"] = []
+
+        # rectified data
+        self.rectifiedRotationLeft = dict()
+        self.rectifiedRotationLeft["x"] = []
+        self.rectifiedRotationLeft["y"] = []
+        self.rectifiedRotationLeft["z"] = []
+        self.rectifiedRotationRight = dict()
+        self.rectifiedRotationRight["x"] = []
+        self.rectifiedRotationRight["y"] = []
+        self.rectifiedRotationRight["z"] = []
+
+        # miscellaneous data
+        self.miscellaneousData = []
+
+    def inputData(self, cameraData, imuData, miscellaneousData, rectificationData):
+        # because data in json files is not always in same order, we sort data before storing it
+        if cameraData[0][0] == 0:
+            # camera 0
+            self.camera0Save(cameraData[0][1])
+
+        elif cameraData[0][0] == 1:
+            # camera 1
+            self.camera1Save(cameraData[0][1])
+
+        else:
+            # camera 2
+            self.camera2Save(cameraData[0][1])
+        if len(cameraData) > 1:
+            if cameraData[1][0] == 0:
+                # camera 0
+                self.camera0Save(cameraData[1][1])
+
+            elif cameraData[1][0] == 1:
+                # camera 1
+                self.camera1Save(cameraData[1][1])
+
+            else:
+                # camera 2
+                self.camera2Save(cameraData[1][1])
+
+            if cameraData[2][0] == 0:
+                # camera 0
+                self.camera1Save(cameraData[2][1])
+
+            elif cameraData[2][0] == 1:
+                # camera 1
+                self.camera1Save(cameraData[2][1])
+
+            else:
+                # camera 2
+                self.camera2Save(cameraData[2][1])
+
+        # imu data
+        if imuData["rotationMatrix"]:
+            tmp = matrixToEuler(imuData["rotationMatrix"])
+            self.imuRotationMatrix["r"].append(tmp[0])
+            self.imuRotationMatrix["p"].append(tmp[1])
+            self.imuRotationMatrix["y"].append(tmp[2])
+        self.imuSpecTranslation["x"].append(imuData["specTranslation"]["x"])
+        self.imuSpecTranslation["y"].append(imuData["specTranslation"]["y"])
+        self.imuSpecTranslation["z"].append(imuData["specTranslation"]["z"])
+        self.imuTranslation["x"].append(imuData["translation"]["x"])
+        self.imuTranslation["y"].append(imuData["translation"]["y"])
+        self.imuTranslation["z"].append(imuData["translation"]["z"])
+
+        # miscellaneous data
+        if miscellaneousData:
+            self.miscellaneousData.append(miscellaneousData)
+
+        # rectification data
+        if rectificationData["rectifiedRotationLeft"]:
+            tmp = matrixToEuler(rectificationData["rectifiedRotationLeft"])
+            self.rectifiedRotationLeft["x"].append(tmp[0])
+            self.rectifiedRotationLeft["y"].append(tmp[1])
+            self.rectifiedRotationLeft["z"].append(tmp[2])
+        if rectificationData["rectifiedRotationRight"]:
+            tmp = matrixToEuler(rectificationData["rectifiedRotationRight"])
+            self.rectifiedRotationRight["x"].append(tmp[0])
+            self.rectifiedRotationRight["y"].append(tmp[1])
+            self.rectifiedRotationRight["z"].append(tmp[2])
+
+    def camera0Save(self, data):
+        self.camera0["distortionCoeff"].append(data["distortionCoeff"])
+
+        # camera 0 does not have rotation matrix?
+        # tmp = matrixToEuler(data["extrinsics"]["rotationMatrix"])
+        # self.camera0["rotationMatrix"]["r"].append(tmp[0])
+        # self.camera0["rotationMatrix"]["p"].append(tmp[1])
+        # self.camera0["rotationMatrix"]["y"].append(tmp[2])
+
+        # save each spec translation component
+        self.camera0["specTranslation"]["x"].append(data["extrinsics"]["specTranslation"]["x"])
+        self.camera0["specTranslation"]["y"].append(data["extrinsics"]["specTranslation"]["y"])
+        self.camera0["specTranslation"]["z"].append(data["extrinsics"]["specTranslation"]["z"])
+
+        # save each translation component
+        self.camera0["translation"]["x"].append(data["extrinsics"]["translation"]["x"])
+        self.camera0["translation"]["y"].append(data["extrinsics"]["translation"]["y"])
+        self.camera0["translation"]["z"].append(data["extrinsics"]["translation"]["z"])
+        self.camera0["height"].append(data["height"])
+
+        # save each intrinsic matrix component
+        tmp = intrinsicData(data["intrinsicMatrix"])
+        self.camera0["intrinsicMatrix"]["f_x"].append(tmp[0])
+        self.camera0["intrinsicMatrix"]["f_y"].append(tmp[2])
+        self.camera0["intrinsicMatrix"]["c_x"].append(tmp[1])
+        self.camera0["intrinsicMatrix"]["c_y"].append(tmp[3])
+        self.camera0["specHfovDeg"].append(data["specHfovDeg"])
+        self.camera0["width"].append(data["width"])
+
+    def camera1Save(self, data):
+        self.camera1["distortionCoeff"].append(data["distortionCoeff"])
+
+        # save each rotation matrix component
+        tmp = matrixToEuler(data["extrinsics"]["rotationMatrix"])
+        self.camera1["rotationMatrix"]["r"].append(tmp[0])
+        self.camera1["rotationMatrix"]["p"].append(tmp[1])
+        self.camera1["rotationMatrix"]["y"].append(tmp[2])
+
+        # save each spec translation component
+        self.camera1["specTranslation"]["x"].append(data["extrinsics"]["specTranslation"]["x"])
+        self.camera1["specTranslation"]["y"].append(data["extrinsics"]["specTranslation"]["y"])
+        self.camera1["specTranslation"]["z"].append(data["extrinsics"]["specTranslation"]["z"])
+
+        # save each translation component
+        self.camera1["translation"]["x"].append(data["extrinsics"]["translation"]["x"])
+        self.camera1["translation"]["y"].append(data["extrinsics"]["translation"]["y"])
+        self.camera1["translation"]["z"].append(data["extrinsics"]["translation"]["z"])
+        self.camera1["height"].append(data["height"])
+
+        # save each intrinsic matrix component
+        tmp = intrinsicData(data["intrinsicMatrix"])
+        self.camera1["intrinsicMatrix"]["f_x"].append(tmp[0])
+        self.camera1["intrinsicMatrix"]["f_y"].append(tmp[2])
+        self.camera1["intrinsicMatrix"]["c_x"].append(tmp[1])
+        self.camera1["intrinsicMatrix"]["c_y"].append(tmp[3])
+        self.camera1["specHfovDeg"].append(data["specHfovDeg"])
+        self.camera1["width"].append(data["width"])
+
+    def camera2Save(self, data):
+        self.camera2["distortionCoeff"].append(data["distortionCoeff"])
+
+        # save each rotation matrix component
+        tmp = matrixToEuler(data["extrinsics"]["rotationMatrix"])
+        self.camera2["rotationMatrix"]["r"].append(tmp[0])
+        self.camera2["rotationMatrix"]["p"].append(tmp[1])
+        self.camera2["rotationMatrix"]["y"].append(tmp[2])
+
+        # save each spec translation component
+        self.camera2["specTranslation"]["x"].append(data["extrinsics"]["specTranslation"]["x"])
+        self.camera2["specTranslation"]["y"].append(data["extrinsics"]["specTranslation"]["y"])
+        self.camera2["specTranslation"]["z"].append(data["extrinsics"]["specTranslation"]["z"])
+
+        # save each translation component
+        self.camera2["translation"]["x"].append(data["extrinsics"]["translation"]["x"])
+        self.camera2["translation"]["y"].append(data["extrinsics"]["translation"]["y"])
+        self.camera2["translation"]["z"].append(data["extrinsics"]["translation"]["z"])
+        self.camera2["height"].append(data["height"])
+
+        # save each intrinsic matrix component
+        tmp = intrinsicData(data["intrinsicMatrix"])
+        self.camera2["intrinsicMatrix"]["f_x"].append(tmp[0])
+        self.camera2["intrinsicMatrix"]["f_y"].append(tmp[2])
+        self.camera2["intrinsicMatrix"]["c_x"].append(tmp[1])
+        self.camera2["intrinsicMatrix"]["c_y"].append(tmp[3])
+        self.camera2["specHfovDeg"].append(data["specHfovDeg"])
+        self.camera2["width"].append(data["width"])
+
+    def plotHistogram(self, plotName):
+        # camera 0 data is shown separately
+        if plotName == "camera0-Rotation":
+            n, bins, patches = plt.hist(
+                [self.camera0["rotationMatrix"]["r"],
+                 self.camera0["rotationMatrix"]["p"],
+                 self.camera0["rotationMatrix"]["y"]],
+                label=['R', 'P', 'Y']
+                )
+            plt.title("Camera0-Rotation")
+
+        if plotName == "camera0-SpecTranslation":
+            n, bins, patches = plt.hist(
+                [self.camera0["specTranslation"]["x"],
+                 self.camera0["specTranslation"]["y"],
+                 self.camera0["specTranslation"]["z"]],
+                label=['X', 'Y', 'Z']
+            )
+            plt.title("Camera0-SpecTranslation")
+
+        if plotName == "camera0-Translation":
+            n, bins, patches = plt.hist(
+                [self.camera0["translation"]["x"],
+                 self.camera0["translation"]["y"],
+                 self.camera0["translation"]["z"]],
+                label=['X', 'Y', 'Z']
+            )
+            plt.title("Camera0-Translation")
+
+        if plotName == "camera0-WidthHeight":
+            n, bins, patches = plt.hist(
+                [self.camera0["width"],
+                 self.camera0["height"]],
+                label=['Width', 'Height']
+            )
+            plt.title("Camera0-WidthHeight")
+
+        if plotName == "camera0-IntrinsicMatrix":
+            n, bins, patches = plt.hist(
+                [self.camera0["intrinsicMatrix"]["f_x"],
+                 self.camera0["intrinsicMatrix"]["f_y"],
+                 self.camera0["intrinsicMatrix"]["c_x"],
+                 self.camera0["intrinsicMatrix"]["c_y"]],
+                label=['F_X', 'F_Y', 'C_X', 'C_Y']
+            )
+            plt.title("Camera0-IntrinsicMatrix")
+
+        if plotName == "camera0-SpecHfovDeg":
+            n, bins, patches = plt.hist(
+                self.camera0["specHfovDeg"],
+                label='SpecHFovDeg'
+            )
+            plt.title("Camera0-SpecHfovDeg")
+
+        # camera 1 and camera 2 data will be shown together
+        if plotName == "camera12-Rotation":
+            n, bins, patches = plt.hist(
+                [self.camera1["rotationMatrix"]["r"],
+                 self.camera2["rotationMatrix"]["r"],
+                 self.camera1["rotationMatrix"]["p"],
+                 self.camera2["rotationMatrix"]["p"],
+                 self.camera1["rotationMatrix"]["y"],
+                 self.camera2["rotationMatrix"]["y"]],
+                label=['R1', 'R2', 'P1', 'P2', 'Y1', 'Y2']
+                )
+            plt.title("Camera12-Rotation")
+        if plotName == "camera12-SpecTranslation":
+            n, bins, patches = plt.hist(
+                [self.camera1["specTranslation"]["x"],
+                 self.camera2["specTranslation"]["x"],
+                 self.camera1["specTranslation"]["y"],
+                 self.camera2["specTranslation"]["y"],
+                 self.camera1["specTranslation"]["z"],
+                 self.camera2["specTranslation"]["z"]],
+                label=['X1', 'X2', 'Y1', 'Y2', 'Z1', 'Z2']
+            )
+            plt.title("Camera12-SpecTranslation")
+
+        if plotName == "camera12-Translation":
+            n, bins, patches = plt.hist(
+                [self.camera1["translation"]["x"],
+                 self.camera2["translation"]["x"],
+                 self.camera1["translation"]["y"],
+                 self.camera2["translation"]["y"],
+                 self.camera1["translation"]["z"],
+                 self.camera2["translation"]["z"]],
+                label=['X1', 'X2', 'Y1', 'Y2', 'Z1', 'Z2']
+            )
+            plt.title("Camera12-Translation")
+
+        if plotName == "camera12-WidthHeight":
+            n, bins, patches = plt.hist(
+                [self.camera1["width"],
+                 self.camera2["width"],
+                 self.camera1["height"],
+                 self.camera2["height"]],
+                label=['Width1', 'Width2', 'Height1', 'Height2']
+            )
+            plt.title("Camera12-WidthHeight")
+
+        if plotName == "camera12-IntrinsicMatrix":
+            n, bins, patches = plt.hist(
+                [self.camera1["intrinsicMatrix"]["f_x"],
+                 self.camera2["intrinsicMatrix"]["f_x"],
+                 self.camera1["intrinsicMatrix"]["f_y"],
+                 self.camera2["intrinsicMatrix"]["f_y"],
+                 self.camera1["intrinsicMatrix"]["c_x"],
+                 self.camera2["intrinsicMatrix"]["c_x"],
+                 self.camera1["intrinsicMatrix"]["c_y"],
+                 self.camera2["intrinsicMatrix"]["c_y"]],
+                label=['F_X1', 'F_X2', 'F_Y1', 'F_Y2', 'C_X1', 'C_X2', 'C_Y1', 'C_Y2']
+            )
+            plt.title("Camera12-IntrinsicMatrix")
+
+        if plotName == "camera12-SpecHfovDeg":
+            n, bins, patches = plt.hist(
+                [self.camera1["specHfovDeg"],
+                 self.camera2["specHfovDeg"]],
+                label=['SpecHfovDeg1', 'SpecHfovDeg2']
+            )
+            plt.title("Camera12-SpecHfovDeg")
+
+        if plotName[:7] == "camera0":
+            cm = plt.cm.tab10
+        else:
+            cm = plt.cm.tab20
+        for i, p in enumerate(patches):
+            plt.setp(p, 'facecolor', cm(i))
+        plt.legend()
+        plt.xlabel("Values")
+        plt.ylabel("Number occurrences")
+        plt.show()
+
+
+# create dictionary for every camera type
+filesDic = dict()
+
+# provide path to folder with .json calibration files
+path = os.getcwd() + "/calib_files"
+for filename in os.listdir(path):
+    with open(os.path.join(path, filename), 'r') as f:
+        data = json.load(f)
+        if data["boardName"] not in filesDic:
+            # if camera type is not yet declared initialize it
+            filesDic[data["boardName"]] = PoeData(data["boardName"])
+
+        # send in data
+        filesDic[data["boardName"]].inputData(
+            data["cameraData"],
+            data["imuExtrinsics"],
+            data["miscellaneousData"],
+            data["stereoRectificationData"]
+        )
+
+
+# Camera types:
+# - BW1098OBC
+# - OAK-D
+# - OAK-D-IoT-40
+# - BW1092
+# - OAK-1-POE
+# - BW1093OAK
+# - OAK-1
+# - OAK-D-LITE
+# - OAK-D-POE
+# - OAK-D-PRO
+# - OAK-D-S2
+# to plot histograms you will have to specify which device's data you wish to see and which data you wish to plot
+# Plotting options are:
+# camera0-SpecTranslation
+# camera0-Translation
+# camera0-WidthHeight
+# camera0-IntrinsicMatrix
+# camera0-SpecHfovDeg
+# camera12-Rotation
+# camera12-SpecTranslation
+# camera12-Translation
+# camera12-WidthHeight
+# camera12-IntrinsicMatrix
+# camera12-SpecHfovDeg
+# MORE plotts can be added...
+filesDic["OAK-D"].plotHistogram("camera0-SpecTranslation")
+filesDic["OAK-D"].plotHistogram("camera12-Rotation")
diff --git a/parser/parserNotebook.ipynb b/parser/parserNotebook.ipynb
new file mode 100644
index 000000000..125fadaa7
--- /dev/null
+++ b/parser/parserNotebook.ipynb
@@ -0,0 +1,557 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# imports \n",
+    "import math\n",
+    "import os\n",
+    "import json\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def matrixToEuler(matrix):\n",
+    "    if not matrix:\n",
+    "        return []\n",
+    "    sy = math.sqrt(matrix[0][0] * matrix[0][0] + matrix[1][0] * matrix[1][0])\n",
+    "    singular = sy < 1e-6\n",
+    "    if not singular:\n",
+    "        x = math.atan2(matrix[2][1], matrix[2][2])\n",
+    "        y = math.atan2(-matrix[2][0], sy)\n",
+    "        z = math.atan2(matrix[1][0], matrix[0][0])\n",
+    "    else:\n",
+    "        x = math.atan2(-matrix[1][2], matrix[1][1])\n",
+    "        y = math.atan2(-matrix[2][0], sy)\n",
+    "        z = 0\n",
+    "    return x, y, z\n",
+    "\n",
+    "\n",
+    "def intrinsicData(matrix):\n",
+    "    return matrix[0][0], matrix[0][2], matrix[1][1], matrix[1][2]\n",
+    "\n",
+    "\n",
+    "class PoeData:\n",
+    "    def __init__(self, boardName):\n",
+    "        self.name = boardName\n",
+    "\n",
+    "        # sort all camera data into designated dictionaries\n",
+    "        self.camera0 = dict()\n",
+    "        self.camera1 = dict()\n",
+    "        self.camera2 = dict()\n",
+    "\n",
+    "        # camera 0 specifications\n",
+    "        self.camera0[\"distortionCoeff\"] = []\n",
+    "        self.camera0[\"rotationMatrix\"] = dict()\n",
+    "        self.camera0[\"rotationMatrix\"][\"r\"] = []\n",
+    "        self.camera0[\"rotationMatrix\"][\"p\"] = []\n",
+    "        self.camera0[\"rotationMatrix\"][\"y\"] = []\n",
+    "        self.camera0[\"specTranslation\"] = dict()\n",
+    "        self.camera0[\"specTranslation\"][\"x\"] = []\n",
+    "        self.camera0[\"specTranslation\"][\"y\"] = []\n",
+    "        self.camera0[\"specTranslation\"][\"z\"] = []\n",
+    "        self.camera0[\"translation\"] = dict()\n",
+    "        self.camera0[\"translation\"][\"x\"] = []\n",
+    "        self.camera0[\"translation\"][\"y\"] = []\n",
+    "        self.camera0[\"translation\"][\"z\"] = []\n",
+    "        self.camera0[\"height\"] = []\n",
+    "        self.camera0[\"intrinsicMatrix\"] = dict()\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"f_x\"] = []\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"f_y\"] = []\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"c_x\"] = []\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"c_y\"] = []\n",
+    "        self.camera0[\"specHfovDeg\"] = []\n",
+    "        self.camera0[\"width\"] = []\n",
+    "\n",
+    "        # camera 1 specifications\n",
+    "        self.camera1[\"distortionCoeff\"] = []\n",
+    "        self.camera1[\"rotationMatrix\"] = dict()\n",
+    "        self.camera1[\"rotationMatrix\"][\"r\"] = []\n",
+    "        self.camera1[\"rotationMatrix\"][\"p\"] = []\n",
+    "        self.camera1[\"rotationMatrix\"][\"y\"] = []\n",
+    "        self.camera1[\"specTranslation\"] = dict()\n",
+    "        self.camera1[\"specTranslation\"][\"x\"] = []\n",
+    "        self.camera1[\"specTranslation\"][\"y\"] = []\n",
+    "        self.camera1[\"specTranslation\"][\"z\"] = []\n",
+    "        self.camera1[\"translation\"] = dict()\n",
+    "        self.camera1[\"translation\"][\"x\"] = []\n",
+    "        self.camera1[\"translation\"][\"y\"] = []\n",
+    "        self.camera1[\"translation\"][\"z\"] = []\n",
+    "        self.camera1[\"height\"] = []\n",
+    "        self.camera1[\"intrinsicMatrix\"] = dict()\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"f_x\"] = []\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"f_y\"] = []\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"c_x\"] = []\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"c_y\"] = []\n",
+    "        self.camera1[\"specHfovDeg\"] = []\n",
+    "        self.camera1[\"width\"] = []\n",
+    "\n",
+    "        # camera 2 specifications\n",
+    "        self.camera2[\"distortionCoeff\"] = []\n",
+    "        self.camera2[\"rotationMatrix\"] = dict()\n",
+    "        self.camera2[\"rotationMatrix\"][\"r\"] = []\n",
+    "        self.camera2[\"rotationMatrix\"][\"p\"] = []\n",
+    "        self.camera2[\"rotationMatrix\"][\"y\"] = []\n",
+    "        self.camera2[\"specTranslation\"] = dict()\n",
+    "        self.camera2[\"specTranslation\"][\"x\"] = []\n",
+    "        self.camera2[\"specTranslation\"][\"y\"] = []\n",
+    "        self.camera2[\"specTranslation\"][\"z\"] = []\n",
+    "        self.camera2[\"translation\"] = dict()\n",
+    "        self.camera2[\"translation\"][\"x\"] = []\n",
+    "        self.camera2[\"translation\"][\"y\"] = []\n",
+    "        self.camera2[\"translation\"][\"z\"] = []\n",
+    "        self.camera2[\"height\"] = []\n",
+    "        self.camera2[\"intrinsicMatrix\"] = dict()\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"f_x\"] = []\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"f_y\"] = []\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"c_x\"] = []\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"c_y\"] = []\n",
+    "        self.camera2[\"specHfovDeg\"] = []\n",
+    "        self.camera2[\"width\"] = []\n",
+    "\n",
+    "        # imu data\n",
+    "        self.imuRotationMatrix = dict()\n",
+    "        self.imuRotationMatrix[\"r\"] = []\n",
+    "        self.imuRotationMatrix[\"p\"] = []\n",
+    "        self.imuRotationMatrix[\"y\"] = []\n",
+    "        self.imuSpecTranslation = dict()\n",
+    "        self.imuSpecTranslation[\"x\"] = []\n",
+    "        self.imuSpecTranslation[\"y\"] = []\n",
+    "        self.imuSpecTranslation[\"z\"] = []\n",
+    "        self.imuTranslation = dict()\n",
+    "        self.imuTranslation[\"x\"] = []\n",
+    "        self.imuTranslation[\"y\"] = []\n",
+    "        self.imuTranslation[\"z\"] = []\n",
+    "\n",
+    "        # rectified data\n",
+    "        self.rectifiedRotationLeft = dict()\n",
+    "        self.rectifiedRotationLeft[\"x\"] = []\n",
+    "        self.rectifiedRotationLeft[\"y\"] = []\n",
+    "        self.rectifiedRotationLeft[\"z\"] = []\n",
+    "        self.rectifiedRotationRight = dict()\n",
+    "        self.rectifiedRotationRight[\"x\"] = []\n",
+    "        self.rectifiedRotationRight[\"y\"] = []\n",
+    "        self.rectifiedRotationRight[\"z\"] = []\n",
+    "\n",
+    "        # miscellaneous data\n",
+    "        self.miscellaneousData = []\n",
+    "\n",
+    "    def inputData(self, cameraData, imuData, miscellaneousData, rectificationData):\n",
+    "        # because data in json files is not always in same order, we sort data before storing it\n",
+    "        if cameraData[0][0] == 0:\n",
+    "            # camera 0\n",
+    "            self.camera0Save(cameraData[0][1])\n",
+    "\n",
+    "        elif cameraData[0][0] == 1:\n",
+    "            # camera 1\n",
+    "            self.camera1Save(cameraData[0][1])\n",
+    "\n",
+    "        else:\n",
+    "            # camera 2\n",
+    "            self.camera2Save(cameraData[0][1])\n",
+    "        if len(cameraData) > 1:\n",
+    "            if cameraData[1][0] == 0:\n",
+    "                # camera 0\n",
+    "                self.camera0Save(cameraData[1][1])\n",
+    "\n",
+    "            elif cameraData[1][0] == 1:\n",
+    "                # camera 1\n",
+    "                self.camera1Save(cameraData[1][1])\n",
+    "\n",
+    "            else:\n",
+    "                # camera 2\n",
+    "                self.camera2Save(cameraData[1][1])\n",
+    "\n",
+    "            if cameraData[2][0] == 0:\n",
+    "                # camera 0\n",
+    "                self.camera1Save(cameraData[2][1])\n",
+    "\n",
+    "            elif cameraData[2][0] == 1:\n",
+    "                # camera 1\n",
+    "                self.camera1Save(cameraData[2][1])\n",
+    "\n",
+    "            else:\n",
+    "                # camera 2\n",
+    "                self.camera2Save(cameraData[2][1])\n",
+    "\n",
+    "        # imu data\n",
+    "        if imuData[\"rotationMatrix\"]:\n",
+    "            tmp = matrixToEuler(imuData[\"rotationMatrix\"])\n",
+    "            self.imuRotationMatrix[\"r\"].append(tmp[0])\n",
+    "            self.imuRotationMatrix[\"p\"].append(tmp[1])\n",
+    "            self.imuRotationMatrix[\"y\"].append(tmp[2])\n",
+    "        self.imuSpecTranslation[\"x\"].append(imuData[\"specTranslation\"][\"x\"])\n",
+    "        self.imuSpecTranslation[\"y\"].append(imuData[\"specTranslation\"][\"y\"])\n",
+    "        self.imuSpecTranslation[\"z\"].append(imuData[\"specTranslation\"][\"z\"])\n",
+    "        self.imuTranslation[\"x\"].append(imuData[\"translation\"][\"x\"])\n",
+    "        self.imuTranslation[\"y\"].append(imuData[\"translation\"][\"y\"])\n",
+    "        self.imuTranslation[\"z\"].append(imuData[\"translation\"][\"z\"])\n",
+    "\n",
+    "        # miscellaneous data\n",
+    "        if miscellaneousData:\n",
+    "            self.miscellaneousData.append(miscellaneousData)\n",
+    "\n",
+    "        # rectification data\n",
+    "        if rectificationData[\"rectifiedRotationLeft\"]:\n",
+    "            tmp = matrixToEuler(rectificationData[\"rectifiedRotationLeft\"])\n",
+    "            self.rectifiedRotationLeft[\"x\"].append(tmp[0])\n",
+    "            self.rectifiedRotationLeft[\"y\"].append(tmp[1])\n",
+    "            self.rectifiedRotationLeft[\"z\"].append(tmp[2])\n",
+    "        if rectificationData[\"rectifiedRotationRight\"]:\n",
+    "            tmp = matrixToEuler(rectificationData[\"rectifiedRotationRight\"])\n",
+    "            self.rectifiedRotationRight[\"x\"].append(tmp[0])\n",
+    "            self.rectifiedRotationRight[\"y\"].append(tmp[1])\n",
+    "            self.rectifiedRotationRight[\"z\"].append(tmp[2])\n",
+    "\n",
+    "    def camera0Save(self, data):\n",
+    "        self.camera0[\"distortionCoeff\"].append(data[\"distortionCoeff\"])\n",
+    "\n",
+    "        # camera 0 does not have rotation matrix?\n",
+    "        # tmp = matrixToEuler(data[\"extrinsics\"][\"rotationMatrix\"])\n",
+    "        # self.camera0[\"rotationMatrix\"][\"r\"].append(tmp[0])\n",
+    "        # self.camera0[\"rotationMatrix\"][\"p\"].append(tmp[1])\n",
+    "        # self.camera0[\"rotationMatrix\"][\"y\"].append(tmp[2])\n",
+    "\n",
+    "        # save each spec translation component\n",
+    "        self.camera0[\"specTranslation\"][\"x\"].append(data[\"extrinsics\"][\"specTranslation\"][\"x\"])\n",
+    "        self.camera0[\"specTranslation\"][\"y\"].append(data[\"extrinsics\"][\"specTranslation\"][\"y\"])\n",
+    "        self.camera0[\"specTranslation\"][\"z\"].append(data[\"extrinsics\"][\"specTranslation\"][\"z\"])\n",
+    "\n",
+    "        # save each translation component\n",
+    "        self.camera0[\"translation\"][\"x\"].append(data[\"extrinsics\"][\"translation\"][\"x\"])\n",
+    "        self.camera0[\"translation\"][\"y\"].append(data[\"extrinsics\"][\"translation\"][\"y\"])\n",
+    "        self.camera0[\"translation\"][\"z\"].append(data[\"extrinsics\"][\"translation\"][\"z\"])\n",
+    "        self.camera0[\"height\"].append(data[\"height\"])\n",
+    "\n",
+    "        # save each intrinsic matrix component\n",
+    "        tmp = intrinsicData(data[\"intrinsicMatrix\"])\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"f_x\"].append(tmp[0])\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"f_y\"].append(tmp[2])\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"c_x\"].append(tmp[1])\n",
+    "        self.camera0[\"intrinsicMatrix\"][\"c_y\"].append(tmp[3])\n",
+    "        self.camera0[\"specHfovDeg\"].append(data[\"specHfovDeg\"])\n",
+    "        self.camera0[\"width\"].append(data[\"width\"])\n",
+    "\n",
+    "    def camera1Save(self, data):\n",
+    "        self.camera1[\"distortionCoeff\"].append(data[\"distortionCoeff\"])\n",
+    "\n",
+    "        # save each rotation matrix component\n",
+    "        tmp = matrixToEuler(data[\"extrinsics\"][\"rotationMatrix\"])\n",
+    "        self.camera1[\"rotationMatrix\"][\"r\"].append(tmp[0])\n",
+    "        self.camera1[\"rotationMatrix\"][\"p\"].append(tmp[1])\n",
+    "        self.camera1[\"rotationMatrix\"][\"y\"].append(tmp[2])\n",
+    "\n",
+    "        # save each spec translation component\n",
+    "        self.camera1[\"specTranslation\"][\"x\"].append(data[\"extrinsics\"][\"specTranslation\"][\"x\"])\n",
+    "        self.camera1[\"specTranslation\"][\"y\"].append(data[\"extrinsics\"][\"specTranslation\"][\"y\"])\n",
+    "        self.camera1[\"specTranslation\"][\"z\"].append(data[\"extrinsics\"][\"specTranslation\"][\"z\"])\n",
+    "\n",
+    "        # save each translation component\n",
+    "        self.camera1[\"translation\"][\"x\"].append(data[\"extrinsics\"][\"translation\"][\"x\"])\n",
+    "        self.camera1[\"translation\"][\"y\"].append(data[\"extrinsics\"][\"translation\"][\"y\"])\n",
+    "        self.camera1[\"translation\"][\"z\"].append(data[\"extrinsics\"][\"translation\"][\"z\"])\n",
+    "        self.camera1[\"height\"].append(data[\"height\"])\n",
+    "\n",
+    "        # save each intrinsic matrix component\n",
+    "        tmp = intrinsicData(data[\"intrinsicMatrix\"])\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"f_x\"].append(tmp[0])\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"f_y\"].append(tmp[2])\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"c_x\"].append(tmp[1])\n",
+    "        self.camera1[\"intrinsicMatrix\"][\"c_y\"].append(tmp[3])\n",
+    "        self.camera1[\"specHfovDeg\"].append(data[\"specHfovDeg\"])\n",
+    "        self.camera1[\"width\"].append(data[\"width\"])\n",
+    "\n",
+    "    def camera2Save(self, data):\n",
+    "        self.camera2[\"distortionCoeff\"].append(data[\"distortionCoeff\"])\n",
+    "\n",
+    "        # save each rotation matrix component\n",
+    "        tmp = matrixToEuler(data[\"extrinsics\"][\"rotationMatrix\"])\n",
+    "        self.camera2[\"rotationMatrix\"][\"r\"].append(tmp[0])\n",
+    "        self.camera2[\"rotationMatrix\"][\"p\"].append(tmp[1])\n",
+    "        self.camera2[\"rotationMatrix\"][\"y\"].append(tmp[2])\n",
+    "\n",
+    "        # save each spec translation component\n",
+    "        self.camera2[\"specTranslation\"][\"x\"].append(data[\"extrinsics\"][\"specTranslation\"][\"x\"])\n",
+    "        self.camera2[\"specTranslation\"][\"y\"].append(data[\"extrinsics\"][\"specTranslation\"][\"y\"])\n",
+    "        self.camera2[\"specTranslation\"][\"z\"].append(data[\"extrinsics\"][\"specTranslation\"][\"z\"])\n",
+    "\n",
+    "        # save each translation component\n",
+    "        self.camera2[\"translation\"][\"x\"].append(data[\"extrinsics\"][\"translation\"][\"x\"])\n",
+    "        self.camera2[\"translation\"][\"y\"].append(data[\"extrinsics\"][\"translation\"][\"y\"])\n",
+    "        self.camera2[\"translation\"][\"z\"].append(data[\"extrinsics\"][\"translation\"][\"z\"])\n",
+    "        self.camera2[\"height\"].append(data[\"height\"])\n",
+    "\n",
+    "        # save each intrinsic matrix component\n",
+    "        tmp = intrinsicData(data[\"intrinsicMatrix\"])\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"f_x\"].append(tmp[0])\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"f_y\"].append(tmp[2])\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"c_x\"].append(tmp[1])\n",
+    "        self.camera2[\"intrinsicMatrix\"][\"c_y\"].append(tmp[3])\n",
+    "        self.camera2[\"specHfovDeg\"].append(data[\"specHfovDeg\"])\n",
+    "        self.camera2[\"width\"].append(data[\"width\"])\n",
+    "\n",
+    "    def plotHistogram(self, plotName):\n",
+    "        # camera 0 data is shown separately\n",
+    "        if plotName == \"camera0-Rotation\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera0[\"rotationMatrix\"][\"r\"],\n",
+    "                 self.camera0[\"rotationMatrix\"][\"p\"],\n",
+    "                 self.camera0[\"rotationMatrix\"][\"y\"]],\n",
+    "                label=['R', 'P', 'Y']\n",
+    "                )\n",
+    "            plt.title(\"Camera0-Rotation\")\n",
+    "\n",
+    "        if plotName == \"camera0-SpecTranslation\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera0[\"specTranslation\"][\"x\"],\n",
+    "                 self.camera0[\"specTranslation\"][\"y\"],\n",
+    "                 self.camera0[\"specTranslation\"][\"z\"]],\n",
+    "                label=['X', 'Y', 'Z']\n",
+    "            )\n",
+    "            plt.title(\"Camera0-SpecTranslation\")\n",
+    "\n",
+    "        if plotName == \"camera0-Translation\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera0[\"translation\"][\"x\"],\n",
+    "                 self.camera0[\"translation\"][\"y\"],\n",
+    "                 self.camera0[\"translation\"][\"z\"]],\n",
+    "                label=['X', 'Y', 'Z']\n",
+    "            )\n",
+    "            plt.title(\"Camera0-Translation\")\n",
+    "\n",
+    "        if plotName == \"camera0-WidthHeight\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera0[\"width\"],\n",
+    "                 self.camera0[\"height\"]],\n",
+    "                label=['Width', 'Height']\n",
+    "            )\n",
+    "            plt.title(\"Camera0-WidthHeight\")\n",
+    "\n",
+    "        if plotName == \"camera0-IntrinsicMatrix\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera0[\"intrinsicMatrix\"][\"f_x\"],\n",
+    "                 self.camera0[\"intrinsicMatrix\"][\"f_y\"],\n",
+    "                 self.camera0[\"intrinsicMatrix\"][\"c_x\"],\n",
+    "                 self.camera0[\"intrinsicMatrix\"][\"c_y\"]],\n",
+    "                label=['F_X', 'F_Y', 'C_X', 'C_Y']\n",
+    "            )\n",
+    "            plt.title(\"Camera0-IntrinsicMatrix\")\n",
+    "\n",
+    "        if plotName == \"camera0-SpecHfovDeg\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                self.camera0[\"specHfovDeg\"],\n",
+    "                label='SpecHFovDeg'\n",
+    "            )\n",
+    "            plt.title(\"Camera0-SpecHfovDeg\")\n",
+    "\n",
+    "        # camera 1 and camera 2 data will be shown together\n",
+    "        if plotName == \"camera12-Rotation\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera1[\"rotationMatrix\"][\"r\"],\n",
+    "                 self.camera2[\"rotationMatrix\"][\"r\"],\n",
+    "                 self.camera1[\"rotationMatrix\"][\"p\"],\n",
+    "                 self.camera2[\"rotationMatrix\"][\"p\"],\n",
+    "                 self.camera1[\"rotationMatrix\"][\"y\"],\n",
+    "                 self.camera2[\"rotationMatrix\"][\"y\"]],\n",
+    "                label=['R1', 'R2', 'P1', 'P2', 'Y1', 'Y2']\n",
+    "                )\n",
+    "            plt.title(\"Camera12-Rotation\")\n",
+    "        if plotName == \"camera12-SpecTranslation\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera1[\"specTranslation\"][\"x\"],\n",
+    "                 self.camera2[\"specTranslation\"][\"x\"],\n",
+    "                 self.camera1[\"specTranslation\"][\"y\"],\n",
+    "                 self.camera2[\"specTranslation\"][\"y\"],\n",
+    "                 self.camera1[\"specTranslation\"][\"z\"],\n",
+    "                 self.camera2[\"specTranslation\"][\"z\"]],\n",
+    "                label=['X1', 'X2', 'Y1', 'Y2', 'Z1', 'Z2']\n",
+    "            )\n",
+    "            plt.title(\"Camera12-SpecTranslation\")\n",
+    "\n",
+    "        if plotName == \"camera12-Translation\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera1[\"translation\"][\"x\"],\n",
+    "                 self.camera2[\"translation\"][\"x\"],\n",
+    "                 self.camera1[\"translation\"][\"y\"],\n",
+    "                 self.camera2[\"translation\"][\"y\"],\n",
+    "                 self.camera1[\"translation\"][\"z\"],\n",
+    "                 self.camera2[\"translation\"][\"z\"]],\n",
+    "                label=['X1', 'X2', 'Y1', 'Y2', 'Z1', 'Z2']\n",
+    "            )\n",
+    "            plt.title(\"Camera12-Translation\")\n",
+    "\n",
+    "        if plotName == \"camera12-WidthHeight\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera1[\"width\"],\n",
+    "                 self.camera2[\"width\"],\n",
+    "                 self.camera1[\"height\"],\n",
+    "                 self.camera2[\"height\"]],\n",
+    "                label=['Width1', 'Width2', 'Height1', 'Height2']\n",
+    "            )\n",
+    "            plt.title(\"Camera12-WidthHeight\")\n",
+    "\n",
+    "        if plotName == \"camera12-IntrinsicMatrix\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera1[\"intrinsicMatrix\"][\"f_x\"],\n",
+    "                 self.camera2[\"intrinsicMatrix\"][\"f_x\"],\n",
+    "                 self.camera1[\"intrinsicMatrix\"][\"f_y\"],\n",
+    "                 self.camera2[\"intrinsicMatrix\"][\"f_y\"],\n",
+    "                 self.camera1[\"intrinsicMatrix\"][\"c_x\"],\n",
+    "                 self.camera2[\"intrinsicMatrix\"][\"c_x\"],\n",
+    "                 self.camera1[\"intrinsicMatrix\"][\"c_y\"],\n",
+    "                 self.camera2[\"intrinsicMatrix\"][\"c_y\"]],\n",
+    "                label=['F_X1', 'F_X2', 'F_Y1', 'F_Y2', 'C_X1', 'C_X2', 'C_Y1', 'C_Y2']\n",
+    "            )\n",
+    "            plt.title(\"Camera12-IntrinsicMatrix\")\n",
+    "\n",
+    "        if plotName == \"camera12-SpecHfovDeg\":\n",
+    "            n, bins, patches = plt.hist(\n",
+    "                [self.camera1[\"specHfovDeg\"],\n",
+    "                 self.camera2[\"specHfovDeg\"]],\n",
+    "                label=['SpecHfovDeg1', 'SpecHfovDeg2']\n",
+    "            )\n",
+    "            plt.title(\"Camera12-SpecHfovDeg\")\n",
+    "\n",
+    "        if plotName[:7] == \"camera0\":\n",
+    "            cm = plt.cm.tab10\n",
+    "        else:\n",
+    "            cm = plt.cm.tab20\n",
+    "        for i, p in enumerate(patches):\n",
+    "            plt.setp(p, 'facecolor', cm(i))\n",
+    "        plt.legend()\n",
+    "        plt.xlabel(\"Values\")\n",
+    "        plt.ylabel(\"Number occurrences\")\n",
+    "        plt.show()\n",
+    "\n",
+    "\n",
+    "# create dictionary for every camera type\n",
+    "filesDic = dict()\n",
+    "\n",
+    "# provide path to folder with .json calibration files\n",
+    "path = os.getcwd() + \"/calib_files\"\n",
+    "for filename in os.listdir(path):\n",
+    "    with open(os.path.join(path, filename), 'r') as f:\n",
+    "        data = json.load(f)\n",
+    "        if data[\"boardName\"] not in filesDic:\n",
+    "            # if camera type is not yet declared initialize it\n",
+    "            filesDic[data[\"boardName\"]] = PoeData(data[\"boardName\"])\n",
+    "\n",
+    "        # send in data\n",
+    "        filesDic[data[\"boardName\"]].inputData(\n",
+    "            data[\"cameraData\"],\n",
+    "            data[\"imuExtrinsics\"],\n",
+    "            data[\"miscellaneousData\"],\n",
+    "            data[\"stereoRectificationData\"]\n",
+    "        )\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Camera types:\n",
+    "# - BW1098OBC\n",
+    "# - OAK-D\n",
+    "# - OAK-D-IoT-40\n",
+    "# - BW1092\n",
+    "# - OAK-1-POE\n",
+    "# - BW1093OAK\n",
+    "# - OAK-1\n",
+    "# - OAK-D-LITE\n",
+    "# - OAK-D-POE\n",
+    "# - OAK-D-PRO\n",
+    "# - OAK-D-S2\n",
+    "# to plot histograms you will have to specify which device's data you wish to see and which data you wish to plot\n",
+    "# Plotting options are:\n",
+    "# camera0-SpecTranslation\n",
+    "# camera0-Translation\n",
+    "# camera0-WidthHeight\n",
+    "# camera0-IntrinsicMatrix\n",
+    "# camera0-SpecHfovDeg\n",
+    "# camera12-Rotation\n",
+    "# camera12-SpecTranslation\n",
+    "# camera12-Translation\n",
+    "# camera12-WidthHeight\n",
+    "# camera12-IntrinsicMatrix\n",
+    "# camera12-SpecHfovDeg\n",
+    "# MORE plotts can be added...\n",
+    "filesDic[\"OAK-D\"].plotHistogram(\"camera12-Rotation\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "filesDic[\"OAK-D\"].plotHistogram(\"camera0-SpecTranslation\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "filesDic[\"OAK-D\"].plotHistogram(\"camera12-pecTranslation\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.7.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}