// return the center of the key over the point p.
//
Vec2 TouchTracker::getKeyCenterAtPoint(const Vec2 p)
{
float x = p.x();
float y = p.y();
int ix, iy;
float fx, fy;
switch (mKeyboardType)
{
case(rectangularA):
default:
MLRange xRange(3.5f, 59.5f);
xRange.convertTo(MLRange(1.f, 29.f));
float kx = xRange(x);
kx = clamp(kx, 0.f, 30.f);
ix = kx;
MLRange yRange(1.25, 5.75); // Soundplane A as measured
yRange.convertTo(MLRange(1.f, 4.f));
float ky = yRange(y);
ky = clamp(ky, 0.f, 5.f);
iy = ky;
MLRange xRangeInv(1.f, 29.f);
xRangeInv.convertTo(MLRange(3.5f, 59.5f));
fx = xRangeInv(ix + 0.5f);
MLRange yRangeInv(1.f, 4.f);
yRangeInv.convertTo(MLRange(1.25, 5.75));
fy = yRangeInv(iy + 0.5f);
break;
}
return Vec2(fx, fy);
}
// return the index of the key over the point p.
//
int TouchTracker::getKeyIndexAtPoint(const Vec2 p)
{
int k = -1;
float x = p.x();
float y = p.y();
int ix, iy;
switch (mKeyboardType)
{
case(rectangularA):
default:
MLRange xRange(3.5f, 59.5f);
xRange.convertTo(MLRange(1.f, 29.f));
float kx = xRange(x);
kx = clamp(kx, 0.f, 29.f);
ix = kx;
MLRange yRange(1.25, 5.75); // Soundplane A as measured
yRange.convertTo(MLRange(1.f, 4.f));
float ky = yRange(y);
ky = clamp(ky, 0.f, 4.f);
iy = ky;
k = iy*30 + ix;
break;
}
return k;
}
void CCombinedLoopFunctions::AddOneFood(){
/*bool added = false;
for(UInt32 j = 0; j < foodPatches.size(); j++){
while(foodPatches[j].size() < NbFoodItems && !added){
CRange<Real> xRange((foodPatchCenters[j].GetX() - (foodPatchSizes[j].GetX()/2)), (foodPatchCenters[j].GetX() + (foodPatchSizes[j].GetX()/2)));
CRange<Real> yRange((foodPatchCenters[j].GetY() - (foodPatchSizes[j].GetY()/2)), (foodPatchCenters[j].GetY() + (foodPatchSizes[j].GetY()/2)));CVector2 pos(m_pcRNG->Uniform(xRange), m_pcRNG->Uniform(yRange));
if(!InNest(pos)){
foodPatches[j].push_back(pos);
added = true;
}
}
added = false;
}*/
bool added = false;
for(UInt32 j = 0; j < foodPatches.size(); j++){
while(foodPatches[j].size() < NbFoodItems && !added){
CRange<Real> xRange((foodPatchCenters[j].GetX() - (foodPatchSizes[j].GetX()/2)), (foodPatchCenters[j].GetX() + (foodPatchSizes[j].GetX()/2)));
CRange<Real> yRange((foodPatchCenters[j].GetY() - (foodPatchSizes[j].GetY()/2)), (foodPatchCenters[j].GetY() + (foodPatchSizes[j].GetY()/2)));
CVector2 pos(m_pcRNG->Uniform(xRange), m_pcRNG->Uniform(yRange));
if(!CloseToNest(pos) && !CloseToArenaEnd(pos)){
foodPatches[j].push_back(pos);
added = true;
}
}
added = false;
}
}
void HexMap::generateMountainRange(mt19937& urng)
{
static sf::Color mt(128, 88, 44);
static vector<VectorSet> splat = { { { 1, -1 }, { 2, -1 }, { 0, 0 }, { 1, 0 }, { -1, 1 }, { 0, 1 }, { -2, 2 }, { -1, 2 }, { 0, 2 } },
{ { 1, -2 }, { 0, -1 }, { 1, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, { -1, 1 }, { 0, 1 }, { -1, 2 }, { 0, 2 } },
{ { 0, -1 }, { 1, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, { -1, 1 }, { 0, 1 } },
{ { 0, -1 }, { 1, -1 }, { 2, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, { -1, 1 }, { 0, 1 }, { 1, 1 } },
{ { 0, -2 }, { 1, -2 }, { -1, -1 }, { 0, -1 }, { 1, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, { -1, 1 } },
{ { -1, -1 }, { 0, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, { -2, 1 }, { -1, 1 }, { 0, 1 } },
{ { -1, 0 }, { 1, 0 }, { 0, 0 }, { -2, 1 }, { -1, 1 }, { 0, 1 }, { 1, 1 }, { -2, 2 }, { -1, 2 }, { 0, 2 } },
{ { 0, -2 }, { 1, -2 }, { 0, -1 }, { 1, -1 }, { 2, -1 }, { -1, 0 }, { 0, 0 }, { 1, 0 }, { 0, 1 } } };
sf::VertexArray va;
static sf::Vector2f w[4];
sf::Vector2f offset = { (float)rng::getInt(2, 85, urng), (float)rng::getInt(2, 85, urng) };
for (int a = 0; a < 100; a++) {
w[0] = { (float)xRange(urng), (float)yRange(urng) };
if (isAxialInBounds((sf::Vector2i)w[0]) && getAxial((int)w[0].x, (int)w[0].y).hts->FLAGS[HexTileS::WALKABLE]) {
break;
}
}
w[3] = { (float)rng::radians(urng), (float)rng::getInt(10, 40, urng) };
polarToCartesian(w[3]);
w[3] = roundvf(w[0] + w[3]);
sf::Vector2f avg = { (w[3] + w[0]) / 2.0f };
// sqrt(a^2 + b^2)
int dist = (int)sqrtf(powf(abs(w[3].x - w[0].x), 2.0f) + powf(abs(w[3].x - w[0].x), 2.0f));
for (int a = 1; a < 3; a++) {
// Distance between the middle points and the endpoint average cannot be greater
// than the distance between the endpoints, to prevent any super-sharp curves
w[a] = { (float)rng::radians(urng), (float)rng::getInt(10, clamp(dist, 10, 40), urng) };
polarToCartesian(w[a]);
w[a] = roundvf(w[a] + avg);
}
float advance = 1.0f / Bezier::lengthCubic(w);
VectorSet h;
sf::Vector2f p;
for (float f = 0.0f; f < 1.0f; f += advance) {
Bezier::curveCubic(p, f, w);
if (!isAxialInBounds((sf::Vector2i)p) || !getAxial((int)p.x, (int)p.y).hts->FLAGS[HexTileS::WALKABLE]) {
break;
}
VectorSet& s = splat[rng::getInt(0, splat.size() - 1, urng)];
for (auto r : s) {
h.insert((sf::Vector2i)axialToOffset(roundHex((sf::Vector2f)r + p)));
}
p = { 0.0f, 0.0f };
}
HexTile* cTile = nullptr;
for (auto& l : h) {
cTile = &getOffset(l.x, l.y);
if (!isOffsetInBounds((sf::Vector2i)l) || !cTile->hts->FLAGS[HexTileS::WALKABLE]) {
continue;
}
//pushTileColor((sf::Vector2i)l, sf::Color::White);
setTileFeature((sf::Vector2i)l, TileFeatureS::get(TileFeatureS::MOUNTAIN), urng);
cTile->FLAGS[HexTile::MOUNTAINS] = true;
}
}
void MotionSystem::noiseShiftWithOdo(Particle* particle, float dX, float dY, float dH) {
// How x,y,h factors when deciding ranges
float xF = 5.f;
float yF = 5.f;
float hF = 5.f;
float xL, xU, yL, yU, hL, hU;
if ((std::fabs(dX * xF) - .2f) < 0.001f) {
xL = -.2f;
xU = .2f;
}
else if (dX >0) {
xL = -1.f * dX * xF;
xU = dX * xF;
}
else {//dX <0
xL = dX * xF;
xU = -1.f * dX * xF;
}
if ((std::fabs(dY * yF) - .2f) < 0.001f) {
yL = -.2f;
yU = .2f;
}
else if (dY >0) {
yL = -1.f * dY * yF;
yU = dY * yF;
}
else { //dY <0
yL = dY * yF;
yU = -1.f * dY * yF;
}
if ((std::fabs(dH * hF) - .025f) < 0.001f) {
hL = -.025f;
hU = .025f;
}
else if (dH >0) {
hL = -1.f * dH * hF;
hU = dH * hF;
}
else { //dH <0
hL = dH * hF;
hU = -1.f * dH * hF;
}
boost::uniform_real<float> xRange(xL, xU);
boost::uniform_real<float> yRange(yL, yU);
boost::uniform_real<float> hRange(hL, hU);
boost::variate_generator<boost::mt19937&, boost::uniform_real<float> > xShift(rng, xRange);
boost::variate_generator<boost::mt19937&, boost::uniform_real<float> > yShift(rng, yRange);
boost::variate_generator<boost::mt19937&, boost::uniform_real<float> > hShift(rng, hRange);
particle->shift(xShift(), yShift(), hShift());
}
void CCombinedLoopFunctions::FillFood(){
/*for(UInt32 j = 0; j < foodPatches.size(); j++)
while(foodPatches[j].size() < NbFoodItems){
CRange<Real> xRange((foodPatchCenters[j].GetX() - (foodPatchSizes[j].GetX()/2)), (foodPatchCenters[j].GetX() + (foodPatchSizes[j].GetX()/2)));
CRange<Real> yRange((foodPatchCenters[j].GetY() - (foodPatchSizes[j].GetY()/2)), (foodPatchCenters[j].GetY() + (foodPatchSizes[j].GetY()/2)));
CVector2 pos(m_pcRNG->Uniform(xRange), m_pcRNG->Uniform(yRange));
//if(!InNest(pos))
foodPatches[j].push_back(pos);
}*/
for(UInt32 j = 0; j < foodPatches.size(); j++)
while(foodPatches[j].size() < NbFoodItems){
CRange<Real> xRange((foodPatchCenters[j].GetX() - (foodPatchSizes[j].GetX()/2)), (foodPatchCenters[j].GetX() + (foodPatchSizes[j].GetX()/2)));
CRange<Real> yRange((foodPatchCenters[j].GetY() - (foodPatchSizes[j].GetY()/2)), (foodPatchCenters[j].GetY() + (foodPatchSizes[j].GetY()/2)));
CVector2 pos(m_pcRNG->Uniform(xRange), m_pcRNG->Uniform(yRange));
if(!CloseToNest(pos) && !CloseToArenaEnd(pos))
foodPatches[j].push_back(pos);
}
}
CVector2 CCombinedLoopFunctions::GenerateFoodPatchPosition(){
/*CRange<Real> xRange(-(arenaSize.GetX()/2)+foodPatchSize/2, arenaSize.GetX()/2-foodPatchSize/2);
CRange<Real> yRange(-(arenaSize.GetY()/2)+foodPatchSize/2, arenaSize.GetY()/2-foodPatchSize/2);
m_pcRNG->Uniform(xRange);m_pcRNG->Uniform(xRange); m_pcRNG->Uniform(xRange);
CVector2 tmp(0,0);
while(CloseToNest(tmp)){
tmp.Set(m_pcRNG->Uniform(xRange), m_pcRNG->Uniform(yRange));
}
return tmp;*/
CRange<Real> xRange(-(arenaSize.GetX()/2), arenaSize.GetX()/2);
CRange<Real> yRange(-(arenaSize.GetY()/2), arenaSize.GetY()/2);
m_pcRNG->Uniform(xRange);m_pcRNG->Uniform(xRange); m_pcRNG->Uniform(xRange);
CVector2 tmp(0,0);
while(CloseToNest(tmp) || CloseToArenaEnd(tmp)){
tmp.Set(m_pcRNG->Uniform(xRange), m_pcRNG->Uniform(yRange));
}
return tmp;
}
void SoundplaneZoneView::renderZones()
{
if (!mpModel) return;
const ScopedLock lock(*(mpModel->getZoneLock()));
const std::vector<ZonePtr>& zoneList = mpModel->getZones();
int viewW = getBackingLayerWidth();
int viewH = getBackingLayerHeight();
int viewScale = getRenderingScale();
// float viewAspect = (float)viewW / (float)viewH;
int gridWidth = 30; // Soundplane A TODO get from tracker
int gridHeight = 5;
int lineWidth = viewW / 200;
int thinLineWidth = viewW / 400;
// int margin = lineWidth*2;
// put origin in lower left.
MLGL::orthoView2(viewW, viewH);
MLRange xRange(0, gridWidth, 1, viewW);
MLRange yRange(0, gridHeight, 1, viewH);
Vec4 lineColor;
Vec4 darkBlue(0.3f, 0.3f, 0.5f, 1.f);
Vec4 gray(0.6f, 0.6f, 0.6f, 1.f);
Vec4 lightGray(0.9f, 0.9f, 0.9f, 1.f);
Vec4 blue2(0.1f, 0.1f, 0.5f, 1.f);
float smallDotSize = xRange(1.f);
// float strokeWidth = viewW / 100;
std::vector<ZonePtr>::const_iterator it;
for(it = zoneList.begin(); it != zoneList.end(); ++it)
{
const Zone& zone = **it;
int t = zone.getType();
MLRect zr = zone.getBounds();
const char * name = zone.getName().c_str();
int offset = zone.getOffset();
// affine transforms TODO for better syntax: MLRect zrd = zr.xform(gridToView);
MLRect zoneRectInView(xRange.convert(zr.x()), yRange.convert(zr.y()), xRange.convert(zr.width()), yRange.convert(zr.height()));
zoneRectInView.shrink(lineWidth);
// color idx = type + port offset.
Vec4 zoneStroke(MLGL::getIndicatorColor(t + offset));
Vec4 zoneFill(zoneStroke);
zoneFill[3] = 0.1f;
Vec4 activeFill(zoneStroke);
activeFill[3] = 0.25f;
Vec4 dotFill(zoneStroke);
dotFill[3] = 0.5f;
// draw box common to all kinds of zones
glColor4fv(&zoneFill[0]);
MLGL::fillRect(zoneRectInView);
glColor4fv(&zoneStroke[0]);
glLineWidth(lineWidth);
MLGL::strokeRect(zoneRectInView, 2.0f*viewScale);
glLineWidth(1);
// draw name
// all these rect calculations read upside-down here because view origin is at bottom
MLGL::drawTextAt(zoneRectInView.left() + lineWidth, zoneRectInView.top() + lineWidth, 0.f, 0.1f, viewScale, name);
// draw any zone-specific things
float x, y;
int toggle;
switch(t)
{
case kNoteRow:
for(int i = 0; i < kSoundplaneMaxTouches; ++i)
{
const ZoneTouch& uTouch = zone.getTouch(i);
const ZoneTouch& touch = zone.touchToKeyPos(uTouch);
if(touch.isActive())
{
glColor4fv(&dotFill[0]);
float dx = xRange(touch.pos.x());
float dy = yRange(touch.pos.y());
float dz = touch.pos.z();
MLGL::drawDot(Vec2(dx, dy), dz*smallDotSize);
}
}
break;
case kControllerX:
x = xRange(zone.getXKeyPos());
glColor4fv(&zoneStroke[0]);
glLineWidth(thinLineWidth);
MLGL::strokeRect(MLRect(x, zoneRectInView.top(), 0., zoneRectInView.height()), viewScale);
glColor4fv(&activeFill[0]);
MLGL::fillRect(MLRect(zoneRectInView.left(), zoneRectInView.top(), x - zoneRectInView.left(), zoneRectInView.height()));
break;
case kControllerY:
y = yRange(zone.getYKeyPos());
glColor4fv(&zoneStroke[0]);
glLineWidth(thinLineWidth);
MLGL::strokeRect(MLRect(zoneRectInView.left(), y, zoneRectInView.width(), 0.), viewScale);
glColor4fv(&activeFill[0]);
MLGL::fillRect(MLRect(zoneRectInView.left(), zoneRectInView.top(), zoneRectInView.width(), y - zoneRectInView.top()));
break;
case kControllerXY:
x = xRange(zone.getXKeyPos());
y = yRange(zone.getYKeyPos());
glColor4fv(&zoneStroke[0]);
glLineWidth(thinLineWidth);
// cross-hairs centered on dot
MLGL::strokeRect(MLRect(x, zoneRectInView.top(), 0., zoneRectInView.height()), viewScale);
MLGL::strokeRect(MLRect(zoneRectInView.left(), y, zoneRectInView.width(), 0.), viewScale);
glColor4fv(&dotFill[0]);
MLGL::drawDot(Vec2(x, y), smallDotSize*0.25f);
break;
case kControllerZ:
y = yRange(zone.mYRange(zone.getValue(0))); // look at z value over y range
glColor4fv(&zoneStroke[0]);
glLineWidth(thinLineWidth);
MLGL::strokeRect(MLRect(zoneRectInView.left(), y, zoneRectInView.width(), 0.), viewScale);
glColor4fv(&activeFill[0]);
MLGL::fillRect(MLRect(zoneRectInView.left(), zoneRectInView.top(), zoneRectInView.width(), y - zoneRectInView.top()));
break;
case kToggle:
toggle = zone.getToggleValue();
glColor4fv(&zoneStroke[0]);
glLineWidth(thinLineWidth);
if(toggle)
{
MLRect toggleFill = zoneRectInView;
Vec2 zoneCenter = zoneRectInView.getCenter();
glColor4fv(&activeFill[0]);
MLGL::fillRect(zoneRectInView);
glColor4fv(&dotFill[0]);
MLGL::drawDot(zoneCenter, smallDotSize*0.25f);
}
break;
}
}
}
void SoundplaneZoneView::renderGrid()
{
int viewW = getBackingLayerWidth();
int viewH = getBackingLayerHeight();
MLGL::orthoView2(viewW, viewH);
int gridWidth = 30; // Soundplane A TODO get from tracker
int gridHeight = 5;
// int margin = viewW / 50;
MLRange xRange(0, gridWidth, 1, viewW);
MLRange yRange(0, gridHeight, 1, viewH);
// draw thin lines at key grid
Vec4 lineColor;
Vec4 darkBlue(0.3f, 0.3f, 0.5f, 1.f);
Vec4 gray(0.6f, 0.6f, 0.6f, 1.f);
lineColor = gray;
// horiz lines
glColor4fv(&lineColor[0]);
for(int j=0; j<=gridHeight; ++j)
{
glBegin(GL_LINE_STRIP);
for(int i=0; i<=gridWidth; ++i)
{
float x = xRange.convert(i);
float y = yRange.convert(j);
glVertex2f(x, y);
}
glEnd();
}
// vert lines
for(int i=0; i<=gridWidth; ++i)
{
glBegin(GL_LINE_STRIP);
for(int j=0; j<=gridHeight; ++j)
{
float x = xRange.convert(i);
float y = yRange.convert(j);
glVertex2f(x, y);
}
glEnd();
}
// draw dots
float r = viewH / 80.;
for(int i=0; i<=gridWidth; ++i)
{
float x = xRange.convert(i + 0.5);
float y = yRange.convert(2.5);
int k = i%12;
if(k == 0)
{
float d = viewH / 50;
Vec4 dotColor(0.6f, 0.6f, 0.6f, 1.f);
glColor4fv(&dotColor[0]);
MLGL::drawDot(Vec2(x, y - d), r);
MLGL::drawDot(Vec2(x, y + d), r);
}
if((k == 3)||(k == 5)||(k == 7)||(k == 9))
{
Vec4 dotColor(0.6f, 0.6f, 0.6f, 1.f);
glColor4fv(&dotColor[0]);
MLGL::drawDot(Vec2(x, y), r);
}
}
}
void CalibrationDialog::processImages(const cv::Mat & imageLeft, const cv::Mat & imageRight, const QString & cameraName)
{
processingData_ = true;
if(cameraName_.isEmpty())
{
cameraName_ = "0000";
if(!cameraName.isEmpty())
{
cameraName_ = cameraName;
}
}
if(ui_->label_serial->text().isEmpty())
{
ui_->label_serial->setText(cameraName_);
}
std::vector<cv::Mat> inputRawImages(2);
if(ui_->checkBox_switchImages->isChecked())
{
inputRawImages[0] = imageRight;
inputRawImages[1] = imageLeft;
}
else
{
inputRawImages[0] = imageLeft;
inputRawImages[1] = imageRight;
}
std::vector<cv::Mat> images(2);
images[0] = inputRawImages[0];
images[1] = inputRawImages[1];
imageSize_[0] = images[0].size();
imageSize_[1] = images[1].size();
bool boardFound[2] = {false};
bool boardAccepted[2] = {false};
bool readyToCalibrate[2] = {false};
std::vector<std::vector<cv::Point2f> > pointBuf(2);
bool depthDetected = false;
for(int id=0; id<(stereo_?2:1); ++id)
{
cv::Mat viewGray;
if(!images[id].empty())
{
if(images[id].type() == CV_16UC1)
{
depthDetected = true;
//assume IR image: convert to gray scaled
const float factor = 255.0f / float((maxIrs_[id] - minIrs_[id]));
viewGray = cv::Mat(images[id].rows, images[id].cols, CV_8UC1);
for(int i=0; i<images[id].rows; ++i)
{
for(int j=0; j<images[id].cols; ++j)
{
viewGray.at<unsigned char>(i, j) = (unsigned char)std::min(float(std::max(images[id].at<unsigned short>(i,j) - minIrs_[id], 0)) * factor, 255.0f);
}
}
cvtColor(viewGray, images[id], cv::COLOR_GRAY2BGR); // convert to show detected points in color
}
else if(images[id].channels() == 3)
{
cvtColor(images[id], viewGray, cv::COLOR_BGR2GRAY);
}
else
{
viewGray = images[id];
cvtColor(viewGray, images[id], cv::COLOR_GRAY2BGR); // convert to show detected points in color
}
}
else
{
UERROR("Image %d is empty!! Should not!", id);
}
minIrs_[id] = 0;
maxIrs_[id] = 0x7FFF;
//Dot it only if not yet calibrated
if(!ui_->pushButton_save->isEnabled())
{
cv::Size boardSize(ui_->spinBox_boardWidth->value(), ui_->spinBox_boardHeight->value());
if(!viewGray.empty())
{
int flags = CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_NORMALIZE_IMAGE;
if(!viewGray.empty())
{
int maxScale = viewGray.cols < 640?2:1;
for( int scale = 1; scale <= maxScale; scale++ )
{
cv::Mat timg;
if( scale == 1 )
timg = viewGray;
else
cv::resize(viewGray, timg, cv::Size(), scale, scale, CV_INTER_CUBIC);
boardFound[id] = cv::findChessboardCorners(timg, boardSize, pointBuf[id], flags);
if(boardFound[id])
{
if( scale > 1 )
{
cv::Mat cornersMat(pointBuf[id]);
cornersMat *= 1./scale;
}
break;
}
}
}
}
if(boardFound[id]) // If done with success,
{
// improve the found corners' coordinate accuracy for chessboard
float minSquareDistance = -1.0f;
for(unsigned int i=0; i<pointBuf[id].size()-1; ++i)
{
float d = cv::norm(pointBuf[id][i] - pointBuf[id][i+1]);
if(minSquareDistance == -1.0f || minSquareDistance > d)
{
minSquareDistance = d;
}
}
float radius = minSquareDistance/2.0f +0.5f;
cv::cornerSubPix( viewGray, pointBuf[id], cv::Size(radius, radius), cv::Size(-1,-1),
cv::TermCriteria( CV_TERMCRIT_EPS + CV_TERMCRIT_ITER, 30, 0.1 ));
// Draw the corners.
cv::drawChessboardCorners(images[id], boardSize, cv::Mat(pointBuf[id]), boardFound[id]);
std::vector<float> params(4,0);
getParams(pointBuf[id], boardSize, imageSize_[id], params[0], params[1], params[2], params[3]);
bool addSample = true;
for(unsigned int i=0; i<imageParams_[id].size(); ++i)
{
if(fabs(params[0] - imageParams_[id][i].at(0)) < 0.1 && // x
fabs(params[1] - imageParams_[id][i].at(1)) < 0.1 && // y
fabs(params[2] - imageParams_[id][i].at(2)) < 0.05 && // size
fabs(params[3] - imageParams_[id][i].at(3)) < 0.1) // skew
{
addSample = false;
}
}
if(addSample)
{
boardAccepted[id] = true;
imagePoints_[id].push_back(pointBuf[id]);
imageParams_[id].push_back(params);
UINFO("[%d] Added board, total=%d. (x=%f, y=%f, size=%f, skew=%f)", id, (int)imagePoints_[id].size(), params[0], params[1], params[2], params[3]);
}
// update statistics
std::vector<float> xRange(2, imageParams_[id][0].at(0));
std::vector<float> yRange(2, imageParams_[id][0].at(1));
std::vector<float> sizeRange(2, imageParams_[id][0].at(2));
std::vector<float> skewRange(2, imageParams_[id][0].at(3));
for(unsigned int i=1; i<imageParams_[id].size(); ++i)
{
xRange[0] = imageParams_[id][i].at(0) < xRange[0] ? imageParams_[id][i].at(0) : xRange[0];
xRange[1] = imageParams_[id][i].at(0) > xRange[1] ? imageParams_[id][i].at(0) : xRange[1];
yRange[0] = imageParams_[id][i].at(1) < yRange[0] ? imageParams_[id][i].at(1) : yRange[0];
yRange[1] = imageParams_[id][i].at(1) > yRange[1] ? imageParams_[id][i].at(1) : yRange[1];
sizeRange[0] = imageParams_[id][i].at(2) < sizeRange[0] ? imageParams_[id][i].at(2) : sizeRange[0];
sizeRange[1] = imageParams_[id][i].at(2) > sizeRange[1] ? imageParams_[id][i].at(2) : sizeRange[1];
skewRange[0] = imageParams_[id][i].at(3) < skewRange[0] ? imageParams_[id][i].at(3) : skewRange[0];
skewRange[1] = imageParams_[id][i].at(3) > skewRange[1] ? imageParams_[id][i].at(3) : skewRange[1];
}
//UINFO("Stats [%d]:", id);
//UINFO(" Count = %d", (int)imagePoints_[id].size());
//UINFO(" x = [%f -> %f]", xRange[0], xRange[1]);
//UINFO(" y = [%f -> %f]", yRange[0], yRange[1]);
//UINFO(" size = [%f -> %f]", sizeRange[0], sizeRange[1]);
//UINFO(" skew = [%f -> %f]", skewRange[0], skewRange[1]);
float xGood = xRange[1] - xRange[0];
float yGood = yRange[1] - yRange[0];
float sizeGood = sizeRange[1] - sizeRange[0];
float skewGood = skewRange[1] - skewRange[0];
if(id == 0)
{
ui_->progressBar_x->setValue(xGood*100);
ui_->progressBar_y->setValue(yGood*100);
ui_->progressBar_size->setValue(sizeGood*100);
ui_->progressBar_skew->setValue(skewGood*100);
if((int)imagePoints_[id].size() > ui_->progressBar_count->maximum())
{
ui_->progressBar_count->setMaximum((int)imagePoints_[id].size());
}
ui_->progressBar_count->setValue((int)imagePoints_[id].size());
}
else
{
ui_->progressBar_x_2->setValue(xGood*100);
ui_->progressBar_y_2->setValue(yGood*100);
ui_->progressBar_size_2->setValue(sizeGood*100);
ui_->progressBar_skew_2->setValue(skewGood*100);
if((int)imagePoints_[id].size() > ui_->progressBar_count_2->maximum())
{
ui_->progressBar_count_2->setMaximum((int)imagePoints_[id].size());
}
ui_->progressBar_count_2->setValue((int)imagePoints_[id].size());
}
if(imagePoints_[id].size() >= COUNT_MIN && xGood > 0.5 && yGood > 0.5 && sizeGood > 0.4 && skewGood > 0.5)
{
readyToCalibrate[id] = true;
}
//update IR values
if(inputRawImages[id].type() == CV_16UC1)
{
//update min max IR if the chessboard was found
minIrs_[id] = 0xFFFF;
maxIrs_[id] = 0;
for(size_t i = 0; i < pointBuf[id].size(); ++i)
{
const cv::Point2f &p = pointBuf[id][i];
cv::Rect roi(std::max(0, (int)p.x - 3), std::max(0, (int)p.y - 3), 6, 6);
roi.width = std::min(roi.width, inputRawImages[id].cols - roi.x);
roi.height = std::min(roi.height, inputRawImages[id].rows - roi.y);
//find minMax in the roi
double min, max;
cv::minMaxLoc(inputRawImages[id](roi), &min, &max);
if(min < minIrs_[id])
{
minIrs_[id] = min;
}
if(max > maxIrs_[id])
{
maxIrs_[id] = max;
}
}
}
}
}
}
ui_->label_baseline->setVisible(!depthDetected);
ui_->label_baseline_name->setVisible(!depthDetected);
if(stereo_ && ((boardAccepted[0] && boardFound[1]) || (boardAccepted[1] && boardFound[0])))
{
stereoImagePoints_[0].push_back(pointBuf[0]);
stereoImagePoints_[1].push_back(pointBuf[1]);
UINFO("Add stereo image points (size=%d)", (int)stereoImagePoints_[0].size());
}
if(!stereo_ && readyToCalibrate[0])
{
ui_->pushButton_calibrate->setEnabled(true);
}
else if(stereo_ && readyToCalibrate[0] && readyToCalibrate[1] && stereoImagePoints_[0].size())
{
ui_->pushButton_calibrate->setEnabled(true);
}
if(ui_->radioButton_rectified->isChecked())
{
if(models_[0].isValid())
{
images[0] = models_[0].rectifyImage(images[0]);
}
if(models_[1].isValid())
{
images[1] = models_[1].rectifyImage(images[1]);
}
}
else if(ui_->radioButton_stereoRectified->isChecked() &&
(stereoModel_.left().isValid() &&
stereoModel_.right().isValid()&&
(!ui_->label_baseline->isVisible() || stereoModel_.baseline() > 0.0)))
{
images[0] = stereoModel_.left().rectifyImage(images[0]);
images[1] = stereoModel_.right().rectifyImage(images[1]);
}
if(ui_->checkBox_showHorizontalLines->isChecked())
{
for(int id=0; id<(stereo_?2:1); ++id)
{
int step = imageSize_[id].height/16;
for(int i=step; i<imageSize_[id].height; i+=step)
{
cv::line(images[id], cv::Point(0, i), cv::Point(imageSize_[id].width, i), CV_RGB(0,255,0));
}
}
}
ui_->label_left->setText(tr("%1x%2").arg(images[0].cols).arg(images[0].rows));
//show frame
ui_->image_view->setImage(uCvMat2QImage(images[0]).mirrored(ui_->checkBox_mirror->isChecked(), false));
if(stereo_)
{
ui_->label_right->setText(tr("%1x%2").arg(images[1].cols).arg(images[1].rows));
ui_->image_view_2->setImage(uCvMat2QImage(images[1]).mirrored(ui_->checkBox_mirror->isChecked(), false));
}
processingData_ = false;
}
void SSTimeSeriesPlot::setYRange(const Vec2 &range) {
if ((yRange().x!=range.x)||(yRange().y!=range.y)) {
SSAbstractPlot::setYRange(range);
d->m_plot_area.setYRange(range.x,range.y);
}
}
