code:
import cv2
from filterpy.kalman import KalmanFilter
from ultralytics import YOLO
import numpy as np
import pandas as pd

model = YOLO('/Users/surabhi/Documents/kalman/best.pt')
dt = 1.0
kf = KalmanFilter(dim_x=6, dim_z=2)
kf.x = np.array([0, 0, 0, 0,0,0]) # initial state estimate
kf.P = np.eye(6) * 1000 # initial error covariance matrix
kf.F = np.array([[1, 0, dt, 0, 0.5 * (dt ** 2), 0],
                 [0, 1, 0, dt, 0, 0.5 * (dt ** 2)],
                 [0, 0, 1, 0, dt, 0], 
                 [0, 0, 0, 1, 0, dt], 
                 [0, 0, 0, 0, 1, 0], 
                 [0, 0, 0, 0, 0, 1]])  # state transition matrix
kf.H = np.array([[1, 0, 0, 0, 0, 0],
                 [0, 1, 0, 0, 0, 0]]) # measurement matrix
kf.R = np.diag([0.1, 0.1]) # measurement noise covariance matrix
kf.Q=  np.array([[dt**4/4, 0, dt**3/2, 0, dt**2, 0],
                [0, dt**4/4, 0, dt**3/2, 0, dt**2],
                [dt**3/2, 0, dt**2, 0, dt, 0],
                [0, dt**3/2, 0, dt**2, 0, dt],
                [dt**2, 0, dt, 0, 1, 0],
                [0, dt**2, 0, dt, 0, 1]]) # process noise covariance matrix

u = np.zeros((4, 1))

cap = cv2.VideoCapture("1_1.mp4")
frame_num = 0
predicted_points = []
bounce_detected = False 
last_bounce_frame = -10
test_df = pd.DataFrame(columns=[ 'frame','x', 'y','vx','vy','ax','ay', 'V'])
while True:
    ret, frame = cap.read()
    if ret is False:
        break
    bbox = model(frame, show=True)
    frame_num += 1
    for boxes_1 in bbox:
        result = boxes_1.boxes.xyxy
        if len(result) == 0:
            print("not detected")
        else:
            cx = int((result[0][0] + result[0][2]) / 2)
            cy = int((result[0][1] + result[0][3]) / 2)
            centroid = np.array([cx, cy])
            kf.predict()
            kf.update(centroid)
            next_point = (kf.x).tolist()
            #predicted_velocity.append((int(next_point[2]),int(next_point[3])))
            predicted_points.append((int(next_point[0]), int(next_point[1])))
            if len(predicted_points) > 10:
                predicted_points.pop(0)
            print("next_point", next_point)
            print("frame_number", frame_num)
            if(next_point[2]>0):
                vx="positive"
            else:
                vx="negative"
            if(next_point[3]>0):
                vy="positive"
            else:
                vy="negative"
            test_df = test_df.append( { 'frame': frame_num, 'x': next_point[0], 'y': next_point[1], 'vx': next_point[2],'vy':next_point[3]
                                      ,'ax':next_point[4],'ay':next_point[5],'V': np.sqrt(kf.x[2]**2 + kf.x[3]**2)}, ignore_index=True)
            cv2.putText(frame, f'Frame: {frame_num}', (10, 50), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            #cv2.putText(frame, f': {next_point}', (10,205), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
            #cv2.putText(frame, f'vx:{vx}',(10,205), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
            #cv2.putText(frame, f'vy:{vy}',(10,230), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 2)
            cv2.circle(frame, (cx, cy), 5, (0,0,255), 5)
            cv2.circle(frame, (int(next_point[0]), int(next_point[1])), 5, (255, 0, 0), 10)
            for i, p in enumerate(predicted_points):
                color = (255,255,255)
                cv2.circle(frame, p, 5, color, 2)
            print(kf.x[2])
            if not bounce_detected and frame_num - last_bounce_frame > 50:
    
                if ((test_df.shape[0] > 1 and test_df.shape[1] > 3 and np.sign(test_df.iloc[-2, 3]) == np.sign(kf.x[2])) and (test_df.shape[0] > 1 and test_df.shape[1] > 3 and np.sign(test_df.iloc[-2, 4]) > 0 and np.sign(kf.x[3]) < 0)):
                #if kf.x[3]< 0 and kf.x[1] <= 0.3048:# If Y acceleration is less than the negative threshold, say -15
                    print(test_df.iloc[-2, 3])
                    bounce_detected = True
                    last_bounce_frame = frame_num
                    print("Bounce detected")
                    
                """
            if not bounce_detected and frame_num - last_bounce_frame > 10:
                if kf.x[2] < 0 and kf.x[3]: # If Y acceleration is less than the negative threshold, say -15
                    bounce_detected = True
                    last_bounce_frame = frame_num
                    print("Bounce detected")
                    """
            if bounce_detected:
                cv2.putText(frame, 'Bounce Detected', (10, 350), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2)
            if kf.x[5] > 0: # After a bounce is detected, wait until acceleration is above the threshold, say -5, to detect the bounce again
                bounce_detected = False
            print(test_df)
            test_df.to_csv('file.csv')
            
            cv2.imshow('raw', frame)
            
            # Uncomment the following lines to save the output video
            # out.write(frame)
            # if cv2.waitKey(1) & 0xFF == ord('q'):
            #     break

cap.release()
cv2.destroyAllWindows()

it's not detecting ball bounce correctly