hand record

app.py

@@ -4,21 +4,21 @@ import subprocess
 import os
 from tempfile import mkdtemp
 from timeit import default_timer as timer
+from hand_record import create_hand_record_pdf
+from pbn_util import validate_pbn, create_single_pbn_string
 
 # Download model and libraries from repo
-try:
-    token = os.environ.get("model_token")
-    subprocess.run(["git", "clone", f"https://oauth2:{token}@huggingface.co/vincentlui/bridge_hand_detect"])
-except:
-    print('Fail to download code')
+# try:
+#     token = os.environ.get("model_token")
+#     subprocess.run(["git", "clone", f"https://oauth2:{token}@huggingface.co/vincentlui/bridge_hand_detect"])
+# except:
+#     print('Fail to download code')
 
 try:
     from bridge_hand_detect2.predict import CardDetectionModel
-    from bridge_hand_detect2.pbn import create_pbn_file
 except Exception as e:
     print(e)
     from bridge_hand_detect.predict import CardDetectionModel
-    from bridge_hand_detect.pbn import create_pbn_file
 
 custom_css = \
 """
@@ -33,18 +33,19 @@ OUTPUT_IMG_HEIGHT = 320
 css = ".output_img {display:block; margin-left: auto; margin-right: auto}"
 model = CardDetectionModel()
 
-def predict(image_path):
+def predict(image_path, top_hand_idx):
+    print(top_hand_idx)
     start = timer()
     df = None
     try:
-        hands, (width,height) = model(image_path, augment=True)
+        hands, (width,height) = model(image_path, augment=True, top_hand_idx=top_hand_idx)
         print(hands)
         # Output dataframe
-        df = pd.DataFrame(['♠', '♥', '♦', '♣'], columns=[''])
+        df = default_df.copy(deep=True)#pd.DataFrame(['♠', '♥', '♦', '♣'], columns=[''])
         for hand in hands:
             df[hand.direction] = [''.join(c) for c in hand.cards]
     except:
-        gr.Error('Cannot process image')
+        raise gr.Error('Cannot process image')
 
     end = timer()
     print(f'Process time: {end - start:.02f} seconds')
@@ -52,25 +53,38 @@ def predict(image_path):
     return df
     
 
-default_df = df = pd.DataFrame({'':['♠', '♥', '♦', '♣'], 
+default_df = pd.DataFrame({'':['♠', '♥', '♦', '♣'], 
                                 'N': ['']*4, 
                                 'E': ['']*4, 
                                 'S': ['']*4, 
                                 'W': ['']*4})
 
 
-def save_file2(df, cache_dir, total):
+def save_file(df, cache_dir, files, board_no):
     d = cache_dir
     if cache_dir is None:
         d = mkdtemp()
-    total += 1
-    file_name = f'bridgehand{total:03d}.pbn'
+
+    pbn_str = create_single_pbn_string(df, board_no=board_no)
+    try:
+        validate_pbn(pbn_str)
+    except Exception as e:
+        print(e)
+        gr.Warning(f'Fail to save: {e}')
+        return files, files, d
+
+    file_name = f'board_{board_no:03d}.pbn'
     file_path = os.path.join(d,file_name)
     with open(file_path, 'w') as f:
-        pbn_str = create_pbn_file(df)
         f.write(pbn_str)
 
-    return file_path, d, total
+    if not file_path in files:
+        files.append(file_path)
+    return files, files, d
+
+def create_hand_record(files):
+    file_path = create_hand_record_pdf(files)
+    return file_path
 
 with gr.Blocks(css=custom_css) as demo:
     gr.Markdown(
@@ -81,35 +95,62 @@ with gr.Blocks(css=custom_css) as demo:
         The results can be exported as a PBN file, which can be imported to other bridge software such as double dummy solvers.
         1. Upload an image showing all four hands fanned as shown in the example.
         2. Click *Submit*. The scan result will be displayed in the table.
-        3. Verify the output and correct any missing or wrong card in the table. Then click *Save* to generate a PBN file.
+        3. Verify the output and correct any missing or wrong card in the table. 
+        4. Enter the information of the deal.
+        5. Click *Save* to generate a PBN file. 
+        6. In the tab *Hand Record*, You can upload all the PBN files and create a hand record as a PDF file.
 
         Tips:
-        - This AI reads the values at the top left corner of the playing cards. Make sure they are visible and as large as possible.
+        - This AI reads the values at corners of the playing cards. Make sure they are visible and as large as possible.
         - To get the best accuracy, place the cards following the layout in the examples. 
 
-        I need your feedback to make this app more useful. Please send your comments to <vincentlui123@gmail.com>.
+        Please send your comments to <vincentlui123@gmail.com>.
         """)
 
     total = gr.State(0)
     gradio_cache_dir = gr.State()
