def init_gui(self):
#self.main_layout = QtWidgets.QVBoxLayout(self)
self.init_main_layout(orientation="vertical")
self.init_attribute_layout()
self.win = pg.GraphicsWindow(title="Expected signal")
self.plot_item = self.win.addPlot(title='Expected ' + self.module.name)
self.plot_item.showGrid(y=True, x=True, alpha=1.)
self.curve = self.plot_item.plot(pen='y')
self.curve_slope = self.plot_item.plot(pen=pg.mkPen('b', width=5))
self.symbol = self.plot_item.plot(pen='b', symbol='o')
self.main_layout.addWidget(self.win)
self.button_calibrate = QtWidgets.QPushButton('Calibrate')
self.main_layout.addWidget(self.button_calibrate)
self.button_calibrate.clicked.connect(lambda: self.module.calibrate())
self.input_calibrated()
python类mkPen()的实例源码
def fit_clicked(self):
""" Do the configured fit and show it in the sum plot """
self._mw.fit_param_TextEdit.clear()
current_fit_function = self._mw.fit_methods_ComboBox.currentText()
fit_x, fit_y, fit_param_dict, fit_result = self._trace_analysis.do_fit(fit_function=current_fit_function)
self._fit_image.setData(x=fit_x, y=fit_y, pen=pg.mkPen(palette.c2, width=2))
if len(fit_param_dict) == 0:
fit_result = 'No Fit parameter passed.'
else:
fit_result = units.create_formatted_output(fit_param_dict)
self._mw.fit_param_TextEdit.setPlainText(fit_result)
return
def update(self):
if not self.ear.data is None and not self.ear.fft is None:
pcmMax=np.max(np.abs(self.ear.data))
if pcmMax>self.maxPCM:
self.maxPCM=pcmMax
self.grPCM.plotItem.setRange(yRange=[-pcmMax,pcmMax])
if np.max(self.ear.fft)>self.maxFFT:
self.maxFFT=np.max(np.abs(self.ear.fft))
#self.grFFT.plotItem.setRange(yRange=[0,self.maxFFT])
self.grFFT.plotItem.setRange(yRange=[0,1])
self.pbLevel.setValue(1000*pcmMax/self.maxPCM)
pen=pyqtgraph.mkPen(color='b')
self.grPCM.plot(self.ear.datax,self.ear.data,pen=pen,clear=True)
pen=pyqtgraph.mkPen(color='r')
self.grFFT.plot(self.ear.fftx,self.ear.fft/self.maxFFT,pen=pen,clear=True)
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def addPlot(self, plot):
image = plot.image
if not self.plots:
self.setImageItem(image)
self.plots.append(plot)
self.setSymColormap()
# hist_pen = pg.mkPen((170, 57, 57, 255), width=1.)
image.setLookupTable(self.getLookupTable)
def updateLevels():
image.setLevels(self.region.getRegion())
self.sigLevelChangeFinished.connect(updateLevels)
self.sigLevelsChanged.connect(updateLevels)
updateLevels()
def triggerKnobEnabledChange(self, state):
self.triggerKnobSource.setEnabled(state)
self.triggerKnobDirection.setEnabled(state)
if state:
if self.triggX is None:
self.triggX = 0.5
if self.triggY is None:
self.triggY = 0
if self.triggerDiamond is None:
self.triggerDiamond = pg.RectROI([self.triggX * self.samples / self.ratioBin, self.triggY],
[0, 0], invertible=True, pen=pg.mkPen(None))
self.triggerDiamond.sigRegionChanged.connect(self.triggerDiamondUpdate)
self.viewPlot.addItem(self.triggerDiamond)
else:
self.viewPlot.removeItem(self.triggerDiamond)
self.triggerDiamond = None
self.triggerReset = True
def set_pen_colors(self):
self.pen_normal.clear()
self.pen_subset.clear()
self.pen_selected.clear()
color_var = self._current_color_var()
if color_var is not None:
colors = color_var.colors
discrete_palette = ColorPaletteGenerator(
number_of_colors=len(colors), rgb_colors=colors)
for v in color_var.values:
basecolor = discrete_palette[color_var.to_val(v)]
basecolor = QColor(basecolor)
basecolor.setAlphaF(0.9)
self.pen_subset[v] = pg.mkPen(color=basecolor, width=1)
self.pen_selected[v] = pg.mkPen(color=basecolor, width=2, style=Qt.DotLine)
notselcolor = basecolor.lighter(150)
notselcolor.setAlphaF(0.5)
self.pen_normal[v] = pg.mkPen(color=notselcolor, width=1)
def update(self):
t1,timeTook=time.time(),0
if len(self.ear.data) and not self.btnPause.isChecked():
freqHighCutoff=0
if self.spinLowpass.value()>0:
freqHighCutoff=self.spinLowpass.value()
data=self.ear.getFiltered(freqHighCutoff)
if self.chkInvert.isChecked():
data=np.negative(data)
if self.chkAutoscale.isChecked():
self.Yscale=np.max(np.abs(data))*1.1
self.grECG.plotItem.setRange(xRange=[0,self.ear.maxMemorySec],
yRange=[-self.Yscale,self.Yscale],padding=0)
self.grECG.plot(np.arange(len(data))/float(self.ear.rate),data,clear=True,
pen=pyqtgraph.mkPen(color='r'),antialias=True)
self.grECG.plotItem.setTitle(self.lineTitle.text(),color=(0,0,0))
self.stamp.setPos(0,-self.Yscale)
self.grECG.plotItem.addItem(self.stamp)
timeTook=(time.time()-t1)*1000
print("plotting took %.02f ms"%(timeTook))
msTillUpdate=int(self.ear.chunk/self.ear.rate*1000)-timeTook
QtCore.QTimer.singleShot(max(0,msTillUpdate), self.update)
def test_init_spots():
plot = pg.PlotWidget()
# set view range equal to its bounding rect.
# This causes plots to look the same regardless of pxMode.
plot.setRange(rect=plot.boundingRect())
spots = [
{'x': 0, 'y': 1},
{'pos': (1, 2), 'pen': None, 'brush': None, 'data': 'zzz'},
]
s = pg.ScatterPlotItem(spots=spots)
# Check we can display without errors
plot.addItem(s)
app.processEvents()
plot.clear()
# check data is correct
spots = s.points()
defPen = pg.mkPen(pg.getConfigOption('foreground'))
assert spots[0].pos().x() == 0
assert spots[0].pos().y() == 1
assert spots[0].pen() == defPen
assert spots[0].data() is None
assert spots[1].pos().x() == 1
assert spots[1].pos().y() == 2
assert spots[1].pen() == pg.mkPen(None)
assert spots[1].brush() == pg.mkBrush(None)
assert spots[1].data() == 'zzz'
def test_init_spots():
plot = pg.PlotWidget()
# set view range equal to its bounding rect.
# This causes plots to look the same regardless of pxMode.
plot.setRange(rect=plot.boundingRect())
spots = [
{'x': 0, 'y': 1},
{'pos': (1, 2), 'pen': None, 'brush': None, 'data': 'zzz'},
]
s = pg.ScatterPlotItem(spots=spots)
# Check we can display without errors
plot.addItem(s)
app.processEvents()
plot.clear()
# check data is correct
spots = s.points()
defPen = pg.mkPen(pg.getConfigOption('foreground'))
assert spots[0].pos().x() == 0
assert spots[0].pos().y() == 1
assert spots[0].pen() == defPen
assert spots[0].data() is None
assert spots[1].pos().x() == 1
assert spots[1].pos().y() == 2
assert spots[1].pen() == pg.mkPen(None)
assert spots[1].brush() == pg.mkBrush(None)
assert spots[1].data() == 'zzz'
def generatePicture(self):
## pre-computing a QPicture object allows paint() to run much more quickly,
## rather than re-drawing the shapes every time.
self.picture = QtGui.QPicture()
p = QtGui.QPainter(self.picture)
p.setPen(pg.mkPen(color='r', width=0.4)) # 0.4 means w*2
# w = (self.data[1][0] - self.data[0][0]) / 3.
w = 0.2
for (t, open, close, min, max) in self.data:
p.drawLine(QtCore.QPointF(t, min), QtCore.QPointF(t, max))
if open > close:
p.setBrush(pg.mkBrush('g'))
else:
p.setBrush(pg.mkBrush('r'))
p.drawRect(QtCore.QRectF(t-w, open, w*2, close-open))
p.end()
def generatePicture(self):
## pre-computing a QPicture object allows paint() to run much more quickly,
## rather than re-drawing the shapes every time.
self.picture = QtGui.QPicture()
p = QtGui.QPainter(self.picture)
p.setPen(pg.mkPen(color='r', width=0.4)) # 0.4 means w*2
# w = (self.data[1][0] - self.data[0][0]) / 3.
w = 0.2
for (t, open, close, min, max) in self.data:
p.drawLine(QtCore.QPointF(t, min), QtCore.QPointF(t, max))
if open > close:
p.setBrush(pg.mkBrush('g'))
else:
p.setBrush(pg.mkBrush('r'))
p.drawRect(QtCore.QRectF(t-w, open, w*2, close-open))
p.end()
def plot_scatter_points(self, x_data, y_data):
if self.scatterplot_item:
self.plotview.removeItem(self.scatterplot_item)
self.n_points = len(x_data)
self.scatterplot_item = pg.ScatterPlotItem(
x=x_data, y=y_data, data=np.arange(self.n_points),
symbol="o", size=10, pen=pg.mkPen(0.2), brush=pg.mkBrush(0.7),
antialias=True)
self.scatterplot_item.opts["useCache"] = False
self.plotview.addItem(self.scatterplot_item)
self.plotview.replot()
def plot_regression_line(self, x_data, y_data):
if self.plot_item:
self.plotview.removeItem(self.plot_item)
self.plot_item = pg.PlotCurveItem(
x=x_data, y=y_data,
pen=pg.mkPen(QColor(255, 0, 0), width=3),
antialias=True
)
self.plotview.addItem(self.plot_item)
self.plotview.replot()
def plot_error_bars(self, x, actual, predicted):
self.remove_error_items()
if self.error_bars_enabled:
for x, a, p in zip(x, actual, predicted):
line = pg.PlotCurveItem(
x=[x, x], y=[a, p],
pen=pg.mkPen(QColor(150, 150, 150), width=1),
antialias=True)
self.plotview.addItem(line)
self.error_plot_items.append(line)
self.plotview.replot()
def refresh_colorbar(self, cb_min, cb_max, width = None, height = None, xMin = None, yMin = None):
""" Refresh the appearance of the colorbar for a changed count range.
@param float cb_min: The minimal count value should be passed here.
@param float cb_max: The maximal count value should be passed here.
@param float width: optional, with that you can change the width of the
colorbar in the display.
"""
if width is None:
width = self.width
else:
self.width = width
# FIXME: Until now, if you want to refresh the colorbar, a new QPainter
# object has been created, but I think that it is not necassary.
# I have to figure out how to use the created object properly.
p = pg.QtGui.QPainter(self.pic)
p.drawRect(self.boundingRect())
p.setPen(pg.mkPen('k'))
grad = pg.QtGui.QLinearGradient(width/2.0, cb_min*1.0, width/2.0, cb_max*1.0)
for stop, color in zip(self.stops, self.colors):
grad.setColorAt(1.0 - stop, pg.QtGui.QColor(*[255*c for c in color]))
p.setBrush(pg.QtGui.QBrush(grad))
if xMin is None:
p.drawRect(pg.QtCore.QRectF(0, cb_min, width, cb_max-cb_min))
else:
# If this picture whants to be set in a plot, which is going to be
# saved:
p.drawRect(pg.QtCore.QRectF(xMin, yMin, width, height))
p.end()
vb = self.getViewBox()
# check whether a viewbox is already created for this object. If yes,
# then it should be adjusted according to the full screen.
if vb is not None:
vb.updateAutoRange()
vb.enableAutoRange()
def test_lag1st_to_trig(self):
# scalar case
dest_weight = core.change_projection_base(self.src_weights, self.src_test_funcs, self.trig_test_funcs[0])
dest_approx_handle_s = core.back_project_from_base(dest_weight, self.trig_test_funcs[0])
# standard case
dest_weights = core.change_projection_base(self.src_weights, self.src_test_funcs, self.trig_test_funcs)
dest_approx_handle = core.back_project_from_base(dest_weights, self.trig_test_funcs)
error = np.sum(np.power(
np.subtract(self.real_func_handle(self.z_values), dest_approx_handle(self.z_values)),
2))
if show_plots:
pw = pg.plot(title="change projection base")
i1 = pw.plot(x=self.z_values, y=self.real_func_handle(self.z_values), pen="r")
i2 = pw.plot(x=self.z_values, y=self.src_approx_handle(self.z_values),
pen=pg.mkPen("g", style=pg.QtCore.Qt.DashLine))
i3 = pw.plot(x=self.z_values, y=dest_approx_handle_s(self.z_values), pen="b")
i4 = pw.plot(x=self.z_values, y=dest_approx_handle(self.z_values), pen="c")
legend = pw.addLegend()
legend.addItem(i1, "f(x) = x")
legend.addItem(i2, "2x Lagrange1st")
legend.addItem(i3, "sin(x)")
legend.addItem(i4, "sin(wx) with w in [1, {0}]".format(dest_weights.shape[0]))
app.exec_()
# should fit pretty nice
self.assertLess(error, 1e-2)
def __init__(self, t, u, show_plot=False):
SimulationInput.__init__(self)
self._t = t
self._T = t[-1]
self._u = u
self.scale = 1
if show_plot:
pw = pg.plot(title="InterpTrajectory")
pw.plot(self._t, self.__call__(time=self._t))
pw.plot([0, self._T], self.__call__(time=[0, self._T]), pen=None, symbolPen=pg.mkPen("g"))
pg.QtGui.QApplication.instance().exec_()
def update(self):
t1=time.clock()
points=100 #number of data points
X=np.arange(points)
Y=np.sin(np.arange(points)/points*3*np.pi+time.time())
C=pyqtgraph.hsvColor(time.time()/5%1,alpha=.5)
pen=pyqtgraph.mkPen(color=C,width=10)
self.grPlot.plot(X,Y,pen=pen,clear=True)
print("update took %.02f ms"%((time.clock()-t1)*1000))
if self.chkMore.isChecked():
QtCore.QTimer.singleShot(1, self.update) # QUICKLY repeat
def addPolyLine(self):
[[xmin, xmax], [ymin, ymax]] = self.plot.viewRange()
self.poly_line = pg.PolyLineROI(
positions=[(xmin+(xmax-xmin)*.4,
ymin+(ymax-ymin)*.4),
(xmin+(xmax-xmin)*.6,
ymin+(ymax-ymin)*.6)],
pen=pg.mkPen('g', width=2))
self.plot.addItem(self.poly_line)
self.updateTransPlot()
self.poly_line.sigRegionChangeFinished.connect(
self.updateTransPlot)
def setGradientEditor(self, gradient_editor):
ge = gradient_editor
image = self.image
hist_pen = pg.mkPen((170, 57, 57, 255), width=1.)
image.setLookupTable(ge.getLookupTable)
def updateLevels():
image.setLevels(ge.region.getRegion())
ge.sigLevelChangeFinished.connect(updateLevels)
ge.sigLevelsChanged.connect(updateLevels)
updateLevels()
def updateHistogram():
h = image.getHistogram()
if h[0] is None:
return
ge.hist_syn.setData(*h)
ge.hist_syn = pg.PlotDataItem(pen=hist_pen)
ge.hist_syn.rotate(90.)
ge.vb.addItem(ge.hist_syn)
updateHistogram()
image.sigImageChanged.connect(updateHistogram)
def pen(self, pen):
if isinstance(pen, QColor):
pen = pg.mkPen(pen)
_inactive_pen = pg.mkPen(QColor(pen.color().red(),
pen.color().green(),
pen.color().blue(),
50))
if self._plot.opts['pen'] == self._pen_stash['pen_on']:
self._pen_stash['pen_on'] = pg.mkPen(pen, width=self.line_width)
self._plot.setPen(self._pen_stash['pen_on'])
elif self._plot.opts['pen'] == self._pen_stash['pen_inactive']:
self._pen_stash['pen_inactive'] = _inactive_pen
self._plot.setPen(self._pen_stash['pen_inactive'])
def error_pen(self, pen):
self._pen_stash['error_pen_on'] = pg.mkPen(pen)
if self.error is not None:
self.error.setOpts(pen=pg.mkPen(pen))
def mask_pen(self, pen):
self._pen_stash['mask_pen_on'] = pg.mkPen(pen)
if self.error is not None:
self.error.setPen(pen=pg.mkPen(pen))
def set_line_width(self, width):
"""
Set the line plot width
Parameters
----------
width: float
The width of the line
"""
self.line_width = width
_pen = pg.mkPen(self._plot.opts['pen'])
_pen.setWidth(self.line_width)
self.pen = _pen
def setup(self):
#self.ui = self.splitter = QtWidgets.QSplitter()
#self.ui.setLayout(QtWidgets.QVBoxLayout())
self.ui = self.dockarea = dockarea.DockArea()
self.imview = pg.ImageView()
self.imview.getView().invertY(False) # lower left origin
#self.splitter.addWidget(self.imview)
self.dockarea.addDock(name='Image', widget=self.imview)
self.graph_layout = pg.GraphicsLayoutWidget()
#self.splitter.addWidget(self.graph_layout)
self.dockarea.addDock(name='Spec Plot', widget=self.graph_layout)
self.spec_plot = self.graph_layout.addPlot()
self.rect_plotdata = self.spec_plot.plot()
self.point_plotdata = self.spec_plot.plot(pen=(0,9))
# Rectangle ROI
self.rect_roi = pg.RectROI([20, 20], [20, 20], pen=(0,9))
self.rect_roi.addTranslateHandle((0.5,0.5))
self.imview.getView().addItem(self.rect_roi)
self.rect_roi.sigRegionChanged[object].connect(self.on_change_rect_roi)
# Point ROI
self.circ_roi = pg.CircleROI( (0,0), (2,2) , movable=True, pen=(0,9))
#self.circ_roi.removeHandle(self.circ_roi.getHandles()[0])
h = self.circ_roi.addTranslateHandle((0.5,.5))
h.pen = pg.mkPen('r')
h.update()
self.imview.getView().addItem(self.circ_roi)
self.circ_roi.removeHandle(0)
self.circ_roi_plotline = pg.PlotCurveItem([0], pen=(0,9))
self.imview.getView().addItem(self.circ_roi_plotline)
self.circ_roi.sigRegionChanged[object].connect(self.on_update_circ_roi)
self.hyperspec_data = None
self.display_image = None
self.spec_x_array = None
self.scan_specific_setup()
def __init__(self, graph):
ViewBox.__init__(self, enableMenu=False)
self.graph = graph
self.setMouseMode(self.PanMode)
self.zoomstartpoint = None
self.current_selection = None
self.action = PANNING
self.y_padding = 0.02
self.x_padding = 0
# line for marking selection
self.selection_line = pg.PlotCurveItem()
self.selection_line.setPen(pg.mkPen(color=QColor(Qt.black), width=2, style=Qt.DotLine))
self.selection_line.setZValue(1e9)
self.selection_line.hide()
self.addItem(self.selection_line, ignoreBounds=True)
# yellow marker for ending the polygon
self.selection_poly_marker = pg.ScatterPlotItem()
self.selection_poly_marker.setPen(pg.mkPen(color=QColor(Qt.yellow), width=2))
self.selection_poly_marker.setSize(SELECT_POLYGON_TOLERANCE*2)
self.selection_poly_marker.setBrush(None)
self.selection_poly_marker.setZValue(1e9+1)
self.selection_poly_marker.hide()
self.selection_poly_marker.mouseClickEvent = lambda x: x # ignore mouse clicks
self.addItem(self.selection_poly_marker, ignoreBounds=True)
def __init__(self, position, label="", setvalfn=None, confirmfn=None,
color=(225, 0, 0), report=None):
pg.UIGraphicsItem.__init__(self)
self.moving = False
self.mouseHovering = False
self.report = report
hp = pg.mkPen(color=color, width=3)
np = pg.mkPen(color=color, width=2)
self.line = pg.InfiniteLine(angle=90, movable=True, pen=np, hoverPen=hp)
if position is not None:
self.line.setValue(position)
else:
self.line.setValue(0)
self.line.hide()
self.line.setCursor(Qt.SizeHorCursor)
self.line.setParentItem(self)
self.line.sigPositionChangeFinished.connect(self.lineMoveFinished)
self.line.sigPositionChanged.connect(self.lineMoved)
self.label = pg.TextItem("", anchor=(0,0))
self.label.setText(label, color=color)
self.label.setParentItem(self)
self.setvalfn = setvalfn
self.confirmfn = confirmfn
self.lastTransform = None
def update_visualization(self, tofs, ranges, clock_offsets, clock_skews, slave_clock_offset, slave_clock_skew):
if not self.show_plots:
return
import pyqtgraph
num_of_units = len(tofs)
# ranges
while len(self.range_plot) < num_of_units:
curve_index = len(self.range_plot)
pen = pyqtgraph.mkPen(curve_index)
self.range_plot.add_curve(pen=pen, name="{}".format(curve_index))
for i in xrange(num_of_units):
self.range_plot.add_point(i, ranges[i])
# clock offset
while len(self.clock_offset_plot) < num_of_units:
curve_index = len(self.clock_offset_plot)
pen = pyqtgraph.mkPen(curve_index)
self.clock_offset_plot.add_curve(pen=pen, name="{}".format(curve_index))
if self.show_slave_clock_offset:
if len(self.clock_offset_plot) < num_of_units + 1:
curve_index = len(self.clock_offset_plot)
pen = pyqtgraph.mkPen(curve_index)
self.clock_offset_plot.add_curve(pen=pen, name="slave")
for i in xrange(num_of_units):
self.clock_offset_plot.add_point(i, clock_offsets[i])
if self.show_slave_clock_offset:
self.clock_offset_plot.add_point(len(self.clock_offset_plot) - 1, slave_clock_offset)
# clock skew
while len(self.clock_skew_plot) < num_of_units:
curve_index = len(self.clock_skew_plot)
pen = pyqtgraph.mkPen(curve_index)
self.clock_skew_plot.add_curve(pen=pen, name="{}".format(curve_index))
if self.show_slave_clock_skew:
if len(self.clock_skew_plot) < num_of_units + 1:
curve_index = len(self.clock_skew_plot)
pen = pyqtgraph.mkPen(curve_index)
self.clock_skew_plot.add_curve(pen=pen, name="slave")
for i in xrange(num_of_units):
self.clock_skew_plot.add_point(i, clock_skews[i])
if self.show_slave_clock_skew:
self.clock_skew_plot.add_point(len(self.clock_skew_plot) - 1, slave_clock_skew)
def test_scatterplotitem():
plot = pg.PlotWidget()
# set view range equal to its bounding rect.
# This causes plots to look the same regardless of pxMode.
plot.setRange(rect=plot.boundingRect())
for i, pxMode in enumerate([True, False]):
for j, useCache in enumerate([True, False]):
s = pg.ScatterPlotItem()
s.opts['useCache'] = useCache
plot.addItem(s)
s.setData(x=np.array([10,40,20,30])+i*100, y=np.array([40,60,10,30])+j*100, pxMode=pxMode)
s.addPoints(x=np.array([60, 70])+i*100, y=np.array([60, 70])+j*100, size=[20, 30])
# Test uniform spot updates
s.setSize(10)
s.setBrush('r')
s.setPen('g')
s.setSymbol('+')
app.processEvents()
# Test list spot updates
s.setSize([10] * 6)
s.setBrush([pg.mkBrush('r')] * 6)
s.setPen([pg.mkPen('g')] * 6)
s.setSymbol(['+'] * 6)
s.setPointData([s] * 6)
app.processEvents()
# Test array spot updates
s.setSize(np.array([10] * 6))
s.setBrush(np.array([pg.mkBrush('r')] * 6))
s.setPen(np.array([pg.mkPen('g')] * 6))
s.setSymbol(np.array(['+'] * 6))
s.setPointData(np.array([s] * 6))
app.processEvents()
# Test per-spot updates
spot = s.points()[0]
spot.setSize(20)
spot.setBrush('b')
spot.setPen('g')
spot.setSymbol('o')
spot.setData(None)
app.processEvents()
plot.clear()
def test_simple():
tempfilename = tempfile.NamedTemporaryFile(suffix='.svg').name
print("using %s as a temporary file" % tempfilename)
scene = pg.QtGui.QGraphicsScene()
#rect = pg.QtGui.QGraphicsRectItem(0, 0, 100, 100)
#scene.addItem(rect)
#rect.setPos(20,20)
#rect.translate(50, 50)
#rect.rotate(30)
#rect.scale(0.5, 0.5)
#rect1 = pg.QtGui.QGraphicsRectItem(0, 0, 100, 100)
#rect1.setParentItem(rect)
#rect1.setFlag(rect1.ItemIgnoresTransformations)
#rect1.setPos(20, 20)
#rect1.scale(2,2)
#el1 = pg.QtGui.QGraphicsEllipseItem(0, 0, 100, 100)
#el1.setParentItem(rect1)
##grp = pg.ItemGroup()
#grp.setParentItem(rect)
#grp.translate(200,0)
##grp.rotate(30)
#rect2 = pg.QtGui.QGraphicsRectItem(0, 0, 100, 25)
#rect2.setFlag(rect2.ItemClipsChildrenToShape)
#rect2.setParentItem(grp)
#rect2.setPos(0,25)
#rect2.rotate(30)
#el = pg.QtGui.QGraphicsEllipseItem(0, 0, 100, 50)
#el.translate(10,-5)
#el.scale(0.5,2)
#el.setParentItem(rect2)
grp2 = pg.ItemGroup()
scene.addItem(grp2)
grp2.scale(100,100)
rect3 = pg.QtGui.QGraphicsRectItem(0,0,2,2)
rect3.setPen(pg.mkPen(width=1, cosmetic=False))
grp2.addItem(rect3)
ex = pg.exporters.SVGExporter(scene)
ex.export(fileName=tempfilename)
os.unlink(tempfilename)
