HYTOS

# coding: utf-8

""" This is xml generator module """

from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse

import symbol

import SymbolBase

import TextInfo as ti

import math

import os

import sys

from AppDocData import AppDocData

ROOT_NODE_NAME = "DWG"

ROOT_DWGNAME_NODE_NAME = "DWGNAME"

ROOT_SIZE_NODE_NAME = "SIZE"

SYMBOL_LIST_NODE_NAME = "SYMBOLS"

TEXT_INFO_LIST_NODE_NAME = "TEXTINFOS"

IMG_LINE_LIST_NODE_NAME = "IMGLINES"

NOTE_TEXT_INFO_LIST_NOTE_NAME = "NOTES"

SCATEGORY_NODE_NAME = "SYMBOL"

SNAME_NODE_NAME = "NAME"

STYPE_NOTE_NAME = "TYPE"

SCLASS_NODE_NAME = "CLASS"

SITEM_NODE_NAME = "ITEM"

SSUB_TEXT = "TEXT"

SSUB_ORIGINAL_POINT = "ORIGINALPOINT"

SSUB_CONNECTION_POINT = "CONNECTIONPOINT"

SSUB_PARENT = "PARENT"

SSUB_CHILD = "CHILD"

SSUB_ANGLE = "ANGLE"

SSUB_START_POINT = "STARTPOINT"

SSUB_SIZE = "SIZE"

LINE_NO_LIST_NODE_NAME = "LINE_NOS"

TEXT_INFO_NODE_NAME = "TEXTINFO"

TTEXT_NODE_NAME = "TEXT"

TTEXT_X_NODE_NAME = "X"

TTEXT_Y_NODE_NAME = "Y"

TTEXT_WIDTH_NODE_NAME = "WIDTH"

TTEXT_HEIGHT_NODE_NAME = "HEIGHT"

TTEXT_ANGLE_NODE_NAME = "ANGLE"

IMG_LINE_NODE_NAME = "IMGLINE"

ISP_NODE_NAME = "START"

IEP_NODE_NAME = "END"

NOTE_TEXT_INFO_NOTE_NAME = "NOTE"

TNOTE_TEXT_NODE_NAME = "TEXT"

TNOTE_TEXT_X_NODE_NAME = "X"

TNOTE_TEXT_Y_NODE_NAME = "Y"

TNOTE_TEXT_WIDTH_NODE_NAME = "WIDTH"

TNOTE_TEXT_HEIGHT_NODE_NAME = "HEIGHT"

TNOTE_TEXT_ANGLE_NODE_NAME = "ANGLE"

LINE_INFOS_NODE_NAME = "LINEINFOS"

LLINE_INFO_NODE_NAME = "LINEINFO"

LLINE_UUID = "UUID"

LLINE_START_POINT_NODE_NAME = "STARTPOINT"

LLINE_END_POINT_NODE_NAME = "ENDPOINT"

LINE_NOS_NODE_NAME = "LINENOS"

TRIM_LINE_NOS_NODE_NAME = "TRIMLINENOS"

UNKNOWNS_NODE_NAME = "UNKNOWNS"

VENDOR_NODE_NAME = "VENDORS"

# END_BREAK = "END_BREAKS"

'''

    @brief  

    @author 

    @date   

    @history    2018.05.25  Jeongwoo    Remove parameter 'imgLineList'

'''

def writeXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList):

    path = os.path.join(AppDocData.instance().getCurrentProject().getTempPath(), pidName + '.xml')

    try:

        xmlData = generateXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList)

        ElementTree(xmlData).write(path)

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        print(message)

        App.mainWnd().addMessage.emit(MessageType.Error, message)

    return path

'''

    @brief  write output xml

    @author humkyung

    @date   2018.04.23

'''

def writeOutputXml(pidName, pidWidth, pidHeight):

    try:

        path = os.path.join(AppDocData.instance().getCurrentProject().getOutputPath(), pidName + '.xml')

        xmlData = generateOutputXml(pidName, pidWidth, pidHeight)

        ElementTree(xmlData).write(path)

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        print(message)

        App.mainWnd().addMessage.emit(MessageType.Error, message)

    return path

'''

    @brief      generate output xml for converter

    @author     humkyung

    @date       2018.04.23

    @history    humkyung 2018.05.02 write equipment node

                humkyung 2018.05.10 write orphan lines

                humkyung 2018.05.16 remove code to write orphan lines and symbols

                humkyung 2018.09.06 write text to xml

'''