-    
-    with gr.Row():
-        with gr.Column():
-            a1 = gr.Image(type="filepath",sources=['upload'],interactive=True,height=INPUT_IMG_HEIGHT)
-            with gr.Row():
-                a2 = gr.ClearButton()
-                a3 = gr.Button('Submit',variant="primary")
-            a4 = gr.Examples('examples', a1)
-
-        with gr.Column():
-            b1 = gr.Dataframe(value=default_df, datatype="str", row_count=(4,'fixed'), col_count=(5,'fixed'), 
-                            headers=['', 'N', 'E', 'S', 'W'],
-                            interactive=True, column_widths=['8%', '23%','23%','23%','23%'])
-            b2 = gr.Button('Save')
-            b3 = gr.File(interactive=False)
-
-    a2.add([a1, b1, b3])
-    a3.click(predict, [a1], [b1])
-    b2.click(save_file2, [b1, gradio_cache_dir, total], [b3, gradio_cache_dir, total])
+    files = gr.State([])
+    with gr.Tab('Scan Image'):
+        with gr.Row():
+            with gr.Column():
+                a1 = gr.Image(type="filepath",sources=['upload'],interactive=True,height=INPUT_IMG_HEIGHT)
+                with gr.Row():
+                    a2 = gr.ClearButton()
+                    a3 = gr.Button('Submit',variant="primary")
+                with gr.Accordion("Board Details",open=True):
+                    with gr.Row():
+                        a_board_no = gr.Number(label="Board", value=1, minimum=1, maximum=999, interactive=True, min_width=80)
+                        a_top = gr.Dropdown(['N','E','S','W'], label='Top', value='N', interactive=True, min_width=80, type='index')
+                        a_deck = gr.Dropdown(['Standard (AKQJ)'], label='Deck', 
+                                            value='Standard (AKQJ)', type='index', interactive=True, min_width=80, scale=2)
+                # with gr.Accordion("Contract Details",open=False) as a_c:
+                #     with gr.Row():
+                #         with gr.Column(scale=3):
+                #             with gr.Group():
+                #                 a_level = gr.Radio(['1','2','3','4','5','6','7','AP'], label='Contract')
+                #                 a_trump = gr.Radio(['♠', '♥', '♦', '♣', 'NT'], show_label=False)
+                #                 a_dbl = gr.Radio(['X', 'XX'], show_label=False)
+                #         a_declarer = gr.Radio(['N','E','S','W'], label='Declarer', min_width=80, scale=1)
+                a4 = gr.Examples('examples', a1)
+
+            with gr.Column():
+                b1 = gr.Dataframe(value=default_df, datatype="str", row_count=(4,'fixed'), col_count=(5,'fixed'), 
+                                headers=['', 'N', 'E', 'S', 'W'],
+                                interactive=True, column_widths=['8%', '23%','23%','23%','23%'])
+                b2 = gr.Button('Save')
+                b3 = gr.File(interactive=False, file_count='multiple')
+
+    with gr.Tab('Hand Record'):
+        with gr.Row():
+            with gr.Group():
+                tab2_upload_file = gr.Files(interactive=True)
+                tab2_submit_button = gr.Button('Create Hand Record',variant="primary")
+            tab2_download_file = gr.File(interactive=False)
+        
+        tab2_submit_button.click(create_hand_record, tab2_upload_file, tab2_download_file)
+
+    a2.add([a1,b1])
+    a3.click(predict, [a1, a_top], [b1])
+    b2.click(save_file, [b1, gradio_cache_dir, files, a_board_no], [b3, tab2_upload_file, gradio_cache_dir])
 
 demo.queue().launch()

hand_record.py

