package com.walker.openocr.table;
|
|
import com.walker.openocr.RecognizeResult;
|
import com.walker.openocr.TextBlock;
|
import com.walker.openocr.util.TableConfigUtils;
|
import com.walker.openocr.util.TableObjectUtils;
|
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.LinkedList;
|
import java.util.List;
|
import java.util.Map;
|
|
public class TableObject extends RecognizeResult<TableConfig> {
|
|
// protected final transient Logger logger = LoggerFactory.getLogger(this.getClass());
|
|
private TableConfig tableConfig = null;
|
|
// private Map<Integer, List<CellObject>> rowCache = new TreeMap<>();
|
|
// 其他还未排序的单元格集合，包含：需要的值以及无用的单元格
|
protected List<CellObject> otherCellObjectList = new ArrayList<>();
|
|
// 配置定义 与 文本快 对应关系，因为存在多个文本匹配同一个配置情况，所以需要再次比较最匹配的。
|
// 如：配置项（死亡伤残赔偿限额）
|
// “死亡伤残赔偿限额180000元” 和 “无责任死亡伤残赔偿限额18000元” 都匹配该项
|
private Map<String, CellObject> configItemBlockCache = new HashMap<>();
|
|
public TableObject(TableConfig tableConfig){
|
if(tableConfig == null){
|
throw new IllegalArgumentException("TableConfig is required!");
|
}
|
this.tableConfig = tableConfig;
|
}
|
|
@Override
|
public TableConfig getRecognizeConfig(){
|
if(this.tableConfig == null){
|
logger.error("TableConfig 不存在!");
|
return null;
|
}
|
return this.tableConfig;
|
}
|
|
/**
|
* 返回解析的表格数据结果，map中：
|
* key = 业务配置的ID，value = 单元格对象
|
* @return
|
* @date 2022-09-02
|
*/
|
public Map<String, CellObject> getTableDataMap(){
|
Map<String, CellObject> map = new HashMap<>();
|
if(this.rowCache.size() == 0){
|
return map;
|
}
|
for (List<CellObject> list : this.rowCache.values()){
|
for(CellObject co : list){
|
if(co.isConfigurable()){
|
map.put(co.getId(), co);
|
}
|
}
|
}
|
return map;
|
}
|
|
/**
|
* 计算标题对应的值。
|
*/
|
@Override
|
public void calculateValue(){
|
int cellSize = 0;
|
for(List<CellObject> rowData : this.rowCache.values()){
|
// 每行处理
|
cellSize = rowData.size();
|
CellObject current = null;
|
String cellValue = null;
|
for(int i=0; i<cellSize; i++){
|
current = rowData.get(i);
|
if(current.isConfigurable()){
|
|
if(current.isConfigNoneCell()){
|
// 不是连续单元格，只能根据内容拆分出来：标题和值
|
cellValue = TableObjectUtils.parseSplitTitleAndValue(current, true);
|
|
} else if (current.isConfigFullRow()) {
|
// 完整一行单元格
|
if(current.isConfigTwoLine()){
|
List<CellObject> nextLineCells = this.acquireTwoLineCellInfo(current);
|
cellValue = TableObjectUtils.parseFullRowTwoLineValue(rowData, current, nextLineCells);
|
} else if(current.isConfigSingleLine()){
|
cellValue = TableObjectUtils.parseFullRowTwoLineValue(rowData, current, null);
|
} else if(current.isConfigMoreLine()){
|
throw new UnsupportedOperationException("未实现完整行（多行文本）代码");
|
}
|
|
} else if(current.isConfigTwoLine()) {
|
// 普通单元格：确定两行
|
if(this.isExistValueCell(i, rowData)){
|
CellObject nextLineCell = this.acquireTwoLineCell(rowData.get(i+1));
|
if(nextLineCell != null){
|
logger.debug("找到第二行值:" + nextLineCell.getSource().getText());
|
cellValue = TableObjectUtils.parseCellTwoLineValue(rowData.get(i+1), nextLineCell, false);
|
}
|
} else {
|
// 未找到标题后面的值单元格，很可能由于不是同一行而忽略，此时需要从备选格中查找最近的行
|
CellObject nextLineCell = this.acquireTwoLineCell(rowData.get(i));
|
if(nextLineCell != null){
|
logger.debug("找到第二行值2:" + nextLineCell.getSource().getText());
|
cellValue = TableObjectUtils.parseCellTwoLineValue(nextLineCell, null, false);
|
}
|
}
|
|
} else if (current.isConfigSingleLine()) {
|
// 先解析看是否存在标题与值粘连的情况
|
cellValue = TableObjectUtils.parseSplitTitleAndValue(current, true);
|
if(cellValue == null){
|
// 普通单元格：单行
|
if(this.isExistValueCell(i, rowData)){
|
// 存在值单元格
|
cellValue = rowData.get(i+1).getSource().getText();
|
} else {
|
// 没有值单元格
|
cellValue = TableObjectUtils.parseSplitTitleAndValue(current, true);
|
}
|
}
|
|
} else {
|
throw new UnsupportedOperationException("未实现代码，不确定的单元格:" + current.getSource().getText());
|
}
|
current.setValue(cellValue);
|
}
|
}
|
}
|
}
|
|
private boolean isExistValueCell(int currentIndex, List<CellObject> rowData){
|
if(currentIndex + 1 < rowData.size()){
|
return true;
|
}
|
return false;
|
}
|
|
/**
|
* 获取两行单元格（值单元格）
|
* @param cellObject 给定的当前单元格，可以是：配置的标题格，也可以是已确定的第一行值单元格
|
* @return
|
*/
|
protected CellObject acquireTwoLineCell(CellObject cellObject){
|
// if(cellObject.isConfigurable()){
|
// throw new IllegalArgumentException("acquireTwoLineCell:不能是可配置单元格");
|
// }
|
return TableObjectUtils.findNextRowCell(cellObject
|
, this.otherCellObjectList, tableConfig.getMultiLineTolerance(), tableConfig.getCellTolerance());
|
}
|
|
protected List<CellObject> acquireTwoLineCellInfo(CellObject configurableCellObject){
|
if(!configurableCellObject.isConfigTwoLine()){
|
throw new IllegalArgumentException("acquireTwoLineCellInfo:单元格不是两行配置，无法调用该方法");
|
}
|
return TableObjectUtils.findNextRowInfo(configurableCellObject
|
, this.otherCellObjectList, tableConfig.getMultiLineTolerance(), tableConfig.getCellTolerance());
|
}
|
|
/**
|
* 添加完文本块后，排序，把相关行内容放在一起，并对每一行进行列排序。
|
*/
|
@Override
|
public void sortCellObjectList(){
|
CellObject target = null;
|
for(Iterator<CellObject> it = this.otherCellObjectList.iterator(); it.hasNext();){
|
// for(CellObject target : this.otherCellObjectList){
|
target = it.next();
|
List<CellObject> rowSet = null;
|
boolean sameRow = false;
|
for(Map.Entry<Integer, List<CellObject>> entry : this.rowCache.entrySet()){
|
rowSet = entry.getValue();
|
sameRow = TableObjectUtils.isInSameRow(rowSet.get(0), target, tableConfig.getCellTolerance());
|
if(sameRow){
|
logger.debug("找到匹配行:" + entry.getKey() + ", target=" + target.getSource().getText());
|
rowSet.add(target);
|
// 从other集合移除该单元格
|
it.remove();
|
// 退出该循环，从下一个目标元素继续执行
|
break;
|
}
|
}
|
}
|
|
// 每行对列排序
|
// int orderColumn = 0;
|
for(List<CellObject> list : this.rowCache.values()){
|
TableObjectUtils.sortColumnCellList(list);
|
}
|
}
|
|
@Override
|
public void addTextBlock(TextBlock textBlock){
|
CellObject cellObject = new CellObject();
|
cellObject.setSource(textBlock);
|
ConfigItem configItem = this.tableConfig.findConfigItem(textBlock.getText());
|
if(configItem != null){
|
if(configItem instanceof ColumnConfigItem){
|
throw new UnsupportedOperationException("未实现代码:ColumnConfigItem");
|
}
|
if(configItem instanceof CellConfigItem){
|
CellConfigItem cellConfigItem = (CellConfigItem) configItem;
|
cellObject.setCellConfigItem(cellConfigItem);
|
cellObject.setId(cellConfigItem.getId());
|
cellObject.setRowNum(cellConfigItem.getOrderNum());
|
}
|
this.putCellObjectToRowCache(cellObject, configItem);
|
|
} else {
|
cellObject.setId(this.generateCellId());
|
this.otherCellObjectList.add(cellObject);
|
}
|
}
|
|
private void putCellObjectToRowCache(CellObject cellObject, ConfigItem configItem){
|
CellObject textBlockExist = this.configItemBlockCache.get(configItem.getId());
|
if(textBlockExist == null){
|
this.configItemBlockCache.put(configItem.getId(), cellObject);
|
this.putOneRowCache(cellObject);
|
|
} else {
|
// 如果已经存在匹配配置项的文本块，说明有些文本也存在关键词，需要根据评分检查。
|
CellObject matchedCellObject = this.findMaxScoreCellObject(textBlockExist, cellObject, configItem);
|
this.configItemBlockCache.put(configItem.getId(), matchedCellObject);
|
this.putOneRowCache(matchedCellObject);
|
}
|
}
|
|
private CellObject findMaxScoreCellObject(CellObject textBlockExist, CellObject cellObject, ConfigItem configItem){
|
float existScore = TableConfigUtils.getSimpleSimilarScore(configItem.getName(), textBlockExist.getSource().getText());
|
float newScore = TableConfigUtils.getSimpleSimilarScore(configItem.getName(), cellObject.getSource().getText());
|
if(newScore > existScore){
|
logger.debug("新文本快更加匹配配置项:" + configItem.getName() + ", newScore=" + newScore + ", text=" + cellObject.getSource().getText());
|
return cellObject;
|
} else {
|
logger.debug("已有文本快更适合:" + configItem.getName() + ", existScore=" + existScore + ", text=" + textBlockExist.getSource().getText());
|
return textBlockExist;
|
}
|
}
|
|
private void putOneRowCache(CellObject cellObject){
|
List<CellObject> list = this.rowCache.get(cellObject.getRowNum());
|
if(list == null){
|
list = new LinkedList<>();
|
this.rowCache.put(cellObject.getRowNum(), list);
|
}
|
if(!list.contains(cellObject)){
|
list.add(cellObject);
|
}
|
}
|
|
private String generateCellId(){
|
return String.valueOf(System.nanoTime());
|
}
|
|
@Override
|
public void printRowCache(){
|
// List<CellObject> data = null;
|
// for(Map.Entry<Integer, List<CellObject>> entry : this.rowCache.entrySet()){
|
// logger.debug("第 " + entry.getKey() + " 行 ==========================================");
|
// data = entry.getValue();
|
// if(data != null){
|
// for(CellObject co : data){
|
// logger.debug(co.toString());
|
// }
|
// }
|
// }
|
super.printRowCache();
|
logger.debug("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
|
for(CellObject other : this.otherCellObjectList){
|
logger.debug(other.toString());
|
}
|
}
|
}
|
