एक छवि से संख्या 2014 का उत्पादन करें


11

में 2014 चुनौती , माइकल स्टर्न पार्स करने के लिए ओसीआर उपयोग करने का सुझाव 2014 की संख्या की एक छवि2014 के लिए मैं एक अलग दिशा में इस चुनौती लेने के लिए चाहते हैं। अपनी पसंद की भाषा / मानक लाइब्रेरी से अंतर्निहित ओसीआर का उपयोग करते हुए, सबसे छोटी छवि (बाइट्स में) डिज़ाइन करें, जिसे एएससीआईआई स्ट्रिंग "2014" में पार्स किया गया है।

स्टर्न की मूल छवि 7357 बाइट्स है, लेकिन थोड़े प्रयास के साथ यह 980 बाइट्स के साथ दोषरहित हो सकता है। कोई संदेह नहीं है कि ब्लैक-एंड-व्हाइट संस्करण (181 बाइट्स) एक ही कोड के साथ काम करता है।

नियम: प्रत्येक उत्तर को बाइट में छवि, उसका आकार और इसे संसाधित करने के लिए आवश्यक कोड देना चाहिए। स्पष्ट कारणों के लिए कोई कस्टम OCR की अनुमति नहीं है ...! किसी भी उचित भाषा और छवि प्रारूप की अनुमति है।

संपादित करें: टिप्पणियों के जवाब में, मैं किसी भी preexisting पुस्तकालय, या यहाँ तक कि उन भाषाओं के लिए http://www.free-ocr.com/ को शामिल करने के लिए इसे व्यापक करूँगा जहाँ कोई OCR उपलब्ध नहीं है।


9
कितनी भाषाओं या मानक पुस्तकालयों में अंतर्निहित ओसीआर है? या क्या आप "मानक पुस्तकालय" का इरादा "किसी भी पुस्तकालय जो इस चुनौती के लिए विशेष रूप से नहीं बनाया गया है" का मतलब है?
पीटर टेलर

3
क्या Mathematica के अलावा किसी भी विकास मंच में OCR का निर्माण किया गया है?
माइकल स्टर्न

आपको मानकीकृत करना चाहिए, जैसे " free-ocr.com का उपयोग करें " या कुछ अन्य आसानी से सुलभ ocr का उपयोग करें।
जस्टिन

जवाबों:


10

शेल (इमेजमैजिक, टेसरैक्ट), 18 बाइट्स

file=golf_2014
echo -n UDQKMTMgNQruqCqo6riKiO6I | base64 -d > $file.pbm
convert -border 2x2 -bordercolor white -resize 300% -sharpen 0 -monochrome $file.pbm $file.png
tesseract $file.png $file digits
cat $file.txt
rm $file.pbm $file.png $file.txt

छवि 18 बाइट्स है और इसे इस तरह से पुन: पेश किया जा सकता है:

echo -n UDQKMTMgNQruqCqo6riKiO6I | base64 -d > 2014.pbm

यह इस तरह दिखता है (यह पीएनजी कॉपी है, मूल नहीं):

2014

ImageMagick के साथ प्रसंस्करण के बाद, यह इस तरह दिखता है:

2014 बड़ा है

ImageMagick संस्करण 6.6.9-7, टेसरैक्ट संस्करण 3.02 का उपयोग करना। PBM छवि को जिम्प में बनाया गया था और एक हेक्स संपादक के साथ संपादित किया गया था।


इस संस्करण की आवश्यकता है jp2a

file=golf_2014
echo -n UDQKMTMgNQruqCqo6riKiO6I | base64 -d > $file.pbm
convert -border 2x2 -bordercolor white -resize 300% -sharpen 0 -monochrome $file.pbm $file.png
tesseract $file.png $file digits
cat $file.txt
convert -background black -fill white -border 2x2 -bordercolor black -pointsize 100 label:$(cat $file.txt) $file.jpg
jp2a --chars=" $(cat $file.txt) " $file.jpg
rm $file.pbm $file.png $file.txt $file.jpg