@@ -0,0 +1,99 @@
+from fpdf import FPDF
+import tempfile
+import os
+import bridgebots
+from pbn_util import merge_pbn, parse_pbn
+
+DEALER_LIST = ['N', 'E', 'S', 'W']
+VULNERABILITY_LIST = ["None","NS","EW","All","NS","EW","All","None","EW","All","None","NS","All","None","NS","EW"]
+SUITS = [bridgebots.Suit.SPADES, bridgebots.Suit.HEARTS, bridgebots.Suit.DIAMONDS, bridgebots.Suit.CLUBS]
+SUIT_SYMBOLS = ['♠','♥','♦','♣']
+
+def create_hand_record_pdf(pbn_paths):
+    filepath_merged_pbn = merge_pbn(pbn_paths)
+    results = parse_pbn(filepath_merged_pbn)
+    fd,fn = tempfile.mkstemp(".pdf")
+    pdf = FPDF()
+
+    pdf.add_page()
+    pdf.add_font('times2', style='', fname='times.ttf')
+    pdf.set_font("times2", "", 8)
+    pdf.c_margin = 0.1
+    table_config = {
+        'borders_layout':'NONE', 
+        'col_widths':3,
+        'line_height':pdf.font_size + 0.5,
+        'align': 'L',
+        'text_align': 'L',
+        'first_row_as_headings': False,
+    }
+
+    start_x,start_y = 10,10
+    table_size = 45, 48 
+    table_margin = 2
+    for i, result in enumerate(results):
+        deal = result[0]
+        board_no = int(result[1][0]['Board'])
+        page_i = i % 20
+        if (i % 20 == 0) and (i != 0):
+            pdf.add_page()
+        row_idx = page_i // 4
+        col_idx = page_i % 4
+        x = start_x + (table_size[0] + 2 * table_margin + 1) * col_idx
+        y = start_y + (table_size[1] + 2 * table_margin + 1) * row_idx
+
+        top_left = x - table_margin, y - table_margin 
+        top_right = x + table_size[0] + table_margin, y - table_margin
+        bottom_left = x - table_margin, y + table_size[1] + table_margin
+        bottom_right = x + table_size[0] + table_margin, y + table_size[1] + table_margin
+        pdf.set_xy(x,y)
+
+        pdf.line(*top_left, *bottom_left)
+        pdf.line(*top_left, * top_right)
+        pdf.line(*top_right, *bottom_right)
+        pdf.line(*bottom_left, *bottom_right)
+
+        dealer = DEALER_LIST[(board_no-1) % 4]
+        vul = VULNERABILITY_LIST[(board_no-1) % 16]
+        with pdf.table(**table_config) as table:
+            row = table.row()
+            row.cell(f'{board_no}\n{dealer}/{vul}', colspan=6, rowspan=4, align='C', v_align='C')
+            for i, (suit, values) in enumerate(zip(SUIT_SYMBOLS, get_values(deal, 'N'))):
+                if i!=0:
+                    row = table.row()
+                print_suit_values(pdf,row,suit,values)
+
+            row = table.row()
+            # row = table.row()
+            for i, (suit, values1, values2) in enumerate(zip(SUIT_SYMBOLS, get_values(deal, 'W'), get_values(deal, 'E'))):
+                row = table.row()
+                print_suit_values(pdf, row, suit, values1)
+                row.cell('',colspan=5)
+
+                print_suit_values(pdf, row, suit, values2)
+
+            row = table.row()
+            row = table.row()
+            row.cell('', colspan=6, rowspan=4)
+            for i, (suit, values) in enumerate(zip(SUIT_SYMBOLS, get_values(deal, 'S'))):
+                if i!=0:
+                    row = table.row()
+                print_suit_values(pdf, row, suit, values)
+
+    pdf.output(fn)
+    return fn
+
+
+def get_values(result, direction):
+    d = bridgebots.Direction.from_str(direction)
+    hand = result.hands[d]
+    return [''.join([value.abbreviation() 
+                for value in hand.suits[suit]]) 
+            for suit in SUITS] 
+
+def print_suit_values(pdf, row, suit, values):
+    if (suit=='♥') or (suit=='♦'): # Hearts or Diamonds
+        pdf.set_text_color(255,0,0)
+    row.cell(suit, colspan=1)
+    pdf.set_text_color(0,0,0)
+    row.cell(values, colspan=4)

pbn_util.py

