java - atscript - जावास्क्रिप्ट इन भाषाओं से प्रेरित




मैं जावा या जावास्क्रिप्ट का उपयोग कर एएससीआईआई कला को HTML में कैसे पार्स कर सकता हूं? (3)

मैंने देखा कि Neo4j API एएससीआईआई कला का उपयोग बहुत ही चतुराई से अपने एपीआई के साथ करता है:

http://jaxenter.com/getting-started-with-neo4j-the-java-graph-database-47955.html

मैं कुछ इसी तरह की कोशिश करना चाहता हूं, लेकिन एएससीआई आर्ट टू एचटीएमएल के साथ कैसे एएससीसीआई कला को पार्स किया जा सकता है, उदाहरण के लिए, एएससीआईआई कला इनपुट की तरह कुछ दिया गया है:

--------------------------------
I                              I
I   -------          -------   I
I   I     I          I     I   I
I   I  A  I          I  B  I   I
I   I     I          I     I   I
I   -------          -------   I
I                              I
I                              I
--------------------------------

: एचटीएमएल आउटपुट की तरह कुछ परिणाम हो सकता है:

<div>
    <div style='display:inline;'>
             A
    </div>
    <div style='display:inline;'>
             B
    </div>
</div>

अद्यतन करें

सवाल यह कहते हुए बंद कर दिया गया था कि "मुझे समस्या हल करने की एक न्यूनतम समझ प्रदर्शित करने की आवश्यकता है।" मुझे हल की समस्या की समझ है। समस्या यह है कि मैं हल करना चाहता हूँ कि टेम्पलेट एचटीएमएल को निम्नलिखित वेब ढांचे के लिए स्रोत कोड में समझना आसान हो:

https://github.com/zubairq/coils

: हालांकि समाधान किसी भी वेब ढांचा पर लागू किया जा सकता है मैंने देखा है कि किसी ने सी ++ में एक प्रारंभिक संस्करण बनाने का प्रयास किया है:

https://github.com/h3nr1x/asciidivs2html/blob/master/asciidivs2html.cpp

: बहुत प्रभावशाली! यदि आप इसे जावा या क्लोज़र में काम कर सकते हैं तो अगर हम सवाल फिर से खोल सकते हैं तो मैं एक इनाम नामित करेगा ताकि आप समाधान के लिए अधिक अंक प्राप्त कर सकें :)

मैं @ मेवॉक द्वारा प्रदान किए गए जावा समाधान को चलाया और यहाँ परिणाम है:

$ java AsciiToDIVs.RunConverter
Created a box(ID=0,X=0,Y=0,width=33,height=10)
Created a box(ID=1,X=2,Y=4,width=8,height=5,parent=0)
Created a char(Char=A,X=4,Y=7,parent=1)
Created a box(ID=2,X=2,Y=21,width=8,height=5,parent=0)
Created a char(Char=B,X=4,Y=24,parent=2)
<div><div><div>A</div></div><div><div>B</div></div></div>

क्रियाविधि

कार्यान्वयन का समाधान निम्नलिखित है:

  • मेमोरी 2 डी सरणी (सरणियों का सरणी) बनाएँ जो कि एक शतरंज के समान है

तब मैं एक एल्गोरिथ बनाऊँगा, जब यह वर्णों का पता लगाता है, तो मैं वर्णों के बाद शेष कोनों (ऊपर दाएं, नीचे बाएं, नीचे दाएं) का पता लगाने के लिए एक विधि को एवलल करना प्रारंभ करता हूं और जहां उनका अंत होता है।

उदाहरण (त्वरित प्यूडोकोड):

while(selectedCell==I) selectedCell=selectedCell.goDown();

ऐसी रणनीति का उपयोग करके आप अपने बक्से को मैप कर सकते हैं और किस बक्से में निहित हैं

शेष को इस जानकारी को HTML के रूप में प्रिंट करना होगा ..