यह कुछ इस तरह का उत्पादन करता है:

    2014444444102         01144444102              214441                 214441     
   1             1      24           1            04    4                0     4     
  1    410201     0    0    410004    1       2014      4              21      4     
 24   42     0    4    4    0     1    0    24          4             04       4     
  22222      1    1   0    42     0    4    2   4100    4            1   41    4     
            1    42   0    4      2     2   2412   0    4          24   420    4     
          04    42    0    1      2     2          0    4         0   40  0    4     
       204    42      0    1      2     2          0    4       24   42   0    4     
     21     12        0    4      0    42          0    4      2     411114     1112 
    04   412          24    0     1    0           0    4      0                   0 
  24     1111111110    1    42  21    4            0    4      200011111001    40002 
  4               4     04    44     42            0    4                 0    4     
 0                4      214       10              0    4                 0    4     
  22222222222222222         222222                  22222                  22222     

बहुत, बहुत प्रभावशाली। हेडर के लिए 3 बाइट्स, छवि के आयामों के लिए 5 बाइट्स, बिटमैप के लिए 10 बाइट्स। यहाँ प्रारूप का वर्णन किया गया है: netpbm.sourceforge.net/doc/pbm.html
चार्ल्स 19

5

जावा + टेसरैक्ट, 53 बाइट्स

चूंकि मेरे पास गणितज्ञ नहीं है, मैंने नियमों को थोड़ा मोड़ने और ओसीआर करने के लिए टेसरैक्ट का उपयोग करने का निर्णय लिया । मैंने एक प्रोग्राम लिखा है जो विभिन्न फोंट, आकारों और शैलियों का उपयोग करके "2014" को एक छवि में बदल देता है, और सबसे छोटी छवि पाता है जिसे "2014" के रूप में मान्यता मिलती है। परिणाम उपलब्ध फोंट पर निर्भर करते हैं।

यहाँ मेरे कंप्यूटर पर विजेता है - "यूआरडब्ल्यू गोथिक एल" फ़ॉन्ट का उपयोग करते हुए 53 बाइट्स: 2014

कोड:

import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.GraphicsEnvironment;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

import javax.imageio.ImageIO;

public class Ocr {
    public static boolean blankLine(final BufferedImage img, final int x1, final int y1, final int x2, final int y2) {
        final int d = x2 - x1 + y2 - y1 + 1;
        final int dx = (x2 - x1 + 1) / d;
        final int dy = (y2 - y1 + 1) / d;
        for (int i = 0, x = x1, y = y1; i < d; ++i, x += dx, y += dy) {
            if (img.getRGB(x, y) != -1) {
                return false;
            }
        }
        return true;
    }

