def __init__(self, parent=None): QtGui.QGraphicsScene.__init__(self, parent) #set the size of the scene self.setSceneRect(0,0,2000,2000) #self.addRect(QtCore.QRectF(800,800,200,200)) #---create the scene-geometries --- #empty list to hold the geometries self.geos = [] #create stuff to add to the scene geo_01 = QtGui.QGraphicsEllipseItem(800,800,200,200) geo_02 = QtGui.QGraphicsEllipseItem(850,850,300,300) geo_03 = QtGui.QGraphicsEllipseItem(900,900,400,400) #add stuff to the scene self.addItem(geo_01) self.addItem(geo_02) self.addItem(geo_03) #put stuff into list so it can be referenced self.geos.append(geo_01) self.geos.append(geo_02) self.geos.append(geo_03) #----do the animation thing--- self.animator = QtCore.QTimer() self.animator.timeout.connect(self.animate) self.animate()
def __init__(self, viewBox, shape):
self.showed = False
self.vb = viewBox
self.shape = shape
pen = pg.mkPen(color=(255, 255, 0),
width=1.5,
style=QtCore.Qt.DotLine,
antialias=True)
pen2 = pg.mkPen(color=(255, 255, 0),
width=1,
style=QtCore.Qt.SolidLine,
antialias=True)
self.yline3 = pg.InfiniteLine(pen=pen2)
self.xline3 = pg.InfiniteLine(pen=pen2, angle=0)
self.rect0 = QtGui.QGraphicsRectItem()
self.rect0.setPen(pen)
self.rect1 = QtGui.QGraphicsRectItem()
self.rect1.setPen(pen)
self.rect2 = QtGui.QGraphicsRectItem()
self.rect2.setPen(pen)
self.circle = QtGui.QGraphicsEllipseItem()
self.circle.setPen(pen)
self.update(self.shape)
def mousePressEvent(self, event):
super(PhotoViewer, self).mousePressEvent(event)
if self.boolSetPath:
self.loopStart = 0
rad = 7
pen = QtGui.QPen(QtCore.Qt.red, 4, QtCore.Qt.SolidLine)
pos = self.mapToScene(event.x(), event.y())
self._save.append((event.x(), event.y()))
self.globalCircleItem.append(
QtGui.QGraphicsEllipseItem(pos.x(), pos.y(), rad, rad))
self.globalItem.append(self.globalCircleItem[-1])
self.globalCircleItem[-1].setPen(pen)
#self._scene.addEllipse(pos.x(), pos.y(), rad, rad, pen)
self._scene.addItem(self.globalCircleItem[-1])
self._pos.append(pos)
if len(self._pos) > 1:
start = self._pos[-2]
end = self._pos[-1]
self.globalConnectItem.append(
QtGui.QGraphicsLineItem(QtCore.QLineF(start, end)))
self.globalItem.append(self.globalConnectItem[-1])
self._scene.addItem(self.globalConnectItem[-1])
else:
QtGui.QMessageBox.information(
self, 'INFO',
"Enter the image and annotation paths to mark the joints!",
QtGui.QMessageBox.Ok)
def ellipse(self,
x,
y,
w,
h,
fill=False,
color=None,
penwidth=None,
add=True):
"""Mimicks canvas api. See openexp._canvas.canvas."""
color = self._color(color)
if fill:
pen = self._pen(color, 1)
brush = self._brush(color)
else:
pen = self._pen(color, penwidth)
brush = QtGui.QBrush()
i = QtGui.QGraphicsEllipseItem(self._x(x), self._y(y), self._w(w),
self._h(h))
i.setPen(pen)
i.setBrush(brush)
if add:
self.addItem(i)
return i
def test_mask_data():
# create Gaussian image:
img_size = 500
x = np.arange(img_size)
y = np.arange(img_size)
X, Y = np.meshgrid(x, y)
center_x = img_size / 2
center_y = img_size / 2
width = 30000.0
intensity = 5000.0
img_data = intensity * \
np.exp(-((X - center_x) ** 2 + (Y - center_y) ** 2) / width)
mask_data = MaskData(img_data.shape)
# test the undo and redo commands
mask_data.mask_above_threshold(img_data, 4000)
mask_data.mask_below_threshold(img_data, 230)
mask_data.undo()
mask_data.undo()
mask_data.redo()
mask_data.redo()
mask_data.undo()
mask_data.mask_rect(200, 400, 400, 100)
mask_data.mask_QGraphicsRectItem(
QtGui.QGraphicsRectItem(100, 10, 100, 100))
mask_data.undo()
mask_data.mask_polygon(
np.array([0, 100, 150, 100, 0]), np.array([0, 0, 50, 100, 100]))
mask_data.mask_QGraphicsPolygonItem(
QtGui.QGraphicsEllipseItem(350, 350, 20, 20))
# performing the plot
pg.image(mask_data.get_img())
def draw_point(self,
point,
group=None,
color=QtCore.Qt.black,
info=None,
first_point=False,
large=False):
w = 50
h = 50
if first_point:
info += " polyline-first-point"
elif large:
w *= 4
h *= 4
item = QtGui.QGraphicsEllipseItem(point.x - w / 2, point.y - h / 2, w,
h)
item.setBrush(color)
item.info = info
item.road_item = point
item.is_a_line = False
item.is_selectable = True
if group:
group.items.append(item)
self.addItem(item)
return item
def update(self):
super(GraphicsLabel, self).update()
mid_x = const.ccWidgetDim // 2
mid_y = const.ccWidgetDim // 2
line_pen = QtGui.QPen(QtCore.Qt.yellow)
line_pen.setCapStyle(QtCore.Qt.RoundCap)
line_pen.setWidth(2)
coeff = const.ccWidgetDim / self.image.shape[0]
print('coeff = {0}'.format(coeff))
for item in self.scene.items()[:-1]:
self.scene.removeItem(item)
for e in self.parent().ellipses:
aa = e.a * coeff
bb = e.b * coeff
b = min(aa, bb)
a = max(aa, bb)
e_item = QtGui.QGraphicsEllipseItem(mid_x - a, mid_y - b, 2 * a, 2 * b)
e_item.setTransformOriginPoint(mid_x, mid_y)
print(e.tau, ran.rad2deg(e.tau))
e_item.setRotation(ran.rad2deg(e.tau))
e_item.setPen(line_pen)
self.scene.addItem(e_item)
def __init__(self,
id,
idSubSon,
subautomata,
x,
y,
isInit,
name,
windowId=0):
self.id = id
self.idSubautSon = idSubSon
self.subautomata = subautomata
self.x = x - NODE_WIDTH / 2
self.y = y - NODE_WIDTH / 2
self.isInit = isInit
self.name = name
self.copies = []
self.windowId = windowId
self.color = "blue"
#CREATE GUI ELEMENTS
self.ellipse = self.State(self, self.x, self.y, NODE_WIDTH)
self.text = QtGui.QGraphicsSimpleTextItem(self.name)
self.text.setPos(self.x, self.y + NODE_WIDTH)
if self.isInit:
self.ellipseInit = QtGui.QGraphicsEllipseItem(
self.x + 5, self.y + 5, INIT_WIDTH, INIT_WIDTH)
else:
self.ellipseInit = None
self.paint("blue", PEN_NORMAL_WIDTH)
def __init__(self, parentItem, Z=1, umpx=1):
Overlay.__init__(self, parentItem, Z=Z)
self.opt = set(['xmass', 'ymass', 'radius', 'angle'])
self.circle = QtGui.QGraphicsEllipseItem(parent=self)
self.circle.setPen(self.pen)
self.circle.setPos(0, 0)
self.umpx = umpx
def updateNodePosAndSize(self, id, newLabel=None):
params = self.params
qt = self.qtScene
if id not in self.nodes.keys():
nodeItem = QtGui.QGraphicsEllipseItem(0, 0, 0, 0)
labelItem = QtGui.QGraphicsSimpleTextItem(str(id))
self.nodePens[id] = (QtGui.QPen(), QtGui.QBrush(), QtGui.QPen())
self.nodes[id] = (nodeItem, labelItem)
self.invokeGui(qt.addItem, nodeItem)
self.invokeGui(qt.addItem, labelItem)
else:
(nodeItem, labelItem) = self.nodes[id]
node = self.scene.nodes[id]
nodesize = node.scale * params.nodesize
(nodePen, nodeBrush, labelPen) = self.nodePens[id]
x1 = node.pos[0] - nodesize
y1 = node.pos[1] - nodesize
self.invokeGui(nodeItem.setRect, x1, y1, nodesize * 2, nodesize * 2)
if newLabel:
newLabelItem = QtGui.QGraphicsSimpleTextItem(newLabel)
newLabelItem.setPen(labelPen)
self.invokeGui(qt.removeItem, labelItem)
self.invokeGui(qt.addItem, newLabelItem)
labelItem = newLabelItem
self.nodes[id] = (nodeItem, newLabelItem)
(x, y, w, h) = labelItem.boundingRect().getRect()
self.invokeGui(labelItem.setPos, node.pos[0] - w / 2,
node.pos[1] - h / 2)
for l in self.nodeLinks[id]:
self.updateLink(*l)
def __init__(self, color, parent):
super().__init__(parent)
height, width = self.SIZE.height(), self.SIZE.width()
self.__circle = QtGui.QGraphicsEllipseItem(0, 0, height, width)
self.__circle.setBrush(QtGui.QBrush(color))
self.__circle.setPen(QtGui.QPen(QtGui.QColor(0, 0, 0, 0)))
self.__circle.setParentItem(self)
def __init__(self, *args, **kwargs):
PoolItem.__init__(self, *args, **kwargs)
self.setFlag(QtGui.QGraphicsItem.ItemIsMovable, True)
self.bgColor = QtGui.QGraphicsEllipseItem(self)
self.bgColor.setFlag(QtGui.QGraphicsItem.ItemStacksBehindParent, True)
self.bgColor.setRect(((self.gobj.boundingRect().width() +
PoolItem.fontMetrics.width(' ')) / 2) - 5,
self.gobj.boundingRect().height() / 2 - 5, 10, 10)
def add_ellipse(self, stain):
if stain.ellipse != None:
ellipse = QtGui.QGraphicsEllipseItem(stain.x_ellipse - (stain.width / 2), stain.y_ellipse - (stain.height / 2), stain.width, stain.height)
ellipse.setTransformOriginPoint(QtCore.QPointF(stain.x_ellipse, stain.y_ellipse ))
ellipse.setRotation(stain.angle)
pen = QtGui.QPen(QtCore.Qt.green)
pen.setWidth(3)
ellipse.setPen(pen)
self.annotation_items.addToGroup(ellipse)
def circle(self, x, y, r, id, linestyle, fillstyle):
qt = self.qtScene
if id in self.shapes.keys():
self.invokeGui(qt.removeItem, self.shapes[id])
del self.shapes[id]
shape = QtGui.QGraphicsEllipseItem(x - r, y - r, 2 * r, 2 * r)
self.shapes[id] = shape
self.attachStyles(shape, linestyle, fillstyle)
self.invokeGui(qt.addItem, shape)
def __init__(self):
QtGui.QGraphicsView.__init__(self)
self.scene = QtGui.QGraphicsScene(self)
for xIdx in range(100):
for yIdx in range(100):
item = QtGui.QGraphicsEllipseItem(xIdx * 80, yIdx * 30, 40, 20)
self.scene.addItem(item)
self.setScene(self.scene)
def render_position(self, position, is_selected):
circle = QtGui.QGraphicsEllipseItem(position[0] - 25, position[1] - 25,
50, 50)
if is_selected:
circle.setPen(self.position_selected_pen)
else:
circle.setPen(self.position_pen)
self.scene().addItem(circle)
def update_view(self):
self.scene().clear()
if self.binary_id is not None:
circle = QtGui.QGraphicsEllipseItem(10, 10, 80, 80)
circle.setPen(self.white_pen)
circle.setBrush(self.white_brush)
self.scene().addItem(circle)
for i, digit in enumerate(self.binary_id):
section = TagSection(i, self.flip_id_bit)
section.setStartAngle(90 * 16 + i * 30 * 16 -
self.rotation * 16)
section.setSpanAngle(30 * 16)
section.setPen(self.white_pen)
if digit:
section.setBrush(self.white_brush)
else:
section.setBrush(self.black_brush)
self.scene().addItem(section)
inner_circle = QtGui.QGraphicsEllipseItem(34, 34, 32, 32)
inner_circle.setPen(self.white_pen)
inner_circle.setBrush(self.white_brush)
self.scene().addItem(inner_circle)
inner_half = QtGui.QGraphicsEllipseItem(34, 34, 32, 32)
inner_half.setStartAngle(180 * 16 - self.rotation * 16)
inner_half.setSpanAngle(180 * 16)
inner_half.setPen(self.white_pen)
inner_half.setBrush(self.black_brush)
self.scene().addItem(inner_half)
id_text = QtGui.QGraphicsSimpleTextItem(
str(aux.binary_id_to_int(self.binary_id)))
id_text.setPos(0, 0)
id_text.setBrush(self.black_brush)
self.scene().addItem(id_text)
rotate_button = RotateButton(80, 80, self.rotate_tag)
rotate_button.setPen(self.no_pen)
rotate_button.setBrush(self.button_brush)
self.scene().addItem(rotate_button)
def __init__(self, **opts):
if 'scale' not in opts:
opts['scale'] = [20e-6, 20e-6]
item = QtGui.QGraphicsEllipseItem(-0.5, -0.5, 1., 1.)
item.setPen(pg.mkPen((255, 255, 255)))
item.setBrush(pg.mkBrush((0, 100, 255)))
opts.setdefault('scalable', False)
opts.setdefault('rotatable', False)
CanvasItem.__init__(self, item, **opts)
self.selectBox.addTranslateHandle([0.5, 0.5])
def addSpot(self, pos, size):
"""Add a circle to the image"""
s2 = size / 2.0
s = QtGui.QGraphicsEllipseItem(0, 0, 1, 1)
s.scale(size, size)
s.setPos(pos[0] - s2, pos[1] - s2)
s.setPen(QtGui.QPen(QtGui.QColor(100, 255, 100, 70)))
self.ui.view.addItem(s)
s.setZValue(100)
self.spots.append(s)
def __init__(self, pen, x0, y0, w, h, filled=False):
Shape.__init__(self)
self.drawn = False
self.pen = pen.copy()
self.filled = filled
self.item = QtGui.QGraphicsEllipseItem()
self.item.setRect(QtCore.QRectF(x0 - w, y0 - h, w * 2, h * 2))
self.item.setStartAngle(180)
self.item.setSpanAngle(360 * 16)
def markLargeGoldParticles(self, event):
self.largeGoldParticleCoordinates.append(event.pos())
pointDiam = 8
tmpEllipse = QtGui.QGraphicsEllipseItem(
self.largeGoldParticleCoordinates[-1].x() - pointDiam / 2,
self.largeGoldParticleCoordinates[-1].y() - pointDiam / 2,
pointDiam, pointDiam)
tmpEllipse.setPen(QtGui.QPen(QtCore.Qt.blue, 2))
self.scene.addItem(tmpEllipse)
self.largeGoldParticleLcdNumber.display(
len(self.largeGoldParticleCoordinates))
def draw_point(self, point, road_item, color=QtCore.Qt.black):
w = 0.3
h = 0.3
graphics_item = QtGui.QGraphicsEllipseItem(-w / 2.0, -h / 2.0, w, h)
graphics_item.setPos(point.x, point.y)
graphics_item.setPen(color)
graphics_item.setBrush(color)
self.addItem(graphics_item)
graphics_item.road_item = road_item
graphics_item.is_selectable = True
return graphics_item
def __init__(self, parentItem, Z=1):
Overlay.__init__(self, parentItem, Z=Z)
self.opt = set(['profile', 'iA', 'iB', 'iC', 'iD', 'roi', 'crop'])
# Create Points attributes, iA, iB, etc
for p in self.opt:
if not p.startswith('i'):
continue
g = QtGui.QGraphicsEllipseItem(parent=self)
g.setPen(self.pen)
g.setZValue(self.Z)
g.setPos(0, 0)
setattr(self, p, g)
def mousePressEvent(self, event):
self._start = event.pos()
self.lastMousePos = event.pos()
radius = 10
pos = QtCore.QPointF(self.mapToScene(event.pos()))
ellipseItem = QtGui.QGraphicsEllipseItem(pos.x()-(radius/2), pos.y()-(radius/2), radius, radius)
ellipseItem.setPen(QtGui.QPen(QtCore.Qt.green, QtCore.Qt.SolidPattern))
ellipseItem.setBrush(QtCore.Qt.green)
self.scene().addItem(ellipseItem)
def __init__(self, *args, **kwargs):
KineticsDisplayItem.__init__(self, *args, **kwargs)
self.gobj = QtGui.QGraphicsEllipseItem(0, 0, EnzItem.defaultWidth,
EnzItem.defaultHeight, self)
self.gobj.mobj = self.mobj
# classname = 'EnzBase'
# doc = moose.element('/classes/%s' % (classname)).docs
# doc = doc.split('Description:')[-1].split('Name:')[0].strip()
self._Km = self.gobj.mobj.Km
self._Kcat = self.gobj.mobj.kcat
doc = "Km\t: " + str(self._Km) + "\nKcat\t: " + str(self._Kcat)
self.gobj.setToolTip(doc)
def __init__(self, uid):
QtGui.QGraphicsView.__init__(self)
self.id = uid
self.strokes = {} ## all strokes in scene, keyed by (origin, id)
#self.newStrokes = [] ## self-drawn strokes generated since last call to getNewStrokes
self.nextId = 0 ## id of next stroke to draw
self.setScene(QtGui.QGraphicsScene())
self.lastPos = None
self.lastWidth = 0
self.lastEvent = None
self.range = QtCore.QRectF(0, 0, 1, 1)
self.aspectLocked = True
self.scaleCenter = False
self.keysPressed = {}
self.noRepeatKeys = [QtCore.Qt.Key_Right, QtCore.Qt.Key_Left, QtCore.Qt.Key_Up, QtCore.Qt.Key_Down, QtCore.Qt.Key_PageUp, QtCore.Qt.Key_PageDown, QtCore.Qt.Key_Q, QtCore.Qt.Key_W, QtCore.Qt.Key_A, QtCore.Qt.Key_S, QtCore.Qt.Key_Z, QtCore.Qt.Key_X, QtCore.Qt.Key_Plus, QtCore.Qt.Key_Minus, QtCore.Qt.Key_Equal]
self.transformKeys = [QtCore.Qt.Key_Right, QtCore.Qt.Key_Left, QtCore.Qt.Key_Up, QtCore.Qt.Key_Down]
self.antialiasDuringTransform = False
self.fullScreen = False
#self.showFullScreen()
self.peniSize = 1.0
self.hue = 0
self.sat = 0
self.val = 255
#self.setSceneRect(QtCore.QRectF(-1e9, -1e9, 2e9, 2e9))
self.setFrameStyle(1)
self.setLineWidth(0)
self.setMidLineWidth(0)
#self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
#self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
#self.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
#self.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.setTransformationAnchor(QtGui.QGraphicsView.NoAnchor)
self.setResizeAnchor(QtGui.QGraphicsView.AnchorViewCenter)
self.setViewportUpdateMode(QtGui.QGraphicsView.MinimalViewportUpdate)
brush = QtGui.QBrush(QtGui.QColor(0,0,0))
self.setBackgroundBrush(brush)
self.setRenderHint(QtGui.QPainter.Antialiasing, True)
self.antialias = True
self.setOptimizationFlags(self.DontSavePainterState)
self.keyTimer = QtCore.QTimer()
self.keyTimer.timeout.connect(self.handleKeys)
#self.keyTimer.start(30)
self.penSample = QtGui.QGraphicsEllipseItem()
self.scene().addItem(self.penSample)
self.penSample.hide()
self.penFader = QtCore.QTimer()
self.penFader.timeout.connect(self.stepPenFade)
def _load_ellipse(svg_ellipse):
pen = _svg_attrib_to_pen(svg_ellipse.attrib)
x = float(svg_ellipse.attrib['cx']) - float(svg_ellipse.attrib['rx'])
y = float(svg_ellipse.attrib['cy']) - float(svg_ellipse.attrib['ry'])
ellipse = QtGui.QGraphicsEllipseItem(x,
y,
float(svg_ellipse.attrib['rx']) * 2,
float(svg_ellipse.attrib['ry']) * 2)
ellipse.setPen(pen)
ellipse.setFlag(QtGui.QGraphicsItem.ItemIsSelectable)
ellipse.setFlag(QtGui.QGraphicsItem.ItemIsMovable)
return ellipse
def __init__(self):
QtGui.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.cmdHBar.clicked.connect(self.cmdHBar_clicked)
self.cmdVBar.clicked.connect(self.cmdVBar_clicked)
self.cmdCircle.clicked.connect(self.cmdCircle_clicked)
self.chkSaturate.clicked.connect(self.chkSaturate_clicked)
self.graphicsView.scene = QtGui.QGraphicsScene(self)
self.item = QtGui.QGraphicsEllipseItem(50, 50, 40, 20)
self.graphicsView.scene.addItem(self.item)
self.graphicsView.show()
def __init__(self, size, parent=None):
QtGui.QGraphicsItemGroup.__init__(self, parent)
self._yawLine = QtGui.QGraphicsLineItem()
self._yawLine.setLine(0, -size, 0, size)
self._yawLine.setPen(QtGui.QPen(QtGui.QColor(*config.SHOOTING_COLOR_SCHEME[config.COLOR_SCHEME]['head'])))
self.addToGroup(self._yawLine)
self._pitchLine = QtGui.QGraphicsLineItem()
self._pitchLine.setLine(-size, 0, size, 0)
self._pitchLine.setPen(QtGui.QPen(QtGui.QColor(*config.SHOOTING_COLOR_SCHEME[config.COLOR_SCHEME]['head'])))
self.addToGroup(self._pitchLine)
self._circle = QtGui.QGraphicsEllipseItem(-size / 2, -size / 2, size, size)
self._circle.setPen(QtGui.QPen(QtGui.QColor(*config.SHOOTING_COLOR_SCHEME[config.COLOR_SCHEME]['head'])))
self.addToGroup(self._circle)
def __init__(self, vehicle_event_dispatcher, ui_event_dispatcher):
QtGui.QWidget.__init__(self)
BasePanelController.__init__(self)
self.ui = Ui_ReceiverCalibrationPanel()
self.ui.setupUi(self)
self.ui.start.setEnabled(True)
self.ui.cancel.setEnabled(False)
leftStickScene = QtGui.QGraphicsScene()
leftStickBackground = QtGui.QPixmap("./resources/TxDial.png")
leftStickItem = QtGui.QGraphicsPixmapItem(leftStickBackground)
leftStickScene.addItem(leftStickItem)
self.leftStick = QtGui.QGraphicsEllipseItem(QtCore.QRectF(75, 75, 30, 30))
self.leftStick.setPen(QtGui.QPen(QtGui.QBrush(QtCore.Qt.black, QtCore.Qt.SolidPattern), 2))
self.leftStick.setBrush(QtGui.QBrush(QtCore.Qt.blue, QtCore.Qt.SolidPattern))
leftStickScene.addItem(self.leftStick)
self.ui.leftTransmitter.setScene(leftStickScene)
rightStickScene = QtGui.QGraphicsScene()
rightStickBackground = QtGui.QPixmap("./resources/TxDial.png")
rightStickItem = QtGui.QGraphicsPixmapItem(rightStickBackground)
rightStickScene.addItem(rightStickItem)
self.rightStick = QtGui.QGraphicsEllipseItem(QtCore.QRectF(75, 75, 30, 30))
self.rightStick.setPen(QtGui.QPen(QtGui.QBrush(QtCore.Qt.black, QtCore.Qt.SolidPattern), 2))
self.rightStick.setBrush(QtGui.QBrush(QtCore.Qt.blue, QtCore.Qt.SolidPattern))
rightStickScene.addItem(self.rightStick)
self.ui.rightTransmitter.setScene(rightStickScene)
self.running = False
self.amount_channels = 12
self.RCmin = [1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500]
self.RCmax = [1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500, 1500]
self.max_amount_channels = 12
self.ui.start.clicked.connect(self.start_RCcalibration)
self.ui.cancel.clicked.connect(self.cancel_RCcalibration)