def generateOutputXml(pidName, pidWidth, pidHeight):

    appDocData = AppDocData.instance()

    try:

        xml = Element(ROOT_NODE_NAME)  # Root Node

        SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

        SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

        SubElement(xml, 'UNIT').text = appDocData.getCurrentProject().unit()

        for equipment in appDocData.equipments:

            equipmentNode = Element('EQUIPMENT')

            equipmentNode.append(equipment.toXml())

            xml.append(equipmentNode)

        sortedList = sorted(appDocData.lineNos, key=lambda param: param.text())

        for lineno in sortedList:

            xml.append(lineno.toXml())

        for text in appDocData.texts:

            xml.append(text.toXml())

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        print(message)

        App.mainWnd().addMessage.emit(MessageType.Error, message)

    return xml

'''

    @history    2018.04.30  Jeongwoo    noteTextInfoList None Check

                2018.05.25  Jeongwoo    Remove parameter 'imgLineList' and Check if variable is None or not

'''

def generateXml(pidName, pidWidth, pidHeight, searchedSymbolList, textInfoList, noteTextInfoList):

    xml = Element(ROOT_NODE_NAME)  # Root Node

    SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = pidName

    SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

    try:

        if searchedSymbolList is not None:

            symbolListNode = Element(SYMBOL_LIST_NODE_NAME)  # Symbol List Node

            sortedList = sorted(searchedSymbolList, key=lambda sym: sym.getName())

            for symbol in sortedList:

                node = getSymbolInfoNode(symbol)

                symbolListNode.append(node)

            xml.append(symbolListNode)

        if textInfoList is not None:

            textInfoListNode = Element(TEXT_INFO_LIST_NODE_NAME)  # Text Info List Node

            for textInfo in textInfoList:

                node = getTextInfoNode(textInfo)

                textInfoListNode.append(node)

            xml.append(textInfoListNode)

        noteTextInfoListNode = Element(NOTE_TEXT_INFO_LIST_NOTE_NAME)

        if noteTextInfoList is not None:

            for noteTextInfo in noteTextInfoList:

                node = getNoteTextInfoNode(noteTextInfo)

                noteTextInfoListNode.append(node)

        xml.append(noteTextInfoListNode)

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        print(message)

        App.mainWnd().addMessage.emit(MessageType.Error, message)

    return xml

def getSymbolInfoNode(symbol):

    sName = symbol.getName()

    sSp = symbol.getSp()

    sAngle = symbol.getRotatedAngle()

    sType = symbol.getType()

    sText = symbol.getText()

    sOriginalPoint = symbol.getOriginalPoint()

    sConnectionPoint = symbol.getConnectionPoint()

    sWidth = symbol.getWidth()

    sHeight = symbol.getHeight()

    sBaseSymbol = symbol.getBaseSymbol()

    sAdditionalSymbol = symbol.getAdditionalSymbol()

    sCategoryNode = Element(SCATEGORY_NODE_NAME)

    sNameNode = Element(SNAME_NODE_NAME)

    sNameNode.text = sName

    sTypeNode = Element(STYPE_NOTE_NAME)

    sTypeNode.text = sType

    sOriginalPointNode = Element(SSUB_ORIGINAL_POINT)

    sOpX = sSp[0] + int(sOriginalPoint.split(',')[0])

    sOpY = sSp[1] + int(sOriginalPoint.split(',')[1])

    sOriginalPointNode.text = str(sOpX) + "," + str(sOpY)

    sConnectionPointNode = Element(SSUB_CONNECTION_POINT)

    convertedConnectionPoint = ""

    if sConnectionPoint:

        splitConnectionPoint = sConnectionPoint.split("/")

        for index in range(len(splitConnectionPoint)):

            if index != 0:

                convertedConnectionPoint = convertedConnectionPoint + "/"

            item = splitConnectionPoint[index]

            sCpX = sSp[0] + int(item.split(',')[0])

            sCpY = sSp[1] + int(item.split(',')[1])

            tempStr = str(sCpX) + "," + str(sCpY)

            convertedConnectionPoint = convertedConnectionPoint + tempStr

    sConnectionPointNode.text = convertedConnectionPoint

    sBaseSymbolNode = Element(SSUB_PARENT)

    sBaseSymbolNode.text = sBaseSymbol

    if sAdditionalSymbol is not None:

        sAdditionalSymbolNode = Element(SSUB_CHILD)

        sAdditionalSymbolNode.text = sAdditionalSymbol

        sCategoryNode.append(sAdditionalSymbolNode)

    sAngleNode = Element(SSUB_ANGLE)

    sAngleNode.text = str(round(math.radians(sAngle), 2))

    sTextNode = Element(SSUB_TEXT)

    sTextNode.text = sText

    sStartPointNode = Element(SSUB_START_POINT)

    sStartPointNode.text = str(sSp[0]) + "," + str(sSp[1])

    sSizeNode = Element(SSUB_SIZE)

    sSizeNode.text = str(sWidth) + "," + str(sHeight)

    sCategoryNode.append(sNameNode)

    sCategoryNode.append(sTypeNode)

    sCategoryNode.append(sOriginalPointNode)

    sCategoryNode.append(sConnectionPointNode)

    sCategoryNode.append(sBaseSymbolNode)

    sCategoryNode.append(sAngleNode)

    sCategoryNode.append(sTextNode)

    sCategoryNode.append(sStartPointNode)

    sCategoryNode.append(sSizeNode)

    return sCategoryNode