@@ -0,0 +1,137 @@
+from collections import defaultdict
+import logging
+import bridgebots
+from pathlib import Path
+from datetime import datetime
+import pandas as pd
+import tempfile
+from collections import Counter
+
+
+DEALER_LIST = ['N', 'E', 'S', 'W']
+VULNERABILITY_LIST = ["None","NS","EW","All","NS","EW","All","None","EW","All","None","NS","All","None","NS","EW"]
+SUITS = [bridgebots.Suit.SPADES, bridgebots.Suit.HEARTS, bridgebots.Suit.DIAMONDS, bridgebots.Suit.CLUBS]
+
+def parse_single_pbn_record(record_strings):
+    """
+    :param record_strings: One string per line of a single PBN deal record
+    :return: Deal and BoardRecord corresponding to the PBN record
+    """
+    record_dict = bridgebots.pbn._build_record_dict(record_strings)
+    try:
+        deal = bridgebots.pbn.from_pbn_deal(record_dict["Dealer"], record_dict["Vulnerable"], record_dict["Deal"])
+    except KeyError as e:
+        # if previous_deal:
+        #     deal = previous_deal
+        # else:
+        raise ValueError("Missing deal fields and no previous_deal provided") from e
+    # board_record = _parse_board_record(record_dict, deal)
+    return deal, record_dict
+
+
+def parse_pbn(file_path):
+    """
+    Split PBN file into boards then decompose those boards into Deal and BoardRecord objects. Only supports PBN v1.0
+    See https://www.tistis.nl/pbn/pbn_v10.txt
+
+    :param file_path: path to a PBN file
+    :return: A list of DealRecords representing all the boards played
+    """
+    records_strings = bridgebots.pbn._split_pbn(file_path)
+    # Maintain a mapping from deal to board records to create a single deal record per deal
+    records = defaultdict(list)
+    # Some PBNs have multiple board records per deal
+    previous_deal = None
+    for record_strings in records_strings:
+        try:
+            deal, board_record = parse_single_pbn_record(record_strings)
+            records[deal].append(board_record)
+            # previous_deal = deal
+        except (KeyError, ValueError) as e:
+            logging.warning(f"Malformed record {record_strings}: {e}")
+    return [(deal, board_records) for deal, board_records in records.items()]
+
+
+def create_single_pbn_string(
+        data: pd.DataFrame,
+        date=datetime.today(),
+        board_no=1,
+        event='',
+        site='',
+    ) -> str:
+    year = date.strftime("%y")
+    month = date.strftime("%m")
+    day = date.strftime("%d")
+    date_print = day + "." + month + "." + year
+    dealer = DEALER_LIST[(board_no-1) % 4]
+    vulnerability=VULNERABILITY_LIST[(board_no-1) % 16]
+    deal = 'N:'
+    deal += ' '.join(
+        ['.'.join(data[col]) for col in data.columns[1:]]
+    ) # sss.hhh.ddd.ccc sss.hhh.ddd.ccc......
+
+    file = ''
+    file += ("%This pbn was generated by Bridge Hand Scanner\n")
+    file += f'[Event "{event}"]\n'
+    file += f'[Site "{site}"]\n'
+    file += f'[Date "{date_print}"]\n'
+    file += f'[Board "{str(board_no)}"]\n'
+    file += f'[Dealer "{dealer}"]\n'
+    file += f'[Vulnerable "{vulnerability}"]\n'
+    file += f'[Deal "{deal}"]\n'
+
+    return file
+
+def merge_pbn(pbn_paths):
+    fd, fn = tempfile.mkstemp(suffix='.pbn', text=True)
+    board_dict = {}
+    for i, pbn_path in enumerate(pbn_paths):
+        result = parse_pbn(pbn_path)[0]
+        with open(pbn_path, 'r') as f2:
+            pbn_str = f2.read()
+        board_no = result[1][0]['Board']
+        board_dict[board_no] = pbn_str
+        
+    ordered_board_dict = dict(sorted(board_dict.items()))
+    with open(fd, 'w') as f:
+        for i, (k,v) in enumerate(ordered_board_dict.items()):
+            if i != 0:
+                f.write('\n*\n')        
+            f.write(v)
+    return fn
+
+
+def validate_pbn(pbn_string):
+    try:
+        deal, record = parse_single_pbn_record(pbn_string)
+    except AssertionError:
+        raise ValueError('Everyone should have 13 cards')
+    except Exception as e:
+        print('test')
+        raise Exception(e)
+    hands = deal.hands
+    duplicated = set()
+    missing = set()
+    validation_dict = {}
+    for suit in bridgebots.Suit:
+        cards = [hands[direction].suits[suit] for direction in hands]
+        # assert len(cards) == 13, 
+        cards = [c for c in sum([hands[direction].suits[suit] for direction in hands], [])]
+        duplicated.update([bridgebots.Card(suit,val) for val,cnt in Counter(cards).items() if cnt >1])
+
+        cards_set = set(cards)
+        missing.update([bridgebots.Card(suit,r) for r in bridgebots.Rank if not r in cards_set])
+
+    err_msg = ''
+    if len(duplicated) > 0:
+        err_msg += f'Duplicated cards: {duplicated}. '
+    if len(missing) > 0:
+        err_msg += f'Missing cards: {missing}. '
+
+    for direction in hands:
+        num_cards = len(hands[direction].cards)
+        if not num_cards == 13:
+            err_msg += '{direction.name} has {num_cards} cards. '
+    
+    if err_msg:
+        raise ValueError(err_msg)

requirements.txt

@@ -4,4 +4,5 @@ onnxruntime
 lap
 opencv-python
 openvino==2024.0.0
-albumentations
+albumentations
+fpdf2