HYTOS

# coding: utf-8

""" This is Drawing module """

import os

import sys

import uuid

from PIL import PngImagePlugin, JpegImagePlugin

from PIL import Image

from PIL.ImageQt import ImageQt

import numpy as np

from AppDocData import AppDocData

sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)) + '\\Shapes')

from SymbolSvgItem import SymbolSvgItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringLineItem import QEngineeringLineItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringRunItem import QEngineeringRunItem

from EngineeringVendorItem import QEngineeringVendorItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

class Source:

    """ This is Source class """

    def __init__(self, source):

        if type(source) is np.ndarray:

            self.source = Image.fromarray(source)

        elif type(source) is PngImagePlugin.PngImageFile or type(source) is JpegImagePlugin.JpegImageFile:

            self.source = source

        elif type(source) is QImage:

            self.source = Image.fromqimage(source)

        elif type(source) is QPixmap:

            self.source = Image.fromqpixmap(source)

    '''

        @history    2018.05.18  Jeongwoo    When Parameter [rect] is None, return whole image

    '''

    def getPyImageOnRect(self, rect = None):

        if rect is not None:

            return self.source.copy().crop((rect.left(), rect.top(), rect.right(), rect.bottom()))

        else:

            return self.source.copy()

    def getQImageOnRect(self, rect = None):

        image = ImageQt(self.getPyImageOnRect(rect))

        return image.convertToFormat(QImage.Format_RGBA8888)

