--split

[Ryan8l]

以笔者提供的unravel简谱链接为例，小节线(__split)函数无法分节，不知道是什么原因,是不是我需要重新截取模版再进行匹配？？

[MAraragi]

以笔者提供的unravel简谱链接为例，小节线(__split)函数无法分节，不知道是什么原因,是不是我需要重新截取模版再进行匹配？？

您好，非常感谢您能关注到我的工作！
请问函数__split()是在哪行语句报错呢？关于无法分节的原因，我猜想一种可能是在二值化时将小节线截断，虽然这种可能不大，因为我记得unravel简谱的小节线很均匀连续。如果方便的话可以提供更多相关报错信息吗？
如果您希望自己截取模板的话，可以这样操作：

• 首先选择一张很清晰的简谱图片，启用recognition.py的__match()方法中第345-363行注释中的代码；
• 随后针对该简谱图片运行项目代码，无论是运行main.py还是recognition.py都可以；
• 然后在文件夹templates_imgs下创建对应含义的模板文件夹，比如创建文件夹“1”，然后从上个步骤生成的./***_slices文件夹中选取数字1对应的图片，放到我们创建的文件夹“1”中；
• 最后运行KdTree.py即可。
  值得一提的是这个小项目是我尚未接触机器学习时完成的，当前运行速度可以说是非常慢，也可以自己编写代码调用recognition.py中的class和method来保存中间结果。我计划在这个寒假对其进行改进。
  如果代码运行顺利，应该会得到与new_midi_file中的unravel.mid相同的结果。
  希望以上回答能够对您有所帮助，如果仍遇到问题随时欢迎讨论！

P.S.妈耶感谢xd，居然真的有同学看到我写的小项目了欸，还是有点激动的哈。我目前想到一些行之有效的效率、识别精度改进方法，xd有意的话还请多多关注，应该等到下学期开学前这个项目就会厉害很多的。

[yet-0911]

您好～想請問有更新加速運行速度的版本嗎><? 謝謝！

[MAraragi]

您好～想請問有更新加速運行速度的版本嗎><? 謝謝！

您好您好，目前为止这个小项目完全没有动过哈）
如果要加速的话可以试试把多线程改成多进程，用joblib库应该可以比较方便地实现，这是大模型给出的改进后代码：

from joblib import Parallel, delayed

def __match(self):
    print("......准备进行字符匹配，这可能需要一些时间......" * self.print_info, end=self.print_info_end)

    def readTemplate(tem_path):
        kdTree = KDTree()
        tem_height, tem_width, tem_KdTree_original = kdTree.readTemplate(tem_path)
        tem_KdTree = []
        for node in tem_KdTree_original:
            tem_KdTree.append([])
            tem_KdTree[-1].append([node[0][0], node[0][1]])
            tem_KdTree[-1].append(node[1])
            tem_KdTree[-1].append(node[2])
            tem_KdTree[-1].append(node[3])
        return [tem_height, tem_width, tem_KdTree]

    templates = []
    templates_dir_name = self.ospath + "/" + "templates" + "_" * (self.sampling_rate - 1)
    try:
        templates_dir = os.listdir(templates_dir_name)
    except:
        print(self.FOLDER_NOT_FOUND_ERROR + "templates" + "_" * (self.sampling_rate - 1))
        return False
    for i in templates_dir:
        template_dir_name = templates_dir_name + "/" + i
        template_dir = os.listdir(template_dir_name)
        for j in template_dir:
            template_path = template_dir_name + "/" + j
            templates.append([i, readTemplate(template_path)])

    def matchUsingProcess(part_front, part_behind):
        for num in range(part_front, part_behind):
            i = self.frame[num]
            currentFrame = self.thImg[i[0]: i[1] + 1, i[2]: i[3] + 1]
            src_height, src_width = i[1] - i[0] + 1, i[3] - i[2] + 1
            preExcludeRuler = src_height / src_width
            src_contours_temp, src_hierarchy = cv2.findContours(currentFrame,
                                                                cv2.RETR_TREE,
                                                                cv2.CHAIN_APPROX_NONE)
            if len(src_contours_temp) == 1:
                i.append("none")
                i.append([])
                continue
            src_contours = src_contours_temp[1:]
            src_cdtf = []
            for j in src_contours:
                for k in range(len(j)):
                    if k % self.match_precision == self.match_precision - 1:
                        src_cdtf.append([j[k][0][0], j[k][0][1]])
            if not src_cdtf:
                i.append("none")
                i.append([])
                continue
            kdTree_src_cdtf = KDTree()
            kdTree_src_cdtf.createKDTree(src_cdtf, create_list=False)

            min_sum = -1
            result = "none"
            for j in templates:
                template_name = j[0]
                if preExcludeRuler >= 0.9 and template_name == "h":
                    continue
                if template_name == "d":
                    if preExcludeRuler <= 0.666667 or preExcludeRuler >= 1.5:
                        continue
                if template_name in ["ve", 'b', "vi"] and preExcludeRuler <= 1.5:
                    continue

                template_height, template_width, template_KdTree_list = j[1]
                template_KdTree_list_current = []
                distance_sum_temp = 0
                for coordinate in template_KdTree_list:
                    template_KdTree_list_current.append([])
                    template_KdTree_list_current[-1].append([coordinate[0][0] * src_width / template_width,
                                                             coordinate[0][1] * src_height / template_height])
                    template_KdTree_list_current[-1].append(coordinate[1])
                    template_KdTree_list_current[-1].append(coordinate[2])
                    template_KdTree_list_current[-1].append(coordinate[3])
                    distance_sum_temp += kdTree_src_cdtf.searchKDTreeInNode(template_KdTree_list_current[-1][0])
                distance_sum_temp /= len(template_KdTree_list_current)

                distance_sum_src = 0
                for src_coordinate in src_cdtf:
                    distance_sum_src += kdTree_src_cdtf
                    distance_sum_src += kdTree_src_cdtf.searchKDTreeInList(src_coordinate, template_KdTree_list_current)
                distance_sum_src /= len(src_cdtf)

                distance_sum = distance_sum_temp + distance_sum_src
                # print(f"{template_name}: " + str(distance_sum))
                if distance_sum < min_sum or min_sum == -1:
                    min_sum = distance_sum
                    result = template_name
            i.append(result)
            i.append([])

    frame_length = len(self.frame)
    frame_parts = []
    part_length = int(frame_length / self.thread_num)
    front = 0
    behind = part_length
    if behind == 0:
        frame_parts.append([0, frame_length])
    else:
        while behind < frame_length:
            frame_parts.append([front, behind])
            front = behind
            behind += part_length
        frame_parts.append([front, frame_length])

    def showProgress():
        matched_num = 0
        last_progress = -1
        while matched_num != frame_length:
            matched_num = frame_length - sum(1 for f in self.frame if len(f) < 5)
            if matched_num > last_progress:
                last_progress = matched_num
                print(self.imgname + ": match in progress (" + str(matched_num)
                      + "/" + str(frame_length) + ")")
            else:
                time.sleep(0.01)

    # 使用 joblib 的 Parallel 和 delayed 来创建多进程
    results = Parallel(n_jobs=self.thread_num)(delayed(matchUsingProcess)(part[0], part[1]) for part in frame_parts)

    # 显示进度
    if self.print_info == 1:
        showProgress()

    """
    current_time = time.localtime()
    time_str = time.strftime("%Y-%m-%d %H:%M:%S", current_time)
    print(time_str)
    """

    """
    # 将轮廓划分结果的切片保存为图片，放在一个文件夹里
    dirpath = self.ospath + "/" + self.imgname + "_slices"
    if not os.path.exists(dirpath):
        os.mkdir(dirpath)
    for num in range(len(self.frame)):
        i = self.frame[num]
        i[1] += 1 if i[0] == i[1] else 0
        i[3] += 1 if i[2] == i[3] else 0
        currentFrame = self.thImg[i[0]: i[1] + 1, i[2]: i[3] + 1]
        cv2.imwrite(dirpath + "/frame" + str(num) + ".png", currentFrame)
    print("......已生成切片......")
    # 将符号匹配结果保存为txt文档
    f = open(self.imgname + "_recogResult.txt", "w")
    for i in range(len(self.frame)):
        if self.frame[i][4] in self.NAME_REFLECTION.keys():
            f.write(f"{i}: {self.NAME_REFLECTION[self.frame[i][4]]}\n")
        else:
            f.write(f"{i}: {self.frame[i][4]}\n")
    f.close()
    """

    return True

另外当前需要加速的部分是recognition.py的__match()里面的多层循环嵌套，每一层的对象都是list。如果您有意可以试试把这个改成用numpy和cuda以加速。