le bon c'est calibrate.py avec les datas dans le dossier damier puis left et right

calib.py

@@ -1,10 +1,11 @@
+
 #retval, corners = cv2.findChessboardCorners(image,patternSize, flags)
 
 import cv2
 import numpy as np
 
 # Define the size of the chessboard
-chessboard_size = (22, 16)
+chessboard_size = (8,5)
 
 # Define the object points of the chessboard
 object_points = np.zeros((np.prod(chessboard_size), 3), dtype=np.float32)
@@ -12,12 +13,12 @@ object_points[:, :2] = np.mgrid[0:chessboard_size[0], 0:chessboard_size[1]].T.re
 
 # Create arrays to store the object points and image points from all the images
 object_points_array = []
-image_points_array = []
+image_points_array1 = []
+image_points_array2 = []
 
 # Load the images
 images = []
-images.append(cv2.imread("/home/ros/Bureau/ca_ur5/left.jpg"))
-images.append(cv2.imread("/home/ros/Bureau/ca_ur5/left2.jpg"))
+images.append(cv2.imread("/home/ros/Bureau/ca_ur5/1.jpg"))
 # Add more images as needed
 
 # Loop through each image and find the chessboard corners
@@ -30,14 +31,55 @@ for image in images:
     # If the corners are found, add the object points and image points to the arrays
     if found:
         object_points_array.append(object_points)
-        image_points_array.append(corners)
+        image_points_array1.append(corners)
 
 # Calibrate the camera using the object points and image points
 ret, camera_matrix, distortion_coefficients, rotation_vectors, translation_vectors = cv2.calibrateCamera(
-    object_points_array, image_points_array, gray.shape[::-1], None, None)
+    object_points_array, image_points_array1, gray.shape[::-1], None, None)
 
 # Print the camera matrix and distortion coefficients
 print("Camera matrix:")
 print(camera_matrix)
 print("Distortion coefficients:")
 print(distortion_coefficients)
