update scripts for parsing the data

scripts/data_class.py

@@ -0,0 +1,135 @@
+import numpy as np
+
+
+IMG_FLAG = "img"
+TEXT_FLAG = "text"
+
+
+class nodeBbox:
+    def __init__(self, img_w, img_h, left=0, top=0, width=0, height=0) -> None:
+        assert img_w is not None
+        assert img_h is not None
+    
+        self.left: int = round(left)
+        self.top: int = round(top)
+        self.width: int = round(width)
+        self.height: int = round(height)
+
+        self.x1: int = self.left
+        self.y1: int = self.top
+        self.x2: int = self.left + self.width
+        self.y2: int = self.top + self.height
+
+        self.cx: int = round((self.x1 + self.x2) / 2)
+        self.cy: int = round((self.y1 + self.y2) / 2)
+
+        self.is_valid: bool = True
+
+        if not (0 <= self.x1 <= img_w and 0 <= self.y1 <= img_h and 0 <= self.x2 <= img_w and 0 <= self.y2 <= img_h):
+            self.is_valid = False
+        
+        if self.x1 >= self.x2 or self.y1 >= self.y2:
+            self.is_valid = False
+
+    def get_max_IoU(self, others) -> float:
+        other_bbox = np.array([[o.x1, o.y1, o.x2, o.y2] for o in others])
+
+        other_bbox[:, 0:1] = np.clip(other_bbox[:, 0:1], a_min=self.x1, a_max=None)
+        other_bbox[:, 1:2] = np.clip(other_bbox[:, 1:2], a_min=self.y1, a_max=None)
+        other_bbox[:, 2:3] = np.clip(other_bbox[:, 2:3], a_min=None, a_max=self.x2)
+        other_bbox[:, 3:4] = np.clip(other_bbox[:, 3:4], a_min=None, a_max=self.y2)
+
+        inter_w = np.clip(other_bbox[:, 2] - other_bbox[:, 0], a_min=0, a_max=None)
+        inter_h = np.clip(other_bbox[:, 3] - other_bbox[:, 1], a_min=0, a_max=None)
+
+        IoU = inter_w * inter_h
+
+        return np.max(IoU)
+
+
+class nodeInfo:
+    def __init__(self, name=None, type=None, func=None, text=None, title=None, bbox=None, point=None, pointer=False, tokenizer=None, img_w=None, img_h=None) -> None:
+        dom_name = name if isinstance(name, str) else ""
+        dom_type = type if isinstance(type, str) else ""
+        dom_func = func if isinstance(func, str) else ""
+        dom_text = text if isinstance(text, str) else ""
+        dom_title = title if isinstance(title, str) else ""
+        dom_bbox = nodeBbox(img_w=img_w, img_h=img_h, **bbox) if isinstance(bbox, dict) else nodeBbox()
+        dom_point = point if isinstance(point, dict) else {"x": 0, "y": 0}
+        dom_pointer = pointer if isinstance(pointer, bool) else False
+        is_valid = dom_bbox.is_valid
+
+        self.name: str = dom_name.lower()
+        self.type: str = dom_type
+        self.func: str = dom_func
+        self.text: str = dom_text
+        self.title: str = dom_title
+        self.bbox: nodeBbox = dom_bbox
+        self.point: dict = dom_point
+        self.pointer: bool = dom_pointer
+        self.is_valid: bool = is_valid
+
+
+class domNode:
+    def __init__(self, id, info, children, father=None, tokenizer=None, img_w=None, img_h=None, task=""):
+        self.id: str = id
+        self.info: nodeInfo = nodeInfo(img_w=img_w, img_h=img_h, tokenizer=tokenizer, **info)
+        self.father: domNode = father
+
+        is_valid = self.info.is_valid
+        
+        if self.is_img() and not self.info.text:
+            is_valid = False
+        
+        children_nodes = []
+        for child in children:
+            child_node = type(self)(father=self, tokenizer=tokenizer, img_w=img_w, img_h=img_h, task=task, **child)
+            children_nodes.append(child_node)
+            if not child_node.is_valid:
+                is_valid = False
+
+        self.children: list[domNode] = children_nodes
+        self.is_valid: bool = is_valid
+
+        for child in self.children:
+            if child.is_leaf() and child.info.type == 'text' and self.info.func == 'text':
+                self.info.func = 'plain'
+                break
+
+        self.class_for_caption: str = ""
+        if self.info.name in ['a', 'button']:
+            self.class_for_caption = self.info.name
+        elif self.info.name == 'input':
+            if self.info.func == 'click':
+                self.class_for_caption = 'button'
+            elif self.info.func == 'type':
+                self.class_for_caption = 'input'
+        elif self.img_type():
+            if self.img_type() in ['img', 'bgimg']:
+                self.class_for_caption = 'img'
+            elif self.img_type() in ['svg', 'fa']:
+                self.class_for_caption = 'svg'
+        elif self.is_text():
+            self.class_for_caption = 'text'
+
+    def is_leaf(self) -> bool:
+        return len(self.children) == 0
+    
+    def has_single_text_child(self) -> bool:
+        return len(self.children) == 1 and self.children[0].info.type == 'text'
+
+    def is_func_leaf(self) -> bool:
+        if self.is_leaf():
+            return not self.is_text()
+        return self.has_single_text_child()
+    
+    def is_text(self) -> bool:
+        return self.info.type == TEXT_FLAG
+    
+    def is_img(self) -> bool:
+        return self.info.type.startswith(IMG_FLAG)
+    
+    def img_type(self) -> str:
+        if not self.is_img():
+            return ""
+        return self.info.type[len(IMG_FLAG) + 1: -1]

