// Find an object in a "clever" way, v in J2000 frame StelObjectP StelObjectMgr::cleverFind(const StelCore* core, const Vec3d& v) const { StelObjectP sobj; QList<StelObjectP> candidates; const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000); // Field of view for a searchRadiusPixel pixel diameter circle on screen float fov_around = core->getMovementMgr()->getCurrentFov()/qMin(prj->getViewportWidth(), prj->getViewportHeight()) * searchRadiusPixel; // Collect the objects inside the range for (const auto* m : objectsModule) candidates += m->searchAround(v, fov_around, core); // GZ 2014-08-17: This should be exactly the sky's limit magnitude (or even more, but not less!), else visible stars cannot be clicked. float limitMag = core->getSkyDrawer()->getLimitMagnitude(); // -2.f; QList<StelObjectP> tmp; for (const auto& obj : candidates) { if (obj->getSelectPriority(core)<=limitMag) tmp.append(obj); } candidates = tmp; // Now select the object minimizing the function y = distance(in pixel) + magnitude Vec3d winpos; prj->project(v, winpos); float xpos = winpos[0]; float ypos = winpos[1]; float best_object_value; best_object_value = 100000.f; for (const auto& obj : candidates) { prj->project(obj->getJ2000EquatorialPos(core), winpos); float distance = std::sqrt((xpos-winpos[0])*(xpos-winpos[0]) + (ypos-winpos[1])*(ypos-winpos[1]))*distanceWeight; float priority = obj->getSelectPriority(core); // qDebug() << (*iter).getShortInfoString(core) << ": " << priority << " " << distance; if (distance + priority < best_object_value) { best_object_value = distance + priority; sobj = obj; } } return sobj; }
void StarMgr::drawPointer(StelRenderer* renderer, StelProjectorP projector, const StelCore* core) { const QList<StelObjectP> newSelected = objectMgr->getSelectedObject("Star"); if (!newSelected.empty()) { const StelObjectP obj = newSelected[0]; Vec3d pos=obj->getJ2000EquatorialPos(core); Vec3d win; // Compute 2D pos and return if outside screen if (!projector->project(pos, win)) { return; } if(NULL == texPointer) { texPointer = renderer->createTexture("textures/pointeur2.png"); // Load pointer texture } Vec3f c(obj->getInfoColor()); if (StelApp::getInstance().getVisionModeNight()) c = StelUtils::getNightColor(c); renderer->setGlobalColor(c[0], c[1], c[2]); texPointer->bind(); renderer->setBlendMode(BlendMode_Alpha); const float angle = StelApp::getInstance().getTotalRunTime() * 40.0f; renderer->drawTexturedRect(win[0] - 13.0f, win[1] - 13.0f, 26.0f, 26.0f, angle); } }
void Supernovae::drawPointer(StelCore* core, StelRenderer* renderer, StelProjectorP projector) { const QList<StelObjectP> newSelected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("Supernova"); if (!newSelected.empty()) { const StelObjectP obj = newSelected[0]; Vec3d pos=obj->getJ2000EquatorialPos(core); Vec3d screenpos; // Compute 2D pos and return if outside screen if (!projector->project(pos, screenpos)) { return; } const Vec3f& c(obj->getInfoColor()); renderer->setGlobalColor(c[0],c[1],c[2]); if(NULL == texPointer) { texPointer = renderer->createTexture("textures/pointeur2.png"); } texPointer->bind(); renderer->setBlendMode(BlendMode_Alpha); renderer->drawTexturedRect(screenpos[0] - 13.0f, screenpos[1] - 13.0f, 26.0f, 26.0f, StelApp::getInstance().getTotalRunTime() * 40.0f); } }
//! Draw any parts on the screen which are for our module void AngleMeasure::draw(StelCore* core) { if (lineVisible.getInterstate() < 0.000001f && messageFader.getInterstate() < 0.000001f) return; const StelProjectorP prj = core->getProjection(StelCore::FrameEquinoxEqu); StelPainter painter(prj); painter.setFont(font); if (lineVisible.getInterstate() > 0.000001f) { glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); glEnable(GL_TEXTURE_2D); Vec3d xy; QString displayedText; if (prj->project(perp1EndPoint,xy)) { painter.setColor(textColor[0], textColor[1], textColor[2], lineVisible.getInterstate()); if (flagShowPA) displayedText = QString("%1 (%2%3)").arg(calculateAngle(), messagePA, calculatePositionAngle(startPoint, endPoint)); else displayedText = calculateAngle(); painter.drawText(xy[0], xy[1], displayedText, 0, 15, 15); } glDisable(GL_TEXTURE_2D); // OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH // glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); // main line is a great circle painter.setColor(lineColor[0], lineColor[1], lineColor[2], lineVisible.getInterstate()); painter.drawGreatCircleArc(startPoint, endPoint, NULL); // End lines painter.drawGreatCircleArc(perp1StartPoint, perp1EndPoint, NULL); painter.drawGreatCircleArc(perp2StartPoint, perp2EndPoint, NULL); } if (messageFader.getInterstate() > 0.000001f) { painter.setColor(textColor[0], textColor[1], textColor[2], messageFader.getInterstate()); int x = 83; int y = 120; int ls = painter.getFontMetrics().lineSpacing(); painter.drawText(x, y, messageEnabled); y -= ls; painter.drawText(x, y, messageLeftButton); y -= ls; painter.drawText(x, y, messageRightButton); } }
void Quasar::draw(StelCore* core, StelRenderer* renderer, StelProjectorP projector, StelTextureNew* markerTexture) { StelSkyDrawer* sd = core->getSkyDrawer(); const Vec3f color = sd->indexToColor(BvToColorIndex(bV))*0.75f; Vec3f dcolor = Vec3f(1.2f,0.5f,0.4f); if (StelApp::getInstance().getVisionModeNight()) dcolor = StelUtils::getNightColor(dcolor); float rcMag[2], size, shift; double mag; StelUtils::spheToRect(qRA, qDE, XYZ); mag = getVMagnitude(core, true); if (GETSTELMODULE(Quasars)->getDisplayMode()) { renderer->setBlendMode(BlendMode_Add); renderer->setGlobalColor(dcolor[0], dcolor[1], dcolor[2], 1); markerTexture->bind(); if (labelsFader.getInterstate()<=0.f) { Vec3d win; if(projector->project(XYZ, win)) { renderer->drawTexturedRect(win[0] - 4, win[1] - 4, 8, 8); } } } else { sd->preDrawPointSource(); if (mag <= sd->getLimitMagnitude()) { sd->computeRCMag(mag, rcMag); const Vec3f XYZf(XYZ[0], XYZ[1], XYZ[2]); Vec3f win; if(sd->pointSourceVisible(&(*projector), XYZf, rcMag, false, win)) { sd->drawPointSource(win, rcMag, sd->indexToColor(BvToColorIndex(bV))); } renderer->setGlobalColor(color[0], color[1], color[2], 1.0f); size = getAngularSize(NULL)*M_PI/180.*projector->getPixelPerRadAtCenter(); shift = 6.f + size/1.8f; if (labelsFader.getInterstate()<=0.f) { renderer->drawText(TextParams(XYZ, projector, designation).shift(shift, shift).useGravity()); } } sd->postDrawPointSource(projector); } }
//! Draw any parts on the screen which are for our module void CompassMarks::draw(StelCore* core) { if (markFader.getInterstate() <= 0.0) { return; } Vec3d pos, screenPos; StelProjectorP prj = core->getProjection(StelCore::FrameAltAz, StelCore::RefractionOff); StelPainter painter(prj); painter.setFont(font); int f = 0; if (StelApp::getInstance().getFlagSouthAzimuthUsage()) f = 180; painter.setColor(markColor[0], markColor[1], markColor[2], markFader.getInterstate()); painter.setBlending(true); painter.setLineSmooth(true); for(int i=0; i<360; i++) { float a = i*M_PI/180; pos.set(sin(a),cos(a), 0.f); float h = -0.002; if (i % 15 == 0) { h = -0.02; // the size of the mark every 15 degrees QString s = QString("%1").arg((i+90+f)%360); float shiftx = painter.getFontMetrics().width(s) / 2.; float shifty = painter.getFontMetrics().height() / 2.; painter.drawText(pos, s, 0, -shiftx, shifty); } else if (i % 5 == 0) { h = -0.01; // the size of the mark every 5 degrees } // Limit arcs to those that are visible for improved performance if (prj->project(pos, screenPos) && screenPos[0]>prj->getViewportPosX() && screenPos[0] < prj->getViewportPosX() + prj->getViewportWidth()) { painter.drawGreatCircleArc(pos, Vec3d(pos[0], pos[1], h), Q_NULLPTR); } } painter.setBlending(false); painter.setLineSmooth(false); }
/************************************************************************* Find in a "clever" way an object from its equatorial position *************************************************************************/ StelObjectP StelObjectMgr::cleverFind(const StelCore* core, int x, int y) const { Vec3d v; const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000); if (prj->unProject(x,y,v)) { // Nick Fedoseev patch: improve click match for refracted coordinates Vec3d win; prj->project(v,win); float dx = x - win.v[0]; float dy = y - win.v[1]; prj->unProject(x+dx, y+dy, v); return cleverFind(core, v); } return StelObjectP(); }
bool AngleMeasure::handleMouseMoves(int x, int y, Qt::MouseButtons) { if (dragging) { const StelProjectorP prj = StelApp::getInstance().getCore()->getProjection(StelCore::FrameEquinoxEqu); prj->unProject(x,y,endPoint); { // Nick Fedoseev patch: improve click match Vec3d win; prj->project(endPoint,win); float dx = x - win.v[0]; float dy = y - win.v[1]; prj->unProject(x+dx, y+dy, endPoint); } const StelProjectorP prjHor = StelApp::getInstance().getCore()->getProjection(StelCore::FrameAltAz, StelCore::RefractionOff); prjHor->unProject(x,y,endPointHor); calculateEnds(); lineVisible = true; return true; } else return false; }
void AngleMeasure::handleMouseClicks(class QMouseEvent* event) { if (!flagShowAngleMeasure) { event->setAccepted(false); return; } if (event->type()==QEvent::MouseButtonPress && event->button()==Qt::LeftButton) { const StelProjectorP prj = StelApp::getInstance().getCore()->getProjection(StelCore::FrameEquinoxEqu); prj->unProject(event->x(),event->y(),startPoint); { // Nick Fedoseev patch: improve click match Vec3d win; prj->project(startPoint,win); float dx = event->x() - win.v[0]; float dy = event->y() - win.v[1]; prj->unProject(event->x()+dx, event->y()+dy, startPoint); } const StelProjectorP prjHor = StelApp::getInstance().getCore()->getProjection(StelCore::FrameAltAz, StelCore::RefractionOff); prjHor->unProject(event->x(),event->y(),startPointHor); // first click reset the line... only draw it after we've dragged a little. if (!dragging) { lineVisible = false; endPoint = startPoint; endPointHor=startPointHor; } else lineVisible = true; dragging = true; calculateEnds(); event->setAccepted(true); return; } else if (event->type()==QEvent::MouseButtonRelease && event->button()==Qt::LeftButton) { dragging = false; calculateEnds(); event->setAccepted(true); return; } else if (event->type()==QEvent::MouseButtonPress && event->button()==Qt::RightButton) { const StelProjectorP prj = StelApp::getInstance().getCore()->getProjection(StelCore::FrameEquinoxEqu); prj->unProject(event->x(),event->y(),endPoint); { // Nick Fedoseev patch: improve click match Vec3d win; prj->project(endPoint,win); float dx = event->x() - win.v[0]; float dy = event->y() - win.v[1]; prj->unProject(event->x()+dx, event->y()+dy, endPoint); } const StelProjectorP prjHor = StelApp::getInstance().getCore()->getProjection(StelCore::FrameAltAz, StelCore::RefractionOff); prjHor->unProject(event->x(),event->y(),endPointHor); calculateEnds(); event->setAccepted(true); return; } event->setAccepted(false); }
void AngleMeasure::drawOne(StelCore *core, const StelCore::FrameType frameType, const StelCore::RefractionMode refractionMode, const Vec3f txtColor, const Vec3f lineColor) { const StelProjectorP prj = core->getProjection(frameType, refractionMode); StelPainter painter(prj); painter.setFont(font); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glEnable(GL_BLEND); if (lineVisible.getInterstate() > 0.000001f) { Vec3d xy; QString displayedText; if (frameType==StelCore::FrameEquinoxEqu) { if (prj->project(perp1EndPoint,xy)) { painter.setColor(txtColor[0], txtColor[1], txtColor[2], lineVisible.getInterstate()); if (flagShowPA) displayedText = QString("%1 (%2%3)").arg(calculateAngle(), messagePA, calculatePositionAngle(startPoint, endPoint)); else displayedText = calculateAngle(); painter.drawText(xy[0], xy[1], displayedText, 0, 15, 15); } } else { if (prj->project(perp1EndPointHor,xy)) { painter.setColor(txtColor[0], txtColor[1], txtColor[2], lineVisible.getInterstate()); if (flagShowHorizontalPA) displayedText = QString("%1 (%2%3)").arg(calculateAngle(true), messagePA, calculatePositionAngle(startPointHor, endPointHor)); else displayedText = calculateAngle(true); painter.drawText(xy[0], xy[1], displayedText, 0, 15, -5); } } glDisable(GL_TEXTURE_2D); // OpenGL ES 2.0 doesn't have GL_LINE_SMOOTH. But it looks much better. #ifdef GL_LINE_SMOOTH if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL) glEnable(GL_LINE_SMOOTH); #endif // main line is a great circle painter.setColor(lineColor[0], lineColor[1], lineColor[2], lineVisible.getInterstate()); if (frameType==StelCore::FrameEquinoxEqu) { painter.drawGreatCircleArc(startPoint, endPoint, NULL); // End lines painter.drawGreatCircleArc(perp1StartPoint, perp1EndPoint, NULL); painter.drawGreatCircleArc(perp2StartPoint, perp2EndPoint, NULL); } else { painter.drawGreatCircleArc(startPointHor, endPointHor, NULL); // End lines painter.drawGreatCircleArc(perp1StartPointHor, perp1EndPointHor, NULL); painter.drawGreatCircleArc(perp2StartPointHor, perp2EndPointHor, NULL); } #ifdef GL_LINE_SMOOTH if (QOpenGLContext::currentContext()->format().renderableType()==QSurfaceFormat::OpenGL) glDisable(GL_LINE_SMOOTH); #endif } if (messageFader.getInterstate() > 0.000001f) { painter.setColor(txtColor[0], txtColor[1], txtColor[2], messageFader.getInterstate()); int x = 83; int y = 120; int ls = painter.getFontMetrics().lineSpacing(); painter.drawText(x, y, messageEnabled); y -= ls; painter.drawText(x, y, messageLeftButton); y -= ls; painter.drawText(x, y, messageRightButton); } glDisable(GL_BLEND); }
bool SkyLabel::draw(StelCore* core, StelRenderer* renderer, StelProjectorP projector) { if(labelFader.getInterstate() <= 0.0) return false; Vec3d objectPos = labelObject->getJ2000EquatorialPos(core); Vec3d labelXY; projector->project(objectPos, labelXY); renderer->setFont(labelFont); double xOffset(0.); double yOffset(0.); char hJustify = 'c'; char vJustify = 'c'; if (labelSide.toUpper().contains("N")) { yOffset = 1.0; vJustify = 'b'; // bottom justify text } else if (labelSide.toUpper().contains("S")) { yOffset = -1.0; vJustify = 't'; // top justufy text } if (labelSide.toUpper().contains("E")) { xOffset = 1.0; hJustify = 'l'; // right justify text } else if (labelSide.toUpper().contains("W")) { xOffset = -1.0; hJustify = 'r'; // left justify text } if (labelDistance >= 0.0) { xOffset *= labelDistance; yOffset *= labelDistance; } else { float shift = 4.0f + labelObject->getAngularSize(core) * M_PI / 180.0f * projector->getPixelPerRadAtCenter() / 1.8f; // use the object size xOffset *= shift; yOffset *= shift; } QFontMetrics fontMetrics(labelFont); const float jxOffset = hJustify == 'r' ? fontMetrics.width(labelText) : hJustify == 'c' ? fontMetrics.width(labelText) * 0.5 : 0.0; const float jyOffset = vJustify == 't' ? fontMetrics.height() : vJustify == 'c' ? fontMetrics.height() * 0.5 : 0.0; renderer->setGlobalColor(labelColor[0], labelColor[1], labelColor[2], labelFader.getInterstate()); renderer->drawText(TextParams(labelXY[0] + xOffset - jxOffset, labelXY[1] + yOffset - jyOffset, labelText).useGravity()); if (labelStyle == SkyLabel::Line) { renderer->setBlendMode(BlendMode_Alpha); // screen coordinates of object Vec3d objXY; projector->project(objectPos, objXY); double lineEndX = labelXY[0]+xOffset; double lineEndY = labelXY[1]+yOffset; if (vJustify == 'b') lineEndY -= 5; else if (vJustify == 't') lineEndY += 5; if (hJustify == 'l') lineEndX -= 5; else if (hJustify == 'r') lineEndX += 5; renderer->setGlobalColor(labelColor[0], labelColor[1], labelColor[2], labelFader.getInterstate()); renderer->drawLine(lineEndX,lineEndY,objXY[0], objXY[1]); } return true; }
void PointerCoordinates::draw(StelCore *core) { if (!isEnabled()) return; const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000, StelCore::RefractionAuto); StelPainter sPainter(prj); sPainter.setColor(textColor[0], textColor[1], textColor[2], 1.f); font.setPixelSize(getFontSize()); sPainter.setFont(font); QPoint p = StelMainView::getInstance().getMousePos(); // get screen coordinates of mouse cursor Vec3d mousePosition; float wh = prj->getViewportWidth()/2.; // get half of width of the screen float hh = prj->getViewportHeight()/2.; // get half of height of the screen float mx = p.x()-wh; // point 0 in center of the screen, axis X directed to right float my = p.y()-hh; // point 0 in center of the screen, axis Y directed to bottom // calculate position of mouse cursor via position of center of the screen (and invert axis Y) // If coordinates are invalid, don't draw them. bool coordsValid=false; coordsValid = prj->unProject(prj->getViewportPosX()+wh+mx, prj->getViewportPosY()+hh+1-my, mousePosition); { // Nick Fedoseev patch Vec3d win; prj->project(mousePosition,win); float dx = prj->getViewportPosX()+wh+mx - win.v[0]; float dy = prj->getViewportPosY()+hh+1-my - win.v[1]; coordsValid = prj->unProject(prj->getViewportPosX()+wh+mx+dx, prj->getViewportPosY()+hh+1-my+dy, mousePosition); } if (!coordsValid) return; bool withDecimalDegree = StelApp::getInstance().getFlagShowDecimalDegrees(); bool useSouthAzimuth = StelApp::getInstance().getFlagSouthAzimuthUsage(); QString coordsSystem, cxt, cyt; double cx, cy; switch (getCurrentCoordinateSystem()) { case RaDecJ2000: { StelUtils::rectToSphe(&cx,&cy,mousePosition); // Calculate RA/DE (J2000.0) and show it... coordsSystem = qc_("RA/Dec (J2000.0)", "abbreviated in the plugin"); if (withDecimalDegree) { cxt = StelUtils::radToDecDegStr(cx, 5, false, true); cyt = StelUtils::radToDecDegStr(cy); } else { cxt = StelUtils::radToHmsStr(cx, true); cyt = StelUtils::radToDmsStr(cy, true); } break; } case RaDec: { StelUtils::rectToSphe(&cx,&cy,core->j2000ToEquinoxEqu(mousePosition)); // Calculate RA/DE and show it... coordsSystem = qc_("RA/Dec", "abbreviated in the plugin"); if (withDecimalDegree) { cxt = StelUtils::radToDecDegStr(cx, 5, false, true); cyt = StelUtils::radToDecDegStr(cy); } else { cxt = StelUtils::radToHmsStr(cx, true); cyt = StelUtils::radToDmsStr(cy, true); } break; } case AltAzi: { StelUtils::rectToSphe(&cy,&cx,core->j2000ToAltAz(mousePosition, StelCore::RefractionAuto)); float direction = 3.; // N is zero, E is 90 degrees if (useSouthAzimuth) direction = 2.; cy = direction*M_PI - cy; if (cy > M_PI*2) cy -= M_PI*2; coordsSystem = qc_("Az/Alt", "abbreviated in the plugin"); if (withDecimalDegree) { cxt = StelUtils::radToDecDegStr(cy); cyt = StelUtils::radToDecDegStr(cx); } else { cxt = StelUtils::radToDmsStr(cy); cyt = StelUtils::radToDmsStr(cx); } break; } case Galactic: { StelUtils::rectToSphe(&cx,&cy,core->j2000ToGalactic(mousePosition)); // Calculate galactic position and show it... coordsSystem = qc_("Gal. Long/Lat", "abbreviated in the plugin"); if (withDecimalDegree) { cxt = StelUtils::radToDecDegStr(cx); cyt = StelUtils::radToDecDegStr(cy); } else { cxt = StelUtils::radToDmsStr(cx, true); cyt = StelUtils::radToDmsStr(cy, true); } break; } case Ecliptic: { double lambda, beta; StelUtils::rectToSphe(&cx,&cy,core->j2000ToEquinoxEqu(mousePosition)); StelUtils::equToEcl(cx, cy, core->getCurrentPlanet()->getRotObliquity(core->getJDE()), &lambda, &beta); // Calculate ecliptic position and show it... if (lambda<0) lambda+=2.0*M_PI; coordsSystem = qc_("Ecl. Long/Lat", "abbreviated in the plugin"); if (withDecimalDegree) { cxt = StelUtils::radToDecDegStr(lambda); cyt = StelUtils::radToDecDegStr(beta); } else { cxt = StelUtils::radToDmsStr(lambda, true); cyt = StelUtils::radToDmsStr(beta, true); } break; } case EclipticJ2000: { double lambda, beta; StelUtils::rectToSphe(&cx,&cy, mousePosition); StelUtils::equToEcl(cx, cy, core->getCurrentPlanet()->getRotObliquity(2451545.0), &lambda, &beta); // Calculate ecliptic position and show it... if (lambda<0) lambda+=2.0*M_PI; coordsSystem = qc_("Ecl. Long/Lat (J2000.0)", "abbreviated in the plugin"); if (withDecimalDegree) { cxt = StelUtils::radToDecDegStr(lambda); cyt = StelUtils::radToDecDegStr(beta); } else { cxt = StelUtils::radToDmsStr(lambda, true); cyt = StelUtils::radToDmsStr(beta, true); } break; } case HourAngle: { Vec3d v = core->j2000ToAltAz(mousePosition, StelCore::RefractionAuto); StelUtils::rectToSphe(&cx,&cy,Mat4d::zrotation(-core->getLocalSiderealTime())*core->altAzToEquinoxEqu(v, StelCore::RefractionOff)); cx = 2.*M_PI-cx; coordsSystem = qc_("HA/Dec", "abbreviated in the plugin"); if (withDecimalDegree) { double ha_sidereal = cx*12/M_PI; if (ha_sidereal>24.) ha_sidereal -= 24.; cxt = QString("%1h").arg(ha_sidereal, 0, 'f', 5); cyt = StelUtils::radToDecDegStr(cy); } else { cxt = StelUtils::radToHmsStr(cx); cyt = StelUtils::radToDmsStr(cy); } break; } } QString coordsText = QString("%1: %2/%3").arg(coordsSystem).arg(cxt).arg(cyt); sPainter.drawText(getCoordinatesPlace(coordsText).first, getCoordinatesPlace(coordsText).second, coordsText); }
//! Draw the sky grid in the current frame void SkyGrid::draw(const StelCore* core) const { const StelProjectorP prj = core->getProjection(frameType, frameType!=StelCore::FrameAltAz ? StelCore::RefractionAuto : StelCore::RefractionOff); if (!fader.getInterstate()) return; bool withDecimalDegree = dynamic_cast<StelGui*>(StelApp::getInstance().getGui())->getFlagShowDecimalDegrees(); // Look for all meridians and parallels intersecting with the disk bounding the viewport // Check whether the pole are in the viewport bool northPoleInViewport = false; bool southPoleInViewport = false; Vec3f win; if (prj->project(Vec3f(0,0,1), win) && prj->checkInViewport(win)) northPoleInViewport = true; if (prj->project(Vec3f(0,0,-1), win) && prj->checkInViewport(win)) southPoleInViewport = true; // Get the longitude and latitude resolution at the center of the viewport Vec3d centerV; prj->unProject(prj->getViewportPosX()+prj->getViewportWidth()/2, prj->getViewportPosY()+prj->getViewportHeight()/2+1, centerV); double lon2, lat2; StelUtils::rectToSphe(&lon2, &lat2, centerV); const double gridStepParallelRad = M_PI/180.*getClosestResolutionDMS(prj->getPixelPerRadAtCenter()); double gridStepMeridianRad; if (northPoleInViewport || southPoleInViewport) gridStepMeridianRad = (frameType==StelCore::FrameAltAz || frameType==StelCore::FrameGalactic) ? M_PI/180.* 10. : M_PI/180.* 15.; else { const double closetResLon = (frameType==StelCore::FrameAltAz || frameType==StelCore::FrameGalactic) ? getClosestResolutionDMS(prj->getPixelPerRadAtCenter()*std::cos(lat2)) : getClosestResolutionHMS(prj->getPixelPerRadAtCenter()*std::cos(lat2)); gridStepMeridianRad = M_PI/180.* ((northPoleInViewport || southPoleInViewport) ? 15. : closetResLon); } // Get the bounding halfspace const SphericalCap& viewPortSphericalCap = prj->getBoundingCap(); // Compute the first grid starting point. This point is close to the center of the screen // and lays at the intersection of a meridien and a parallel lon2 = gridStepMeridianRad*((int)(lon2/gridStepMeridianRad+0.5)); lat2 = gridStepParallelRad*((int)(lat2/gridStepParallelRad+0.5)); Vec3d firstPoint; StelUtils::spheToRect(lon2, lat2, firstPoint); firstPoint.normalize(); // Q_ASSERT(viewPortSphericalCap.contains(firstPoint)); // Initialize a painter and set openGL state StelPainter sPainter(prj); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode Vec4f textColor(color[0], color[1], color[2], 0); sPainter.setColor(color[0],color[1],color[2], fader.getInterstate()); textColor*=2; textColor[3]=fader.getInterstate(); sPainter.setFont(font); ViewportEdgeIntersectCallbackData userData(&sPainter); userData.textColor = textColor; userData.frameType = frameType; ///////////////////////////////////////////////// // Draw all the meridians (great circles) SphericalCap meridianSphericalCap(Vec3d(1,0,0), 0); Mat4d rotLon = Mat4d::zrotation(gridStepMeridianRad); Vec3d fpt = firstPoint; Vec3d p1, p2; int maxNbIter = (int)(M_PI/gridStepMeridianRad); int i; for (i=0; i<maxNbIter; ++i) { StelUtils::rectToSphe(&lon2, &lat2, fpt); userData.raAngle = lon2; meridianSphericalCap.n = fpt^Vec3d(0,0,1); meridianSphericalCap.n.normalize(); if (!SphericalCap::intersectionPoints(viewPortSphericalCap, meridianSphericalCap, p1, p2)) { if (viewPortSphericalCap.d<meridianSphericalCap.d && viewPortSphericalCap.contains(meridianSphericalCap.n)) { // The meridian is fully included in the viewport, draw it in 3 sub-arcs to avoid length > 180. const Mat4d& rotLon120 = Mat4d::rotation(meridianSphericalCap.n, 120.*M_PI/180.); Vec3d rotFpt=fpt; rotFpt.transfo4d(rotLon120); Vec3d rotFpt2=rotFpt; rotFpt2.transfo4d(rotLon120); sPainter.drawGreatCircleArc(fpt, rotFpt, NULL, viewportEdgeIntersectCallback, &userData); sPainter.drawGreatCircleArc(rotFpt, rotFpt2, NULL, viewportEdgeIntersectCallback, &userData); sPainter.drawGreatCircleArc(rotFpt2, fpt, NULL, viewportEdgeIntersectCallback, &userData); fpt.transfo4d(rotLon); continue; } else break; } Vec3d middlePoint = p1+p2; middlePoint.normalize(); if (!viewPortSphericalCap.contains(middlePoint)) middlePoint*=-1.; // Draw the arc in 2 sub-arcs to avoid lengths > 180 deg sPainter.drawGreatCircleArc(p1, middlePoint, NULL, viewportEdgeIntersectCallback, &userData); sPainter.drawGreatCircleArc(p2, middlePoint, NULL, viewportEdgeIntersectCallback, &userData); fpt.transfo4d(rotLon); } if (i!=maxNbIter) { rotLon = Mat4d::zrotation(-gridStepMeridianRad); fpt = firstPoint; fpt.transfo4d(rotLon); for (int j=0; j<maxNbIter-i; ++j) { StelUtils::rectToSphe(&lon2, &lat2, fpt); userData.raAngle = lon2; meridianSphericalCap.n = fpt^Vec3d(0,0,1); meridianSphericalCap.n.normalize(); if (!SphericalCap::intersectionPoints(viewPortSphericalCap, meridianSphericalCap, p1, p2)) break; Vec3d middlePoint = p1+p2; middlePoint.normalize(); if (!viewPortSphericalCap.contains(middlePoint)) middlePoint*=-1; sPainter.drawGreatCircleArc(p1, middlePoint, NULL, viewportEdgeIntersectCallback, &userData); sPainter.drawGreatCircleArc(p2, middlePoint, NULL, viewportEdgeIntersectCallback, &userData); fpt.transfo4d(rotLon); } } ///////////////////////////////////////////////// // Draw all the parallels (small circles) SphericalCap parallelSphericalCap(Vec3d(0,0,1), 0); rotLon = Mat4d::rotation(firstPoint^Vec3d(0,0,1), gridStepParallelRad); fpt = firstPoint; maxNbIter = (int)(M_PI/gridStepParallelRad)-1; for (i=0; i<maxNbIter; ++i) { StelUtils::rectToSphe(&lon2, &lat2, fpt); if (withDecimalDegree) userData.text = StelUtils::radToDecDegStr(lat2); else userData.text = StelUtils::radToDmsStrAdapt(lat2); parallelSphericalCap.d = fpt[2]; if (parallelSphericalCap.d>0.9999999) break; const Vec3d rotCenter(0,0,parallelSphericalCap.d); if (!SphericalCap::intersectionPoints(viewPortSphericalCap, parallelSphericalCap, p1, p2)) { if ((viewPortSphericalCap.d<parallelSphericalCap.d && viewPortSphericalCap.contains(parallelSphericalCap.n)) || (viewPortSphericalCap.d<-parallelSphericalCap.d && viewPortSphericalCap.contains(-parallelSphericalCap.n))) { // The parallel is fully included in the viewport, draw it in 3 sub-arcs to avoid lengths >= 180 deg static const Mat4d rotLon120 = Mat4d::zrotation(120.*M_PI/180.); Vec3d rotFpt=fpt; rotFpt.transfo4d(rotLon120); Vec3d rotFpt2=rotFpt; rotFpt2.transfo4d(rotLon120); sPainter.drawSmallCircleArc(fpt, rotFpt, rotCenter, viewportEdgeIntersectCallback, &userData); sPainter.drawSmallCircleArc(rotFpt, rotFpt2, rotCenter, viewportEdgeIntersectCallback, &userData); sPainter.drawSmallCircleArc(rotFpt2, fpt, rotCenter, viewportEdgeIntersectCallback, &userData); fpt.transfo4d(rotLon); continue; } else break; } // Draw the arc in 2 sub-arcs to avoid lengths > 180 deg Vec3d middlePoint = p1-rotCenter+p2-rotCenter; middlePoint.normalize(); middlePoint*=(p1-rotCenter).length(); middlePoint+=rotCenter; if (!viewPortSphericalCap.contains(middlePoint)) { middlePoint-=rotCenter; middlePoint*=-1.; middlePoint+=rotCenter; } sPainter.drawSmallCircleArc(p1, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData); sPainter.drawSmallCircleArc(p2, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData); fpt.transfo4d(rotLon); } if (i!=maxNbIter) { rotLon = Mat4d::rotation(firstPoint^Vec3d(0,0,1), -gridStepParallelRad); fpt = firstPoint; fpt.transfo4d(rotLon); for (int j=0; j<maxNbIter-i; ++j) { StelUtils::rectToSphe(&lon2, &lat2, fpt); if (withDecimalDegree) userData.text = StelUtils::radToDecDegStr(lat2); else userData.text = StelUtils::radToDmsStrAdapt(lat2); parallelSphericalCap.d = fpt[2]; const Vec3d rotCenter(0,0,parallelSphericalCap.d); if (!SphericalCap::intersectionPoints(viewPortSphericalCap, parallelSphericalCap, p1, p2)) { if ((viewPortSphericalCap.d<parallelSphericalCap.d && viewPortSphericalCap.contains(parallelSphericalCap.n)) || (viewPortSphericalCap.d<-parallelSphericalCap.d && viewPortSphericalCap.contains(-parallelSphericalCap.n))) { // The parallel is fully included in the viewport, draw it in 3 sub-arcs to avoid lengths >= 180 deg static const Mat4d rotLon120 = Mat4d::zrotation(120.*M_PI/180.); Vec3d rotFpt=fpt; rotFpt.transfo4d(rotLon120); Vec3d rotFpt2=rotFpt; rotFpt2.transfo4d(rotLon120); sPainter.drawSmallCircleArc(fpt, rotFpt, rotCenter, viewportEdgeIntersectCallback, &userData); sPainter.drawSmallCircleArc(rotFpt, rotFpt2, rotCenter, viewportEdgeIntersectCallback, &userData); sPainter.drawSmallCircleArc(rotFpt2, fpt, rotCenter, viewportEdgeIntersectCallback, &userData); fpt.transfo4d(rotLon); continue; } else break; } // Draw the arc in 2 sub-arcs to avoid lengths > 180 deg Vec3d middlePoint = p1-rotCenter+p2-rotCenter; middlePoint.normalize(); middlePoint*=(p1-rotCenter).length(); middlePoint+=rotCenter; if (!viewPortSphericalCap.contains(middlePoint)) { middlePoint-=rotCenter; middlePoint*=-1.; middlePoint+=rotCenter; } sPainter.drawSmallCircleArc(p1, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData); sPainter.drawSmallCircleArc(p2, middlePoint, rotCenter, viewportEdgeIntersectCallback, &userData); fpt.transfo4d(rotLon); } } }
// returns true if visible // Assumes that we are in local frame void Meteor::draw(const StelCore* core, StelPainter& sPainter) { if (!alive) return; const StelProjectorP proj = sPainter.getProjector(); Vec3d spos = position; Vec3d epos = posTrain; // convert to equ spos.transfo4d(mmat); epos.transfo4d(mmat); // convert to local and correct for earth radius [since equ and local coordinates in stellarium use same 0 point!] spos = core->equinoxEquToAltAz( spos ); epos = core->equinoxEquToAltAz( epos ); spos[2] -= EARTH_RADIUS; epos[2] -= EARTH_RADIUS; // 1216 is to scale down under 1 for desktop version spos/=1216; epos/=1216; // qDebug("[%f %f %f] (%d, %d) (%d, %d)\n", position[0], position[1], position[2], (int)start[0], (int)start[1], (int)end[0], (int)end[1]); if (train) { // connect this point with last drawn point double tmag = mag*distMultiplier; // compute an intermediate point so can curve slightly along projection distortions Vec3d posi = posInternal; posi[2] = position[2] + (posTrain[2] - position[2])/2; posi.transfo4d(mmat); posi = core->equinoxEquToAltAz( posi ); posi[2] -= EARTH_RADIUS; posi/=1216; // draw dark to light Vec4f colorArray[3]; colorArray[0].set(0,0,0,0); colorArray[1].set(1,1,1,tmag*0.5); colorArray[2].set(1,1,1,tmag); Vec3d vertexArray[3]; vertexArray[0]=epos; vertexArray[1]=posi; vertexArray[2]=spos; sPainter.setColorPointer(4, GL_FLOAT, colorArray); sPainter.setVertexPointer(3, GL_DOUBLE, vertexArray); // TODO the crash doesn't appear when the last true is set to false sPainter.enableClientStates(true, false, true); sPainter.drawFromArray(StelPainter::LineStrip, 3, 0, true); sPainter.enableClientStates(false); } else { sPainter.setPointSize(1.f); Vec3d start; proj->project(spos, start); sPainter.drawPoint2d(start[0],start[1]); } train = 1; }
void StelQGLRenderer::drawText(const TextParams& params) { statistics[TEXT_DRAWS] += 1.0; StelQGLTextureBackend* currentTexture = currentlyBoundTextures[0]; if(params.string_.length() == 0) { return; } viewport.enablePainting(); if(currentFontSet) { viewport.setFont(currentFont); } QPainter* painter = viewport.getPainter(); Q_ASSERT_X(NULL != painter, Q_FUNC_INFO, "Trying to draw text but painting is disabled"); QFontMetrics fontMetrics = painter->fontMetrics(); StelProjectorP projector = NULL == params.projector_ ? StelApp::getInstance().getCore()->getProjection2d() : params.projector_; Vec3f win; if(params.doNotProject_) { win = params.position_; } else if(!projector->project(params.position_, win)) { viewport.disablePainting(); return; } const int x = win[0]; const int y = win[1]; // Avoid drawing if outside viewport. // We do a worst-case approximation as getting exact text dimensions is expensive. // We also account for rotation by assuming the worst case in bot X and Y // (culling with a rotating rectangle would be expensive) const int cullDistance = std::max(fontMetrics.height(), params.string_.size() * fontMetrics.maxWidth()); const Vec4i viewXywh = projector->getViewportXywh(); const int viewMinX = viewXywh[0]; const int viewMinY = viewXywh[1]; const int viewMaxX = viewMinX + viewXywh[2]; const int viewMaxY = viewMinY + viewXywh[3]; if(y + cullDistance < viewMinY || y - cullDistance > viewMaxY || x + cullDistance < viewMinX || x - cullDistance > viewMaxX) { viewport.disablePainting(); return; } if(projector->useGravityLabels() && !params.noGravity_) { drawTextGravityHelper(params, *painter, x, y, projector); return; } const int pixelSize = painter->font().pixelSize(); // Strings drawn by drawText() can differ by text, font size, or the font itself. const QByteArray hash = params.string_.toUtf8() + QByteArray::number(pixelSize) + painter->font().family().toUtf8(); StelQGLTextureBackend* textTexture = textTextureCache.object(hash); // No texture in cache for this string, need to draw it. if (NULL == textTexture) { const QRect extents = fontMetrics.boundingRect(params.string_); // Width and height of the text. // Texture width/height is required to be at least equal to this. // // Both X and Y need to be at least 1 so we don't create an empty image // (doesn't work with textures) const int requiredWidth = std::max(1, extents.width() + 1 + static_cast<int>(0.02f * extents.width())); const int requiredHeight = std::max(1, extents.height()); // Create temporary image and render text into it // QImage is used solely to reuse existing QGLTextureBackend constructor // function. QPixmap could be used as well (not sure which is faster, // needs profiling) QImage image = areNonPowerOfTwoTexturesSupported() ? QImage(requiredWidth, requiredHeight, QImage::Format_ARGB32_Premultiplied) : QImage(StelUtils::smallestPowerOfTwoGreaterOrEqualTo(requiredWidth), StelUtils::smallestPowerOfTwoGreaterOrEqualTo(requiredHeight), QImage::Format_ARGB32); image.fill(Qt::transparent); QPainter fontPainter(&image); fontPainter.setFont(painter->font()); fontPainter.setRenderHints(QPainter::TextAntialiasing, true); fontPainter.setPen(Qt::white); // The second argument ensures the text is positioned correctly even if // the image is enlarged to power-of-two. fontPainter.drawText(-extents.x(), image.height() - requiredHeight - extents.y(), params.string_); textTexture = StelQGLTextureBackend::constructFromImage (this, QString(), TextureParams().filtering(TextureFiltering_Linear), image); const QSize size = textTexture->getDimensions(); if(!textTexture->getStatus() == TextureStatus_Loaded) { qWarning() << "Texture error: " << textTexture->getErrorMessage(); Q_ASSERT_X(false, Q_FUNC_INFO, "Failed to construct a text texture"); } textTextureCache.insert(hash, textTexture, 4 * size.width() * size.height()); } // Even if NPOT textures are not supported, we always draw the full rectangle // of the texture. The extra space is fully transparent, so it's not an issue. // Shortcut variables to calculate the rectangle. const QSize size = textTexture->getDimensions(); const float w = size.width(); const float h = size.height(); const float xShift = params.xShift_; const float yShift = params.yShift_; const float angleDegrees = params.angleDegrees_ + (params.noGravity_ ? 0.0f : projector->getDefaultAngleForGravityText()); // Zero out very small angles. // // (this could also be used to optimize the case with zero angled // to avoid sin/cos if needed) const bool angled = std::fabs(angleDegrees) >= 1.0f * M_PI / 180.f; const float cosr = angled ? std::cos(angleDegrees * M_PI / 180.0) : 1.0f; const float sinr = angled ? std::sin(angleDegrees * M_PI / 180.0) : 0.0f; // Corners of the (possibly rotated) texture rectangle. const Vec2f ne(round(x + cosr * xShift - sinr * yShift), round(y + sinr * xShift + cosr * yShift)); const Vec2f nw(round(x + cosr * (w + xShift) - sinr * yShift), round(y + sinr * (w + xShift) + cosr * yShift)); const Vec2f se(round(x + cosr * xShift - sinr * (h + yShift)), round(y + sinr * xShift + cosr * (h + yShift))); const Vec2f sw(round(x + cosr * (w + xShift) - sinr * (h + yShift)), round(y + sinr * (w + xShift) + cosr * (h + yShift))); // Construct the text vertex buffer if it doesn't exist yet, otherwise clear it. if(NULL == textBuffer) { textBuffer = createVertexBuffer<TexturedVertex>(PrimitiveType_TriangleStrip); } else { textBuffer->unlock(); textBuffer->clear(); } textBuffer->addVertex(TexturedVertex(ne, Vec2f(0.0f, 0.0f))); textBuffer->addVertex(TexturedVertex(nw, Vec2f(1.0f, 0.0f))); textBuffer->addVertex(TexturedVertex(se, Vec2f(0.0f, 1.0f))); textBuffer->addVertex(TexturedVertex(sw, Vec2f(1.0f, 1.0f))); textBuffer->lock(); // Draw. const BlendMode oldBlendMode = blendMode; setBlendMode(BlendMode_Alpha); textTexture->bind(0); drawVertexBuffer(textBuffer); setBlendMode(oldBlendMode); // Reset user-bound texture. if(NULL != currentTexture) { currentTexture->bind(0); } viewport.disablePainting(); }
// Draw the Comet and all the related infos : name, circle etc... GZ: Taken from Planet.cpp 2013-11-05 and extended void Comet::draw(StelCore* core, float maxMagLabels, const QFont& planetNameFont) { if (hidden) return; if (getEnglishName() == core->getCurrentLocation().planetName) { // GZ moved this up. Maybe even don't do that? E.g., draw tail while riding the comet? Decide later. return; } // The CometOrbit is in fact available in userDataPtr! CometOrbit* orbit=(CometOrbit*)userDataPtr; Q_ASSERT(orbit); if (!orbit->objectDateValid(core->getJDay())) return; // out of useful date range. This allows having hundreds of comet elements. if (orbit->getUpdateTails()){ // Compute lengths and orientations from orbit object, but only if required. // TODO: This part should possibly be moved to another thread to keep draw() free from too much computation. Vec2f tailFactors=getComaDiameterAndTailLengthAU(); float gasTailEndRadius=qMax(tailFactors[0], 0.025f*tailFactors[1]) ; // This avoids too slim gas tails for bright comets like Hale-Bopp. float gasparameter=gasTailEndRadius*gasTailEndRadius/(2.0f*tailFactors[1]); // parabola formula: z=r²/2p, so p=r²/2z // The dust tail is thicker and usually shorter. The factors can be configured in the elements. float dustparameter=gasTailEndRadius*gasTailEndRadius*dustTailWidthFactor*dustTailWidthFactor/(2.0f*dustTailLengthFactor*tailFactors[1]); // Find valid parameters to create paraboloid vertex arrays: dustTail, gasTail. computeParabola(gasparameter, gasTailEndRadius, -0.5f*gasparameter, gastailVertexArr, gastailTexCoordArr, gastailIndices); // This was for a rotated straight parabola: //computeParabola(dustparameter, 2.0f*tailFactors[0], -0.5f*dustparameter, dusttailVertexArr, dusttailTexCoordArr, dusttailIndices); // Now we make a skewed parabola. Skew factor 15 (last arg) ad-hoc/empirical. TBD later: Find physically correct solution. computeParabola(dustparameter, dustTailWidthFactor*gasTailEndRadius, -0.5f*dustparameter, dusttailVertexArr, gastailTexCoordArr, gastailIndices, 25.0f*orbit->getVelocity().length()); // Note that we use a diameter larger than what the formula returns. A scale factor of 1.2 is ad-hoc/empirical (GZ), but may look better. computeComa(1.0f*tailFactors[0]); orbit->setUpdateTails(false); // don't update until position has been recalculated elsewhere } Mat4d mat = Mat4d::translation(eclipticPos) * rotLocalToParent; /* // We can remove that - a Comet has no parent except for the sun... PlanetP p = parent; while (p && p->parent) { mat = Mat4d::translation(p->eclipticPos) * mat * p->rotLocalToParent; p = p->parent; } */ // This removed totally the Planet shaking bug!!! StelProjector::ModelViewTranformP transfo = core->getHeliocentricEclipticModelViewTransform(); transfo->combine(mat); // Compute the 2D position and check if in the screen const StelProjectorP prj = core->getProjection(transfo); float screenSz = getAngularSize(core)*M_PI/180.*prj->getPixelPerRadAtCenter(); float viewport_left = prj->getViewportPosX(); float viewport_bottom = prj->getViewportPosY(); if (prj->project(Vec3d(0), screenPos) && screenPos[1]>viewport_bottom - screenSz && screenPos[1] < viewport_bottom + prj->getViewportHeight()+screenSz && screenPos[0]>viewport_left - screenSz && screenPos[0] < viewport_left + prj->getViewportWidth() + screenSz) { // Draw the name, and the circle if it's not too close from the body it's turning around // this prevents name overlapping (ie for jupiter satellites) float ang_dist = 300.f*atan(getEclipticPos().length()/getEquinoxEquatorialPos(core).length())/core->getMovementMgr()->getCurrentFov(); // if (ang_dist==0.f) ang_dist = 1.f; // if ang_dist == 0, the Planet is sun.. --> GZ: we can remove it. // by putting here, only draw orbit if Comet is visible for clarity drawOrbit(core); // TODO - fade in here also... if (flagLabels && ang_dist>0.25 && maxMagLabels>getVMagnitude(core)) { labelsFader=true; } else { labelsFader=false; } drawHints(core, planetNameFont); draw3dModel(core,transfo,screenSz); } // tails should also be drawn if core is off-screen... drawTail(core,transfo,true); // gas tail drawTail(core,transfo,false); // dust tail //Coma: this is just a fan disk tilted towards the observer;-) drawComa(core, transfo); return; }
void BookmarksDialog::goToBookmark(QString uuid) { if (!uuid.isEmpty()) { bookmark bm = bookmarksCollection.value(uuid); if (!bm.jd.isEmpty()) { core->setJD(bm.jd.toDouble()); } if (!bm.location.isEmpty()) { StelLocationMgr* locationMgr = &StelApp::getInstance().getLocationMgr(); core->moveObserverTo(locationMgr->locationForString(bm.location)); } StelMovementMgr* mvmgr = GETSTELMODULE(StelMovementMgr); objectMgr->unSelect(); bool status = objectMgr->findAndSelect(bm.name); float amd = mvmgr->getAutoMoveDuration(); if (!bm.ra.isEmpty() && !bm.dec.isEmpty() && !status) { Vec3d pos; StelUtils::spheToRect(StelUtils::getDecAngle(bm.ra.trimmed()), StelUtils::getDecAngle(bm.dec.trimmed()), pos); if (bm.name.contains("marker", Qt::CaseInsensitive)) { // Add a custom object on the sky GETSTELMODULE(CustomObjectMgr)->addCustomObject(bm.name, pos, bm.isVisibleMarker); status = objectMgr->findAndSelect(bm.name); } else { // The unnamed stars StelObjectP sobj; const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000); double fov = 5.0; if (bm.fov > 0.0) fov = bm.fov; mvmgr->zoomTo(fov, 0.0); mvmgr->moveToJ2000(pos, mvmgr->mountFrameToJ2000(Vec3d(0., 0., 1.)), 0.0); QList<StelObjectP> candidates = GETSTELMODULE(StarMgr)->searchAround(pos, 0.5, core); if (candidates.empty()) // The FOV is too big, let's reduce it { mvmgr->zoomTo(0.5*fov, 0.0); candidates = GETSTELMODULE(StarMgr)->searchAround(pos, 0.5, core); } Vec3d winpos; prj->project(pos, winpos); float xpos = winpos[0]; float ypos = winpos[1]; float best_object_value = 1000.f; for (const auto& obj : candidates) { prj->project(obj->getJ2000EquatorialPos(core), winpos); float distance = std::sqrt((xpos-winpos[0])*(xpos-winpos[0]) + (ypos-winpos[1])*(ypos-winpos[1])); if (distance < best_object_value) { best_object_value = distance; sobj = obj; } } if (sobj) status = objectMgr->setSelectedObject(sobj); } } if (status) { const QList<StelObjectP> newSelected = objectMgr->getSelectedObject(); if (!newSelected.empty()) { mvmgr->moveToObject(newSelected[0], amd); mvmgr->setFlagTracking(true); } } } }
double StelGeodesicGridDrawer::draw(StelCore* core, int maxSearchLevel) { const StelProjectorP prj = core->getProjection(); StelPainter sPainter(prj); StelGeodesicGrid* geodesicGrid = core->getGeodesicGrid(); const GeodesicSearchResult* geodesic_search_result = geodesicGrid->search(prj->unprojectViewport(), maxSearchLevel); glDisable(GL_TEXTURE_2D); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Normal transparency mode core->setCurrentFrame(StelCore::FrameJ2000); // set 2D coordinate sPainter.setColor(0.2,0.3,0.2); int lev = (int)(7./pow(prj->getFov(), 0.4))+2; if (lev>geodesicGrid->getMaxLevel()) lev = geodesicGrid->getMaxLevel(); lev = maxSearchLevel; Vec3d win1, win2; int index; Vec3d v0, v1, v2; { GeodesicSearchInsideIterator it1(*geodesic_search_result, lev); while((index = it1.next()) >= 0) { Vec3d center(0); geodesicGrid->getTriangleCorners(lev, index, v0, v1, v2); prj->project(v0, win1); prj->project(v1, win2); center += win1; sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]); prj->project(v1, win1); prj->project(v2, win2); sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]); center += win1; prj->project(v2, win1); prj->project(v0, win2); sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]); center += win1; center*=0.33333; QString str = QString("%1 (%2)").arg(index) .arg(geodesicGrid->getPartnerTriangle(lev, index)); glEnable(GL_TEXTURE_2D); prj->drawText(font,center[0]-6, center[1]+6, str); glDisable(GL_TEXTURE_2D); } } GeodesicSearchBorderIterator it1(*geodesic_search_result, lev); while((index = it1.next()) >= 0) { Vec3d center(0); geodesicGrid->getTriangleCorners(lev, index, v0, v1, v2); prj->project(v0, win1); prj->project(v1, win2); center += win1; sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]); prj->project(v1, win1); prj->project(v2, win2); sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]); center += win1; prj->project(v2, win1); prj->project(v0, win2); sPainter.drawLine2d(win1[0],win1[1], win2[0],win2[1]); center += win1; center*=0.33333; QString str = QString("%1 (%2)").arg(index) .arg(geodesicGrid->getPartnerTriangle(lev, index)); glEnable(GL_TEXTURE_2D); prj->drawText(font,center[0]-6, center[1]+6, str); glDisable(GL_TEXTURE_2D); } return 0.; }