def getTextInfoNode(textInfo):

    text = textInfo.getText()

    x = textInfo.getX()

    y = textInfo.getY()

    w = textInfo.getW()

    h = textInfo.getH()

    angle = textInfo.getAngle()

    tInfoNode = Element(TEXT_INFO_NODE_NAME)

    textNode = Element(TTEXT_NODE_NAME)

    textNode.text = text

    xNode = Element(TTEXT_X_NODE_NAME)

    xNode.text = str(x)

    yNode = Element(TTEXT_Y_NODE_NAME)

    yNode.text = str(y)

    widthNode = Element(TTEXT_WIDTH_NODE_NAME)

    widthNode.text = str(w)

    heightNode = Element(TTEXT_HEIGHT_NODE_NAME)

    heightNode.text = str(h)

    angleNode = Element(TTEXT_ANGLE_NODE_NAME)

    angleNode.text = str(round(math.radians(angle), 2))

    tInfoNode.append(textNode)

    tInfoNode.append(xNode)

    tInfoNode.append(yNode)

    tInfoNode.append(widthNode)

    tInfoNode.append(heightNode)

    tInfoNode.append(angleNode)

    return tInfoNode

def getNoteTextInfoNode(noteTextInfo):

    text = noteTextInfo.getText()

    x = noteTextInfo.getX()

    y = noteTextInfo.getY()

    w = noteTextInfo.getW()

    h = noteTextInfo.getH()

    angle = noteTextInfo.getAngle()

    ntInfoNode = Element(NOTE_TEXT_INFO_NOTE_NAME)

    textNode = Element(TNOTE_TEXT_NODE_NAME)

    textNode.text = text

    xNode = Element(TNOTE_TEXT_X_NODE_NAME)

    xNode.text = str(x)

    yNode = Element(TNOTE_TEXT_Y_NODE_NAME)

    yNode.text = str(y)

    widthNode = Element(TNOTE_TEXT_WIDTH_NODE_NAME)

    widthNode.text = str(w)

    heightNode = Element(TNOTE_TEXT_HEIGHT_NODE_NAME)

    heightNode.text = str(h)

    angleNode = Element(TNOTE_TEXT_ANGLE_NODE_NAME)

    angleNode.text = str(round(math.radians(angle), 2))

    ntInfoNode.append(textNode)

    ntInfoNode.append(xNode)

    ntInfoNode.append(yNode)

    ntInfoNode.append(widthNode)

    ntInfoNode.append(heightNode)

    ntInfoNode.append(angleNode)

    return ntInfoNode

'''

    @brief      Append LineInfo Data

    @author     Jeongwoo

    @date       2018.05.28

'''

def appendLineInfo(xmlPath, lineInfo):

    tree = parse(xmlPath)

    root = tree.getroot()

    lineInfosNode = root.find(LINE_INFOS_NODE_NAME)

    if lineInfosNode is not None:

        lineInfosNode.clear()

    else:

        lineInfosNode = Element(LINE_INFOS_NODE_NAME)

        root.append(lineInfosNode)

    for line in lineInfo:

        lineInfoNode = Element(LLINE_INFO_NODE_NAME)

        # uuidNode = Element(LLINE_UUID)

        # uuidNode.text = line.uid

        startPointNode = Element(LLINE_START_POINT_NODE_NAME)

        startPointNode.text = str(line.start_point()[0]) + "," + str(line.start_point()[1])

        endPointNode = Element(LLINE_END_POINT_NODE_NAME)

        endPointNode.text = str(line.end_point()[0]) + "," + str(line.end_point()[1])

        # lineInfoNode.append(uuidNode)

        lineInfoNode.append(startPointNode)

        lineInfoNode.append(endPointNode)

        lineInfosNode.append(lineInfoNode)

    ElementTree(root).write(xmlPath)

