dds

app.py

@@ -36,7 +36,6 @@ css = ".output_img {display:block; margin-left: auto; margin-right: auto}"
 model = CardDetectionModel()
 
 def predict(image_path, top_hand_idx):
-    print(top_hand_idx)
     start = timer()
     df = None
     try:
@@ -84,8 +83,8 @@ def save_file(df, cache_dir, files, board_no):
         files.append(file_path)
     return files, files, d
 
-def create_hand_record(files):
-    file_path = create_hand_record_pdf(files)
+def create_hand_record(files, event, site):
+    file_path = create_hand_record_pdf(files, event=event, site=site)
     return file_path
 
 with gr.Blocks(css=custom_css) as demo:
@@ -144,12 +143,14 @@ with gr.Blocks(css=custom_css) as demo:
 
     with gr.Tab('Hand Record'):
         with gr.Row():
-            with gr.Group():
+            with gr.Column():
                 tab2_upload_file = gr.Files(interactive=True)
+                tab2_event = gr.Textbox(max_lines=1, placeholder='Event name', label='Event')
+                tab2_site = gr.Textbox(max_lines=1, placeholder='Site name', label='Site')
                 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)
+        tab2_submit_button.click(create_hand_record, [tab2_upload_file, tab2_event, tab2_site], tab2_download_file)
 
     a2.add([a1,b1])
     a3.click(predict, [a1, a_top], [b1])

dds_util.py