scripts/make_dom.py

@@ -0,0 +1,268 @@
+import os
+import os.path as osp
+import json
+import random
+import transformers
+from tqdm import tqdm
+from multiprocessing import Pool
+from functools import partial
+
+from data_class import domNode, nodeBbox
+
+
+MAX_TOKEN_LEN = 800
+MIN_TOKEN_LEN = 200
+MAX_IoU = 0
+
+HTML2BBOX_TEMPLATE = [
+    "Where is the given dom tree?",
+    # Other template questions here...
+]
+
+BBOX2HTML_TEMPLATE = [
+    "Can you give me a description of the region <objs> in image?",
+    # Other template questions here...
+]
+
+
+class NodewithHtml(domNode):
+    def __init__(self, id, info=None, children=None, father=None, tokenizer=None, img_w=None, img_h=None, task=""):
+        super().__init__(id, info, children, father, tokenizer, img_w=img_w, img_h=img_h, task="")
+        self.dom_xml = self.get_dom_xml(mode="dom_xml")
+        self.dom_xml_with_bbox = self.get_dom_xml(mode="dom_xml_with_bbox")
+
+    def bbox2str(self) -> str:
+        x1_rel = round(max(0, (self.info.bbox.x1 / IMG_W)) * 1000)
+        y1_rel = round(max(0, (self.info.bbox.y1 / IMG_H)) * 1000)
+        x2_rel = round(min(0.999, (self.info.bbox.x2 / IMG_W)) * 1000)
+        y2_rel = round(min(0.999, (self.info.bbox.y2 / IMG_H)) * 1000)
+
+        coords = [x1_rel, y1_rel, x2_rel, y2_rel]
+        bbox_str = ["{:03}".format(coord) for coord in coords]
+        bbox_str = "[" + ", ".join(bbox_str) + "]"
+        
+        return bbox_str
+    
+    def center2str(self) -> str:
+        cx = round(max(0, min(0.999, self.info.bbox.cx / IMG_W)) * 1000)
+        cy = round(max(0, min(0.999, self.info.bbox.cy / IMG_H)) * 1000)
+
+        point = [cx, cy]
+        point_str = ["{:03}".format(p) for p in point]
+        point_str = "[" + ", ".join(point_str) + "]"
+        
+        return point_str
+
+    def node2xml_withbbox(self) -> str:
+        text = self.info.text
+        bbox_str = self.bbox2str()
+
+        if self.is_text() or self.has_single_text_child():
+            pseudo_html_line = f"<text box={bbox_str} content=\"{text}\">"
+        elif self.is_img():
+            if self.class_for_caption == 'img':
+                pseudo_html_line = f"<img box={bbox_str} alt={text}>"
+            elif self.class_for_caption == 'svg':
+                pseudo_html_line = f"<svg box={bbox_str} alt={text}>"
+            else:
+                return ""
+        elif self.info.func == 'type':
+            pseudo_html_line = f"<input box={bbox_str}, content=\"{text}\">"
+        else:
+            if self.is_leaf():
+                return ""
+            else:
+                pseudo_html_line = f"<plain box={bbox_str}>"
+
+        return pseudo_html_line
+
+    def node2xml(self) -> str:
+        text = self.info.text
+        bbox_str = self.bbox2str()
+        center_str = self.center2str()
+
+        if self.is_text() or self.has_single_text_child():
+            pseudo_html_line = f"<text content=\"{text}\">"
+        elif self.is_img():
+            if self.class_for_caption == 'img':
+                pseudo_html_line = f"<img alt={text}>"
+            elif self.class_for_caption == 'svg':
+                pseudo_html_line = f"<svg alt={text}>"
+            else:
+                return ""
+        elif self.info.func == 'type':
+            pseudo_html_line = f"<input center={center_str}, content=\"{text}\">"
+        else:
+            if self.is_leaf():
+                return ""
+            else:
+                pseudo_html_line = f"<plain>"
+
+        return pseudo_html_line
+
+    def get_dom_xml(self, mode: str):
+        xml_func = self.node2xml if mode == 'dom_xml' else self.node2xml_withbbox
+
+        self_dom_xml = xml_func()
+        if not self_dom_xml:
+            return ""
+        
+        dom_xml_list = [self_dom_xml]
+
+        if not self.is_func_leaf():
+            for child in self.children:
+                child_xml = getattr(child, mode)
+                if not child_xml:
+                    return ""
+                child_xml_list = child_xml.strip().split('\n')
+                child_xml_list = ['\t' + line for line in child_xml_list]
+                child_xml_fmt = '\n'.join(child_xml_list)
+                dom_xml_list.append(child_xml_fmt)
+
+        dom_xml = '\n'.join(dom_xml_list)
+        return dom_xml
+
+
+tokenizer = transformers.AutoTokenizer.from_pretrained(
+    "path/to/your/tokenizer",
+    trust_remote_code=True,
+)
+
+
+def get_str_token_len(str_: str) -> int:
+    return len(tokenizer.encode(str_))
+
+
+def collect_nodes(dom: NodewithHtml, node_list: list[NodewithHtml]) -> list:
+    if dom.is_valid:
+        node_list.append(dom)
+
+    for child in dom.children:
+        collect_nodes(child, node_list)
+
+    return node_list
+
+
+def selece_node(xml: str, bbox: nodeBbox, selected_dom_list: list[nodeBbox]) -> bool:
+    if not xml:
+        return False
+
+    try:
+        token_len = get_str_token_len(xml)
+    except:
+        return False
+    if token_len > MAX_TOKEN_LEN or token_len < MIN_TOKEN_LEN:
+        return False
+
+    if selected_dom_list:
+        max_IoUs = bbox.get_max_IoU(selected_dom_list)
+        if max_IoUs > MAX_IoU:
+            return False
+
+    return True
+
+
+def make_qa(node_list: list[NodewithHtml], img_path: str):
+    random.shuffle(node_list)
+
+    dom_xml_list = []
+    dom_xml_with_bbox_list = []
+
+    ann_list = []
+    for node in node_list:
+        if selece_node(node.dom_xml_with_bbox, node.info.bbox, dom_xml_with_bbox_list):
+            bbox2html_prompt = random.choice(BBOX2HTML_TEMPLATE)
+            prompt = bbox2html_prompt.replace("<objs>", node.bbox2str())
+            caption = node.dom_xml_with_bbox
+
+            ann = {
+                "image": img_path,
+                "conversations": [
+                    {
+                        "from": "human",
+                        "value": f"<image>\n{prompt}"
+                    },
+                    {
+                        "from": "gpt",
+                        "value": caption
+                    }
+                ]
+            }
+            ann_list.append(ann)
+            dom_xml_with_bbox_list.append(node.info.bbox)
+    
+    return ann_list
+
+
+def write_ann(ann_list, ann_path):
+    ann_dir = osp.dirname(ann_path)
+    if not osp.exists(ann_dir):
+        os.mkdir(ann_dir)
+
+    with open(ann_path, 'a', encoding='utf-8') as f:
+        for i in range(len(ann_list)):
+            ann_list[i]['id'] = i
+
+            ann_str = json.dumps(ann_list[i], ensure_ascii=False)
+            f.write(ann_str + '\n')
+
+
+def single_proc(data_dir, language, sub_dir):
+    sub_path = osp.join(data_dir, sub_dir)
+    screen_shot_dir = osp.join(sub_path, 'screenshot')
+    dom_sub_dir = 'dom_svg' if language == 'zh' else 'dom_svg_en'
+    dom_dir = osp.join(sub_path, dom_sub_dir)
+    html_dir = osp.join(sub_path, 'html')
+
+    html_path = osp.join(html_dir, 'html_0.html')
+    if not osp.exists(html_path):
+        return []
+    html_content = open(html_path).readline().strip()
+    if html_content in ['https://www.qq.com/', 'https://music.163.com/']:
+        return []
+
+    all_annotations = []
+    for img_file in os.listdir(screen_shot_dir):
+        if 'tmp' in img_file:
+            continue
+        file_ids = img_file.split('.')[0].split('_')[1]
+        json_path = osp.join(dom_dir, f'dom_{file_ids}.json')
+        img_path = osp.join(screen_shot_dir, img_file)
+        if not osp.exists(json_path):
+            continue
+
+        dom_data = json.load(open(json_path))
+        try:
+            dom_node = NodewithHtml(tokenizer=tokenizer, img_w=IMG_W, img_h=IMG_H, task='dom', **dom_data)
+        except ValueError as e:
+            print(f"Json data error: {e}\n{json_path}")
+            continue
+
+        node_list = collect_nodes(dom_node, [])
+        annotations = make_qa(node_list, img_path)
+        all_annotations.extend(annotations)
+    
+    return all_annotations
+
+
+def main_multi(data_dir, dst_path, language):
+    pool = Pool(processes=16)
+
+    sub_dir_list = os.listdir(data_dir)
+    single_proc_partial = partial(single_proc, data_dir, language)
+
+    num = 0
+    for res in tqdm(pool.imap_unordered(single_proc_partial, sub_dir_list), total=len(sub_dir_list)):
+        write_ann(res, dst_path)
+        num += len(res)
+
+
+IMG_W = 1920
+IMG_H = 1080
+
+data_dir = 'data_20240624'
+dst_path = 'xxx.jsonl'
+
+
+if __name__ == '__main__':
+    main_multi(data_dir, dst_path, 'en')

