def detect(self, im):
        """
        Detecting texts from an image
        :return: the bounding boxes of the detected texts
        """
        text_proposals, scores = self.text_proposal_detector.detect(
            im, cfg.MEAN)
        keep_inds = np.where(scores > cfg.TEXT_PROPOSALS_MIN_SCORE)[0]
        text_proposals, scores = text_proposals[keep_inds], scores[keep_inds]

        sorted_indices = np.argsort(scores.ravel())[::-1]
        text_proposals, scores = text_proposals[sorted_indices], scores[
            sorted_indices]

        # nms for text proposals
        keep_inds = nms(np.hstack((text_proposals, scores)),
                        cfg.TEXT_PROPOSALS_NMS_THRESH)
        text_proposals, scores = text_proposals[keep_inds], scores[keep_inds]

        scores = normalize(scores)

        text_lines = self.text_proposal_connector.get_text_lines(
            text_proposals, scores, im.shape[:2])

        keep_inds = self.filter_boxes(text_lines)
        text_lines = text_lines[keep_inds]

        # nms for text lines
        if text_lines.shape[0] != 0:
            keep_inds = nms(text_lines, cfg.TEXT_LINE_NMS_THRESH)
            text_lines = text_lines[keep_inds]
        text_lines = sorted(text_lines,
                            key=lambda x: -float(x[1]),
                            reverse=True)
        return text_lines
Beispiel #2
0
    def detect(self, im):
        """
        Detecting texts from an image
        :return: the bounding boxes of the detected texts
        """
        text_proposals, scores=self.text_proposal_detector.detect(im, cfg.MEAN)
        keep_inds=np.where(scores>cfg.TEXT_PROPOSALS_MIN_SCORE)[0]
        text_proposals, scores=text_proposals[keep_inds], scores[keep_inds]

        sorted_indices=np.argsort(scores.ravel())[::-1]
        text_proposals, scores=text_proposals[sorted_indices], scores[sorted_indices]

        # nms for text proposals
        keep_inds=nms(np.hstack((text_proposals, scores)), cfg.TEXT_PROPOSALS_NMS_THRESH)
        text_proposals, scores=text_proposals[keep_inds], scores[keep_inds]

        scores=normalize(scores)

        text_lines=self.text_proposal_connector.get_text_lines(text_proposals, scores, im.shape[:2])

        keep_inds=self.filter_boxes(text_lines)
        text_lines=text_lines[keep_inds]

        # nms for text lines
        if text_lines.shape[0]!=0:
            keep_inds=nms(text_lines, cfg.TEXT_LINE_NMS_THRESH)
            text_lines=text_lines[keep_inds]

        return text_lines
