int MeasureTool::processMouseEvent( ViewportMouseEvent& event )
{
int flags = 0;
Ogre::Vector3 pos;
std::stringstream ss;
bool success = context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, pos );
setCursor( success ? hit_cursor_ : std_cursor_ );
switch ( state_ )
{
case START:
break;
case END:
if ( success )
{
line_->setPoints(start_,pos);
length_ = (start_-pos).length();
}
break;
}
if ( length_ > 0.0 )
{
ss << "[Length: " << length_ << "m] ";
}
ss << "Click on two points to measure their distance. Right-click to reset.";
setStatus( QString( ss.str().c_str() ) );
if( event.leftUp() && success )
{
switch ( state_ )
{
case START:
start_ = pos;
state_ = END;
break;
case END:
end_ = pos;
state_ = START;
line_->setPoints(start_,end_);
break;
}
flags |= Render;
}
if ( event.rightUp() )
{
state_ = START;
line_->setVisible(false);
}
return flags;
}
void FPSViewController::handleMouseEvent(ViewportMouseEvent& event)
{
if ( event.shift() )
{
setStatus( "<b>Left-Click:</b> Move X/Y. <b>Right-Click:</b>: Move Z." );
}
else
{
setStatus( "<b>Left-Click:</b> Rotate. <b>Middle-Click:</b> Move X/Y. <b>Right-Click:</b>: Zoom. <b>Shift</b>: More options." );
}
bool moved = false;
int32_t diff_x = 0;
int32_t diff_y = 0;
if( event.type == QEvent::MouseMove )
{
diff_x = event.x - event.last_x;
diff_y = event.y - event.last_y;
moved = true;
}
if( event.left() && !event.shift() )
{
setCursor( Rotate3D );
yaw( -diff_x*0.005 );
pitch( diff_y*0.005 );
}
else if( event.middle() || ( event.shift() && event.left() ))
{
setCursor( MoveXY );
move( diff_x*0.01, -diff_y*0.01, 0.0f );
}
else if( event.right() )
{
setCursor( MoveZ );
move( 0.0f, 0.0f, diff_y*0.1 );
}
else
{
setCursor( event.shift() ? MoveXY : Rotate3D );
}
if ( event.wheel_delta != 0 )
{
int diff = event.wheel_delta;
move( 0.0f, 0.0f, -diff * 0.01 );
moved = true;
}
if (moved)
{
context_->queueRender();
}
}
void FixedViewController::handleMouseEvent(ViewportMouseEvent& event)
{
setStatus( "<b>Right-Click / Mouse Wheel:</b>: Zoom. " );
int32_t diff_x = event.x - event.last_x;
int32_t diff_y = event.y - event.last_y;
if( event.right() )
{
setCursor( Zoom );
zoom( -diff_y * 0.1);
}
if( event.wheel_delta != 0 )
{
int diff = event.wheel_delta;
zoom( diff * 0.001 );
}
}
int PointTool::processMouseEvent( ViewportMouseEvent& event )
{
int flags = 0;
Ogre::Vector3 pos;
bool success = context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, pos );
setCursor( success ? hit_cursor_ : std_cursor_ );
if ( success )
{
std::ostringstream s;
s << "<b>Left-Click:</b> Select this point.";
s.precision(3);
s << " [" << pos.x << "," << pos.y << "," << pos.z << "]";
setStatus( s.str().c_str() );
if( event.leftUp() )
{
geometry_msgs::PointStamped ps;
ps.point.x = pos.x;
ps.point.y = pos.y;
ps.point.z = pos.z;
ps.header.frame_id = context_->getFixedFrame().toStdString();
ps.header.stamp = ros::Time::now();
pub_.publish( ps );
if ( auto_deactivate_property_->getBool() )
{
flags |= Finished;
}
}
}
else
{
setStatus( "Move over an object to select the target point." );
}
return flags;
}
int FocusTool::processMouseEvent( ViewportMouseEvent& event )
{
int flags = 0;
Ogre::Vector3 pos;
bool success = context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, pos );
setCursor( success ? hit_cursor_ : std_cursor_ );
if ( !success )
{
Ogre::Ray mouse_ray = event.viewport->getCamera()->getCameraToViewportRay(
(float)event.x / (float)event.viewport->getActualWidth(),
(float)event.y / (float)event.viewport->getActualHeight() );
pos = mouse_ray.getPoint(1.0);
setStatus( "<b>Left-Click:</b> Look in this direction." );
}
else
{
std::ostringstream s;
s << "<b>Left-Click:</b> Focus on this point.";
s.precision(3);
s << " [" << pos.x << "," << pos.y << "," << pos.z << "]";
setStatus( s.str().c_str() );
}
if( event.leftUp() )
{
if ( event.panel->getViewController() )
{
event.panel->getViewController()->lookAt( pos );
}
flags |= Finished;
}
return flags;
}
int PoseTool::processMouseEvent( ViewportMouseEvent& event )
{
int flags = 0;
if( event.leftDown() )
{
ROS_ASSERT( state_ == Position );
Ogre::Vector3 intersection;
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0.0f );
if( getPointOnPlaneFromWindowXY( event.viewport,
ground_plane,
event.x, event.y, intersection ))
{
pos_ = intersection;
arrow_->setPosition( pos_ );
state_ = Orientation;
flags |= Render;
}
}
else if( event.type == QEvent::MouseMove && event.left() )
{
if( state_ == Orientation )
{
//compute angle in x-y plane
Ogre::Vector3 cur_pos;
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0.0f );
if( getPointOnPlaneFromWindowXY( event.viewport,
ground_plane,
event.x, event.y, cur_pos ))
{
double angle = atan2( cur_pos.y - pos_.y, cur_pos.x - pos_.x );
arrow_->getSceneNode()->setVisible( true );
//we need base_orient, since the arrow goes along the -z axis by default (for historical reasons)
Ogre::Quaternion orient_x = Ogre::Quaternion( Ogre::Radian(-Ogre::Math::HALF_PI), Ogre::Vector3::UNIT_Y );
arrow_->setOrientation( Ogre::Quaternion( Ogre::Radian(angle), Ogre::Vector3::UNIT_Z ) * orient_x );
flags |= Render;
}
}
}
else if( event.leftUp() )
{
if( state_ == Orientation )
{
//compute angle in x-y plane
Ogre::Vector3 cur_pos;
Ogre::Plane ground_plane( Ogre::Vector3::UNIT_Z, 0.0f );
if( getPointOnPlaneFromWindowXY( event.viewport,
ground_plane,
event.x, event.y, cur_pos ))
{
double angle = atan2( cur_pos.y - pos_.y, cur_pos.x - pos_.x );
onPoseSet(pos_.x, pos_.y, angle);
flags |= (Finished|Render);
}
}
}
return flags;
}
void XYOrbitViewController::handleMouseEvent(ViewportMouseEvent& event)
{
if ( event.shift() )
{
setStatus( "<b>Left-Click:</b> Move X/Y. <b>Right-Click:</b>: Zoom." );
}
else
{
setStatus( "<b>Left-Click:</b> Rotate. <b>Middle-Click:</b> Move X/Y. <b>Right-Click:</b>: Move Z. <b>Shift</b>: More options." );
}
int32_t diff_x = 0;
int32_t diff_y = 0;
bool moved = false;
if( event.type == QEvent::MouseButtonPress )
{
focal_shape_->getRootNode()->setVisible(true);
moved = true;
}
else if( event.type == QEvent::MouseButtonRelease )
{
focal_shape_->getRootNode()->setVisible(false);
moved = true;
}
else if( event.type == QEvent::MouseMove )
{
diff_x = event.x - event.last_x;
diff_y = event.y - event.last_y;
moved = true;
}
if( event.left() && !event.shift() )
{
setCursor( Rotate3D );
yaw( diff_x*0.005 );
pitch( -diff_y*0.005 );
}
else if( event.middle() || (event.left() && event.shift()) )
{
setCursor( MoveXY );
// handle mouse movement
int width = event.viewport->getActualWidth();
int height = event.viewport->getActualHeight();
Ogre::Ray mouse_ray = event.viewport->getCamera()->getCameraToViewportRay( event.x / (float) width,
event.y / (float) height );
Ogre::Ray last_mouse_ray =
event.viewport->getCamera()->getCameraToViewportRay( event.last_x / (float) width,
event.last_y / (float) height );
Ogre::Vector3 last_intersect, intersect;
if( intersectGroundPlane( last_mouse_ray, last_intersect ) &&
intersectGroundPlane( mouse_ray, intersect ))
{
Ogre::Vector3 motion = last_intersect - intersect;
// When dragging near the horizon, the motion can get out of
// control. This throttles it to an arbitrary limit per mouse
// event.
float motion_distance_limit = 1; /*meter*/
if( motion.length() > motion_distance_limit )
{
motion.normalise();
motion *= motion_distance_limit;
}
focal_point_property_->add( motion );
emitConfigChanged();
}
}
else if( event.right() )
{
setCursor( Zoom );
zoom( -diff_y * 0.1 * (distance_property_->getFloat() / 10.0f) );
}
else
{
setCursor( event.shift() ? MoveXY : Rotate3D );
}
if( event.wheel_delta != 0 )
{
int diff = event.wheel_delta;
zoom( diff * 0.001 * distance_property_->getFloat() );
moved = true;
}
if( moved )
{
context_->queueRender();
}
}
int SelectionTool::processMouseEvent( ViewportMouseEvent& event )
{
SelectionManager* sel_manager = context_->getSelectionManager();
int flags = 0;
if( event.alt() )
{
moving_ = true;
selecting_ = false;
}
else
{
moving_ = false;
if( event.leftDown() )
{
selecting_ = true;
sel_start_x_ = event.x;
sel_start_y_ = event.y;
}
}
if( selecting_ )
{
sel_manager->highlight( event.viewport, sel_start_x_, sel_start_y_, event.x, event.y );
if( event.leftUp() )
{
SelectionManager::SelectType type = SelectionManager::Replace;
M_Picked selection;
if( event.shift() )
{
type = SelectionManager::Add;
}
else if( event.control() )
{
type = SelectionManager::Remove;
}
sel_manager->select( event.viewport, sel_start_x_, sel_start_y_, event.x, event.y, type );
selecting_ = false;
}
flags |= Render;
}
else if( moving_ )
{
sel_manager->removeHighlight();
flags = move_tool_->processMouseEvent( event );
if( event.type == QEvent::MouseButtonRelease )
{
moving_ = false;
}
}
else
{
sel_manager->highlight( event.viewport, event.x, event.y, event.x, event.y );
}
return flags;
}
void InteractiveMarkerControl::handleMouseEvent( ViewportMouseEvent& event )
{
// * check if this is just a receive/lost focus event
// * try to hand over the mouse event to the parent interactive marker
// * otherwise, execute mouse move handling
// handle receive/lose focus
if( event.type == QEvent::FocusIn )
{
has_focus_ = true;
std::set<Ogre::Pass*>::iterator it;
setHighlight( HOVER_HIGHLIGHT );
event.panel->setCursor( cursor_ );
}
else if( event.type == QEvent::FocusOut )
{
has_focus_ = false;
setHighlight(0.0);
return;
}
// change dragging state
switch( interaction_mode_ )
{
case visualization_msgs::InteractiveMarkerControl::BUTTON:
if( event.leftUp() )
{
Ogre::Vector3 point_rel_world;
bool got_3D_point = context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, point_rel_world );
visualization_msgs::InteractiveMarkerFeedback feedback;
feedback.event_type = visualization_msgs::InteractiveMarkerFeedback::BUTTON_CLICK;
feedback.control_name = name_;
feedback.marker_name = parent_->getName();
parent_->publishFeedback( feedback, got_3D_point, point_rel_world );
}
break;
case visualization_msgs::InteractiveMarkerControl::MOVE_AXIS:
case visualization_msgs::InteractiveMarkerControl::MOVE_PLANE:
case visualization_msgs::InteractiveMarkerControl::MOVE_ROTATE:
case visualization_msgs::InteractiveMarkerControl::ROTATE_AXIS:
if( event.leftDown() )
{
parent_->startDragging();
dragging_ = true;
drag_viewport_ = event.viewport;
recordDraggingInPlaceEvent( event );
if( ! context_->getSelectionManager()->get3DPoint( event.viewport, event.x, event.y, grab_point_ ))
{
// If we couldn't get a 3D point for the grab, just use the
// current relative position of the control frame.
grab_point_ = control_frame_node_->getPosition();
}
else
{
// If we could get a 3D point for the grab, convert it from
// the world frame to the reference frame (in case those are different).
grab_point_ = reference_node_->convertWorldToLocalPosition(grab_point_);
}
grab_pixel_.x = event.x;
grab_pixel_.y = event.y;
parent_position_at_mouse_down_ = parent_->getPosition();
parent_orientation_at_mouse_down_ = parent_->getOrientation();
if( orientation_mode_ == visualization_msgs::InteractiveMarkerControl::VIEW_FACING &&
drag_viewport_ )
{
updateControlOrientationForViewFacing( drag_viewport_ );
}
control_frame_orientation_at_mouse_down_ = control_frame_node_->getOrientation();
rotation_at_mouse_down_ = rotation_;
rotation_axis_ = control_frame_node_->getOrientation() * control_orientation_.xAxis();
// Find rotation_center = 3D point closest to grab_point_ which is
// on the rotation axis, relative to the reference frame.
Ogre::Vector3 rotation_center_rel_ref = closestPointOnLineToPoint( parent_->getPosition(),
rotation_axis_,
grab_point_ );
Ogre::Matrix4 reference_rel_control_frame;
reference_rel_control_frame.makeInverseTransform( control_frame_node_->getPosition(),
Ogre::Vector3::UNIT_SCALE,
control_frame_node_->getOrientation() );
rotation_center_rel_control_ = reference_rel_control_frame * rotation_center_rel_ref;
grab_point_rel_control_ = reference_rel_control_frame * grab_point_;
}
if( event.leftUp() )
{
dragging_ = false;
drag_viewport_ = NULL;
parent_->stopDragging();
}
break;
default:
break;
}
if( event.leftDown() )
{
setHighlight( ACTIVE_HIGHLIGHT );
}
else if( event.leftUp() )
{
setHighlight( HOVER_HIGHLIGHT );
}
if (!parent_->handleMouseEvent(event, name_))
{
if( event.type == QEvent::MouseMove && event.left() )
{
recordDraggingInPlaceEvent( event );
handleMouseMovement( event );
}
}
}
void OrthoViewControllerCustom::handleMouseEvent(ViewportMouseEvent& event)
{
// if ( event.shift() )
// {
setStatus( "<b>Left-Click:</b> Move X/Y." );
// }
// else
// {
// setStatus( "<b>Left-Click:</b> Rotate. <b>Middle-Click:</b> Move X/Y. <b>Right-Click:</b>: Zoom. <b>Shift</b>: More options." );
// }
bool moved = false;
int32_t diff_x = 0;
int32_t diff_y = 0;
if( event.type == QEvent::MouseButtonPress )
{
dragging_ = true;
}
else if( event.type == QEvent::MouseButtonRelease )
{
dragging_ = false;
}
else if( dragging_ && event.type == QEvent::MouseMove )
{
diff_x = event.x - event.last_x;
diff_y = event.y - event.last_y;
moved = true;
}
// if( event.left() && !event.shift() )
// {
// setCursor( Rotate2D );
// angle_property_->add( diff_x * 0.005 );
// orientCamera();
// }
// else if( event.middle() || ( event.shift() && event.left() ))
// {
// setCursor( MoveXY );
// float scale = scale_property_->getFloat();
// move( -diff_x / scale, diff_y / scale );
// }
// else if( event.right() )
// {
// setCursor( Zoom );
// scale_property_->multiply( 1.0 - diff_y * 0.01 );
// }
// else
// {
// setCursor( event.shift() ? MoveXY : Rotate2D );
// }
// can only do XY panning
setCursor( MoveXY );
if( event.middle() )
{
float scale = scale_property_->getFloat();
move( -diff_x / scale, diff_y / scale );
}
if ( event.wheel_delta != 0 )
{
int diff = event.wheel_delta;
scale_property_->multiply( 1.0 - (-diff) * 0.001 );
moved = true;
}
if (moved)
{
context_->queueRender();
emitConfigChanged();
}
}
int ImageSelectionToolCustom::processMouseEvent( ViewportMouseEvent& event )
{
//SelectionManager* sel_manager = context_->getSelectionManager();
Q_EMIT mouseHasMoved(event.x, event.y);
int flags = 0;
moving_ = false;
if( event.leftDown() )
{
selecting_ = true;
sel_start_x_ = event.x;
sel_start_y_ = event.y;
}
if( selecting_ )
{
/**std::cout<<"tool selected x1 " <<sel_start_x_<<std::endl;
std::cout<<"tool selected y1 " <<sel_start_y_<<std::endl;
std::cout<<"tool selected x2 " <<event.x<<std::endl;
std::cout<<"selected y2 " <<event.y<<std::endl;**/
theX1 = sel_start_x_;
theX2 = event.x;
theY1 = sel_start_y_;
theY2 = event.y;
port = event.viewport;
highlight( event.viewport, sel_start_x_, sel_start_y_, event.x, event.y );
if( event.leftUp() )
{
SelectionManager::SelectType type = SelectionManager::Replace;
M_Picked selection;
/*if( event.shift() )
{
type = SelectionManager::Add;
}
else if( event.control() )
{
type = SelectionManager::Remove;
}*/
//sel_manager->select( event.viewport, sel_start_x_, sel_start_y_, event.x, event.y, type );
removeHighlight();
Q_EMIT select( sel_start_x_, sel_start_y_, event.x, event.y );
selecting_ = false;
}
flags |= Render;
}
else
{
highlight( event.viewport, theX1, theY1, theX2, theY2 );
}
return flags;
}