@@ -0,0 +1,120 @@
+import ctypes
+from ctypes import POINTER, Structure, byref, c_char, c_int, c_uint
+import os
+import sys
+
+
+"""
+Adopted from Peter Ellington's PBNCreator https://github.com/Britwizard/PBNCreator
+"""
+DDS_HANDS = 4
+DDS_SUITS = 5
+DDS_STRAINS = 5
+
+dcardSuit = ["S", "H", "D", "C", "NT"]
+convert_table1={'a':'10','b':'11','c':'12','d':'13'}
+convert_table2={'10':'a','11':'b','12':'c','13':'d'}
+vulnerability= ["None","NS","EW","All","NS","EW","All","None","EW","All","None","NS","All","None","NS","EW"]
+dealerlist=["N","E","S","W"]
+dd_dealer_point = ["N","S","E","W"]
+dd_suit=["NT","S","H","D","C"]
+dd_suit_wide=["NT"," S"," H"," D"," C"]
+
+
+class ddTableDeal(Structure):
+    _fields_ = [("cards", c_uint * DDS_HANDS * DDS_SUITS)]
+
+class ddTableResults(Structure):
+#    _fields_ = [("resTable", c_int * DDS_STRAINS * DDS_HANDS)]
+    _fields_ = [("resTable", c_int * DDS_HANDS * DDS_STRAINS)]
+
+class ddTableDealPBN(Structure):
+    _fields_ = [("cards", c_char * 80)]
+
+class ddTableResults(Structure):
+#    _fields_ = [("resTable", c_int * DDS_STRAINS * DDS_HANDS)]
+    _fields_ = [("resTable", c_int * DDS_HANDS * DDS_STRAINS)]
+    
+tableDealPBN = ddTableDealPBN()
+table = ddTableResults()
+
+dll_name = DLL = None
+if os.name == "posix":
+    dll_name = "libdds.so"
+    DLL = ctypes.CDLL
+
+if dll_name:
+     #dll_path = os.path.join(os.path.dirname(os.path.abspath(__file__)),dll_name)
+    dll_path = os.path.join(os.getcwd(),dll_name)
+#dll_path='C:\\Users\\peter\\Python\\PBNGenerator\\dds-64.dll'
+if dll_name and os.path.exists(dll_path):
+    dll = DLL(dll_path)
+    dll.CalcDDtable.argtypes = [ddTableDeal, POINTER(ddTableResults)]
+    dll.ErrorMessage.argtypes = [c_int, POINTER(c_char)]
+
+    if os.name == "posix":
+        dll.SetMaxThreads(0)
+    def _check_dll(name):
+        return
+
+else:
+    def _check_dll(name):
+        raise Exception(f"Unable to load DDS; {name} is not available")
+    
+
+def errorMessage(res):
+    msg = ctypes.create_string_buffer(80)
+    dll.ErrorMessage(res, msg)
+    result_len = ctypes.c_size_t(len(msg))
+    return msg[:result_len.value]
+
+def calcDDtablePBN(tableDealPBN):
+    myTable = ctypes.pointer(table)
+    res = dll.CalcDDtablePBN(tableDealPBN, myTable)
+    if res != 1:
+        line = errorMessage(res)
+        raise Exception("DDS error: {}".format(line.decode("utf-8")))
+    return myTable
+
+def get_ddstable(pbn):
+    tableDealPBN.cards = pbn
+    table = calcDDtablePBN(tableDealPBN)
+    all = { "N" : {}, "S" : {}, "E" : {}, "W" : {} }
+    # below doesn't work, why?
+    #all = dict.fromkeys(["N","S","E","W"], {})
+    # print(all)
+    for suit in range(0, DDS_SUITS):
+        all["N"][dcardSuit[suit]] = table.contents.resTable[suit][0]
+        all["S"][dcardSuit[suit]] = table.contents.resTable[suit][2]
+        all["E"][dcardSuit[suit]] = table.contents.resTable[suit][1]
+        all["W"][dcardSuit[suit]] = table.contents.resTable[suit][3]
+    return all
+
+def get_dd_tricks(deal):
+    byte_board=deal.encode('utf-8')  # ddstable requires the board description to be in byte format
+    dd_array = get_ddstable(byte_board)
+    double_dummy_tricks=''
+    for point in dd_array:
+        for suit in dd_suit:
+            temp = dd_array[point][suit]
+            value=str(temp)
+            if temp > 9:
+                value=convert_table2[value]
+            double_dummy_tricks = double_dummy_tricks + value
+    return(double_dummy_tricks)
+
+"""
+End
+"""
+
+DD_DIRECTIONS = ['N', 'S', 'E', 'W']
+DD_SUITS = ['NT', 'S', 'H', 'D', 'C']
+def get_result_table(pbn_deal_string):
+    dd_tricks_string = get_dd_tricks(pbn_deal_string)
+    s = '[OptimumResultTable "Declarer;Denomination\\2R;Result\\2R"]\n'
+    for i, char in enumerate(dd_tricks_string):
+        direction = DD_DIRECTIONS[i//5]
+        suit = DD_SUITS[i%5]
+        tricks = int(char, 16)
+        s += f'{direction} {suit} {tricks}\n'
+    return s

hand_record.py

@@ -2,84 +2,156 @@ from fpdf import FPDF
 import tempfile
 import os
 import bridgebots
-from pbn_util import merge_pbn, parse_pbn
+from pbn_util import merge_pbn, parse_pbn, parse_dds_table
 
 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)
