개정판 6642ad5b
issue #1445: support text element
Change-Id: If61c57741e84986caa47f60c2a531b2abe87c370
| DTI_PID/DTI_PID/DEXPI/Equipment.py | ||
|---|---|---|
| 8 | 8 |
from .Extent import Extent |
| 9 | 9 |
from .Presentation import Presentation |
| 10 | 10 |
from .Shape import Point, Line as DEXPI_Line, ConnectionPoints, GenericAttributes, BsplineCurve |
| 11 |
from .Transform import Transform |
|
| 12 |
from .Text import Text |
|
| 11 | 13 |
|
| 12 | 14 |
|
| 13 | 15 |
class Equipment: |
| ... | ... | |
| 17 | 19 |
pass |
| 18 | 20 |
|
| 19 | 21 |
@staticmethod |
| 20 |
def to_transform(matrix: str) -> QTransform: |
|
| 21 |
"""convert given value to transform""" |
|
| 22 |
import sys |
|
| 23 |
import re |
|
| 24 |
|
|
| 25 |
res = None |
|
| 26 |
try: |
|
| 27 |
if 'matrix' in matrix: |
|
| 28 |
_str = matrix[len('matrix('):-1]
|
|
| 29 |
tokens = _str.split(',')
|
|
| 30 |
|
|
| 31 |
res = QTransform(float(tokens[0]), float(tokens[1]), |
|
| 32 |
float(tokens[2]), float(tokens[3]), |
|
| 33 |
float(tokens[4]), float(tokens[5])) |
|
| 34 |
else: |
|
| 35 |
float_re = '[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?' |
|
| 36 |
|
|
| 37 |
translate_trans = None |
|
| 38 |
if 'translate' in matrix: |
|
| 39 |
match = re.search(f"translate\({float_re},{float_re}\)", matrix)
|
|
| 40 |
if match: |
|
| 41 |
_str = match.group()[len('translate('):-1]
|
|
| 42 |
tokens = _str.split(',')
|
|
| 43 |
|
|
| 44 |
translate_trans = QTransform() |
|
| 45 |
translate_trans.translate(float(tokens[0]), float(tokens[1])) |
|
| 46 |
|
|
| 47 |
scale_trans = None |
|
| 48 |
if 'scale' in matrix: |
|
| 49 |
match = re.search(f"scale\({float_re},{float_re}\)", matrix)
|
|
| 50 |
if match: |
|
| 51 |
_str = match.group()[len('scale('):-1]
|
|
| 52 |
tokens = _str.split(',')
|
|
| 53 |
|
|
| 54 |
scale_trans = QTransform() |
|
| 55 |
scale_trans.scale(float(tokens[0]), float(tokens[1])) |
|
| 56 |
|
|
| 57 |
if translate_trans and scale_trans: |
|
| 58 |
res = scale_trans * translate_trans |
|
| 59 |
elif translate_trans: |
|
| 60 |
res = translate_trans |
|
| 61 |
elif scale_trans: |
|
| 62 |
res = scale_trans |
|
| 63 |
except Exception as ex: |
|
| 64 |
message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \
|
|
| 65 |
f"{sys.exc_info()[-1].tb_lineno}"
|
|
| 66 |
print(message) |
|
| 67 |
|
|
| 68 |
return res |
|
| 69 |
|
|
| 70 |
@staticmethod |
|
| 71 |
def apply_transform(trans: QTransform, pos: complex) -> complex: |
|
| 72 |
"""transform given pos and then return the result""" |
|
| 73 |
res = trans.map(QPointF(pos.real, pos.imag)) |
|
| 74 |
return complex(res.x(), res.y()) |
|
| 75 |
|
|
| 76 |
@staticmethod |
|
| 77 |
def to_xml(item) -> Element: |
|
| 22 |
def to_xml(texts: list, item) -> Element: |
|
| 78 | 23 |
"""return element for equipment""" |
| 79 | 24 |
import sys |
| 80 | 25 |
from svg.path import Path, Line, Arc, CubicBezier, QuadraticBezier, parse_path |
| ... | ... | |
| 105 | 50 |
_node.attrib['Identifier'] = str(item.uid) |
| 106 | 51 |
_node.attrib['Context'] = 'ID2' |
| 107 | 52 |
|
| 53 |
for text in texts: |
|
| 54 |
Text.to_xml(node, text, item) |
|
| 55 |
|
|
| 108 | 56 |
svg = item.to_svg(parent=None) |
| 109 | 57 |
matrix_trans = None |
| 110 | 58 |
if 'transform' in svg[0].attrib: |
| 111 |
matrix_trans = Equipment.to_transform(svg[0].attrib['transform'])
|
|
| 59 |
matrix_trans = Transform.to_transform(svg[0].attrib['transform'])
|
|
| 112 | 60 |
|
| 113 | 61 |
paths = svg[0].findall('path')
|
| 114 | 62 |
for path in paths: |
| 115 |
_trans = Equipment.to_transform(path.attrib['transform'])
|
|
| 63 |
_trans = Transform.to_transform(path.attrib['transform'])
|
|
| 116 | 64 |
trans = _trans * matrix_trans |
| 117 | 65 |
path_ele = parse_path(path.attrib['d']) |
| 118 | 66 |
for idx, ele in enumerate(path_ele): |
| 119 | 67 |
if type(ele) is Move: |
| 120 | 68 |
continue |
| 121 | 69 |
elif type(ele) is Line: |
| 122 |
line = DEXPI_Line(Equipment.apply_transform(trans, ele.start),
|
|
| 123 |
Equipment.apply_transform(trans, ele.end))
|
|
| 124 |
node.append(line.to_xml()) |
|
| 70 |
line = DEXPI_Line(Transform.apply_transform(trans, ele.start),
|
|
| 71 |
Transform.apply_transform(trans, ele.end))
|
|
| 72 |
node.append(line.to_xml(item.scene().sceneRect()))
|
|
| 125 | 73 |
elif type(ele) is Arc: |
| 126 | 74 |
continue |
| 127 | 75 |
elif type(ele) is CubicBezier: |
| 76 |
_node = DEXPI_Line(Transform.apply_transform(trans, ele.start), |
|
| 77 |
Transform.apply_transform(trans, ele.control1)) |
|
| 78 |
node.append(_node.to_xml(item.scene().sceneRect())) |
|
| 79 |
|
|
| 80 |
_node = DEXPI_Line(Transform.apply_transform(trans, ele.control1), |
|
| 81 |
Transform.apply_transform(trans, ele.control2)) |
|
| 82 |
node.append(_node.to_xml(item.scene().sceneRect())) |
|
| 83 |
|
|
| 84 |
_node = DEXPI_Line(Transform.apply_transform(trans, ele.control2), |
|
| 85 |
Transform.apply_transform(trans, ele.end)) |
|
| 86 |
node.append(_node.to_xml(item.scene().sceneRect())) |
|
| 87 |
""" |
|
| 128 | 88 |
bspline_curve_node = BsplineCurve.to_xml(controls=[Equipment.apply_transform(trans, ele.start), |
| 129 | 89 |
Equipment.apply_transform(trans, ele.control1), |
| 130 | 90 |
Equipment.apply_transform(trans, ele.control2), |
| 131 | 91 |
Equipment.apply_transform(trans, ele.end)], |
| 132 | 92 |
_type='BsplineCurve', knots=[]) |
| 133 | 93 |
node.append(bspline_curve_node) |
| 94 |
""" |
|
| 134 | 95 |
elif type(ele) is QuadraticBezier: |
| 135 | 96 |
continue |
| 136 | 97 |
else: |
| DTI_PID/DTI_PID/DEXPI/PipingComponent.py | ||
|---|---|---|
| 8 | 8 |
from .Extent import Extent |
| 9 | 9 |
from .Presentation import Presentation |
| 10 | 10 |
from .Shape import Point, Line as DEXPI_Line, ConnectionPoints, GenericAttributes, BsplineCurve |
| 11 |
from .Transform import Transform |
|
| 12 |
from .Text import Text |
|
| 11 | 13 |
|
| 12 | 14 |
|
| 13 | 15 |
class PipingComponent: |
| ... | ... | |
| 17 | 19 |
pass |
| 18 | 20 |
|
| 19 | 21 |
@staticmethod |
| 20 |
def to_transform(matrix: str) -> QTransform: |
|
| 21 |
"""convert given value to transform""" |
|
| 22 |
import sys |
|
| 23 |
import re |
|
| 24 |
|
|
| 25 |
res = None |
|
| 26 |
try: |
|
| 27 |
if 'matrix' in matrix: |
|
| 28 |
_str = matrix[len('matrix('):-1]
|
|
| 29 |
tokens = _str.split(',')
|
|
| 30 |
|
|
| 31 |
res = QTransform(float(tokens[0]), float(tokens[1]), |
|
| 32 |
float(tokens[2]), float(tokens[3]), |
|
| 33 |
float(tokens[4]), float(tokens[5])) |
|
| 34 |
else: |
|
| 35 |
float_re = '[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?' |
|
| 36 |
|
|
| 37 |
translate_trans = None |
|
| 38 |
if 'translate' in matrix: |
|
| 39 |
match = re.search(f"translate\({float_re},{float_re}\)", matrix)
|
|
| 40 |
if match: |
|
| 41 |
_str = match.group()[len('translate('):-1]
|
|
| 42 |
tokens = _str.split(',')
|
|
| 43 |
|
|
| 44 |
translate_trans = QTransform() |
|
| 45 |
translate_trans.translate(float(tokens[0]), float(tokens[1])) |
|
| 46 |
|
|
| 47 |
scale_trans = None |
|
| 48 |
if 'scale' in matrix: |
|
| 49 |
match = re.search(f"scale\({float_re},{float_re}\)", matrix)
|
|
| 50 |
if match: |
|
| 51 |
_str = match.group()[len('scale('):-1]
|
|
| 52 |
tokens = _str.split(',')
|
|
| 53 |
|
|
| 54 |
scale_trans = QTransform() |
|
| 55 |
scale_trans.scale(float(tokens[0]), float(tokens[1])) |
|
| 56 |
|
|
| 57 |
if translate_trans and scale_trans: |
|
| 58 |
res = scale_trans * translate_trans |
|
| 59 |
elif translate_trans: |
|
| 60 |
res = translate_trans |
|
| 61 |
elif scale_trans: |
|
| 62 |
res = scale_trans |
|
| 63 |
except Exception as ex: |
|
| 64 |
message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \
|
|
| 65 |
f"{sys.exc_info()[-1].tb_lineno}"
|
|
| 66 |
print(message) |
|
| 67 |
|
|
| 68 |
return res |
|
| 69 |
|
|
| 70 |
@staticmethod |
|
| 71 |
def apply_transform(trans: QTransform, pos: complex) -> complex: |
|
| 72 |
"""transform given pos and then return the result""" |
|
| 73 |
res = trans.map(QPointF(pos.real, pos.imag)) |
|
| 74 |
return complex(res.x(), res.y()) |
|
| 75 |
|
|
| 76 |
@staticmethod |
|
| 77 |
def to_xml(item) -> Element: |
|
| 22 |
def to_xml(texts: list, item) -> Element: |
|
| 78 | 23 |
"""return element for equipment""" |
| 79 | 24 |
import sys |
| 80 | 25 |
from svg.path import Path, Line, Arc, CubicBezier, QuadraticBezier, parse_path |
| ... | ... | |
| 92 | 37 |
Presentation.to_xml(node, layer='0', color='0', line_type='0', line_weight=1, r=0, g=0, b=0) |
| 93 | 38 |
Extent.to_xml(node, item=item) |
| 94 | 39 |
|
| 40 |
for text in texts: |
|
| 41 |
Text.to_xml(node, text, item) |
|
| 42 |
|
|
| 95 | 43 |
_node = SubElement(node, 'Position') |
| 96 | 44 |
pt = item.pos() |
| 97 | 45 |
_node.append(Point.to_xml('Location', pt.x(), pt.y()))
|
| ... | ... | |
| 107 | 55 |
svg = item.to_svg(parent=None) |
| 108 | 56 |
matrix_trans = None |
| 109 | 57 |
if 'transform' in svg[0].attrib: |
| 110 |
matrix_trans = PipingComponent.to_transform(svg[0].attrib['transform'])
|
|
| 58 |
matrix_trans = Transform.to_transform(svg[0].attrib['transform'])
|
|
| 111 | 59 |
|
| 112 | 60 |
paths = svg[0].findall('path')
|
| 113 | 61 |
for path in paths: |
| 114 |
_trans = PipingComponent.to_transform(path.attrib['transform'])
|
|
| 62 |
_trans = Transform.to_transform(path.attrib['transform'])
|
|
| 115 | 63 |
trans = _trans * matrix_trans |
| 116 | 64 |
path_ele = parse_path(path.attrib['d']) |
| 117 | 65 |
for idx, ele in enumerate(path_ele): |
| 118 | 66 |
if type(ele) is Move: |
| 119 | 67 |
continue |
| 120 | 68 |
elif type(ele) is Line: |
| 121 |
line = DEXPI_Line(PipingComponent.apply_transform(trans, ele.start),
|
|
| 122 |
PipingComponent.apply_transform(trans, ele.end))
|
|
| 123 |
node.append(line.to_xml()) |
|
| 69 |
line = DEXPI_Line(Transform.apply_transform(trans, ele.start),
|
|
| 70 |
Transform.apply_transform(trans, ele.end))
|
|
| 71 |
node.append(line.to_xml(item.scene().sceneRect()))
|
|
| 124 | 72 |
elif type(ele) is Arc: |
| 125 | 73 |
continue |
| 126 | 74 |
elif type(ele) is CubicBezier: |
| 75 |
_node = DEXPI_Line(Transform.apply_transform(trans, ele.start), |
|
| 76 |
Transform.apply_transform(trans, ele.control1)) |
|
| 77 |
node.append(_node.to_xml(item.scene().sceneRect())) |
|
| 78 |
|
|
| 79 |
_node = DEXPI_Line(Transform.apply_transform(trans, ele.control1), |
|
| 80 |
Transform.apply_transform(trans, ele.control2)) |
|
| 81 |
node.append(_node.to_xml(item.scene().sceneRect())) |
|
| 82 |
|
|
| 83 |
_node = DEXPI_Line(Transform.apply_transform(trans, ele.control2), |
|
| 84 |
Transform.apply_transform(trans, ele.end)) |
|
| 85 |
node.append(_node.to_xml(item.scene().sceneRect())) |
|
| 86 |
|
|
| 87 |
""" |
|
| 127 | 88 |
bspline_curve_node = BsplineCurve.to_xml(controls=[PipingComponent.apply_transform(trans, ele.start), |
| 128 | 89 |
PipingComponent.apply_transform(trans, ele.control1), |
| 129 | 90 |
PipingComponent.apply_transform(trans, ele.control2), |
| 130 | 91 |
PipingComponent.apply_transform(trans, ele.end)], |
| 131 | 92 |
_type='BsplineCurve', knots=[]) |
| 132 | 93 |
node.append(bspline_curve_node) |
| 94 |
""" |
|
| 133 | 95 |
elif type(ele) is QuadraticBezier: |
| 134 | 96 |
continue |
| 135 | 97 |
else: |
| DTI_PID/DTI_PID/DEXPI/PipingNetworkSegment.py | ||
|---|---|---|
| 3 | 3 |
|
| 4 | 4 |
from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse, tostring |
| 5 | 5 |
from PyQt5.QtWidgets import * |
| 6 |
from PyQt5.QtGui import * |
|
| 7 |
from PyQt5.QtCore import * |
|
| 8 |
from EngineeringTextItem import QEngineeringTextItem |
|
| 6 | 9 |
from .Extent import Extent |
| 7 |
from .Shape import Point |
|
| 10 |
from .Shape import Point, Line as DEXPI_Line
|
|
| 8 | 11 |
from .Presentation import Presentation |
| 9 | 12 |
from .PipingComponent import PipingComponent |
| 13 |
from .Transform import Transform |
|
| 10 | 14 |
|
| 11 | 15 |
|
| 12 | 16 |
class PipingNetworkSegment: |
| ... | ... | |
| 16 | 20 |
pass |
| 17 | 21 |
|
| 18 | 22 |
@staticmethod |
| 19 |
def to_xml(parent: Element, run) -> Element: |
|
| 23 |
def to_xml(parent: Element, run, scene) -> Element:
|
|
| 20 | 24 |
"""return element for PipingNetworkSegment""" |
| 21 | 25 |
|
| 22 | 26 |
from EngineeringLineItem import QEngineeringLineItem |
| ... | ... | |
| 31 | 35 |
|
| 32 | 36 |
for item in run.items: |
| 33 | 37 |
if type(item) is QEngineeringLineItem: |
| 34 |
PipingNetworkSegment.line_to_xml(node, item) |
|
| 38 |
line = DEXPI_Line(Transform.apply_transform(QTransform(), |
|
| 39 |
complex(item.start_point()[0], item.start_point()[1])), |
|
| 40 |
Transform.apply_transform(QTransform(), |
|
| 41 |
complex(item.end_point()[0], item.end_point()[1]))) |
|
| 42 |
node.append(line.to_xml(scene.sceneRect())) |
|
| 35 | 43 |
elif issubclass(type(item), SymbolSvgItem): |
| 36 |
comp_node = PipingComponent.to_xml(item) |
|
| 44 |
texts = [child for child in scene.items() if type(child) is QEngineeringTextItem and |
|
| 45 |
str(child.owner) == str(item.uid)] |
|
| 46 |
|
|
| 47 |
comp_node = PipingComponent.to_xml(texts, item) |
|
| 37 | 48 |
if comp_node: |
| 38 | 49 |
node.append(comp_node) |
| 39 | 50 |
|
| ... | ... | |
| 54 | 65 |
x, y = line.end_point()[0], line.end_point()[1] |
| 55 | 66 |
node.append(Point.to_xml('Coordinate', x=x, y=y))
|
| 56 | 67 |
|
| 57 |
return node |
|
| 68 |
return node |
|
| DTI_PID/DTI_PID/DEXPI/PipingNetworkSystem.py | ||
|---|---|---|
| 14 | 14 |
pass |
| 15 | 15 |
|
| 16 | 16 |
@staticmethod |
| 17 |
def to_xml(parent: Element, line_no) -> Element: |
|
| 17 |
def to_xml(parent: Element, line_no, scene) -> Element:
|
|
| 18 | 18 |
"""return element for PipingNetworkSystem""" |
| 19 | 19 |
|
| 20 | 20 |
node = SubElement(parent, 'PipingNetworkSystem') |
| ... | ... | |
| 25 | 25 |
node.attrib['Status'] = 'Current' |
| 26 | 26 |
|
| 27 | 27 |
for run in line_no.runs: |
| 28 |
PipingNetworkSegment.to_xml(node, run) |
|
| 28 |
PipingNetworkSegment.to_xml(node, run, scene)
|
|
| 29 | 29 |
|
| 30 | 30 |
return node |
| DTI_PID/DTI_PID/DEXPI/Shape.py | ||
|---|---|---|
| 2 | 2 |
""" This is Shape module """ |
| 3 | 3 |
|
| 4 | 4 |
from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse, tostring |
| 5 |
from PyQt5.QtCore import * |
|
| 5 | 6 |
from .Presentation import Presentation |
| 6 | 7 |
|
| 7 | 8 |
|
| ... | ... | |
| 26 | 27 |
self.start = start |
| 27 | 28 |
self.end = end |
| 28 | 29 |
|
| 29 |
def to_xml(self): |
|
| 30 |
def to_xml(self, rect: QRectF):
|
|
| 30 | 31 |
node = Element('Line')
|
| 31 | 32 |
Presentation.to_xml(node, layer='125', color='0', line_type='1', line_weight=0.35, r=0, g=0, b=0) |
| 32 | 33 |
extent_node = SubElement(node, 'Extent') |
| ... | ... | |
| 40 | 41 |
max_node.attrib['Z'] = '0' |
| 41 | 42 |
coordinate_node = SubElement(node, 'Coordinate') |
| 42 | 43 |
coordinate_node.attrib['X'] = str(self.start.real) |
| 43 |
coordinate_node.attrib['Y'] = str(self.start.imag) |
|
| 44 |
coordinate_node.attrib['Y'] = str(rect.height() - self.start.imag)
|
|
| 44 | 45 |
coordinate_node.attrib['Z'] = '0' |
| 45 | 46 |
coordinate_node = SubElement(node, 'Coordinate') |
| 46 | 47 |
coordinate_node.attrib['X'] = str(self.end.real) |
| 47 |
coordinate_node.attrib['Y'] = str(self.end.imag) |
|
| 48 |
coordinate_node.attrib['Y'] = str(rect.height() - self.end.imag)
|
|
| 48 | 49 |
coordinate_node.attrib['Z'] = '0' |
| 49 | 50 |
|
| 50 | 51 |
return node |
| DTI_PID/DTI_PID/DEXPI/Text.py | ||
|---|---|---|
| 1 |
# coding: utf-8 |
|
| 2 |
""" This is Text module """ |
|
| 3 |
|
|
| 4 |
from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse, tostring |
|
| 5 |
from PyQt5.QtWidgets import * |
|
| 6 |
from PyQt5.QtGui import * |
|
| 7 |
from PyQt5.QtCore import * |
|
| 8 |
from .Extent import Extent |
|
| 9 |
from .Presentation import Presentation |
|
| 10 |
from .Shape import Point, Line as DEXPI_Line, ConnectionPoints, GenericAttributes, BsplineCurve |
|
| 11 |
from .Transform import Transform |
|
| 12 |
|
|
| 13 |
|
|
| 14 |
class Text: |
|
| 15 |
def __init__(self): |
|
| 16 |
pass |
|
| 17 |
|
|
| 18 |
@staticmethod |
|
| 19 |
def to_xml(parent: Element, item, owner: str) -> Element: |
|
| 20 |
"""return element for equipment""" |
|
| 21 |
import sys |
|
| 22 |
from svg.path import Path, Line, Arc, CubicBezier, QuadraticBezier, parse_path |
|
| 23 |
from svg.path.path import Move |
|
| 24 |
|
|
| 25 |
node = None |
|
| 26 |
try: |
|
| 27 |
svg = item.to_svg(owner) |
|
| 28 |
|
|
| 29 |
if svg: |
|
| 30 |
node = SubElement(parent, 'Text') |
|
| 31 |
node.attrib['Font'] = svg[0].attrib['font-family'] |
|
| 32 |
node.attrib['Width'] = svg[0].attrib['font-size'] |
|
| 33 |
node.attrib['Height'] = svg[0].attrib['font-size'] |
|
| 34 |
node.attrib['String'] = svg[0].find('text').text
|
|
| 35 |
node.attrib['Justification'] = 'LeftTop' |
|
| 36 |
node.attrib['TextAngle'] = '0' |
|
| 37 |
node.attrib['SlantAngle'] = '0' |
|
| 38 |
|
|
| 39 |
Presentation.to_xml(node, layer='22', color='0', line_type='0', line_weight=1, r=0, g=0, b=0) |
|
| 40 |
Extent.to_xml(node, item=item) |
|
| 41 |
|
|
| 42 |
_node = SubElement(node, 'Position') |
|
| 43 |
_node.append(Point.to_xml('Location', item.loc[0], item.scene().sceneRect().height() - item.loc[1] -
|
|
| 44 |
float(node.attrib['Height']))) |
|
| 45 |
_node.append(Point.to_xml('Axis', 0, 0, 1))
|
|
| 46 |
_node.append(Point.to_xml('Reference', 1, 0, 0))
|
|
| 47 |
except Exception as ex: |
|
| 48 |
message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \
|
|
| 49 |
f"{sys.exc_info()[-1].tb_lineno}"
|
|
| 50 |
print(message) |
|
| 51 |
|
|
| 52 |
return None |
|
| 53 |
|
|
| 54 |
|
|
| 55 |
class Nozzle: |
|
| 56 |
def __init__(self): |
|
| 57 |
pass |
|
| 58 |
|
|
| 59 |
@staticmethod |
|
| 60 |
def to_xml(item) -> Element: |
|
| 61 |
"""return element for nozzle""" |
|
| 62 |
|
|
| 63 |
node = Element('Nozzle')
|
|
| 64 |
node.attrib['ID'] = '' |
|
| 65 |
node.attrib['TagName'] = '' |
|
| 66 |
node.attrib['ComponentClass'] = 'Nozzle' |
|
| 67 |
node.attrib['ComponentName'] = '' |
|
| 68 |
node.attrib['ComponentType'] = 'Explicit' |
|
| 69 |
node.attrib['Status'] = 'Current' |
|
| 70 |
|
|
| 71 |
Presentation.to_xml(node, layer='30', color='0', line_type='0', line_weight=0.1, r=0, g=0, b=0) |
|
| 72 |
|
|
| 73 |
return node |
|
| DTI_PID/DTI_PID/DEXPI/Transform.py | ||
|---|---|---|
| 1 |
# coding: utf-8 |
|
| 2 |
""" This is Transform module """ |
|
| 3 |
|
|
| 4 |
from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse, tostring |
|
| 5 |
from PyQt5.QtGui import * |
|
| 6 |
from PyQt5.QtCore import * |
|
| 7 |
|
|
| 8 |
|
|
| 9 |
class Transform: |
|
| 10 |
def __init__(self): |
|
| 11 |
pass |
|
| 12 |
|
|
| 13 |
@staticmethod |
|
| 14 |
def to_transform(matrix: str) -> QTransform: |
|
| 15 |
"""convert given value to transform""" |
|
| 16 |
import sys |
|
| 17 |
import re |
|
| 18 |
|
|
| 19 |
res = None |
|
| 20 |
try: |
|
| 21 |
if 'matrix' in matrix: |
|
| 22 |
_str = matrix[len('matrix('):-1]
|
|
| 23 |
tokens = _str.split(',')
|
|
| 24 |
|
|
| 25 |
res = QTransform(float(tokens[0]), float(tokens[1]), |
|
| 26 |
float(tokens[2]), float(tokens[3]), |
|
| 27 |
float(tokens[4]), float(tokens[5])) |
|
| 28 |
else: |
|
| 29 |
float_re = '[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?' |
|
| 30 |
|
|
| 31 |
translate_trans, reverse_trans = None, None |
|
| 32 |
if 'translate' in matrix: |
|
| 33 |
match = re.search(f"translate\({float_re},{float_re}\)", matrix)
|
|
| 34 |
if match: |
|
| 35 |
_str = match.group()[len('translate('):-1]
|
|
| 36 |
tokens = _str.split(',')
|
|
| 37 |
|
|
| 38 |
translate_trans = QTransform() |
|
| 39 |
translate_trans.translate(float(tokens[0]), float(tokens[1])) |
|
| 40 |
|
|
| 41 |
reverse_trans = QTransform() |
|
| 42 |
reverse_trans.translate(-float(tokens[0]), -float(tokens[1])) |
|
| 43 |
|
|
| 44 |
scale_trans = None |
|
| 45 |
if 'scale' in matrix: |
|
| 46 |
match = re.search(f"scale\({float_re},{float_re}\)", matrix)
|
|
| 47 |
if match: |
|
| 48 |
_str = match.group()[len('scale('):-1]
|
|
| 49 |
tokens = _str.split(',')
|
|
| 50 |
|
|
| 51 |
scale_trans = QTransform() |
|
| 52 |
scale_trans.scale(float(tokens[0]), float(tokens[1])) |
|
| 53 |
|
|
| 54 |
if translate_trans and scale_trans: |
|
| 55 |
res = scale_trans * translate_trans |
|
| 56 |
elif translate_trans: |
|
| 57 |
res = translate_trans |
|
| 58 |
elif scale_trans: |
|
| 59 |
res = scale_trans |
|
| 60 |
except Exception as ex: |
|
| 61 |
message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \
|
|
| 62 |
f"{sys.exc_info()[-1].tb_lineno}"
|
|
| 63 |
print(message) |
|
| 64 |
|
|
| 65 |
return res |
|
| 66 |
|
|
| 67 |
@staticmethod |
|
| 68 |
def apply_transform(trans: QTransform, pos: complex) -> complex: |
|
| 69 |
"""transform given pos and then return the result""" |
|
| 70 |
res = trans.map(QPointF(pos.real, pos.imag)) |
|
| 71 |
return complex(res.x(), res.y()) |
|
| DTI_PID/DTI_PID/DEXPI/formatter.py | ||
|---|---|---|
| 7 | 7 |
from PyQt5.QtWidgets import * |
| 8 | 8 |
from EngineeringEquipmentItem import QEngineeringEquipmentItem |
| 9 | 9 |
from EngineeringLineNoTextItem import QEngineeringLineNoTextItem |
| 10 |
from EngineeringTextItem import QEngineeringTextItem |
|
| 10 | 11 |
|
| 11 | 12 |
from .Drawing import Drawing |
| 12 | 13 |
from .Extent import Extent |
| ... | ... | |
| 63 | 64 |
"""equipment nodes""" |
| 64 | 65 |
equipments = [item for item in scene.items() if type(item) is QEngineeringEquipmentItem] |
| 65 | 66 |
for equipment in equipments: |
| 66 |
node = Equipment.to_xml(equipment) |
|
| 67 |
texts = [item for item in scene.items() if type(item) is QEngineeringTextItem and |
|
| 68 |
str(item.owner) == str(equipment.uid)] |
|
| 69 |
node = Equipment.to_xml(texts, equipment) |
|
| 67 | 70 |
xml.append(node) |
| 68 | 71 |
|
| 69 | 72 |
"""piping network system""" |
| 70 | 73 |
line_nos = [item for item in scene.items() if type(item) is QEngineeringLineNoTextItem] |
| 71 | 74 |
for line_no in line_nos: |
| 72 |
PipingNetworkSystem.to_xml(xml, line_no) |
|
| 75 |
PipingNetworkSystem.to_xml(xml, line_no, scene)
|
|
| 73 | 76 |
|
| 74 | 77 |
for item in scene.items(): |
| 75 | 78 |
formatter(item) |
| DTI_PID/DTI_PID/Shapes/EngineeringTextItem.py | ||
|---|---|---|
| 853 | 853 |
res.append(node) |
| 854 | 854 |
except Exception as ex: |
| 855 | 855 |
from App import App |
| 856 |
message = 'error occurred({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename,
|
|
| 857 |
sys.exc_info()[-1].tb_lineno)
|
|
| 856 |
message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \
|
|
| 857 |
f"{sys.exc_info()[-1].tb_lineno}"
|
|
| 858 | 858 |
App.mainWnd().addMessage.emit(MessageType.Error, message) |
| 859 | 859 |
|
| 860 | 860 |
return res |
내보내기 Unified diff
