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; }