class Drawing:

    '''

        @brief  construction

        @author humkyung

        @date   2018.07.07

    '''

    def __init__(self, uid, name, datetime):

        import uuid

        app_doc_data = AppDocData.instance()

        self.name = name

        self._datetime = datetime

        ''' set drawing uid '''

        if not uid:

            drawings = app_doc_data.getDrawings()

            drawing = [drawing for drawing in drawings if self.name == os.path.splitext(drawing.name)[0]]

            self.UID = drawing[0].UID if drawing else uuid.uuid4()

            self._datetime = drawing[0].datetime if drawing else None

        else:

            self.UID = uid

        self.width = 0

        self.height = 0

        self._attrs = [['Drawing No', ''], ['Rev No', ''], ['Unit', '']] # attributes

    @property

    def datetime(self):

        """ return datetime """

        return self._datetime

    @datetime.setter

    def datetime(self, value):

        """ set date time of drawing """

        self._datetime = value

    '''

        @brief  getter of attrs

        @author humkyung

        @date   2018.07.07

    '''

    @property

    def attrs(self):

        return self._attrs

    '''

        @brief  setter of attrs

        @author humkyung

        @date   2018.07.07

    '''

    @attrs.setter

    def attrs(self, value):

        self._attrs = value

    def set_pid_source(self, image):

        """ set image source for drawing """

        self.width, self.height = image.size

        self.currentPidSource = Source(image)

    '''

        @brief  set attribute

        @author humkyung

        @date   2018.07.07

    '''

    def setAttr(self, name, value):

        attrs = [attr for attr in self._attrs if attr[0] == name]

        if attrs:

            attrs[0][1] = value

        else:

            self._attrs.append([name, value])

        print('attribute({},{})'.format(name, value))

    def from_database(self):

        """ load all components of drawing """

        items = []

        tracer_line_nos = []

        app_doc_data = AppDocData.instance()

        try:

            components = app_doc_data.get_components(self.UID)

            """ parsing all symbols """

            for symbol in [component for component in components if component['SymbolType_UID'] != -1]:

                item = SymbolSvgItem.from_database(symbol)

                if item: items.append(item)

            # parse texts

            for text in [component for component in components if component['Name'] == 'Text' and component['SymbolType_UID'] == -1]:

                item = QEngineeringTextItem.from_database(text)

                if item:

                    item.uid = text['UID']

                    item.attribute = text['Value']

                    items.append(item)

            # note

            for note in [component for component in components if component['Name'] == 'Note' and component['SymbolType_UID'] == -1]:

                item = QEngineeringTextItem.from_database(note)

                if item is not None:

                    item.uid = note['UID']

                    items.append(item)

            for line in [component for component in components if component['Name'] == 'Line' and component['SymbolType_UID'] == -1]:

                item = QEngineeringLineItem.from_database(line)

                if item: items.append(item)

            for unknown in [component for component in components if component['Name'] == 'Unknown' and component['SymbolType_UID'] == -1]:

                item = QEngineeringUnknownItem.from_database(unknown)

                if item: items.append(item)

            for component in [component for component in components if component['Name'] == 'Line NO' and component['SymbolType_UID'] == -1]:

                line_no = QEngineeringLineNoTextItem.from_database(component)

                if type(line_no) is QEngineeringLineNoTextItem:

                    runs = app_doc_data.get_pipe_runs(str(line_no.uid))

                    if not runs: continue

                    for run in runs:

                        line_run = QEngineeringRunItem()

                        run_items = app_doc_data.get_pipe_run_items(run['UID'])

                        for record in run_items:

                            uid = record['Components_UID']

                            matches = [item for item in items if str(item) == str(uid)]

                            if matches:

                                matches[0]._owner = line_no

                                line_run.items.append(matches[0])

                        line_run.owner = line_no

                        line_no.runs.append(line_run)

            for component in [component for component in components if component['Name'] == 'Trim Line NO' and component['SymbolType_UID'] == -1]:

                tracer_line_no = QEngineeringTrimLineNoTextItem()

                tracer_line_no.uid = uuid.UUID(component['UID'], version=4)

                runs = app_doc_data.get_pipe_runs(str(tracer_line_no.uid))

                if not runs: continue

                for run in runs:

                    line_run = QEngineeringRunItem()

                    run_items = app_doc_data.get_pipe_run_items(run['UID'])

                    for record in run_items:

                        uid = record['Components_UID']

                        matches = [item for item in items if str(item) == str(uid)]

                        if matches:

                            matches[0].owner = tracer_line_no

                            line_run.items.append(matches[0])

                tracer_line_no.runs.append(line_run)

                tracer_line_nos.append(tracer_line_no)

            for component in [component for component in components if component['Name'] == 'VendorPackage' and component['SymbolType_UID'] == -1]:

                item = QEngineeringVendorItem.from_database(component)

                if item: items.append(item)

        except Exception as ex:

            from App import App

            from AppDocData import MessageType

            message = 'error occured({}) 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:

            return items,tracer_line_nos

    def export(self, path):

        """ save items of drawing to given xml file """

        import XmlGenerator as xg

        items,tracer_line_nos = self.from_database()

        xg.writeXmlOnScene(path, self.width, self.height, items, tracer_line_nos)

    def transfer(self, database):

        """ data transfer to given database """

        from AppDocData import AppDocData, MessageType

        app_doc_data = AppDocData.instance()

        conn = database.connect()

        with conn:

            try:

                cursor = conn.cursor()

                sql = database.to_sql('delete from LINE_DATA_LIST where PNID_NO=?')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from EQUIPMENT_DATA_LIST where PNID_NO=?')

                cursor.execute(sql,(self.name,))

                sql = database.to_sql('delete from VALVE_DATA_LIST where PNID_NO=?')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from INSTRUMENT_DATA_LIST where PNID_NO=?')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from NOTE_DATA_LIST where PNID_NO=?') 

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from TitleBlockValues where Drawings_UID=(select UID from Drawings where [Name]=?)')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from LineNoAttributes where Components_UID in (select UID from Components where Drawings_UID=(select UID from Drawings where Name=?))')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from Attributes where Components_UID in (select UID from Components where Drawings_UID=(select UID from Drawings where Name=?))')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from Associations where Components_UID in (select UID from Components where Drawings_UID=(select UID from Drawings where Name=?))')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from Points where Components_UID in (select UID from Components where Drawings_UID=(select UID from Drawings where Name=?))')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from PipeRunItems where PipeRuns_UID in (select UID from PipeRuns where Drawings_UID=(select UID from Drawings where Name=?))')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from PipeRuns where Drawings_UID=(select UID from Drawings where Name=?)')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from Components where Drawings_UID=(select UID from Drawings where Name=?)')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('delete from Drawings where Name=?')

                cursor.execute(sql, (self.name,))

                sql = database.to_sql('insert into Drawings(UID,Name,DATETIME) values(?,?,?)')

                cursor.execute(sql, (self.UID, self.name, self.datetime))

                components = app_doc_data.get_components(str(self.UID))

                for component in components:

                    sql = database.to_sql('insert into Components(UID,Drawings_UID,Symbol_UID,X,Y,Width,Height,Rotation,Area,Value,Owner,[From],[To],Connected,[Supplied By],SpecialItemTypes_UID, OriginIndex) \

                        values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)')

                    cursor.execute(sql, (component['UID'], component['Drawings_UID'], component['Symbol_UID'], 

                        component['X'], component['Y'], component['Width'], component['Height'], component['Rotation'], component['Area'],

                        component['Value'], component['Owner'], component['From'], component['To'], component['Connected'], 

                        component['Supplied By'], component['SpecialItemTypes_UID'], component['OriginIndex']))

                for component in components:

                    pipe_runs = app_doc_data.get_pipe_runs(component['UID'])

                    for pipe_run in pipe_runs:

                        sql = database.to_sql('insert into PipeRuns(UID,Drawings_UID,Type,Owner,[Index]) values(?,?,?,?,?)')

                        cursor.execute(sql, (pipe_run[0], pipe_run[1], pipe_run[2], pipe_run[3], pipe_run[4]))

                        pipe_run_items = app_doc_data.get_pipe_run_items(pipe_run[0])

                        for pipe_run_item in pipe_run_items:

                            sql = database.to_sql('insert into PipeRunItems(UID,PipeRuns_UID,[Index],Components_UID) values(?,?,?,?)')

                            cursor.execute(sql, (pipe_run_item[0], pipe_run_item[1], pipe_run_item[2], pipe_run_item[3]))

                    connectors = app_doc_data.get_component_connectors(component['UID'])

                    for connector in connectors:

                        sql = database.to_sql('insert into Points(Components_UID,[Index],X,Y,Connected,Connected_At) values(?,?,?,?,?,?)')

                        cursor.execute(sql, (connector['Components_UID'], connector['Index'], connector['X'], connector['Y'], connector['Connected'], connector['Connected_At']))

                    associations = app_doc_data.get_component_associations(component['UID'])

                    for assoc in associations:

                        sql = database.to_sql('insert into Associations(UID,[Type],Components_UID,Association) values(?,?,?,?)')

                        cursor.execute(sql, (assoc['UID'], assoc['Type'], assoc['Components_UID'], assoc['Association']))

                    attributes = app_doc_data.get_component_attributes(component['UID'])

                    for attr in attributes:

                        sql = database.to_sql('insert into Attributes(UID,Components_UID,SymbolAttribute_UID,Value) values(?,?,?,?)')

                        cursor.execute(sql, (attr['UID'], attr['Components_UID'], attr['SymbolAttribute_UID'], attr['Value']))

                    conn.commit()

                # Catch the exception

            except Exception as ex:

                # Roll back any change if something goes wrong

                conn.rollback()

                print(sql)

                from App import App

                message = 'error occured({}) 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)