def write_to_xml(path, pidWidth, pidHeight, items, tracer_line_nos):

    """write xml data"""

    from EngineeringAbstractItem import QEngineeringAbstractItem

    from EngineeringNoteItem import QEngineeringNoteItem

    from EngineeringTextItem import QEngineeringTextItem

    from EngineeringLineItem import QEngineeringLineItem

    from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

    from EngineeringUnknownItem import QEngineeringUnknownItem

    from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

    from QEngineeringSizeTextItem import QEngineeringSizeTextItem

    from QEngineeringTagNoTextItem import QEngineeringTagNoTextItem

    from EngineeringValveOperCodeTextItem import QEngineeringValveOperCodeTextItem

    from EngineeringReservedWordTextItem import QEngineeringReservedWordTextItem

    from SymbolSvgItem import SymbolSvgItem

    from EngineeringVendorItem import QEngineeringVendorItem

    from EngineeringErrorItem import QEngineeringErrorItem

    from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

    from EngineeringGraphicsLineItem import QEngineeringGraphicsLineItem

    xml = Element(ROOT_NODE_NAME)  # Root Node

    """write boundingbox"""

    app_doc_data = AppDocData.instance()

    areas = app_doc_data.getAreaList()

    matches = [x for x in areas if x.name == 'Size']

    if matches:

        xml.attrib['BoundingBox'] = f"{matches[0].x},{matches[0].y},{matches[0].width},{matches[0].height}"

    """up to here"""

    SubElement(xml, ROOT_DWGNAME_NODE_NAME).text = os.path.splitext(os.path.basename(path))[0]

    SubElement(xml, ROOT_SIZE_NODE_NAME).text = str(pidWidth) + "," + str(pidHeight)

    symbolListNode = Element(SYMBOL_LIST_NODE_NAME)  # Symbol List Node

    textInfoListNode = Element(TEXT_INFO_LIST_NODE_NAME)  # Text Info List Node

    noteTextInfoListNode = Element(NOTE_TEXT_INFO_LIST_NOTE_NAME)

    lineListNode = Element(LINE_INFOS_NODE_NAME)

    lineNoListNode = Element(LINE_NOS_NODE_NAME)

    unknownListNode = Element(UNKNOWNS_NODE_NAME)

    vendorListNode = Element(VENDOR_NODE_NAME)

    node_dictionary = {SymbolSvgItem: symbolListNode, QEngineeringTextItem: textInfoListNode,

                       QEngineeringNoteItem: noteTextInfoListNode,

                       QEngineeringLineItem: lineListNode, QEngineeringGraphicsLineItem: lineListNode,

                       QEngineeringLineNoTextItem: lineNoListNode,

                       QEngineeringUnknownItem: unknownListNode,

                       QEngineeringSizeTextItem: textInfoListNode, QEngineeringValveOperCodeTextItem: textInfoListNode,

                       QEngineeringTagNoTextItem: textInfoListNode,

                       QEngineeringReservedWordTextItem: textInfoListNode, QEngineeringVendorItem: vendorListNode}

    # trim line 추가

    trimLineNoListNode = Element(TRIM_LINE_NOS_NODE_NAME)

    try:

        resultDic = {}

        for item in items:

            key = str(type(item))

            if not key in resultDic:

                resultDic[key] = [0, []]

            node = None

            try:

                if issubclass(type(item), QEngineeringAbstractItem) and type(item) is not QGraphicsBoundingBoxItem and \

                        type(item) is not QEngineeringErrorItem:

                    node = item.toXml()

                else:

                    continue

            except Exception as ex:

                from App import App

                from AppDocData import MessageType

                message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                               sys.exc_info()[-1].tb_lineno)

                App.mainWnd().addMessage.emit(MessageType.Error, message)

            finally:

                pass

            if node:

                resultDic[key][0] += 1

                _type = type(item)

                if issubclass(type(item), SymbolSvgItem): _type = SymbolSvgItem

                if _type in node_dictionary: node_dictionary[_type].append(node)

            else:

                resultDic[key][1].append(str(item.uid))

        for line in tracer_line_nos:

            key = str(type(line))

            if not key in resultDic:

                resultDic[key] = [0, []]

            if issubclass(type(line), QEngineeringTrimLineNoTextItem):

                trimNode = line.toXml()

                if trimNode:

                    resultDic[key][0] += 1

                    trimLineNoListNode.append(trimNode)

                else:

                    resultDic[key][1].append(str(line.uid))

        xml.append(symbolListNode)

        xml.append(textInfoListNode)

        xml.append(noteTextInfoListNode)

        xml.append(lineListNode)

        xml.append(lineNoListNode)

        xml.append(unknownListNode)

        xml.append(trimLineNoListNode)

        xml.append(vendorListNode)

        #ElementTree(xml).write(path)

    except Exception as ex:

        from App import App

        from AppDocData import MessageType

        message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,

                                                       sys.exc_info()[-1].tb_lineno)

        App.mainWnd().addMessage.emit(MessageType.Error, message)

    return xml, resultDic

def indent(elem, level=0):

    i = "\n" + level * "  "

    if len(elem):

        if not elem.text or not elem.text.strip():

            elem.text = i + "  "

        if not elem.tail or not elem.tail.strip():

            elem.tail = i

        for elem in elem:

            indent(elem, level + 1)

        if not elem.tail or not elem.tail.strip():

            elem.tail = i

    else:

        if level and (not elem.tail or not elem.tail.strip()):

            elem.tail = i

    return elem