|
|
|
|
|
import argparse |
|
|
import os |
|
|
import torch |
|
|
import cv2 |
|
|
import numpy as np |
|
|
from experiment import Structure, Experiment |
|
|
from concern.config import Configurable, Config |
|
|
import math |
|
|
|
|
|
def main(): |
|
|
parser = argparse.ArgumentParser(description='Text Recognition Training') |
|
|
parser.add_argument('exp', type=str) |
|
|
parser.add_argument('--resume', type=str, help='Resume from checkpoint') |
|
|
parser.add_argument('--image_path', type=str, help='image path') |
|
|
parser.add_argument('--result_dir', type=str, default='./demo_results/', help='path to save results') |
|
|
parser.add_argument('--data', type=str, |
|
|
help='The name of dataloader which will be evaluated on.') |
|
|
parser.add_argument('--image_short_side', type=int, default=736, |
|
|
help='The threshold to replace it in the representers') |
|
|
parser.add_argument('--thresh', type=float, |
|
|
help='The threshold to replace it in the representers') |
|
|
parser.add_argument('--box_thresh', type=float, default=0.6, |
|
|
help='The threshold to replace it in the representers') |
|
|
parser.add_argument('--visualize', action='store_true', |
|
|
help='visualize maps in tensorboard') |
|
|
parser.add_argument('--resize', action='store_true', |
|
|
help='resize') |
|
|
parser.add_argument('--polygon', action='store_true', |
|
|
help='output polygons if true') |
|
|
parser.add_argument('--eager', '--eager_show', action='store_true', dest='eager_show', |
|
|
help='Show iamges eagerly') |
|
|
|
|
|
args = parser.parse_args() |
|
|
args = vars(args) |
|
|
args = {k: v for k, v in args.items() if v is not None} |
|
|
|
|
|
conf = Config() |
|
|
experiment_args = conf.compile(conf.load(args['exp']))['Experiment'] |
|
|
experiment_args.update(cmd=args) |
|
|
experiment = Configurable.construct_class_from_config(experiment_args) |
|
|
|
|
|
Demo(experiment, experiment_args, cmd=args).inference(args['image_path'], args['visualize']) |
|
|
|
|
|
|
|
|
class Demo: |
|
|
def __init__(self, experiment, args, cmd=dict()): |
|
|
self.RGB_MEAN = np.array([122.67891434, 116.66876762, 104.00698793]) |
|
|
self.experiment = experiment |
|
|
experiment.load('evaluation', **args) |
|
|
self.args = cmd |
|
|
model_saver = experiment.train.model_saver |
|
|
self.structure = experiment.structure |
|
|
self.model_path = self.args['resume'] |
|
|
|
|
|
def init_torch_tensor(self): |
|
|
|
|
|
torch.set_default_tensor_type('torch.FloatTensor') |
|
|
if torch.cuda.is_available(): |
|
|
self.device = torch.device('cuda') |
|
|
torch.set_default_tensor_type('torch.cuda.FloatTensor') |
|
|
else: |
|
|
self.device = torch.device('cpu') |
|
|
|
|
|
def init_model(self): |
|
|
model = self.structure.builder.build(self.device) |
|
|
return model |
|
|
|
|
|
def resume(self, model, path): |
|
|
if not os.path.exists(path): |
|
|
print("Checkpoint not found: " + path) |
|
|
return |
|
|
print("Resuming from " + path) |
|
|
states = torch.load( |
|
|
path, map_location=self.device) |
|
|
model.load_state_dict(states, strict=False) |
|
|
print("Resumed from " + path) |
|
|
|
|
|
def resize_image(self, img): |
|
|
height, width, _ = img.shape |
|
|
if height < width: |
|
|
new_height = self.args['image_short_side'] |
|
|
new_width = int(math.ceil(new_height / height * width / 32) * 32) |
|
|
else: |
|
|
new_width = self.args['image_short_side'] |
|
|
new_height = int(math.ceil(new_width / width * height / 32) * 32) |
|
|
resized_img = cv2.resize(img, (new_width, new_height)) |
|
|
return resized_img |
|
|
|
|
|
def load_image(self, image_path): |
|
|
img = cv2.imread(image_path, cv2.IMREAD_COLOR).astype('float32') |
|
|
original_shape = img.shape[:2] |
|
|
img = self.resize_image(img) |
|
|
img -= self.RGB_MEAN |
|
|
img /= 255. |
|
|
img = torch.from_numpy(img).permute(2, 0, 1).float().unsqueeze(0) |
|
|
return img, original_shape |
|
|
|
|
|
def format_output(self, batch, output): |
|
|
batch_boxes, batch_scores = output |
|
|
for index in range(batch['image'].size(0)): |
|
|
original_shape = batch['shape'][index] |
|
|
filename = batch['filename'][index] |
|
|
result_file_name = 'res_' + filename.split('/')[-1].split('.')[0] + '.txt' |
|
|
result_file_path = os.path.join(self.args['result_dir'], result_file_name) |
|
|
boxes = batch_boxes[index] |
|
|
scores = batch_scores[index] |
|
|
if self.args['polygon']: |
|
|
with open(result_file_path, 'wt') as res: |
|
|
for i, box in enumerate(boxes): |
|
|
box = np.array(box).reshape(-1).tolist() |
|
|
result = ",".join([str(int(x)) for x in box]) |
|
|
score = scores[i] |
|
|
res.write(result + ',' + str(score) + "\n") |
|
|
else: |
|
|
with open(result_file_path, 'wt') as res: |
|
|
for i in range(boxes.shape[0]): |
|
|
score = scores[i] |
|
|
if score < self.args['box_thresh']: |
|
|
continue |
|
|
box = boxes[i,:,:].reshape(-1).tolist() |
|
|
result = ",".join([str(int(x)) for x in box]) |
|
|
res.write(result + ',' + str(score) + "\n") |
|
|
|
|
|
def inference(self, image_path, visualize=False): |
|
|
self.init_torch_tensor() |
|
|
model = self.init_model() |
|
|
self.resume(model, self.model_path) |
|
|
all_matircs = {} |
|
|
model.eval() |
|
|
batch = dict() |
|
|
batch['filename'] = [image_path] |
|
|
img, original_shape = self.load_image(image_path) |
|
|
batch['shape'] = [original_shape] |
|
|
with torch.no_grad(): |
|
|
batch['image'] = img |
|
|
pred = model.forward(batch, training=False) |
|
|
output = self.structure.representer.represent(batch, pred, is_output_polygon=self.args['polygon']) |
|
|
if not os.path.isdir(self.args['result_dir']): |
|
|
os.mkdir(self.args['result_dir']) |
|
|
self.format_output(batch, output) |
|
|
|
|
|
if visualize and self.structure.visualizer: |
|
|
vis_image = self.structure.visualizer.demo_visualize(image_path, output) |
|
|
cv2.imwrite(os.path.join(self.args['result_dir'], image_path.split('/')[-1].split('.')[0]+'.jpg'), vis_image) |
|
|
|
|
|
if __name__ == '__main__': |
|
|
main() |
|
|
|