त्वरित और गंदे कार्यान्वयन

चूंकि मैं मूड में था इसलिए मैंने खिलौना कार्यान्वयन को जल्दी से पकाने के लिए एक घंटे खर्च किया। नीचे के संदर्भ में गैर-ऑप्टिमाइज़ किया गया है कि मैं कोशिकाओं पर जाने के लिए Iterators का उपयोग नहीं करता, और एक गंभीर रूपरेखा बनने के लिए पुनर्संरचना की आवश्यकता होगी।

Cell.java

package AsciiToDIVs;

public class Cell {
    public char Character;
    public CellGrid parentGrid;
    private int rowIndex;
    private int colIndex;

    public Cell(char Character, CellGrid parent, int rowIndex, int colIndex)
    {
        this.Character = Character;
        this.parentGrid = parent;
        this.rowIndex = rowIndex;
        this.colIndex = colIndex;
    }

    public int getRowIndex() {
        return rowIndex;
    }

    public int getColIndex() {
        return colIndex;
    }
}

CellGrid.java

package AsciiToDIVs;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;

public class CellGrid {

    private ArrayList<ArrayList<Cell>> CellGridData;

    public CellGrid(String asciiFile) throws IOException {
        readDataFile(asciiFile);
    }

    public ArrayList<FoundObject> findBoxes(FoundBoxObject parent)
    {

        int startRowIndex = 0, startColIndex = 0, 
                parentRowLimit = Integer.MAX_VALUE, 
                parentColLimit = Integer.MAX_VALUE,
                startingColIndex = 0;
        if(parent != null)
        {
            startRowIndex = parent.getRowIndex()+1;
            startColIndex = startingColIndex =  parent.getColIndex()+1;
            parentRowLimit = parent.getRowIndex() + parent.getHeight();
            parentColLimit = parent.getColIndex() + parent.getWidth();
        }

        ArrayList<FoundObject> results = new ArrayList<FoundObject>();

        Cell currentCell;

        if(startRowIndex>=CellGridData.size())
        return null;        

        for(; startRowIndex<CellGridData.size() && startRowIndex<parentRowLimit; startRowIndex++ )
        {
            startColIndex = startingColIndex;

            for(; startColIndex< CellGridData.get(startRowIndex).size() && startColIndex<parentColLimit; startColIndex++)
            {           
                FoundBoxObject withinBox = checkWithinFoundBoxObject(results, startRowIndex, startColIndex);

                if(withinBox !=null)
                startColIndex+=withinBox.getWidth();

                currentCell = getCell(startRowIndex, startColIndex);

                if(currentCell!=null)
                {
                    if(currentCell.Character == '-') // Found a TOP-CORNER
                    {
                        int boxHeight =  getConsecutiveIs(startRowIndex+1, startColIndex) + 1;
                        if(boxHeight>1)
                        {
                            int boxWidth = getConsecutiveDashes(startRowIndex, startColIndex);

                            FoundBoxObject box = new FoundBoxObject(startRowIndex, startColIndex, boxWidth, boxHeight, parent);
                            results.add(box);
                            findBoxes(box);

                            startColIndex+=boxWidth;                            
                        }                   
                    }

                    //This is a character
                    else if(currentCell.Character != '-' && currentCell.Character != 'I' && currentCell.Character != ' ' 
                            && currentCell.Character != '\n' && currentCell.Character != '\n' && currentCell.Character != '\t')
                    {
                        FoundCharObject Char = new FoundCharObject(startRowIndex, startColIndex, parent,  currentCell.Character);
                        results.add(Char);
                    }
                }
            }       
        }

        if(parent!=null)
        parent.containedObjects = results;

        return results;     
    }

