उच्च-गुणवत्ता (बिटमैप नहीं) आरेख सॉफ़्टवेयर

Question

मैं सॉफ्टवेयर के लिए देख रहा हूँ की तुलना में FEN ले सकते हैं और पीडीएफ, पोस्टस्क्रिप्ट, विंडोज मेटाफ़ाइल, या कुछ और है कि 1200x1200 डीपीआई या बेहतर में दिखेगा में एक उच्च गुणवत्ता आरेख उत्पन्न करते हैं । मैंने सोचा था कि विभिन्न शतरंज इंजन ऐसा करेंगे, लेकिन उनके आरेख सभी बिटमैप हैं (जहां तक ​​मैं बता सकता हूं) और मनमाने ढंग से आकार बदलने पर कचरा जैसा दिखता है। इसके अलावा, उनके अपने प्रकाशन निर्यात को कुछ भी मानक, AFAICT में संपादित नहीं किया जा सकता है।

अदा करने को तैयार।

Comments

की जाँच करें apronus.com/chess/diagram/editor/... - शायद यह बड़े आरेख सब के बाद अपनी जरूरतों को पूरा करेगा। किसी भी स्थिति में, आप टूल को अपनी विशिष्ट आवश्यकताओं के अनुरूप बनाने के बारे में वेबमास्टर (मुझसे) से संपर्क कर सकते हैं।

— DrCapablasker

जैसे मैंने अपनी पिछली टिप्पणी में लिखा था कि मैं उस उपकरण की आपूर्ति कर सकता हूं जिसकी आपको आवश्यकता है। मैं प्रत्येक टुकड़े के लिए अलग-अलग SVG फ़ाइलों से एक SVG आरेख बनाने के बारे में सोच रहा हूँ। आपने मुझे सुझाव दिए बिना मुझसे संपर्क करने के लिए एक इनाम शुरू किया है।

— DrCapablasker

क्या आपने लेटेक्स पैकेज "स्कक": लिंक पर विचार किया है ? यह सीधे FEN स्ट्रिंग ले सकता है।

— U. Hjort

Answer 1

जैसा कि थब ने बताया है, आपको वैक्टर चाहिए। मेरा सुझाव है कि आप एसवीजी वेक्टर छवियों को उत्पन्न करने के लिए एक अजगर-शतरंज का उपयोग करें।

आवश्यक शर्तें:

1. पायथन 2.6+ या 3.3+
2. अजगर-शतरंज :
   • पिप का उपयोग करके फॉर्म पिपी स्थापित करें :pip install python-chess[uci,gaviota]

एक स्क्रिप्ट बनाना

चूंकि आपको कई एसवीजी उत्पन्न करने की आवश्यकता हो सकती है, आइए एक स्क्रिप्ट बनाएं। तो, आप आसानी से कई शतरंज बोर्ड बनाने के लिए स्क्रिप्ट का उपयोग कर सकते हैं। निम्नलिखित पायथन 3.x में लिखा गया है। उदाहरण के लिए पायथन स्क्रिप्ट, FENtoSVG.py बनाएं। निम्नलिखित कोड डालें:

import chess, sys
from chess import svg
'''
This imports python-chess module and sys module. 
Python-chess will generate the boards while sys.argv will take 
arguments for your script.
'''
svgstomake = (list(sys.argv))[1:]
for svgs in svgstomake:
    board = chess.Board(svgs)
    nameoffile = svgs.replace("/", "")+".SVG"
    boardsvg = chess.svg.board(board = board)
    filetowriteto = open(nameoffile, "w")
    filetowriteto.write(boardsvg)
    filetowriteto.close()

यदि आप लिनक्स पर हैं, तो स्क्रिप्ट शुरू करें #!/usr/bin/env python3।

प्रयोग

अब, यह एक बहुत ही सरल स्क्रिप्ट है यदि आप अजगर जानते हैं, लेकिन मैं इसे उन लोगों के लिए सरल रखना चाहता हूं जो कोड नहीं करते हैं। स्क्रिप्ट का उपयोग करने के लिए, सीएमडी / टर्मिनल खोलें जहां आपने स्क्रिप्ट को सहेजा है। फिर, निम्नानुसार उपयोग करें:

./FENtoSVG.py "examplefen" "morefen"

कहो कि मुझे FEN के लिए दो SVG चाहिए "8/8/8/8/4N3/8/8/8 w - - 0 1"और "8/8/8/8/4Q3/8/8/8 w - - 0 1" , मैं दर्ज करूंगा:

./FENtoSVG.py "8/8/8/8/4N3/8/8/8 w - - 0 1" "8/8/8/8/4Q3/8/8/8 w - - 0 1"

यह दो फाइलें बनाएगा: 88884N3888 w - - 0 1.SVGऔर88884Q3888 w - - 0 1.SVG

मैं उन अनुकूलन के कारण अजगर-शतरंज का सुझाव देता हूं जो अंतर्निर्मित कार्यों का उपयोग करके आसानी से आरेख में किए जा सकते हैं। यह अच्छी तरह से प्रलेखित भी है।

Comments

स्पष्ट, उपयोग में आसान और व्यापक सिफारिश के लिए बधाई @Fluxenein। मैं अपनी प्रकाशन आवश्यकताओं के लिए इस दृष्टिकोण पर एक नज़र डाल रहा हूं। समुदाय में आपका स्वागत है!

— यक्ष

धन्यवाद! यह अभी भी मेरे लिए एक कठिन काम है, इसलिए मैं शायद तब तक अपडेट करता रहूंगा जब तक मैं अपनी जरूरतों के लिए एक तेज पर्याप्त समाधान नहीं बना लेता / पाती हूं।

— MrFregg 7

इनाम को पुरस्कृत करना क्योंकि यह अब तक का सबसे अच्छा है, लेकिन हमारे पास शब्द प्रसंस्करण के साथ अच्छी तरह से एकीकृत होने के लिए जाने के लिए एक रास्ता है।

— एंड्रयू लाजर

एक महान पुस्तकालय पर महान सुझाव। क्या अंतिम चाल या बोर्ड की शैली के लिए तीरों को निर्दिष्ट करने का एक उदाहरण है? स्पष्ट करने के लिए - यह नहीं करना चाहते हैं ।/FENtoSVG.py, बल्कि मेरी अपनी स्क्रिप्ट में अजगर-शतरंज के माध्यम से।

— जो

Answer 2

एक सदिश प्रारूप सूट करेगा।

जैसा कि आप जानते हैं, एक वेक्टर प्रारूप ग्राफिक का एक बिटमैप के रूप में नहीं बल्कि ज्यामितीय रूप से, एक गणितीय विवरण के रूप में प्रतिनिधित्व करता है जिसे किसी भी पैमाने पर प्रदान किया जा सकता है।