+
+
+# Load the images
+images = []
+images.append(cv2.imread("/home/ros/Bureau/ca_ur5/2.jpg"))
+# Add more images as needed
+
+# Loop through each image and find the chessboard corners
+for image in images:
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+    # Find the chessboard corners
+    found, corners = cv2.findChessboardCorners(gray, chessboard_size, None)
+
+    # If the corners are found, add the object points and image points to the arrays
+    if found:
+        object_points_array.append(object_points)
+        image_points_array2.append(corners)
+
+# Calibrate the camera using the object points and image points
+ret, camera_matrix, distortion_coefficients, rotation_vectors, translation_vectors = cv2.calibrateCamera(
+    object_points_array, image_points_array2, gray.shape[::-1], None, None)
+
+# Print the camera matrix and distortion coefficients
+print("Camera matrix:")
+print(camera_matrix)
+print("Distortion coefficients:")
+print(distortion_coefficients)
+
+print("Stereo calib")
+
+flags = 0
+flags |= cv2.CALIB_FIX_INTRINSIC
+# Here we fix the intrinsic camara matrixes so that only Rot, Trns, Emat and Fmat are calculated.
+# Hence intrinsic parameters are the same 
+ 
+criteria_stereo= (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+ 
+ 
+# This step is performed to transformation between the two cameras and calculate Essential and Fundamenatl matrix
+retS, new_mtxL, distL, new_mtxR, distR, Rot, Trns, Emat, Fmat = cv2.stereoCalibrate(object_points_array, image_points_array1, image_points_array2, new_mtxL, distL, new_mtxR, distR, imgL_gray.shape[::-1], criteria_stereo, flags)

calibonelib.py

@@ -0,0 +1,54 @@
+# Set the path to the images captured by the left and right cameras
+import cv2
+import numpy as np
+import tqdm as tqdm
+
+pathL = "/home/ros/Bureau/ca_ur5/1.jpg"
+pathR = "/home/ros/Bureau/ca_ur5/2.jpg"
+ 
+# Termination criteria for refining the detected corners
+criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+ 
+ 
+objp = np.zeros((8*5,3), np.float32)
+objp[:,:2] = np.mgrid[0:8,0:5].T.reshape(-1,2)
+ 
+img_ptsL = []
+img_ptsR = []
+obj_pts = []
+ 
+for i in tqdm(range(1,12)):
+  imgL = cv2.imread(pathL+"img%d.png"%i)
+  imgR = cv2.imread(pathR+"img%d.png"%i)
+  imgL_gray = cv2.imread(pathL+"img%d.png"%i,0)
+  imgR_gray = cv2.imread(pathR+"img%d.png"%i,0)
+ 
+  outputL = imgL.copy()
+  outputR = imgR.copy()
+ 
+  retR, cornersR =  cv2.findChessboardCorners(outputR,(8,5),None)
+  retL, cornersL = cv2.findChessboardCorners(outputL,(8,5),None)
+ 
+  if retR and retL:
+    obj_pts.append(objp)
+    cv2.cornerSubPix(imgR_gray,cornersR,(11,11),(-1,-1),criteria)
+    cv2.cornerSubPix(imgL_gray,cornersL,(11,11),(-1,-1),criteria)
+    cv2.drawChessboardCorners(outputR,(8,5),cornersR,retR)
+    cv2.drawChessboardCorners(outputL,(8,5),cornersL,retL)
+    cv2.imshow('cornersR',outputR)
+    cv2.imshow('cornersL',outputL)
+    cv2.waitKey(0)
+ 
+    img_ptsL.append(cornersL)
+    img_ptsR.append(cornersR)
+ 
+ 
+# Calibrating left camera
+retL, mtxL, distL, rvecsL, tvecsL = cv2.calibrateCamera(obj_pts,img_ptsL,imgL_gray.shape[::-1],None,None)
+hL,wL= imgL_gray.shape[:2]
+new_mtxL, roiL= cv2.getOptimalNewCameraMatrix(mtxL,distL,(wL,hL),1,(wL,hL))
+ 
+# Calibrating right camera
+retR, mtxR, distR, rvecsR, tvecsR = cv2.calibrateCamera(obj_pts,img_ptsR,imgR_gray.shape[::-1],None,None)
+hR,wR= imgR_gray.shape[:2]
+new_mtxR, roiR= cv2.getOptimalNewCameraMatrix(mtxR,distR,(wR,hR),1,(wR,hR))

calibrate.py

@@ -0,0 +1,107 @@
+import numpy as np 
+import cv2
+from tqdm import tqdm
+
+
+# Set the path to the images captured by the left and right cameras
+pathL = "/home/ros/Bureau/ca_ur5/damier/Left/"
+pathR = "/home/ros/Bureau/ca_ur5/damier/Right/"
+
+print("Extracting image coordinates of respective 3D pattern ....\n")
+
+# Termination criteria for refining the detected corners
+criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+
+
+objp = np.zeros((8*5,3), np.float32)
+objp[:,:2] = np.mgrid[0:8,0:5].T.reshape(-1,2)
+
+img_ptsL = []
+img_ptsR = []
+obj_pts = []
+
+for i in tqdm(range(1,5)):
+	imgL = cv2.imread(pathL+"L%d.jpg"%i)
+	imgR = cv2.imread(pathR+"R%d.jpg"%i)
+	imgL_gray = cv2.imread(pathL+"L%d.jpg"%i,0)
+	imgR_gray = cv2.imread(pathR+"R%d.jpg"%i,0)
+	
+	
+	outputL = imgL.copy()
+	outputR = imgR.copy()
+
+	retR, cornersR =  cv2.findChessboardCorners(outputR,(8,5),None)
+	retL, cornersL = cv2.findChessboardCorners(outputL,(8,5),None)
+
+	if retR and retL:
+		
+		obj_pts.append(objp)
+		cv2.cornerSubPix(imgR_gray,cornersR,(11,11),(-1,-1),criteria)
+		cv2.cornerSubPix(imgL_gray,cornersL,(11,11),(-1,-1),criteria)
+		cv2.drawChessboardCorners(outputR,(8,5),cornersR,retR)
+		cv2.drawChessboardCorners(outputL,(8,5),cornersL,retL)
+		cv2.imshow('cornersR',outputR)
+		cv2.imshow('cornersL',outputL)
+		cv2.waitKey(0)
+
+		img_ptsL.append(cornersL)
+		img_ptsR.append(cornersR)
+
+
+print("Calculating left camera parameters ... ")
+# Calibrating left camera
+retL, mtxL, distL, rvecsL, tvecsL = cv2.calibrateCamera(obj_pts,img_ptsL,imgL_gray.shape[::-1],None,None)
+hL,wL= imgL_gray.shape[:2]
+new_mtxL, roiL= cv2.getOptimalNewCameraMatrix(mtxL,distL,(wL,hL),1,(wL,hL))
+
+print("Calculating right camera parameters ... ")
+# Calibrating right camera
+retR, mtxR, distR, rvecsR, tvecsR = cv2.calibrateCamera(obj_pts,img_ptsR,imgR_gray.shape[::-1],None,None)
+hR,wR= imgR_gray.shape[:2]
+new_mtxR, roiR= cv2.getOptimalNewCameraMatrix(mtxR,distR,(wR,hR),1,(wR,hR))
+
+
+print("Stereo calibration .....")
+flags = 0
+flags |= cv2.CALIB_FIX_INTRINSIC
+# Here we fix the intrinsic camara matrixes so that only Rot, Trns, Emat and Fmat are calculated.
+# Hence intrinsic parameters are the same 
+
+criteria_stereo= (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+
+
+# This step is performed to transformation between the two cameras and calculate Essential and Fundamenatl matrix
+retS, new_mtxL, distL, new_mtxR, distR, Rot, Trns, Emat, Fmat = cv2.stereoCalibrate(obj_pts,
+                                                          img_ptsL,
+                                                          img_ptsR,
+                                                          new_mtxL,
+                                                          distL,
+                                                          new_mtxR,
+                                                          distR,
+                                                          imgL_gray.shape[::-1],
+                                                          criteria_stereo,
+                                                          flags)
+
+# Once we know the transformation between the two cameras we can perform stereo rectification
+# StereoRectify function
+rectify_scale= 1 # if 0 image croped, if 1 image not croped
+rect_l, rect_r, proj_mat_l, proj_mat_r, Q, roiL, roiR= cv2.stereoRectify(new_mtxL, distL, new_mtxR, distR,
+                                                 imgL_gray.shape[::-1], Rot, Trns,
+                                                 rectify_scale,(0,0))
+
+# Use the rotation matrixes for stereo rectification and camera intrinsics for undistorting the image
+# Compute the rectification map (mapping between the original image pixels and 
+# their transformed values after applying rectification and undistortion) for left and right camera frames
+Left_Stereo_Map= cv2.initUndistortRectifyMap(new_mtxL, distL, rect_l, proj_mat_l,
+                                             imgL_gray.shape[::-1], cv2.CV_16SC2)
+Right_Stereo_Map= cv2.initUndistortRectifyMap(new_mtxR, distR, rect_r, proj_mat_r,
+                                              imgR_gray.shape[::-1], cv2.CV_16SC2)
+
+
+print("Saving parameters ......")
+cv_file = cv2.FileStorage("data/params_py.xml", cv2.FILE_STORAGE_WRITE)
+cv_file.write("Left_Stereo_Map_x",Left_Stereo_Map[0])
+cv_file.write("Left_Stereo_Map_y",Left_Stereo_Map[1])
+cv_file.write("Right_Stereo_Map_x",Right_Stereo_Map[0])
+cv_file.write("Right_Stereo_Map_y",Right_Stereo_Map[1])
+cv_file.release()

stereocalib.py

@@ -0,0 +1,12 @@
+import cv2
+import numpy as np
+flags = 0
+flags |= cv2.CALIB_FIX_INTRINSIC
+# Here we fix the intrinsic camara matrixes so that only Rot, Trns, Emat and Fmat are calculated.
+# Hence intrinsic parameters are the same 
+ 
+criteria_stereo= (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+ 
+ 
+# This step is performed to transformation between the two cameras and calculate Essential and Fundamenatl matrix
+retS, new_mtxL, distL, new_mtxR, distR, Rot, Trns, Emat, Fmat = cv2.stereoCalibrate(obj_pts, img_ptsL, img_ptsR, new_mtxL, distL, new_mtxR, distR, imgL_gray.shape[::-1], criteria_stereo, flags)