//static LLVector2 LLUI::getWindowSize() { LLCoordWindow window_rect; sWindow->getSize(&window_rect); return LLVector2(window_rect.mX / getScaleFactor().mV[VX], window_rect.mY / getScaleFactor().mV[VY]); }
//static void LLUI::setMousePositionScreen(S32 x, S32 y) { S32 screen_x, screen_y; screen_x = llround((F32)x * getScaleFactor().mV[VX]); screen_y = llround((F32)y * getScaleFactor().mV[VY]); LLView::getWindow()->setCursorPosition(LLCoordGL(screen_x, screen_y).convert()); }
//static void LLUI::getMousePositionScreen(S32 *x, S32 *y) { LLCoordWindow cursor_pos_window; getWindow()->getCursorPosition(&cursor_pos_window); LLCoordGL cursor_pos_gl(cursor_pos_window.convert()); *x = llround((F32)cursor_pos_gl.mX / getScaleFactor().mV[VX]); *y = llround((F32)cursor_pos_gl.mY / getScaleFactor().mV[VX]); }
void ScaleX::execEvent() { g_log.information("Processing event workspace"); const MatrixWorkspace_const_sptr matrixInputWS = this->getProperty("InputWorkspace"); const std::string op = getPropertyValue("Operation"); EventWorkspace_const_sptr inputWS=boost::dynamic_pointer_cast<const EventWorkspace>(matrixInputWS); // generate the output workspace pointer API::MatrixWorkspace_sptr matrixOutputWS = this->getProperty("OutputWorkspace"); EventWorkspace_sptr outputWS; if (matrixOutputWS == matrixInputWS) outputWS = boost::dynamic_pointer_cast<EventWorkspace>(matrixOutputWS); else { //Make a brand new EventWorkspace outputWS = boost::dynamic_pointer_cast<EventWorkspace>(API::WorkspaceFactory::Instance().create("EventWorkspace", inputWS->getNumberHistograms(), 2, 1)); //Copy geometry over. API::WorkspaceFactory::Instance().initializeFromParent(inputWS, outputWS, false); //You need to copy over the data as well. outputWS->copyDataFrom( (*inputWS) ); //Cast to the matrixOutputWS and save it matrixOutputWS = boost::dynamic_pointer_cast<MatrixWorkspace>(outputWS); this->setProperty("OutputWorkspace", matrixOutputWS); } int numHistograms = static_cast<int>(inputWS->getNumberHistograms()); PARALLEL_FOR1(outputWS) for (int i=0; i < numHistograms; ++i) { PARALLEL_START_INTERUPT_REGION //Do the offsetting if ((i >= m_wi_min) && (i <= m_wi_max)) { if(op=="Multiply") { outputWS->getEventList(i).scaleTof(getScaleFactor(inputWS, i)); if( m_algFactor < 0 ) { outputWS->getEventList(i).reverse(); } } else if(op=="Add") { outputWS->getEventList(i).addTof(getScaleFactor(inputWS, i)); } } m_progress->report("Scaling X"); PARALLEL_END_INTERUPT_REGION } PARALLEL_CHECK_INTERUPT_REGION outputWS->clearMRU(); }
void ScalingLayer::renderToTarget(MyGUI::IRenderTarget *_target, bool _update) { MyGUI::IntSize globalViewSize = MyGUI::RenderManager::getInstance().getViewSize(); MyGUI::IntSize viewSize = globalViewSize; float scale = getScaleFactor(); viewSize.width /= scale; viewSize.height /= scale; float hoffset = (globalViewSize.width - mViewSize.width*getScaleFactor())/2.f / static_cast<float>(globalViewSize.width); float voffset = (globalViewSize.height - mViewSize.height*getScaleFactor())/2.f / static_cast<float>(globalViewSize.height); ProxyRenderTarget proxy(_target, viewSize, hoffset, voffset); MyGUI::OverlappedLayer::renderToTarget(&proxy, _update); }
/** * Handle pointer releases. * @param point The pointer position on the screen. */ void ScreenImageSwiper::handlePointerReleased(MAPoint2d point) { // Search for the image on the center of the screen. int centeredImage = -1; for (int i = 0; i < mImagesSize; ++i) { if ( mImages[i]->isOnScreenCenter(mScreenWidth) ) { centeredImage = i; break; } } // Align images to grid. if (centeredImage >= 0) { mLabelLayout->setText(mImages[centeredImage]->getName()); int offset = mImages[centeredImage]->getGridOffset(mScreenWidth); for (int i = 0; i < mImagesSize; ++i) { mImages[i]->update(offset, 0); } } float scaleFactor = getScaleFactor(); mPointerXStart = (int)((float) point.x * scaleFactor); mPointerXEnd = (int)((float) point.x * scaleFactor); }
BOOL PieMenu::handleHover(S32 x, S32 y, MASK mask) { // initialize pie scale factor for popup effect F32 factor = getScaleFactor(); // initially, the current segment is marked as invalid mCurrentSegment = -1; // remember to take the UI scaling into account LLVector2 scale = gViewerWindow->getDisplayScale(); // move mouse coordinates to be relative to the pie center LLVector2 mouseVector(x - PIE_OUTER_SIZE / scale.mV[VX], y - PIE_OUTER_SIZE / scale.mV[VY]); // get the distance from the center point F32 distance = mouseVector.length(); // check if our mouse pointer is within the pie slice area if (distance > PIE_INNER_SIZE && (distance < (PIE_OUTER_SIZE * factor) || mFirstClick)) { // get the angle of the mouse pointer from the center in radians F32 angle = acos(mouseVector.mV[VX] / distance); // if the mouse is below the middle of the pie, reverse the angle if (mouseVector.mV[VY] < 0) { angle = F_PI * 2 - angle; } // rotate the angle slightly so the slices' centers are aligned correctly angle += F_PI / 8; // calculate slice number from the angle mCurrentSegment = (S32) (8.f * angle / (F_PI * 2.f)) % 8; } return TRUE; }
/** * Handle pointer presses. * @param point The pointer position on the screen. */ void ScreenImageSwiper::handlePointerPressed(MAPoint2d point) { // Set start and end swipe point to the touch down point. float scaleFactor = getScaleFactor(); mPointerXStart = (int)((float) point.x * scaleFactor); mPointerXEnd = (int)((float) point.x * scaleFactor); }
NutrientAmount FoodAmount::getScaledCaloriesFromNutrientId (const QString& nutrId) const { if (getFood() == NULL) { throw std::logic_error("Attempted to scale the nutrients of an undefined food."); } return getFood()->getCaloriesFromNutrientId(nutrId) * getScaleFactor(); }
void ImageEditor::cropImage(){ if(selRect.isNull()){ return; } qreal sf = getScaleFactor(); QRect srect = QRect( qRound(selRect.x()/sf), qRound(selRect.y()/sf), qRound(selRect.width()/sf), qRound(selRect.height()/sf)); fullIMG = fullIMG.copy(srect); scaledIMG = fullIMG.scaled( defaultSize, Qt::KeepAspectRatio,Qt::SmoothTransformation); selRect = QRect(); emit selectionChanged(false); this->update(); //trigger paint event }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ScaleVolume::readFilterParameters(AbstractFilterParametersReader* reader, int index) { reader->openFilterGroup(this, index); setApplyToVoxelVolume( reader->readValue("ApplyToVoxelVolume", getApplyToVoxelVolume()) ); setApplyToSurfaceMesh( reader->readValue("ApplyToSurfaceMesh", getApplyToSurfaceMesh()) ); setScaleFactor( reader->readFloatVec3("ScaleFactor", getScaleFactor() ) ); setDataContainerName(reader->readString("DataContainerName", getDataContainerName())); setSurfaceDataContainerName(reader->readString("SurfaceDataContainerName", getSurfaceDataContainerName())); reader->closeFilterGroup(); }
void IntersectActor::setupChildrenPriorities(void) { UInt32 numChildren = getNumChildren (); UInt32 numExtraChildren = getNumExtraChildren(); Real32 scaleFactor = getScaleFactor(); Real32 hitDist = getHitDistance(); Real32 bvEnter; Real32 bvExit; setChildrenListEnabled(true); for(UInt32 i = 0; i < numChildren; ++i) { #ifndef OSG_2_PREP const DynamicVolume &vol = getChild(i)->editVolume(true); #else const BoxVolume &vol = getChild(i)->editVolume(true); #endif if((vol.intersect(getRay(), bvEnter, bvExit) == true ) && (bvEnter * scaleFactor < hitDist) ) { setChildPriority(i, -bvEnter * scaleFactor); } else { setChildActive (i, false); } } for(UInt32 i = 0; i < numExtraChildren; ++i) { #ifndef OSG_2_PREP const DynamicVolume &vol = getChild(i)->editVolume(true); #else const BoxVolume &vol = getChild(i)->editVolume(true); #endif if((vol.intersect(getRay(), bvEnter, bvExit) == true ) && (bvEnter * scaleFactor < hitDist) ) { setExtraChildPriority(i, -bvEnter * scaleFactor); } else { setExtraChildActive (i, false); } } }
vgm::MatrixR Transform::gethMatrix() const { vgm::MatrixR matrix; matrix.setTransform( getTranslation(), getRotation(), getScaleFactor(), getScaleOrientation(), getCenter() ); return ( matrix ); }
void TmultiScore::resizeEvent(QResizeEvent* event) { int hh = height(), ww = width(); if (event) { hh = event->size().height(); ww = event->size().width(); } if (m_inMode == e_single) { if (ww < 300 || hh < 200) return; TsimpleScore::resizeEvent(event); } else { if (ww < 400 || hh < 200) return; qreal factor = getScaleFactor(hh, m_scale); scoreScene()->prepareToChangeRect(); scale(factor, factor); qreal oldStaffWidth = staff()->viewWidth(); for (int i = 0; i < m_staves.size(); i++) adjustStaffWidth(m_staves[i]); if (oldStaffWidth != staff()->viewWidth()) { // TODO: another routine for non-rhythms for (int i = 0; i < m_staves.size(); i++) { qreal staffContentWidth = m_staves[i]->contentWidth(m_staves[i]->gapFactor()); if (staffContentWidth != m_staves[i]->width()) { qDebug() << debug() << "staff width changed about" << qAbs(staffContentWidth - m_staves[i]->width()) << "- fitting"; m_staves[i]->fit(); m_staves[i]->updateNotesPos(); } } for (int i = 0; i < m_staves.size(); i++) { if (m_staves[i]->count() == 0) deleteLastStaff(); } } qreal staffOff = staff()->isPianoStaff() ? 1.1 : 0.0; for (int i = 0; i < m_staves.size(); i++) { if (i == 0) m_staves[i]->setPos(staffOff, 0.0); else m_staves[i]->setPos(staffOff, m_staves[i - 1]->pos().y() + m_staves[i - 1]->loNotePos() - m_staves[i]->hiNotePos() + ((staff()->hasScordature() && i == 1) ? 7.0 : 4.0)); } updateSceneRect(); } }
void ScalingLayer::screenToLayerCoords(int& _left, int& _top) const { float scale = getScaleFactor(); if (scale <= 0.f) return; MyGUI::IntSize globalViewSize = MyGUI::RenderManager::getInstance().getViewSize(); _left -= globalViewSize.width/2; _top -= globalViewSize.height/2; _left /= scale; _top /= scale; _left += mViewSize.width/2; _top += mViewSize.height/2; }
QVector<FoodAmount> FoodAmount::getScaledComponents() const { // See getScaledNutrients for logic description if (getFood() == NULL) { throw std::logic_error("Attempted to scale the components of an undefined food."); } QVector<FoodAmount> components = getFood()->getComponentAmounts(); double scaleFactor = getScaleFactor(); for (QVector<FoodAmount>::iterator i = components.begin(); i != components.end(); ++i) { (*i) *= scaleFactor; } return components; }
QMap<QString, NutrientAmount> FoodAmount::getScaledNutrients() const { // TODO: Cache this instead of recomputing every time if (getFood() == NULL) { throw std::logic_error("Attempted to scale the nutrients of an undefined food."); } QMap<QString, NutrientAmount> nutrients = getFood()->getNutrients(); double scaleFactor = getScaleFactor(); for (QMap<QString, NutrientAmount>::iterator i = nutrients.begin(); i != nutrients.end(); ++i) { (*i) *= scaleFactor; } return nutrients; }
//----------------------------------------------------------------------------- void D2DDrawContext::drawBitmap (CBitmap* bitmap, const CRect& dest, const CPoint& offset, float alpha) { if (renderTarget == 0) return; D2DApplyClip ac (this); if (ac.isEmpty ()) return; double transformedScaleFactor = getScaleFactor (); CGraphicsTransform t = getCurrentTransform (); if (t.m11 == t.m22 && t.m12 == 0 && t.m21 == 0) transformedScaleFactor *= t.m11; IPlatformBitmap* platformBitmap = bitmap->getBestPlatformBitmapForScaleFactor (transformedScaleFactor); D2DBitmap* d2dBitmap = platformBitmap ? dynamic_cast<D2DBitmap*> (platformBitmap) : 0; if (d2dBitmap) { if (d2dBitmap->getSource ()) { ID2D1Bitmap* d2d1Bitmap = D2DBitmapCache::instance ()->getBitmap (d2dBitmap, renderTarget); if (d2d1Bitmap) { double bitmapScaleFactor = platformBitmap->getScaleFactor (); CGraphicsTransform bitmapTransform; bitmapTransform.scale (bitmapScaleFactor, bitmapScaleFactor); Transform transform (*this, bitmapTransform.inverse ()); CRect d (dest); d.makeIntegral (); CRect source (dest); source.offset (-source.left, -source.top); source.offset (offset.x, offset.y); bitmapTransform.transform (source); D2D1_RECT_F sourceRect = makeD2DRect (source); renderTarget->DrawBitmap (d2d1Bitmap, makeD2DRect (d), alpha * currentState.globalAlpha, D2D1_BITMAP_INTERPOLATION_MODE_LINEAR, &sourceRect); } } } }
/** * Updates the bounding volumes of a model. In this case the OOBB * is used to speed up the calculation of the bounding sphere and the * AABB * * Fast calculation idea copied from * http://zeuxcg.org/2010/10/17/aabb-from-obb-with-component-wise-abs/ */ void _updateBoundingVolumes() { glm::mat4 model = getModelMatrix(); glm::mat4 absModel(glm::abs(model[0][0]), glm::abs(model[0][1]), glm::abs(model[0][2]), glm::abs(model[0][3]), glm::abs(model[1][0]), glm::abs(model[1][1]), glm::abs(model[1][2]), glm::abs(model[1][3]), glm::abs(model[2][0]), glm::abs(model[2][1]), glm::abs(model[2][2]), glm::abs(model[2][3]), glm::abs(model[3][0]), glm::abs(model[3][1]), glm::abs(model[3][2]), glm::abs(model[3][3])); glm::vec3 center = (_oobb.getMin() + _oobb.getMax()) / 2.0f; glm::vec3 extent = (_oobb.getMax() - _oobb.getMin()) / 2.0f; glm::vec3 newCenter = glm::vec3(model * glm::vec4(center, 1.0f)); glm::vec3 newExtent = glm::vec3(absModel * glm::vec4(extent, 0.0f)); glm::vec3 min = newCenter - newExtent; glm::vec3 max = newCenter + newExtent; _aabb.setMin(newCenter - newExtent); _aabb.setMax(newCenter + newExtent); _boundingSphere.setRadius(glm::length(_maxLengthVertex * getScaleFactor())); }
void ImageEditor::scaleDown(int val){ qreal sf = getScaleFactor(); sf-= ((qreal) val)/100.0; if(sf<0.1){ sf = 0.1; } rescaleImage(sf); }
void translate(const double x, const double y) { opengl::translate(x * getScaleFactor(), y * getScaleFactor()); }
//static void LLUI::screenPointToGL(S32 screen_x, S32 screen_y, S32 *gl_x, S32 *gl_y) { *gl_x = llround((F32)screen_x * getScaleFactor().mV[VX]); *gl_y = llround((F32)screen_y * getScaleFactor().mV[VY]); }
//static void LLUI::glPointToScreen(S32 gl_x, S32 gl_y, S32 *screen_x, S32 *screen_y) { *screen_x = llround((F32)gl_x / getScaleFactor().mV[VX]); *screen_y = llround((F32)gl_y / getScaleFactor().mV[VY]); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ScaleVolume::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FloatVec3FilterParameter::New("Scaling Factor", "ScaleFactor", getScaleFactor(), FilterParameter::Parameter)); QStringList linkedProps("DataContainerName"); parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Image Geometry", "ApplyToVoxelVolume", getApplyToVoxelVolume(), linkedProps, FilterParameter::Parameter)); { DataContainerSelectionFilterParameter::RequirementType req; req.dcGeometryTypes = QVector<unsigned int>(1, DREAM3D::GeometryType::ImageGeometry); parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Image Geometry to Scale", "DataContainerName", getDataContainerName(), FilterParameter::RequiredArray, req)); } linkedProps.clear(); linkedProps << "SurfaceDataContainerName"; parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Surface Geometry", "ApplyToSurfaceMesh", getApplyToSurfaceMesh(), linkedProps, FilterParameter::Parameter)); { DataContainerSelectionFilterParameter::RequirementType req; QVector<unsigned int> dcGeometryTypes; dcGeometryTypes.push_back(DREAM3D::GeometryType::TriangleGeometry); dcGeometryTypes.push_back(DREAM3D::GeometryType::QuadGeometry); req.dcGeometryTypes = dcGeometryTypes; parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Surface Geometry to Scale", "SurfaceDataContainerName", getSurfaceDataContainerName(), FilterParameter::RequiredArray, req)); } setFilterParameters(parameters); }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void ScaleVolume::setupFilterParameters() { FilterParameterVector parameters; parameters.push_back(FloatVec3FilterParameter::New("Scaling Factor", "ScaleFactor", getScaleFactor(), FilterParameter::Parameter)); QStringList linkedProps("DataContainerName"); parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Image Geometry", "ApplyToVoxelVolume", getApplyToVoxelVolume(), linkedProps, FilterParameter::Parameter)); parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Image Geometry to Scale", "DataContainerName", getDataContainerName(), FilterParameter::RequiredArray)); linkedProps.clear(); linkedProps << "SurfaceDataContainerName"; parameters.push_back(LinkedBooleanFilterParameter::New("Apply to Surface Geometry", "ApplyToSurfaceMesh", getApplyToSurfaceMesh(), linkedProps, FilterParameter::Parameter)); parameters.push_back(DataContainerSelectionFilterParameter::New("Data Container Surface Geometry to Scale", "SurfaceDataContainerName", getSurfaceDataContainerName(), FilterParameter::RequiredArray)); setFilterParameters(parameters); }
cv::Mat motionEstimation_node::imageCallback(sensor_msgs::ImagePtr &left, sensor_msgs::ImagePtr &right) { /* try { cv::imshow("left", cv_bridge::toCvShare(left, "bgr8")->image); cv::imshow("right", cv_bridge::toCvShare(right, "bgr8")->image); cv::waitKey(30); }*/ if(image_sub_count == 0) { //right; features = getStrongFeaturePoints(image_L1, 100, 0.001, 20); refindFeaturePoints(left, right, features, points_L1_temp, points_R1_temp); if (10 > points_L1_temp.size()) { ROS_INFO("Could not find more than features in stereo 1:"); } else { camera.left = left; camera.right = right; cam.push_back(camera); } } image_sub_count++; while(image_sub_count > 0) { skipFrameNumber++; if(4 < skipFrameNumber) { ROS_INFO("NO MOVEMENT FOR LAST 4 FRAMES"); image_sub_count = 0; break; } refindFeaturePoints(camera.left, left, points_L1_temp, points_L1, points_L2); refindFeaturePoints(camera.right, right, points_R1_temp, points_R1, points_R2); deleteUnvisiblePoints(points_L1_temp, points_R1_temp, points_L1, points_R1, points_L2, points_R2, camera.left.cols, camera.left.rows); if(0 == points_L1.size()) { image_sub_count--; ROS_INFO("Could not find more than features in stereo 2:"); break; } if (1 == mode) { if (8 > points_L1.size()) { ROS_INFO("NO MOVEMENT: to less points found"); image_sub_count--; break; } getInliersFromHorizontalDirection(make_pair(points_L1, points_R1), inliersHorizontal_L1, inliersHorizontal_R1); getInliersFromHorizontalDirection(make_pair(points_L2, points_R2), inliersHorizontal_L2, inliersHorizontal_R2); deleteZeroLines(points_L1, points_R1, points_L2, points_R2, inliersHorizontal_L1, inliersHorizontal_R1, inliersHorizontal_L2, inliersHorizontal_R2); if (8 > inliersHorizontal_L1.size()) { ROS_INFO("NO MOVEMENT: couldn't find horizontal points... probably rectification fails or to less feature points found?!"); image_sub_count--; break; } foundF_L = getFundamentalMatrix(points_L1, points_L2, &inliersF_L1, &inliersF_L2, F_L); foundF_R = getFundamentalMatrix(points_R1, points_R2, &inliersF_R1, &inliersF_R2, F_R); deleteZeroLines(inliersF_L1, inliersF_L2, inliersF_R1, inliersF_R2); if (1 > inliersF_L1.size()) { ROS_INFO("NO MOVEMENT: couldn't find enough ransac inlier"); image_sub_count--; break; } drawCorresPoints(camera.left, inliersF_L1, inliersF_L2, "inlier F left " , CV_RGB(0,0,255)); drawCorresPoints(camera.right, inliersF_R1, inliersF_R2, "inlier F right " , CV_RGB(0,0,255)); bool poseEstimationFoundES_L = false; bool poseEstimationFoundES_R = false; if(foundF_L) { poseEstimationFoundES_L = motionEstimationEssentialMat(inliersF_L1, inliersF_L2, F_L, K_L, T_E_L, R_E_L); } if(foundF_R) { poseEstimationFoundES_R = motionEstimationEssentialMat(inliersF_R1, inliersF_R2, F_R, K_R, T_E_R, R_E_R); } if (!poseEstimationFoundES_L && !poseEstimationFoundES_R) { image_sub_count--; break; T_E_L = cv::Mat::zeros(3, 1, CV_32F); R_E_L = cv::Mat::eye(3, 3, CV_32F); T_E_R = cv::Mat::zeros(3, 1, CV_32F); R_E_R = cv::Mat::eye(3, 3, CV_32F); } else if (!poseEstimationFoundES_L) { T_E_L = cv::Mat::zeros(3, 1, CV_32F); R_E_L = cv::Mat::eye(3, 3, CV_32F); } else if (!poseEstimationFoundES_R) { T_E_R = cv::Mat::zeros(3, 1, CV_32F); R_E_R = cv::Mat::eye(3, 3, CV_32F); } cv::Mat PK_0 = K_L * P_0; cv::Mat PK_LR = K_R * P_LR; TriangulatePointsHZ(PK_0, PK_LR, points_L1, points_R1, 0, pointCloud_1); TriangulatePointsHZ(PK_0, PK_LR, points_L2, points_R2, 0, pointCloud_2); #if 1 composeProjectionMat(T_E_L, R_E_L, P_L); composeProjectionMat(T_E_R, R_E_R, P_R); cv::Mat PK_L = K_L * P_L; cv::Mat PK_R = K_R * P_R; getScaleFactor(PK_0, PK_LR, PK_L, PK_R, points_L1, points_R1, points_L2, points_R2, u_L1, u_R1, stereoCloud, nearestPoints); ROS_INFO( "skipFrameNumber : %d", skipFrameNumber); if(u_L1 < -1 || u_L1 > 1000*skipFrameNumber) { ROS_INFO("scale factors for left cam is too big: %d ", u_L1); //skipFrame = true; //continue; } else { T_E_L = T_E_L * u_L1; } if(u_R1 < -1 || u_R1 > 1000*skipFrameNumber ) { ROS_INFO( "scale factors for right cam is too big: %d ", u_R1); //skipFrame = true; //continue; } else { T_E_R = T_E_R * u_R1; } #if 0 // get RGB values for pointcloud representation std::vector<cv::Vec3b> RGBValues; for (unsigned int i = 0; i < points_L1.size(); ++i){ uchar grey = camera.left.at<uchar>(points_L1[i].x, points_L1[i].y); RGBValues.push_back(cv::Vec3b(grey,grey,grey)); } std::vector<cv::Vec3b> red; for (unsigned int i = 0; i < 5; ++i){ red.push_back(cv::Vec3b(0,0,255)); } AddPointcloudToVisualizer(stereoCloud, "cloud1" + std::to_string(frame1), RGBValues); AddPointcloudToVisualizer(nearestPoints, "cloud2" + std::to_string(frame1), red); #endif #else // 2. method: float u_L2, u_R2; getScaleFactor2(T_LR, R_LR, T_E_L, R_E_L, T_E_R, u_L2, u_R2); if(u_L2 < -1000 || u_R2 < -1000 || u_L2 > 1000 || u_R2 > 1000 ){ std::cout << "scale factors to small or to big: L: " << u_L2 << " R: " << u_R2 << std::endl; } else { T_E_L = T_E_L * u_L2; T_E_R = T_E_R * u_R2; } //compare both methods ROS_INFO("u links 2:%d ", u_L2); ROS_INFO("u rechts 2:%d", u_R2); #endif ROS_INFO("translation 1:%d ", T_E_L); cv::Mat newTrans3D_E_L; getNewTrans3D( T_E_L, R_E_L, newTrans3D_E_L); cv::Mat newPos_ES_L; getAbsPos(currentPos_ES_L, newTrans3D_E_L, R_E_L.t(), newPos_ES_L); cv::Mat rotation_ES_L, translation_ES_L; decomposeProjectionMat(newPos_ES_L, translation_ES_L, rotation_ES_L); cv::Mat newPos_ES_mean = newPos_ES_L + newPos_ES_R; newPos_ES_mean /= 2; cv::Mat rotation_ES_mean, translation_ES_mean; decomposeProjectionMat(newPos_ES_mean, translation_ES_mean, rotation_ES_mean); geometry_msgs::Pose pose; pose.position.x = rotation_ES_mean(0); pose.position.y = rotation_ES_mean(1); pose.position.z = rotation_ES_mean(2); posePublisher_.publish(pose); Eigen::Matrix3f m; m = translation_ES_mean; float roll; float pitch; float yaw; roll = atan2(m(3,2), m(3,3)); pitch = atan(-m(3,1)/(m(3,2)*sin(roll)+m(3,3)*cos(roll))); yaw = atan2(m(2,1),m(1,1)); currentPos_ES_mean = newPos_ES_mean; currentPos_ES_L = newPos_ES_L; currentPos_ES_R = newPos_ES_R; ROS_INFO("abs. position ", translation_ES_mean); } if(2 == mode) { if (8 > points_L1.size()) { ROS_INFO("NO MOVEMENT: to less points found"); image_sub_count--; break; } std::vector<cv::Point2f> inliersHorizontal_L1, inliersHorizontal_R1, inliersHorizontal_L2, inliersHorizontal_R2; getInliersFromHorizontalDirection(make_pair(points_L1, points_R1), inliersHorizontal_L1, inliersHorizontal_R1); getInliersFromHorizontalDirection(make_pair(points_L2, points_R2), inliersHorizontal_L2, inliersHorizontal_R2); //delete all points that are not correctly found in stereo setup deleteZeroLines(points_L1, points_R1, points_L2, points_R2, inliersHorizontal_L1, inliersHorizontal_R1, inliersHorizontal_L2, inliersHorizontal_R2); if (8 > points_L1.size()) { ROS_INFO("NO MOVEMENT: couldn't find horizontal points... probably rectification fails or to less feature points found?!"); image_sub_count--; break; } cv::Mat F_L; bool foundF_L; std::vector<cv::Point2f> inliersF_L1, inliersF_L2; foundF_L = getFundamentalMatrix(points_L1, points_L2, &inliersF_L1, &inliersF_L2, F_L); // compute fundemental matrix F_R1R2 and get inliers from Ransac cv::Mat F_R; bool foundF_R; std::vector<cv::Point2f> inliersF_R1, inliersF_R2; foundF_R = getFundamentalMatrix(points_R1, points_R2, &inliersF_R1, &inliersF_R2, F_R); // make sure that there are all inliers in all frames. deleteZeroLines(inliersF_L1, inliersF_L2, inliersF_R1, inliersF_R2); drawCorresPoints(image_R1, inliersF_R1, inliersF_R2, "inlier F right " , CV_RGB(0,0,255)); drawCorresPoints(image_L1, inliersF_L1, inliersF_L2, "inlier F left " , CV_RGB(0,0,255)); // calibrate projection mat cv::Mat PK_0 = K_L * P_0; cv::Mat PK_LR = K_R * P_LR; std::vector<cv::Point3f> pointCloud_1, pointCloud_2; TriangulatePointsHZ(PK_0, PK_LR, inliersF_L1, inliersF_R1, 0, pointCloud_1); TriangulatePointsHZ(PK_0, PK_LR, inliersF_L2, inliersF_R2, 0, pointCloud_2); #if 1 //LEFT: bool poseEstimationFoundTemp_L = false; cv::Mat T_PnP_L, R_PnP_L; if(foundF_L){ // GUESS TRANSLATION + ROTATION UP TO SCALE!!! poseEstimationFoundTemp_L = motionEstimationEssentialMat(inliersF_L1, inliersF_L2, F_L, K_L, T_PnP_L, R_PnP_L); } if (!poseEstimationFoundTemp_L){ image_sub_count--; break; } #if 0 // scale factor: float u_L1; cv::Mat P_L; composeProjectionMat(T_PnP_L, R_PnP_L, P_L); // calibrate projection mat cv::Mat PK_L = K_L * P_L; getScaleFactorLeft(PK_0, PK_LR, PK_L, inliersF_L1, inliersF_R1, inliersF_L2, u_L1); if(u_L1 < -1 || u_L1 > 1000 ){ ROS_INFO("scale factors to small or to big: L: ", u_L1); image_sub_count--; break; } T_PnP_L = T_PnP_L * u_L1; #endif bool poseEstimationFoundPnP_L = motionEstimationPnP(inliersF_L2, pointCloud_1, K_L, T_PnP_L, R_PnP_L); if (!poseEstimationFoundPnP_L) { image_sub_count--; break; } if(cv::norm(T_PnP_L) > 1500.0 * skipFrameNumber) { // this is bad... ROS_INFO("NO MOVEMENT: estimated camera movement is too big, skip this camera.. T = ", cv::norm(T_PnP_L)); image_sub_count--; break; } cv::Mat newTrans3D_PnP_L; getNewTrans3D( T_PnP_L, R_PnP_L, newTrans3D_PnP_L); cv::Mat newPos_PnP_L; getAbsPos(currentPos_PnP_L, newTrans3D_PnP_L, R_PnP_L, newPos_PnP_L); cv::Mat rotation_PnP_L, translation_PnP_L; decomposeProjectionMat(newPos_PnP_L, translation_PnP_L, rotation_PnP_L); pose.position.x = rotation_PnP_L(0); pose.position.y = rotation_PnP_L(1); pose.position.z = rotation_PnP_L(2); posePublisher_.publish(pose); Eigen::Matrix3f m; m = translation_ES_mean; float roll; float pitch; float yaw; roll = atan2(m(3,2), m(3,3)); pitch = atan(-m(3,1)/(m(3,2)*sin(roll)+m(3,3)*cos(roll))); yaw = atan2(m(2,1),m(1,1)); currentPos_PnP_L = newPos_PnP_L ; #else //RIGHT: bool poseEstimationFoundTemp_R = false; cv::Mat T_PnP_R, R_PnP_R; if(foundF_R){ // GUESS TRANSLATION + ROTATION UP TO SCALE!!! poseEstimationFoundTemp_R = motionEstimationEssentialMat(inliersF_R1, inliersF_R2, F_R, K_R, KInv_R, T_PnP_R, R_PnP_R); } if (!poseEstimationFoundTemp_R){ skipFrame = true; continue; } // use initial guess values for pose estimation bool poseEstimationFoundPnP_R = motionEstimationPnP(inliersF_R2, pointCloud_1, K_R, T_PnP_R, R_PnP_R); if (!poseEstimationFoundPnP_R){ skipFrame = true; continue; } cv::Mat newTrans3D_PnP_R; getNewTrans3D( T_PnP_R, R_PnP_R, newTrans3D_PnP_R); cv::Mat newPos_PnP_R; getAbsPos(currentPos_PnP_R, newTrans3D_PnP_R, R_PnP_R, newPos_PnP_R); cv::Mat rotation_PnP_R, translation_PnP_R; decomposeProjectionMat(newPos_PnP_R, translation_PnP_R, rotation_PnP_R); pose.position.x = rotation_PnP_R(0); pose.position.y = rotation_PnP_R(1); pose.position.z = rotation_PnP_R(2); posePublisher_.publish(pose); Eigen::Matrix3f m; m = translation_ES_mean; float roll; float pitch; float yaw; roll = atan2(m(3,2), m(3,3)); pitch = atan(-m(3,1)/(m(3,2)*sin(roll)+m(3,3)*cos(roll))); yaw = atan2(m(2,1),m(1,1)); currentPos_PnP_R = newPos_PnP_R ; #endif } if (3 == mode) { std::vector<cv::Point2f> inliersHorizontal_L1, inliersHorizontal_R1, inliersHorizontal_L2, inliersHorizontal_R2; getInliersFromHorizontalDirection(make_pair(points_L1, points_R1), inliersHorizontal_L1, inliersHorizontal_R1); getInliersFromHorizontalDirection(make_pair(points_L2, points_R2), inliersHorizontal_L2, inliersHorizontal_R2); //delete all points that are not correctly found in stereo setup deleteZeroLines(points_L1, points_R1, points_L2, points_R2, inliersHorizontal_L1, inliersHorizontal_R1, inliersHorizontal_L2, inliersHorizontal_R2); if (8 > points_L1.size()) { ROS_INFO("NO MOVEMENT: couldn't find horizontal points... probably rectification fails or to less feature points found?!"); image_sub_count--; break; } drawCorresPoints(image_L1, points_L1, points_R1, "inlier F1 links rechts", cv::Scalar(255,255,0)); drawCorresPoints(image_L2, points_L2, points_R2, "inlier F2 links rechts", cv::Scalar(255,255,0)); // calibrate projection mat cv::Mat PK_0 = K_L * P_0; cv::Mat PK_LR = K_R * P_LR; // TRIANGULATE POINTS std::vector<cv::Point3f> pointCloud_1, pointCloud_2; TriangulatePointsHZ(PK_0, PK_LR, points_L1, points_R1, 0, pointCloud_1); TriangulatePointsHZ(PK_0, PK_LR, points_L2, points_R2, 0, pointCloud_2); float reproj_error_1L = calculateReprojectionErrorHZ(PK_0, points_L1, pointCloud_1); float reproj_error_1R = calculateReprojectionErrorHZ(PK_LR, points_R1, pointCloud_1); if (!positionCheck(P_0, pointCloud_2) && !positionCheck(P_LR, pointCloud_2) && reproj_error_2L < 10.0 && reproj_error_2R < 10.0 ) { ROS_INFO("second pointcloud seem's to be not perfect.."); image_sub_count--; break; } #if 0 //load disparity map cv::Mat dispMap1; cv::FileStorage fs_dist1(dataPath + "disparity/disparity_"+to_string(frame)+".yml", cv::FileStorage::READ); fs_dist1["disparity"] >> dispMap1; fs_dist1.release(); cv::Mat dispMap2; cv::FileStorage fs_dist2(dataPath + "disparity/disparity_"+to_string(frame+1)+".yml", cv::FileStorage::READ); fs_dist2["disparity"] >> dispMap2; fs_dist2.release(); dispMap1.convertTo(dispMap1, CV_32F); dispMap2.convertTo(dispMap2, CV_32F); std::vector <cv::Mat_<float>> cloud1; std::vector <cv::Mat_<float>> cloud2; for(unsigned int i = 0; i < inlier_median_L1.size(); ++i){ cv::Mat_<float> point3D1(1,4); cv::Mat_<float> point3D2(1,4); calcCoordinate(point3D1, Q, dispMap1, inlier_median_L1[i].x, inlier_median_L1[i].y); calcCoordinate(point3D2, Q, dispMap2, inlier_median_L2[i].x, inlier_median_L2[i].y); cloud1.push_back(point3D1); cloud2.push_back(point3D2); } std::vector<cv::Point3f> pcloud1, pcloud2; std::vector<cv::Vec3b> rgb1, rgb2; for (unsigned int i = 0; i < cloud1.size(); ++i) { if (!cloud1[i].empty() && !cloud2[i].empty()){ pcloud1.push_back(cv::Point3f(cloud1[i](0), cloud1[i](1), cloud1[i](2) )); pcloud2.push_back(cv::Point3f(cloud2[i](0), cloud2[i](1), cloud2[i](2) )); rgb1.push_back(cv::Vec3b(255,0,0)); rgb2.push_back(cv::Vec3b(0,255,0)); } } AddPointcloudToVisualizer(pcloud1, "pcloud1", rgb1); AddPointcloudToVisualizer(pcloud2, "pcloud2", rgb2); cv::Mat T_Stereo, R_Stereo; bool poseEstimationFoundStereo = motionEstimationStereoCloudMatching(pcloud1, pcloud2, T_Stereo, R_Stereo); #else cv::Mat T_Stereo, R_Stereo; bool poseEstimationFoundStereo = motionEstimationStereoCloudMatching(pointCloud_1, pointCloud_2, T_Stereo, R_Stereo); #endif if (!poseEstimationFoundStereo) { image_sub_count--; break; } ROS_INFO("ROTATION \n"); ROS_INFO(R_Stereo); ROS_INFO("\n TRANSLATION \n"); ROS_INFO(T_Stereo); float x_angle, y_angle, z_angle; decomposeRotMat(R_Stereo, x_angle, y_angle, z_angle); ROS_INFO("x angle:", x_angle); ROS_INFO("y angle:", y_angle); ROS_INFO("z angle:", z_angle); cv::Mat newTrans3D_Stereo; getNewTrans3D( T_Stereo, R_Stereo, newTrans3D_Stereo); cv::Mat newPos_Stereo; getAbsPos(currentPos_Stereo, newTrans3D_Stereo, R_Stereo, newPos_Stereo); cv::Mat rotation, translation; decomposeProjectionMat(newPos_Stereo, translation, rotation); pose.position.x = rotation(0); pose.position.y = rotation(1); pose.position.z = rotation(2); posePublisher_.publish(pose); Eigen::Matrix3f m; m = translation; float roll; float pitch; float yaw; roll = atan2(m(3,2), m(3,3)); pitch = atan(-m(3,1)/(m(3,2)*sin(roll)+m(3,3)*cos(roll))); yaw = atan2(m(2,1),m(1,1)); currentPos_Stereo = newPos_Stereo; } if (4 == mode) { // ######################## TRIANGULATION TEST ################################ // get inlier from stereo constraints std::vector<cv::Point2f> inliersHorizontal_L1, inliersHorizontal_R1, inliersHorizontal_L2, inliersHorizontal_R2; getInliersFromHorizontalDirection(make_pair(points_L1, points_R1), inliersHorizontal_L1, inliersHorizontal_R1); getInliersFromHorizontalDirection(make_pair(points_L2, points_R2), inliersHorizontal_L2, inliersHorizontal_R2); //delete all points that are not correctly found in stereo setup deleteZeroLines(points_L1, points_R1, points_L2, points_R2, inliersHorizontal_L1, inliersHorizontal_R1, inliersHorizontal_L2, inliersHorizontal_R2); drawCorresPoints(image_L1, points_L1, points_R1, "inlier 1 " , CV_RGB(0,0,255)); drawCorresPoints(image_R1, points_L2, points_R2, "inlier 2 " , CV_RGB(0,0,255)); if(0 == points_L1.size()){ image_sub_count--; break; } // calibrate projection mat cv::Mat PK_0 = K_L * P_0; cv::Mat PK_LR = K_R * P_LR; std::vector<cv::Point3f> pointCloud_1, pointCloud_2; TriangulatePointsHZ(PK_0, PK_LR, points_L1, points_R1, 0, pointCloud_1); TriangulatePointsHZ(PK_0, PK_LR, points_L2, points_R2, 0, pointCloud_2); if(0 == pointCloud_1.size()) { ROS_INFO("horizontal inlier: can't find any corresponding points in all 4 frames' "); image_sub_count--; break; } // get RGB values for pointcloud representation std::vector<cv::Vec3b> RGBValues; for (unsigned int i = 0; i < points_L1.size(); ++i) { uchar grey = image_L1.at<uchar>(points_L1[i].x, points_L1[i].y); RGBValues.push_back(cv::Vec3b(grey,grey,grey)); } AddPointcloudToVisualizer(pointCloud_1, "cloud1" + std::to_string(frame1), RGBValues); #if 1 // int index = 0; // for (auto i : pointCloud_1) { // float length = sqrt( i.x*i.x + i.y*i.y + i.z*i.z); // cout<< "HZ: "<< index << ": " << i << " length: " << length << endl; // ++index; // } std::vector<cv::Point3f> pcloud_CV; TriangulateOpenCV(PK_0, PK_LR, points_L1, points_R1, pcloud_CV); // index = 0; // for (auto i : pcloud_CV) { // float length = sqrt( i.x*i.x + i.y*i.y + i.z*i.z); // cout<< "CV: "<< index << ": " << i << " length: " << length << endl; // ++index; // } std::vector<cv::Vec3b> RGBValues2; for (unsigned int i = 0; i < points_L1.size(); ++i){ //uchar grey2 = image_L2.at<uchar>(points_L2[i].x, points_L2[i].y); //RGBValues2.push_back(cv::Vec3b(grey2,grey2,grey2)); RGBValues2.push_back(cv::Vec3b(255,0,0)); } AddPointcloudToVisualizer(pcloud_CV, "cloud2" + std::to_string(frame1), RGBValues2); #endif } }
//--------------------------------------------------------------------------- void GameCamera::render(void) { //------------------------------------------------------ // At present, these actually draw. Later they will // add elements to the draw list and sort and draw. // The later time has arrived. We begin sorting immediately. // NO LONGER NEED TO SORT! // ZBuffer time has arrived. Share and Enjoy! // Everything SIMPLY draws at the execution point into the zBuffer // at the correct depth. Miracles occur at that point! // Big code change but it removes a WHOLE bunch of code and memory! //-------------------------------------------------------- // Get new viewport values to scale stuff. No longer uses // VFX stuff for this. ALL GOS NOW! gos_GetViewport(&viewMulX, &viewMulY, &viewAddX, &viewAddY); MidLevelRenderer::MLRState default_state; default_state.SetBackFaceOn(); default_state.SetDitherOn(); default_state.SetTextureCorrectionOn(); default_state.SetZBufferCompareOn(); default_state.SetZBufferWriteOn(); default_state.SetFilterMode(MidLevelRenderer::MLRState::BiLinearFilterMode); float z = 1.0f; Stuff::RGBAColor fColor; fColor.red = ((fogColor >> 16) & 0xff); fColor.green = ((fogColor >> 8) & 0xff); fColor.blue = ((fogColor)&0xff); //-------------------------------------------------------- // Get new viewport values to scale stuff. No longer uses // VFX stuff for this. ALL GOS NOW! screenResolution.x = viewMulX; screenResolution.y = viewMulY; calculateProjectionConstants(); TG_Shape::SetViewport(viewMulX, viewMulY, viewAddX, viewAddY); userInput->setViewport(viewMulX, viewMulY, viewAddX, viewAddY); gos_TextSetRegion(viewAddX, viewAddY, viewMulX, viewMulY); //-------------------------------------------------------- // Get new viewport values to scale stuff. No longer uses // VFX stuff for this. ALL GOS NOW! screenResolution.x = viewMulX; screenResolution.y = viewMulY; calculateProjectionConstants(); globalScaleFactor = getScaleFactor(); globalScaleFactor *= viewMulX / 640.0; // Scale Mechs to ScreenRES //----------------------------------------------- // Set Ambient for this pass of rendering uint32_t lightRGB = (ambientRed << 16) + (ambientGreen << 8) + ambientBlue; eye->setLightColor(1, lightRGB); eye->setLightIntensity(1, 1.0); MidLevelRenderer::PerspectiveMode = usePerspective; theClipper->StartDraw(cameraOrigin, cameraToClip, fColor, &fColor, default_state, &z); MidLevelRenderer::GOSVertex::farClipReciprocal = (1.0f - cameraToClip(2, 2)) / cameraToClip(3, 2); if (active && turn > 1) { //---------------------------------------------------------- // Turn stuff on line by line until perspective is working. if (Environment.Renderer != 3) theSky->render(1); land->render(); // render the Terrain if (Environment.Renderer != 3) craterManager->render(); // render the craters and footprints ObjectManager->render(true, true, true); // render all other objects land->renderWater(); // Draw Water Last! if (useShadows && Environment.Renderer != 3) ObjectManager->renderShadows(true, true, true); if (mission && mission->missionInterface) mission->missionInterface->drawVTOL(); if (!drawOldWay && !inMovieMode) { if (compass && (turn > 3) && drawCompass) compass->render(-1); // Force this to zBuffer in front of everything } if (!drawOldWay) mcTextureManager->renderLists(); // This sends triangles down to the // card. All "rendering" to this // point has been setting up tri // lists if (drawOldWay) { // Last thing drawn were shadows which are not Gouraud Shaded!!! // MLR to be "efficient" doesn't set this state by default at // startup! gos_SetRenderState(gos_State_ShadeMode, gos_ShadeGouraud); } theClipper->RenderNow(); // Draw the FX if (useNonWeaponEffects) weather->render(); // Draw the weather } if (drawOldWay && !inMovieMode) { gos_SetRenderState(gos_State_ZCompare, 0); gos_SetRenderState(gos_State_ZWrite, 0); gos_SetRenderState(gos_State_Perspective, 1); if (compass && (turn > 3) && drawCompass) compass->render(); } //--------------------------------------------------------- // Check if we are inMovieMode and should be letterboxed. // draw letterboxes here. if (inMovieMode && (letterBoxPos != 0.0f)) { // Figure out the two faces we need to draw based on letterBox Pos and // Alpha float barTopX = screenResolution.y * letterBoxPos; float barBotX = screenResolution.y - barTopX; gos_SetRenderState(gos_State_AlphaMode, gos_Alpha_AlphaInvAlpha); gos_SetRenderState(gos_State_ShadeMode, gos_ShadeGouraud); gos_SetRenderState(gos_State_MonoEnable, 0); gos_SetRenderState(gos_State_Perspective, 0); gos_SetRenderState(gos_State_Clipping, 1); gos_SetRenderState(gos_State_AlphaTest, 1); gos_SetRenderState(gos_State_Specular, 0); gos_SetRenderState(gos_State_Dither, 1); gos_SetRenderState(gos_State_TextureMapBlend, gos_BlendModulate); gos_SetRenderState(gos_State_Filter, gos_FilterNone); gos_SetRenderState(gos_State_TextureAddress, gos_TextureClamp); gos_SetRenderState(gos_State_ZCompare, 0); gos_SetRenderState(gos_State_ZWrite, 0); gos_SetRenderState(gos_State_Texture, 0); //------------------------------------ gos_VERTEX gVertex[4]; gVertex[0].x = 0.0f; gVertex[0].y = 0.0f; gVertex[0].z = 0.00001f; gVertex[0].rhw = 0.00001f; gVertex[0].u = 0.0f; gVertex[0].v = 0.0f; gVertex[0].argb = (letterBoxAlpha << 24); gVertex[0].frgb = 0xff000000; gVertex[1].x = 0.0f; gVertex[1].y = barTopX; gVertex[1].z = 0.00001f; gVertex[1].rhw = 0.00001f; gVertex[1].u = 0.0f; gVertex[1].v = 0.0f; gVertex[1].argb = (letterBoxAlpha << 24); gVertex[1].frgb = 0xff000000; gVertex[2].x = screenResolution.x; gVertex[2].y = barTopX; gVertex[2].z = 0.00001f; gVertex[2].rhw = 0.00001f; gVertex[2].u = 0.0f; gVertex[2].v = 0.0f; gVertex[2].argb = (letterBoxAlpha << 24); gVertex[2].frgb = 0xff000000; gVertex[3].x = screenResolution.x; gVertex[3].y = 0.0f; gVertex[3].z = 0.00001f; gVertex[3].rhw = 0.00001f; gVertex[3].u = 0.0f; gVertex[3].v = 0.0f; gVertex[3].argb = (letterBoxAlpha << 24); gVertex[3].frgb = 0xff000000; gos_DrawQuads(gVertex, 4); gVertex[0].x = 0.0f; gVertex[0].y = barBotX; gVertex[0].z = 0.00001f; gVertex[0].rhw = 0.00001f; gVertex[0].u = 0.0f; gVertex[0].v = 0.0f; gVertex[0].argb = (letterBoxAlpha << 24); gVertex[0].frgb = 0xff000000; gVertex[1].x = screenResolution.x; gVertex[1].y = barBotX; gVertex[1].z = 0.00001f; gVertex[1].rhw = 0.00001f; gVertex[1].u = 0.0f; gVertex[1].v = 0.0f; gVertex[1].argb = (letterBoxAlpha << 24); gVertex[1].frgb = 0xff000000; gVertex[2].x = screenResolution.x; gVertex[2].y = screenResolution.y; gVertex[2].z = 0.00001f; gVertex[2].rhw = 0.00001f; gVertex[2].u = 0.0f; gVertex[2].v = 0.0f; gVertex[2].argb = (letterBoxAlpha << 24); gVertex[2].frgb = 0xff000000; gVertex[3].x = 0.0f; gVertex[3].y = screenResolution.y; gVertex[3].z = 0.00001f; gVertex[3].rhw = 0.00001f; gVertex[3].u = 0.0f; gVertex[3].v = 0.0f; gVertex[3].argb = (letterBoxAlpha << 24); gVertex[3].frgb = 0xff000000; gos_DrawQuads(gVertex, 4); } if (inMovieMode && (fadeAlpha != 0x0)) { // We are fading to something other then clear screen. gos_SetRenderState(gos_State_AlphaMode, gos_Alpha_AlphaInvAlpha); gos_SetRenderState(gos_State_ShadeMode, gos_ShadeGouraud); gos_SetRenderState(gos_State_MonoEnable, 0); gos_SetRenderState(gos_State_Perspective, 0); gos_SetRenderState(gos_State_Clipping, 1); gos_SetRenderState(gos_State_AlphaTest, 1); gos_SetRenderState(gos_State_Specular, 0); gos_SetRenderState(gos_State_Dither, 1); gos_SetRenderState(gos_State_TextureMapBlend, gos_BlendModulate); gos_SetRenderState(gos_State_Filter, gos_FilterNone); gos_SetRenderState(gos_State_TextureAddress, gos_TextureClamp); gos_SetRenderState(gos_State_ZCompare, 0); gos_SetRenderState(gos_State_ZWrite, 0); gos_SetRenderState(gos_State_Texture, 0); //------------------------------------ gos_VERTEX gVertex[4]; gVertex[0].x = 0.0f; gVertex[0].y = 0.0f; gVertex[0].z = 0.00001f; gVertex[0].rhw = 0.00001f; gVertex[0].u = 0.0f; gVertex[0].v = 0.0f; gVertex[0].argb = (fadeAlpha << 24) + (fadeColor & 0x00ffffff); gVertex[0].frgb = 0xff000000; gVertex[1].x = 0.0f; gVertex[1].y = screenResolution.y; gVertex[1].z = 0.00001f; gVertex[1].rhw = 0.00001f; gVertex[1].u = 0.0f; gVertex[1].v = 0.0f; gVertex[1].argb = (fadeAlpha << 24) + (fadeColor & 0x00ffffff); gVertex[1].frgb = 0xff000000; gVertex[2].x = screenResolution.x; gVertex[2].y = screenResolution.y; gVertex[2].z = 0.00001f; gVertex[2].rhw = 0.00001f; gVertex[2].u = 0.0f; gVertex[2].v = 0.0f; gVertex[2].argb = (fadeAlpha << 24) + (fadeColor & 0x00ffffff); gVertex[2].frgb = 0xff000000; gVertex[3].x = screenResolution.x; gVertex[3].y = 0.0f; gVertex[3].z = 0.00001f; gVertex[3].rhw = 0.00001f; gVertex[3].u = 0.0f; gVertex[3].v = 0.0f; gVertex[3].argb = (fadeAlpha << 24) + (fadeColor & 0x00ffffff); gVertex[3].frgb = 0xff000000; gos_DrawQuads(gVertex, 4); } //----------------------------------------------------- }
void PieMenu::draw() { // save the current OpenGL drawing matrix so we can freely modify it gGL.pushMatrix(); // save the widget's rectangle for later use LLRect r = getRect(); // initialize pie scale factor for popup effect F32 factor = getScaleFactor(); #if PIE_DRAW_BOUNDING_BOX // draw a bounding box around the menu for debugging purposes gl_rect_2d(0, r.getHeight(), r.getWidth(), 0, LLColor4::white, FALSE); #endif // set up pie menu colors LLColor4 lineColor = LLUIColorTable::instance().getColor("PieMenuLineColor"); LLColor4 selectedColor = LLUIColorTable::instance().getColor("PieMenuSelectedColor"); LLColor4 textColor = LLUIColorTable::instance().getColor("PieMenuTextColor"); LLColor4 bgColor = LLUIColorTable::instance().getColor("PieMenuBgColor"); LLColor4 borderColor = bgColor % 0.3f; // if the user wants their own colors, apply them here static LLCachedControl<bool> sOverridePieColors(gSavedSettings, "OverridePieColors", false); if (sOverridePieColors) { static LLCachedControl<F32> sPieMenuOpacity(gSavedSettings, "PieMenuOpacity"); static LLCachedControl<F32> sPieMenuFade(gSavedSettings, "PieMenuFade"); bgColor = LLUIColorTable::instance().getColor("PieMenuBgColorOverride") % sPieMenuOpacity; borderColor = bgColor % (1.f - sPieMenuFade); selectedColor = LLUIColorTable::instance().getColor("PieMenuSelectedColorOverride"); } // on first click, make the menu fade out to indicate "borderless" operation if (mFirstClick) { borderColor %= 0.f; } // move origin point to the center of our rectangle gGL.translatef(r.getWidth() / 2, r.getHeight() / 2, 0); // draw the general pie background gl_washer_2d(PIE_OUTER_SIZE * factor, PIE_INNER_SIZE, 32, bgColor, borderColor); // set up an item list iterator to point at the beginning of the item list slice_list_t::iterator cur_item_iter; cur_item_iter = mSlices->begin(); // clear current slice pointer mSlice = NULL; // current slice number is 0 S32 num = 0; bool wasAutohide = false; do { // standard item text color LLColor4 itemColor = textColor; // clear the label and set up the starting angle to draw in std::string label(""); F32 segmentStart = F_PI / 4.f * (F32)num - F_PI / 8.f; // iterate through the list of slices if (cur_item_iter != mSlices->end()) { // get current slice item LLView* item = (*cur_item_iter); // check if this is a submenu or a normal click slice PieSlice* currentSlice = dynamic_cast<PieSlice*>(item); PieMenu* currentSubmenu = dynamic_cast<PieMenu*>(item); // advance internally to the next slice item cur_item_iter++; // in case it is regular click slice if (currentSlice) { // get the slice label and tell the slice to check if it's supposed to be visible label = currentSlice->getLabel(); currentSlice->updateVisible(); // disable it if it's not visible, pie slices never really disappear BOOL slice_visible = currentSlice->getVisible(); currentSlice->setEnabled(slice_visible); if (!slice_visible) { // LL_DEBUGS() << label << " is not visible" << LL_ENDL; label = ""; } // if the current slice is the start of an autohide chain, clear out previous chains if (currentSlice->getStartAutohide()) { wasAutohide = false; } // check if the current slice is part of an autohide chain if (currentSlice->getAutohide()) { // if the previous item already won the autohide, skip this item if (wasAutohide) { continue; } // look at the next item in the pie LLView* lookAhead = (*cur_item_iter); // check if this is a normal click slice PieSlice* lookSlice = dynamic_cast<PieSlice*>(lookAhead); if (lookSlice) { // if the next item is part of the current autohide chain as well ... if (lookSlice->getAutohide() && !lookSlice->getStartAutohide()) { // ... it's visible and it's enabled, skip the current one. // the first visible and enabled item in autohide chains wins // this is useful for Sit/Stand toggles lookSlice->updateEnabled(); lookSlice->updateVisible(); if (lookSlice->getVisible() && lookSlice->getEnabled()) { continue; } // this item won the autohide contest wasAutohide = true; } } } else { // reset autohide chain wasAutohide = false; } // check if the slice is currently enabled currentSlice->updateEnabled(); if (!currentSlice->getEnabled()) { LL_DEBUGS() << label << " is disabled" << LL_ENDL; // fade the item color alpha to mark the item as disabled itemColor %= 0.3f; } } // if it's a submenu just get the label else if (currentSubmenu) { label = currentSubmenu->getLabel(); } // if it's a slice or submenu, the mouse pointer is over the same segment as our counter and the item is enabled if ((currentSlice || currentSubmenu) && (mCurrentSegment == num) && item->getEnabled()) { // memorize the currently highlighted slice for later mSlice = item; // if we highlighted a different slice than before, we must play a sound if (mOldSlice != mSlice) { // get the appropriate UI sound and play it char soundNum = '0' + num; std::string soundName = "UISndPieMenuSliceHighlight"; soundName += soundNum; make_ui_sound(soundName.c_str()); // remember which slice we highlighted last, so we only play the sound once mOldSlice = mSlice; } // draw the currently highlighted pie slice gl_washer_segment_2d(PIE_OUTER_SIZE * factor, PIE_INNER_SIZE, segmentStart + 0.02f, segmentStart + F_PI / 4.f - 0.02f, 4, selectedColor, borderColor); } } // draw the divider line for this slice gl_washer_segment_2d(PIE_OUTER_SIZE * factor, PIE_INNER_SIZE, segmentStart - 0.02f, segmentStart + 0.02f, 4, lineColor, borderColor); // draw the slice labels around the center mFont->renderUTF8(label, 0, PIE_X[num], PIE_Y[num], itemColor, LLFontGL::HCENTER, LLFontGL::VCENTER, LLFontGL::NORMAL, LLFontGL::DROP_SHADOW_SOFT); // next slice num++; } while (num < 8); // do this until the menu is full // draw inner and outer circle, outer only if it was not the first click if (!mFirstClick) { gl_washer_2d(PIE_OUTER_SIZE * factor, PIE_OUTER_SIZE * factor - 2.f, 32, lineColor, borderColor); } gl_washer_2d(PIE_INNER_SIZE + 1, PIE_INNER_SIZE - 1, 16, borderColor, lineColor); // restore OpenGL drawing matrix gGL.popMatrix(); // give control back to the UI library LLView::draw(); }
/** * Handle pointer moves. * @param point The pointer position on the screen. */ void ScreenImageSwiper::handlePointerMoved(MAPoint2d point) { float scaleFactor = getScaleFactor(); // Update the end swipe position. mPointerXEnd = (int)((float) point.x * scaleFactor); }
// === PUBLIC SLOTS === void ImageEditor::scaleUp(int val){ qreal sf = getScaleFactor(); sf+= ((qreal) val)/100.0; if(sf>2){ sf = 2.0; } rescaleImage(sf); }