    public static String printDIV(ArrayList<FoundObject> objects)
    {
        String result = "";
        Iterator<FoundObject> it = objects.iterator();
        FoundObject fo;

        while(it.hasNext())
        {
            result+="<div>";

            fo = it.next();

            if(fo instanceof FoundCharObject)
            {
                FoundCharObject fc = (FoundCharObject)fo;
                result+=fc.getChar();
            }

            if(fo instanceof FoundBoxObject)
            {
                FoundBoxObject fb = (FoundBoxObject)fo;
                result+=printDIV(fb.containedObjects);
            }

            result+="</div>";
        }

        return result;
    }

    private FoundBoxObject checkWithinFoundBoxObject(ArrayList<FoundObject> results, int rowIndex, int colIndex)
    {
        Iterator<FoundObject> it = results.iterator();
        FoundObject f;
        FoundBoxObject fbox = null;
        while(it.hasNext())
        {
            f = it.next();

            if(f instanceof FoundBoxObject)
            {
                fbox = (FoundBoxObject) f;

                if(rowIndex >= fbox.getRowIndex() && rowIndex <= fbox.getRowIndex() + fbox.getHeight())
                {
                    if(colIndex >= fbox.getColIndex() && colIndex <= fbox.getColIndex() + fbox.getWidth())
                    {
                        return fbox;
                    }
                }
            }
        }

        return null;
    }

    private int getConsecutiveDashes(int startRowIndex, int startColIndex)
    {
        int counter = 0;
        Cell cell = getCell(startRowIndex, startColIndex);

        while( cell!=null && cell.Character =='-')
        {
            counter++;
            cell = getCell(startRowIndex, startColIndex++);
        }

        return counter;

    }

    private int getConsecutiveIs(int startRowIndex, int startColIndex)
    {
        int counter = 0;
        Cell cell = getCell(startRowIndex, startColIndex);

        while( cell!=null && cell.Character =='I')
        {
            counter++;
            cell = getCell(startRowIndex++, startColIndex);
        }

        return counter;
    }

    public Cell getCell(int rowIndex, int columnIndex)
    {
        ArrayList<Cell> row;


        if(rowIndex<CellGridData.size())
        row = CellGridData.get(rowIndex);
        else return null;

        Cell cell = null;

        if(row!=null){
            if(columnIndex<row.size())
            cell = row.get(columnIndex);
        }

        return cell;
    }


    public Iterator<ArrayList<Cell>> getRowGridIterator(int StartRow) {
        Iterator<ArrayList<Cell>> itRow = CellGridData.iterator();

        int CurrentRow = 0;

        while (itRow.hasNext()) {
            // Itrate to Row
            if (CurrentRow++ < StartRow)
                itRow.next();

        }
        return itRow;
    }

    private void readDataFile(String asciiFile) throws IOException {
        CellGridData = new ArrayList<ArrayList<Cell>>();
        ArrayList<Cell> row;

        FileInputStream fstream = new FileInputStream(asciiFile);
        BufferedReader br = new BufferedReader(new InputStreamReader(fstream));

        String strLine;

        // Read File Line By Line
        int rowIndex = 0;
        while ((strLine = br.readLine()) != null) {
            CellGridData.add(row = new ArrayList<Cell>());
            // System.out.println (strLine);
            for (int colIndex = 0; colIndex < strLine.length(); colIndex++) {
                row.add(new Cell(strLine.charAt(colIndex), this, rowIndex,colIndex));
                // System.out.print(strLine.charAt(i));
            }
            rowIndex++;
            // System.out.println();
        }

        // Close the input stream
        br.close();
    }

    public String printGrid() {
        String result = "";

        Iterator<ArrayList<Cell>> itRow = CellGridData.iterator();
        Iterator<Cell> itCol;
        Cell cell;

        while (itRow.hasNext()) {
            itCol = itRow.next().iterator();

            while (itCol.hasNext()) {
                cell = itCol.next();
                result += cell.Character;
            }
            result += "\n";
        }

        return result;
    }

}

FoundBoxObject.java

package AsciiToDIVs;

import java.util.ArrayList;

