def on_but_plot(self):
logger.debug('on_but_plot', __name__)
try:
cp.plotimgspe.close()
try:
del cp.plotimgspe
except:
pass
except:
arr = gu.get_array_from_file(fnm.path_pedestals_ave())
if arr == None: return
#print arr.shape,'\n', arr
cp.plotimgspe = PlotImgSpe(None,
arr,
ifname=fnm.path_pedestals_ave(),
ofname=fnm.path_peds_aver_plot())
#cp.plotimgspe.setParent(self)
cp.plotimgspe.move(cp.guimain.pos().__add__(QtCore.QPoint(
720, 120)))
cp.plotimgspe.show()
def centerScaleRect(rect, scale):
"""
centerScaleRect(QRect rect, float scale) -> QRect scaled
Takes a QRect and a float scale value, and returns a copy
of the rect that has been scaled around the center point.
"""
scaledRect = QtCore.QRect(rect)
size = scaledRect.size()
pos = scaledRect.center()
offset = QtCore.QPoint(pos.x() - (size.width() * .5),
pos.y() - (size.height() * .5))
scaledRect.moveCenter(offset)
scaledRect.setSize(size * scale)
scaledRect.moveCenter(pos)
return scaledRect
def mouseDragEvent(self, ev):
if ev.button() == QtCore.Qt.LeftButton:
ev.accept()
x, y = self.get_xy(
QtCore.QPoint(ev.scenePos()[0],
ev.scenePos()[1]))
if x is False: return False
if ev.isStart():
self.press = np.array([np.array([np.array([x, y])])])
if ev.isFinish():
self.press = cv2.approxPolyDP(
self.press, 0.01 * cv2.arcLength(self.press, True), True)
if len(self.press) >= 4:
roi = ROI(np.array([p[0] for p in self.press]), self)
else:
if self.press[-1][0][0] != x and self.press[-1][0][1] != y:
self.press = np.append(
self.press, np.array([np.array([np.array([x, y])])]),
0)
self.ev = ev
def __init__(self,
markerAlpha,
markerNeutralColor,
imgWidth,
imgHeight,
parent=None):
super(ScribbleImage, self).__init__(parent)
self.setAttribute(QtCore.Qt.WA_StaticContents)
self.scribbling = False
self.lining = False
self._penWidth = 3
self._imgWidth = imgWidth
self._imgHeight = imgHeight
self._markerNeutralColor = markerNeutralColor
self._markerAlpha = markerAlpha #TODO make interactively settable
self.lastPoint = QtCore.QPoint()
self.backgroundImage = None
self.watershedImg = None
self.markerImgRGB = None
self._showWatershed = False
def on_but_view(self):
logger.info('on_but_view', __name__)
try:
cp.guifilebrowser.close()
except:
list_of_fnames = [ self.fname_geometry.value() \
, self.fname_roi_img_nda.value() \
, self.fname_roi_img.value() \
, self.fname_roi_mask_img.value() \
, self.fname_roi_mask_nda.value() \
, self.fname_roi_mask_nda_tst.value() \
]
cp.guifilebrowser = GUIFileBrowser(None, list_of_fnames,
list_of_fnames[0])
cp.guifilebrowser.move(self.pos().__add__(QtCore.QPoint(
880, 40))) # open window with offset w.r.t. parent
cp.guifilebrowser.show()
def applyPreferences(self):
if self.preferences['windowState'] is not None:
self.restoreState(QtCore.QByteArray.fromBase64(self.preferences['windowState']))
if self.preferences['windowPosition'] is not None:
self.move(QtCore.QPoint(*self.preferences['windowPosition']))
if self.preferences['windowSize'] is not None:
self.resize(QtCore.QSize(*self.preferences['windowSize']))
self.comboTags.addItems(self.preferences['tags'])
self.applyPreferencesContent()
if self.preferences['firstRun']:
QtGui.QMessageBox.information(
self,
'Yomichan',
'This may be the first time you are running Yomichan.\n' \
'Please take some time to configure this extension.'
)
self.onActionPreferences()
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.object = 0
self.gridLines = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QtCore.QPoint()
self.mult = 1.0
self.yaw = 0.0
self.pitch = 0.0
self.roll = 0.0
self.depth = 0.0
self.y = 0.0
self.x = 0.0
self.trolltechGreen = QtGui.QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QtGui.QColor.fromCmykF(0.1, 0.1, 0.1, 0.0)
def canvasMoveEvent(self, event):
# move the last point
if self.rubberBand != None:
x = event.pos().x()
y = event.pos().y()
thisPoint = QtCore.QPoint(x, y)
# try to snap
snapper = QgsMapCanvasSnapper(self.canvas)
# snap to any layer within snap tolerance
(retval, result) = snapper.snapToBackgroundLayers(thisPoint)
if result == []:
mapToPixel = self.canvas.getCoordinateTransform()
self.rubberBand.movePoint(
self.rubberBand.numberOfVertices() - 1,
mapToPixel.toMapCoordinates(thisPoint))
else:
self.rubberBand.movePoint(
self.rubberBand.numberOfVertices() - 1,
result[0].snappedVertex)
def __init__(self, callback, pixmap_size,
first_pic, parent=None):
'''Constructor'''
QtCore.QObject.__init__(self, parent)
self._elements = []
self._size = pixmap_size
self._rect= QtCore.QRect(QtCore.QPoint(0, 0), self._size)
self._callback = callback
# timer initialization
self._timer = QtCore.QTimer(QtGui.QApplication.instance())
self._timer.timeout.connect(self._on_timeout)
self._fpms = 0.12 # frames / millisencond
self._duration = 1000.0 # millisecond
self._frame_time = 1 / self._fpms
self._alpha_step = self._frame_time / self._duration
# pixmap painting initializations
self._result = QtGui.QPixmap(first_pic).scaled(self._size,
transformMode=Qt.SmoothTransformation)
self._result.fill(Qt.transparent)
self._painter = QtGui.QPainter(self._result)
def timerEvent(self, event):
count = 0
for data in self.d.flickData.values():
if data.state == FlickData.ManualScroll:
count += 1
cursorPos = QtGui.QCursor.pos()
data.speed = cursorPos - data.dragPos
data.dragPos = cursorPos
elif data.state == FlickData.AutoScroll:
count += 1
data.speed = deaccelerate(data.speed)
p = scrollOffset(data.widget)
setScrollOffset(data.widget, p - data.speed)
if data.speed == QtCore.QPoint(0, 0):
data.state = FlickData.Steady
if count == 0:
self.d.ticker.stop()
QtCore.QObject.timerEvent(self, event)
def on_but_plot(self):
logger.debug('on_but_plot', __name__)
try:
cp.plotimgspe.close()
try:
del cp.plotimgspe
except:
pass
except:
ifname = fnm.path_data_raw_ave()
arr = gu.get_array_from_file(ifname)
if arr == None: return
logger.debug('Array shape: ' + str(arr.shape), __name__)
cp.plotimgspe = PlotImgSpe(None,
arr,
ifname,
ofname=fnm.path_data_aver_plot())
cp.plotimgspe.move(cp.guimain.pos().__add__(QtCore.QPoint(
740, 140)))
cp.plotimgspe.show()
def show_brief_messages():
self.hide_brief_message()
full_message = u"<body>"
for mess in self.brief_messages:
full_message += u"%s <hr />" % mess
full_message = full_message.rstrip("<hr />") + "</body>"
self.brief_message_box = MessagePopup(full_message, self)
self.brief_message_box.right_to_left = self.right_to_left
self.brief_message_box.show()
self.brief_message_box.raise_()
if self.right_to_left:
x = (self.briefMessagePosition.x() -
self.brief_message_box.width())
pos = QtCore.QPoint(x, self.briefMessagePosition.y())
else:
pos = self.briefMessagePosition
self.brief_message_box.move(pos)
app = QtGui.QApplication.instance()
if app:
app.processEvents()
def renderInput(self):
html = markdown.markdown(
unicode(self.VIEW.active_input().toPlainText()))
self.VIEW.saveAction.setDisabled(False)
preview = self.VIEW.active_preview()
y = preview.page().mainFrame().scrollPosition().y()
data = QtCore.QString("<style>")
data.append(QtCore.QString(self.MODEL.base_css))
data.append("</style>")
data.append(QtCore.QString(html))
#data = QtCore.QByteArray("<style>"+ +"</style>" + html)
preview.setContent(data.toUtf8())
preview.scroll(0, y)
preview.page().mainFrame().scroll(0, y)
preview.page().mainFrame().setScrollPosition(QtCore.QPoint(0, y))
y = preview.page().mainFrame().scrollPosition().y()
def mouseReleaseEvent(self, e):
if e.button() == Qt.LeftButton:
self._mouse_release_pos = e.pos()
self._mouse_move = self._mouse_release_pos - self._mouse_press_pos
x = self._mouse_release_pos.x()
y = self._mouse_release_pos.y()
g = self.geometry()
if 0 <= x <= g.width() and 0 <= y <= g.height():
xr = float(x) / g.width()
yr = float(y) / g.height()
r = self._source_rect
if r:
xi = r.x() + int(np.ceil(xr * r.width()))
yi = r.y() + int(np.ceil(yr * r.height()))
self._mouse_image_release_pos = QtCore.QPoint(xi, yi)
self._source_rect = QtCore.QRect(
self._mouse_image_press_pos,
self._mouse_image_release_pos)
self._window_zoom_active = False
self.repaint()
def __init__(self, parent = None):
format = QtOpenGL.QGLFormat()
format.setSampleBuffers(True)
QtOpenGL.QGLWidget.__init__(self, format, parent)
#self.setCursor(QtCore.Qt.OpenHandCursor)
self.setMouseTracking(True)
self.modelview_matrix_ = []
self.translate_vector_ = [0.0, 0.0, 0.0]
self.viewport_matrix_ = []
self.projection_matrix_ = []
self.near_ = 0.1
self.far_ = 100.0
self.fovy_ = 45.0
self.radius_ = 5.0
self.last_point_2D_ = QtCore.QPoint()
self.last_point_ok_ = False
self.last_point_3D_ = [1.0, 0.0, 0.0]
self.isInRotation_ = False
self.pickSize = 3
def onButView(self):
#self.exportLocalPars()
logger.info('onButView', __name__)
try:
cp.guifilebrowser.close()
except:
list_of_fnames = cp.guidirtree.get_list_of_checked_item_names()
if list_of_fnames == []:
logger.info(
'\nThe list of checked files IS EMPTY ! Click on check-box of desired file(s).',
__name__)
return
cp.guifilebrowser = GUIFileBrowser(None, list_of_fnames,
list_of_fnames[0])
cp.guifilebrowser.move(self.pos().__add__(QtCore.QPoint(
880, 40))) # open window with offset w.r.t. parent
cp.guifilebrowser.show()
def drawPlot(self):
try:
self.redrawPlotResetLimits()
#print 'Redraw plot'
except:
#self.setImgArray()
if self.but_g2tau.hasFocus() \
or self.but_intens_t.hasFocus():
cp.plotimgspe_g = PlotImgSpe(None,
self.arr2d,
title=self.getTitle(),
orient=90,
y_is_flip=True)
else:
cp.plotimgspe_g = PlotImgSpe(None, self.arr2d, title=self.getTitle(), \
orient=int(cp.ccd_orient.value()), y_is_flip=cp.y_is_flip.value())
cp.plotimgspe_g.move(
self.parentWidget().parentWidget().pos().__add__(
QtCore.QPoint(850, 20)))
cp.plotimgspe_g.show()
def contextMenuEvent(self, event):
menu = QtGui.QMenu()
remove = menu.addAction('Remove')
change_color = menu.addAction('Change Color')
show_params = menu.addAction('Show Parameters')
fit = menu.addAction('Fit')
move = menu.addAction('Move')
action = menu.exec_(self.mapToGlobal(QtCore.QPoint(0, 20)))
if action == remove:
self.context_menu_selected.emit(self.name,
DatasetList.removeDataset)
elif action == change_color:
self.context_menu_selected.emit(self.name, DatasetList.changeColor)
elif action == show_params:
self.context_menu_selected.emit(self.name,
DatasetList.showParameters)
elif action == fit:
self.context_menu_selected.emit(self.name, DatasetList.doFit)
elif action == move:
self.context_menu_selected.emit(DatasetList.moveWindow)
def startDrag(self, supportedActions):
item = self.currentItem()
itemData = QtCore.QByteArray()
dataStream = QtCore.QDataStream(itemData, QtCore.QIODevice.WriteOnly)
pixmap = QtGui.QPixmap(item.data(QtCore.Qt.UserRole))
location = item.data(QtCore.Qt.UserRole+1)
dataStream << pixmap << location
mimeData = QtCore.QMimeData()
mimeData.setData('image/x-puzzle-piece', itemData)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setHotSpot(QtCore.QPoint(pixmap.width()/2, pixmap.height()/2))
drag.setPixmap(pixmap)
if drag.exec_(QtCore.Qt.MoveAction) == QtCore.Qt.MoveAction:
self.takeItem(self.row(item))
def readSettings(self):
"""Read application settings."""
settings = QtCore.QSettings()
pos = settings.value('pos', QtCore.QPoint(200, 200))
size = settings.value('size', QtCore.QSize(400, 400))
self.move(pos)
self.resize(size)
if settings.contains('windowgeometry'):
self.restoreGeometry(settings.value('windowgeometry'))
if settings.contains('windowstate'):
self.restoreState(settings.value('windowstate'))
self._showScrollbarsAct.setChecked(
toBool(settings.value(SETTING_SCROLLBARS, True)))
self._showStatusbarAct.setChecked(
toBool(settings.value(SETTING_STATUSBAR, True)))
self._synchZoomAct.setChecked(
toBool(settings.value(SETTING_SYNCHZOOM, True)))
self._synchPanAct.setChecked(
toBool(settings.value(SETTING_SYNCHPAN, True)))
def on_save(self):
point, size = self.mapToGlobal(QtCore.QPoint(
-5, -22)), self.size() # Offset (-5,-22) for frame size.
x, y, w, h = point.x(), point.y(), size.width(), size.height()
msg = 'Save main window x,y,w,h : %d, %d, %d, %d' % (x, y, w, h)
log.info(msg, self._name)
#print msg
#Save main window position and size
self.main_win_pos_x.setValue(x)
self.main_win_pos_y.setValue(y)
self.main_win_width.setValue(w)
self.main_win_height.setValue(h)
cp.printParameters()
cp.saveParametersInFile()
if cp.save_log_at_exit.value():
log.saveLogInFile(cp.log_file.value())
def mouseMoveEvent(self, event):
buttons = event.buttons()
modifiers = event.modifiers()
dx = event.x() - self.lastPos.x()
dy = event.y() - self.lastPos.y()
if buttons == QtCore.Qt.LeftButton:
if modifiers == QtCore.Qt.ControlModifier:
self.roll(-0.5 * dx - 0.5 * dy)
elif modifiers == QtCore.Qt.ShiftModifier:
self.pan(dx / 600.,
-dy / 600.) # qt viewport y axis points down
else:
self.yaw(0.5 * dx)
self.pitch(0.5 * dy)
elif buttons == QtCore.Qt.RightButton:
self.zoom(-dy / 500.) # qt viewport y axis points down
self.updateGL()
self.lastPos = QtCore.QPoint(event.pos())
def __init__(self):
super(ScrnshotUI, self).__init__()
self.setWindowFlags(QtCore.Qt.FramelessWindowHint)
self.ltPoint = self.tempPoint = self.rbPoint =QtCore.QPoint(0,0)
self.ltRect = QtCore.QRect()
self.rtRect = QtCore.QRect()
self.lbRect = QtCore.QRect()
self.rbRect = QtCore.QRect()
self.pixmapRect = QtCore.QRect()
self.grab = True
#设置窗体为整个屏幕
self.scrPix = ImageGrab.grab()
self.scrPix.save("bground.jpeg")
self.pixmap = QtGui.QPixmap("bground.jpeg")
width, height = self.scrPix.size
self.resize(width, height)
def paintEvent(self, event):
p = QtGui.QPainter(self)
if self.frame_img:
region = event.region()
p.setClipRegion(
region) # first set clipping area as given by redraw event
frame, img = self.frame_img
# get relevant rectangles
self_rect = self.rect()
img_rect = img.rect() # [0, width]x[0, height]
refresh_rect = event.rect()
centering_offset = (
self_rect.size() - img_rect.size()
) / 2 # offset from the widget boundary to the bottom left of the image to center it in the widget
centering_offset = QtCore.QPoint(
centering_offset.width(),
centering_offset.height()) # convert to point
img_rect.translate(
centering_offset
) # representation of the image region in widget coordinate space
img_rect_in_widget = img_rect.intersected(
refresh_rect) # intersect with area that should be redrawn
img_rect.translate(
-centering_offset) # translate back to image space
p.drawImage(
centering_offset, img, img_rect
) # draw section of the image with the given offset to make it centered
region = region.subtracted(
QtGui.QRegion(img_rect_in_widget)
) # remove drawn image region from the region to be refreshed.
brush = QtGui.QBrush(QtCore.Qt.blue)
for rect in region.rects(
): # draw the area surrounding the image in a different color. And only draw on the refreshed area.
p.fillRect(rect, brush)
else:
p.setPen(QtCore.Qt.red)
p.fillRect(self.rect(), QtGui.QBrush(QtCore.Qt.blue))
p.drawText(self.rect(), QtCore.Qt.AlignCenter, "TEST")
def mouseMoveEvent(self, event):
self.x = event.x()
self.y = event.y()
if self.mouseDown == True:
dx = self.x - self.oldPos.x()
dy = self.y - self.oldPos.y()
g = self.geometry()
if self.left == True:
g.setLeft(g.left() + dx)
if self.right == True:
g.setRight(g.right() + dx)
if self.bottom == True:
g.setBottom(g.bottom() + dy)
self.setGeometry(g)
tmpx = event.x()
if not self.left:
tmpx = event.x()
else:
tmpx = self.oldPos.x()
self.oldPos = QtCore.QPoint(tmpx, event.y())
self.rectWidth = g.width()
else:
r = self.rect()
self.left = QtCore.qAbs(self.x - r.left()) <= 5
self.right = QtCore.qAbs(self.x - r.right()) <= 5
self.bottom = QtCore.qAbs(self.y - r.bottom()) <= 5
hor = self.left | self.right
if hor and self.bottom == True:
if self.left == True:
self.setCursor(QtCore.Qt.SizeBDiagCursor)
else:
self.setCursor(QtCore.Qt.SizeFDiagCursor)
elif hor == True:
self.setCursor(QtCore.Qt.SizeHorCursor)
elif self.bottom == True:
self.setCursor(QtCore.Qt.SizeVerCursor)
else:
self.setCursor(QtCore.Qt.ArrowCursor)
def mouseMoveEvent(self, e):
#initiate drag event only until threshold has been superpassed, to prevent
#drag thing when just clicking to start an app
if self.distance(e.pos(), self.mousePressPos) < self.dragThreshold:
return
#what was this for
if e.buttons() == QtCore.Qt.RightButton:
return
#prevent the dragged app from being dropped in the drawer itself
self.parent().setAcceptDrops(False)
for w in self.findChildren(QtGui.QLabel):
w.pmUp()
super(DrawerEntryBase, self).mouseReleaseEvent(e)
#convert freedesktop entry to url for mimedata
url = QtCore.QUrl(self.desktopentrypath)
urls = [url]
mimeData = QtCore.QMimeData()
mimeData.setUrls(urls)
#find the child with the icon inside, grab and set translucent for display during drag
for c in self.children():
if c.isIcon: break
pixmap = QtGui.QPixmap.grabWidget(c)
painter = QtGui.QPainter(pixmap)
painter.setCompositionMode(painter.CompositionMode_DestinationIn)
painter.fillRect(pixmap.rect(), QtGui.QColor(0, 0, 0, 180))
painter.end()
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
#set 'hot spot' in the center of the dragged pixmap
drag.setHotSpot(QtCore.QPoint(pixmap.width() / 2, pixmap.height() / 2))
# start the drag operation
# exec_ will return the accepted action from dropEvent (?)
if drag.exec_(QtCore.Qt.CopyAction
| QtCore.Qt.MoveAction) == QtCore.Qt.MoveAction:
print 'moved'
#accept drops again after dragging operation
self.parent().setAcceptDrops(True)
else:
print 'copied'
self.parent().setAcceptDrops(True)
def paint(self, painter, option, index):
""" painter(painter: QPainter, option QStyleOptionViewItem,
index: QModelIndex) -> None
Repaint the top-level item to have a button-look style
"""
model = index.model()
if (model.parent(index).isValid() == False
or model.parent(index).parent().isValid() == False):
style = self.treeView.style()
r = option.rect
textrect = QtCore.QRect(r.left() + 10, r.top(),
r.width() - 10, r.height())
font = painter.font()
font.setBold(True)
painter.setFont(font)
text = option.fontMetrics.elidedText(
model.data(index, QtCore.Qt.DisplayRole).toString(),
QtCore.Qt.ElideMiddle,
textrect.width() - 10)
style.drawItemText(painter, textrect, QtCore.Qt.AlignLeft,
option.palette, self.treeView.isEnabled(), text)
painter.setPen(QtGui.QPen(QtCore.Qt.black))
fm = QtGui.QFontMetrics(font)
size = fm.size(QtCore.Qt.TextSingleLine, text)
#painter.drawLine(textrect.left()-5,
# textrect.bottom()-1,
# textrect.left()+size.width()+5,
# textrect.bottom()-1)
annotatedId = model.data(index, QtCore.Qt.UserRole + 1)
if annotatedId.isValid():
idRect = QtCore.QRect(
QtCore.QPoint(textrect.left() + size.width() + 5,
textrect.top()), textrect.bottomRight())
QAnnotatedPipelineView.drawId(
painter, idRect,
annotatedId.toInt()[0],
QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter)
else:
QtGui.QItemDelegate.paint(self, painter, option, index)
def startDrag(self, event):
''' Draging owned units'''
index = self.indexAt(event.pos())
if not index.isValid(): return
## selected is the relevant person object
itemSelected = self.model().data(index, QtCore.Qt.UserRole)
if not itemSelected.canmove: return
selected = dict(group=self.group, uid=itemSelected.uid)
bstream = cPickle.dumps(selected)
mimeData = QtCore.QMimeData()
mimeData.setData("application/x-ownedunit-reinforcement", bstream)
drag = QtGui.QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(self.itemAt(event.pos()).icon().pixmap(50, 50))
drag.setHotSpot(QtCore.QPoint(0, 0))
drag.start(QtCore.Qt.MoveAction)
def __init__(self, parent):
QtGui.QGraphicsView.__init__(self, parent)
self._zoom = 1.0
self._currentNodeUi = None
self._panning = False
self._currentCenterPoint = QtCore.QPointF()
self._lastPanPoint = QtCore.QPoint()
self.setFocusPolicy(QtCore.Qt.ClickFocus)
self.setAcceptDrops(True)
self.setRenderHint(QtGui.QPainter.Antialiasing)
self.setDragMode(QtGui.QGraphicsView.RubberBandDrag)
self.setSceneRect(-5000, -5000, 10000, 10000)
self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
QtGui.QShortcut(QtGui.QKeySequence("Delete"), self, self._deleteKey)
QtGui.QShortcut(QtGui.QKeySequence("Backspace"), self, self._deleteKey)
QtGui.QShortcut(QtGui.QKeySequence("Ctrl+C"), self, self._copyKey)
QtGui.QShortcut(QtGui.QKeySequence("Ctrl+V"), self, self._pasteKey)
def initNodes(self, width, height):
nodeNames = ["Internet", "Site 1", "Site 2", "Site 3"]
nodeDBName = [
"INTERNET", "EnterpriseSite1", "EnterpriseSite2", "EnterpriseSite3"
]
nodeWidth = NODE_WIDTH_SCALE * width
nodeHeight = NODE_HEIGHT_SCALE * width
nodeRadius = height * 0.4
nodePositions = [QtCore.QPoint(0, 0)]
for i in range(0, len(nodeNames)):
point = QtCore.QPointF(
nodeRadius * math.cos(math.radians(self.startAngle)),
nodeRadius * math.sin(math.radians(self.startAngle)))
nodePositions.append(point)
self.startAngle = self.startAngle + self.angleStep
node = SiteNode(nodePositions[i], width * CENTER_X_SCALE,
height * CENTER_Y_SCALE, nodeWidth, nodeHeight,
nodeNames[i], self.health[i], nodeDBName[i])
self.nodeList.append(node)
self.startAngle = -90