वेब प्रदर्शन के लिए, आप एसवीजी प्रारूप का उपयोग कर सकते हैं। यहां एसवीजी प्रारूप में कुछ शतरंज हैं। (यदि आप लिंक का अनुसरण करते हैं, तो प्रत्येक शतरंज के लिए, "मूल फ़ाइल (SVG फ़ाइल) पर क्लिक करें। जब तक आप क्लिक नहीं करेंगे, तब तक आपको प्राप्त होने वाला सभी बिटमैप, PNG सन्निकटन SVG के लिए होगा। आप वास्तविक SVG चाहते हैं।"

पीडीएफ डिस्प्ले के लिए, TeX में कई पैकेज हैं जिनका आप उपयोग कर सकते हैं। यहाँ एक सूची है। (यह केवल तभी सुविधाजनक है जब आप TeX या LaTeX से परिचित हों; लेकिन परिणामी आरेख अच्छे हैं। उदाहरण के लिए, इस PDF उदाहरण को Skak शैली में देखें। 4 , इसके अलावा, मेरा मानना ​​है कि इस PDF का पृष्ठ 4 दिखाता है। श्वाल्बे-शतरंज शैली, जिसे आप पसंद कर सकते हैं, हालाँकि इसका दस्तावेज़ीकरण सभी जर्मन में लगता है। ये सभी खुले स्रोत हैं, किसी भी दर पर।)

Comments

मुझे लगता है कि आपके पिछले उदाहरण (सद्भाव) में चित्र निम्न गुणवत्ता के हैं। सफेद वर्ग बहुत कम क्षैतिज स्थान का उपयोग करते हैं, इसलिए वे एच-फाइल और बोर्ड के किनारे के बीच बड़े अंतराल को छोड़कर बाईं ओर बहुत दूर हैं। वे चित्र मुझे ऐसे लगते हैं जैसे कि वे लाटेक्स पैकेज "शतरंज-समस्या-चित्र" के साथ बनाए गए थे, जो कि ctan.org/tex-archive/macros/latex/contrib/… पर उपलब्ध है । मैंने उस पैकेज का उपयोग करके जो आरेख बनाए हैं, वही बग हैं।

— रोजी एफ

Answer 3

मेरा समाधान शतरंज मेरिडा या शतरंज मामलों की तरह एक शतरंज फ़ॉन्ट का उपयोग किया गया है ।

उदाहरण के लिए इस तरह के एक फ़ॉन्ट के साथ शुरुआत की स्थिति इस तरह से लिखी गई है:

1222222223
4tMvWlVmT5
4OoOoOoOo5
4 + + + +5
4+ + + + 5
4 + + + +5
4+ + + + 5
4pPpPpPpP5
4RnBqKbNr5
7888888889

और (यह मानते हुए कि लाइन-ऊंचाई फ़ॉन्ट की ऊंचाई पर सेट है) यह इस तरह दिखता है (यहाँ फ़ॉन्ट के रूप में शतरंज मेरिडा का उपयोग करते हुए ):

इसलिए मैंने यह पायथन लिपि लिखी जो फेन से इस प्रारूप में परिवर्तित हो गई। इस स्क्रिप्ट को कॉल करें (मान लें कि आपने इसे fen2diag.py नाम दिया है ) python fen2diag.py "<the fen>"और यह डायग्राम स्ट्रिंग को प्रिंट करता है।

import sys


def fen2diag(fen, borders=False):
    """
    Convert a fen to a diagram string used by fonts like
    'Chess Merida' and 'Chess Cases'.

    fen:        The fen. For example the fen for the startposition is
                'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1'.
    borders:    If the returned diagram string shall have borders.

    Returns the diagram string.
    """

    # We dont need anything except the piece positions.
    fen = fen[:fen.find(' ')]

    # Transposition table for the black pieces.
    # White pieces are the same in both formats.
    t = {'k': 'l', 'q': 'w', 'r': 't', 'b': 'v', 'n': 'm', 'p': 'o'}

    # If the current square is a white square or not.
    w = False

    def todiagletter(fenletter):
        """"
        Return the diagram letter corresponding to the letter in the fen.
        """

        nonlocal borders, w
        w = not w
        if fenletter == '/':
            # In the diagram font these are the characters for the diagram borders:
            # '1' upper left, '2' upper, '3' upper right,
            # '4' left, '5' right,
            # '7' bottom left, '8' bottom, '9' bottom right
            return '5\n4' if borders else '\n'
        else:
            # this code handles numbers in the fen, denoting empty squares.
            try:
                # this is a number between 1 and 8.
                n = int(fenletter)

                # This will be a string denoting empty squares.
                # Would be eg. ' + + + +' for an empty eight rank.
                spaces = []

                while n > 0:
                    # In the diagram font ' ' denotes a white square
                    # and '+' denotes a black square.
                    spaces.append(' ' if w else '+')

                    w = not w
                    n -= 1
                w = not w
                return ''.join(spaces)

            # this code handles piece letters in the fen.
            except ValueError:
                # a black piece
                if fenletter in t:
                    fenletter = t[fenletter]

                # In the diagram font lowercase letters denote
                # pieces on white squares and uppercase letters
                # denote pieces on black squares.
                return fenletter.lower() if w else fenletter.upper()

    diagram = ''.join(map(todiagletter, fen))
    if borders:
        return f'1222222223\n4{diagram}5\n7888888889'
    else:
        return diagram


if __name__ == '__main__':
    print(fen2diag(sys.argv[1], borders=True))

ये आरेख फोंट भी डॉट्स या सितारों के साथ चिह्नित वर्गों का समर्थन करते हैं, एक अन्य प्रकार की सीमा, गोल बॉर्डर कोनों, पंक्तियों / स्तंभों को दर्शाते हुए बाईं / नीचे की सीमाओं पर संख्या / अक्षर। मैंने इसे स्क्रिप्ट में शामिल नहीं किया है। मेरा कोड अपडेट करने के लिए स्वतंत्र महसूस करें।

चेसबेस ने एक फ़ॉन्ट परिवार भी बनाया है ('डायग्राम टीटी ...' से शुरू होने वाला) जो और भी अधिक सामान का समर्थन करता है (जैसे कि टुकड़े 180 °)। पृष्ठभूमि के लिए और एक टुकड़ा के लिए।