इनपुट के रूप में किसी भी उचित दोषरहित प्रारूप में एक श्वेत-श्याम छवि को देखते हुए , आउटपुट ASCII कला जो इनपुट छवि के जितना संभव हो उतना करीब है।
नियम
- केवल लाइनफीड और ASCII बाइट 32-127 का उपयोग किया जा सकता है।
- इनपुट छवि को क्रॉप किया जाएगा ताकि छवि के आसपास कोई बाहरी व्हाट्सएप न हो।
- प्रस्तुतियाँ 5 मिनट के भीतर पूरे स्कोरिंग कॉर्पस को पूरा करने में सक्षम होनी चाहिए।
- केवल कच्चा पाठ स्वीकार्य है; कोई समृद्ध पाठ प्रारूप नहीं।
- स्कोरिंग में उपयोग किया जाने वाला फ़ॉन्ट 20-pt लिनक्स लिबर्टिन है ।
- आउटपुट टेक्स्ट फ़ाइल, जब नीचे वर्णित छवि में परिवर्तित हो जाती है, तो इनपुट आयाम के समान आयाम होना चाहिए, दोनों आयामों में 30 पिक्सेल के भीतर।
स्कोरिंग
इन छवियों का उपयोग स्कोरिंग के लिए किया जाएगा:
आप यहाँ छवियों का एक ज़िप डाउनलोड कर सकते हैं ।
प्रस्तुतियाँ इस कॉर्पस के लिए अनुकूलित नहीं होनी चाहिए; बल्कि, उन्हें समान आयामों के किसी भी 8 श्वेत-श्याम चित्रों के लिए काम करना चाहिए। यदि मुझे संदेह है कि इन विशिष्ट चित्रों के लिए सबमिशन को अनुकूलित किया जा रहा है, तो मैं कॉर्पस में छवियों को बदलने का अधिकार सुरक्षित रखता हूं।
स्कोरिंग इस स्क्रिप्ट के माध्यम से किया जाएगा:
#!/usr/bin/env python
from __future__ import print_function
from __future__ import division
# modified from http://stackoverflow.com/a/29775654/2508324
# requires Linux Libertine fonts - get them at https://sourceforge.net/projects/linuxlibertine/files/linuxlibertine/5.3.0/
# requires dssim - get it at https://github.com/pornel/dssim
import PIL
import PIL.Image
import PIL.ImageFont
import PIL.ImageOps
import PIL.ImageDraw
import pathlib
import os
import subprocess
import sys
PIXEL_ON = 0 # PIL color to use for "on"
PIXEL_OFF = 255 # PIL color to use for "off"
def dssim_score(src_path, image_path):
out = subprocess.check_output(['dssim', src_path, image_path])
return float(out.split()[0])
def text_image(text_path):
"""Convert text file to a grayscale image with black characters on a white background.
arguments:
text_path - the content of this file will be converted to an image
"""
grayscale = 'L'
# parse the file into lines
with open(str(text_path)) as text_file: # can throw FileNotFoundError
lines = tuple(l.rstrip() for l in text_file.readlines())
# choose a font (you can see more detail in my library on github)
large_font = 20 # get better resolution with larger size
if os.name == 'posix':
font_path = '/usr/share/fonts/linux-libertine/LinLibertineO.otf'
else:
font_path = 'LinLibertine_DRah.ttf'
try:
font = PIL.ImageFont.truetype(font_path, size=large_font)
except IOError:
print('Could not use Libertine font, exiting...')
exit()
# make the background image based on the combination of font and lines
pt2px = lambda pt: int(round(pt * 96.0 / 72)) # convert points to pixels
max_width_line = max(lines, key=lambda s: font.getsize(s)[0])
# max height is adjusted down because it's too large visually for spacing
test_string = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
max_height = pt2px(font.getsize(test_string)[1])
max_width = pt2px(font.getsize(max_width_line)[0])
height = max_height * len(lines) # perfect or a little oversized
width = int(round(max_width + 40)) # a little oversized
image = PIL.Image.new(grayscale, (width, height), color=PIXEL_OFF)
draw = PIL.ImageDraw.Draw(image)
# draw each line of text
vertical_position = 5
horizontal_position = 5
line_spacing = int(round(max_height * 0.8)) # reduced spacing seems better
for line in lines:
draw.text((horizontal_position, vertical_position),
line, fill=PIXEL_ON, font=font)
vertical_position += line_spacing
# crop the text
c_box = PIL.ImageOps.invert(image).getbbox()
image = image.crop(c_box)
return image
if __name__ == '__main__':
compare_dir = pathlib.PurePath(sys.argv[1])
corpus_dir = pathlib.PurePath(sys.argv[2])
images = []
scores = []
for txtfile in os.listdir(str(compare_dir)):
fname = pathlib.PurePath(sys.argv[1]).joinpath(txtfile)
if fname.suffix != '.txt':
continue
imgpath = fname.with_suffix('.png')
corpname = corpus_dir.joinpath(imgpath.name)
img = text_image(str(fname))
corpimg = PIL.Image.open(str(corpname))
img = img.resize(corpimg.size, PIL.Image.LANCZOS)
corpimg.close()
img.save(str(imgpath), 'png')
img.close()
images.append(str(imgpath))
score = dssim_score(str(corpname), str(imgpath))
print('{}: {}'.format(corpname, score))
scores.append(score)
print('Score: {}'.format(sum(scores)/len(scores)))
स्कोरिंग प्रक्रिया:
- प्रत्येक कॉर्पस छवि के लिए सबमिशन चलाएँ, परिणाम को
.txtफाइल के रूप में एक ही स्टेम के साथ आउटपुट करते हुए कॉर्पस फ़ाइल (मैन्युअल रूप से किया गया)। - 20-बिंदु फ़ॉन्ट का उपयोग करके, व्हाट्सएप को क्रॉप करके प्रत्येक टेक्स्ट फ़ाइल को पीएनजी छवि में परिवर्तित करें।
- परिणाम छवि को लैंक्ज़ोस रेज़म्पलिंग का उपयोग करके मूल छवि के आयामों का आकार बदलें।
- मूल छवि का उपयोग करके प्रत्येक पाठ छवि की तुलना करें
dssim। - प्रत्येक पाठ फ़ाइल के लिए dssim स्कोर आउटपुट करें।
- औसत स्कोर का आउटपुट।
संरचनात्मक समानता (वह मीट्रिक जिसके द्वारा dssimस्कोर की गणना की जाती है) चित्रों में मानवीय दृष्टि और वस्तु पहचान के आधार पर एक मीट्रिक है। इसे स्पष्ट रूप से कहने के लिए: यदि दो छवियां मनुष्यों के समान दिखती हैं, तो वे (शायद) से कम स्कोर करेंगे dssim।
जीतने वाला सबमिशन सबसे कम औसत स्कोर के साथ जमा होगा।
6
"ब्लैक एंड व्हाइट" के रूप में "शून्य / एक" या कितने ग्रे स्तर?
—
लुइस मेन्डो
@DonMuesli 0 और 1.
—
Mego
क्या आप स्पष्ट कर सकते हैं कि "
—
DanTheMan
.txtफाइलों के परिणामों को आउटपुट करने" से आपका क्या मतलब है ? क्या प्रोग्राम आउटपुट टेक्स्ट को फ़ाइल में पाइप किया जाना चाहिए या हमें सीधे फाइल आउटपुट करना चाहिए?
@DANTheMan या तो स्वीकार्य है। यदि आप STDOUT में आउटपुट करते हैं, तो आउटपुट को स्कोरिंग उद्देश्यों के लिए फ़ाइल में पुनर्निर्देशित करना होगा, हालांकि।
—
मेगो
आप संकल्प बाधाओं को निर्दिष्ट नहीं करना चाहिए? अन्यथा, हम कह सकते हैं कि, 10000 से 10000 वर्ण छवि का उत्पादन, जब, नीचे, मूल छवियों को काफी बारीकी से मिलाएगा, और व्यक्तिगत वर्ण अवैध डॉट्स होंगे। अगर आउटपुट इमेज बहुत बड़ी है तो फॉन्ट-साइज़ मायने नहीं रखता।
—
डेविड
