/*!
Get the coordinates of the mouse pointer.
\warning Not implemented yet.
\param ip [out] : The coordinates of the mouse pointer.
\return true if a pointer motion event was received, false otherwise.
\exception vpDisplayException::notInitializedError : If the display
was not initialized.
*/
bool
vpDisplayOpenCV::getPointerMotionEvent (vpImagePoint &ip )
{
bool ret = false;
if (displayHasBeenInitialized) {
//flushDisplay() ;
double u, v;
if (move){
ret = true ;
u = (unsigned int)x_move;
v = (unsigned int)y_move;
ip.set_u( u );
ip.set_v( v );
move = false;
}
}
else {
vpERROR_TRACE("OpenCV not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"OpenCV not initialized")) ;
}
return ret;
}
/*!
Display a selection of the gray level image \e I (8bits).
\warning Display has to be initialized.
\warning Suppress the overlay drawing in the region of interest.
\param I : Image to display.
\param iP : Top left corner of the region of interest
\param w : Width of the region of interest
\param h : Height of the region of interest
\sa init(), closeDisplay()
*/
void vpDisplayGTK::displayImageROI ( const vpImage<unsigned char> &I,const vpImagePoint &iP, const unsigned int w, const unsigned int h )
{
if (displayHasBeenInitialized)
{
vpImage<unsigned char> Itemp;
vpImageTools::crop(I,(unsigned int)iP.get_i(),(unsigned int)iP.get_j(), h, w,Itemp);
/* Copie de l'image dans le pixmap fond */
gdk_draw_gray_image(background,
gc, (gint)iP.get_u(), (gint)iP.get_v(), (gint)w, (gint)h,
GDK_RGB_DITHER_NONE,
I.bitmap,
(gint)w);
/* Le pixmap background devient le fond de la zone de dessin */
gdk_window_set_back_pixmap(widget->window, background, FALSE);
/* Affichage */
//gdk_window_clear(GTK_WINDOW(widget));
//gdk_flush();
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
/*!
Wait for a click from one of the mouse button and get the position
of the clicked image point.
\param ip [out] : The coordinates of the clicked image point.
\param blocking [in] : true for a blocking behaviour waiting a mouse
button click, false for a non blocking behaviour.
\return
- true if a button was clicked. This is always the case if blocking is set
to \e true.
- false if no button was clicked. This can occur if blocking is set
to \e false.
*/
bool vpDisplayWin32::getClick(vpImagePoint &ip, bool blocking)
{
//wait if the window is not initialized
waitForInit();
bool ret = false ;
double u, v;
//tells the window there has been a getclick demand
// PostMessage(window.getHWnd(), vpWM_GETCLICK, 0,0);
//waits for a click
if(blocking){
WaitForSingleObject(window.semaClick, NULL);
WaitForSingleObject(window.semaClickUp, NULL);//to erase previous events
WaitForSingleObject(window.semaClick, INFINITE);
ret = true;
}
else
ret = (WAIT_OBJECT_0 == WaitForSingleObject(window.semaClick, NULL));
u = window.clickX;
v = window.clickY;
ip.set_u( u );
ip.set_v( v );
return ret;
}
/*!
Display a string at the image point \e ip location.
To select the font used to display the string, use setFont().
\param ip : Upper left image point location of the string in the display.
\param text : String to display in overlay.
\param color : String color.
\sa setFont()
*/
void vpDisplayOpenCV::displayCharString( const vpImagePoint &ip,
const char *text,
const vpColor &color )
{
if (displayHasBeenInitialized)
{
if (color.id < vpColor::id_unknown) {
cvPutText( background, text,
cvPoint( vpMath::round( ip.get_u() ),
vpMath::round( ip.get_v()+fontHeight ) ),
font, col[color.id] );
}
else {
cvcolor = CV_RGB(color.R, color.G, color.B) ;
cvPutText( background, text,
cvPoint( vpMath::round( ip.get_u() ),
vpMath::round( ip.get_v()+fontHeight ) ),
font, cvcolor );
}
}
else
{
vpERROR_TRACE("OpenCV not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"OpenCV not initialized")) ;
}
}
/*!
Display a point at the image point \e ip location.
\param ip : Point location.
\param color : Point color.
*/
void vpDisplayGTK::displayPoint ( const vpImagePoint &ip,
const vpColor &color )
{
if (displayHasBeenInitialized)
{
if (color.id < vpColor::id_unknown)
gdk_gc_set_foreground(gc, col[color.id]);
else {
gdkcolor.red = 256 * color.R;
gdkcolor.green = 256 * color.G;
gdkcolor.blue = 256 * color.B;
gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
gdk_gc_set_foreground(gc, &gdkcolor);
}
gdk_draw_point(background,gc,
vpMath::round( ip.get_u() ),
vpMath::round( ip.get_v() ) );
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
/*!
Wait for a click from one of the mouse button and get the position
of the clicked image point.
\param ip [out] : The coordinates of the clicked image point.
\param blocking [in] : true for a blocking behaviour waiting a mouse
button click, false for a non blocking behaviour.
\return
- true if a button was clicked. This is always the case if blocking is set
to \e true.
- false if no button was clicked. This can occur if blocking is set
to \e false.
*/
bool
vpDisplayGTK::getClick(vpImagePoint &ip, bool blocking)
{
bool ret = false;
if (displayHasBeenInitialized) {
double u, v ;
do {
GdkEvent *ev = NULL;
while ((ev = gdk_event_get())!=NULL){
if (ev->any.window == widget->window && ev->type == GDK_BUTTON_PRESS) {
u = ((GdkEventButton *)ev)->x ;
v = ((GdkEventButton *)ev)->y ;
ip.set_u( u );
ip.set_v( v );
ret = true ;
}
gdk_event_free(ev) ;
}
if (blocking){
flushDisplay();
vpTime::wait(100);
}
} while ( ret == false && blocking == true);
}
else {
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
return ret ;
}
/*!
Wait for a mouse button click release and get the position of the
image point were the click release occurs. The button used to click is
also set. Same method as getClick(unsigned int&, unsigned int&,
vpMouseButton::vpMouseButtonType &, bool).
\param ip [out] : Position of the clicked image point.
\param button [in] : Button used to click.
\param blocking [in] : true for a blocking behaviour waiting a mouse
button click, false for a non blocking behaviour.
\return
- true if a button was clicked. This is always the case if blocking is set
to \e true.
- false if no button was clicked. This can occur if blocking is set
to \e false.
\sa getClick(vpImagePoint &, vpMouseButton::vpMouseButtonType &, bool)
*/
bool vpDisplayWin32::getClickUp(vpImagePoint &ip,
vpMouseButton::vpMouseButtonType& button,
bool blocking)
{
//wait if the window is not initialized
waitForInit();
bool ret = false;
double u, v;
//tells the window there has been a getclickup demand
// PostMessage(window.getHWnd(), vpWM_GETCLICKUP, 0,0);
//waits for a click release
if(blocking){
WaitForSingleObject(window.semaClickUp, 0);
WaitForSingleObject(window.semaClick, 0);//to erase previous events
WaitForSingleObject(window.semaClickUp, INFINITE);
ret = true;
}
else
ret = (WAIT_OBJECT_0 == WaitForSingleObject(window.semaClickUp, 0));
u = window.clickXUp;
v = window.clickYUp;
ip.set_u( u );
ip.set_v( v );
button = window.clickButtonUp;
return ret;
}
/*!
Display a string at the image point \e ip location.
To select the font used to display the string, use setFont().
\param ip : Upper left image point location of the string in the display.
\param text : String to display in overlay.
\param color : String color.
\sa setFont()
*/
void vpDisplayGTK::displayCharString ( const vpImagePoint &ip,
const char *text,
const vpColor &color )
{
if (displayHasBeenInitialized)
{
if (color.id < vpColor::id_unknown)
gdk_gc_set_foreground(gc, col[color.id]);
else {
gdkcolor.red = 256 * color.R;
gdkcolor.green = 256 * color.G;
gdkcolor.blue = 256 * color.B;
gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
gdk_gc_set_foreground(gc, &gdkcolor);
}
if (font != NULL)
gdk_draw_string(background, font, gc,
vpMath::round( ip.get_u() ),
vpMath::round( ip.get_v() ),
(const gchar *)text);
else
std::cout << "Cannot draw string: no font is selected" << std::endl;
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
/*
Compute the distance d = |Pw1-Pw2|
*/
inline double distance(const vpImagePoint &iP1, const double w1, const vpImagePoint &iP2, const double w2)
{
double distancei = iP1.get_i() - iP2.get_i();
double distancej = iP1.get_j() - iP2.get_j();
double distancew = w1 -w2;
return sqrt(vpMath::sqr(distancei)+vpMath::sqr(distancej)+vpMath::sqr(distancew));
}
/*!
Display a line from image point \e ip1 to image point \e ip2.
\param ip1,ip2 : Initial and final image points.
\param color : Line color.
\param thickness : Line thickness.
*/
void vpDisplayGTK::displayLine ( const vpImagePoint &ip1,
const vpImagePoint &ip2,
const vpColor &color,
unsigned int thickness )
{
if (displayHasBeenInitialized)
{
if ( thickness == 1 ) thickness = 0;
if (color.id < vpColor::id_unknown)
gdk_gc_set_foreground(gc, col[color.id]);
else {
gdkcolor.red = 256 * color.R;
gdkcolor.green = 256 * color.G;
gdkcolor.blue = 256 * color.B;
gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE);
gdk_gc_set_foreground(gc, &gdkcolor);
}
gdk_gc_set_line_attributes(gc, (gint)thickness,
GDK_LINE_SOLID, GDK_CAP_BUTT,
GDK_JOIN_BEVEL) ;
gdk_draw_line(background, gc,
vpMath::round( ip1.get_u() ),
vpMath::round( ip1.get_v() ),
vpMath::round( ip2.get_u() ),
vpMath::round( ip2.get_v() ) );
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
/*!
Constructs a rectangle with \e topLeft the top-left corner location
and \e width and \e height the rectangle size.
*/
vpRect::vpRect(const vpImagePoint &topLeft, double width, double height)
{
this->left = topLeft.get_u();
this->top = topLeft.get_v();
this->width = width;
this->height = height;
};
/*!
\brief flush the Win32 buffer
It's necessary to use this function to see the results of any drawing
*/
void vpDisplayWin32::flushDisplayROI(const vpImagePoint &iP, const unsigned int width, const unsigned int height)
{
//waits if the window is not initialized
waitForInit();
/*
Under windows, flushing an ROI takes more time than
flushing the whole image.
Therefore, we update the maximum area even when asked to update a region.
*/
#ifdef FLUSH_ROI
typedef struct _half_rect_t{
unsigned short left_top;
unsigned short right_bottom;
} half_rect_t;
half_rect_t hr1;
half_rect_t hr2;
hr1.left_top = (unsigned short)iP.get_u();
hr1.right_bottom = (unsigned short)(iP.get_u()+width-1);
hr2.left_top = (unsigned short)iP.get_v();
hr2.right_bottom = (unsigned short)(iP.get_v()+height-1);
//sends a message to the window
WPARAM wp=*((WPARAM*)(&hr1));
LPARAM lp=*((WPARAM*)(&hr2));
PostMessage(window.getHWnd(), vpWM_DISPLAY_ROI, wp,lp);
#else
PostMessage(window.getHWnd(), vpWM_DISPLAY, 0,0);
#endif
}
/*!
Display a selection of the color image \e I in RGBa format (32bits).
\warning Display has to be initialized.
\warning Suppress the overlay drawing in the region of interest.
\param I : Image to display.
\param iP : Top left corner of the region of interest
\param w : Width of the region of interest
\param h : Height of the region of interest
\sa init(), closeDisplay()
*/
void vpDisplayGTK::displayImageROI ( const vpImage<vpRGBa> &I,const vpImagePoint &iP, const unsigned int w, const unsigned int h )
{
if (displayHasBeenInitialized)
{
vpImage<vpRGBa> Itemp;
vpImageTools::crop(I,(unsigned int)iP.get_i(), (unsigned int)iP.get_j(), h, w, Itemp);
/* Copie de l'image dans le pixmap fond */
gdk_draw_rgb_32_image(background,
gc, (gint)iP.get_u(), (gint)iP.get_v(), (gint)w, (gint)h,
GDK_RGB_DITHER_NONE,
(unsigned char *)Itemp.bitmap,
(gint)(4*w));
/* Permet de fermer la fenetre si besoin (cas des sequences d'images) */
//while (g_main_iteration(FALSE));
/* Le pixmap background devient le fond de la zone de dessin */
gdk_window_set_back_pixmap(widget->window, background, FALSE);
/* Affichage */
//gdk_window_clear(GTK_WINDOW(widget));
//flushDisplay() ;
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
/*!
Constructs a rectangle with \e topLeft the top-left corner location
and \e bottomRight the bottom-right corner.
*/
vpRect::vpRect(const vpImagePoint &topLeft, const vpImagePoint &bottomRight)
{
this->left = topLeft.get_u();
this->top = topLeft.get_v();
setBottom( bottomRight.get_v() );
setRight( bottomRight.get_u() );
};
/*!
Computes the \f$ alpha \f$ angle of the two points and store them into alpha1 for the smallest and alpha2 for the biggest.
\note this function is useful only during the initialization.
\param pt1 : First point whose \f$ alpha \f$ angle is computed.
\param pt2 : Second point whose \f$ alpha \f$ angle is computed.
*/
void
vpMeEllipse::computeAngle(vpImagePoint pt1, vpImagePoint pt2)
{
getParameters() ;
double j1, i1, j11, i11;
j1 = i1 = 0.0 ;
int number_of_points = 2000 ;
double incr = 2 * M_PI / number_of_points ; // angle increment
double dmin1 = 1e6 ;
double dmin2 = 1e6 ;
double k = 0 ;
while(k < 2*M_PI) {
// j1 = a *cos(k) ; // equation of an ellipse
// i1 = b *sin(k) ; // equation of an ellipse
j1 = a *sin(k) ; // equation of an ellipse
i1 = b *cos(k) ; // equation of an ellipse
// (i1,j1) are the coordinates on the origin centered ellipse ;
// a rotation by "e" and a translation by (xci,jc) are done
// to get the coordinates of the point on the shifted ellipse
// j11 = iPc.get_j() + ce *j1 - se *i1 ;
// i11 = iPc.get_i() -( se *j1 + ce *i1) ;
j11 = iPc.get_j() + ce *j1 + se *i1 ;
i11 = iPc.get_i() - se *j1 + ce *i1 ;
double d = vpMath::sqr(pt1.get_i()-i11) + vpMath::sqr(pt1.get_j()-j11) ;
if (d < dmin1)
{
dmin1 = d ;
alpha1 = k ;
}
d = vpMath::sqr(pt2.get_i()-i11) + vpMath::sqr(pt2.get_j()-j11) ;
if (d < dmin2)
{
dmin2 = d ;
alpha2 = k ;
}
k += incr ;
}
//std::cout << "end vpMeEllipse::computeAngle(..)" << alpha1 << " " << alpha2 << std::endl ;
if (alpha2 < alpha1)
alpha2 += 2 * M_PI;
//else if (alpha2 == alpha1)
else if (std::fabs(alpha2 - alpha1) < std::fabs(alpha1) * std::numeric_limits<double>::epsilon())
alpha2 += 2 * M_PI;
//std::cout << "end vpMeEllipse::computeAngle(..)" << alpha1 << " " << alpha2 << std::endl ;
}
/*!
Display a selection of the gray level image \e I (8bits).
\warning Display has to be initialized.
\warning Suppress the overlay drawing in the region of interest.
\param I : Image to display.
\param iP : Top left corner of the region of interest
\param width : Width of the region of interest
\param height : Height of the region of interest
\sa init(), closeDisplay()
*/
void vpDisplayOpenCV::displayImageROI ( const vpImage<unsigned char> &I,const vpImagePoint &iP, const unsigned int width, const unsigned int height )
{
if (displayHasBeenInitialized)
{
vpImage<unsigned char> Itemp;
vpImageTools::createSubImage(I,(unsigned int)iP.get_i(),(unsigned int)iP.get_j(),height,width,Itemp);
vpImage<vpRGBa> Ic;
vpImageConvert::convert(Itemp,Ic);
CvSize size = cvSize((int)this->width, (int)this->height);
int depth = 8;
int channels = 3;
if (background != NULL){
if(background->nChannels != channels || background->depth != depth
|| background->height != (int) I.getHeight() || background->width != (int) I.getWidth()){
if(background->nChannels != 0) cvReleaseImage(&background);
background = cvCreateImage( size, depth, channels );
}
}
else background = cvCreateImage( size, depth, channels );
IplImage* Ip = NULL;
vpImageConvert::convert(Ic, Ip);
unsigned char * input = (unsigned char*)Ip->imageData;
unsigned char * output = (unsigned char*)background->imageData;
unsigned int iwidth = Ic.getWidth();
input = input;
output = output + (int)(iP.get_i()*3*this->width+ iP.get_j()*3);
unsigned int i = 0;
while (i < height)
{
unsigned int j = 0;
while (j < width)
{
*(output+3*j) = *(input+j*3);
*(output+3*j+1) = *(input+j*3+1);
*(output+3*j+2) = *(input+j*3+2);
j++;
}
input = input + 3*iwidth;
output = output + 3*this->width;
i++;
}
cvReleaseImage(&Ip);
}
else
{
vpERROR_TRACE("openCV not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"OpenCV not initialized")) ;
}
}
/*!
Get the extremities of the line.
\param ip1 : Coordinates of the first extremity.
\param ip2 : Coordinates of the second extremity.
*/
void
vpMeLine::getExtremities(vpImagePoint &ip1, vpImagePoint &ip2)
{
/*Return the coordinates of the extremities of the line*/
ip1.set_i( PExt[0].ifloat );
ip1.set_j( PExt[0].jfloat );
ip2.set_i( PExt[1].ifloat );
ip2.set_j( PExt[1].jfloat );
}
bool
vpImageSimulator::getPixel(const vpImagePoint &iP, unsigned char &Ipixelplan)
{
// std::cout << "In get Pixel" << std::endl;
//test si pixel dans zone projetee
bool inside = false;
for(unsigned int i = 0 ; i < listTriangle.size() ; i++)
if(listTriangle[i].inTriangle(iP)){
inside = true;
break;
}
if(!inside) return false;
// if(!T1.inTriangle(iP) && !T2.inTriangle(iP)){
//// std::cout << "The pixel is inside the projected area" << std::endl;
// return false;}
//methoed algebrique
double z;
//calcul de la profondeur de l'intersection
z = distance/(normal_Cam_optim[0]*iP.get_u()+normal_Cam_optim[1]*iP.get_v()+normal_Cam_optim[2]);
//calcul coordonnees 3D intersection
Xinter_optim[0]=iP.get_u()*z;
Xinter_optim[1]=iP.get_v()*z;
Xinter_optim[2]=z;
//recuperation des coordonnes de l'intersection dans le plan objet
//repere plan object :
// centre = X0_2_optim[i] (premier point definissant le plan)
// base = u:(X[1]-X[0]) et v:(X[3]-X[0])
//ici j'ai considere que le plan est un rectangle => coordonnees sont simplement obtenu par un produit scalaire
double u = 0, v = 0;
for(unsigned int i = 0; i < 3; i++)
{
double diff = (Xinter_optim[i]-X0_2_optim[i]);
u += diff*vbase_u_optim[i];
v += diff*vbase_v_optim[i];
}
u = u/(euclideanNorm_u*euclideanNorm_u);
v = v/(euclideanNorm_v*euclideanNorm_v);
if( u > 0 && v > 0 && u < 1. && v < 1.)
{
double i2,j2;
i2=v*(Ig.getHeight()-1);
j2=u*(Ig.getWidth()-1);
if (interp == BILINEAR_INTERPOLATION)
Ipixelplan = Ig.getValue(i2,j2);
else if (interp == SIMPLE)
Ipixelplan = Ig[(unsigned int)i2][(unsigned int)j2];
return true;
}
else
return false;
}
bool
vpImageSimulator::getPixelDepth(const vpImagePoint iP,double &Zpixelplan)
{
//test si pixel dans zone projetee
if(!T1.inTriangle(iP) && !T2.inTriangle(iP))
return false;
Zpixelplan = distance/(normal_Cam_optim[0]*iP.get_u()+normal_Cam_optim[1]*iP.get_v()+normal_Cam_optim[2]);
return true;
}
int
vpMeTracker::outOfImage(vpImagePoint iP, int half, int rows, int cols)
{
int i = vpMath::round(iP.get_i());
int j = vpMath::round(iP.get_j());
return (! ((i> half+2) &&
(i< rows -(half+2)) &&
(j>half+2) &&
(j<cols-(half+2)))
) ;
}
/*!
Display a rectangle.
\param topLeft : Top-left corner of the rectangle.
\param bottomRight : Bottom-right corner of the rectangle.
\param color : Rectangle color.
\param fill : When set to true fill the rectangle.
\param thickness : Thickness of the four lines used to display the
rectangle.
\warning The thickness can not be set if the display uses the d3d library.
*/
void vpDisplayWin32::displayRectangle( const vpImagePoint &topLeft,
const vpImagePoint &bottomRight,
const vpColor &color, bool fill,
unsigned int thickness )
{
//wait if the window is not initialized
waitForInit();
unsigned int width = static_cast<unsigned int>( bottomRight.get_j() - topLeft.get_j() );
unsigned int height = static_cast<unsigned int>(bottomRight.get_i() - topLeft.get_i() );
window.renderer->drawRect(topLeft,width,height,color, fill, thickness);
}
void addContourPoint(vpImage<int> &I, vp::vpContour *border, const vpImagePoint &point, bool checked[8], const int nbd) {
border->m_points.push_back(point);
unsigned int i = (unsigned int) point.get_i();
unsigned int j = (unsigned int) point.get_j();
if (crossesEastBorder(I, checked, point)) {
I[i][j] = -nbd;
} else if (I[i][j] == 1) {
//Only set if the pixel has not been visited before (3.4) (b)
I[i][j] = nbd;
} //Otherwise leave it alone
}
/*!
\relates vpImagePoint
Returns true if ip1 and ip2 are different; otherwire returns true.
*/
VISP_EXPORT bool operator!=( const vpImagePoint &ip1, const vpImagePoint &ip2 ) {
//return ( ( ip1.get_i() != ip2.get_i() ) || ( ip1.get_j() != ip2.get_j() ) );
double i1 = ip1.get_i();
double j1 = ip1.get_j();
double i2 = ip2.get_i();
double j2 = ip2.get_j();
return (
( std::fabs(i1-i2) > std::fabs(vpMath::maximum(i1, i2))*std::numeric_limits<double>::epsilon() )
||
( std::fabs(j1-j2) > std::fabs(vpMath::maximum(j1, j2))*std::numeric_limits<double>::epsilon() )
);
}
/*!
Display a dashed line from image point \e ip1 to image point \e ip2.
\warning Dot lines are not yet implemented in OpenCV. We display a
normal line instead.
\param ip1,ip2 : Initial and final image points.
\param color : Line color.
\param thickness : Line thickness.
*/
void
vpDisplayOpenCV::displayDotLine(const vpImagePoint &ip1,
const vpImagePoint &ip2,
const vpColor &color,
unsigned int thickness)
{
if (displayHasBeenInitialized)
{
vpTRACE("Dot lines are not yet implemented");
if (color.id < vpColor::id_unknown) {
cvLine( background,
cvPoint( vpMath::round( ip1.get_u() ),
vpMath::round( ip1.get_v() ) ),
cvPoint( vpMath::round( ip2.get_u() ),
vpMath::round( ip2.get_v() ) ),
col[color.id], (int) thickness);
}
else {
cvcolor = CV_RGB(color.R, color.G, color.B) ;
cvLine( background,
cvPoint( vpMath::round( ip1.get_u() ),
vpMath::round( ip1.get_v() ) ),
cvPoint( vpMath::round( ip2.get_u() ),
vpMath::round( ip2.get_v() ) ),
cvcolor, (int) thickness);
}
}
else
{
vpERROR_TRACE("OpenCV not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"OpenCV not initialized")) ;
}
}
/*!
Computes the \f$ \theta \f$ angle which represents the angle between the tangente to the curve and the i axis.
\param theta : The computed value.
\param K : The parameters of the ellipse.
\param iP : the point belonging th the ellipse where the angle is computed.
*/
void
computeTheta(double &theta, vpColVector &K, vpImagePoint iP)
{
double i = iP.get_i();
double j = iP.get_j();
double A = 2*i+2*K[1]*j + 2*K[2] ;
double B = 2*K[0]*j + 2*K[1]*i + 2*K[3];
theta = atan2(A,B) ; //Angle between the tangente and the i axis.
while (theta > M_PI) { theta -= M_PI ; }
while (theta < 0) { theta += M_PI ; }
}
/*!
Train the classifier on a region of the entire image. The region is a
rectangle defined by its top left corner, its height and its width. The
parameters of this rectangle must be given in pixel. It also includes the
training of the fern classifier.
\param _I : The image use to train the classifier.
\param _iP : The top left corner of the rectangle defining the region of interest (ROI).
\param _height : The height of the ROI.
\param _width : The width of the ROI.
\return the number of reference points
*/
unsigned int
vpPlanarObjectDetector::buildReference(const vpImage<unsigned char> &_I,
const vpImagePoint &_iP,
unsigned int _height, unsigned int _width)
{
unsigned int res = fern.buildReference(_I, _iP, _height, _width);
modelROI.x = (int)_iP.get_u();
modelROI.y = (int)_iP.get_v();
modelROI.width = (int)_width;
modelROI.height = (int)_height;
initialiseRefCorners(modelROI);
return res;
}
/*!
Wait for a mouse button click release and get the position of the
image point were the click release occurs. The button used to click is
also set. Same method as getClick(unsigned int&, unsigned int&,
vpMouseButton::vpMouseButtonType &, bool).
\param ip [out] : Position of the clicked image point.
\param button [in] : Button used to click.
\param blocking [in] : true for a blocking behaviour waiting a mouse
button click, false for a non blocking behaviour.
\return
- true if a button was clicked. This is always the case if blocking is set
to \e true.
- false if no button was clicked. This can occur if blocking is set
to \e false.
\sa getClick(vpImagePoint &, vpMouseButton::vpMouseButtonType &, bool)
*/
bool
vpDisplayGTK::getClickUp(vpImagePoint &ip,
vpMouseButton::vpMouseButtonType& button,
bool blocking)
{
bool ret = false;
if ( displayHasBeenInitialized ) {
//flushDisplay() ;
double u, v ;
do {
GdkEvent *ev = NULL;
while ((ev = gdk_event_get())!=NULL){
if ( ev->any.window == widget->window
&& ev->type == GDK_BUTTON_RELEASE) {
u = ((GdkEventButton *)ev)->x ;
v = ((GdkEventButton *)ev)->y ;
ip.set_u( u );
ip.set_v( v );
switch ( ( int ) ( ( GdkEventButton * ) ev )->button ) {
case 1:
button = vpMouseButton::button1; break;
case 2:
button = vpMouseButton::button2; break;
case 3:
button = vpMouseButton::button3; break;
}
ret = true ;
}
gdk_event_free(ev) ;
}
if (blocking){
flushDisplay();
vpTime::wait(100);
}
} while ( ret == false && blocking == true);
}
else {
vpERROR_TRACE ( "GTK not initialized " ) ;
throw ( vpDisplayException ( vpDisplayException::notInitializedError,
"GTK not initialized" ) ) ;
}
return ret;
}
/*!
Display of the ellipse thanks to the equation parameters.
\param I : The image used as background.
\param center : Center of the ellipse
\param A : Semiminor axis of the ellipse.
\param B : Semimajor axis of the ellipse.
\param E : Angle made by the major axis and the i axis of the image frame \f$ (i,j) \f$
\param smallalpha : Smallest \f$ alpha \f$ angle in rad.
\param highalpha : Highest \f$ alpha \f$ angle in rad.
\param color : Color used to display th lines.
\param thickness : Thickness of the drawings.
*/
void vpMeEllipse::display(const vpImage<vpRGBa>& I, const vpImagePoint ¢er,
const double &A, const double &B, const double &E,
const double & smallalpha, const double &highalpha,
const vpColor &color, unsigned int thickness)
{
double j1, i1;
vpImagePoint iP11;
double j2, i2;
vpImagePoint iP22;
j1 = j2 = i1 = i2 = 0 ;
double incr = vpMath::rad(2) ; // angle increment
vpDisplay::displayCross(I,center,20, vpColor::red, thickness) ;
double k = smallalpha ;
while (k+incr<highalpha)
{
j1 = A *cos(k) ; // equation of an ellipse
i1 = B *sin(k) ; // equation of an ellipse
j2 = A *cos(k+incr) ; // equation of an ellipse
i2 = B *sin(k+incr) ; // equation of an ellipse
// (i1,j1) are the coordinates on the origin centered ellipse ;
// a rotation by "e" and a translation by (xci,jc) are done
// to get the coordinates of the point on the shifted ellipse
iP11.set_j ( center.get_j() + cos(E) *j1 - sin(E) *i1 );
iP11.set_i ( center.get_i() -( sin(E) *j1 + cos(E) *i1) );
// to get the coordinates of the point on the shifted ellipse
iP22.set_j ( center.get_j() + cos(E) *j2 - sin(E) *i2 );
iP22.set_i ( center.get_i() -( sin(E) *j2 + cos(E) *i2) );
vpDisplay::displayLine(I, iP11, iP22, color, thickness) ;
k += incr ;
}
j1 = A *cos(smallalpha) ; // equation of an ellipse
i1 = B *sin(smallalpha) ; // equation of an ellipse
j2 = A *cos(highalpha) ; // equation of an ellipse
i2 = B *sin(highalpha) ; // equation of an ellipse
// (i1,j1) are the coordinates on the origin centered ellipse ;
// a rotation by "e" and a translation by (xci,jc) are done
// to get the coordinates of the point on the shifted ellipse
iP11.set_j ( center.get_j() + cos(E) *j1 - sin(E) *i1 );
iP11.set_i ( center.get_i() -( sin(E) *j1 + cos(E) *i1) );
// to get the coordinates of the point on the shifted ellipse
iP22.set_j ( center.get_j() + cos(E) *j2 - sin(E) *i2 );
iP22.set_i ( center.get_i() -( sin(E) *j2 + cos(E) *i2) );
vpDisplay::displayLine(I, center, iP11, vpColor::red, thickness) ;
vpDisplay::displayLine(I, center, iP22, vpColor::blue, thickness) ;
}
/*!
Check if the 2D point \f$ iP \f$ is inside the triangle.
\param iP : The point which coulb be inside the triangle.
\param threshold : A threshold used to define the accuracy of the computation when the point is very near from the edges of the triangle. 0 is the smallest value.
\return Returns true if the point is inside the triangle. Returns false otherwise.
*/
bool
vpTriangle::inTriangle(const vpImagePoint &iP, double threshold)
{
if(!goodTriange)
return false;
if(threshold < 0)
threshold = 0;
ptempo0 = iP.get_i() - S1.get_i();
ptempo1 = iP.get_j() - S1.get_j();
double p_ds_uv0=ptempo0*uvinv00+ptempo1*uvinv10;
double p_ds_uv1=ptempo0*uvinv01+ptempo1*uvinv11;
return (p_ds_uv0+p_ds_uv1<1.+threshold && p_ds_uv0>-threshold && p_ds_uv1>-threshold);
}
bool
vpImageSimulator::getPixelDepth(const vpImagePoint &iP, double &Zpixelplan)
{
//test si pixel dans zone projetee
bool inside = false;
for(unsigned int i = 0 ; i < listTriangle.size() ; i++)
if(listTriangle[i].inTriangle(iP)){
inside = true;
break;
}
if(!inside) return false;
// if(!T1.inTriangle(iP) && !T2.inTriangle(iP))
// return false;
Zpixelplan = distance/(normal_Cam_optim[0]*iP.get_u()+normal_Cam_optim[1]*iP.get_v()+normal_Cam_optim[2]);
return true;
}