    public static BufferedImage trim(final BufferedImage img) {
        int x1 = 0;
        int y1 = 0;
        int x2 = img.getWidth() - 1;
        int y2 = img.getHeight() - 1;
        while (x1 < x2 && blankLine(img, x1, y1, x1, y2)) x1++;
        while (x1 < x2 && blankLine(img, x2, y1, x2, y2)) x2--;
        while (y1 < y2 && blankLine(img, x1, y1, x2, y1)) y1++;
        while (y1 < y2 && blankLine(img, x1, y2, x2, y2)) y2--;
        return img.getSubimage(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
    }

    public static int render(final Font font, final int w, final String name) throws IOException {
        BufferedImage img = new BufferedImage(w, w, BufferedImage.TYPE_BYTE_BINARY);
        Graphics2D g = img.createGraphics();
        float size = font.getSize2D();
        Font f = font;
        while (true) {
            final FontMetrics fm = g.getFontMetrics(f);
            if (fm.stringWidth("2014") <= w) {
                break;
            }
            size -= 0.5f;
            f = f.deriveFont(size);
        }
        g = img.createGraphics();
        g.setFont(f);
        g.fillRect(0, 0, w, w);
        g.setColor(Color.BLACK);
        g.drawString("2014", 0, w - 1);
        g.dispose();
        img = trim(img);
        final File file = new File(name);
        ImageIO.write(img, "gif", file);
        return (int) file.length();
    }

    public static boolean ocr() throws Exception {
        Runtime.getRuntime().exec("/usr/bin/tesseract 2014.gif out -psm 8").waitFor();
        String t = "";
        final BufferedReader br = new BufferedReader(new FileReader("out.txt"));
        while (true) {
            final String s = br.readLine();
            if (s == null) break;
            t += s;
        }
        br.close();
        return t.trim().equals("2014");
    }

    public static void main(final String... args) throws Exception {
        int min = 10000;
        for (String s : GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames()) {
            for (int t = 0; t < 4; ++t) {
                final Font font = new Font(s, t, 50);
                for (int w = 10; w < 25; ++w) {
                    final int size = render(font, w, "2014.gif");
                    if (size < min && ocr()) {
                        render(font, w, "2014win.gif");
                        min = size;
                        System.out.println(s + ", " + size);
                    }
                }
            }
        }
    }
}

मैंने इसे और समान प्रविष्टियों की अनुमति देने के लिए नियमों को बदल दिया। प्रभावशाली फ़ाइल का आकार।
चार्ल्स

1

गणितज्ञ 753 100

f[n_,format_]:=
Module[{filename},
Print["raster: ",n," by ", n];
filename="2014At"<>ToString[n]<>"."<>format;
Print["filename:  ",filename];
Print["format: ",format];
Print["raster image: ",rasterImg=Rasterize[Style[2014,"OCR A Std"],
RasterSize->n,ImageSize->1n,ImageResolution->6n]];
Export[filename,rasterImg];
Print["Actual imported image: ",img=Switch[format,"PDF"|"HDF",Import[filename][[1]],
_,Import[filename]]];
Print["Identified text: ",TextRecognize[ImageResize[img,Scaled[3]]]];
Print["filesize (bytes): ",FileByteCount[filename]]]

मेरा अब तक का सबसे अच्छा मामला:

f[24, "PBM"]

दक्षता


1

गणितज्ञ, 78 बाइट्स

Mathematica में इसे जीतने की ट्रिक शायद नीचे की तरह ImageResize [] फंक्शन का उपयोग करेगी।

सबसे पहले, मैंने "2014" टेक्स्ट बनाया और डेविड काररहर के समाधान के साथ निष्पक्ष तुलना के लिए इसे जीआईएफ फ़ाइल में सहेजा। पाठ जैसा दिखता है 2014। यह किसी भी तरह से अनुकूलित नहीं है; यह छोटे फ़ॉन्ट आकार में सिर्फ जिनेवा है; अन्य फोंट और छोटे आकार संभव हो सकते हैं। सीधे TextRecognize [] विफल होगा, लेकिन TextRecognize [ImageResize []]] को कोई समस्या नहीं है

filename = "~/Desktop/2014.gif";
Print["Actual imported image: ", img = Import[filename]]
Print["Identified text: ", 
 TextRecognize[ImageResize[img, Scaled[2]]]]
Print["filesize (bytes): ", FileByteCount[filename]]

परिणाम

टाइपफेस, फॉन्ट साइज़, स्केलिंग की डिग्री इत्यादि के साथ फ़्यूज़ करने से शायद और भी छोटी फ़ाइलों का काम होगा।


बहुत प्रभावशाली फ़ाइल आकार।
डेविड जेएन

आप छवि को सफेद सीमाओं से काट सकते हैं ताकि इसे अंकों के बीच छोटे और छोटे स्थान बना सकें, शायद उन्हें अधिक कॉम्पैक्ट बनाने के लिए फिर से तैयार किया जाए।
बेंत की मार

@ वास्तव में, सफ़ेद बॉर्डर को ट्रिम करने के लिए इसे 78 बाय तक ले जाता है।
माइकल स्टर्न
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.