예제 #1
0
def main():
    global dict_config

    print('Initializing main function')
    text = input('Insert camera number: ')

    dict_config = ClassUtils.load_cam_calib_params(text)

    print('Opening file')

    # Problems in windows version
    # Tk().withdraw()

    print('Generating elements in list')

    init_dir = '/home/mauricio/Oviedo/CameraCalibration/' + text
    if platform == 'win32':
        init_dir = 'C:\\SharedFTP\\CameraCalibration\\' + text

    options = {'initialdir': init_dir}
    filename = askopenfilename(**options)

    if not filename:
        print('File not selected')
    else:
        print('Loading file ' + filename)

        image = cv2.imread(filename)

        if image is None:
            print('Cant read image ' + filename)
        else:
            show_image(image)
예제 #2
0
    def convert_video_mjpegx(cls,
                             file_path: str,
                             cam_number: str,
                             instance_nn_pose: ClassNN = None):
        extension = os.path.splitext(file_path)[1]

        if ClassUtils.cam_calib_exists(cam_number):
            calib_params = ClassUtils.load_cam_calib_params(cam_number)
        else:
            print('Warning: Calib params not found for camera {0}'.format(
                cam_number))
            calib_params = None

        if extension != '.mjpegx':
            raise Exception('file_path must have extension .mjpegx')

        print('Reading image')
        output_video = file_path + '_1'

        images = ClassMjpegReader.process_video_mjpegx(file_path)
        print('Len images: ' + str(len(images)))

        with open(output_video, 'wb') as newFile:
            counter = 0
            for elem in images:
                # Avoid previous conversion -> only reading
                image = elem[0]
                ticks = elem[1]
                json_dict = elem[2]

                vectors = json_dict['vectors']

                # Avoid over processing - Only process images with poses
                image_cv = None
                if len(vectors) != 0:
                    image_np = np.frombuffer(image, dtype=np.uint8)
                    image_cv = cv2.imdecode(image_np, cv2.IMREAD_ANYCOLOR)

                params = list()

                for vector in vectors:
                    # Check if vector is bodypart 25
                    # Avoid confusions with COCO processing
                    if len(vector) != 25:
                        raise Exception(
                            'Vector is not bodypart 25 - File: {0} Len Vectors: {1}'
                            .format(file_path, len(vector)))

                    params.append(
                        ClassDescriptors.get_person_descriptors(
                            vector,
                            cls.min_percent,
                            cam_number=cam_number,
                            image=image_cv,
                            calib_params=calib_params,
                            decode_img=False,
                            instance_nn_pose=instance_nn_pose))

                # Save object globally
                # CamNumber
                new_json_dict = {
                    'vectors': vectors,
                    'params': params,
                    'camNumber': cam_number
                }

                # Write in new file - New json dict
                ClassUtils.write_in_file(newFile, ticks, image, new_json_dict)

                counter += 1
                if counter % 100 == 0:
                    print('Counter: ' + str(counter))
                    if calib_params is None:
                        print('Warning: Calib params not found for camera {0}'.
                              format(cam_number))

        # Delete old
        os.remove(file_path)

        # Naming new
        os.rename(output_video, file_path)
def main():
    global list_object_points, image, list_point_rect_obj
    print('Initializing main function')

    list_cams = [419, 420, 421, 428, 429, 430]

    # Loading files
    for cam in list_cams:
        cam_str = str(cam)

        calib_params = ClassUtils.load_cam_calib_params(cam_str)
        object_points = calib_params['objectPoints']

        center_points = calib_params['centerPoints']
        angle_degrees = calib_params['angleDegrees']

        if angle_degrees == 0:
            for point in object_points:
                point[0] += center_points[0]
                point[1] += center_points[1]
        elif angle_degrees == 180:
            for point in object_points:
                point[0] = center_points[0] - point[0]
                point[1] = center_points[1] - point[1]
        else:
            raise Exception(
                'Angle deg not implemented: {0}'.format(angle_degrees))

        print('Object points for cam: {0} - {1}'.format(cam, object_points))
        list_object_points.append({
            'camNumber': cam,
            'objectPoints': object_points
        })

    # Loading Zone Points
    path = '/home/mauricio/Oviedo/CameraCalibration/ZonePoints/calibration.json'
    if platform == 'win32':
        path = 'C:\\SharedFTP\\CameraCalibration\\ZonePoints\\calibration.json'

    if os.path.exists(path):
        with open(path, 'r') as f:
            obj_json = f.read()

        obj_data = json.loads(obj_json)
        list_points_temp = obj_data['listRectanglePoints']

        # Converting to tuple
        for points in list_points_temp:
            list_point_rect_obj.append([(points[0][0], points[0][1]),
                                        (points[1][0], points[1][1])])

    draw_image()

    # Showing image
    cv2.namedWindow('main_window', cv2.WINDOW_AUTOSIZE)
    cv2.setMouseCallback('main_window', mouse_callback)

    print(
        'Showing images. Press ESC to exit. Press Q to reset rectangles, Press S to save'
    )
    while True:
        cv2.imshow('main_window', image)
        key = cv2.waitKey(100)

        if key != -1:
            print('Key pressed: {0}'.format(key))

            if key == 27:
                break
            elif key == 113:
                print('Cleaning object list')
                list_point_rect_obj.clear()
                draw_image()
            elif key == 115:
                save_points()
                # Exiting!
                break

    cv2.destroyAllWindows()
    print('Done!')