scripts/make_ocr.py

@@ -0,0 +1,402 @@
+import os
+import os.path as osp
+import json
+import random
+import transformers
+from tqdm import tqdm
+from multiprocessing import Pool
+from functools import partial
+from copy import deepcopy
+
+from data_class import domNode, nodeBbox
+
+
+MAX_TOTAL_LEN = 800
+MAX_TOKEN_LEN = 50
+MIN_TOKEN_LEN = 0
+MAX_IoU = 0
+
+NODE_SEPARATOR_TOKEN = '<node_separator>'
+
+TEXT2BBOX_TEMPLATE = [
+    "Where is the given content?",
+    # Other template questions here...
+]
+
+BBOX2TEXT_TEMPLATE = [
+    "Can you give me a description of the region in image?",
+    # Other template questions here...
+]
+
+
+class NodewithOCR(domNode):
+    def __init__(self, id, info, children, father=None, tokenizer=None, img_w=None, img_h=None, task=""):
+        super().__init__(id, info, children, father, tokenizer, img_w=img_w, img_h=img_h, task="")
+        self.struct_text: str = self.get_struct_text()
+
+    def get_struct_text(self) -> str:
+        if self.is_leaf():
+            struct_text = self.info.text.strip()
+            if self.is_img():
+                if not struct_text:
+                    return ""
+                if self.info.type == 'img[svg]':
+                    struct_text = '[svg]' + struct_text
+                else:
+                    struct_text = '[image]' + struct_text
+            return struct_text
+        
+        children_text = []
+        for child in self.children:
+            child_text = child.struct_text
+            if child_text:
+                children_text.append(child.struct_text)
+        return NODE_SEPARATOR_TOKEN.join(children_text)
+    
+    def get_context_text(self, root_text: str) -> str:
+        self.context_text: str = ""
+
+        cur_node = self
+        for _ in range(3):
+            if root_text.count(cur_node.struct_text) == 1:
+                func = ''
+                if self.info.func == 'type':
+                    func += '(input box)'
+                elif self.info.func == 'click':
+                    func += '(clickable)'
+                elif self.info.func == 'text':
+                    func += '(pure text)'
+                if cur_node == self:
+                    context = ""
+                else:
+                    context = f'(context: "{cur_node.struct_text}")'
+                self.context_text = self.struct_text + func + context
+                return
+
+            if not cur_node.father:
+                return
+
+            cur_node = cur_node.father
+
+    # x1, y1, x2, y2
+    def bbox2str(self) -> str:
+        x1_rel = round(max(0, (self.info.bbox.x1 / IMG_W)) * 1000)
+        y1_rel = round(max(0, (self.info.bbox.y1 / IMG_H)) * 1000)
+        x2_rel = round(min(0.999, (self.info.bbox.x2 / IMG_W)) * 1000)
+        y2_rel = round(min(0.999, (self.info.bbox.y2 / IMG_H)) * 1000)
+
+        coords = [x1_rel, y1_rel, x2_rel, y2_rel]
+        bbox_str = ["{:03}".format(coord) for coord in coords]
+        bbox_str = "[" + ", ".join(bbox_str) + "]"
+        
+        return bbox_str
+    
+    # x1, y1, x2, y2  seeclick_format
+    def bbox2str_2(self) -> str:
+        x1_rel = round(max(0, (self.info.bbox.x1 / IMG_W)), 2)
+        y1_rel = round(max(0, (self.info.bbox.y1 / IMG_H)), 2)
+        x2_rel = round(min(0.999, (self.info.bbox.x2 / IMG_W)), 2)
+        y2_rel = round(min(0.999, (self.info.bbox.y2 / IMG_H)), 2)
+
+        coords = [x1_rel, y1_rel, x2_rel, y2_rel]
+        bbox_str = ["{:.2f}".format(coord) for coord in coords]
+        bbox_str = "(" + ",".join(bbox_str) + ")"
+        
+        return bbox_str
+    
+    # bbox center_x, center_y, w, h
+    def bbox2str_ct(self) -> str:
+        cx_rel = round(min(0.999, max(0, (self.info.bbox.cx / IMG_W))) * 1000)
+        cy_rel = round(min(0.999, max(0, (self.info.bbox.cy / IMG_H))) * 1000)
+        w_rel = round(min(0.999, max(0, (self.info.bbox.width / IMG_W))) * 1000)
+        h_rel = round(min(0.999, max(0, (self.info.bbox.height / IMG_H))) * 1000)
+
+        coords = [cx_rel, cy_rel, w_rel, h_rel]
+        bbox_str = ["{:03}".format(coord) for coord in coords]
+        bbox_str = "[" + ", ".join(bbox_str) + "]"
+        
+        return bbox_str
+    
+    # block idx, bbox center_x, center_y, w, h
+    def bbox2str_ct_block(self, block_num_w=2, block_num_h=2) -> str:
+        block_w = IMG_W // block_num_w
+        block_h = IMG_H // block_num_h
+
+        block_xi = max(0, min(IMG_W - 1, self.info.bbox.cx)) // block_w
+        block_yi = max(0, min(IMG_H - 1, self.info.bbox.cy)) // block_h
+        block_idx = block_yi * block_num_w + block_xi
+
+        cx_block = self.info.bbox.cx % block_w
+        cy_block = self.info.bbox.cy % block_h
+
+        cx_rel = round(min(0.999, max(0, (cx_block / block_w))) * 1000)
+        cy_rel = round(min(0.999, max(0, (cy_block / block_h))) * 1000)
+        w_rel = round(min(0.999, max(0, (self.info.bbox.width / block_w))) * 1000)
+        h_rel = round(min(0.999, max(0, (self.info.bbox.height / block_h))) * 1000)
+
+        coords = [cx_rel, cy_rel, w_rel, h_rel]
+        bbox_str = [str(block_idx)] + ["{:03}".format(coord) for coord in coords]
+        bbox_str = "[" + ", ".join(bbox_str) + "]"
+        
+        return bbox_str
+    
+    # center point  seeclick_format
+    def bbox2str_ct_2(self) -> str:
+        cx_rel = round(min(0.999, max(0, (self.info.bbox.cx / IMG_W))), 2)
+        cy_rel = round(min(0.999, max(0, (self.info.bbox.cy / IMG_H))), 2)
+
+        coords = [cx_rel, cy_rel]
+        bbox_str = ["{:.2f}".format(coord) for coord in coords]
+        bbox_str = "(" + ",".join(bbox_str) + ")"
+        
+        return bbox_str
+
+
+def init_context_text(node: NodewithOCR, root_text: str):
+    node.get_context_text(root_text)
+    for child in node.children:
+        init_context_text(child, root_text)
+
+
+tokenizer = transformers.AutoTokenizer.from_pretrained(
+    "path/to/your/tokenizer",
+    trust_remote_code=True,
+)
+tokenizer.add_tokens([NODE_SEPARATOR_TOKEN], special_tokens=True)
+
+
+def get_str_token_len(str_: str) -> int:
+    return len(tokenizer.encode(str_))
+
+
+def collect_nodes(dom: NodewithOCR, node_list: list[NodewithOCR]) -> list:
+    if dom.is_valid:
+        node_list.append(dom)
+
+    for child in dom.children:
+        collect_nodes(child, node_list)
+
+    return node_list
+
+
+def select_node(node, node_text, node_bbox: nodeBbox, selected_node_list: list[domNode], total_len: int) -> tuple[bool, int]:
+    if node.info.func == 'type':
+        if not node.context_text:
+            return False, total_len
+    if not node_text:
+        return False, total_len
+
+    try:
+        token_len = get_str_token_len(node_text)
+    except:
+        return False, total_len
+    if token_len > MAX_TOKEN_LEN or token_len < MIN_TOKEN_LEN:
+        return False, total_len
+    
+    total_len += token_len + 20
+
+    if selected_node_list:
+        selected_bbox_list = [_node.info.bbox for _node in selected_node_list]
+        max_IoUs = node_bbox.get_max_IoU(selected_bbox_list)
+        if max_IoUs > MAX_IoU:
+            return False, total_len
+
+    return True, total_len
+
+
+def get_bbox_text(node_list: list[NodewithOCR], context=False, is_point=True, is_seeclick=False):  
+    input_node_list = [_node for _node in node_list if _node.info.func == 'type']
+    pointer_node_list = [_node for _node in node_list if _node.info.pointer]
+    click_node_list = [_node for _node in node_list if not _node.info.pointer and _node.info.func == 'click']
+    text_node_list = [_node for _node in node_list if _node.info.func == 'text']
+
+    input_node_list_copy = deepcopy(input_node_list)
+    pointer_node_list_copy = deepcopy(pointer_node_list)
+    click_node_list_copy = deepcopy(click_node_list)
+    text_node_list_copy = deepcopy(text_node_list)
+
+    random.shuffle(input_node_list_copy)
+    random.shuffle(pointer_node_list_copy)
+    random.shuffle(click_node_list_copy)
+    random.shuffle(text_node_list_copy)
+
+    node_list_copy = input_node_list_copy + pointer_node_list_copy + click_node_list_copy + text_node_list_copy
+
+    total_len = 0
+    selected_node_list = []
+    for node in node_list_copy:
+        node_text = node.context_text if context else node.struct_text
+        keep, total_len = select_node(node, node_text, node.info.bbox, selected_node_list, total_len)
+        if total_len > MAX_TOTAL_LEN:
+            break
+        if keep:
+            selected_node_list.append(node)
+    random.shuffle(selected_node_list)
+
+    bbox_str_list = []
+    text_str_list = []
+    for i, node in enumerate(selected_node_list):
+        node_text = node.context_text if context else node.struct_text
+
+        if not is_seeclick:
+            bbox_str_list.append(f"{i+1}. {node.bbox2str_ct_block(block_num_w=BLOCK_NUM_W, block_num_h=BLOCK_NUM_H)}")
+        else:
+            if is_point:
+                bbox_str_list.append(f"{i+1}. {node.bbox2str_ct_2()}")
+            else:
+                bbox_str_list.append(f"{i+1}. {node.bbox2str_2()}")
+
+        text_str_list.append(f"{i+1}. {node_text}")
+        
+    bbox_str = '\n'.join(bbox_str_list)
+    text_str = '\n'.join(text_str_list)
+
+    return bbox_str, text_str
+
+
+def make_bbox2text(node_list: list[NodewithOCR], img_path: str, is_point=True, is_seeclick=False):
+    bbox_str, text_str = get_bbox_text(node_list, context=False, is_point=is_point, is_seeclick=is_seeclick)
+    if not bbox_str or not text_str:
+        return
+    
+    prompt = bbox_str + '\n' + random.choice(BBOX2TEXT_TEMPLATE)
+    return {
+        "image": img_path,
+        "conversations": [
+            {
+                "from": "human",
+                "value": f"<image>\n{prompt}"
+            },
+            {
+                "from": "gpt",
+                "value": text_str
+            }
+        ]
+    }
+
+
+def make_text2bbox(node_list: list[NodewithOCR], img_path: str, is_point=True, is_seeclick=False):
+    bbox_str, text_str = get_bbox_text(node_list, context=True, is_point=is_point, is_seeclick=is_seeclick)
+    if not bbox_str or not text_str:
+        return
+    
+    prompt = text_str + '\n' + random.choice(TEXT2BBOX_TEMPLATE) + '(bbox: [block_index, cx, cy, w, h])'
+
+    return {
+        "image": img_path,
+        "conversations": [
+            {
+                "from": "human",
+                "value": f"<image>\n{prompt}"
+            },
+            {
+                "from": "gpt",
+                "value": bbox_str
+            }
+        ]
+    }
+
+
+def write_ann(ann_list, ann_path, mode='w', save_ratio=1.0):
+    ann_dir = osp.dirname(ann_path)
+    if not osp.exists(ann_dir):
+        os.mkdir(ann_dir)
+
+    if save_ratio == 1.0 or random.random() < save_ratio:
+        with open(ann_path, mode, encoding='utf-8') as f:
+            for i in range(len(ann_list)):
+                ann_list[i]['id'] = i
+
+                ann_str = json.dumps(ann_list[i], ensure_ascii=False)
+                f.write(ann_str + '\n')
+
+
+def single_proc(mode, data_dir, language, sub_dir):
+    sub_path = osp.join(data_dir, sub_dir)
+    screen_shot_dir = osp.join(sub_path, 'screenshot')
+    dom_sub_dir = 'dom_svg' if language == 'zh' else 'dom_svg_en'
+    dom_dir = osp.join(sub_path, dom_sub_dir)
+    html_dir = osp.join(sub_path, 'html')
+
+    html_path = osp.join(html_dir, 'html_0.html')
+    if not osp.exists(html_path):
+        return []
+    html_content = open(html_path).readline().strip()
+    if html_content in ['https://www.qq.com/', 'https://music.163.com/']:
+        return []
+
+    all_annotations = []
+    for img_file in os.listdir(screen_shot_dir):
+        if 'tmp' in img_file:
+            continue
+        file_ids = img_file.split('.')[0].split('_')[1]
+        json_path = osp.join(dom_dir, f'dom_{file_ids}.json')
+        img_path = osp.join(screen_shot_dir, img_file)
+        if not osp.exists(json_path):
+            continue
+
+        dom_data = json.load(open(json_path))
+
+        try:
+            dom_node = NodewithOCR(tokenizer=tokenizer, img_w=IMG_W, img_h=IMG_H, task=mode, **dom_data)
+        except ValueError as e:
+            print(f"Json data error: {e}\n{json_path}")
+            continue
+
+        init_context_text(dom_node, dom_node.struct_text)
+
+        node_list = collect_nodes(dom_node, [])
+        if mode == 'bbox2text':
+            ann = make_bbox2text(node_list, img_path, is_seeclick=False, is_point=False)
+        elif mode == 'text2bbox':
+            ann = make_text2bbox(node_list, img_path, is_seeclick=False, is_point=False)
+        elif mode == 'text2bbox_seeclick':
+            ann = make_text2bbox(node_list, img_path, is_seeclick=True, is_point=False)
+        elif mode == 'bbox2text_seeclick':
+            ann = make_bbox2text(node_list, img_path, is_seeclick=True, is_point=False)
+        elif mode == 'text2point_seeclick':
+            ann = make_text2bbox(node_list, img_path, is_seeclick=True, is_point=True)
+        elif mode == 'point2text_seeclick':
+            ann = make_bbox2text(node_list, img_path, is_seeclick=True, is_point=True)
+
+        else:
+            assert 0
+        if ann is not None:
+            all_annotations.append(ann)
+    
+    return all_annotations
+
+
+def main_multi(data_dir, dst_path, mode, language='zh', save_ratio=1.0):
+    pool = Pool(processes=16)
+
+    sub_dir_list = os.listdir(data_dir)
+    single_proc_partial = partial(single_proc, mode, data_dir, language)
+
+    for res in tqdm(pool.imap_unordered(single_proc_partial, sub_dir_list), total=len(sub_dir_list)):
+        write_ann(res, dst_path, mode='a', save_ratio=save_ratio)
+
+
+if __name__ == '__main__':
+    mode = 'text2bbox'
+    # mode = 'bbox2text'
+    
+    # ZH
+    BLOCK_NUM_W = 2
+    BLOCK_NUM_H = 2
+    IMG_W = 1120
+    IMG_H = 1120
+
+    data_dir = 'data_20240617'
+    dst_path = f'xxx.jsonl'
+
+    # EN
+    BLOCK_NUM_W = 3
+    BLOCK_NUM_H = 2
+    IMG_W = 1920
+    IMG_H = 1080
+
+    data_dir = 'data_20240624'
+    dst_path = f'xxx.jsonl'
+
+    main_multi(data_dir, dst_path, mode, language='en')

scripts/readme.txt

@@ -0,0 +1,2 @@
+bbox2dom: make_dom.py
+text2bbox/bbox2text: make_ocr.py