Beispiel #3
0
def detect(root, img_file, model_file):
    net = Net.CTPN()
    net.load_state_dict(torch.load(model_file))
    # net.cuda()
    print(net)
    net.eval()
    text_connector = TextProposalConnector()
    im = cv2.imread(os.path.join(root, img_file))
    # im = Dataset.scale_img(im, None, shortest_side=600)
    img = copy.deepcopy(im)
    img = img.transpose(2, 0, 1)
    img = img[np.newaxis, :, :, :]
    img = torch.Tensor(img)
    # img = img.cuda()
    v, score, side = net(img, val=True)
    score = score.cpu().detach().numpy()[:, :, :, 1]
    result = np.where(score > 0.7)
    for_nms = []
    for anchor, height, width in zip(result[0], result[1], result[2]):
        vc = v[anchor, 0, height, width]
        vh = v[anchor, 1, height, width]
        cya = height * 16 + 7.5
        ha = anchor_height[anchor]
        cy = vc * ha + cya
        h = math.pow(10, vh) * ha
        pt = other.trans_to_2pt(width, cy, h)
        for_nms.append(
            [pt[0], pt[1], pt[2], pt[3], score[anchor, height, width]])
    for_nms = np.array(for_nms, dtype=np.float32)
    nms_result = nms.cpu_nms(for_nms, TEXT_LINE_NMS_THRESH)
    text_proposals = []
    text_proposal_score = []
    for i in nms_result:
        text_proposals.append(for_nms[i, 0:4])
        text_proposal_score.append(for_nms[i, 4])
    text_proposals = np.array(text_proposals)
    text_proposal_score = np.array(text_proposal_score)
    text_proposal_score = other.normalize(text_proposal_score)
    text_lines = text_connector.get_text_lines(text_proposals,
                                               text_proposal_score,
                                               im.shape[:2])

    keep_index = filter_boxes(text_lines)
    text_lines = text_lines[keep_index]

    # nms for text lines
    if text_lines.shape[0] != 0:
        keep_inds = nms.cpu_nms(text_lines, TEXT_LINE_NMS_THRESH)
        text_lines = text_lines[keep_inds]

    rec = other.draw_boxes(im, text_lines)
    rec_file = open(os.path.join(img_dir,
                                 img_file.split('.')[0] + '.txt'), 'w')
    rec = rec.tolist()
    for box in rec:
        box = [str(pt) for pt in box]
        rec_file.write(','.join(box))
        rec_file.write('\n')
    def detect(self, im):
        """
        Detecting text boxes from an image
        :return: the bounding boxes of the detected texts
        """
        text_proposals, scores = self.text_proposal_detector.detect(
            im, cfg.MEAN)
        keep_inds = np.where(scores > cfg.TEXT_PROPOSALS_MIN_SCORE)[0]
        text_proposals = text_proposals[keep_inds]
        scores = scores[keep_inds]

        sorted_indices = np.argsort(scores.ravel())[::-1]
        text_proposals, scores = text_proposals[sorted_indices], scores[
            keep_inds]

        # nms for text propoasls
        keep_inds = nms(np.hstack((text_proposals, scores)),
                        cfg.TEXT_PROPOSALS_NMS_THRESH)
        text_proposals, scores = text_proposals[keep_inds], scores[keep_inds]

        # 得分归一化统一为[0,1]之间
        scores = normalize(scores)

        text_lines = self.text_proposal_connector.get_text_lines(
            text_proposals, scores, im.shape[:2])
        # text_lines:(x1, x2, y1, y2, score)

        # 筛选text boxes
        keep_inds = self.filter_boxes(text_lines)
        text_lines = text_lines[keep_inds]

        if text_lines.shape[0] != 0:
            keep_inds = nms(text_lines, cfg.TETEXT_LINE_NMS_THRESHXL)
            text_lines = text_lines[keep_inds]

        return text_lines
    def detect(self, im):
        """
        Detecting texts from an image
        :return: the bounding boxes of the detected texts
        """
        # import cv2
        # cv2.imshow('111', im)
        # cv2.waitKey(0)
        text_proposals, scores = self.text_proposal_detector.detect(
            im, cfg.MEAN)
        keep_inds = np.where(scores > cfg.TEXT_PROPOSALS_MIN_SCORE)[0]
        text_proposals, scores = text_proposals[keep_inds], scores[keep_inds]

        sorted_indices = np.argsort(scores.ravel())[::-1]
        text_proposals, scores = text_proposals[sorted_indices], scores[
            sorted_indices]

        # nms for text proposals
        keep_inds = nms(np.hstack((text_proposals, scores)),
                        cfg.TEXT_PROPOSALS_NMS_THRESH)
        text_proposals, scores = text_proposals[keep_inds], scores[keep_inds]

        scores = normalize(scores)

        text_lines = self.text_proposal_connector.get_text_lines_rotate(
            text_proposals, scores, im.shape[:2])

        keep_inds = self.filter_boxes(text_lines)
        text_lines = text_lines[keep_inds]

        # nms for text lines
        if text_lines.shape[0] != 0:
            keep_inds = nms(text_lines, cfg.TEXT_LINE_NMS_THRESH)
            text_lines = text_lines[keep_inds]

        return text_lines