void dialogAnalog::plot(bool forceRedraw,QSize size)
{
QPainter p;
screenPixmap = QPixmap( size);
if (forceRedraw)
{
initPixmap(size);
QColor greenColor(Qt::green);
QPen dataPen1( greenColor);
fillPixmap(&dataplot,&dataPen1);
#if 0
QPen dataPen2(QColor(Qt::red));
dataPen2.setStyle(Qt::DashDotDotLine);
fillPixmap(&dataplot2,&dataPen2);
#endif
}
p.begin(&screenPixmap);
p.drawPixmap(0, 0, lastPixmap);
drawMarkers(&p);
p.end(); // draw markers
}
void InsetMathEnsureMath::draw(PainterInfo & pi, int x, int y) const
{
bool really_change_font = isTextFont(from_ascii(pi.base.fontname));
FontSetChanger dummy(pi.base, "mathnormal", really_change_font);
cell(0).draw(pi, x, y);
drawMarkers(pi, x, y);
}
void TooltipView::
draw()
{
if (!model_->comment)
return;
if (!initialized)
initialize();
//if (visible)
{
drawMarkers();
if (model_->automarking == TooltipModel::AutoMarkerWorking)
{
TaskInfo ti("TooltipView doesn't have all data yet");
std::string prev_html = model_->comment->html();
model_->showToolTip( model_->pos() );
std::string html = model_->comment->html();
if (model_->automarking != TooltipModel::AutoMarkerWorking)
TaskInfo("TooltipView just finished\n%s", html.c_str());
else if(html != prev_html)
TaskInfo("Changed tooltip\n%s", html.c_str());
render_view_->redraw();
emit tooltipChanged();
}
}
}
void Picture_erase (Picture me) {
Graphics_clearRecording (my graphics.get());
Graphics_clearWs (my graphics.get());
if (my drawingArea) {
drawMarkers (me);
drawSelection (me, 1);
}
}
void InsetMathXArrow::draw(PainterInfo & pi, int x, int y) const
{
ScriptChanger dummy(pi.base);
Dimension const dim = dimension(*pi.base.bv);
Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
// center the cells with the decoration
cell(0).draw(pi, x + dim.width()/2 - dim0.width()/2, y - 10);
Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
cell(1).draw(pi, x + dim.width()/2 - dim1.width()/2, y + dim1.height());
mathed_draw_deco(pi, x + 1, y - 7, dim.wid - 2, 5, name_);
drawMarkers(pi, x, y);
}
void InsetMathUnderset::draw(PainterInfo & pi, int x, int y) const
{
Dimension const dim = dimension(*pi.base.bv);
Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
Dimension const & dim1 = cell(1).dimension(*pi.base.bv);
int m = x + dim.wid / 2;
int yo = y + dim1.descent() + dim0.ascent() + 1;
cell(1).draw(pi, m - dim1.width() / 2, y);
FracChanger dummy(pi.base);
cell(0).draw(pi, m - dim0.width() / 2, yo);
drawMarkers(pi, x, y);
}
void InsetMathBrace::draw(PainterInfo & pi, int x, int y) const
{
FontInfo font = pi.base.font;
augmentFont(font, from_ascii("mathnormal"));
font.setShape(UP_SHAPE);
font.setColor(Color_latex);
Dimension t = theFontMetrics(font).dimension('{');
pi.pain.text(x, y, '{', font);
cell(0).draw(pi, x + t.wid, y);
Dimension const & dim0 = cell(0).dimension(*pi.base.bv);
pi.pain.text(x + t.wid + dim0.width(), y, '}', font);
drawMarkers(pi, x, y);
}
void Inset::drawMarkers2(PainterInfo & pi, int x, int y) const
{
ColorCode pen_color = mouseHovered(pi.base.bv) || editing(pi.base.bv)?
Color_mathframe : Color_mathcorners;
drawMarkers(pi, x, y);
Dimension const dim = dimension(*pi.base.bv);
int const t = x + dim.width() - 1;
int const a = y - dim.ascent();
pi.pain.line(x, a + 3, x, a, pen_color);
pi.pain.line(t, a + 3, t, a, pen_color);
pi.pain.line(x, a, x + 3, a, pen_color);
pi.pain.line(t - 3, a, t, a, pen_color);
setPosCache(pi, x, y);
}
void InsetMathSqrt::draw(PainterInfo & pi, int x, int y) const
{
cell(0).draw(pi, x + 10, y);
Dimension const dim = dimension(*pi.base.bv);
int const a = dim.ascent();
int const d = dim.descent();
int xp[3];
int yp[3];
pi.pain.line(x + dim.width(), y - a + 1,
x + 8, y - a + 1, pi.base.font.color());
xp[0] = x + 8; yp[0] = y - a + 1;
xp[1] = x + 5; yp[1] = y + d - 1;
xp[2] = x; yp[2] = y + (d - a)/2;
pi.pain.lines(xp, yp, 3, pi.base.font.color());
drawMarkers(pi, x, y);
}
static void gui_drawingarea_cb_expose (Picture me, GuiDrawingArea_ExposeEvent event) {
#if gtk
/*
* The size of the viewable part of the drawing area may have changed.
*/
Melder_assert (event -> widget);
#if ALLOW_GDK_DRAWING
gdk_cairo_reset_clip ((cairo_t *) Graphics_x_getCR (my graphics.get()), GDK_DRAWABLE (GTK_WIDGET (event -> widget -> d_widget) -> window));
gdk_cairo_reset_clip ((cairo_t *) Graphics_x_getCR (my selectionGraphics.get()), GDK_DRAWABLE (GTK_WIDGET (event -> widget -> d_widget) -> window));
#endif
#else
(void) event;
#endif
drawMarkers (me);
Graphics_play (my graphics.get(), my graphics.get());
drawSelection (me, 1);
}
void RenderSVGShape::fillStrokeMarkers(PaintInfo& childPaintInfo)
{
auto paintOrder = style().svgStyle().paintTypesForPaintOrder();
for (unsigned i = 0; i < paintOrder.size(); ++i) {
switch (paintOrder.at(i)) {
case PaintTypeFill:
fillShape(style(), childPaintInfo.context());
break;
case PaintTypeStroke:
strokeShape(childPaintInfo.context());
break;
case PaintTypeMarkers:
if (!m_markerPositions.isEmpty())
drawMarkers(childPaintInfo);
break;
}
}
}
void MarkerDetector::findMarkers( cv::Mat& src, std::vector<Marker>& markers, bool draw_markers)
{
std::vector<Marker> loc_markers;
findMarkers(src, loc_markers);
_transformations.clear();
for (size_t i=0; i<loc_markers.size(); i++)
{
_transformations.push_back(loc_markers[i].transformation);
}
markers = loc_markers;
if(draw_markers)
drawMarkers(src, loc_markers);
}
void InsetMathComment::draw(PainterInfo & pi, int x, int y) const
{
cell(0).draw(pi, x + 1, y);
drawMarkers(pi, x, y);
}
void PeakMeter::paint(Graphics& g)
{
int x = 0;
int y = 1;
int width = TraKmeter::TRAKMETER_LABEL_WIDTH - 14;
int height = 13;
g.setColour(Colours::grey.brighter(0.6f));
g.fillRect(x, y, width + 3, height);
g.setColour(Colours::black);
g.drawRect(x, y, width + 3, height);
int x_2 = TraKmeter::TRAKMETER_LABEL_WIDTH + nInputChannels * (TraKmeter::TRAKMETER_SEGMENT_WIDTH + 6) - 1;
g.setColour(Colours::grey.brighter(0.6f));
g.fillRect(x + x_2, y, width + 3, height);
g.setColour(Colours::black);
g.drawRect(x + x_2 + x, y, width + 3, height);
String strMarker = "dB";
g.setColour(Colours::black);
g.setFont(12.0f);
drawMarkers(g, strMarker, x + 1, y + 1, width, height, Colours::black);
g.setColour(Colours::grey.brighter(0.6f));
g.fillRect((nWidth - 32) / 2, y, 32, height);
g.setColour(Colours::black);
g.drawRect((nWidth - 32) / 2, y, 32, height);
g.setColour(Colours::black);
g.drawFittedText("Peak", (nWidth - 32) / 2, y, 32, height, Justification::centred, 1, 1.0f);
y = nMeterPositionTop;
strMarker = "OVR";
g.setFont(12.0f);
g.setColour(Colour(0.00f, 1.0f, 1.0f, 1.0f));
drawMarkers(g, strMarker, x + 1, y, width, height, Colour(0.00f, 1.0f, 1.0f, 1.0f));
y -= round_to_int(nSegmentHeight / 2.0f);
for (int n = nNumberOfBars; n > 2; n -= 2)
{
int nLevel = nCrestFactor + n - 19;
if (nLevel > 0)
{
strMarker = "+" + String(nLevel);
}
else
{
strMarker = String(nLevel);
}
y += 2 * nSegmentHeight;
if (nLevel == nCrestFactor - 10)
{
g.setColour(Colours::white);
drawMarkers(g, strMarker, x + 1, y, width, height, Colours::white.darker(0.5f));
}
else
{
g.setColour(Colours::grey.brighter(0.1f));
drawMarkers(g, strMarker, x + 1, y, width, height, Colours::grey.darker(0.1f));
}
}
y -= round_to_int(nSegmentHeight / 2.0f);
strMarker = "LOW";
g.setColour(Colour(0.58f, 1.0f, 1.0f, 1.0f));
drawMarkers(g, strMarker, x + 1, y + 2 * nSegmentHeight, width, height, Colour(0.58f, 1.0f, 1.0f, 1.0f));
for (int nChannel = 0; nChannel < nInputChannels; nChannel++)
{
int nPositionX = TraKmeter::TRAKMETER_LABEL_WIDTH + nChannel * (TraKmeter::TRAKMETER_SEGMENT_WIDTH + 6) - 3;
nPositionX += (nChannel % 2) ? -2 : 2;
g.setColour(Colours::black.brighter(0.15f));
g.fillRect(nPositionX - 1, nMeterPositionTop - 1, TraKmeter::TRAKMETER_SEGMENT_WIDTH + 2, nHeight);
g.setColour(Colours::black);
g.fillRect(nPositionX, nMeterPositionTop, TraKmeter::TRAKMETER_SEGMENT_WIDTH, nSegmentHeight + 1);
}
}
void InsetMathPhantom::draw(PainterInfo & pi, int x, int y) const
{
static int const arrow_size = 4;
// We first draw the text and then an arrow
ColorCode const origcol = pi.base.font.color();
if (visibleContents())
pi.base.font.setColor(Color_special);
cell(0).draw(pi, x + 1, y);
if (visibleContents())
pi.base.font.setColor(origcol);
Dimension const dim = dimension(*pi.base.bv);
if (kind_ == phantom || kind_ == vphantom) {
// y1---------
// / \.
// y2----- / | \.
// |
// |
// y3----- \ | /
// \ /
// y4---------
// | | |
// / | \.
// x1 x2 x3
int const x2 = x + dim.wid / 2;
int const x1 = x2 - arrow_size;
int const x3 = x2 + arrow_size;
int const y1 = y - dim.asc;
int const y2 = y1 + arrow_size;
int const y4 = y + dim.des;
int const y3 = y4 - arrow_size;
// top arrow
pi.pain.line(x2, y1, x1, y2, Color_added_space);
pi.pain.line(x2, y1, x3, y2, Color_added_space);
// bottom arrow
pi.pain.line(x2, y4, x1, y3, Color_added_space);
pi.pain.line(x2, y4, x3, y3, Color_added_space);
// joining line
pi.pain.line(x2, y1, x2, y4, Color_added_space);
}
if (kind_ == phantom || kind_ == hphantom) {
// y1---- / \.
// / \.
// y2--- <---------------->
// \ /
// y3---- \ /
// | | | |
// x1 x2 x3 x4
int const x1 = x;
int const x2 = x + arrow_size;
int const x4 = x + dim.wid;
int const x3 = x4 - arrow_size;
int const y2 = y + (dim.des - dim.asc) / 2;
int const y1 = y2 - arrow_size;
int const y3 = y2 + arrow_size;
// left arrow
pi.pain.line(x1, y2, x2, y3, Color_added_space);
pi.pain.line(x1, y2, x2, y1, Color_added_space);
// right arrow
pi.pain.line(x4, y2, x3, y3, Color_added_space);
pi.pain.line(x4, y2, x3, y1, Color_added_space);
// joining line
pi.pain.line(x1, y2, x4, y2, Color_added_space);
}
else if (kind_ == mathclap) {
// y1---- \ /
// \ /
// y2--- -------->-<--------
// / \.
// y3---- / \.
// | | | | |
// x1 x2 x3 x4 x5
int const x1 = x;
int const x5 = x + dim.wid;
int const x3 = x + dim.wid / 2;
int const x2 = std::max(x1, x3 - arrow_size);
int const x4 = std::min(x5, x3 + arrow_size);
int const y2 = y + (dim.des - dim.asc) / 2;
int const y1 = y2 - arrow_size;
int const y3 = y2 + arrow_size;
// left arrow
pi.pain.line(x2, y3, x3, y2, Color_added_space);
pi.pain.line(x2, y1, x3, y2, Color_added_space);
// right arrow
pi.pain.line(x4, y3, x3, y2, Color_added_space);
pi.pain.line(x4, y1, x3, y2, Color_added_space);
// joining line
pi.pain.line(x1, y2, x5, y2, Color_added_space);
}
else if (kind_ == mathllap) {
// y1---- \.
// \.
// y2--- ------------------>
// /
// y3---- /
// | | |
// x1 x2 x3
int const x1 = x;
int const x3 = x + dim.wid;
int const x2 = std::max(x1, x3 - arrow_size);
int const y2 = y + (dim.des - dim.asc) / 2;
int const y1 = y2 - arrow_size;
int const y3 = y2 + arrow_size;
// right arrow
pi.pain.line(x3, y2, x2, y3, Color_added_space);
pi.pain.line(x3, y2, x2, y1, Color_added_space);
// joining line
pi.pain.line(x1, y2, x3, y2, Color_added_space);
}
else if (kind_ == mathrlap) {
// y1---- /
// /
// y2--- <------------------
// \.
// y3---- \.
// | | |
// x1 x2 x3
int const x1 = x;
int const x3 = x + dim.wid;
int const x2 = std::min(x3, x + arrow_size);
int const y2 = y + (dim.des - dim.asc) / 2;
int const y1 = y2 - arrow_size;
int const y3 = y2 + arrow_size;
// left arrow
pi.pain.line(x1, y2, x2, y3, Color_added_space);
pi.pain.line(x1, y2, x2, y1, Color_added_space);
// joining line
pi.pain.line(x1, y2, x3, y2, Color_added_space);
}
else if (kind_ == smash) {
// y1---------
// |
// y2----- \ | /
// \ /
// y3-------- |
// / \.
// y4----- / | \.
// |
// y5---------
// | | |
// / | \.
// x1 x2 x3
int const x2 = x + dim.wid / 2;
int const x1 = x2 - arrow_size;
int const x3 = x2 + arrow_size;
int const y1 = y - dim.asc;
int const y5 = y + dim.des;
int const y3 = y;
int const y2 = std::max(y1, y3 - arrow_size);
int const y4 = std::min(y5, y3 + arrow_size);
// top arrow
pi.pain.line(x1, y2, x2, y3, Color_added_space);
pi.pain.line(x3, y2, x2, y3, Color_added_space);
// bottom arrow
pi.pain.line(x1, y4, x2, y3, Color_added_space);
pi.pain.line(x3, y4, x2, y3, Color_added_space);
// joining line
pi.pain.line(x2, y1, x2, y5, Color_added_space);
}
drawMarkers(pi, x, y);
}
void InsetMathSize::draw(PainterInfo & pi, int x, int y) const
{
StyleChanger dummy(pi.base, style_);
cell(0).draw(pi, x + 1, y);
drawMarkers(pi, x, y);
}
void InsetMathLefteqn::draw(PainterInfo & pi, int x, int y) const
{
cell(0).draw(pi, x + 2, y);
drawMarkers(pi, x, y);
}
void InsetMathFrac::draw(PainterInfo & pi, int x, int y) const
{
setPosCache(pi, x, y);
Dimension const dim = dimension(*pi.base.bv);
Dimension const dim0 = cell(0).dimension(*pi.base.bv);
if (kind_ == UNIT || (kind_ == UNITFRAC && nargs() == 3)) {
if (nargs() == 1) {
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
cell(0).draw(pi, x + 1, y);
} else if (nargs() == 2) {
cell(0).draw(pi, x + 1, y);
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
cell(1).draw(pi, x + dim0.width() + 5, y);
} else {
cell(2).draw(pi, x + 1, y);
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
FracChanger dummy(pi.base);
Dimension const dim1 = cell(1).dimension(*pi.base.bv);
Dimension const dim2 = cell(2).dimension(*pi.base.bv);
int xx = x + dim2.wid + 5;
cell(0).draw(pi, xx + 2,
y - dim0.des - 5);
cell(1).draw(pi, xx + dim0.width() + 5,
y + dim1.asc / 2);
}
} else {
FracChanger dummy(pi.base);
Dimension const dim1 = cell(1).dimension(*pi.base.bv);
int m = x + dim.wid / 2;
if (kind_ == NICEFRAC) {
cell(0).draw(pi, x + 2,
y - dim0.des - 5);
cell(1).draw(pi, x + dim0.width() + 5,
y + dim1.asc / 2);
} else if (kind_ == UNITFRAC) {
ShapeChanger dummy2(pi.base.font, UP_SHAPE);
cell(0).draw(pi, x + 2, y - dim0.des - 5);
cell(1).draw(pi, x + dim0.width() + 5, y + dim1.asc / 2);
} else if (kind_ == FRAC || kind_ == ATOP || kind_ == OVER) {
cell(0).draw(pi, m - dim0.wid / 2, y - dim0.des - 2 - 5);
cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc + 2 - 5);
} else if (kind_ == TFRAC) {
// tfrac is in always in text size
StyleChanger dummy2(pi.base, LM_ST_SCRIPT);
cell(0).draw(pi, m - dim0.wid / 2, y - dim0.des - 2 - 5);
cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc + 2 - 5);
} else {
// \cfrac and \dfrac are always in display size
StyleChanger dummy2(pi.base, LM_ST_DISPLAY);
if (kind_ == CFRAC || kind_ == DFRAC)
cell(0).draw(pi, m - dim0.wid / 2, y - dim0.des - 2 - 5);
else if (kind_ == CFRACLEFT)
cell(0).draw(pi, x + 2, y - dim0.des - 2 - 5);
else if (kind_ == CFRACRIGHT)
cell(0).draw(pi, x + dim.wid - dim0.wid - 2,
y - dim0.des - 2 - 5);
cell(1).draw(pi, m - dim1.wid / 2, y + dim1.asc + 2 - 5);
}
}
if (kind_ == NICEFRAC || kind_ == UNITFRAC) {
// Diag line:
int xx = x;
if (nargs() == 3)
xx += cell(2).dimension(*pi.base.bv).wid + 5;
pi.pain.line(xx + dim0.wid,
y + dim.des - 2,
xx + dim0.wid + 5,
y - dim.asc + 2, pi.base.font.color());
}
if (kind_ == FRAC || kind_ == CFRAC || kind_ == CFRACLEFT
|| kind_ == CFRACRIGHT || kind_ == DFRAC
|| kind_ == TFRAC || kind_ == OVER)
pi.pain.line(x + 1, y - 5,
x + dim.wid - 2, y - 5, pi.base.font.color());
drawMarkers(pi, x, y);
}
void PlaybackMarkersView::
draw()
{
drawMarkers();
}
void AverageMeter::paint(Graphics& g)
{
int x = 0;
int y = nMeterHeight + nMeterPositionBottom - 13;
int width = TraKmeter::TRAKMETER_LABEL_WIDTH - 14;
int height = 13;
g.setColour(Colours::grey.brighter(0.6f));
g.fillRect(x, y, width + 3, height);
g.setColour(Colours::black);
g.drawRect(x, y, width + 3, height);
int x_2 = TraKmeter::TRAKMETER_LABEL_WIDTH + nInputChannels * (TraKmeter::TRAKMETER_SEGMENT_WIDTH + 6) - 1;
g.setColour(Colours::grey.brighter(0.6f));
g.fillRect(x + x_2, y, width + 3, height);
g.setColour(Colours::black);
g.drawRect(x + x_2 + x, y, width + 3, height);
String strMarker = "dB";
g.setColour(Colours::black);
g.setFont(12.0f);
drawMarkers(g, strMarker, x + 1, y + 1, width, height);
g.setColour(Colours::grey.brighter(0.6f));
g.fillRect((nWidth - 32) / 2, y, 32, height);
g.setColour(Colours::black);
g.drawRect((nWidth - 32) / 2, y, 32, height);
g.setColour(Colours::black);
g.drawFittedText("RMS", (nWidth - 30) / 2, y, 30, height, Justification::centred, 1, 1.0f);
y = 0;
strMarker = "HOT";
g.setFont(12.0f);
g.setColour(Colours::red);
drawMarkers(g, strMarker, x + 1, y, width, height);
y -= TraKmeter::TRAKMETER_SEGMENT_HEIGHT / 2;
for (int n = nNumberOfBars; n > 2; n -= 2)
{
int nLevel = nCrestFactor + n - 26;
if (nLevel > 0)
{
strMarker = "+" + String(nLevel);
}
else
{
strMarker = String(nLevel);
}
y += 2 * nSegmentHeight;
if (nLevel == nCrestFactor - 20)
{
g.setColour(Colours::white);
}
else
{
g.setColour(Colours::white.darker(0.4f));
}
drawMarkers(g, strMarker, x + 1, y, width, height);
}
y -= TraKmeter::TRAKMETER_SEGMENT_HEIGHT / 2;
strMarker = "LOW";
g.setColour(Colours::yellow);
drawMarkers(g, strMarker, x + 1, y + 2 * nSegmentHeight, width, height);
}
void CalibWidget::drawRectAndLED(QImage *_qimg,
const calib::LEDCalibContainer &container,
const calib::LEDCalibSample &sample,
const Camera *cam) {
const std::vector<cv::Point2f> &image_points = sample.image_points;
// draw the found markers on the image
drawMarkers(_qimg, image_points);
/**************************************************************
* Get the vectors from the LED calibrator
**************************************************************/
std::vector<cv::Point3f> objectPoints;
calib::LEDCalibPattern::getLEDObjectPoints(container.circleSpacing,
objectPoints);
Eigen::Matrix4d transformation;
// compute the transformation matrix
calib::LEDCalibPattern::makeTransformationMatrix(cam->getIntrisicMatrix(),
cam->getDistortion(),
sample.image_points,
objectPoints,
transformation);
// compute the normal
Eigen::Vector3d eig_normal;
calib::LEDCalibPattern::computeNormal(transformation, eig_normal);
// the vector from the camera centre to the intersection point
const Eigen::Vector3d vec_inters = calib::computeIntersectionPoint(sample.glint,
objectPoints,
eig_normal,
transformation,
*cam);
if(vec_inters(0) == 0 && vec_inters(1) == 0 && vec_inters(2) == 0) {
return;
}
// the vector reflected with respect to the intersection vector.
Eigen::Vector3d vec_reflect = calib::computeReflectionPoint(eig_normal,
vec_inters);
/**************************************************************
* Get and draw the glint
**************************************************************/
const cv::Point2d &glint = sample.glint;
{
QPainter painter(_qimg);
painter.drawArc(glint.x - 3, glint.y - 3, 6, 6, 0, 16*360);
/**************************************************************
* Map the reflected vector to 2D and draw it
**************************************************************/
double c = 3*container.circleSpacing;
cv::Point3d p3DStart;
p3DStart.x = vec_inters(0);
p3DStart.y = vec_inters(1);
p3DStart.z = vec_inters(2);
double uStart, vStart;
cam->worldToPix(p3DStart, &uStart, &vStart);
cv::Point3d p3DEnd;
p3DEnd.x = vec_inters(0) + c*vec_reflect(0);
p3DEnd.y = vec_inters(1) + c*vec_reflect(1);
p3DEnd.z = vec_inters(2) + c*vec_reflect(2);
double uEnd, vEnd;
cam->worldToPix(p3DEnd, &uEnd, &vEnd);
painter.setPen(Qt::red);
painter.drawLine((int)(uStart + 0.5), (int)(vStart + 0.5),
(int)(uEnd + 0.5), (int)(vEnd + 0.5));
/*******************************************************************************
* Map the normal vector to 2D and draw it
*******************************************************************************/
p3DEnd.x = vec_inters(0) + c*eig_normal(0);
p3DEnd.y = vec_inters(1) + c*eig_normal(1);
p3DEnd.z = vec_inters(2) + c*eig_normal(2);
cam->worldToPix(p3DEnd, &uEnd, &vEnd);
painter.setPen(Qt::blue);
painter.drawLine((int)(uStart + 0.5), (int)(vStart + 0.5),
(int)(uEnd + 0.5), (int)(vEnd + 0.5));
}
/**************************************************
* Compute the transformed object points
**************************************************/
// get the normalised object points
const std::vector<cv::Point3f> &norm_object_points = container.normalisedObjectPoints;
// define the transformed object points
std::vector<cv::Point3f> trans_obj_points(norm_object_points.size());
// compute the transformed object points
computeTransormedPoints(norm_object_points,
container.circleSpacing,
transformation,
trans_obj_points);
{
QPainter painter(_qimg);
painter.setPen(Qt::yellow);
int x = 10;
int y = 15;
for(size_t i = 0; i < trans_obj_points.size(); ++i) {
const cv::Point3f &curPoint = trans_obj_points[i];
QString str;
str.sprintf("%d: (%.2f, %.2f, %.2f)", (int)i, curPoint.x, curPoint.y, curPoint.z);
painter.drawText(x, y, str);
y += 20;
}
}
}
