def genDistractors(self):
# generate distractor images
for j in range(self.optionNum):
plt.figure()
for i in self.distractors:
# do something and then draw the distractors.
choice = random.choice(['flip', 'rotate', 'swap'])
if choice == 'flip':
i.flip(how=random.choice(['vert', 'hori']))
elif choice == 'rotate':
i.rotate(theta=random.choice(
[math.pi / 2, math.pi / 4, math.pi]))
elif choice == 'swap':
i.swap_polygons(random.choice(self.distractors))
i.drawPolygon()
plt.axis('image')
plt.axis('off')
distractor_tmpPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_cut_question_' + str(
self.questionCount) + '_dist_' + str(j) + '.png'
plt.savefig(distractor_tmpPath)
# crop the image
img = cv2.imread(distractor_tmpPath, 0)
img = cropImage(img)
cv2.imwrite(distractor_tmpPath, img)
# remove one quadrant from distractor full image and generate options
img = cv2.imread(distractor_tmpPath, 0)
quad, rest_img = splitQuad(img, self.quadrantNum)
distractor_finalPath = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_cut_question_' + str(
self.questionCount) + '_dist_' + str(j) + '.png'
cv2.imwrite(distractor_finalPath, quad)
# cv2.imwrite('./plot/quads/plotRest'+str(l)+'Dist'+str(j)+'.png',rest_img)
# self.distractors_path.append(os.path.split(distractor_finalPath)[1])
self.distractors_path.append(distractor_finalPath)
plt.close()
def generate_question_answer_pair(self):
# generate question image
plt.figure()
# Make a random polygon (the outer most Polygon)
A = Polygon()
A.makeRandomCircumcircle()
A.drawPolygon()
# store distractor sequence
self.distractor_sequence(A)
plt.axis('image')
plt.axis('off')
question_tmpPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_cut_question_' + str(
self.questionCount) + '.png'
plt.savefig(question_tmpPath)
# crop the question image
img = cv2.imread(question_tmpPath, 0)
img = cropImage(img)
cv2.imwrite(question_tmpPath, img)
# remove one quadrant from question and generate answer
self.question_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_cut_question_' + str(
self.questionCount) + '.png'
self.answer_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_cut_answer_' + str(
self.questionCount) + '.png'
img = cv2.imread(question_tmpPath, 0)
quad, rest_img = splitQuad(img, self.quadrantNum)
cv2.imwrite(self.answer_path, quad)
cv2.imwrite(self.question_path, rest_img)
draw_boundary(self.quadrantNum, self.question_path)
# os.system(' convert '+ self.question_path +' -bordercolor Black -border 8x8 '+ self.question_path)
# os.system(' convert '+ self.answer_path +' -bordercolor Black -border 4x4 '+ self.answer_path)
plt.close()
def generate_all_images(self):
sides = [0, 0, 2, 4]
XX = [0, 10, 15, 20]
YY = [10, 15, 0, 20]
polys = []
plt.figure()
temp = None
for i in range(len(sides)):
size = (i + 1)**2 * 100
temp = Polygon(no_of_sides=sides[i], isRegular=False)
temp.circumcircle = Circumcircle(size, XX[i], YY[i])
temp.makeShape()
temp.drawPolygon()
polys.append(temp)
plt.axis('image')
plt.axis('off')
question_baseImgPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '_base.png'
plt.savefig(question_baseImgPath, transparent=True)
plt.close()
# save a flipped version
question_baseImgFlippedPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '_base_flipped.png'
os.system('convert ' + question_baseImgPath + ' -flop ' +
question_baseImgFlippedPath)
one = IMG.open(question_baseImgPath).convert('RGBA')
two = IMG.open(question_baseImgFlippedPath).convert('RGBA')
base_img_merge_filepath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '_base_merge.png'
IMG.alpha_composite(one, two).save(base_img_merge_filepath)
img = cv2.imread(base_img_merge_filepath, 0)
height, width = img.shape
# gives transparent image
self.question_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '.png'
self.answer_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_fold_answer_' + str(
self.questionCount) + '.png'
os.system(
'convert ' + question_baseImgPath +
' -strokewidth 1 -fill none -stroke black -draw \"stroke-dasharray 5 3 line '
+ str(width / 2) + ',0 ' + str(width / 2) + ',' + str(height) +
'\" ' + self.question_path)
os.system(
'convert ' + base_img_merge_filepath +
' -strokewidth 1 -fill none -stroke black -draw \"stroke-dasharray 5 3 line '
+ str(width / 2) + ',0 ' + str(width / 2) + ',' + str(height) +
'\" ' + base_img_merge_filepath)
os.system('convert ' + base_img_merge_filepath +
' -fill white -draw "rectangle 0,0 ' + str(width / 2) +
',' + str(height) + '" ' + self.answer_path)
# adds white bg
os.system('convert -flatten ' + self.question_path + ' ' +
self.question_path) # question
os.system('convert -flatten ' + base_img_merge_filepath + ' ' +
base_img_merge_filepath) # intermediate output
os.system('convert -flatten ' + self.answer_path + ' ' +
self.answer_path) # answer
# distractors
for j in range(3):
dist_base_img = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '_dist_' + str(j) + 'base.png'
dist_base_flipped_img = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '_dist_' + str(j) + 'base_flipped.png'
dist_base_merge_img = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '_dist_' + str(j) + 'base_merge.png'
plt.figure()
# additional transformation
for temp in polys:
if random.random() <= 0.5:
temp.flip(how=random.choice(['vert', 'hori']))
else:
temp.rotate(
random.choice([-1, +1]) *
random.choice([math.pi / 4, math.pi / 2]))
temp.drawPolygon()
plt.axis('image')
plt.axis('off')
# same base image
plt.savefig(dist_base_img, transparent=True)
plt.close()
# save a flipped version
os.system('convert ' + dist_base_img + ' -flop ' +
dist_base_flipped_img)
one = IMG.open(dist_base_img).convert('RGBA')
two = IMG.open(dist_base_flipped_img).convert('RGBA')
IMG.alpha_composite(one, two).save(dist_base_merge_img)
img = cv2.imread(dist_base_merge_img, 0)
height, width = img.shape
distractor_final_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_fold_question_' + str(
self.questionCount) + '_dist_' + str(j) + '.png'
os.system(
'convert ' + dist_base_img +
' -strokewidth 1 -fill none -stroke black -draw \"stroke-dasharray 5 3 line '
+ str(width / 2) + ',0 ' + str(width / 2) + ',' + str(height) +
'\" ' + dist_base_img)
os.system(
'convert ' + dist_base_merge_img +
' -strokewidth 1 -fill none -stroke black -draw \"stroke-dasharray 5 3 line '
+ str(width / 2) + ',0 ' + str(width / 2) + ',' + str(height) +
'\" ' + dist_base_merge_img)
os.system('convert ' + dist_base_merge_img +
' -fill white -draw "rectangle 0,0 ' + str(width / 2) +
',' + str(height) + '" ' + distractor_final_path)
os.system('convert -flatten ' + dist_base_img + ' ' +
dist_base_img) # base distractor
os.system('convert -flatten ' + dist_base_merge_img + ' ' +
dist_base_merge_img) # intermediate distractor output
os.system(
'convert -flatten ' + distractor_final_path + ' ' +
distractor_final_path) # final transformed distractor - folded
self.distractors_path.append(distractor_final_path)
def generate_all_images(self):
for i in range(1, self.TOTAL_FIG + 4):
plt.figure()
A = Polygon(no_of_sides=3 + (self.XX + i) % self.SIDE_REPEAT_FREQ,
isRegular=False,
hatch=self.two_hatches[(self.XX + i) %
self.HATCH_REPEAT_FREQ])
A.makeRandomCircumcircle()
A.drawPolygon()
plt.axis('image')
plt.axis('off')
# part of the question
if i < self.TOTAL_FIG:
question_tmpPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_series_question_' + str(
self.questionCount) + '_part_' + str(i) + '.png'
plt.savefig(question_tmpPath)
plt.close()
img = cv2.imread(question_tmpPath, 0)
img = cropImage(img)
cv2.imwrite(question_tmpPath, img)
os.system(' convert ' + question_tmpPath +
' -bordercolor Black -border 4x4 ' +
question_tmpPath)
# answer
elif i == self.TOTAL_FIG:
self.answer_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_series_answer_' + str(
self.questionCount) + '.png'
plt.savefig(self.answer_path)
plt.close()
img = cv2.imread(self.answer_path, 0)
img = cropImage(img)
cv2.imwrite(self.answer_path, img)
os.system(' convert ' + self.answer_path +
' -bordercolor Black -border 4x4 ' +
self.answer_path)
# distractors
else:
distractor_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_series_question_' + str(
self.questionCount) + '_dist_' + str(i - self.TOTAL_FIG -
1) + '.png'
plt.savefig(distractor_path)
plt.close()
img = cv2.imread(distractor_path, 0)
img = cropImage(img)
cv2.imwrite(distractor_path, img)
os.system(' convert ' + distractor_path +
' -bordercolor Black -border 4x4 ' +
distractor_path)
self.distractors_path.append(distractor_path)
# build question montage
question_path = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_series_question_' + str(
self.questionCount) + '_part_'
self.question_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_series_question_' + str(
self.questionCount) + '.png'
os.system('montage -mode concatenate -tile ' +
str(self.TOTAL_FIG - 1) + 'x1 ' + question_path + '[1-' +
str(self.TOTAL_FIG - 1) + '].png ' + self.question_path)
def generate_all_images(self):
dist_root_seq_of_polygons = []
for l in range(self.lenSequence):
# Cleans canvas starts a new figure
plt.figure()
# Make a random polygon (the outer most Polygon)
A = Polygon()
A.makeRandomCircumcircle()
# This stores the polgons that make up an image.
# We should store this and use it to create a distractor image
seqs_of_polygons = []
for j in range(self.numPolygons):
# any number of sides
B = Polygon(no_of_sides=int(random.random() * 3) + 3)
# same center and radius
B.clone_circumcircle(A)
# Center remains same as A but the radius can be anything less than A's raduis
B.circumcircle.radius = 0.5 * A.circumcircle.radius
# make the sides
B.makeShape()
# draw the polygon on the canvas
B.drawPolygon()
seqs_of_polygons.append(B)
A.circumcircle.radius = B.circumcircle.radius
plt.axis('image')
plt.axis('off')
question_base_path = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_grid_question_' + str(
self.questionCount) + '_' + str(l) + '_0.png'
plt.savefig(question_base_path)
plt.close()
img = cv2.imread(question_base_path, 0)
img = cropImage(img)
cv2.imwrite(question_base_path, img)
img = IMG.open(question_base_path)
img.resize((300, 300), IMG.ANTIALIAS).save(question_base_path,
quality=90)
for level in [1, 2]:
plt.figure()
# transformations for each embedded polygon
# TODO: shuffle order and rules to generate distractors
for i in range(len(seqs_of_polygons)):
if i == 0:
seqs_of_polygons[i].rotate(math.pi * 0.5) # 90 degrees
elif i == 1:
seqs_of_polygons[i].flip('vert')
elif i == 2:
seqs_of_polygons[i].rotate(math.pi *
0.75) # 270 degrees
seqs_of_polygons[i].drawPolygon()
if l == 2 and level == 1:
dist_root_seq_of_polygons = copy.deepcopy(seqs_of_polygons)
plt.axis('image')
plt.axis('off')
question_transform_path = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_grid_question_' + str(
self.questionCount) + '_' + str(l) + '_' + str(
level) + '.png'
plt.savefig(question_transform_path)
plt.close()
img = cv2.imread(question_transform_path, 0)
img = cropImage(img)
cv2.imwrite(question_transform_path, img)
img = IMG.open(question_transform_path)
img.resize((300, 300),
IMG.ANTIALIAS).save(question_transform_path,
quality=90)
level_montage_path = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + '_grid_question_' + str(
self.questionCount) + '_level_' + str(l) + '_final.png'
if l == 2:
self.answer_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_grid_answer_' + str(
self.questionCount) + '.png'
os.system("cp " + self.STATIC_ROOT + 'tmp/' + self.user_id +
"_" + self.session_id + '_grid_question_' +
str(self.questionCount) + '_2_2.png ' +
self.answer_path)
os.system("montage -mode concatenate -border 2 " +
self.STATIC_ROOT + "tmp/" + self.user_id + "_" +
self.session_id + "_grid_question_" +
str(self.questionCount) + "_" + str(l) +
"_[0-1].png -tile 3x1 -geometry +1+1 " +
level_montage_path)
# generate distractors
for dist in range(3):
# create copy of level 2 part 1 question - from which answer is generated
dist_seq_of_polygons = copy.deepcopy(
dist_root_seq_of_polygons)
plt.figure()
if dist == 0:
# order of transformations are shuffled for the distractors
for i in range(len(dist_seq_of_polygons)):
if i == 0:
dist_seq_of_polygons[i].rotate(
math.pi * 0.75) # 270 degrees
elif i == 1:
dist_seq_of_polygons[i].flip('hori')
elif i == 2:
dist_seq_of_polygons[i].rotate(
math.pi * 0.5) # 90 degrees
dist_seq_of_polygons[i].drawPolygon()
if dist == 1:
# order of transformations are shuffled for the distractors
for i in range(len(dist_seq_of_polygons)):
if i == 0:
dist_seq_of_polygons[i].rotate(
math.pi * 0.5) # 90 degrees
elif i == 1:
dist_seq_of_polygons[i].rotate(
math.pi * 0.75) # 270 degrees
elif i == 2:
dist_seq_of_polygons[i].flip('hori')
dist_seq_of_polygons[i].drawPolygon()
if dist == 2:
# order of transformations are shuffled for the distractors
for i in range(len(dist_seq_of_polygons)):
if i == 0:
dist_seq_of_polygons[i].flip('vert')
elif i == 1:
dist_seq_of_polygons[i].rotate(
math.pi * 0.75) # 270 degrees
elif i == 2:
dist_seq_of_polygons[i].rotate(
math.pi * 0.5) # 90 degrees
dist_seq_of_polygons[i].drawPolygon()
plt.axis('image')
plt.axis('off')
distractor_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_grid_question_' + str(
self.questionCount) + '_dist_' + str(dist) + '.png'
plt.savefig(distractor_path)
plt.close()
img = cv2.imread(distractor_path, 0)
img = cropImage(img)
cv2.imwrite(distractor_path, img)
img = IMG.open(distractor_path)
img.resize((300, 300), IMG.ANTIALIAS).save(distractor_path,
quality=90)
self.distractors_path.append(distractor_path)
else:
os.system("montage -mode concatenate -border 2 " +
self.STATIC_ROOT + "tmp/" + self.user_id + "_" +
self.session_id + "_grid_question_" +
str(self.questionCount) + "_" + str(l) +
"_[0-2].png -tile 3x1 -geometry +1+1 " +
level_montage_path)
self.question_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + '_grid_question_' + str(
self.questionCount) + '.png'
os.system("montage -mode concatenate -border 2 " + self.STATIC_ROOT +
"tmp/" + self.user_id + "_" + self.session_id +
"_grid_question_" + str(self.questionCount) +
"_level_[0-2]_final.png -tile 1x3 -geometry +1+1 " +
self.question_path)
def generate_all_images(self):
if self.logic_choice < 0.5:
plt.figure()
draw_grid()
polys = []
XX = 0
rank = range(1, 10)
random.shuffle(rank)
for i in rank:
temp = Polygon(no_of_sides=int(random.random() * 6),
isRegular=False,
hatch='random')
draw_polygon_grid(temp, i)
polys.append(temp)
XX += 1
# question
plt.axis('image')
plt.axis('off')
question_tmpPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + \
'_figureMatrix_question_' + \
str(self.questionCount)+'_part_' + str(0) + '.png'
plt.savefig(question_tmpPath, dpi=150)
img = cv2.imread(question_tmpPath, 0)
img = cropImage(img)
cv2.imwrite(question_tmpPath, img)
plt.close()
# generates remaining 4 parts for question
for i in range(1, 9):
plt.figure()
draw_grid()
# shift polygons by one position
temp_circumcircle = polys[0].circumcircle
for j in range(len(polys) - 1):
polys[j].circumcircle = polys[j + 1].circumcircle
polys[len(polys) - 1].circumcircle = temp_circumcircle
for k in range(len(polys)):
polys[k].gen_points()
polys[k].drawPolygon()
plt.axis('image')
plt.axis('off')
if i in [1, 2, 3, 4]:
question_tmpPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + \
'_figureMatrix_question_' + \
str(self.questionCount)+'_part_' + str(i) + '.png'
elif i == 5:
question_tmpPath = self.STATIC_ROOT + 'result/' + self.user_id + "_" + \
self.session_id + '_figureMatrix_answer_' + \
str(self.questionCount) + '.png'
self.answer_path = question_tmpPath
else:
question_tmpPath = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + \
'_figureMatrix_question_' + \
str(self.questionCount)+'_dist_' + str(i-6) + '.png'
self.distractors_path.append(question_tmpPath)
plt.savefig(question_tmpPath, dpi=150)
img = cv2.imread(question_tmpPath, 0)
img = cropImage(img)
cv2.imwrite(question_tmpPath, img)
plt.close()
else:
plt.figure()
draw_grid()
polys = []
XX = 0
rank = range(1, 10)
random.shuffle(rank)
hatches = ['-', '+', 'x', '\\', '*', 'o', 'O', '.', '/', '|']
random.shuffle(hatches)
for i in rank:
temp = Polygon(no_of_sides=int(random.random() * 6) + 3,
isRegular=False,
hatch=hatches[i % 10])
draw_polygon_grid(temp, i)
polys.append(temp)
XX += 1
# question
plt.axis('image')
plt.axis('off')
question_tmpPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + \
'_figureMatrix_question_' + \
str(self.questionCount)+'_part_' + str(0) + '.png'
plt.savefig(question_tmpPath, dpi=150)
img = cv2.imread(question_tmpPath, 0)
img = cropImage(img)
cv2.imwrite(question_tmpPath, img)
plt.close()
# generates remaining 4 parts for question
for i in range(1, 9):
plt.figure()
draw_grid()
# shift polygons by one position
temp_circumcircle = polys[0].circumcircle
for j in range(len(polys) - 1):
polys[j].circumcircle = polys[j + 1].circumcircle
polys[len(polys) - 1].circumcircle = temp_circumcircle
for k in range(len(polys)):
polys[k].gen_points()
polys[k].drawPolygon()
plt.axis('image')
plt.axis('off')
if i in [1, 2, 3, 4]:
question_tmpPath = self.STATIC_ROOT + 'tmp/' + self.user_id + "_" + self.session_id + \
'_figureMatrix_question_' + \
str(self.questionCount)+'_part_' + str(i) + '.png'
elif i == 5:
question_tmpPath = self.STATIC_ROOT + 'result/' + self.user_id + "_" + \
self.session_id + '_figureMatrix_answer_' + \
str(self.questionCount) + '.png'
self.answer_path = question_tmpPath
else:
question_tmpPath = self.STATIC_ROOT + 'result/' + self.user_id + "_" + self.session_id + \
'_figureMatrix_question_' + \
str(self.questionCount)+'_dist_' + str(i-6) + '.png'
self.distractors_path.append(question_tmpPath)
plt.savefig(question_tmpPath, dpi=150)
img = cv2.imread(question_tmpPath, 0)
img = cropImage(img)
cv2.imwrite(question_tmpPath, img)
plt.close()
self.question_path = self.STATIC_ROOT + 'result/' + self.user_id + "_" + \
self.session_id + '_figureMatrix_question_' + \
str(self.questionCount) + '.png'
os.system('montage -mode concatenate -tile 5x1 -border 5 ' +
self.STATIC_ROOT + 'tmp/' + self.user_id + "_" +
self.session_id + '_figureMatrix_question_' +
str(self.questionCount) + '_part_[0-4].png ' +
self.question_path)