개정판 740725ef
dev issue #619: connect, connectPts를 ConnectorItem으로 이전
| DTI_PID/DTI_PID/LineDetector.py | ||
|---|---|---|
| 231 | 231 |
try: |
| 232 | 232 |
pool = [] |
| 233 | 233 |
if (0 == symbol.angle) or (1.57 == symbol.angle) or (3.14 == symbol.angle) or (4.71 == symbol.angle): |
| 234 |
for conn in symbol.connPts:
|
|
| 235 |
dx = conn[0] - symbol.origin[0] |
|
| 236 |
dy = conn[1] - symbol.origin[1] |
|
| 234 |
for connector in symbol.connectors:
|
|
| 235 |
dx = connector.sceneConnectPoint[0] - symbol.origin[0]
|
|
| 236 |
dy = connector.sceneConnectPoint[1] - symbol.origin[1]
|
|
| 237 | 237 |
length = math.sqrt(dx*dx + dy*dy) |
| 238 | 238 |
if length > 0: |
| 239 | 239 |
dx /= length |
| ... | ... | |
| 241 | 241 | |
| 242 | 242 |
if abs(dx) < 0.1: |
| 243 | 243 |
dir = [0,1 if dy > 0 else -1] |
| 244 |
pt = [round(conn[0] - offsetX), round(conn[1] - offsetY)]
|
|
| 244 |
pt = [round(connector.sceneConnectPoint[0] - offsetX), round(connector.sceneConnectPoint[1] - offsetY)]
|
|
| 245 | 245 |
pt, thickness = self.adjustStartPoint(pt, dir) |
| 246 | 246 |
pool.append([dir, pt, thickness]) |
| 247 | 247 |
elif abs(dy) < 0.1: |
| 248 | 248 |
dir = [1 if dx > 0 else -1,0] |
| 249 |
pt = [round(conn[0] - offsetX), round(conn[1] - offsetY)]
|
|
| 249 |
pt = [round(connector.sceneConnectPoint[0] - offsetX), round(connector.sceneConnectPoint[1] - offsetY)]
|
|
| 250 | 250 |
pt, thickness = self.adjustStartPoint(pt, dir) |
| 251 | 251 |
pool.append([dir, pt, thickness]) |
| 252 | 252 | |
| ... | ... | |
| 300 | 300 |
''' |
| 301 | 301 |
def connectLineToSymbol(self, line, offset, symbol): |
| 302 | 302 |
startPt = line[0] |
| 303 |
distStart = [(self.distanceTo(startPt, (pt[0]-offset[0], pt[1]-offset[1])), (pt[0]-offset[0], pt[1]-offset[1])) for pt in symbol.connPts]
|
|
| 303 |
distStart = [(self.distanceTo(startPt, (connector.sceneConnectPoint[0]-offset[0], connector.sceneConnectPoint[1]-offset[1])), (connector.sceneConnectPoint[0]-offset[0], connector.sceneConnectPoint[1]-offset[1])) for connector in symbol.connectors]
|
|
| 304 | 304 |
distStart.sort() |
| 305 | 305 | |
| 306 | 306 |
endPt = line[-1] |
| 307 |
distEnd = [(self.distanceTo(endPt, (pt[0]-offset[0], pt[1]-offset[1])), (pt[0]-offset[0], pt[1]-offset[1])) for pt in symbol.connPts]
|
|
| 307 |
distEnd = [(self.distanceTo(endPt, (connector.sceneConnectPoint[0]-offset[0], connector.sceneConnectPoint[1]-offset[1])), (connector.sceneConnectPoint[0]-offset[0], connector.sceneConnectPoint[1]-offset[1])) for connector in symbol.connectors]
|
|
| 308 | 308 |
distEnd.sort() |
| 309 | 309 | |
| 310 | 310 |
if distStart[0][0] < distEnd[0][0]: |
| DTI_PID/DTI_PID/QtImageViewer.py | ||
|---|---|---|
| 535 | 535 |
svg.size = [svg.boundingRect().width(), svg.boundingRect().height()] |
| 536 | 536 |
self.scene.addItem(svg) |
| 537 | 537 | |
| 538 |
svg.setConnector() |
|
| 539 | 538 |
svg.transfer.onRemoved.connect(self.mainWindow.itemRemoved) |
| 540 | 539 | |
| 541 | 540 |
self.scene.clearFocus() |
| DTI_PID/DTI_PID/ResultPropertyTableWidget.py | ||
|---|---|---|
| 54 | 54 |
self.setItem(2, 1, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))
|
| 55 | 55 |
pt = item.endPoint() |
| 56 | 56 |
self.setItem(3, 1, QTableWidgetItem('({},{})'.format(pt[0], pt[1])))
|
| 57 |
self.setItem(4, 1, QTableWidgetItem('{}'.format('None' if item.conns[0] is None else item.conns[0].uid)))
|
|
| 58 |
self.setItem(5, 1, QTableWidgetItem('{}'.format('None' if item.conns[1] is None else item.conns[1].uid)))
|
|
| 57 |
self.setItem(4, 1, QTableWidgetItem('{}'.format('None' if item.connectors[0].connectedItem is None else item.connectors[0].connectedItem.uid)))
|
|
| 58 |
self.setItem(5, 1, QTableWidgetItem('{}'.format('None' if item.connectors[1].connectedItem is None else item.connectors[1].connectedItem.uid)))
|
|
| 59 | 59 |
elif issubclass(type(item), SymbolSvgItem): |
| 60 | 60 |
self.onSymbolClicked(item) |
| 61 | 61 |
elif type(item) is QEngineeringLineNoTextItem: |
| ... | ... | |
| 232 | 232 |
self.setItem(5, 1, QTableWidgetItem('{}'.format(self.symData.owner)))
|
| 233 | 233 | |
| 234 | 234 |
row = self.rowCount() |
| 235 |
self.setRowCount(row + len(self.symData.getAttributes()) + len(self.symData.conns)) |
|
| 235 |
self.setRowCount(row + len(self.symData.getAttributes()) + len(self.symData.connectors))
|
|
| 236 | 236 |
# display attributes of symbol |
| 237 | 237 |
attrs = self.symData.getAttributes() |
| 238 | 238 |
if attrs is not None: |
| ... | ... | |
| 256 | 256 | |
| 257 | 257 |
# display connectivity |
| 258 | 258 |
count = 1 |
| 259 |
for conn in self.symData.conns:
|
|
| 259 |
for connector in self.symData.connectors:
|
|
| 260 | 260 |
item = QTableWidgetItem('CONN{}'.format(count))
|
| 261 | 261 |
item.setFlags(Qt.ItemIsEnabled) |
| 262 | 262 |
item.setBackground(QColor(220, 220, 220)) |
| 263 | 263 |
self.setItem(row, 0, item) |
| 264 | 264 | |
| 265 |
item = QTableWidgetItem('{}'.format('None' if conn is None else str(conn.uid)))
|
|
| 265 |
item = QTableWidgetItem('{}'.format('None' if connector.connectedItem is None else str(connector.connectedItem.uid)))
|
|
| 266 | 266 |
item.setFlags(Qt.ItemIsEnabled) |
| 267 | 267 |
self.setItem(row, 1, item) |
| 268 | 268 |
row = row + 1 |
| DTI_PID/DTI_PID/Shapes/EngineeringConnectorItem.py | ||
|---|---|---|
| 34 | 34 |
self.buildItem() |
| 35 | 35 |
self.highlight = False |
| 36 | 36 |
self.connectedItem = None |
| 37 |
self.sceneConnectPoint = None |
|
| 38 |
self.connectPoint = None |
|
| 37 | 39 | |
| 38 | 40 |
self.setAcceptHoverEvents(True) |
| 39 | 41 | |
| DTI_PID/DTI_PID/Shapes/EngineeringLineItem.py | ||
|---|---|---|
| 33 | 33 |
QEngineeringPolylineItem.__init__(self, parent) |
| 34 | 34 |
self.isCreated = True |
| 35 | 35 | |
| 36 |
self._conns = [None, None] |
|
| 37 | 36 |
self.connectors = [] |
| 38 | 37 |
self._owner = None |
| 39 | 38 |
self._flowMark = None |
| ... | ... | |
| 82 | 81 |
self.setColor(self._color) |
| 83 | 82 | |
| 84 | 83 |
''' |
| 85 |
@brief getter of conns |
|
| 86 |
@author humkyung |
|
| 87 |
@date 2018.07.23 |
|
| 88 |
''' |
|
| 89 |
@property |
|
| 90 |
def conns(self): |
|
| 91 |
return self._conns |
|
| 92 | ||
| 93 |
''' |
|
| 94 |
@brief setter of conns |
|
| 95 |
@author humkyung |
|
| 96 |
@date 2018.07.23 |
|
| 97 |
''' |
|
| 98 |
@conns.setter |
|
| 99 |
def conns(self, value): |
|
| 100 |
self._conns = value |
|
| 101 | ||
| 102 |
''' |
|
| 103 | 84 |
@brief getter flow mark |
| 104 | 85 |
@author humkyung |
| 105 | 86 |
@date 2018.06.21 |
| ... | ... | |
| 340 | 321 |
if type(item) is QEngineeringLineItem: |
| 341 | 322 |
rhs = [item.startPoint(), item.endPoint()] |
| 342 | 323 |
elif issubclass(type(item), SymbolSvgItem): |
| 343 |
rhs = item.connPts |
|
| 324 |
rhs = [] |
|
| 325 |
for connector in item.connectors: |
|
| 326 |
rhs.append(connector.sceneConnectPoint) |
|
| 344 | 327 |
else: |
| 345 | 328 |
rhs = [] |
| 346 | 329 | |
| ... | ... | |
| 380 | 363 |
self.update() |
| 381 | 364 |
break |
| 382 | 365 |
else: |
| 383 |
if len(item.connPts) == 2:
|
|
| 384 |
connPts1 = item.connPts[0]
|
|
| 385 |
connPts2 = item.connPts[1]
|
|
| 366 |
if len(item.connectors) == 2:
|
|
| 367 |
connector1Point = item.connectors[0].sceneConnectPoint
|
|
| 368 |
connector2Point = item.connectors[1].sceneConnectPoint
|
|
| 386 | 369 | |
| 387 | 370 |
# startPoint와 같은 connPts 찾음 |
| 388 |
if startPoint[0] == connPts1[0] and startPoint[1] == connPts1[1]:
|
|
| 389 |
self.conns[0] = item
|
|
| 390 |
elif startPoint[0] == connPts2[0] and startPoint[1] == connPts2[1]:
|
|
| 391 |
self.conns[0] = item
|
|
| 371 |
if startPoint[0] == connector1Point[0] and startPoint[1] == connector1Point[1]:
|
|
| 372 |
self.connectors[0].connectedItem = item
|
|
| 373 |
elif startPoint[0] == connector2Point[0] and startPoint[1] == connector2Point[1]:
|
|
| 374 |
self.connectors[0].connectedItem = item
|
|
| 392 | 375 | |
| 393 | 376 |
# endPoint와 같은 connPts 찾음 |
| 394 |
if endPoint[0] == connPts1[0] and endPoint[1] == connPts1[1]:
|
|
| 395 |
self.conns[1] = item
|
|
| 396 |
elif endPoint[0] == connPts2[0] and endPoint[1] == connPts2[1]:
|
|
| 397 |
self.conns[1] = item
|
|
| 377 |
if endPoint[0] == connector1Point[0] and endPoint[1] == connector1Point[1]:
|
|
| 378 |
self.connectors[1].connectedItem = item
|
|
| 379 |
elif endPoint[0] == connector2Point[0] and endPoint[1] == connector2Point[1]:
|
|
| 380 |
self.connectors[1].connectedItem = item
|
|
| 398 | 381 | |
| 399 | 382 | |
| 400 | 383 |
''' |
| ... | ... | |
| 436 | 419 | |
| 437 | 420 |
if self.lineType == line.lineType: |
| 438 | 421 |
if self.isHorizontal() and line.isHorizontal(): |
| 439 |
flag = (line.conns[0] is not None and issubclass(type(line.conns[0]), SymbolSvgItem)) or (line.conns[1] is not None and issubclass(type(line.conns[1]), SymbolSvgItem))
|
|
| 422 |
flag = (line.connectors[0].connectedItem is not None and issubclass(type(line.connectors[0].connectedItem), SymbolSvgItem)) or (line.connectors[1].connectedItem is not None and issubclass(type(line.connectors[1].connectedItem), SymbolSvgItem))
|
|
| 440 | 423 |
return (flag and (math.fabs(self.startPoint()[1] - line.startPoint()[1]) < toler)) |
| 441 | 424 |
elif self.isVertical() and line.isVertical(): |
| 442 |
flag = (line.conns[0] is not None and issubclass(type(line.conns[0]), SymbolSvgItem)) or (line.conns[1] is not None and issubclass(type(line.conns[1]), SymbolSvgItem))
|
|
| 425 |
flag = (line.connectors[0].connectedItem is not None and issubclass(type(line.connectors[0].connectedItem), SymbolSvgItem)) or (line.connectors[1].connectedItem is not None and issubclass(type(line.connectors[1].connectedItem), SymbolSvgItem))
|
|
| 443 | 426 |
return (flag and (math.fabs(self.startPoint()[0] - line.startPoint()[0]) < toler)) |
| 444 | 427 |
|
| 445 | 428 |
return False |
| ... | ... | |
| 460 | 443 |
endPt = self.endPoint() |
| 461 | 444 | |
| 462 | 445 |
if issubclass(type(obj), SymbolSvgItem): |
| 463 |
for i in range(len(obj.connPts)): |
|
| 464 |
pt = obj.connPts[i] |
|
| 465 |
if len(obj.conns) <= i: obj.conns.append(None) |
|
| 446 |
for i in range(len(obj.connectors)): |
|
| 447 |
pt = obj.connectors[i].sceneConnectPoint |
|
| 466 | 448 | |
| 467 |
if (self.conns[0] is None) and (Point(startPt[0], startPt[1]).distance(Point(pt[0], pt[1])) < toler):
|
|
| 468 |
self.conns[0] = obj
|
|
| 469 |
obj.conns[i] = self
|
|
| 449 |
if (self.connectors[0].connectedItem is None) and (Point(startPt[0], startPt[1]).distance(Point(pt[0], pt[1])) < toler):
|
|
| 450 |
self.connectors[0].connectedItem = obj
|
|
| 451 |
obj.connectors[i].connectedItem = self
|
|
| 470 | 452 |
res.append(obj) |
| 471 |
if (self.conns[1] is None) and (Point(endPt[0], endPt[1]).distance(Point(pt[0], pt[1])) < toler):
|
|
| 472 |
self.conns[1] = obj
|
|
| 473 |
obj.conns[i] = self
|
|
| 453 |
if (self.connectors[1].connectedItem is None) and (Point(endPt[0], endPt[1]).distance(Point(pt[0], pt[1])) < toler):
|
|
| 454 |
self.connectors[1].connectedItem = obj
|
|
| 455 |
obj.connectors[i].connectedItem = self
|
|
| 474 | 456 |
res.append(obj) |
| 475 | 457 |
elif type(obj) is QEngineeringLineItem: |
| 476 | 458 |
_startPt = obj.startPoint() |
| 477 | 459 |
_endPt = obj.endPoint() |
| 478 | 460 |
if((Point(startPt[0], startPt[1]).distance(Point(_startPt[0], _startPt[1])) < toler)): |
| 479 |
self.conns[0] = obj
|
|
| 480 |
obj.conns[0] = self
|
|
| 461 |
self.connectors[0].connectedItem = obj
|
|
| 462 |
obj.connectors[0].connectedItem = self
|
|
| 481 | 463 |
res.append(obj) |
| 482 | 464 |
if ((Point(startPt[0], startPt[1]).distance(Point(_endPt[0], _endPt[1])) < toler)): |
| 483 |
self.conns[0] = obj
|
|
| 484 |
obj.conns[1] = self
|
|
| 465 |
self.connectors[0].connectedItem = obj
|
|
| 466 |
obj.connectors[1].connectedItem = self
|
|
| 485 | 467 |
res.append(obj) |
| 486 | 468 |
|
| 487 | 469 |
if((Point(endPt[0], endPt[1]).distance(Point(_startPt[0], _startPt[1])) < toler)): |
| 488 |
self.conns[1] = obj
|
|
| 489 |
obj.conns[0] = self
|
|
| 470 |
self.connectors[1].connectedItem = obj
|
|
| 471 |
obj.connectors[0].connectedItem = self
|
|
| 490 | 472 |
res.append(obj) |
| 491 | 473 |
|
| 492 | 474 |
if ((Point(endPt[0], endPt[1]).distance(Point(_endPt[0], _endPt[1])) < toler)): |
| 493 |
self.conns[1] = obj
|
|
| 494 |
obj.conns[1] = self
|
|
| 475 |
self.connectors[1].connectedItem = obj
|
|
| 476 |
obj.connectors[1].connectedItem = self
|
|
| 495 | 477 |
res.append(obj) |
| 496 | 478 | |
| 497 | 479 |
return res |
| ... | ... | |
| 654 | 636 |
symbol.setTransform(transform) |
| 655 | 637 |
#save angle |
| 656 | 638 |
symbol.angle = round(angle, 2) |
| 657 |
if 2 == len(symbol.connPts): # 2 way component
|
|
| 658 |
for i in range(len(symbol.connPts)):
|
|
| 659 |
rotatedPt = affinity.rotate(Point(symbol.connPts[i][0] - symbol.origin[0], symbol.connPts[i][1] - symbol.origin[1]), -angle, Point(0, 0), use_radians=True)
|
|
| 660 |
symbol.connPts[i] = (origin.x+rotatedPt.x, origin.y+rotatedPt.y)
|
|
| 639 |
if 2 == len(symbol.connectors): # 2 way component
|
|
| 640 |
for i in range(len(symbol.connectors)):
|
|
| 641 |
rotatedPt = affinity.rotate(Point(symbol.connectors[i].sceneConnectPoint[0] - symbol.origin[0], symbol.connectors[i].sceneConnectPoint[1] - symbol.origin[1]), -angle, Point(0, 0), use_radians=True)
|
|
| 642 |
symbol.connectors[i].sceneConnectPoint = (origin.x+rotatedPt.x, origin.y+rotatedPt.y)
|
|
| 661 | 643 | |
| 662 |
dx1 = symbol.connPts[0][0] - self.startPoint()[0]
|
|
| 663 |
dy1 = symbol.connPts[0][1] - self.startPoint()[1]
|
|
| 644 |
dx1 = symbol.connectors[0].sceneConnectPoint[0] - self.startPoint()[0]
|
|
| 645 |
dy1 = symbol.connectors[0].sceneConnectPoint[1] - self.startPoint()[1]
|
|
| 664 | 646 |
length1 = math.sqrt(dx1*dx1 + dy1*dy1) |
| 665 |
dx2 = symbol.connPts[1][0] - self.startPoint()[0]
|
|
| 666 |
dy2 = symbol.connPts[1][1] - self.startPoint()[1]
|
|
| 647 |
dx2 = symbol.connectors[1].sceneConnectPoint[0] - self.startPoint()[0]
|
|
| 648 |
dy2 = symbol.connectors[1].sceneConnectPoint[1] - self.startPoint()[1]
|
|
| 667 | 649 |
length2 = math.sqrt(dx2*dx2 + dy2*dy2) |
| 668 | 650 | |
| 669 | 651 |
if length1 < length2: |
| 670 |
processLine = QEngineeringLineItem([symbol.connPts[1], self.endPoint()])
|
|
| 671 |
processLine.conns.append(symbol)
|
|
| 672 |
processLine.conns.append(self.conns[1])
|
|
| 652 |
processLine = QEngineeringLineItem([symbol.connectors[1].sceneConnectPoint, self.endPoint()])
|
|
| 653 |
processLine.connectors[0].connectedItem = symbol
|
|
| 654 |
processLine.connectors[1].connectedItem = self.connectors[1].connectedItem
|
|
| 673 | 655 |
self.scene().addItem(processLine) |
| 674 | 656 | |
| 675 |
line = QLineF(self.line().p1(), QPointF(symbol.connPts[0][0], symbol.connPts[0][1]))
|
|
| 657 |
line = QLineF(self.line().p1(), QPointF(symbol.connectors[0].sceneConnectPoint[0], symbol.connectors[0].sceneConnectPoint[1]))
|
|
| 676 | 658 |
self.setLine(line) |
| 677 |
self.conns[1] = symbol
|
|
| 659 |
self.connectors[1].connectedItem = symbol
|
|
| 678 | 660 | |
| 679 |
symbol.conns = [] |
|
| 680 |
symbol.conns.append(self) |
|
| 681 |
symbol.conns.append(processLine) |
|
| 661 |
symbol.connectors[0].connectedItem = self |
|
| 662 |
symbol.connectors[1].connectedItem = processLine |
|
| 682 | 663 |
else: |
| 683 |
processLine = QEngineeringLineItem(symbol.connPts[0], self.endPoint())
|
|
| 684 |
processLine.conns.append(symbol)
|
|
| 685 |
processLine.conns.append(self.conns[1])
|
|
| 664 |
processLine = QEngineeringLineItem(symbol.connectors[0].sceneConnectPoint, self.endPoint())
|
|
| 665 |
processLine.connectors[0].connectedItem = symbol
|
|
| 666 |
processLine.connectors[1].connectedItem = self.connectors[1].connectedItem
|
|
| 686 | 667 |
self.scene().addItem(processLine) |
| 687 | 668 | |
| 688 |
line = QLineF(self.line().p1(), QPointF(symbol.connPts[1][0], symbol.connPts[1][1]))
|
|
| 669 |
line = QLineF(self.line().p1(), QPointF(symbol.connectors[1].sceneConnectPoint[0], symbol.connectors[1].sceneConnectPoint[1]))
|
|
| 689 | 670 |
self.setLine(line) |
| 690 |
self.conns[1] = symbol
|
|
| 671 |
self.connectors[1].connectedItem = symbol
|
|
| 691 | 672 | |
| 692 |
symbol.conns = []
|
|
| 693 |
symbol.conns.append(processLine)
|
|
| 694 |
symbol.conns.append(self) |
|
| 673 |
symbol.connectors[0].connectedItem = processLine
|
|
| 674 |
symbol.connectors[1].connectedItem = self
|
|
| 675 |
|
|
| 695 | 676 | |
| 696 | 677 |
self.joinTo(symbol) |
| 697 | 678 |
processLine.joinTo(symbol) |
| ... | ... | |
| 708 | 689 |
''' |
| 709 | 690 |
def reDrawLine(self, symbol, changedConnPoint1, changedConnPoint2): |
| 710 | 691 |
# startPoint에 symbol |
| 711 |
if self.conns[0] == symbol:
|
|
| 712 |
if self.startPoint()[0] == symbol.connPts[0][0] and self.startPoint()[1] == symbol.connPts[0][1]:
|
|
| 692 |
if self.connectors[0].connectedItem == symbol:
|
|
| 693 |
if self.startPoint()[0] == symbol.connectors[0].sceneConnectPoint[0] and self.startPoint()[1] == symbol.connectors[0].sceneConnectPoint[1]:
|
|
| 713 | 694 |
line = QLineF(QPointF(changedConnPoint1[0], changedConnPoint1[1]), self.line().p2()) |
| 714 | 695 |
self.setLine(line) |
| 715 | 696 |
else: |
| 716 | 697 |
line = QLineF(QPointF(changedConnPoint2[0], changedConnPoint2[1]), self.line().p2()) |
| 717 | 698 |
self.setLine(line) |
| 718 | 699 |
# endPoint에 symbol |
| 719 |
elif self.conns[1] == symbol:
|
|
| 720 |
if self.endPoint()[0] == symbol.connPts[0][0] and self.endPoint()[1] == symbol.connPts[0][1]:
|
|
| 700 |
elif self.connectors[1].connectedItem == symbol:
|
|
| 701 |
if self.endPoint()[0] == symbol.connectors[0].sceneConnectPoint[0] and self.endPoint()[1] == symbol.connectors[0].sceneConnectPoint[1]:
|
|
| 721 | 702 |
line = QLineF(self.line().p1(), QPointF(changedConnPoint1[0], changedConnPoint1[1])) |
| 722 | 703 |
self.setLine(line) |
| 723 | 704 |
else: |
| ... | ... | |
| 734 | 715 |
def removeSymbol(self, symbol): |
| 735 | 716 |
import math |
| 736 | 717 | |
| 737 |
if 2 == len(symbol.conns): # 2-way component |
|
| 738 |
connected = symbol.conns[0] if symbol.conns[0] is not self else symbol.conns[1]
|
|
| 718 |
if 2 == len(symbol.connectors): # 2-way component
|
|
| 719 |
connected = symbol.connectors[0].connectedItem if symbol.connectors[0].connectedItem is not self else symbol.connectors[1].connectedItem
|
|
| 739 | 720 |
|
| 740 | 721 |
pts = [] |
| 741 | 722 |
pts.append(self.startPoint()) |
| ... | ... | |
| 777 | 758 |
def updateLineType(self): |
| 778 | 759 |
from QEngineeringInstrumentItem import QEngineeringInstrumentItem |
| 779 | 760 | |
| 780 |
if len(self.conns) == 2: |
|
| 781 |
lines = [item for item in self.conns if item is not None and type(item) is QEngineeringLineItem]
|
|
| 782 |
insts = [item for item in self.conns if item is not None and type(item) is QEngineeringInstrumentItem]
|
|
| 761 |
if len(self.connectors) == 2:
|
|
| 762 |
lines = [item.connectedItem for item in self.connectors if item.connectedItem is not None and type(item.connectedItem) is QEngineeringLineItem]
|
|
| 763 |
insts = [item.connectedItem for item in self.connectors if item.connectedItem is not None and type(item.connectedItem) is QEngineeringInstrumentItem]
|
|
| 783 | 764 | |
| 784 | 765 |
matches = [inst for inst in insts if (inst.measuredVariableCode + inst.typeModifier) not in ['FT', 'PT', 'TT', 'TI', 'TG', 'PG']] |
| 785 | 766 |
if matches: |
| 786 | 767 |
self.lineType = 'Electric' |
| 787 | 768 | |
| 788 |
pool = [item for item in self.conns if item is not None and type(item) is QEngineeringLineItem]
|
|
| 769 |
pool = [item.connectedItem for item in self.connectors if item.connectedItem is not None and type(item.connectedItem) is QEngineeringLineItem]
|
|
| 789 | 770 |
visited = [] |
| 790 | 771 |
visited.extend(pool) |
| 791 | 772 |
while len(pool): |
| 792 | 773 |
line = pool.pop() |
| 793 | 774 |
line.lineType = 'Electric' |
| 794 | 775 | |
| 795 |
matches = [item for item in line.conns if item is not None and item not in visited and type(item) is QEngineeringLineItem]
|
|
| 776 |
matches = [item.connectedItem for item in line.connectors if item.connectedItem is not None and item.connectedItem not in visited and type(item.connectedItem) is QEngineeringLineItem]
|
|
| 796 | 777 |
pool.extend(matches) |
| 797 | 778 |
visited.extend(matches) |
| 798 | 779 |
else: |
| ... | ... | |
| 889 | 870 | |
| 890 | 871 |
item = QEngineeringLineItem(vertices=[startPoint, endPoint]) |
| 891 | 872 |
item.lineType = lineType |
| 892 |
item.conns = conns |
|
| 873 |
for connIndex in range(len(conns)): |
|
| 874 |
item.connectors[connIndex].connectedItem = conns[connIndex] |
|
| 893 | 875 |
except Exception as ex: |
| 894 | 876 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
| 895 | 877 | |
| ... | ... | |
| 928 | 910 | |
| 929 | 911 |
# write conected items' uid to xml |
| 930 | 912 |
connsNode = Element('CONNS')
|
| 931 |
connsNode.text = ','.join([str(conn.uid) if conn is not None else 'None' for conn in self._conns])
|
|
| 913 |
connsNode.text = ','.join([str(connector.connectedItem.uid) if connector.connectedItem is not None else 'None' for connector in self.connectors])
|
|
| 932 | 914 |
node.append(connsNode) |
| 933 | 915 |
# up to here |
| 934 | 916 |
except Exception as ex: |
| DTI_PID/DTI_PID/Shapes/SymbolSvgItem.py | ||
|---|---|---|
| 41 | 41 |
self.origin = None |
| 42 | 42 |
self.loc = None |
| 43 | 43 |
self.size = None |
| 44 |
self._conns = [] |
|
| 45 | 44 |
self.connectors = [] |
| 46 | 45 |
self.attrs = [] # attributes |
| 47 | 46 |
self._owner = None |
| ... | ... | |
| 96 | 95 |
self._color = self.DEFAULT_COLOR |
| 97 | 96 |
self.setColor(self._color) |
| 98 | 97 | |
| 99 |
''' |
|
| 100 |
@brief getter of conns |
|
| 101 |
@author humkyung |
|
| 102 |
@date 2018.07.23 |
|
| 103 |
''' |
|
| 104 |
@property |
|
| 105 |
def conns(self): |
|
| 106 |
return self._conns |
|
| 107 | ||
| 108 |
''' |
|
| 109 |
@brief setter of conns |
|
| 110 |
@author humkyung |
|
| 111 |
@date 2018.07.23 |
|
| 112 |
''' |
|
| 113 |
@conns.setter |
|
| 114 |
def conns(self, value): |
|
| 115 |
self._conns = value |
|
| 116 | 98 | |
| 117 | 99 |
''' |
| 118 | 100 |
@brief build symbol item |
| ... | ... | |
| 133 | 115 |
self.origin = origin |
| 134 | 116 |
originalPoint = symbolInfo.getOriginalPoint().split(',')
|
| 135 | 117 |
self.symbolOrigin = (float(originalPoint[0]), float(originalPoint[1])) |
| 118 | ||
| 119 |
# setting connectors |
|
| 136 | 120 |
connectionPoints = symbolInfo.getConnectionPoint().split('/')
|
| 137 |
connectionPointList = [] |
|
| 138 |
for connectionPoint in connectionPoints: |
|
| 139 |
split = connectionPoint.split(',')
|
|
| 140 |
connectionPointList.append((float(split[0]), float(split[1]))) |
|
| 141 |
self.originConnPts = connectionPointList |
|
| 142 |
self.connPts = connPts |
|
| 121 |
for index in range(len(connectionPoints)): |
|
| 122 |
split = connectionPoints[index].split(',')
|
|
| 123 |
self.setConnector() |
|
| 124 |
self.connectors[index].setPos((float(split[0]), float(split[1]))) |
|
| 125 |
self.connectors[index].connectPoint = (float(split[0]), float(split[1])) |
|
| 126 |
self.connectors[index].sceneConnectPoint = connPts[index] if len(connPts) > index else None |
|
| 127 |
|
|
| 143 | 128 |
self.parentSymbol = parentSymbol |
| 144 | 129 |
self.childSymbol = childSymbol |
| 145 | 130 |
self.hasInstrumentLabel = hasInstrumentLabel |
| 146 | 131 |
self.currentPointModeIndex = 0 |
| 132 | ||
| 147 | 133 |
''' |
| 148 | 134 |
self.connectors.clear() |
| 149 | 135 |
center = (loc[0] + size[0]*0.5, loc[1] + size[1]*0.5) |
| ... | ... | |
| 172 | 158 |
@date 2018.04.13 |
| 173 | 159 |
''' |
| 174 | 160 |
def isConnectable(self, line, offset, toler=10): |
| 175 |
for pt in self.connPts:
|
|
| 176 |
dx = pt[0] - (line[0][0] + offset[0])
|
|
| 177 |
dy = pt[1] - (line[0][1] + offset[1])
|
|
| 161 |
for connector in self.connectors:
|
|
| 162 |
dx = connector.sceneConnectPoint[0] - (line[0][0] + offset[0])
|
|
| 163 |
dy = connector.sceneConnectPoint[1] - (line[0][1] + offset[1])
|
|
| 178 | 164 |
if (math.sqrt(dx*dx + dy*dy) < toler): return True |
| 179 |
dx = pt[0] - (line[-1][0] + offset[0])
|
|
| 180 |
dy = pt[1] - (line[-1][1] + offset[1])
|
|
| 165 |
dx = connector.sceneConnectPoint[0] - (line[-1][0] + offset[0])
|
|
| 166 |
dy = connector.sceneConnectPoint[1] - (line[-1][1] + offset[1])
|
|
| 181 | 167 |
if (math.sqrt(dx*dx + dy*dy) < toler): return True |
| 182 | 168 | |
| 183 | 169 |
return False |
| ... | ... | |
| 191 | 177 |
import math |
| 192 | 178 |
from EngineeringLineItem import QEngineeringLineItem |
| 193 | 179 | |
| 194 |
lhs = self.connPts |
|
| 180 |
lhs = [] |
|
| 181 |
for connector in self.connectors: |
|
| 182 |
lhs.append(connector.sceneConnectPoint) |
|
| 183 | ||
| 195 | 184 |
if type(item) is QEngineeringLineItem: |
| 196 | 185 |
rhs = [item.startPoint(), item.endPoint()] |
| 197 | 186 |
elif issubclass(type(item), SymbolSvgItem): |
| 198 |
rhs = item.connPts |
|
| 187 |
rhs = [] |
|
| 188 |
for connector in item.connectors: |
|
| 189 |
rhs.append(connector.sceneConnectPoint) |
|
| 199 | 190 |
else: |
| 200 | 191 |
rhs = [] |
| 201 | 192 | |
| ... | ... | |
| 223 | 214 |
if type(obj) is QEngineeringLineItem: |
| 224 | 215 |
startPt = obj.startPoint() |
| 225 | 216 |
endPt = obj.endPoint() |
| 226 |
for i in range(len(self.connPts)): |
|
| 227 |
if len(self.conns) <= i: self.conns.append(None) |
|
| 228 | ||
| 229 |
if (self.conns[i] is None) and (Point(startPt[0], startPt[1]).distance(Point(self.connPts[i][0], self.connPts[i][1])) < toler): |
|
| 230 |
self.conns[i] = obj |
|
| 231 |
obj.conns[0] = self |
|
| 217 |
for i in range(len(self.connectors)): |
|
| 218 |
if (self.connectors[i].connectedItem is None) and (Point(startPt[0], startPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler): |
|
| 219 |
self.connectors[i].connectedItem = obj |
|
| 220 |
obj.connectors[0].connectedItem = self |
|
| 232 | 221 |
res.append(obj) |
| 233 |
if (self.conns[i] is None) and (Point(endPt[0], endPt[1]).distance(Point(self.connPts[i][0], self.connPts[i][1])) < toler):
|
|
| 234 |
self.conns[i] = obj
|
|
| 235 |
obj.conns[1] = self
|
|
| 222 |
if (self.connectors[i].connectedItem is None) and (Point(endPt[0], endPt[1]).distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler):
|
|
| 223 |
self.connectors[i].connectedItem = obj
|
|
| 224 |
obj.connectors[1].connectedItem = self
|
|
| 236 | 225 |
res.append(obj) |
| 237 | 226 |
elif issubclass(type(obj), SymbolSvgItem): |
| 238 |
for i in range(len(self.connPts)): |
|
| 239 |
if len(self.conns) <= i: self.conns.append(None) |
|
| 240 | ||
| 241 |
for j in range(len(obj.connPts)): |
|
| 242 |
_pt = Point(obj.connPts[j][0], obj.connPts[j][1]) |
|
| 243 |
if (self.conns[i] is None) and (_pt.distance(Point(self.connPts[i][0], self.connPts[i][1])) < toler): |
|
| 244 |
self.conns[i] = obj |
|
| 245 |
obj.conns[j] = self |
|
| 227 |
for i in range(len(self.connectors)): |
|
| 228 |
for j in range(len(obj.connectors)): |
|
| 229 |
_pt = Point(obj.connectors[j].sceneConnectPoint[0], obj.connectors[j].sceneConnectPoint[1]) |
|
| 230 |
if (self.connectors[i].connectedItem is None) and (_pt.distance(Point(self.connectors[i].sceneConnectPoint[0], self.connectors[i].sceneConnectPoint[1])) < toler): |
|
| 231 |
self.connectors[i].connectedItem = obj |
|
| 232 |
obj.connectors[j].connectedItem = self |
|
| 246 | 233 |
res.append(obj) |
| 247 | 234 | |
| 248 | 235 |
return res |
| ... | ... | |
| 255 | 242 |
def getConnectionPointCloseTo(self, pt, toler=10): |
| 256 | 243 |
import math |
| 257 | 244 | |
| 258 |
for connPt in self.connPts:
|
|
| 259 |
dx = connPt[0] - pt[0]
|
|
| 260 |
dy = connPt[1] - pt[1]
|
|
| 245 |
for connector in self.connectors:
|
|
| 246 |
dx = connector.sceneConnectPoint[0] - pt[0]
|
|
| 247 |
dy = connector.sceneConnectPoint[1] - pt[1]
|
|
| 261 | 248 |
if math.sqrt(dx*dx + dy*dy) < toler: return connPt |
| 262 | 249 |
|
| 263 | 250 |
return None |
| ... | ... | |
| 502 | 489 | |
| 503 | 490 |
for symbol in findSymbols: |
| 504 | 491 |
isConnected = False |
| 505 |
for conn in symbol.conns:
|
|
| 506 |
if conn is not None: |
|
| 492 |
for connector in symbol.connectors:
|
|
| 493 |
if connector.connectedItem is not None:
|
|
| 507 | 494 |
isConnected = True |
| 508 | 495 |
break |
| 509 | 496 |
|
| ... | ... | |
| 580 | 567 | |
| 581 | 568 |
# write conected items' uid to xml |
| 582 | 569 |
connsNode = Element('CONNS')
|
| 583 |
connsNode.text = ','.join([str(conn.uid) if conn is not None else 'None' for conn in self.conns])
|
|
| 570 |
connsNode.text = ','.join([str(connector.connectedItem.uid) if connector.connectedItem is not None else 'None' for connector in self.connectors])
|
|
| 584 | 571 |
node.append(connsNode) |
| 585 | 572 |
# up to here |
| 586 | 573 | |
| 587 | 574 |
connectionNode = Element('CONNECTIONPOINT')
|
| 588 | 575 |
connectionPoint = '' |
| 589 |
if self.connPts is not None:
|
|
| 590 |
for index in range(len(self.connPts)):
|
|
| 576 |
if self.connectors is not None:
|
|
| 577 |
for index in range(len(self.connectors)):
|
|
| 591 | 578 |
if index != 0: |
| 592 | 579 |
connectionPoint = connectionPoint + "/" |
| 593 |
connTuple = self.connPts[index]
|
|
| 580 |
connTuple = self.connectors[index].sceneConnectPoint
|
|
| 594 | 581 |
connectionPoint = connectionPoint + str(connTuple[0]) + "," + str(connTuple[1]) |
| 595 | 582 |
connectionNode.text = connectionPoint |
| 596 | 583 |
node.append(connectionNode) |
| ... | ... | |
| 678 | 665 |
if os.path.isfile(svgFilePath): |
| 679 | 666 |
item[0] = SymbolSvgItem.createItem(type, svgFilePath, uid) |
| 680 | 667 |
item[0].buildItem(name, type, angle, pt, size, origin, connPts, baseSymbol, childSymbol, hasInstrumentLabel) |
| 681 |
item[0].conns = conns |
|
| 668 |
for connIndex in range(len(conns)): |
|
| 669 |
item.connectors[connIndex].connectedItem = conns[connIndex] |
|
| 682 | 670 |
item[1] = owner |
| 683 | 671 |
except Exception as ex: |
| 684 | 672 |
print('error occured({}) in {}:{}'.format(ex, sys.exc_info()[-1].tb_frame.f_code.co_filename, sys.exc_info()[-1].tb_lineno))
|
| ... | ... | |
| 824 | 812 |
# add connectors |
| 825 | 813 |
inverted,_ = transform.inverted() |
| 826 | 814 |
self.connectors.clear() |
| 827 |
for pt in self.connPts:
|
|
| 828 |
x,y = inverted.map(pt[0], pt[1])
|
|
| 815 |
for connector in self.connectors:
|
|
| 816 |
x,y = inverted.map(connector.sceneConnectPoint[0], connector.sceneConnectPoint[1])
|
|
| 829 | 817 |
connector = QEngineeringConnectorItem(self) |
| 830 | 818 |
connector.setPos((x, y)) |
| 831 | 819 |
connector.setParentItem(self) |
| ... | ... | |
| 846 | 834 |
@date 2018.07.26 |
| 847 | 835 |
''' |
| 848 | 836 |
def setConnector(self): |
| 849 |
self.connectors.clear() |
|
| 850 |
for pt in self.originConnPts: |
|
| 851 |
connector = QEngineeringConnectorItem(self) |
|
| 852 |
connector.setPos((pt[0], pt[1])) |
|
| 853 |
connector.setParentItem(self) |
|
| 854 |
self.connectors.append(connector) |
|
| 837 |
connector = QEngineeringConnectorItem(self) |
|
| 838 |
connector.setParentItem(self) |
|
| 839 |
self.connectors.append(connector) |
|
| 855 | 840 | |
| 856 | 841 |
''' |
| 857 | 842 |
''' |
| ... | ... | |
| 865 | 850 |
@date 2018.05.25 |
| 866 | 851 |
''' |
| 867 | 852 |
def deleteSvgItemFromScene(self): |
| 868 |
for conn in self.conns:
|
|
| 869 |
if conn is not None: |
|
| 870 |
conn.removeSymbol(self) |
|
| 853 |
for connector in self.connectors:
|
|
| 854 |
if connector.connectedItem is not None:
|
|
| 855 |
connector.connectedItem.removeSymbol(self)
|
|
| 871 | 856 |
break |
| 872 | 857 | |
| 873 | 858 |
self.transfer.onRemoved.emit(self) |
| ... | ... | |
| 920 | 905 |
self.setTransform(transform) |
| 921 | 906 | |
| 922 | 907 |
# redrawLine |
| 923 |
if len(self.connPts) == 2 and len(self.conns) == 2:
|
|
| 924 |
line1 = self.conns[0]
|
|
| 925 |
line2 = self.conns[1]
|
|
| 908 |
if len(self.connectors) == 2 and self.connectors[0].connectedItem is not None and self.connectors[1].connectedItem is not None:
|
|
| 909 |
line1 = self.connectors[0].connectedItem
|
|
| 910 |
line2 = self.connectors[1].connectedItem
|
|
| 926 | 911 |
if line1 is not None and line2 is not None : |
| 927 | ||
| 928 |
changedConnPoint1 = transform.map(QPointF(self.originConnPts[0][0], self.originConnPts[0][1]))
|
|
| 912 |
|
|
| 913 |
changedConnPoint1 = transform.map(QPointF(self.connectors[0].connectPoint[0], self.connectors[0].connectPoint[1]))
|
|
| 929 | 914 |
changedConnPoint1 = (changedConnPoint1.x(), changedConnPoint1.y()) |
| 930 |
changedConnPoint2 = transform.map(QPointF(self.originConnPts[1][0], self.originConnPts[1][1]))
|
|
| 915 |
changedConnPoint2 = transform.map(QPointF(self.connectors[1].connectPoint[0], self.connectors[1].connectPoint[1]))
|
|
| 931 | 916 |
changedConnPoint2 = (changedConnPoint2.x(), changedConnPoint2.y()) |
| 932 | 917 | |
| 933 | 918 |
line1.reDrawLine(self, changedConnPoint1, changedConnPoint2) |
| 934 | 919 |
line2.reDrawLine(self, changedConnPoint1, changedConnPoint2) |
| 935 | 920 | |
| 936 |
self.connPts[0] = changedConnPoint1
|
|
| 937 |
self.connPts[1] = changedConnPoint2
|
|
| 921 |
self.connectors[0].sceneConnectPoint = changedConnPoint1
|
|
| 922 |
self.connectors[1].sceneConnectPoint = changedConnPoint2
|
|
| 938 | 923 | |
| 939 | 924 |
''' |
| 940 | 925 |
@brief change Conn point |
| ... | ... | |
| 942 | 927 |
@date 2018.07.25 |
| 943 | 928 |
''' |
| 944 | 929 |
def changeConnPoint(self): |
| 945 |
if len(self.connPts) == 2 and len(self.conns) == 2: |
|
| 946 |
line1 = self.conns[0] |
|
| 947 |
line2 = self.conns[1] |
|
| 948 |
|
|
| 930 |
if len(self.connectors) == 2 and self.connectors[0].connectedItem is not None and self.connectors[1].connectedItem is not None: |
|
| 931 |
line1 = self.connectors[0].connectedItem |
|
| 932 |
line2 = self.connectors[1].connectedItem |
|
| 949 | 933 |
if line1 is not None and line2 is not None : |
| 950 | 934 |
# line1의 startPoint |
| 951 | 935 |
# line2의 endPoint |
| 952 |
if line1.conns[0] == self: |
|
| 936 |
if line1.connectors[0] == self:
|
|
| 953 | 937 |
temp = line1.startPoint() |
| 954 | 938 |
line1.reDrawLine(self, line2.endPoint(), line2.endPoint()) |
| 955 | 939 |
line2.reDrawLine(self, temp, temp) |
| ... | ... | |
| 966 | 950 |
@date 2018.07.24 |
| 967 | 951 |
''' |
| 968 | 952 |
def changeStandardPoint(self): |
| 969 |
connPtsCount = len(self.originConnPts)
|
|
| 953 |
connPtsCount = len(self.connectors)
|
|
| 970 | 954 |
|
| 971 | 955 |
if self.currentPointModeIndex < connPtsCount: |
| 972 | 956 |
self.currentPointModeIndex += 1 |
| ... | ... | |
| 984 | 968 |
def getCurrentPoint(self): |
| 985 | 969 |
pointList = [] |
| 986 | 970 |
pointList.append(self.symbolOrigin) |
| 987 |
for connPoint in self.originConnPts:
|
|
| 988 |
pointList.append(connPoint) |
|
| 971 |
for connector in self.connectors:
|
|
| 972 |
pointList.append(connector.connectPoint)
|
|
| 989 | 973 | |
| 990 | 974 |
return pointList[self.currentPointModeIndex] |
| 991 | 975 | |
내보내기 Unified diff