def main():
dataDir = sys.argv[1]
dataType = "train2014"
plt.switch_backend("TkAgg")
pylab.rcParams['figure.figsize'] = (15.0, 10.0)
ct = coco_text.COCO_Text(sys.argv[2])
ct.info()
# get all images containing at least one instance of legible text
imgIds = ct.getImgIds(imgIds=ct.train, catIds=[('legibility', 'legible')])
while True:
# pick one at random
img = ct.loadImgs(imgIds[np.random.randint(0, len(imgIds))])[0]
I = io.imread('%s/images/%s/%s' %
(dataDir, dataType, img['file_name']))
print '/images/%s/%s' % (dataType, img['file_name'])
plt.figure()
annIds = ct.getAnnIds(imgIds=img['id'])
anns = ct.loadAnns(annIds)
ct.showAnns(anns)
plt.imshow(I)
plt.show()
def __init__(self, ann_path, dataDir):
super(ImageDataset, self).__init__()
# link annotation
self.ct = coco_text.COCO_Text(ann_path)
# save the path to picture data
self.dataDir = dataDir
self.add_class("cocotext", 1, "text")
imgIds = self.ct.getImgIds(imgIds=self.ct.train,
catIds=[('legibility', 'legible')])
for imgId in imgIds:
image_array = self.ct.loadImgs(imgId)[0]
# '%s/%s'%(self.dataDir,img['file_name']) is to get the file path
self.add_image("cocotext",
image_id=imgId,
path=self.dataDir + "/" + image_array['file_name'],
height=image_array["height"],
width=image_array["width"])
def ablate(imgIds=[],
mode='destroy',
out_path="tmp",
coco=coco,
ct=None,
**args):
"""[ablation entry point 2.0]
Created to accomodate background-destroying ablation. Will dispatch all
old ablations (gaussian, blackout, & median) to gen_ablation."""
if ct is None:
ct = coco_text.COCO_Text(os.path.join(CD, 'COCO_Text.json'))
if imgIds == []:
imgIds = ct.getImgIds(imgIds=ct.train,
catIds=[('legibility', 'legible')])
imgIds = [imgIds[np.random.randint(0, len(imgIds))]]
#dispatch to old ablation entry point
if mode in ['gaussian', 'blackout', 'median']:
return gen_ablation(imgIds, mode, ct, out_path=out_path, **args)
#else do destroy_bg
if coco is None:
coco = COCO('%s/annotations/instances_%s.json' %
(DATA_PATH, DATA_TYPE))
imgs = coco.loadImgs(imgIds)
results = []
for idx, img in enumerate(imgs):
print("Ablating image {}/{} with id {} ".format(
idx + 1, len(imgIds), img['id']))
ori_file_name = os.path.join(CD, DATA_PATH, DATA_TYPE,
img['file_name'])
orig = io.imread(ori_file_name)
if mode == 'destroy':
ablt = destroy_bg(orig, img['id'], coco, **args)
elif mode == 'median_bg':
ablt = median_bg(orig, img['id'], coco, **args)
out_file_name = os.path.join(CD, "..", out_path,
"%s_%s" % (mode, img['file_name']))
io.imsave(out_file_name, ablt)
results.append((img['id'], ori_file_name, out_file_name))
return results
def main():
global id2word
global lda_model
global num_topics
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
# Initialize tensorflow params.
tensorflow_init()
# Write the results in the .txt file.
f = open('results_50.txt', 'w')
# First, read the dictionary and make a dictionary.
id2word = gensim.corpora.Dictionary.load_from_text(
'/home/avinash/Desktop/SMAI/DynamicLexiconGenerationCVC/DynamicLexiconGeneration/train_gensim_dict.txt'
)
# Specify the number of topics present in the LDA_model.
num_topics = 50
# Initiate COCO-Text API instance.
coco_txt = coco_text.COCO_Text(
'/home/avinash/Desktop/SMAI/DynamicLexiconGenerationCVC/DynamicLexiconGeneration/Dataset/COCO_Text.json'
)
im_ids_txt = coco_txt.getImgIds(imgIds=coco_txt.train)
# Image base_url.
base_url_image = '/home/avinash/Desktop/SMAI/images/train2014/'
# Parse the dictionary and Pre-process.
iterator = id2word.iteritems()
keys = id2word.keys()
dict_natural = {}
for i in range(0, len(keys)):
temp_item = iterator.next()
try:
dict_natural[str(temp_item[1]).lower()] = []
except:
pass
# Now, read the LDA model built on Natural dictionary.
lda_model = gensim.models.ldamodel.LdaModel.load(
'/home/avinash/Desktop/SMAI/DynamicLexiconGenerationCVC/DynamicLexiconGeneration/lda_model_50.lda',
mmap='r')
# Read, all the Validation set captions.
# Combine each of them and make a document
# Project the document on the LDA model.
# Please verify with the CNN validation labels.
# NOTE :The validation set of CNN is used here as
# Evaluation set for word-ranking.
eval_file = open(
'/home/avinash/Desktop/SMAI/DynamicLexiconGenerationCVC/DynamicLexiconGeneration/dataset_corpus_train.json',
'r')
eval_json = json.load(eval_file)
# Get all the topics only once.
# YOU FETCH ONLY ONCE B-).
# I'm bond! James Bond B-).
# Iterate over each instance of eval set.
counter_image = 0
counter_word_instance = 0
for ind in im_ids_txt:
# Keep printing the counter values.
counter_image += 1
if counter_image == 5000:
break
#print ("Total 20K : " + str(counter_image))
words_present = []
try:
value = eval_json[str(ind)]
except:
continue
captions = value['caption']
url = value['url']
final_url = base_url_image + str(url)
ann_ids_txt = coco_txt.getAnnIds(imgIds=ind)
ann_txt = coco_txt.loadAnns(ann_ids_txt)
for j in ann_txt:
try:
if j['utf8_string'] != '':
counter_word_instance += 1
words_present.append(j['utf8_string'])
except KeyError:
pass
if not words_present:
pass
else:
# For a given image now we have prob distribution
# and words_present in the image. Now, we need to
# make all ranked dictionary and make inference
# for each and everyword.
# REST ALL THE SHIT GOES HERE.
try:
query_out = make_query(final_url)
except:
continue
for topic in query_out:
topic_words = [
x for x in lda_model.show_topic(
topic[0], topn=len(dict_natural.keys()))
]
for word in topic_words:
try:
p_topic = topic[1]
p_word = word[1]
p_final = p_topic * p_word
dict_natural[str(word[0])].append(p_final)
except:
pass
# Choose the highest values for each of the words.
topic_word_ranks = []
for j in dict_natural.keys():
try:
topic_word_ranks.append(
(str(j), sum(dict_natural[str(j)])))
except:
pass
# Sort the dictionary and make final ranking prediction.
final_ranking = sorted(topic_word_ranks,
key=lambda x: x[1],
reverse=True)
final_ranks = []
for i in final_ranking:
final_ranks.append(i[0].lower())
text_ranks = []
for text in words_present:
try:
text_ranks.append(
str(text) + " : " +
str(final_ranks.index(str(text.lower()))))
except ValueError:
try:
text_ranks.append(str(text) + " : NA")
except:
text_ranks.append("Unicode error")
f.write(str(text_ranks) + "\n")
f.write("Image url : " + str(url) + "\n")
f.write("Total words : " + str(len(final_ranks)) + "\n")
f.write("---------------------------------------\n")
print(str(text_ranks))
print("Image url : " + str(url) + "\n")
print("Total words : " + str(len(final_ranks)))
print("---------------------------------------")
# At the end make sure to make each word probs zero.
# For next iteration.
for i in dict_natural.keys():
dict_natural[i] = []
print("counter_word_instances : " + str(counter_word_instance))
f.close()
import os
import sys
ROOT_DIR = os.getcwd()
#ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
COCO_DIR = os.path.join(ROOT_DIR, 'COCO')
TEXT_DIR = os.path.join(COCO_DIR, 'coco-text')
sys.path.append(COCO_DIR)
sys.path.append(TEXT_DIR)
from ctpn_crnn_pytorch import *
import coco_text
ct = coco_text.COCO_Text(os.path.join(TEXT_DIR, 'COCO_Text.json'))
imgs_val = ct.val
imgs_all = ct.imgs.keys()
dataType = 'val'
imgs_used = imgs_val
def make_result_dic(utf8_string, image_id, bbox):
result = {"utf8_string": utf8_string, "image_id": image_id, "bbox": bbox}
return result
def infer_on_coco():
total_results = []
for i, img_id in enumerate(imgs_used):
def __init__(self):
self.ct = coco_text.COCO_Text("../dataset/annotation/COCO_Text.json")
print(self.ct.info())
win_unicode_console.enable()
import os
import sys
import numpy as np
import cv2
ROOT_DIR = os.getcwd()
#ROOT_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.append(os.path.join(ROOT_DIR, 'coco-text'))
sys.path.append(os.path.join(ROOT_DIR, 'train2014'))
sys.path.append(os.path.join(ROOT_DIR, 'test2014'))
sys.path.append(os.path.join(ROOT_DIR, 'val2014'))
import coco_text
ct = coco_text.COCO_Text('coco-text/COCO_Text.json')
imgs_train = ct.getImgIds(imgIds=ct.train,
catIds=[('legibility', 'legible'),
('language', 'english')])
imgs_val = ct.getImgIds(imgIds=ct.val,
catIds=[('legibility', 'legible'),
('language', 'english')])
imgs_test = ct.getImgIds(imgIds=ct.test,
catIds=[('legibility', 'legible'),
('language', 'english')])
def make_for_crnn(imgIds, dataType):
csv_out = 'COCO_Text_' + dataType + '.csv'
print('CSV opened', csv_out)
from pascal_voc_writer import Writer
import sys
sys.path.append('/media/weihao/DISK0/Object_detection/COCO/coco-text-master')
import coco_text
def has_digits(s):
for a in range(len(s)):
if s[a].isnumeric():
return True
return False
string_tag = 'utf8_string'
ct = coco_text.COCO_Text('/media/weihao/DISK0/Object_detection/COCO/COCO_Text.json')
ct.info()
# imgs = ct.getImgIds(imgIds=ct.train,
# catIds=[('legibility','legible'),('class','machine printed')])
# anns = ct.getAnnIds(imgIds=ct.val,
# catIds=[('legibility','legible'),('class','machine printed')],
# areaRng=[1000,200000])
dataDir='/home/weihao/Downloads'
dataType='train2017'
output_dir = '/home/weihao/tmp/data/'
if output_dir is not None:
if os.path.exists(output_dir):
shutil.rmtree(output_dir)
os.mkdir(output_dir)
import coco_text
import os, json, sys
import coco_evaluation
ct = coco_text.COCO_Text('../COCO_Text.json')
test_path = sys.argv[1]
dataDir = '../train2014'
dataType = 'train2014'
test = []
print "test path: {}".format(test_path)
imgIds = []
for txt in os.listdir(test_path):
if 'txt' in txt:
im_id = int(txt.split('_')[-1].replace('.txt', ''))
with open(os.path.join(test_path, txt)) as f:
content = f.readlines()
imgIds.append(im_id)
for line in content:
line = map(int, line.split(',')[:8])
x_axis = [line[0], line[2], line[4], line[6]]
y_axis = [line[1], line[3], line[5], line[7]]
x_coord = min(x_axis)
y_coord = min(y_axis)
width = max(x_axis) - min(x_axis)
height = max(y_axis) - min(y_axis)
test.append({
"image_id": im_id,
"bbox": [x_coord, y_coord, width, height]
})
print len(test)
os.system('touch results.json')
#--------------rectify the file_name of the imgs in 'val'--------
# import coco_text
# ct = coco_text.COCO_Text(gtJson)
# imgIds = ct.getImgIds(imgIds = ct.val)
# ct.changeImgNames(imgIds)
# import json
# with open(gtJsonNew, 'w') as jsonFile:
# json.dump(ct.dataset, jsonFile)
# print 'ok!'
#-------------create the new dir for the coco-text image ------------
import coco_text
import os
import shutil
ct = coco_text.COCO_Text(gtJson)
imgIdVal = ct.getImgIds(imgIds=ct.val)
if not os.path.exists(imgDestValDir):
os.mkdir(imgDestValDir)
for num, eachId in enumerate(imgIdVal):
imgName = ct.imgs[eachId]['file_name']
sourceDir = '{}/{}'.format(imgSourceDir, imgName)
targetDir = '{}/{}'.format(imgDestValDir, imgName)
shutil.copy(sourceDir, targetDir)
if not (num % 500):
print num
imgIdTrain = ct.getImgIds(imgIds=ct.train)
if not os.path.exists(imgDestTrainDir):
os.mkdir(imgDestTrainDir)
for num, eachId in enumerate(imgIdTrain):
import numpy as np
import skimage.io as io
import matplotlib.pyplot as plt
import pylab as pl
import pylab
from matplotlib.pyplot import *
import cv2
import sys
from PIL import Image
if __name__ == '__main__':
for loop in range(0, 2): # loop and pick random pictures
#API offers some basic infos of the dataset.
ct = coco_text.COCO_Text('/COCO_Data_set/COCO_Text.json')
ct.info()
#Select annotations and images based on filter criteria
# get all images containing at least one instance of legible text
#retrieve some images. We want to get a list of all image ids from the training set,
#where the image contains at least one text instance that is legilbe and is machine printed.
imgs = ct.getImgIds(imgIds=ct.train,
catIds=[('legibility', 'legible'),
('class', 'machine printed')])
#all annotation ids from the validation set that are legible, machine printed
#and have an area between 0 and 200 pixels.
anns = ct.getAnnIds(imgIds=ct.val,
catIds=[('legibility', 'legible'),
import coco_text
import json
ct = coco_text.COCO_Text('COCO_Text.json')
ct.info()
# Some image retreival...To get a list of all those image ids from training set where at least one text instance is there, i.e, all legible images and are machine printed
imgs = ct.getImgIds(imgIds=ct.train,
catIds=[('legibility', 'legible'),
('class', 'machine printed')])
# imgs = ct.getImgIds(imgIds=ct.val, catIds=[('legibility','legible'), ('class','machine printed')])
# imgs = ct.getImgIds(imgIds=ct.train, catIds=[('legibility','legible')])
# imgs = ct.getImgIds(imgIds=ct.train)
# imgs = ct.getImgIds(imgIds=ct.val)
# imgs = ct.getImgIds(imgIds=ct.test)
print(type(imgs))
print(imgs)
print(len(imgs))
# Annotation Ids retreival form the validation set that are legible, machine printed and have an area between 0 and 200 pixel
anns = ct.getAnnIds(imgIds=ct.val,
catIds=[('legibility', 'legible'),
('class', 'machine printed')],
areaRng=[0, 200])
# anns = ct.getAnnIds(imgIds=ct.train, catIds=[('legibility','legible'),('class','machine printed')], areaRng=[0,200])
# anns = ct.getAnnIds(imgIds=ct.train, catIds=[('legibility','legible'),('class','machine printed')])
# print(type(anns))
# print(anns)
# print(len(anns))
for img_path in tqdm(img_paths):
raw_pred, text = recognition.recognize_cropped(Image.open(img_path))
file_num = img_path.split('/')[-1].split('.')[0]
result = '{},{}'.format(file_num, text)
print(result, file=task2_f)
task2_f.close()
def force_mkdirs(path):
if os.path.exists(path):
shutil.rmtree(path)
os.makedirs(path)
ct = coco_text.COCO_Text(COCO_DATA + 'COCO_Text.json')
#force_mkdirs(TASK1_PATH)
#force_mkdirs(TASK3_PATH)
thresholds = [0.6, 0.0]
for threshold in thresholds:
path = str(int(threshold * 100)) + VAL_RESULT
print(
'Preparing validation results for Task 1 at {}\n Task 3 at {}'.format(
TASK1_PATH + path, TASK3_PATH + path))
force_mkdirs(TASK1_PATH + path)
force_mkdirs(TASK3_PATH + path)
valid_img_ids = ct.getImgIds(imgIds=ct.val)
valid_imgs = ct.loadImgs(valid_img_ids)
coco_competition_result(valid_imgs, INPUT_PATH, TASK1_PATH + path,
import coco_text
from nltk.corpus import stopwords
import json
# This script is to make dictionary from all the
# words in the dataset. Thus this include both
# training and validation images from COCO-Text.
dataset_dictionary_all = []
stop_words = set(stopwords.words('english'))
stop_words_str = [str(i).lower() for i in stop_words]
stop_words_post_space = [str(i) + " " for i in stop_words_str]
stop_words_pre_space = [" " + str(i) for i in stop_words_str]
print str(stop_words_str)
cntr = 0
coco_txt = coco_text.COCO_Text('/home/avinash/Desktop/SMAI/DynamicLexiconGenerationCVC/DynamicLexiconGeneration/Dataset/COCO_Text.json')
# First make on Training set.
im_ids_train = coco_txt.getImgIds(imgIds=coco_txt.train) # I think it should be coco_txt.train not coco_txt.val.. Modifying it
#im_ids_train = coco_txt.getImgIds(imgIds=coco_txt.val)
for i in im_ids_train:
ann_ids_txt = coco_txt.getAnnIds(imgIds = i)
ann_txt = coco_txt.loadAnns(ann_ids_txt)
for j in ann_txt:
try:
if j['utf8_string'] != '':
try:
given_word = str(j['utf8_string']).lower()
if ((given_word not in dataset_dictionary_all) and (given_word not in stop_words_str) and (given_word not in stop_words_post_space) and (given_word not in stop_words_pre_space)):
cntr += 1
dataset_dictionary_all.append(given_word)
INPUT_PATH = os.path.join(FD, 'input')
INPUT_FILE = 'test.pkl' # contains imgIds to compute the score for
OUTPUT_PATH = os.path.join(FD, 'output')
IMG_PATH = os.path.join(FD, 'data', 'coco')
IMG_TYPE = 'train2014' # input directory to sample from
CAPTION_PATH = os.path.join(FD, 'neuraltalk2') # captioning code folder
MODEL_PATH = os.path.join(FD, 'model', 'neuraltalk2',
'model_id1-501-1448236541.t7')
COCO_PATH = os.path.join(FD, 'data', 'coco')
COCO_ANNO_PATH = os.path.join(COCO_PATH, 'annotations')
COCO_TEXT_PATH = os.path.join(FD, 'coco-text')
sys.path.insert(0, COCO_TEXT_PATH)
import coco_text as ct
ct = ct.COCO_Text(os.path.join(COCO_TEXT_PATH, 'COCO_Text.json'))
sys.path.insert(0, os.path.join(FD, 'coco', 'PythonAPI'))
from pycocotools.coco import COCO
coco = ablation.coco
def run(amode='gaussian',
input_file=INPUT_FILE,
output_file=INPUT_FILE,
batch_size=1,
category=''):
# Clean up the previous results.
print("Cleaning up")
abs_tmp_dir = os.path.join(FD, "tmp_%s" % output_file)
def format_coco_text():
print 'format coco_text dataset: 80percent training, 10percent valing, 10percent testing'
# read annotations
# in : annotate_id imagename bbox(xmin,ymin,w,h);
# out: imgprefix label(text) bbox1(xmin,ymin,xmax,ymax)
# imgprefix label(text) bbox2
# import the annotations of coco-text
if not os.path.exists('train2014'):
print 'train2014/ not found, please unzipping'
return -1
if not os.path.exists('COCO_Text.json'):
print 'COCO_Text.json not found, please unzipping'
return -1
train_file = open('formatted_dataset/ImageSets/Main/train.txt', 'w')
trainval_file = open('formatted_dataset/ImageSets/Main/trainval.txt', 'w')
test_file = open('formatted_dataset/ImageSets/Main/test.txt', 'w')
val_file = open('formatted_dataset/ImageSets/Main/val.txt', 'w')
annotation_in = coco_text.COCO_Text('COCO_Text.json')
annotation_out = open('formatted_dataset/images.annotations', 'w')
# select training image
ann_ids = annotation_in.getAnnIds(imgIds=annotation_in.train,
catIds=[('legibility', 'legible'),
('class', 'machine printed')])
print 'train annotations:' + str(len(ann_ids))
anns = annotation_in.loadAnns(ann_ids)
imgid_set = set()
for ann in anns:
im_id_str = str(ann['image_id'])
imgprefix = im_id_str
for i in xrange(0, 12 - len(im_id_str)):
imgprefix = '0' + imgprefix
imgprefix = 'COCO_train2014_' + imgprefix
img_name = imgprefix + '.jpg'
# images.annotations
bbox = ann['bbox']
xmin = int(round(bbox[0]))
ymin = int(round(bbox[1]))
xmax = int(round(bbox[0] + bbox[2]))
ymax = int(round(bbox[1] + bbox[3]))
annotation_out.write(img_name + ' text ' + str(xmin) + ' ' +
str(ymin) + ' ' + str(xmax) + ' ' + str(ymax) +
'\n')
if not ann['image_id'] in imgid_set:
# ImageSets train
train_file.write(imgprefix + '\n')
trainval_file.write(imgprefix + '\n')
# JPEGImages train
if not os.path.isfile('formatted_dataset/JPEGImages/' + img_name):
os.system('mv train2014/' + img_name +
' formatted_dataset/JPEGImages')
imgid_set.add(ann['image_id'])
# select valing and testing image
ann_ids = annotation_in.getAnnIds(imgIds=annotation_in.val,
catIds=[('legibility', 'legible'),
('class', 'machine printed')])
print 'val annotations:' + str(len(ann_ids))
anns = annotation_in.loadAnns(ann_ids)
imgid_set = set()
cnt = 0
for ann in anns:
cnt += 1
im_id_str = str(ann['image_id'])
imgprefix = im_id_str
for i in xrange(0, 12 - len(im_id_str)):
imgprefix = '0' + imgprefix
imgprefix = 'COCO_train2014_' + imgprefix
img_name = imgprefix + '.jpg'
# images.annotations
bbox = ann['bbox']
xmin = int(round(bbox[0]))
ymin = int(round(bbox[1]))
xmax = int(round(bbox[0] + bbox[2]))
ymax = int(round(bbox[1] + bbox[3]))
annotation_out.write(img_name + ' text ' + str(xmin) + ' ' +
str(ymin) + ' ' + str(xmax) + ' ' + str(ymax) +
'\n')
if not ann['image_id'] in imgid_set:
# ImageSets train or test
if cnt % 4 == 1:
test_file.write(imgprefix + '\n')
else:
val_file.write(imgprefix + '\n')
trainval_file.write(imgprefix + '\n')
# JPEGImages val or test
if not os.path.isfile('formatted_dataset/JPEGImages/' + img_name):
os.system('mv train2014/' + img_name +
' formatted_dataset/JPEGImages')
imgid_set.add(ann['image_id'])
def whole_split(opt):
imgCls = [ct.train, ct.val, ct.test]
split_div = ["train", "val", "test"]
# Load COCO_Text.json here
ct = coco_text.COCO_Text(opt.COCO_path)
sp = 0
for i in imgCls:
now_path = os.getcwd()
ann_path = now_path + "/" + split_div[sp] + "_anns"
set_path = now_path + "/coco_" + split_div[sp]
# Start creating new folders to save annotations and images
try:
os.mkdir(ann_path)
except OSError:
print("Creation of the directory %s failed" % ann_path)
else:
print("Successfully created the directory %s " % ann_path)
try:
os.mkdir(set_path)
except OSError:
print("Creation of the directory %s failed" % set_path)
else:
print("Successfully created the directory %s " % set_path)
# Load image ids for different set here
imgs = ct.getImgIds(imgIds=i)
anns = ct.getAnnIds(imgIds=i)
cnt = 0
total_img_num = len(imgs)
for j in imgs:
ind = 0
img_info = {}
ind_info = {}
img = ct.loadImgs(j)[0]
fName = img['file_name']
iId = img['id']
img_info["img_id"] = iId
img_info["file_name"] = fName
# remember to extract width, height
#img_info["width"]=img['width']
#img_info["height"]=img['height']
already_saved_this_img = False
have_text = False
for k in anns:
ann = ct.loadAnns(k)[0]
if (ann["image_id"] == iId):
aBbox = ann["bbox"]
img_info["bbox"] = aBbox
if "utf8_string" in ann:
have_text = True
aTran = ann["utf8_string"]
img_info["transcription"] = aTran
ind_info[ind] = img_info
ind += 1
if (not already_saved_this_img):
trg_path = set_path + "/"
src_path = opt.img_path + fName
try:
copy(src_path, trg_path)
except IOError as e:
print("Unable to copy file. %s" % fName)
except:
print("Unexpected error:", sys.exc_info())
cnt += 1
already_saved_this_img = True
if have_text:
savepath = ann_path + "/" + fName[:-3] + "json"
saveAnn = open(savepath, "w")
json.dump(ind_info, saveAnn)
saveAnn.close()
sp += 1
if cnt == total_img_num: output = "Copying Finished Successfully!"
elif cnt == 0: output = "No one get copied."
else:
output = "Copying Finished Successfully! But some images are not copied."
def yolo_split(opt):
# Load COCO_Text.json here
ct = coco_text.COCO_Text(opt.COCO_path)
imgCls = [ct.val, ct.test, ct.train]
split_div = ["valid", "test", "train"]
now_path = os.getcwd()
cls_path = now_path + "/classes.names"
clspath = open(cls_path, "w")
classes = []
cls_dict = {}
cls_num = 0
sp = 0
for i in imgCls:
ann_path = now_path + "/labels/" + split_div[sp]
set_path = now_path + "/images/" + split_div[sp]
lst_path = now_path + "/" + split_div[sp] + ".txt"
# Start creating new folders to save annotations and images
try:
os.mkdir(ann_path)
except OSError:
print("Creation of the directory %s failed" % ann_path)
else:
print("Successfully created the directory %s " % ann_path)
try:
os.mkdir(set_path)
except OSError:
print("Creation of the directory %s failed" % set_path)
else:
print("Successfully created the directory %s " % set_path)
# Load image ids for different set here
imgs = ct.getImgIds(imgIds=i)
anns = ct.getAnnIds(imgIds=i)
# count how many images do we select
cnt = 0
total_img_num = len(imgs)
lstpath = open(lst_path, "a")
for j in imgs:
# get image's description
img = ct.loadImgs(j)[0]
iId = img['id']
fName = img['file_name']
# save annotation for each image
savepath = ann_path + "/" + fName[:-3] + "txt"
# remember to extract width, height
iWidth = img['width']
iHeight = img['height']
already_saved_this_img = False
"""
# this is for test set
lstpath.write(set_path+"/"+fName+"\n")
trg_path = set_path+"/"
src_path = opt.img_path+fName
try:
copy(src_path, trg_path)
except IOError as e:
print("Unable to copy file. %s" % fName)
except:
print("Unexpected error:", sys.exc_info())
"""
for k in anns:
# get ann's description
ann = ct.loadAnns(k)[0]
if (ann["image_id"] == iId):
aBbox = ann["bbox"]
if "utf8_string" in ann:
aTran = ann["utf8_string"].strip()
saveAnn = open(savepath, "a")
# start write
if aTran not in classes:
classes.append(aTran)
clspath.write(aTran + "\n")
cls_dict[cls_num] = aTran
#max_val = 640
#saveAnn.write(str(cls_num)+" "+str(aBbox[0]/max_val)+" "+str(aBbox[1]/max_val)+" "+str(aBbox[2]/max_val)+" "+str(aBbox[3]/max_val)+"\n")
saveAnn.write(
str(cls_num) + " " + str(aBbox[0] / iWidth) +
" " + str(aBbox[1] / iHeight) + " " +
str(aBbox[2] / iWidth) + " " +
str(aBbox[3] / iHeight) + "\n")
if cls_num <= 0 and cls_num > 26239: print(cls_num)
cls_num += 1
else:
cls_key = get_key(aTran, cls_dict)
#saveAnn.write(str(cls_num)+" "+str(aBbox[0]/max_val)+" "+str(aBbox[1]/max_val)+" "+str(aBbox[2]/max_val)+" "+str(aBbox[3]/max_val)+"\n")
saveAnn.write(
str(cls_key) + " " + str(aBbox[0] / iWidth) +
" " + str(aBbox[1] / iHeight) + " " +
str(aBbox[2] / iWidth) + " " +
str(aBbox[3] / iHeight) + "\n")
saveAnn.close()
if (not already_saved_this_img):
#save image directory and name for different division
lstpath.write(set_path + "/" + fName + "\n")
trg_path = set_path + "/"
src_path = opt.img_path + fName
try:
copy(src_path, trg_path)
except IOError as e:
print("Unable to copy file. %s" % fName)
except:
print("Unexpected error:", sys.exc_info())
cnt += 1
already_saved_this_img = True
#elif "utf8_string" not in ann:
#saveAnn.write("NULL "+str(aBbox[0])+" "+str(aBbox[1])+" "+str(aBbox[2])+" "+str(aBbox[3])+" "+str(iWidth)+" "+str(iHeight)+"\n")
"""
if (not already_saved_this_img):
#save image directory and name for different division
lstpath.write(set_path+"/"+fName+"\n")
trg_path = set_path+"/"
src_path = opt.img_path+fName
try:
copy(src_path, trg_path)
except IOError as e:
print("Unable to copy file. %s" % fName)
except:
print("Unexpected error:", sys.exc_info())
cnt+=1
already_saved_this_img = True
"""
#saveAnn.close()
lstpath.close()
sp += 1
if cnt == total_img_num: output = "Copying Finished Successfully!"
elif cnt == 0: output = "No one get copied."
else:
output = "Copying Finished Successfully! But some images are not copied."
print(output)
clspath.close()
print("The class number is: ", cls_num)
return print("Only One more step to finish")
def add_negative_sampling_data(activ_D_folder,
COCO_folder,
total_negative_samples=1000,
testing_samples=100):
# Create a folder to store negative sampling images
negative_folder = join(activ_D_folder, "Negative")
if not isdir(negative_folder):
os.mkdir(negative_folder)
if not isdir(join(negative_folder, "trainingFiles")):
os.mkdir(join(negative_folder, "trainingFiles"))
if not isdir(join(negative_folder, "testFiles")):
os.mkdir(join(negative_folder, "testFiles"))
# Get list of images with text from COCO-Text dataset
ct = coco_text.COCO_Text('COCO_Text.json')
negative_images = ct.loadImgs(
ct.getImgIds(imgIds=ct.train,
catIds=[('legibility', 'legible'),
('class', 'machine printed'),
('language', 'english')
])[:total_negative_samples + testing_samples])
modes = ["training", "test"]
for mode in modes:
if mode == 'training':
negative_images_subset = negative_images[:total_negative_samples]
elif mode == 'test':
negative_images_subset = negative_images[
total_negative_samples:total_negative_samples +
testing_samples]
else:
print("unknown mode; quitting")
quit()
# Start XML file text
xml_file_output = '''<?xml version="1.0" encoding="UTF-8"?>\n\n<Protocol4 channel="Negative">\n\n'''
counter = 0
for negative_image_dict in negative_images_subset:
#xml_file_output += '''<frame source="vd00" id="{0}">'''.format(str(counter))
if not os.path.isdir(COCO_folder):
print("COCO_folder not found at {0}".format(COCO_folder))
quit()
# Make path to COCO train2014 folder to load image
negative_image = cv2.imread(
join(COCO_folder, negative_image_dict['file_name']))
suffix = negative_image_dict['file_name'][
negative_image_dict['file_name'].rfind(".") + 1:]
xml_file_output += '''<frame source="vd00" id="{0}" ext="{1}">\n'''.format(
str(counter), suffix)
# Get annotations
annIds = ct.getAnnIds(imgIds=negative_image_dict['id'])
anns = ct.loadAnns(annIds)
rectangle_num = 0
for ann in anns:
rectangle_num += 1
# Per COCO-Text “bbox” : [x,y,width,height],
x, y, width, height = ann['bbox']
xml_file_output += '''<rectangle id="{4}" height="{0}" width="{1}" y="{2}" x="{3}"/>\n'''.format(
int(height), int(width), int(y), int(x), rectangle_num)
xml_file_output += '''</frame>\n'''
# Save in Negative folder under AcTiV-D
cv2.imwrite(
join(negative_folder, mode + "Files",
"Negative_vd00_frame_" + str(counter) + "." + suffix),
negative_image)
counter += 1
if counter % 200 == 0 and counter != total_negative_samples and counter != testing_samples:
print("Added {0} negative {1} examples".format(counter, mode))
# End XML file text
xml_file_output += "\n</Protocol4>"
#print(xml_file_output)
with open(join(negative_folder, "g" + mode + "_Ne.xml"), 'w') as f:
f.write(xml_file_output)
# Print out final count
if mode == 'training':
print("Added {0} negative {1} examples".format(
total_negative_samples, mode))
elif mode == 'test':
print("Added {0} negative {1} examples".format(
testing_samples, mode))
"i.e. COCO_Text.json")
parser.add_argument(
"-i",
"--imagedir",
type=str,
required=True,
help="Directory containing the train images - coco text uses"
"coco 2014 train images.")
parser.add_argument("-t",
"--targetdir",
type=str,
required=True,
help="Directory that will contain the yolo dataset.")
args = parser.parse_args()
ct = coco_text.COCO_Text(args.annotationfile)
ct.info()
#in contrast to other coco scripts i don't feel like it should be possible to specify labels to use for now
labels = ["machine printed legible", "machine printed illegible"]
dsTypes = ["train", "valid"]
if (not os.path.exists(args.targetdir)):
os.makedirs(args.targetdir)
backUpDir = os.path.join(args.targetdir, "backup")
if (not os.path.exists(backUpDir)):
os.makedirs(backUpDir)
with open(os.path.join(args.targetdir, "coco_text.data"), 'w') as dataFile:
dataFile.write("classes = " + str(len(labels)) + "\n")
'image/object/bbox/ymax':
dataset_util.float_list_feature(ymaxs),
'image/object/class/text':
dataset_util.bytes_list_feature(classes_text),
'image/object/class/label':
dataset_util.int64_list_feature(classes),
}))
writer.write(tf_example.SerializeToString())
num_examples += 1
return num_examples
if __name__ == "__main__":
args = parse_arguments()
train_or_val = args.train_or_val.lower()
ct = coco_text.COCO_Text(args.cocotext_json)
img_ids = ct.getImgIds(imgIds=ct.train, catIds=[('legibility', 'legible')]) \
if train_or_val == 'train' else ct.getImgIds(imgIds=ct.val, catIds=[('legibility', 'legible')])
seen = set()
num_examples = 0
writer = tf.python_io.TFRecordWriter(args.output_path)
for img_id in img_ids:
img = ct.loadImgs(img_id)[0]
file_name = img['file_name']
if file_name in seen:
continue
seen.add(file_name)
train_val_dir = 'train2014'
path = os.path.join(args.coco_imgdir, train_val_dir)
pil_img = Image.open(os.path.join(path, file_name))
import coco_text
import cv2
import os
ct = coco_text.COCO_Text('cocotext.v2.json')
ct.info()
imgs = ct.getImgIds(imgIds=ct.val,
catIds=[('legibility', 'legible'),
('class', 'machine printed')])
anns = ct.getAnnIds(imgIds=ct.val,
catIds=[('legibility', 'legible'),
('class', 'machine printed')],
areaRng=[0, 200])
dataDir = '/Data3/data'
dataType = 'train2014'
import numpy as np
import skimage.io as io
import matplotlib.pyplot as plt
import pylab
pylab.rcParams['figure.figsize'] = (10.0, 8.0)
# get all images containing at least one instance of legible text
imgIds = ct.getImgIds(imgIds=ct.val, catIds=[('legibility', 'legible')])
#print(imgIds)
#print(len(imgIds))
# pick one at random
path = '/Data3/coco_val1/'
