void console::redraw()
{
if (!con_win)
return;
con_win->clear();
char *s = screen;
int xa = fnt->Size().x, ya = fnt->Size().y;
for (int j = 0, dy = wy(); j < h; j++, dy += ya)
for (int i = 0, dx = wx(); i < w; i++, s++, dx += xa)
if (*s)
fnt->PutChar(con_win->m_surf, ivec2(dx, dy), *s);
fnt->PutChar(con_win->m_surf, ivec2(wx() + cx * xa, wy() + cy * ya), '_');
}
void console::draw_cursor()
{
if (!con_win)
return;
fnt->PutChar(con_win->m_surf,
ivec2(cx, cy) * fnt->Size() + ivec2(wx(), wy()), '_');
}
void console::DrawChar(ivec2 pos, char ch)
{
if (!con_win)
return;
ivec2 fs = fnt->Size();
pos = ivec2(wx(), wy()) + pos * fs;
con_win->m_surf->Bar(pos, pos + fs - ivec2(1), wm->black());
fnt->PutChar(con_win->m_surf, pos, ch);
}
pair<Mat, Mat> FeaturePointsRANSAC::calculateProjection(vector<pair<string, Point2f> > ffpsAtOrigin, vector<pair<string, Point3f> > mmPointsAtOrigin)
{
// Construct V
Mat V(mmPointsAtOrigin.size(), 3, CV_32F); // As many rows as Ffp's, and 3 cols (x, y, z)
for (unsigned int i=0; i<mmPointsAtOrigin.size(); ++i) {
V.at<float>(i, 0) = mmPointsAtOrigin[i].second.x;
V.at<float>(i, 1) = mmPointsAtOrigin[i].second.y;
V.at<float>(i, 2) = mmPointsAtOrigin[i].second.z;
}
// Construct wx, wy
Mat wx(mmPointsAtOrigin.size(), 1, CV_32F);
Mat wy(mmPointsAtOrigin.size(), 1, CV_32F);
for (unsigned int i=0; i<mmPointsAtOrigin.size(); ++i) {
wx.at<float>(i, 0) = ffpsAtOrigin[i].second.x;
wy.at<float>(i, 0) = ffpsAtOrigin[i].second.y;
}
// TODO: check if matrix square. If not, use another invert(...) instead of .inv().
bool useSVD = true;
if(V.rows==V.cols)
useSVD = false;
cout << "wx = " << wx << endl;
cout << "wy = " << wy << endl;
cout << "V = " << V << endl;
Mat s;
Mat t;
if(!useSVD) {
cout << "det(V) = " << determinant(V) << endl; // Det() of non-symmetric matrix?
cout << "V.inv() = " << V.inv() << endl;
s = V.inv() * wx;
t = V.inv() * wy;
} else {
Mat Vinv;
invert(V, Vinv, cv::DECOMP_SVD);
cout << "invert(V) with SVD = " << Vinv << endl;
s = Vinv * wx;
t = Vinv * wy;
}
cout << "s = " << s << endl;
cout << "t = " << t << endl;
for(unsigned int i=0; i<V.rows; ++i) {
cout << "<v|s> = wx? " << V.row(i).t().dot(s) << " ?= " << wx.row(i) << endl;
cout << "<v|t> = wy? " << V.row(i).t().dot(t) << " ?= " << wy.row(i) << endl;
}
return make_pair(s, t);
}
static np::ndarray extractBoxes( const Image &im, const RMatrixXi & b, int W, int H ) {
// Create the output array
const int C = im.C();
const int im_W = im.W();
np::ndarray res = np::empty( make_tuple( b.rows(), H, W, C ), np::dtype::get_builtin<float>() );
const float * pim = (const float *)im.data();
float * pres = (float *)res.get_data();
#pragma omp parallel for
for( int i=0; i<b.rows(); i++ ) {
// Build the lerp lookup table
const float Y0=b(i,0), X0=b(i,1);
const float dy=b(i,2)-Y0-1, dx=b(i,3)-X0-1;
std::vector< int > x0( W ), y0( H ), x1( W ), y1( H );
std::vector< float > wx( W ), wy( H );
for( int j=0; j<H; j++ ) {
float p = Y0 + j*dy/(H-1);
y0[j] = floor(p); y1[j] = ceil(p);
wy[j] = y1[j]-p;
}
for( int j=0; j<W; j++ ) {
float p = X0 + j*dx/(W-1);
x0[j] = floor(p); x1[j] = ceil(p);
wx[j] = x1[j]-p;
}
// Run the lerp
float * pr = pres + i*H*W*C;
for( int j=0; j<H; j++ )
for( int i=0; i<W; i++ )
for( int k=0; k<C; k++ )
pr[ (j*W+i)*C+k ] = wx[i] * wy[j] *pim[ ( y0[j]*im_W+x0[i] )*C+k ]
+ wx[i] *(1-wy[j])*pim[ ( y1[j]*im_W+x0[i] )*C+k ]
+(1-wx[i])* wy[j] *pim[ ( y0[j]*im_W+x1[i] )*C+k ]
+(1-wx[i])*(1-wy[j])*pim[ ( y1[j]*im_W+x1[i] )*C+k ];
}
return res;
}
void IntegrationRule::DefineIntegrationRuleSquareAnisotropic(IntegrationRule & integrationRule, int ruleOrder_x, int ruleOrder_y)
{
// we use a ready function, which provides a one-dimensional integration rule
// we use different integration rules for x and y direction
Vector xx, xy;
Vector wx, wy;
GetIntegrationRule(xx, wx, ruleOrder_x);
GetIntegrationRule(xy, wy, ruleOrder_y);
// and now we create a 2D integration rule
integrationRule.integrationPoints.SetLen(xx.Length() * xy.Length());
int cnt = 1;
for (int i1 = 1; i1 <= xx.GetLen(); i1++)
{
for (int i2 = 1; i2 <= xy.GetLen(); i2++)
{
integrationRule.integrationPoints(cnt).x = xx(i1);
integrationRule.integrationPoints(cnt).y = xy(i2);
integrationRule.integrationPoints(cnt).z = 0;
integrationRule.integrationPoints(cnt).weight = wx(i1) * wy(i2);
cnt++;
}
}
}