public class FoundBoxObject extends FoundObject {
    public ArrayList<FoundObject> containedObjects = new ArrayList<FoundObject>();
    public static int boxCounter = 0;

    public final int ID = boxCounter++;

    public FoundBoxObject(int rowIndex, int colIndex, int width, int height, FoundBoxObject parent) {
        super(rowIndex, colIndex, width, height);

        if(parent!=null)
        System.out.println("Created a box(" +
                "ID="+ID+
                ",X="+rowIndex+
                ",Y="+colIndex+
                ",width="+width+
                ",height="+height+
                ",parent="+parent.ID+")");
        else
            System.out.println("Created a box(" +
                    "ID="+ID+
                    ",X="+rowIndex+
                    ",Y="+colIndex+
                    ",width="+width+
                    ",height="+height+
                    ")");   
    }

}

FoundCharObject.java

package AsciiToDIVs;

public class FoundCharObject extends FoundObject {
private Character Char;

public FoundCharObject(int rowIndex, int colIndex,FoundBoxObject parent, char Char) {
    super(rowIndex, colIndex, 1, 1);

    if(parent!=null)
    System.out.println("Created a char(" +
            "Char="+Char+
            ",X="+rowIndex+
            ",Y="+colIndex+
            ",parent="+parent.ID+")");
    else
        System.out.println("Created a char(" +
                ",X="+rowIndex+
                ",Y="+colIndex+")");

    this.Char = Char;
}

public Character getChar() {
    return Char;
}
}

FoundObject.java

package AsciiToDIVs;

public class FoundObject {

    private int rowIndex;
    private int colIndex;
    private int width = 0;
    private int height = 0;

    public FoundObject(int rowIndex, int colIndex, int width, int height )
    {
        this.rowIndex = rowIndex;
        this.colIndex = colIndex;
        this.width = width;
        this.height = height;
    }

    public int getRowIndex() {
        return rowIndex;
    }

    public int getColIndex() {
        return colIndex;
    }

    public int getWidth() {
        return width;
    }

    public int getHeight() {
        return height;
    }
}

मुख्य विधि

public static void main(String args[])
    {
        try {
            CellGrid grid = new CellGrid("ascii.txt");
            System.out.println(CellGrid.printDIV(grid.findBoxes(null)));
            //System.out.println(grid.printGrid());
        } catch (IOException e) {
            e.printStackTrace();
        }       
    }   

अद्यतन करें

'PrintDIV' को इस तरह होना चाहिए (आवश्यक से अधिक मुद्रित किया जा रहा था)

public static String printDIV(ArrayList<FoundObject> objects)
    {
        String result = "";
        Iterator<FoundObject> it = objects.iterator();
        FoundObject fo;

        while(it.hasNext())
        {
            fo = it.next();

            if(fo instanceof FoundCharObject)
            {
                FoundCharObject fc = (FoundCharObject)fo;
                result+=fc.getChar();
            }

            if(fo instanceof FoundBoxObject)
            {
                result+="<div>";
                FoundBoxObject fb = (FoundBoxObject)fo;
                result+=printDIV(fb.containedObjects);
                result+="</div>";
            }           
        }

        return result;
    }

आपको क्या चाहिए 2-आयामी पार्सिंग का विचार है, जो 2 डी संस्थाओं का पता लगाता है और पुष्टि करता है कि उनके पास वैध संबंध हैं।

देखें http://mmi.tudelft.nl/pub/siska/TSD%202DVisLangGrammar.pdf