+suit_symbols = ['♠','♥','♦','♣']
+
+class PDF(FPDF):
+    def __init__(self, event, site, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.event = event
+        self.site = site
+
+    def header(self) -> None:
+        # Setting font: helvetica bold 15
+        self.set_font("helvetica", "B", 12)
+        # Moving cursor to the right:
+        self.cell(80, 5, self.event)
+        # Printing title:
+        self.cell(80, 5, self.site, align="C", new_x="LMARGIN",
+            new_y="NEXT",)
+        # Performing a line break:
+        self.ln(5)
+    
+    def footer(self) -> None:
+        return super().footer()
+    
+    def print_boards(self, results):
+        self.add_page()
+        self.add_font('times2', style='', fname='times.ttf')
+        self.set_font("times2", "", 10)
+        self.c_margin = 0.1
+        table_config = {
+            'borders_layout':'NONE', 
+            'col_widths':3,
+            'line_height':self.font_size + 0.4,
+            'align': 'L',
+            'text_align': 'L',
+            'first_row_as_headings': False,
+        }
+
+        start_x,start_y = 9, self.y
+        table_size = 45, 46
+        table_margin = 2
+        for i, result in enumerate(results):
+            deal = result[0]
+            board_no = int(result[1][0]['Board'])
+            dds_tricks_table = result[1][0]['dds_tricks_table']
+
+            page_i = i % 20
+            if (i % 20 == 0) and (i != 0):
+                self.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
+            self.set_xy(x,y)
+
+            self.line(*top_left, *bottom_left)
+            self.line(*top_left, * top_right)
+            self.line(*top_right, *bottom_right)
+            self.line(*bottom_left, *bottom_right)
+
+            dds_top_left = x - table_margin, y + 35 - 1
+            dds_top_right = x - table_margin + 18, y + 35 - 1
+            dds_bottom_right = x - table_margin + 18, y + table_size[1] + table_margin
+            self.line(*dds_top_left, *dds_top_right)
+            self.line(*dds_top_right, *dds_bottom_right)
 
-                print_suit_values(pdf, row, suit, values2)
+            dealer = DEALER_LIST[(board_no-1) % 4]
+            vul = VULNERABILITY_LIST[(board_no-1) % 16]
 
-            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:
+            self.set_font_size(10)
+            with self.table(**table_config) as table:
+                row = table.row()
+                self.set_font_size(16)
+                row.cell(str(board_no), colspan=6, rowspan=2, align='C', v_align='C', padding=(2,0,0,0))
+                self.set_font_size(10)
+                for i, (suit, values) in enumerate(zip(suit_symbols, get_values(deal, 'N'))):
+                    if i!=0:
+                        row = table.row()
+                    if i == 2:
+                        row.cell(f'{dealer} / {vul}', colspan=6, rowspan=2, align='C', v_align='C')
+                    print_suit_values(self,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, values)
+                    row.cell('', colspan=1, rowspan=1)
+                    print_suit_values(self, row, suit, values1)
+                    row.cell('',colspan=3)
+
+                    print_suit_values(self, 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(self, row, suit, values)
+
+            self.set_xy(x-1,y+34)
+            self.set_font_size(7)
+            dds_table_config = {
+                'borders_layout':'NONE', 
+                'col_widths':2.8,
+                'line_height':self.font_size + 0.1,
+                'align': 'L',
+                'text_align': 'L',
+                'first_row_as_headings': False,
+                'padding': 0.1
+            }
+            with self.table(**dds_table_config) as table:
+                row = table.row()
+                row.cell('')
+                self.set_font_size(5)
+                row.cell('NT', align='C')
+                self.set_font_size(7)
+                row.cell(suit_symbols[0], align='C')
+                row.cell(suit_symbols[1], align='C')
+                row.cell(suit_symbols[2], align='C')
+                row.cell(suit_symbols[3], align='C')
+                row = table.row()
+                for i in range(4):
+                    if i!=0:
+                        row = table.row()
+                    row.cell(dds_tricks_table[i*5][0], align='C')
+                    row.cell(dds_tricks_table[i*5][2], align='C')
+                    row.cell(dds_tricks_table[i*5+1][2], align='C')
+                    row.cell(dds_tricks_table[i*5+2][2], align='C')
+                    row.cell(dds_tricks_table[i*5+3][2], align='C')
+                    row.cell(dds_tricks_table[i*5+4][2], align='C')
+    
+
+def create_hand_record_pdf(pbn_paths, event, site):
+    filepath_merged_pbn = merge_pbn(pbn_paths)
+    results = parse_pbn(filepath_merged_pbn)
+    fd,fn = tempfile.mkstemp(".pdf")
+    pdf = PDF(event, site)
+    pdf.print_boards(results)
     pdf.output(fn)
     return fn
 

libdds.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f38db5d391d6d1f9046af221e517b6359bbe536ad55907eb37253ef7eccfaaa0
+size 495992

pbn_util.py

@@ -6,18 +6,95 @@ from datetime import datetime
 import pandas as pd
 import tempfile
 from collections import Counter
+from dds_util import get_result_table
+from typing import List, Dict
 
 
 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 _build_record_dict(record_strings: List[str]) -> Dict:
+    """
+    Parse the pbn line by line. When a block section like "Auction" or "Play" is encountered, collect all the content of
+     the block into a single entry
+    :param record_strings: List of string lines for a single board
+    :return: A dictionary mapping keys from the pbn to strings or other useful values (e.g. list of strings for the
+    bidding record)
+    """
+    record_dict = {}
+    # Janky while loop to handle non bracketed lines
+    i = 0
+    while i < len(record_strings):
+        record_string = record_strings[i]
+        if not (record_string.startswith("[") or record_string.startswith("{")):
+            i += 1
+            continue
+        if record_string.startswith("{"):
+            commentary = ""
+            while i < len(record_strings):
+                record_string = record_strings[i]
+                if record_string.startswith("["):
+                    break
+                commentary += record_string + " "
+                i += 1
+            record_dict["Commentary"] = commentary.strip()
+            continue
+        if record_string.startswith("[") and "]" not in record_string:
+            while "]" not in record_string:
+                i += 1
+                record_string = record_string + record_strings[i]
+        record_string = record_string.replace("[", "").replace("]", "")
+        key, value = record_string.split(maxsplit=1)
+        value = value.replace('"', "")
+        if key == "Note":
+            number, message = value.split(":", maxsplit=1)
+            key = key + "_" + number
+            value = message
+        record_dict[key] = value
+        if key == "Auction":
+            auction_record = []
+            i += 1
+            while i < len(record_strings):
+                auction_str = record_strings[i]
+                if "[" in auction_str:
+                    break
+                auction_record.extend(auction_str.split())
+                i += 1
+            record_dict["bidding_record"] = auction_record
+
+        elif key == "Play":
+            play_record = []
+            i += 1
+            while i < len(record_strings):
+                play_str = record_strings[i]
+                if "[" in play_str or play_str == "*":
+                    break
+                play_record.append(play_str.split())
+                i += 1
+            record_dict["play_record"] = play_record
+        elif key == "OptimumResultTable":
+            dds_tricks_table = []
+            i += 1
+            while i < len(record_strings):
+                dds_str = record_strings[i]
+                if "[" in dds_str or dds_str == "*":
+                    break
+                dds_tricks_table.append(dds_str.split())
+                i += 1
+            print(dds_tricks_table)
+            record_dict["dds_tricks_table"] = dds_tricks_table
+        else:
+            i += 1
+    return record_dict
+
 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)
+    record_dict = _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:
@@ -69,9 +146,10 @@ def create_single_pbn_string(
     deal += ' '.join(
         ['.'.join(data[col]) for col in data.columns[1:]]
     ) # sss.hhh.ddd.ccc sss.hhh.ddd.ccc......
+    dd_tricks = get_result_table(deal)
 
     file = ''
-    file += ("%This pbn was generated by Bridge Hand Scanner\n")
+    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'
@@ -79,7 +157,8 @@ def create_single_pbn_string(
     file += f'[Dealer "{dealer}"]\n'
     file += f'[Vulnerable "{vulnerability}"]\n'
     file += f'[Deal "{deal}"]\n'
-
+    file += dd_tricks
+    file += '\n'
     return file
 
 def merge_pbn(pbn_paths):
@@ -96,7 +175,7 @@ def merge_pbn(pbn_paths):
     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('\n')        
             f.write(v)
     return fn
 
@@ -107,7 +186,6 @@ def validate_pbn(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()
@@ -134,4 +212,21 @@ def validate_pbn(pbn_string):
             err_msg += '{direction.name} has {num_cards} cards. '
     
     if err_msg:
-        raise ValueError(err_msg)
+        raise ValueError(err_msg)
+    
+def parse_dds_table(raw_list):
+    table = []
+    row = []
+    tempchar = ''
+    for x in raw_list:
+        if len(x) > 0:
+            tempchar += x[0]
+        else:
+            if len(tempchar) > 0:
+                row.append(tempchar)
+            tempchar = ''
+
+        if len(row) == 3:
+            table.append(row)
+            row = []
+    return table