संभव "एएससीआईआई आर्ट" बाधाओं के सेट को परिभाषित करना क्या मुश्किल होगा क्या आप केवल पत्र पहचानना चाहते हैं? केवल वही अक्षर वाले पात्रों के बने? "घुमंत" पत्र? बक्से? (आपके उदाहरण के ऐसे बॉक्स हैं जिनके पक्षों को उसी एएससीआईआई वर्ण से नहीं बनाया गया है)। मनमाना मोटी दीवारों के साथ बॉक्स? नेस्टेड बक्से? (पतली / वसा) तीरों के साथ आरेख? किलरॉय-था-यहाँ-नाक-ओवर-द-दीवार? मोना लिसा की चित्रों में कौन से वर्ण पिक्सल घनत्व संबंध प्रदान करते हैं? "एएससीआईआई कला" से आप वास्तव में क्या मतलब है?

वास्तविक समस्या उन चीजों की श्रेणी को परिभाषित कर रही है जिन्हें आप पहचानना चाहते हैं यदि आप उस सीमा को सीमित करते हैं, तो सफलता की आपके बाधाएं बढ़ जाती हैं (संदर्भित पेपर देखें)

यहां समस्या जावा या जावास्क्रिप्ट के साथ विशेष रूप से करने के लिए बहुत कम है यह एल्गोरिदम से कहीं अधिक संबंधित है कला का एक सीमित वर्ग चुनें, सही एल्गोरिदम चुनें, और उसके बाद आपके पास एक कोडिंग समस्या है जिसे हल करना अपेक्षाकृत आसान होना चाहिए। कोई सीमा नहीं, कोई एल्गोरिदम नहीं -> जावास्क्रिप्ट की कोई भी राशि आपको बचाएगी नहीं।


यहां जावास्क्रिप्ट में काफी आसान समाधान है, नोड के माध्यम से परीक्षण किया गया है। बेशक, आपको इनपुट और आउटपुट विधियों को समायोजित करने की आवश्यकता होगी।

var s = "\n\
--------------------------------\n\
I                              I\n\
I   -------          -------   I\n\
I   I     I          I     I   I\n\
I   I  A  I          I  B  I   I\n\
I   I     I          I     I   I\n\
I   -------          -------   I\n\
I                              I\n\
I                              I\n\
--------------------------------\n\
";

var lines = s.split('\n');

var outer_box_top_re = /--+/g;

var i;
for (i=0; i<lines.length; i++) {
    while ((res = outer_box_top_re.exec(lines[i])) != null) {
        L = res.index
        R = outer_box_top_re.lastIndex
        process_box(i, L, R)
    }
}

function process_box(T, L, R) {
    console.log('<div top="' + T + '" left="' + L + '" right="' + R + '">')
    blank_out(T, L, R)

    var i = T;
    while (1) {
        i += 1;
        if (i >= lines.length) {
            console.log('Fell off bottom of ascii-art without finding bottom of box');
            process.exit(1);
        }

        var line = lines[i];

        if (line[L] == 'I' && line[R-1] == 'I') {
            // interior

            // Look for (the tops of) sub-boxes.
            // (between L+1 and R-2)
            var inner_box_top_re = /--+/g;
            // Inner and outer need to be separate so that
            // inner doesn't stomp on outer's lastIndex.
            inner_box_top_re.lastIndex = L+1;
            while ((res = inner_box_top_re.exec(lines[i])) != null) {
                sub_L = res.index;
                sub_R = inner_box_top_re.lastIndex;
                if (sub_L > R-1) { break; }
                process_box(i, sub_L, sub_R);
            }

            // Look for any other content (i.e., a box label)
            content = lines[i].substring(L+1, R-1);
            if (content.search(/[^ ]/) != -1) {
                console.log(content);
            }

            blank_out(i, L, R);
        }
        else if (line.substring(L,R).match(/^-+$/)) {
            // bottom
            blank_out(i, L, R);
            break;
        }
        else {
            console.log("line " + i + " doesn't contain a valid continuation of the box");
            process.exit(1)
        }
    }

    console.log('</div>')
}

function blank_out(i, L, R) {
    lines[i] = (
          lines[i].substring(0,L)
        + lines[i].substring(L,R).replace(/./g, ' ')
        + lines[i].substring(R)
    );
}





ascii-art