Stellarium/stellarium | Build 15291801018 | src/core/modules/NebulaMgr.cpp | Coveralls

59

void addEnglishOrAliasName(const NebulaP& nebula, const QString& name)

×

61

        const QString &currentName = nebula->getEnglishName();

×

62

        if (currentName.isEmpty()) // Set native name of DSO

×

63

                nebula->setEnglishName(name);

×

64

        else if (currentName != name) // Add traditional (well-known?) name of DSO as alias

×

65

                nebula->addNameAlias(name);

×

66

×

70

void NebulaMgr::setLabelsColor(const Vec3f& c) {Nebula::labelColor = c; emit labelsColorChanged(c);}

×

71

const Vec3f NebulaMgr::getLabelsColor(void) const {return Nebula::labelColor;}

×

72

void NebulaMgr::setCirclesColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebUnknown, c); emit circlesColorChanged(c); }

×

73

const Vec3f NebulaMgr::getCirclesColor(void) const {return Nebula::hintColorMap.value(Nebula::NebUnknown);}

×

74

void NebulaMgr::setRegionsColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebRegion, c); emit regionsColorChanged(c); }

×

75

const Vec3f NebulaMgr::getRegionsColor(void) const {return Nebula::hintColorMap.value(Nebula::NebRegion);}

×

76

void NebulaMgr::setGalaxyColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebGx, c); Nebula::hintColorMap.insert(Nebula::NebPartOfGx, c); emit galaxiesColorChanged(c); }

×

77

const Vec3f NebulaMgr::getGalaxyColor(void) const {return Nebula::hintColorMap.value(Nebula::NebGx);}

×

78

void NebulaMgr::setRadioGalaxyColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebRGx, c); emit radioGalaxiesColorChanged(c); }

×

79

const Vec3f NebulaMgr::getRadioGalaxyColor(void) const {return Nebula::hintColorMap.value(Nebula::NebRGx);}

×

80

void NebulaMgr::setActiveGalaxyColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebAGx, c); emit activeGalaxiesColorChanged(c); }

×

81

const Vec3f NebulaMgr::getActiveGalaxyColor(void) const {return Nebula::hintColorMap.value(Nebula::NebAGx);}

×

82

void NebulaMgr::setInteractingGalaxyColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebIGx, c); emit interactingGalaxiesColorChanged(c); }

×

83

const Vec3f NebulaMgr::getInteractingGalaxyColor(void) const {return Nebula::hintColorMap.value(Nebula::NebIGx);}

×

84

void NebulaMgr::setQuasarColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebQSO, c); emit quasarsColorChanged(c); }

×

85

const Vec3f NebulaMgr::getQuasarColor(void) const {return Nebula::hintColorMap.value(Nebula::NebQSO);}

×

86

void NebulaMgr::setNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebN, c); Nebula::hintColorMap.insert(Nebula::NebCn, c); emit nebulaeColorChanged(c); }

×

87

const Vec3f NebulaMgr::getNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebN);}

×

88

void NebulaMgr::setPlanetaryNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebPn, c); emit planetaryNebulaeColorChanged(c);}

×

89

const Vec3f NebulaMgr::getPlanetaryNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebPn);}

×

90

void NebulaMgr::setReflectionNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebRn, c); emit reflectionNebulaeColorChanged(c);}

×

91

const Vec3f NebulaMgr::getReflectionNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebRn);}

×

92

void NebulaMgr::setBipolarNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebBn, c); emit bipolarNebulaeColorChanged(c);}

×

93

const Vec3f NebulaMgr::getBipolarNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebBn);}

×

94

void NebulaMgr::setEmissionNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebEn, c); emit emissionNebulaeColorChanged(c);}

×

95

const Vec3f NebulaMgr::getEmissionNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebEn);}

×

96

void NebulaMgr::setDarkNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebDn, c); emit darkNebulaeColorChanged(c);}

×

97

const Vec3f NebulaMgr::getDarkNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebDn);}

×

98

void NebulaMgr::setHydrogenRegionColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebHII, c); emit hydrogenRegionsColorChanged(c);}

×

99

const Vec3f NebulaMgr::getHydrogenRegionColor(void) const {return Nebula::hintColorMap.value(Nebula::NebHII);}

×

100

void NebulaMgr::setSupernovaRemnantColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebSNR, c); emit supernovaRemnantsColorChanged(c);}

×

101

const Vec3f NebulaMgr::getSupernovaRemnantColor(void) const {return Nebula::hintColorMap.value(Nebula::NebSNR);}

×

102

void NebulaMgr::setSupernovaCandidateColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebSNC, c); emit supernovaCandidatesColorChanged(c);}

×

103

const Vec3f NebulaMgr::getSupernovaCandidateColor(void) const {return Nebula::hintColorMap.value(Nebula::NebSNC);}

×

104

void NebulaMgr::setSupernovaRemnantCandidateColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebSNRC, c); emit supernovaRemnantCandidatesColorChanged(c);}

×

105

const Vec3f NebulaMgr::getSupernovaRemnantCandidateColor(void) const {return Nebula::hintColorMap.value(Nebula::NebSNRC);}

×

106

void NebulaMgr::setInterstellarMatterColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebISM, c); emit interstellarMatterColorChanged(c);}

×

107

const Vec3f NebulaMgr::getInterstellarMatterColor(void) const {return Nebula::hintColorMap.value(Nebula::NebISM);}

×

108

void NebulaMgr::setClusterColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebCl, c); emit clustersColorChanged(c);}

×

109

const Vec3f NebulaMgr::getClusterColor(void) const {return Nebula::hintColorMap.value(Nebula::NebCl);}

×

110

void NebulaMgr::setOpenClusterColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebOc, c); emit openClustersColorChanged(c);}

×

111

const Vec3f NebulaMgr::getOpenClusterColor(void) const {return Nebula::hintColorMap.value(Nebula::NebOc);}

×

112

void NebulaMgr::setGlobularClusterColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebGc, c); emit globularClustersColorChanged(c);}

×

113

const Vec3f NebulaMgr::getGlobularClusterColor(void) const {return Nebula::hintColorMap.value(Nebula::NebGc);}

×

114

void NebulaMgr::setStellarAssociationColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebSA, c); emit stellarAssociationsColorChanged(c);}

×

115

const Vec3f NebulaMgr::getStellarAssociationColor(void) const {return Nebula::hintColorMap.value(Nebula::NebSA);}

×

116

void NebulaMgr::setStarCloudColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebSC, c); emit starCloudsColorChanged(c);}

×

117

const Vec3f NebulaMgr::getStarCloudColor(void) const {return Nebula::hintColorMap.value(Nebula::NebSC);}

×

118

void NebulaMgr::setEmissionObjectColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebEMO, c); emit emissionObjectsColorChanged(c);}

×

119

const Vec3f NebulaMgr::getEmissionObjectColor(void) const {return Nebula::hintColorMap.value(Nebula::NebEMO);}

×

120

void NebulaMgr::setBlLacObjectColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebBLL, c); emit blLacObjectsColorChanged(c);}

×

121

const Vec3f NebulaMgr::getBlLacObjectColor(void) const {return Nebula::hintColorMap.value(Nebula::NebBLL);}

×

122

void NebulaMgr::setBlazarColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebBLA, c); emit blazarsColorChanged(c);}

×

123

const Vec3f NebulaMgr::getBlazarColor(void) const {return Nebula::hintColorMap.value(Nebula::NebBLA);}

×

124

void NebulaMgr::setMolecularCloudColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebMolCld, c); emit molecularCloudsColorChanged(c);}

×

125

const Vec3f NebulaMgr::getMolecularCloudColor(void) const {return Nebula::hintColorMap.value(Nebula::NebMolCld);}

×

126

void NebulaMgr::setYoungStellarObjectColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebYSO, c); emit youngStellarObjectsColorChanged(c);}

×

127

const Vec3f NebulaMgr::getYoungStellarObjectColor(void) const {return Nebula::hintColorMap.value(Nebula::NebYSO);}

×

128

void NebulaMgr::setPossibleQuasarColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebPossQSO, c); emit possibleQuasarsColorChanged(c);}

×

129

const Vec3f NebulaMgr::getPossibleQuasarColor(void) const {return Nebula::hintColorMap.value(Nebula::NebPossQSO);}

×

130

void NebulaMgr::setPossiblePlanetaryNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebPossPN, c); emit possiblePlanetaryNebulaeColorChanged(c);}

×

131

const Vec3f NebulaMgr::getPossiblePlanetaryNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebPossPN);}

×

132

void NebulaMgr::setProtoplanetaryNebulaColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebPPN, c); emit protoplanetaryNebulaeColorChanged(c);}

×

133

const Vec3f NebulaMgr::getProtoplanetaryNebulaColor(void) const {return Nebula::hintColorMap.value(Nebula::NebPPN);}

×

134

void NebulaMgr::setStarColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebStar, c); emit starsColorChanged(c);}

×

135

const Vec3f NebulaMgr::getStarColor(void) const {return Nebula::hintColorMap.value(Nebula::NebStar);}

×

136

void NebulaMgr::setSymbioticStarColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebSymbioticStar, c); emit symbioticStarsColorChanged(c);}

×

137

const Vec3f NebulaMgr::getSymbioticStarColor(void) const {return Nebula::hintColorMap.value(Nebula::NebSymbioticStar);}

×

138

void NebulaMgr::setEmissionLineStarColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebEmissionLineStar, c); emit emissionLineStarsColorChanged(c);}

×

139

const Vec3f NebulaMgr::getEmissionLineStarColor(void) const {return Nebula::hintColorMap.value(Nebula::NebEmissionLineStar);}

×

140

void NebulaMgr::setGalaxyClusterColor(const Vec3f& c) {Nebula::hintColorMap.insert(Nebula::NebGxCl, c); emit galaxyClustersColorChanged(c);}

×

141

const Vec3f NebulaMgr::getGalaxyClusterColor(void) const {return Nebula::hintColorMap.value(Nebula::NebGxCl);}

×

143

bool NebulaMgr::getHintsProportional(void) const {return Nebula::drawHintProportional;}

×

144

void NebulaMgr::setHintsProportional(const bool proportional)

×

146

        if(Nebula::drawHintProportional!=proportional)

×

148

                Nebula::drawHintProportional=proportional;

×

149

                StelApp::immediateSave("astro/flag_nebula_hints_proportional", proportional);

×

150

                emit hintsProportionalChanged(proportional);

×

152

×

154

bool NebulaMgr::getDesignationUsage(void) const {return Nebula::designationUsage; }

×

155

void NebulaMgr::setDesignationUsage(const bool flag)

×

157

        if(Nebula::designationUsage!=flag)

×

159

                Nebula::designationUsage=flag;

×

160

                StelApp::immediateSave("astro/flag_dso_designation_usage", flag);

×

161

                emit designationUsageChanged(flag);

×

163

×

164

bool NebulaMgr::getFlagAdditionalNames(void) const {return Nebula::flagShowAdditionalNames;}

×

165

void NebulaMgr::setFlagAdditionalNames(const bool flag)

×

167

        if(Nebula::flagShowAdditionalNames!=flag)

×

169

                Nebula::flagShowAdditionalNames=flag;

×

170

                StelApp::immediateSave("astro/flag_dso_additional_names", flag);

×

171

                emit flagAdditionalNamesDisplayedChanged(flag);

×

173

×

175

bool NebulaMgr::getFlagOutlines(void) const {return Nebula::flagUseOutlines;}

×

176

void NebulaMgr::setFlagOutlines(const bool flag)

×

178

        if(Nebula::flagUseOutlines!=flag)

×

180

                Nebula::flagUseOutlines=flag;

×

181

                StelApp::immediateSave("astro/flag_dso_outlines_usage", flag);

×

182

                emit flagOutlinesDisplayedChanged(flag);

×

184

×

186

bool NebulaMgr::getFlagShowOnlyNamedDSO(void) const {return Nebula::flagShowOnlyNamedDSO; }

×

187

void NebulaMgr::setFlagShowOnlyNamedDSO(const bool flag)

×

189

        if(Nebula::flagShowOnlyNamedDSO!=flag)

×

191

                Nebula::flagShowOnlyNamedDSO=flag;

×

192

                StelApp::immediateSave("astro/flag_dso_show_only_named", flag);

×

193

                emit flagShowOnlyNamedDSOChanged(flag);

×

195

×

197

NebulaMgr::NebulaMgr(void) : StelObjectModule()

×

198

        , nebGrid(200)

×

199

        , hintsAmount(0)

×

200

        , labelsAmount(0)

×

201

        , hintsBrightness(1.0)

×

202

        , labelsBrightness(1.0)

×

203

        , flagConverter(false)

×

204

        , flagDecimalCoordinates(true)

×

206

        setObjectName("NebulaMgr");

×

207

×

209

NebulaMgr::~NebulaMgr()

×

211

        Nebula::texRegion = StelTextureSP();

×

212

        Nebula::texPointElement = StelTextureSP();

×

213

        Nebula::texPlanetaryNebula = StelTextureSP();

×

214

×

219

double NebulaMgr::getCallOrder(StelModuleActionName actionName) const

×

221

        if (actionName==StelModule::ActionDraw)

×

222

                return StelApp::getInstance().getModuleMgr().getModule("MilkyWay")->getCallOrder(actionName)+10;

×

223

        return 0;

×

227

void NebulaMgr::init()

×

229

        QSettings* conf = StelApp::getInstance().getSettings();

×

230

        Q_ASSERT(conf);

×

232

        nebulaFont.setPixelSize(StelApp::getInstance().getScreenFontSize());

×

233

        connect(&StelApp::getInstance(), SIGNAL(screenFontSizeChanged(int)), SLOT(setFontSizeFromApp(int)));

×

234

    auto& texMan = StelApp::getInstance().getTextureManager();

×

236

        Nebula::texRegion                = texMan.createTexture(StelFileMgr::getInstallationDir()+"/textures/neb_reg.png");

×

238

        Nebula::texPointElement                = texMan.createTexture(StelFileMgr::getInstallationDir()+"/textures/neb_point_elem.png");

×

240

        Nebula::texPlanetaryNebula        = texMan.createTexture(StelFileMgr::getInstallationDir()+"/textures/neb_pnb.png");

×

242

        texPointer = texMan.createTexture(StelFileMgr::getInstallationDir()+"/textures/pointeur5.png");

×

244

        setFlagShow(conf->value("astro/flag_nebula",true).toBool());

×

245

        setFlagHints(conf->value("astro/flag_nebula_name",false).toBool());

×

246

        setHintsAmount(conf->value("astro/nebula_hints_amount", 3.0).toDouble());

×

247

        setLabelsAmount(conf->value("astro/nebula_labels_amount", 3.0).toDouble());

×

248

        setHintsProportional(conf->value("astro/flag_nebula_hints_proportional", false).toBool());

×

249

        setFlagOutlines(conf->value("astro/flag_dso_outlines_usage", false).toBool());

×

250

        setFlagAdditionalNames(conf->value("astro/flag_dso_additional_names",true).toBool());

×

251

        setDesignationUsage(conf->value("astro/flag_dso_designation_usage", false).toBool());

×

252

        setFlagSurfaceBrightnessUsage(conf->value("astro/flag_surface_brightness_usage", false).toBool());

×

253

        setFlagSurfaceBrightnessArcsecUsage(conf->value("gui/flag_surface_brightness_arcsec", false).toBool());

×

254

        setFlagSurfaceBrightnessShortNotationUsage(conf->value("gui/flag_surface_brightness_short", false).toBool());

×

255

        setFlagShowOnlyNamedDSO(conf->value("astro/flag_dso_show_only_named", false).toBool());

×

257

        setFlagSizeLimitsUsage(conf->value("astro/flag_size_limits_usage", false).toBool());

×

258

        setMinSizeLimit(conf->value("astro/size_limit_min", 1.0).toDouble());

×

259

        setMaxSizeLimit(conf->value("astro/size_limit_max", 600.0).toDouble());

×

263

        if (conf->contains("color/nebula_label_color"))

×

265

                conf->setValue("color/dso_label_color", conf->value("color/nebula_label_color", "0.4,0.3,0.5").toString());

×

266

                conf->remove("color/nebula_label_color");

×

268

        if (conf->contains("color/nebula_circle_color"))

×

270

                conf->setValue("color/dso_circle_color", conf->value("color/nebula_circle_color", "0.8,0.8,0.1").toString());

×

271

                conf->remove("color/nebula_circle_color");

×

273

        if (conf->contains("color/nebula_galaxy_color"))

×

275

                conf->setValue("color/dso_galaxy_color", conf->value("color/nebula_galaxy_color", "1.0,0.2,0.2").toString());

×

276

                conf->remove("color/nebula_galaxy_color");

×

278

        if (conf->contains("color/nebula_radioglx_color"))

×

280

                conf->setValue("color/dso_radio_galaxy_color", conf->value("color/nebula_radioglx_color", "0.3,0.3,0.3").toString());

×

281

                conf->remove("color/nebula_radioglx_color");

×

283

        if (conf->contains("color/nebula_activeglx_color"))

×

285

                conf->setValue("color/dso_active_galaxy_color", conf->value("color/nebula_activeglx_color", "1.0,0.5,0.2").toString());

×

286

                conf->remove("color/nebula_activeglx_color");

×

288

        if (conf->contains("color/nebula_intglx_color"))

×

290

                conf->setValue("color/dso_interacting_galaxy_color", conf->value("color/nebula_intglx_color", "0.2,0.5,1.0").toString());

×

291

                conf->remove("color/nebula_intglx_color");

×

293

        if (conf->contains("color/nebula_brightneb_color"))

×

295

                conf->setValue("color/dso_nebula_color", conf->value("color/nebula_brightneb_color", "0.1,1.0,0.1").toString());

×

296

                conf->remove("color/nebula_brightneb_color");

×

298

        if (conf->contains("color/nebula_darkneb_color"))

×

300

                conf->setValue("color/dso_dark_nebula_color", conf->value("color/nebula_darkneb_color", "0.3,0.3,0.3").toString());

×

301

                conf->remove("color/nebula_darkneb_color");

×

303

        if (conf->contains("color/nebula_hregion_color"))

×

305

                conf->setValue("color/dso_hydrogen_region_color", conf->value("color/nebula_hregion_color", "0.1,1.0,0.1").toString());

×

306

                conf->remove("color/nebula_hregion_color");

×

308

        if (conf->contains("color/nebula_snr_color"))

×

310

                conf->setValue("color/dso_supernova_remnant_color", conf->value("color/nebula_snr_color", "0.1,1.0,0.1").toString());

×

311

                conf->remove("color/nebula_snr_color");

×

313

        if (conf->contains("color/nebula_cluster_color"))

×

315

                conf->setValue("color/dso_cluster_color", conf->value("color/nebula_cluster_color", "0.8,0.8,0.1").toString());

×

316

                conf->remove("color/nebula_cluster_color");

×

320

        setLabelsBrightness(conf->value("astro/nebula_labels_brightness", "1.0").toDouble());

×

321

        setHintsBrightness(conf->value("astro/nebula_hints_brightness", "1.0").toDouble());

×

322

        setLabelsColor(Vec3f(conf->value("color/dso_label_color", "0.2,0.6,0.7").toString()));

×

323

        setCirclesColor(Vec3f(conf->value("color/dso_circle_color", "1.0,0.7,0.2").toString()));

×

324

        setRegionsColor(Vec3f(conf->value("color/dso_region_color", "0.7,0.7,0.2").toString()));

×

326

        QString defaultGalaxyColor = conf->value("color/dso_galaxy_color", "1.0,0.2,0.2").toString();

×

327

        setGalaxyColor(           Vec3f(defaultGalaxyColor));

×

328

        setRadioGalaxyColor(      Vec3f(conf->value("color/dso_radio_galaxy_color", "0.3,0.3,0.3").toString()));

×

329

        setActiveGalaxyColor(     Vec3f(conf->value("color/dso_active_galaxy_color", "1.0,0.5,0.2").toString()));

×

330

        setInteractingGalaxyColor(Vec3f(conf->value("color/dso_interacting_galaxy_color", "0.2,0.5,1.0").toString()));

×

331

        setGalaxyClusterColor(    Vec3f(conf->value("color/dso_galaxy_cluster_color", "0.2,0.8,1.0").toString()));

×

332

        setQuasarColor(           Vec3f(conf->value("color/dso_quasar_color", defaultGalaxyColor).toString()));

×

333

        setPossibleQuasarColor(   Vec3f(conf->value("color/dso_possible_quasar_color", defaultGalaxyColor).toString()));

×

334

        setBlLacObjectColor(      Vec3f(conf->value("color/dso_bl_lac_color", defaultGalaxyColor).toString()));

×

335

        setBlazarColor(           Vec3f(conf->value("color/dso_blazar_color", defaultGalaxyColor).toString()));

×

337

        QString defaultNebulaColor = conf->value("color/dso_nebula_color", "0.1,1.0,0.1").toString();

×

338

        setNebulaColor(                   Vec3f(defaultNebulaColor));

×

339

        setPlanetaryNebulaColor(          Vec3f(conf->value("color/dso_planetary_nebula_color", defaultNebulaColor).toString()));

×

340

        setReflectionNebulaColor(         Vec3f(conf->value("color/dso_reflection_nebula_color", defaultNebulaColor).toString()));

×

341

        setBipolarNebulaColor(            Vec3f(conf->value("color/dso_bipolar_nebula_color", defaultNebulaColor).toString()));

×

342

        setEmissionNebulaColor(           Vec3f(conf->value("color/dso_emission_nebula_color", defaultNebulaColor).toString()));

×

343

        setDarkNebulaColor(               Vec3f(conf->value("color/dso_dark_nebula_color", "0.3,0.3,0.3").toString()));

×

344

        setHydrogenRegionColor(           Vec3f(conf->value("color/dso_hydrogen_region_color", defaultNebulaColor).toString()));

×

345

        setSupernovaRemnantColor(         Vec3f(conf->value("color/dso_supernova_remnant_color", defaultNebulaColor).toString()));

×

346

        setSupernovaCandidateColor(       Vec3f(conf->value("color/dso_supernova_candidate_color", defaultNebulaColor).toString()));

×

347

        setSupernovaRemnantCandidateColor(Vec3f(conf->value("color/dso_supernova_remnant_cand_color", defaultNebulaColor).toString()));

×

348

        setInterstellarMatterColor(       Vec3f(conf->value("color/dso_interstellar_matter_color", defaultNebulaColor).toString()));

×

349

        setMolecularCloudColor(           Vec3f(conf->value("color/dso_molecular_cloud_color", defaultNebulaColor).toString()));

×

350

        setPossiblePlanetaryNebulaColor(  Vec3f(conf->value("color/dso_possible_planetary_nebula_color", defaultNebulaColor).toString()));

×

351

        setProtoplanetaryNebulaColor(     Vec3f(conf->value("color/dso_protoplanetary_nebula_color", defaultNebulaColor).toString()));

×

353

        QString defaultClusterColor = conf->value("color/dso_cluster_color", "1.0,1.0,0.1").toString();

×

354

        setClusterColor(           Vec3f(defaultClusterColor));

×

355

        setOpenClusterColor(       Vec3f(conf->value("color/dso_open_cluster_color", defaultClusterColor).toString()));

×

356

        setGlobularClusterColor(   Vec3f(conf->value("color/dso_globular_cluster_color", defaultClusterColor).toString()));

×

357

        setStellarAssociationColor(Vec3f(conf->value("color/dso_stellar_association_color", defaultClusterColor).toString()));

×

358

        setStarCloudColor(         Vec3f(conf->value("color/dso_star_cloud_color", defaultClusterColor).toString()));

×

360

        QString defaultStellarColor = conf->value("color/dso_star_color", "1.0,0.7,0.2").toString();

×

361

        setStarColor(              Vec3f(defaultStellarColor));

×

362

        setSymbioticStarColor(     Vec3f(conf->value("color/dso_symbiotic_star_color", defaultStellarColor).toString()));

×

363

        setEmissionLineStarColor(  Vec3f(conf->value("color/dso_emission_star_color", defaultStellarColor).toString()));

×

364

        setEmissionObjectColor(    Vec3f(conf->value("color/dso_emission_object_color", defaultStellarColor).toString()));

×

365

        setYoungStellarObjectColor(Vec3f(conf->value("color/dso_young_stellar_object_color", defaultStellarColor).toString()));

×

368

        QMetaEnum nType=QMetaEnum::fromType<Nebula::NebulaType>();

×

369

        for(int t=0; t<nType.keyCount(); t++)

×

371

                if (!Nebula::hintColorMap.contains(static_cast<Nebula::NebulaType>(nType.value(t))))

×

372

                                qDebug() << "No color assigned to Nebula Type " << nType.key(t) << ". Please report as bug!";

×

376

        flagConverter = conf->value("devel/convert_dso_catalog", false).toBool();

×

377

        flagDecimalCoordinates = conf->value("devel/convert_dso_decimal_coord", true).toBool();

×

379

        setFlagUseTypeFilters(conf->value("astro/flag_use_type_filter", false).toBool());

×

381

        loadCatalogFilters();

×

383

        Nebula::TypeGroup typeFilters = Nebula::TypeGroup(Nebula::TypeNone);

×

385

        conf->beginGroup("dso_type_filters");

×

386

        if (conf->value("flag_show_galaxies", true).toBool())

×

387

                typeFilters        |= Nebula::TypeGalaxies;

×

388

        if (conf->value("flag_show_active_galaxies", true).toBool())

×

389

                typeFilters        |= Nebula::TypeActiveGalaxies;

×

390

        if (conf->value("flag_show_interacting_galaxies", true).toBool())

×

391

                typeFilters        |= Nebula::TypeInteractingGalaxies;

×

392

        if (conf->value("flag_show_open_clusters", true).toBool())

×

393

                typeFilters        |= Nebula::TypeOpenStarClusters;

×

394

        if (conf->value("flag_show_globular_clusters", true).toBool())

×

395

                typeFilters        |= Nebula::TypeGlobularStarClusters;

×

396

        if (conf->value("flag_show_bright_nebulae", true).toBool())

×

397

                typeFilters        |= Nebula::TypeBrightNebulae;

×

398

        if (conf->value("flag_show_dark_nebulae", true).toBool())

×

399

                typeFilters        |= Nebula::TypeDarkNebulae;

×

400

        if (conf->value("flag_show_planetary_nebulae", true).toBool())

×

401

                typeFilters        |= Nebula::TypePlanetaryNebulae;

×

402

        if (conf->value("flag_show_hydrogen_regions", true).toBool())

×

403

                typeFilters        |= Nebula::TypeHydrogenRegions;

×

404

        if (conf->value("flag_show_supernova_remnants", true).toBool())

×

405

                typeFilters        |= Nebula::TypeSupernovaRemnants;

×

406

        if (conf->value("flag_show_galaxy_clusters", true).toBool())

×

407

                typeFilters        |= Nebula::TypeGalaxyClusters;

×

408

        if (conf->value("flag_show_other", true).toBool())

×

409

                typeFilters        |= Nebula::TypeOther;

×

410

        conf->endGroup();

×

412

        setTypeFilters(typeFilters);

×

415

        const QString nebulaSetName=conf->value("astro/nebula_set", "default").toString();

×

418

        const QString allSetsUnwantedRefsRaw = conf->value("astro/nebula_exclude_references").toString(); // Later: read this from config.ini. Syntax: "setName:unrefA,unrefB,..."

×

419

        QString allUnwantedReferencesFromOneSetRaw;

×

420

        if (allSetsUnwantedRefsRaw.contains(';'))

×

424

                QStringList allSetsUnwantedRefs=allSetsUnwantedRefsRaw.split(';', Qt::SkipEmptyParts);

×

428

                foreach (const QString &entry, allSetsUnwantedRefs)

×

430

                        QStringList oneSetList=entry.split(':');

×

431

                        if (oneSetList.length()==2 && oneSetList.at(0)==nebulaSetName)

×

433

                                allUnwantedReferencesFromOneSetRaw=oneSetList.at(1); // Now this has the packed list without nebulaSet name

×

434

                                break;

×

436

×

437

                if (allUnwantedReferencesFromOneSetRaw.isEmpty())

×

439

                        qInfo() << "NebulaMgr: FYI: No references found to be excluded for set" << nebulaSetName;

×

441

×

442

        else if (allSetsUnwantedRefsRaw.contains(':'))

×

445

                allUnwantedReferencesFromOneSetRaw=allSetsUnwantedRefsRaw.section(':', 1, 1);

×

448

                allUnwantedReferencesFromOneSetRaw=allSetsUnwantedRefsRaw;

×

451

        unwantedReferences=allUnwantedReferencesFromOneSetRaw.split(',', Qt::SkipEmptyParts);

×

455

        if (!unwantedReferences.isEmpty()) // Do not show unwanted references when they does not defined

×

456

                qInfo() << "NebulaMgr: Unwanted References:" << unwantedReferences;

×

458

        loadNebulaSet(nebulaSetName);

×

460

        updateI18n();

×

462

        StelApp *app = &StelApp::getInstance();

×

463

        connect(app, SIGNAL(languageChanged()), this, SLOT(updateI18n()));

×

464

        connect(&app->getSkyCultureMgr(), &StelSkyCultureMgr::currentSkyCultureChanged, this, &NebulaMgr::updateSkyCulture);

×

465

        GETSTELMODULE(StelObjectMgr)->registerStelObjectMgr(this);

×

467

        addAction("actionShow_Nebulas", N_("Display Options"), N_("Deep-sky objects"), "flagHintDisplayed", "D", "N");

×

468

        addAction("actionSet_Nebula_TypeFilterUsage", N_("Display Options"), N_("Toggle DSO type filter"), "flagTypeFiltersUsage");

×

469

×

471

void NebulaMgr::selectAllCatalogs()

×

473

        setCatalogFilters(Nebula::CatAll);

×

474

×

476

void NebulaMgr::selectStandardCatalogs()

×

478

        Nebula::CatalogGroup catalogs = Nebula::CatNone;

×

479

        catalogs |= Nebula::CatNGC;

×

480

        catalogs |= Nebula::CatIC;

×

481

        catalogs |= Nebula::CatM;

×

482

        setCatalogFilters(catalogs);

×

483

×

485

void NebulaMgr::selectNoneCatalogs()

×

487

        setCatalogFilters(Nebula::CatNone);

×

488

×

490

void NebulaMgr::loadCatalogFilters()

×

492

        QSettings* conf = StelApp::getInstance().getSettings();

×

493

        Q_ASSERT(conf);

×

495

        Nebula::CatalogGroup catalogFilters = Nebula::CatalogGroup(Nebula::CatNone);

×

497

        conf->beginGroup("dso_catalog_filters");

×

498

        if (conf->value("flag_show_ngc", true).toBool())

×

499

                catalogFilters        |= Nebula::CatNGC;

×

500

        if (conf->value("flag_show_ic", true).toBool())

×

501

                catalogFilters        |= Nebula::CatIC;

×

502

        if (conf->value("flag_show_m", true).toBool())

×

503

                catalogFilters        |= Nebula::CatM;

×

504

        if (conf->value("flag_show_c", false).toBool())

×

505

                catalogFilters        |= Nebula::CatC;

×

506

        if (conf->value("flag_show_b", false).toBool())

×

507

                catalogFilters        |= Nebula::CatB;

×

508

        if (conf->value("flag_show_sh2", false).toBool())

×

509

                catalogFilters        |= Nebula::CatSh2;

×

510

        if (conf->value("flag_show_vdb", false).toBool())

×

511

                catalogFilters        |= Nebula::CatVdB;

×

512

        if (conf->value("flag_show_lbn", false).toBool())

×

513

                catalogFilters        |= Nebula::CatLBN;

×

514

        if (conf->value("flag_show_ldn", false).toBool())

×

515

                catalogFilters        |= Nebula::CatLDN;

×

516

        if (conf->value("flag_show_rcw", false).toBool())

×

517

                catalogFilters        |= Nebula::CatRCW;

×

518

        if (conf->value("flag_show_cr", false).toBool())

×

519

                catalogFilters        |= Nebula::CatCr;

×

520

        if (conf->value("flag_show_mel", false).toBool())

×

521

                catalogFilters        |= Nebula::CatMel;

×

522

        if (conf->value("flag_show_pgc", false).toBool())

×

523

                catalogFilters        |= Nebula::CatPGC;

×

524

        if (conf->value("flag_show_ced", false).toBool())

×

525

                catalogFilters        |= Nebula::CatCed;

×

526

        if (conf->value("flag_show_ugc", false).toBool())

×

527

                catalogFilters        |= Nebula::CatUGC;

×

528

        if (conf->value("flag_show_arp", false).toBool())

×

529

                catalogFilters        |= Nebula::CatArp;

×

530

        if (conf->value("flag_show_vv", false).toBool())

×

531

                catalogFilters        |= Nebula::CatVV;

×

532

        if (conf->value("flag_show_pk", false).toBool())

×

533

                catalogFilters        |= Nebula::CatPK;

×

534

        if (conf->value("flag_show_png", false).toBool())

×

535

                catalogFilters        |= Nebula::CatPNG;

×

536

        if (conf->value("flag_show_snrg", false).toBool())

×

537

                catalogFilters        |= Nebula::CatSNRG;

×

538

        if (conf->value("flag_show_aco", false).toBool())

×

539

                catalogFilters        |= Nebula::CatACO;

×

540

        if (conf->value("flag_show_hcg", false).toBool())

×

541

                catalogFilters        |= Nebula::CatHCG;

×

542

        if (conf->value("flag_show_eso", false).toBool())

×

543

                catalogFilters        |= Nebula::CatESO;

×

544

        if (conf->value("flag_show_vdbh", false).toBool())

×

545

                catalogFilters        |= Nebula::CatVdBH;

×

546

        if (conf->value("flag_show_dwb", false).toBool())

×

547

                catalogFilters        |= Nebula::CatDWB;

×

548

        if (conf->value("flag_show_tr", false).toBool())

×

549

                catalogFilters        |= Nebula::CatTr;

×

550

        if (conf->value("flag_show_st", false).toBool())

×

551

                catalogFilters        |= Nebula::CatSt;

×

552

        if (conf->value("flag_show_ru", false).toBool())

×

553

                catalogFilters        |= Nebula::CatRu;

×

554

        if (conf->value("flag_show_vdbha", false).toBool())

×

555

                catalogFilters        |= Nebula::CatVdBHa;

×

556

        if (conf->value("flag_show_other", true).toBool())

×

557

                catalogFilters        |= Nebula::CatOther;

×

558

        conf->endGroup();

×

561

        setCatalogFilters(int(catalogFilters));

×

562

×

564

void NebulaMgr::storeCatalogFilters()

×

566

        QSettings* conf = StelApp::getInstance().getSettings();

×

567

        Q_ASSERT(conf);

×

570

        const Nebula::CatalogGroup cflags = static_cast<Nebula::CatalogGroup>(getCatalogFilters());

×

572

        conf->beginGroup("dso_catalog_filters");

×

573

        conf->setValue("flag_show_ngc",                static_cast<bool>(cflags & Nebula::CatNGC));

×

574

        conf->setValue("flag_show_ic",                static_cast<bool>(cflags & Nebula::CatIC));

×

575

        conf->setValue("flag_show_m",                static_cast<bool>(cflags & Nebula::CatM));

×

576

        conf->setValue("flag_show_c",                static_cast<bool>(cflags & Nebula::CatC));

×

577

        conf->setValue("flag_show_b",                static_cast<bool>(cflags & Nebula::CatB));

×

578

        conf->setValue("flag_show_vdb",                static_cast<bool>(cflags & Nebula::CatVdB));

×

579

        conf->setValue("flag_show_sh2",                static_cast<bool>(cflags & Nebula::CatSh2));

×

580

        conf->setValue("flag_show_rcw",                static_cast<bool>(cflags & Nebula::CatRCW));

×

581

        conf->setValue("flag_show_lbn",                static_cast<bool>(cflags & Nebula::CatLBN));

×

582

        conf->setValue("flag_show_ldn",                static_cast<bool>(cflags & Nebula::CatLDN));

×

583

        conf->setValue("flag_show_cr",                static_cast<bool>(cflags & Nebula::CatCr));

×

584

        conf->setValue("flag_show_mel",                static_cast<bool>(cflags & Nebula::CatMel));

×

585

        conf->setValue("flag_show_ced",                static_cast<bool>(cflags & Nebula::CatCed));

×

586

        conf->setValue("flag_show_pgc",                static_cast<bool>(cflags & Nebula::CatPGC));

×

587

        conf->setValue("flag_show_ugc",                static_cast<bool>(cflags & Nebula::CatUGC));

×

588

        conf->setValue("flag_show_arp",                static_cast<bool>(cflags & Nebula::CatArp));

×

589

        conf->setValue("flag_show_vv",                static_cast<bool>(cflags & Nebula::CatVV));

×

590

        conf->setValue("flag_show_pk",                static_cast<bool>(cflags & Nebula::CatPK));

×

591

        conf->setValue("flag_show_png",                static_cast<bool>(cflags & Nebula::CatPNG));

×

592

        conf->setValue("flag_show_snrg",                static_cast<bool>(cflags & Nebula::CatSNRG));

×

593

        conf->setValue("flag_show_aco",                static_cast<bool>(cflags & Nebula::CatACO));

×

594

        conf->setValue("flag_show_hcg",                static_cast<bool>(cflags & Nebula::CatHCG));

×

595

        conf->setValue("flag_show_eso",                static_cast<bool>(cflags & Nebula::CatESO));

×

596

        conf->setValue("flag_show_vdbh",                static_cast<bool>(cflags & Nebula::CatVdBH));

×

597

        conf->setValue("flag_show_dwb",                static_cast<bool>(cflags & Nebula::CatDWB));

×

598

        conf->setValue("flag_show_tr",                static_cast<bool>(cflags & Nebula::CatTr));

×

599

        conf->setValue("flag_show_st",                static_cast<bool>(cflags & Nebula::CatSt));

×

600

        conf->setValue("flag_show_ru",                static_cast<bool>(cflags & Nebula::CatRu));

×

601

        conf->setValue("flag_show_vdbha",        static_cast<bool>(cflags & Nebula::CatVdBHa));

×

602

        conf->setValue("flag_show_other",                static_cast<bool>(cflags & Nebula::CatOther));

×

603

        conf->endGroup();

×

604

×

608

        DrawNebulaFuncObject(float amaxMagHints, float amaxMagLabels, StelPainter* p, StelCore* aCore, bool acheckMaxMagHints)

×

609

                : maxMagHints(amaxMagHints)

×

610

                , maxMagLabels(amaxMagLabels)

×

611

                , sPainter(p)

×

612

                , core(aCore)

×

613

                , checkMaxMagHints(acheckMaxMagHints)

×

615

                angularSizeLimit = 5.f/sPainter->getProjector()->getPixelPerRadAtCenter()*M_180_PIf;

×

616

×

617

        void operator()(StelRegionObject* obj)

×

619

                if (checkMaxMagHints)

×

620

                        return;

×

622

                Nebula* n = static_cast<Nebula*>(obj);

×

623

                if (!n->objectInDisplayedCatalog())

×

UNCOV

624

                        return;

×

UNCOV

626

                if (n->flagShowOnlyNamedDSO && n->getEnglishName().isEmpty() && n->culturalNames.isEmpty())

×

627

                        return;

×

UNCOV

629

                if (!n->objectInAllowedSizeRangeLimits())

×

630

                        return;

×

UNCOV

632

                float mag=n->getVisibilityLevelByMagnitude();

×

633

                StelSkyDrawer *drawer = core->getSkyDrawer();

×

UNCOV

635

                if ((drawer->getFlagNebulaMagnitudeLimit()) && (mag > static_cast<float>(drawer->getCustomNebulaMagnitudeLimit())))

×

636

                        return;

×

UNCOV

638

                if (n->majorAxisSize>angularSizeLimit || n->majorAxisSize==0.f || mag <= maxMagHints)

×

UNCOV

640

                        sPainter->getProjector()->project(n->getJ2000EquatorialPos(core),n->XY);

×

641

                        n->drawLabel(*sPainter, maxMagLabels);

×

642

                        n->drawHints(*sPainter, maxMagHints, core);

×

643

                        n->drawOutlines(*sPainter, maxMagHints);

×

UNCOV

654

void NebulaMgr::setCatalogFilters(int cflags)

×

UNCOV

656

        if(cflags != static_cast<int>(Nebula::catalogFilters))

×

UNCOV

658

                Nebula::catalogFilters = static_cast<Nebula::CatalogGroup>(cflags);

×

659

                emit catalogFiltersChanged(cflags);

×

UNCOV

661

×

UNCOV

663

void NebulaMgr::setTypeFilters(int tflags)

×

UNCOV

665

        if(tflags != static_cast<int>(Nebula::typeFilters))

×

UNCOV

667

                Nebula::typeFilters = static_cast<Nebula::TypeGroup>(tflags);

×

668

                emit typeFiltersChanged(tflags);

×

UNCOV

670

×

UNCOV

672

void NebulaMgr::setFlagSurfaceBrightnessUsage(const bool usage)

×

UNCOV

674

        if (usage!=Nebula::surfaceBrightnessUsage)

×

UNCOV

676

                Nebula::surfaceBrightnessUsage=usage;

×

677

                StelApp::immediateSave("astro/flag_surface_brightness_usage", Nebula::surfaceBrightnessUsage);

×

678

                emit flagSurfaceBrightnessUsageChanged(usage);

×

UNCOV

680

×

UNCOV

682

bool NebulaMgr::getFlagSurfaceBrightnessUsage(void) const

×

UNCOV

684

        return Nebula::surfaceBrightnessUsage;

×

UNCOV

687

void NebulaMgr::setFlagSurfaceBrightnessArcsecUsage(const bool usage)

×

UNCOV

689

        if (usage!=Nebula::flagUseArcsecSurfaceBrightness)

×

UNCOV

691

                Nebula::flagUseArcsecSurfaceBrightness=usage;

×

692

                StelApp::immediateSave("gui/flag_surface_brightness_arcsec", Nebula::flagUseArcsecSurfaceBrightness);

×

693

                emit flagSurfaceBrightnessArcsecUsageChanged(usage);

×

UNCOV

695

×

UNCOV

697

bool NebulaMgr::getFlagSurfaceBrightnessArcsecUsage(void) const

×

UNCOV

699

        return Nebula::flagUseArcsecSurfaceBrightness;

×

UNCOV

702

void NebulaMgr::setFlagSurfaceBrightnessShortNotationUsage(const bool usage)

×

UNCOV

704

        if (usage!=Nebula::flagUseShortNotationSurfaceBrightness)

×

UNCOV

706

                Nebula::flagUseShortNotationSurfaceBrightness=usage;

×

707

                StelApp::immediateSave("gui/flag_surface_brightness_short", Nebula::flagUseShortNotationSurfaceBrightness);

×

708

                emit flagSurfaceBrightnessShortNotationUsageChanged(usage);

×

UNCOV

710

×

UNCOV

712

bool NebulaMgr::getFlagSurfaceBrightnessShortNotationUsage(void) const

×

UNCOV

714

        return Nebula::flagUseShortNotationSurfaceBrightness;

×

UNCOV

717

void NebulaMgr::setFlagSizeLimitsUsage(const bool usage)

×

UNCOV

719

        if (usage!=Nebula::flagUseSizeLimits)

×

UNCOV

721

                Nebula::flagUseSizeLimits=usage;

×

722

                StelApp::immediateSave("astro/flag_size_limits_usage", Nebula::flagUseSizeLimits);

×

723

                emit flagSizeLimitsUsageChanged(usage);

×

UNCOV

725

×

UNCOV

727

bool NebulaMgr::getFlagSizeLimitsUsage(void) const

×

UNCOV

729

        return Nebula::flagUseSizeLimits;

×

UNCOV

732

void NebulaMgr::setFlagUseTypeFilters(const bool b)

×

UNCOV

734

        if (Nebula::flagUseTypeFilters!=b)

×

UNCOV

736

                Nebula::flagUseTypeFilters=b;

×

737

                StelApp::immediateSave("astro/flag_use_type_filter", Nebula::flagUseTypeFilters);

×

738

                emit flagUseTypeFiltersChanged(b);

×

UNCOV

740

×

UNCOV

742

bool NebulaMgr::getFlagUseTypeFilters(void) const

×

UNCOV

744

        return Nebula::flagUseTypeFilters;

×

UNCOV

747

void NebulaMgr::setLabelsAmount(double a)

×

UNCOV

749

        if((a-labelsAmount) != 0.)

×

UNCOV

751

                labelsAmount=a;

×

752

                StelApp::immediateSave("astro/nebula_labels_amount", labelsAmount);

×

753

                emit labelsAmountChanged(a);

×

UNCOV

755

×

UNCOV

757

double NebulaMgr::getLabelsAmount(void) const

×

UNCOV

759

        return labelsAmount;

×

UNCOV

762

void NebulaMgr::setHintsAmount(double f)

×

UNCOV

764

        if((hintsAmount-f) != 0.)

×

UNCOV

766

                hintsAmount = f;

×

767

                StelApp::immediateSave("astro/nebula_hints_amount", hintsAmount);

×

768

                emit hintsAmountChanged(f);

×

UNCOV

770

×

UNCOV

772

double NebulaMgr::getHintsAmount(void) const

×

UNCOV

774

        return hintsAmount;

×

UNCOV

777

void NebulaMgr::setLabelsBrightness(double b)

×

UNCOV

779

        if (b!=labelsBrightness)

×

UNCOV

781

                labelsBrightness = b;

×

782

                StelApp::immediateSave("astro/nebula_labels_brightness", labelsBrightness);

×

783

                emit labelsBrightnessChanged(b);

×

UNCOV

785

×

UNCOV

787

double NebulaMgr::getLabelsBrightness(void) const

×

UNCOV

789

        return labelsBrightness;

×

UNCOV

792

void NebulaMgr::setHintsBrightness(double b)

×

UNCOV

794

        if (b!=hintsBrightness)

×

UNCOV

796

                hintsBrightness = b;

×

797

                StelApp::immediateSave("astro/nebula_hints_brightness", hintsBrightness);

×

798

                emit hintsBrightnessChanged(b);

×

UNCOV

800

×

UNCOV

802

double NebulaMgr::getHintsBrightness(void) const

×

UNCOV

804

        return hintsBrightness;

×

UNCOV

808

void NebulaMgr::setMinSizeLimit(double s)

×

UNCOV

810

        if((Nebula::minSizeLimit-s) != 0.)

×

UNCOV

812

                Nebula::minSizeLimit = s;

×

813

                StelApp::immediateSave("astro/size_limit_min", Nebula::minSizeLimit);

×

814

                emit minSizeLimitChanged(s);

×

UNCOV

816

×

UNCOV

818

double NebulaMgr::getMinSizeLimit() const

×

UNCOV

820

        return Nebula::minSizeLimit;

×

UNCOV

823

void NebulaMgr::setMaxSizeLimit(double s)

×

UNCOV

825

        if((Nebula::maxSizeLimit-s) != 0.)

×

UNCOV

827

                Nebula::maxSizeLimit = s;

×

828

                StelApp::immediateSave("astro/size_limit_max", Nebula::maxSizeLimit);

×

829

                emit maxSizeLimitChanged(s);

×

UNCOV

831

×

UNCOV

833

double NebulaMgr::getMaxSizeLimit() const

×

UNCOV

835

        return Nebula::maxSizeLimit;

×

UNCOV

838

float NebulaMgr::computeMaxMagHint(const StelSkyDrawer* skyDrawer) const

×

UNCOV

840

        return skyDrawer->getLimitMagnitude()*1.2f-2.f+static_cast<float>(hintsAmount *1.)-2.f;

×

UNCOV

844

void NebulaMgr::draw(StelCore* core)

×

UNCOV

846

        const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000);

×

847

        StelPainter sPainter(prj);

×

848

        sPainter.setFont(nebulaFont);

×

UNCOV

850

        if(hintsFader.getInterstate()>0.f)

×

UNCOV

852

                static StelSkyDrawer* skyDrawer = core->getSkyDrawer();

×

UNCOV

854

                Nebula::hintsBrightness  = hintsFader.getInterstate()*flagShow.getInterstate()*static_cast<float>(hintsBrightness);

×

855

                Nebula::labelsBrightness = hintsFader.getInterstate()*flagShow.getInterstate()*static_cast<float>(labelsBrightness);

×

UNCOV

858

                const float margin = 4.f*M_PI_180f*prj->getPixelPerRadAtCenter();

×

859

                const SphericalRegionP& p = prj->getViewportConvexPolygon(margin, margin);

×

UNCOV

862

                float maxMagHints  = computeMaxMagHint(skyDrawer);

×

863

                float maxMagLabels = skyDrawer->getLimitMagnitude()-2.f+static_cast<float>(labelsAmount*1.2)-2.f;

×

864

                DrawNebulaFuncObject func(maxMagHints, maxMagLabels, &sPainter, core, hintsFader.getInterstate()<=0.f);

×

865

                nebGrid.processIntersectingPointInRegions(p.data(), func);

×

866

×

UNCOV

868

        static StelObjectMgr *som=GETSTELMODULE(StelObjectMgr);

×

869

        if (som->getFlagSelectedObjectPointer())

×

870

                drawPointer(core, sPainter);

×

871

×

UNCOV

873

void NebulaMgr::drawPointer(const StelCore* core, StelPainter& sPainter)

×

UNCOV

875

        const StelProjectorP prj = core->getProjection(StelCore::FrameJ2000);

×

UNCOV

877

        const QList<StelObjectP> newSelected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("Nebula");

×

878

        if (!newSelected.empty())

×

UNCOV

880

                const StelObjectP obj = newSelected[0];

×

881

                Vec3d pos=obj->getJ2000EquatorialPos(core);

×

UNCOV

884

                if (!prj->projectInPlace(pos)) return;

×

885

                sPainter.setColor(0.4f,0.5f,0.8f);

×

UNCOV

887

                texPointer->bind();

×

UNCOV

889

                sPainter.setBlending(true);

×

UNCOV

892

                float screenRd = static_cast<float>(obj->getAngularRadius(core))*M_PI_180f*prj->getPixelPerRadAtCenter();

×

893

                if (screenRd>120.f) // avoid oversized marker

×

894

                        screenRd = 120.f;

×

UNCOV

896

                if (Nebula::drawHintProportional)

×

897

                        screenRd*=1.2f;

×

898

                screenRd+=20.f + 10.f*std::sin(3.f * static_cast<float>(StelApp::getInstance().getAnimationTime()));

×

899

                sPainter.drawSprite2dMode(static_cast<float>(pos[0])-screenRd*0.5f, static_cast<float>(pos[1])-screenRd*0.5f, 10, 90);

×

900

                sPainter.drawSprite2dMode(static_cast<float>(pos[0])-screenRd*0.5f, static_cast<float>(pos[1])+screenRd*0.5f, 10, 0);

×

901

                sPainter.drawSprite2dMode(static_cast<float>(pos[0])+screenRd*0.5f, static_cast<float>(pos[1])+screenRd*0.5f, 10, -90);

×

902

                sPainter.drawSprite2dMode(static_cast<float>(pos[0])+screenRd*0.5f, static_cast<float>(pos[1])-screenRd*0.5f, 10, -180);

×

903

×

904

×

UNCOV

907

NebulaP NebulaMgr::searchForCommonName(const QString& name)

×

UNCOV

909

        QString uname = name.toUpper();

×

UNCOV

911

        if (const auto it = commonNameIndex.find(uname); it != commonNameIndex.end())

×

912

                return (it->nebula);

×

UNCOV

914

        return searchByDesignation(uname);

×

915

×

UNCOV

917

void NebulaMgr::loadNebulaSet(const QString& setName)

×

UNCOV

919

        QString srcCatalogPath        = StelFileMgr::findFile("nebulae/" + setName + "/catalog.txt");

×

920

        QString dsoCatalogPath        = StelFileMgr::findFile("nebulae/" + setName + "/catalog-" + StellariumDSOCatalogVersion + ".dat");

×

921

        if (dsoCatalogPath.isEmpty()) // Extended edition is not exist, let's try find standard edition

×

922

                dsoCatalogPath        = StelFileMgr::findFile("nebulae/" + setName + "/catalog.dat");

×

923

        QString dsoOutlinesPath        = StelFileMgr::findFile("nebulae/" + setName + "/outlines.dat");

×

924

        QString dsoDiscoveryPath = StelFileMgr::findFile("nebulae/" + setName + "/discovery.dat");

×

925

        QString dsoNamesPath = StelFileMgr::findFile("nebulae/" + setName + "/names.dat");

×

UNCOV

927

        dsoArray.clear();

×

928

        dsoIndex.clear();

×

929

        nebGrid.clear();

×

UNCOV

931

        if (flagConverter)

×

UNCOV

933

                if (!srcCatalogPath.isEmpty())

×

934

                        convertDSOCatalog(srcCatalogPath, StelFileMgr::findFile("nebulae/" + setName + "/catalog.pack", StelFileMgr::New), flagDecimalCoordinates);

×

UNCOV

936

                        qWarning() << "ERROR converting catalogue, because source data set does not exist for " << setName;

×

UNCOV

939

        if (dsoCatalogPath.isEmpty())

×

UNCOV

941

                qWarning() << "ERROR while loading deep-sky catalog data set " << setName;

×

942

                return;

×

UNCOV

945

        loadDSOCatalog(dsoCatalogPath);

×

UNCOV

947

        if (dsoNamesPath.isEmpty())

×

UNCOV

949

                qWarning().noquote() << "ERROR while loading deep-sky names data set" << setName;

×

UNCOV

953

                loadDSONames(dsoNamesPath);

×

UNCOV

956

        if (!dsoOutlinesPath.isEmpty())

×

957

                loadDSOOutlines(dsoOutlinesPath);

×

UNCOV

959

        if (!dsoDiscoveryPath.isEmpty())

×

960

                loadDSODiscoveryData(dsoDiscoveryPath);

×

961

×

UNCOV

964

NebulaP NebulaMgr::search(const Vec3d& apos)

×

UNCOV

966

        Vec3d pos(apos);

×

967

        pos.normalize();

×

968

        NebulaP plusProche;

×

969

        double anglePlusProche=0.0;

×

970

        for (const auto& n : std::as_const(dsoArray))

×

UNCOV

972

                if (n->XYZ*pos>anglePlusProche)

×

UNCOV

974

                        anglePlusProche=n->XYZ*pos;

×

975

                        plusProche=n;

×

UNCOV

978

        if (anglePlusProche>0.999) // object within ~2.5 degrees

×

UNCOV

980

                return plusProche;

×

UNCOV

982

        else return NebulaP();

×

983

×

UNCOV

986

QList<StelObjectP> NebulaMgr::searchAround(const Vec3d& av, double limitFov, const StelCore*) const

×

UNCOV

988

        QList<StelObjectP> result;

×

989

        if (!getFlagShow())

×

990

                return result;

×

UNCOV

992

        Vec3d v(av);

×

993

        v.normalize();

×

994

        const double cosLimFov = cos(limitFov * M_PI/180.);

×

995

        Vec3d equPos;

×

996

        for (const auto& n : std::as_const(dsoArray))

×

UNCOV

998

                equPos = n->XYZ;

×

999

                equPos.normalize();

×

1000

                if (equPos*v >= cosLimFov)

×

UNCOV

1002

                        result.push_back(qSharedPointerCast<StelObject>(n));

×

UNCOV

1005

        return result;

×

1006

×

UNCOV

1008

NebulaP NebulaMgr::searchDSO(unsigned int DSO) const

×

UNCOV

1010

        if (dsoIndex.contains(DSO))

×

1011

                return dsoIndex[DSO];

×

1012

        return NebulaP();

×

UNCOV

1016

NebulaP NebulaMgr::searchM(unsigned int M) const

×

UNCOV

1018

        for (const auto& n : dsoArray)

×

1019

                if (n->M_nb == M)

×

1020

                        return n;

×

1021

        return NebulaP();

×

UNCOV

1024

NebulaP NebulaMgr::searchNGC(unsigned int NGC) const

×

UNCOV

1026

        for (const auto& n : dsoArray)

×

1027

                if (n->NGC_nb == NGC)

×

1028

                        return n;

×

1029

        return NebulaP();

×

UNCOV

1032

NebulaP NebulaMgr::searchIC(unsigned int IC) const

×

UNCOV

1034

        for (const auto& n : dsoArray)

×

1035

                if (n->IC_nb == IC)

×

1036

                        return n;

×

1037

        return NebulaP();

×

UNCOV

1040

NebulaP NebulaMgr::searchC(unsigned int C) const

×

UNCOV

1042

        for (const auto& n : dsoArray)

×

1043

                if (n->C_nb == C)

×

1044

                        return n;

×

1045

        return NebulaP();

×

UNCOV

1048

NebulaP NebulaMgr::searchB(unsigned int B) const

×

UNCOV

1050

        for (const auto& n : dsoArray)

×

1051

                if (n->B_nb == B)

×

1052

                        return n;

×

1053

        return NebulaP();

×

UNCOV

1056

NebulaP NebulaMgr::searchSh2(unsigned int Sh2) const

×

UNCOV

1058

        for (const auto& n : dsoArray)

×

1059

                if (n->Sh2_nb == Sh2)

×

1060

                        return n;

×

1061

        return NebulaP();

×

UNCOV

1064

NebulaP NebulaMgr::searchVdB(unsigned int VdB) const

×

UNCOV

1066

        for (const auto& n : dsoArray)

×

1067

                if (n->VdB_nb == VdB)

×

1068

                        return n;

×

1069

        return NebulaP();

×

UNCOV

1072

NebulaP NebulaMgr::searchVdBHa(unsigned int VdBHa) const

×

UNCOV

1074

        for (const auto& n : dsoArray)

×

1075

                if (n->VdBHa_nb == VdBHa)

×

1076

                        return n;

×

1077

        return NebulaP();

×

UNCOV

1080

NebulaP NebulaMgr::searchRCW(unsigned int RCW) const

×

UNCOV

1082

        for (const auto& n : dsoArray)

×

1083

                if (n->RCW_nb == RCW)

×

1084

                        return n;

×

1085

        return NebulaP();

×

UNCOV

1088

NebulaP NebulaMgr::searchLDN(unsigned int LDN) const

×

UNCOV

1090

        for (const auto& n : dsoArray)

×

1091

                if (n->LDN_nb == LDN)

×

1092

                        return n;

×

1093

        return NebulaP();

×

UNCOV

1096

NebulaP NebulaMgr::searchLBN(unsigned int LBN) const

×

UNCOV

1098

        for (const auto& n : dsoArray)

×

1099

                if (n->LBN_nb == LBN)

×

1100

                        return n;

×

1101

        return NebulaP();

×

UNCOV

1104

NebulaP NebulaMgr::searchCr(unsigned int Cr) const

×

UNCOV

1106

        for (const auto& n : dsoArray)

×

1107

                if (n->Cr_nb == Cr)

×

1108

                        return n;

×

1109

        return NebulaP();

×

UNCOV

1112

NebulaP NebulaMgr::searchMel(unsigned int Mel) const

×

UNCOV

1114

        for (const auto& n : dsoArray)

×

1115

                if (n->Mel_nb == Mel)

×

1116

                        return n;

×

1117

        return NebulaP();

×

UNCOV

1120

NebulaP NebulaMgr::searchPGC(unsigned int PGC) const

×

UNCOV

1122

        for (const auto& n : dsoArray)

×

1123

                if (n->PGC_nb == PGC)

×

1124

                        return n;

×

1125

        return NebulaP();

×

UNCOV

1128

NebulaP NebulaMgr::searchUGC(unsigned int UGC) const

×

UNCOV

1130

        for (const auto& n : dsoArray)

×

1131

                if (n->UGC_nb == UGC)

×

1132

                        return n;

×

1133

        return NebulaP();

×

UNCOV

1136

NebulaP NebulaMgr::searchCed(QString Ced) const

×

UNCOV

1138

        Ced = Ced.trimmed();

×

1139

        for (const auto& n : dsoArray)

×

1140

                if (n->Ced_nb.compare(Ced, Qt::CaseInsensitive) == 0)

×

1141

                        return n;

×

1142

        return NebulaP();

×

UNCOV

1145

NebulaP NebulaMgr::searchArp(unsigned int Arp) const

×

UNCOV

1147

        for (const auto& n : dsoArray)

×

1148

                if (n->Arp_nb == Arp)

×

1149

                        return n;

×

1150

        return NebulaP();

×

UNCOV

1153

NebulaP NebulaMgr::searchVV(unsigned int VV) const

×

UNCOV

1155

        for (const auto& n : dsoArray)

×

1156

                if (n->VV_nb == VV)

×

1157

                        return n;

×

1158

        return NebulaP();

×

UNCOV

1161

NebulaP NebulaMgr::searchPK(QString PK) const

×

UNCOV

1163

        PK = PK.trimmed();

×

1164

        for (const auto& n : dsoArray)

×

1165

                if (n->PK_nb.compare(PK, Qt::CaseInsensitive) == 0)

×

1166

                        return n;

×

1167

        return NebulaP();

×

UNCOV

1170

NebulaP NebulaMgr::searchPNG(QString PNG) const

×

UNCOV

1172

        PNG = PNG.trimmed();

×

1173

        for (const auto& n : dsoArray)

×

1174

                if (n->PNG_nb.compare(PNG, Qt::CaseInsensitive) == 0)

×

1175

                        return n;

×

1176

        return NebulaP();

×

UNCOV

1179

NebulaP NebulaMgr::searchSNRG(QString SNRG) const

×

UNCOV

1181

        SNRG = SNRG.trimmed();

×

1182

        for (const auto& n : dsoArray)

×

1183

                if (n->SNRG_nb.compare(SNRG, Qt::CaseInsensitive) == 0)

×

1184

                        return n;

×

1185

        return NebulaP();

×

UNCOV

1188

NebulaP NebulaMgr::searchACO(QString ACO) const

×

UNCOV

1190

        ACO = ACO.trimmed();

×

1191

        for (const auto& n : dsoArray)

×

1192

                if (n->ACO_nb.compare(ACO, Qt::CaseInsensitive) == 0)

×

1193

                        return n;

×

1194

        return NebulaP();

×

UNCOV

1197

NebulaP NebulaMgr::searchHCG(QString HCG) const

×

UNCOV

1199

        HCG = HCG.trimmed();

×

1200

        for (const auto& n : dsoArray)

×

1201

                if (n->HCG_nb.compare(HCG, Qt::CaseInsensitive) == 0)

×

1202

                        return n;

×

1203

        return NebulaP();

×

UNCOV

1206

NebulaP NebulaMgr::searchESO(QString ESO) const

×

UNCOV

1208

        ESO = ESO.trimmed();

×

1209

        for (const auto& n : dsoArray)

×

1210

                if (n->ESO_nb.compare(ESO, Qt::CaseInsensitive) == 0)

×

1211

                        return n;

×

1212

        return NebulaP();

×

UNCOV

1215

NebulaP NebulaMgr::searchVdBH(QString VdBH) const

×

UNCOV

1217

        VdBH = VdBH.trimmed();

×

1218

        for (const auto& n : dsoArray)

×

1219

                if (n->VdBH_nb.compare(VdBH, Qt::CaseInsensitive) == 0)

×

1220

                        return n;

×

1221

        return NebulaP();

×

UNCOV

1224

NebulaP NebulaMgr::searchDWB(unsigned int DWB) const

×

UNCOV

1226

        for (const auto& n : dsoArray)

×

1227

                if (n->DWB_nb == DWB)

×

1228

                        return n;

×

1229

        return NebulaP();

×

UNCOV

1232

NebulaP NebulaMgr::searchTr(unsigned int Tr) const

×

UNCOV

1234

        for (const auto& n : dsoArray)

×

1235

                if (n->Tr_nb == Tr)

×

1236

                        return n;

×

1237

        return NebulaP();

×

UNCOV

1240

NebulaP NebulaMgr::searchSt(unsigned int St) const

×

UNCOV

1242

        for (const auto& n : dsoArray)

×

1243

                if (n->St_nb == St)

×

1244

                        return n;

×

1245

        return NebulaP();

×

UNCOV

1248

NebulaP NebulaMgr::searchRu(unsigned int Ru) const

×

UNCOV

1250

        for (const auto& n : dsoArray)

×

1251

                if (n->Ru_nb == Ru)

×

1252

                        return n;

×

1253

        return NebulaP();

×

UNCOV

1256

QString NebulaMgr::getLatestSelectedDSODesignation() const

×

UNCOV

1258

        QString result = "";

×

UNCOV

1260

        const QList<StelObjectP> selected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("Nebula");

×

1261

        if (!selected.empty())

×

UNCOV

1263

                for (const auto& n : dsoArray)

×

1264

                        if (n==selected[0])

×

1265

                                result = n->getDSODesignation(); // Get designation for latest selected DSO

×

UNCOV

1268

        return result;

×

1269

×

UNCOV

1271

QString NebulaMgr::getLatestSelectedDSODesignationWIC() const

×

UNCOV

1273

        QString result = "";

×

UNCOV

1275

        const QList<StelObjectP> selected = GETSTELMODULE(StelObjectMgr)->getSelectedObject("Nebula");

×

1276

        if (!selected.empty())

×

UNCOV

1278

                for (const auto& n : dsoArray)

×

1279

                        if (n==selected[0])

×

1280

                                result = n->getDSODesignationWIC(); // Get designation for latest selected DSO

×

UNCOV

1283

        return result;

×

1284

×

UNCOV

1286

void NebulaMgr::convertDSOCatalog(const QString &in, const QString &out, bool decimal=false)

×

UNCOV

1288

        QFile dsoIn(in);

×

1289

        if (!dsoIn.open(QIODevice::ReadOnly | QIODevice::Text))

×

1290

                return;

×

UNCOV

1292

        QFile dsoOut(out);

×

1293

        if (!dsoOut.open(QIODevice::WriteOnly))

×

UNCOV

1295

                qDebug() << "Error converting DSO data! Cannot open file" << QDir::toNativeSeparators(out);

×

1296

                return;

×

UNCOV

1299

        int totalRecords=0;

×

1300

        QString record;

×

1301

        while (!dsoIn.atEnd())

×

UNCOV

1303

                dsoIn.readLine();

×

1304

                ++totalRecords;

×

UNCOV

1308

        dsoIn.seek(0);

×

UNCOV

1310

        QDataStream dsoOutStream(&dsoOut);

×

1311

        dsoOutStream.setVersion(QDataStream::Qt_5_2);

×

UNCOV

1313

        int readOk = 0;                                // how many records were read without problems

×

1314

        while (!dsoIn.atEnd())

×

UNCOV

1316

                record = QString::fromUtf8(dsoIn.readLine());

×

UNCOV

1318

                static const QRegularExpression version("ersion\\s+([\\d\\.]+)\\s+(\\w+)");

×

1319

                QRegularExpressionMatch versionMatch;

×

1320

                int vp = record.indexOf(version, 0, &versionMatch);

×

1321

                if (vp!=-1) // Version of catalog, a first line!

×

1322

                        dsoOutStream << versionMatch.captured(1).trimmed() << versionMatch.captured(2).trimmed();

×

UNCOV

1325

                if (record.startsWith("//") || record.startsWith("#"))

×

UNCOV

1327

                        --totalRecords;

×

1328

                        continue;

×

UNCOV

1331

                if (!record.isEmpty())

×

UNCOV

1334

                        QStringList list=record.split("\t", Qt::KeepEmptyParts);

×

UNCOV

1339

                        int id                 = list.at(0).toInt();    // ID (inner identification number)

×

1340

                        QString ra             = list.at(1).trimmed();

×

1341

                        QString dec            = list.at(2).trimmed();

×

1342

                        float bMag             = list.at(3).toFloat();  // B magnitude

×

1343

                        float vMag             = list.at(4).toFloat();  // V magnitude

×

1344

                        QString oType          = list.at(5).trimmed();  // Object type

×

1345

                        QString mType          = list.at(6).trimmed();  // Morphological type of object

×

1346

                        float majorAxisSize    = list.at(7).toFloat();  // major axis size (arcmin)

×

1347

                        float minorAxisSize    = list.at(8).toFloat();  // minor axis size (arcmin)

×

1348

                        int orientationAngle   = list.at(9).toInt();    // orientation angle (degrees)

×

1349

                        float z                = list.at(10).toFloat(); // redshift

×

1350

                        float zErr             = list.at(11).toFloat(); // error of redshift

×

1351

                        float plx              = list.at(12).toFloat(); // parallax (mas)

×

1352

                        float plxErr           = list.at(13).toFloat(); // error of parallax (mas)

×

1353

                        float dist             = list.at(14).toFloat(); // distance (Mpc for galaxies, kpc for other objects)

×

1354

                        float distErr          = list.at(15).toFloat(); // distance error (Mpc for galaxies, kpc for other objects)

×

UNCOV

1358

                        int NGC                = list.at(16).toInt();   // NGC number

×

1359

                        int IC                 = list.at(17).toInt();   // IC number

×

1360

                        int M                  = list.at(18).toInt();   // M number

×

1361

                        int C                  = list.at(19).toInt();   // C number

×

1362

                        int B                  = list.at(20).toInt();   // B number

×

1363

                        int Sh2                = list.at(21).toInt();   // Sh2 number

×

1364

                        int VdB                = list.at(22).toInt();   // VdB number

×

1365

                        int RCW                = list.at(23).toInt();   // RCW number

×

1366

                        int LDN                = list.at(24).toInt();   // LDN number

×

1367

                        int LBN                = list.at(25).toInt();   // LBN number

×

1368

                        int Cr                 = list.at(26).toInt();   // Cr number (alias: Col)

×

1369

                        int Mel                = list.at(27).toInt();   // Mel number

×

1370

                        int PGC                = list.at(28).toInt();   // PGC number (subset)

×

1371

                        int UGC                = list.at(29).toInt();   // UGC number (subset)

×

1372

                        QString Ced            = list.at(30).trimmed();        // Ced number

×

1373

                        int Arp                = list.at(31).toInt();   // Arp number

×

1374

                        int VV                 = list.at(32).toInt();   // VV number

×

1375

                        QString PK             = list.at(33).trimmed(); // PK number

×

1376

                        QString PNG            = list.at(34).trimmed(); // PN G number

×

1377

                        QString SNRG           = list.at(35).trimmed(); // SNR G number

×

1378

                        QString ACO            = list.at(36).trimmed(); // ACO number

×

1379

                        QString HCG            = list.at(37).trimmed(); // HCG number

×

1380

                        QString ESO            = list.at(38).trimmed(); // ESO number

×

1381

                        QString VdBH           = list.at(39).trimmed(); // VdBH number

×

1382

                        int DWB                = list.at(40).toInt();   // DWB number

×

1383

                        int Tr                 = list.at(41).toInt();   // Tr number

×

1384

                        int St                 = list.at(42).toInt();   // St number

×

1385

                        int Ru                 = list.at(43).toInt();   // Ru number

×

1386

                        int VdBHa              = list.at(44).toInt();   // VdB-Ha number

×

UNCOV

1389

                        if (decimal)

×

UNCOV

1392

                                raRad        = ra.toFloat() *M_PI_180f;

×

1393

                                decRad        = dec.toFloat()*M_PI_180f;

×

UNCOV

1397

                                QStringList raLst;

×

1398

                                if (ra.contains(":"))

×

1399

                                        raLst        = ra.split(":");

×

UNCOV

1401

                                        raLst        = ra.split(" ");

×

UNCOV

1403

                                QStringList decLst;

×

1404

                                if (dec.contains(":"))

×

1405

                                        decLst = dec.split(":");

×

UNCOV

1407

                                        decLst = dec.split(" ");

×

UNCOV

1409

                                raRad        = raLst.at(0).toFloat() + raLst.at(1).toFloat()/60.f + raLst.at(2).toFloat()/3600.f;

×

1410

                                decRad        = qAbs(decLst.at(0).toFloat()) + decLst.at(1).toFloat()/60.f + decLst.at(2).toFloat()/3600.f;

×

1411

                                if (dec.startsWith("-")) decRad *= -1.f;

×

UNCOV

1413

                                raRad  *= M_PIf/12.f;        // Convert from hours to rad

×

1414

                                decRad *= M_PIf/180.f;    // Convert from deg to rad

×

1415

×

UNCOV

1417

                        majorAxisSize /= 60.f;        // Convert from arcmin to degrees

×

1418

                        minorAxisSize /= 60.f;        // Convert from arcmin to degrees

×

UNCOV

1421

                        if (bMag <= 0.f) bMag = 99.f;

×

1422

                        if (vMag <= 0.f) vMag = 99.f;

×

UNCOV

1424

                                { "G"   , Nebula::NebGx  },

×

1425

                                { "GX"  , Nebula::NebGx  },

×

1426

                                { "GC"  , Nebula::NebGc  },

×

1427

                                { "OC"  , Nebula::NebOc  },

×

1428

                                { "NB"  , Nebula::NebN   },

×

1429

                                { "PN"  , Nebula::NebPn  },

×

1430

                                { "DN"  , Nebula::NebDn  },

×

1431

                                { "RN"  , Nebula::NebRn  },

×

1432

                                { "C+N" , Nebula::NebCn  },

×

1433

                                { "RNE" , Nebula::NebRn  },

×

1434

                                { "HII" , Nebula::NebHII },

×

1435

                                { "SNR" , Nebula::NebSNR },

×

1436

                                { "BN"  , Nebula::NebBn  },

×

1437

                                { "EN"  , Nebula::NebEn  },

×

1438

                                { "SA"  , Nebula::NebSA  },

×

1439

                                { "SC"  , Nebula::NebSC  },

×

1440

                                { "CL"  , Nebula::NebCl  },

×

1441

                                { "IG"  , Nebula::NebIGx },

×

1442

                                { "RG"  , Nebula::NebRGx },

×

1443

                                { "AGX" , Nebula::NebAGx },

×

1444

                                { "QSO" , Nebula::NebQSO },

×

1445

                                { "ISM" , Nebula::NebISM },

×

1446

                                { "EMO" , Nebula::NebEMO },

×

1447

                                { "GNE" , Nebula::NebHII },

×

1448

                                { "RAD" , Nebula::NebISM },

×

1449

                                { "LIN" , Nebula::NebAGx },// LINER-type active galaxies

×

1450

                                { "BLL" , Nebula::NebBLL },

×

1451

                                { "BLA" , Nebula::NebBLA },

×

1452

                                { "MOC" , Nebula::NebMolCld },

×

1453

                                { "YSO" , Nebula::NebYSO },

×

1454

                                { "Q?"  , Nebula::NebPossQSO },

×

1455

                                { "PN?" , Nebula::NebPossPN },

×

1456

                                { "*"   , Nebula::NebStar},

×

1457

                                { "SFR" , Nebula::NebMolCld },

×

1458

                                { "IR"  , Nebula::NebDn  },

×

1459

                                { "**"  , Nebula::NebStar},

×

1460

                                { "MUL" , Nebula::NebStar},

×

1461

                                { "PPN" , Nebula::NebPPN },

×

1462

                                { "GIG" , Nebula::NebIGx },

×

1463

                                { "OPC" , Nebula::NebOc  },

×

1464

                                { "MGR" , Nebula::NebSA  },

×

1465

                                { "IG2" , Nebula::NebIGx },

×

1466

                                { "IG3" , Nebula::NebIGx },

×

1467

                                { "SY*" , Nebula::NebSymbioticStar},

×

1468

                                { "PA*" , Nebula::NebPPN },

×

1469

                                { "CV*" , Nebula::NebStar},

×

1470

                                { "Y*?" , Nebula::NebYSO },

×

1471

                                { "CGB" , Nebula::NebISM },

×

1472

                                { "SNRG", Nebula::NebSNR },

×

1473

                                { "Y*O" , Nebula::NebYSO },

×

1474

                                { "SR*" , Nebula::NebStar},

×

1475

                                { "EM*" , Nebula::NebEmissionLineStar },

×

1476

                                { "AB*" , Nebula::NebStar },

×

1477

                                { "MI*" , Nebula::NebStar },

×

1478

                                { "MI?" , Nebula::NebStar },

×

1479

                                { "TT*" , Nebula::NebStar },

×

1480

                                { "WR*" , Nebula::NebStar },

×

1481

                                { "C*"  , Nebula::NebEmissionLineStar },

×

1482

                                { "WD*" , Nebula::NebStar },

×

1483

                                { "EL*" , Nebula::NebStar },

×

1484

                                { "NL*" , Nebula::NebStar },

×

1485

                                { "NO*" , Nebula::NebStar },

×

1486

                                { "HS*" , Nebula::NebStar },

×

1487

                                { "LP*" , Nebula::NebStar },

×

1488

                                { "OH*" , Nebula::NebStar },

×

1489

                                { "S?R" , Nebula::NebStar },

×

1490

                                { "IR*" , Nebula::NebStar },

×

1491

                                { "POC" , Nebula::NebMolCld },

×

1492

                                { "PNB" , Nebula::NebPn   },

×

1493

                                { "GXCL", Nebula::NebGxCl },

×

1494

                                { "AL*" , Nebula::NebStar },

×

1495

                                { "PR*" , Nebula::NebStar },

×

1496

                                { "RS*" , Nebula::NebStar },

×

1497

                                { "S*B" , Nebula::NebStar },

×

1498

                                { "SN?" , Nebula::NebSNC  },

×

1499

                                { "SR?" , Nebula::NebSNRC },

×

1500

                                { "DNE" , Nebula::NebDn   },

×

1501

                                { "RG*" , Nebula::NebStar },

×

1502

                                { "PSR" , Nebula::NebSNR  },

×

1503

                                { "HH"  , Nebula::NebISM  },

×

1504

                                { "V*"  , Nebula::NebStar },

×

1505

                                { "*IN" , Nebula::NebCn   },

×

1506

                                { "SN*" , Nebula::NebStar },

×

1507

                                { "PA?" , Nebula::NebPPN  },

×

1508

                                { "BUB" , Nebula::NebISM  },

×

1509

                                { "CLG" , Nebula::NebGxCl },

×

1510

                                { "POG" , Nebula::NebPartOfGx },

×

1511

                                { "CGG" , Nebula::NebGxCl },

×

1512

                                { "SCG" , Nebula::NebGxCl },

×

1513

                                { "REG" , Nebula::NebRegion },

×

1514

                                { "?" , Nebula::NebUnknown }

×

1515

});

×

UNCOV

1517

                        Nebula::NebulaType nType=oTypesHash.value(oType.toUpper(), Nebula::NebUnknown);

×

1518

                        if (nType == Nebula::NebUnknown)

×

1519

                                qDebug() << "Record with ID" << id <<"has unknown type of object:" << oType;

×

UNCOV

1521

                        ++readOk;

×

UNCOV

1523

                        dsoOutStream << id << raRad << decRad << bMag << vMag << static_cast<unsigned int>(nType) << mType << majorAxisSize << minorAxisSize

×

1524

                                     << orientationAngle << z << zErr << plx << plxErr << dist  << distErr << NGC << IC << M << C

×

1525

                                     << B << Sh2 << VdB << RCW  << LDN << LBN << Cr << Mel << PGC << UGC << Ced << Arp << VV << PK

×

1526

                                     << PNG << SNRG << ACO << HCG << ESO << VdBH << DWB << Tr << St << Ru << VdBHa;

×

1527

×

1528

×

1529

        dsoIn.close();

×

1530

        dsoOut.flush();

×

1531

        dsoOut.close();

×

1532

        qInfo().noquote() << "Converted" << readOk << "/" << totalRecords << "DSO records";

×

1533

        qInfo().noquote() << "[...] Please use 'gzip -nc catalog.pack > catalog.dat' to pack the catalog.";

×

1534

×

UNCOV

1536

bool NebulaMgr::loadDSOCatalog(const QString &filename)

×

UNCOV

1538

        QFile in(filename);

×

1539

        if (!in.open(QIODevice::ReadOnly))

×

1540

                return false;

×

UNCOV

1542

        qInfo().noquote() << "Loading DSO data ...";

×

UNCOV

1545

        QDataStream ins(StelUtils::uncompress(in.readAll()));

×

1546

        ins.setVersion(QDataStream::Qt_5_2);

×

UNCOV

1548

        QString version = "", edition= "";

×

1549

        int totalRecords=0;

×

1550

        while (!ins.atEnd())

×

UNCOV

1552

                if (totalRecords==0) // Read the version of catalog

×

UNCOV

1554

                        ins >> version >> edition;

×

1555

                        if (version.isEmpty())

×

1556

                                version = "3.1"; // The first version of extended edition of the catalog

×

1557

                        if (edition.isEmpty())

×

1558

                                edition = "unknown";

×

1559

                        qInfo().noquote() << "[...]" << QString("Stellarium DSO Catalog, version %1 (%2 edition)").arg(version, edition);

×

1560

                        if (StelUtils::compareVersions(version, StellariumDSOCatalogVersion)!=0)

×

UNCOV

1562

                                ++totalRecords;

×

1563

                                qWarning().noquote() << "Mismatch of DSO catalog version (" << version << ")! The expected version is" << StellariumDSOCatalogVersion;

×

1564

                                qWarning().noquote() << "See section 5.5 of the User Guide and install the right version of the catalog!";

×

1565

                                QMessageBox::warning(&StelMainView::getInstance(), q_("Attention!"),

×

1566

                                                     QString("%1. %2: %3 - %4: %5. %6").arg(q_("DSO catalog version mismatch"),

×

1567

                                                                                            q_("Found"),

×

UNCOV

1569

                                                                                            q_("Expected"),

×

UNCOV

1571

                                                                                            q_("See Logfile for instructions.")), QMessageBox::Ok);

×

1572

                                break;

×

UNCOV

1578

                        NebulaP e = NebulaP(new Nebula);

×

1579

                        e->readDSO(ins);

×

UNCOV

1581

                        dsoArray.append(e);

×

1582

                        nebGrid.insert(qSharedPointerCast<StelRegionObject>(e));

×

1583

                        if (e->DSO_nb!=0)

×

1584

                                dsoIndex.insert(e->DSO_nb, e);

×

1585

×

1586

                ++totalRecords;

×

UNCOV

1588

        in.close();

×

1589

        qInfo().noquote() << "Loaded" << --totalRecords << "DSO records";

×

1590

        return true;

×

1591

×

UNCOV

1593

bool NebulaMgr::loadDSONames(const QString &filename)

×

UNCOV

1595

        qInfo() << "Loading DSO name data ...";

×

UNCOV

1597

        commonNameMap.clear();

×

UNCOV

1599

        QFile dsoNameFile(filename);

×

1600

        if (!dsoNameFile.open(QIODevice::ReadOnly | QIODevice::Text))

×

UNCOV

1602

                qWarning().noquote() << "DSO name data file" << QDir::toNativeSeparators(filename) << "not found.";

×

1603

                return false;

×

UNCOV

1607

        QString name, record, ref, cdes;

×

1608

        QStringList nodata;

×

1609

        nodata.clear();

×

1610

        int totalRecords=0;

×

1611

        int readOk=0;

×

UNCOV

1613

        NebulaP e;

×

1614

        static const QRegularExpression commentRx("^(\\s*#.*|\\s*)$");

×

1615

        while (!dsoNameFile.atEnd())

×

UNCOV

1617

                record = QString::fromUtf8(dsoNameFile.readLine());

×

1618

                if (commentRx.match(record).hasMatch())

×

1619

                        continue;

×

UNCOV

1621

                totalRecords++;

×

UNCOV

1624

                ref  = record.left(5).trimmed();

×

UNCOV

1626

                cdes = record.mid(5, 15).trimmed().toUpper();

×

UNCOV

1628

                name = record.mid(21).trimmed(); // Let gets the name with trimmed whitespaces

×

UNCOV

1630

                nb = cdes.toUInt();

×

UNCOV

1635

                        "ACO", "HCG", "ESO", "VDBH", "DWB", "TR", "ST", "RU", "DBHA"};

×

UNCOV

1637

                switch (catalogs.indexOf(ref.toUpper()))

×

UNCOV

1639

                        case 0:

×

1640

                                e = searchIC(nb);

×

1641

                                break;

×

1642

                        case 1:

×

1643

                                e = searchM(nb);

×

1644

                                break;

×

1645

                        case 2:

×

1646

                                e = searchC(nb);

×

1647

                                break;

×

1648

                        case 3:

×

1649

                                e = searchCr(nb);

×

1650

                                break;

×

1651

                        case 4:

×

1652

                                e = searchMel(nb);

×

1653

                                break;

×

1654

                        case 5:

×

1655

                                e = searchB(nb);

×

1656

                                break;

×

1657

                        case 6:

×

1658

                                e = searchSh2(nb);

×

1659

                                break;

×

1660

                        case 7:

×

1661

                                e = searchVdB(nb);

×

1662

                                break;

×

1663

                        case 8:

×

1664

                                e = searchRCW(nb);

×

1665

                                break;

×

1666

                        case 9:

×

1667

                                e = searchLDN(nb);

×

1668

                                break;

×

1669

                        case 10:

×

1670

                                e = searchLBN(nb);

×

1671

                                break;

×

1672

                        case 11:

×

1673

                                e = searchNGC(nb);

×

1674

                                break;

×

1675

                        case 12:

×

1676

                                e = searchPGC(nb);

×

1677

                                break;

×

1678

                        case 13:

×

1679

                                e = searchUGC(nb);

×

1680

                                break;

×

1681

                        case 14:

×

1682

                                e = searchCed(cdes);

×

1683

                                break;

×

1684

                        case 15:

×

1685

                                e = searchArp(nb);

×

1686

                                break;

×

1687

                        case 16:

×

1688

                                e = searchVV(nb);

×

1689

                                break;

×

1690

                        case 17:

×

1691

                                e = searchPK(cdes);

×

1692

                                break;

×

1693

                        case 18:

×

1694

                                e = searchPNG(cdes);

×

1695

                                break;

×

1696

                        case 19:

×

1697

                                e = searchSNRG(cdes);

×

1698

                                break;

×

1699

                        case 20:

×

1700

                                e = searchACO(cdes);

×

1701

                                break;

×

1702

                        case 21:

×

1703

                                e = searchHCG(cdes);

×

1704

                                break;

×

1705

                        case 22:

×

1706

                                e = searchESO(cdes);

×

1707

                                break;

×

1708

                        case 23:

×

1709

                                e = searchVdBH(cdes);

×

1710

                                break;

×

1711

                        case 24:

×

1712

                                e = searchDWB(nb);

×

1713

                                break;

×

1714

                        case 25:

×

1715

                                e = searchTr(nb);

×

1716

                                break;

×

1717

                        case 26:

×

1718

                                e = searchSt(nb);

×

1719

                                break;

×

1720

                        case 27:

×

1721

                                e = searchRu(nb);

×

1722

                                break;

×

1723

                        case 28:

×

1724

                                e = searchVdBHa(nb);

×

1725

                                break;

×

1726

                        default:

×

1727

                                e = searchDSO(nb);

×

1728

                                break;

×

UNCOV

1731

                if (!e.isNull())

×

UNCOV

1733

                        static const QRegularExpression transRx("_[(]\"(.*)\"[)](\\s*#.*)?"); // optional comments after name.

×

1734

                        QRegularExpressionMatch transMatch=transRx.match(name);

×

1735

                        if (transMatch.hasMatch())

×

UNCOV

1737

                                QString propName = transMatch.captured(1).trimmed();

×

UNCOV

1739

                                QString refs = transMatch.captured(2).trimmed(); // a null string should not complain.

×

1740

                                QStringList refList;

×

1741

                                bool accept=refs.isNull(); // if we don't have a reference, we must accept it.

×

1742

                                if (!accept)

×

UNCOV

1744

                                        refs=refs.right(refs.length()-1); // Chop off # sign. Use slice after switch to Qt6!

×

1745

                                        refList=refs.split(",");

×

UNCOV

1747

                                        for (int i=0; i<refList.length(); ++i)

×

UNCOV

1749

                                                refList[i]=refList.at(i).trimmed();

×

UNCOV

1753

                                        accept=refList.isEmpty(); // if we don't have a reference list, we must accept it.

×

UNCOV

1757

                                if (!accept)

×

UNCOV

1761

                                        foreach(QString str, refList)

×

UNCOV

1763

                                                if (unwantedReferences.contains(str))

×

UNCOV

1766

                                                        refList.removeOne(str);

×

UNCOV

1768

×

UNCOV

1770

                                        accept=!refList.isEmpty();

×

UNCOV

1773

                                if (accept)

×

UNCOV

1775

                                        commonNameMap[e].push_back(propName);

×

1776

                                        NebulaWithReferences nr = {e, refList };

×

1777

                                        commonNameIndex[propName.toUpper()] = nr;  // add with reduced refList.

×

1778

×

1779

×

1780

                        readOk++;

×

1781

×

UNCOV

1783

                        nodata.append(QString("%1 %2").arg(ref.trimmed(), cdes.trimmed()));

×

UNCOV

1785

        dsoNameFile.close();

×

1786

        qInfo().noquote() << "Loaded" << readOk << "/" << totalRecords << "DSO name records successfully";

×

UNCOV

1788

        int err = nodata.size();

×

1789

        if (err>0)

×

1790

                qWarning().noquote() << "No position data for" << err << "objects:" << nodata.join(", ");

×

UNCOV

1792

        return true;

×

1793

×

UNCOV

1795

bool NebulaMgr::loadDSODiscoveryData(const QString &filename)

×

UNCOV

1797

        qInfo() << "Loading DSO discovery data ...";

×

1798

        QFile dsoDiscoveryFile(filename);

×

1799

        if (!dsoDiscoveryFile.open(QIODevice::ReadOnly | QIODevice::Text))

×

UNCOV

1801

                qWarning().noquote() << "DSO discovery data file" << QDir::toNativeSeparators(filename) << "not found.";

×

1802

                return false;

×

UNCOV

1805

        int readOk = 0;

×

1806

        int totalRecords = 0;

×

1807

        QString record, dso, dYear, dName;

×

1808

        NebulaP e;

×

1809

        while (!dsoDiscoveryFile.atEnd())

×

UNCOV

1811

                record = QString::fromUtf8(dsoDiscoveryFile.readLine());

×

1812

                if (record.startsWith("//") || record.startsWith("#") || record.isEmpty())

×

1813

                        continue;

×

UNCOV

1815

                totalRecords++;

×

UNCOV

1817

                QStringList list=record.split("\t", Qt::KeepEmptyParts);

×

UNCOV

1822

                dso        = list.at(0).trimmed();

×

1823

                dYear        = list.at(1).trimmed();

×

1824

                dName        = list.at(2).trimmed();

×

UNCOV

1826

                e = searchForCommonName(dso);

×

1827

                if (e.isNull()) // maybe this is inner number of DSO

×

1828

                        e = searchDSO(dso.toUInt());

×

UNCOV

1830

                if (!e.isNull())

×

UNCOV

1832

                        e->setDiscoveryData(dName, dYear);

×

1833

                        readOk++;

×

UNCOV

1835

×

1836

        dsoDiscoveryFile.close();

×

1837

        qInfo().noquote() << "Loaded" << readOk << "/" << totalRecords << "DSO discovery records successfully";

×

1838

        return true;

×

1839

×

UNCOV

1841

bool NebulaMgr::loadDSOOutlines(const QString &filename)

×

UNCOV

1843

        qInfo() << "Loading DSO outline data ...";

×

1844

        QFile dsoOutlineFile(filename);

×

1845

        if (!dsoOutlineFile.open(QIODevice::ReadOnly | QIODevice::Text))

×

UNCOV

1847

                qWarning().noquote() << "DSO outline data file" << QDir::toNativeSeparators(filename) << "not found.";

×

1848

                return false;

×

UNCOV

1852

        int i, readOk = 0;

×

1853

        Vec3d XYZ;

×

1854

        std::vector<Vec3d> *points = Q_NULLPTR;

×

UNCOV

1856

        coords point, fpoint;

×

1857

        QVector<coords> outline;

×

1858

        QString record, command, dso;

×

1859

        NebulaP e;

×

UNCOV

1861

        static const QRegularExpression commentRx("^(\\s*#.*|\\s*)$");

×

1862

        while (!dsoOutlineFile.atEnd())

×

UNCOV

1864

                record = QString::fromUtf8(dsoOutlineFile.readLine());

×

1865

                if (commentRx.match(record).hasMatch())

×

1866

                        continue;

×

UNCOV

1870

                RA = record.first(8).toDouble();

×

UNCOV

1872

                DE = record.sliced(9, 10).toDouble();

×

UNCOV

1880

                command = record.mid(19, 7).trimmed();

×

UNCOV

1882

                dso = record.mid(26).trimmed();

×

UNCOV

1884

                RA*=M_PI/12.;     // Convert from hours to rad

×

1885

                DE*=M_PI/180.;    // Convert from deg to rad

×

UNCOV

1887

                if (command.contains("start", Qt::CaseInsensitive))

×

UNCOV

1889

                        outline.clear();

×

1890

                        e = searchForCommonName(dso);

×

1891

                        if (e.isNull()) // maybe this is inner number of DSO

×

1892

                                e = searchDSO(dso.toUInt());

×

UNCOV

1894

                        point.first  = RA;

×

1895

                        point.second = DE;

×

1896

                        outline.append(point);

×

1897

                        fpoint = point;

×

UNCOV

1900

                if (command.contains("vertex", Qt::CaseInsensitive))

×

UNCOV

1902

                        point.first  = RA;

×

1903

                        point.second = DE;

×

1904

                        outline.append(point);

×

UNCOV

1907

                if (command.contains("end", Qt::CaseInsensitive))

×

UNCOV

1909

                        point.first  = RA;

×

1910

                        point.second = DE;

×

1911

                        outline.append(point);

×

1912

                        outline.append(fpoint);

×

UNCOV

1914

                        if (!e.isNull())

×

UNCOV

1916

                                points = new std::vector<Vec3d>;

×

1917

                                for (i = 0; i < outline.size(); i++)

×

UNCOV

1920

                                        point = outline.at(i);

×

1921

                                        StelUtils::spheToRect(point.first, point.second, XYZ);

×

1922

                                        points->push_back(XYZ);

×

UNCOV

1925

                                e->outlineSegments.push_back(points);

×

UNCOV

1927

                        readOk++;

×

UNCOV

1930

        dsoOutlineFile.close();

×

1931

        qInfo().noquote() << "Loaded" << readOk << "DSO outline records successfully";

×

1932

        return true;

×

1933

×

UNCOV

1935

void NebulaMgr::updateSkyCulture(const StelSkyCulture& skyCulture)

×

UNCOV

1937

        for (const auto& n : std::as_const(dsoArray))

×

1938

                n->removeAllNames();

×

1941

        int numLoaded = 0;

×

UNCOV

1942

        if (!skyCulture.names.isEmpty())

×

1943

                numLoaded = loadCultureSpecificNames(skyCulture.names);

×

UNCOV

1945

        if (numLoaded)

×

1947

                qInfo().noquote() << "Loaded" << numLoaded << "culture-specific DSO names";

×

1951

        if (numLoaded==0 || skyCulture.fallbackToInternationalNames)

×

1953

                for (auto it = commonNameMap.cbegin(); it != commonNameMap.cend(); ++it)

×

UNCOV

1954

                        for (const auto& name : it.value())

×

UNCOV

1955

                                addEnglishOrAliasName(it.key(), name);

×

1958

        updateI18n();

×

1959

×

UNCOV

1961

int NebulaMgr::loadCultureSpecificNames(const QJsonObject& data)

×

1963

        const StelTranslator& trans = StelApp::getInstance().getLocaleMgr().getSkyTranslator();

×

1965

        for (const auto& n : std::as_const(dsoArray))

×

UNCOV

1966

                n->culturalNames.clear();

×

1968

        int loadedTotal = 0;

×

UNCOV

1969

        for (auto it = data.begin(); it != data.end(); ++it)

×

1971

                const auto key = it.key();

×

UNCOV

1972

                const auto specificNames = it->toArray();

×

UNCOV

1974

                if (key.startsWith("HIP "))

×

UNCOV

1978

                else if (key.startsWith("NAME "))

×

UNCOV

1983

                        auto name = key.mid(5);

×

1988

};

×

1989

                        if (const auto it = renamer.find(name); it != renamer.end())

×

1990

                                name = it.value();

×

1991

                        loadCultureSpecificNameForNamedObject(it.value().toArray(), name);

×

1992

×

UNCOV

1993

                else if (const NebulaP n = searchByDesignation(key))

×

UNCOV

1995

                        for (const auto& entry : specificNames)

×

UNCOV

1997

                                QJsonObject json=entry.toObject();

×

1998

                                StelObject::CulturalName cName;

×

1999

                                cName.native          = json["native"].toString().trimmed();

×

2000

                                cName.pronounce       = json["pronounce"].toString().trimmed();

×

2001

                                cName.pronounceI18n   = trans.qtranslate(json["pronounce"].toString(), json["context"].toString());

×

2002

                                cName.transliteration = json["transliteration"].toString().trimmed();

×

2003

                                cName.translated      = json["english"].toString().trimmed();

×

UNCOV

2004

                                cName.translatedI18n  = trans.qtranslate(json["english"].toString(), json["context"].toString());

×

2005

                                cName.IPA             = json["IPA"].toString().trimmed();

×

2007

                                n->addCulturalName(cName);

×

2008

                                ++loadedTotal;

×

UNCOV

2009

×

2010

×

UNCOV

2011

×

2012

        return loadedTotal;

×

2013

×

2016

void NebulaMgr::loadCultureSpecificNameForNamedObject(const QJsonArray& data, const QString& commonName)

×

UNCOV

2018

        const auto commonNameIndexIt = commonNameIndex.find(commonName.toUpper());

×

2019

        if (commonNameIndexIt == commonNameIndex.end())

×

2022

                return;

×

UNCOV

2025

        for (const auto& entry : data)

×

UNCOV

2031

                QJsonObject json=entry.toObject();

×

2032

                StelObject::CulturalName cName;

×

2033

                cName.native          = json["native"].toString().trimmed();

×

2034

                cName.pronounce       = json["pronounce"].toString().trimmed();

×

2035

                cName.pronounceI18n   = qc_(json["pronounce"].toString(), json["context"].toString()); // TODO: Clarify if context is available

×

UNCOV

2036

                cName.transliteration = json["transliteration"].toString().trimmed();

×

UNCOV

2037

                cName.translated      = json["english"].toString().trimmed();

×

UNCOV

2038

                cName.translatedI18n  = qc_(json["english"].toString(), json["context"].toString()); // TODO: Clarify if context is available

×

2039

                cName.IPA             = json["IPA"].toString().trimmed();

×

2041

                commonNameIndexIt.value().nebula->addCulturalName(cName);

×

UNCOV

2042

×

UNCOV

2045

void NebulaMgr::updateI18n()

×

2047

        const StelTranslator& trans = StelApp::getInstance().getLocaleMgr().getSkyTranslator();

×

2048

        for (const auto& n : std::as_const(dsoArray))

×

2049

                n->translateName(trans);

×

UNCOV

2050

×

2054

StelObjectP NebulaMgr::searchByNameI18n(const QString& nameI18n) const

×

2056

        const QString nameI18nUpper = nameI18n.toUpper();

×

UNCOV

2059

        for (const auto& n : std::as_const(dsoArray))

×

UNCOV

2061

                if (n->nameI18.toUpper() == nameI18nUpper)

×

2062

                        return qSharedPointerCast<StelObject>(n);

×

UNCOV

2066

        for (const auto& n : std::as_const(dsoArray))

×

2068

                for (auto &nameI18Alias : n->nameI18Aliases)

×

2070

                        if (nameI18Alias.toUpper()==nameI18nUpper)

×

UNCOV

2071

                                return qSharedPointerCast<StelObject>(n);

×

2076

        NebulaP n = searchByDesignation(nameI18nUpper);

×

2077

        return qSharedPointerCast<StelObject>(n);

×

2078

×

UNCOV

2082

StelObjectP NebulaMgr::searchByName(const QString& name) const

×

UNCOV

2084

        const QString nameUpper = name.toUpper();

×

2087

        for (const auto& n : dsoArray)

×

UNCOV

2089

                if (n->englishName.toUpper()==nameUpper)

×

UNCOV

2090

                        return qSharedPointerCast<StelObject>(n);

×

UNCOV

2093

        if (getFlagAdditionalNames())

×

2096

                for (const auto& n : dsoArray)

×

UNCOV

2098

                        for (auto &englishAlias : n->englishAliases)

×

2100

                                if (englishAlias.toUpper()==nameUpper)

×

UNCOV

2101

                                        return qSharedPointerCast<StelObject>(n);

×

2107

        NebulaP n = searchByDesignation(nameUpper);

×

UNCOV

2108

        return qSharedPointerCast<StelObject>(n);

×

2109

×

2113

NebulaP NebulaMgr::searchByDesignation(const QString &designation) const

×

2115

        NebulaP n;

×

2116

        QString designationUpper = designation.toUpper();

×

2118

        static const QRegularExpression catNumRx("^(M|NGC|IC|C|B|VDB|RCW|LDN|LBN|CR|MEL|PGC|UGC|ARP|VV|DWB|TR|TRUMPLER|ST|STOCK|RU|RUPRECHT|VDB-HA)\\s*(\\d+)$");

×

2119

        QRegularExpressionMatch catNumMatch=catNumRx.match(designationUpper);

×

2120

        if (catNumMatch.hasMatch())

×

2122

                QString cat = catNumMatch.captured(1);

×

2123

                unsigned int num = catNumMatch.captured(2).toUInt();

×

2124

                if (cat == "M") n = searchM(num);

×

2125

                if (cat == "NGC") n = searchNGC(num);

×

2126

                if (cat == "IC") n = searchIC(num);

×

2127

                if (cat == "C") n = searchC(num);

×

2128

                if (cat == "B") n = searchB(num);

×

2129

                if (cat == "VDB-HA") n = searchVdBHa(num);

×

2130

                if (cat == "VDB") n = searchVdB(num);

×

2131

                if (cat == "RCW") n = searchRCW(num);

×

2132

                if (cat == "LDN") n = searchLDN(num);

×

2133

                if (cat == "LBN") n = searchLBN(num);

×

2134

                if (cat == "CR") n = searchCr(num);

×

UNCOV

2135

                if (cat == "MEL") n = searchMel(num);

×

2136

                if (cat == "PGC") n = searchPGC(num);

×

2137

                if (cat == "UGC") n = searchUGC(num);

×

UNCOV

2138

                if (cat == "ARP") n = searchArp(num);

×

2139

                if (cat == "VV") n = searchVV(num);

×

2140

                if (cat == "DWB") n = searchDWB(num);

×

2141

                if (cat == "TR" || cat == "TRUMPLER") n = searchTr(num);

×

2142

                if (cat == "ST" || cat == "STOCK") n = searchSt(num);

×

2143

                if (cat == "RU" || cat == "RUPRECHT") n = searchRu(num);

×

UNCOV

2144

×

2145

        static const QRegularExpression dCatNumRx("^(SH)\\s*\\d-\\s*(\\d+)$");

×

2146

        QRegularExpressionMatch dCatNumMatch=dCatNumRx.match(designationUpper);

×

UNCOV

2147

        if (dCatNumMatch.hasMatch())

×

2149

                QString dcat = dCatNumMatch.captured(1);

×

2150

                unsigned int dnum = dCatNumMatch.captured(2).toUInt();

×

2152

                if (dcat == "SH") n = searchSh2(dnum);

×

2153

×

2154

        static const QRegularExpression sCatNumRx("^(CED|PK|ACO|ABELL|HCG|ESO|VDBH)\\s*(.+)$");

×

2155

        QRegularExpressionMatch sCatNumMatch=sCatNumRx.match(designationUpper);

×

2156

        if (sCatNumMatch.hasMatch())

×

UNCOV

2158

                QString cat = sCatNumMatch.captured(1);

×

2159

                QString num = sCatNumMatch.captured(2).trimmed();

×

UNCOV

2161

                if (cat == "CED") n = searchCed(num);

×

2162

                if (cat == "PK") n = searchPK(num);

×

2163

                if (cat == "ACO" || cat == "ABELL") n = searchACO(num);

×

2164

                if (cat == "HCG") n = searchHCG(num);

×

UNCOV

2165

                if (cat == "ESO") n = searchESO(num);

×

2166

                if (cat == "VDBH") n = searchVdBH(num);

×

2167

×

UNCOV

2168

        static const QRegularExpression gCatNumRx("^(PN|SNR)\\s*G(.+)$");

×

UNCOV

2169

        QRegularExpressionMatch gCatNumMatch=gCatNumRx.match(designationUpper);

×

2170

        if (gCatNumMatch.hasMatch())

×

2172

                QString cat = gCatNumMatch.captured(1);

×

2173

                QString num = gCatNumMatch.captured(2).trimmed();

×

UNCOV

2175

                if (cat == "PN") n = searchPNG(num);

×

2176

                if (cat == "SNR") n = searchSNRG(num);

×

UNCOV

2177

×

2179

        return n;

×

UNCOV

2180

×

2183

QStringList NebulaMgr::listMatchingObjects(const QString& objPrefix, int maxNbItem, bool useStartOfWords) const

×

2185

        QStringList result;

×

2186

        if (maxNbItem <= 0)

×

UNCOV

2187

                return result;

×

2189

        QString objUpper = objPrefix.toUpper();

×

2192

        if (objUpper.size()>=1 && objUpper.at(0)=='M' && objUpper.left(3)!="MEL")

×

2194

                for (const auto& n : dsoArray)

×

UNCOV

2196

                        if (n->M_nb==0) continue;

×

UNCOV

2197

                        QString constw = QString("M%1").arg(n->M_nb);

×

UNCOV

2198

                        QString constws = constw.mid(0, objUpper.size());

×

2199

                        if (constws.toUpper()==objUpper)

×

2201

                                result << constws;

×

UNCOV

2202

                                continue;        // Prevent adding both forms for name

×

2204

                        constw = QString("M %1").arg(n->M_nb);

×

2205

                        constws = constw.mid(0, objUpper.size());

×

2206

                        if (constws.toUpper()==objUpper)

×

2207

                                result << constw;

×

UNCOV

2208

×

2212

        if (objUpper.size()>=1 && objUpper.left(3)=="MEL")

×

2214

                for (const auto& n : dsoArray)

×

2216

                        if (n->Mel_nb==0) continue;

×

2217

                        QString constw = QString("Mel%1").arg(n->Mel_nb);

×

UNCOV

2218

                        QString constws = constw.mid(0, objUpper.size());

×

UNCOV

2219

                        QString constws2 = QString("Melotte%1").arg(n->Mel_nb).mid(0, objUpper.size());

×

UNCOV

2220

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2222

                                result << constws;

×

2223

                                continue;        // Prevent adding both forms for name

×

2225

                        constw = QString("Mel %1").arg(n->Mel_nb);

×

2226

                        constws = constw.mid(0, objUpper.size());

×

2227

                        constws2 = QString("Melotte %1").arg(n->Mel_nb).mid(0, objUpper.size());

×

2228

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2229

                                result << constw;

×

2230

×

2234

        if (objUpper.size()>=1 && objUpper.left(2)=="IC")

×

2236

                for (const auto& n : dsoArray)

×

UNCOV

2238

                        if (n->IC_nb==0) continue;

×

UNCOV

2239

                        QString constw = QString("IC%1").arg(n->IC_nb);

×

UNCOV

2240

                        QString constws = constw.mid(0, objUpper.size());

×

2241

                        if (constws.toUpper()==objUpper)

×

2243

                                result << constws;

×

2244

                                continue;        // Prevent adding both forms for name

×

2246

                        constw = QString("IC %1").arg(n->IC_nb);

×

UNCOV

2247

                        constws = constw.mid(0, objUpper.size());

×

2248

                        if (constws.toUpper()==objUpper)

×

2249

                                result << constw;

×

UNCOV

2250

×

2254

        for (const auto& n : dsoArray)

×

UNCOV

2256

                if (n->NGC_nb==0) continue;

×

UNCOV

2257

                QString constw = QString("NGC%1").arg(n->NGC_nb);

×

2258

                QString constws = constw.mid(0, objUpper.size());

×

UNCOV

2259

                if (constws.toUpper()==objUpper)

×

UNCOV

2261

                        result << constws;

×

2262

                        continue;

×

2264

                constw = QString("NGC %1").arg(n->NGC_nb);

×

2265

                constws = constw.mid(0, objUpper.size());

×

UNCOV

2266

                if (constws.toUpper()==objUpper)

×

2267

                        result << constw;

×

2268

×

2271

        if (objUpper.size()>=1 && objUpper.left(3)=="PGC")

×

2273

                for (const auto& n : dsoArray)

×

UNCOV

2275

                        if (n->PGC_nb==0) continue;

×

UNCOV

2276

                        QString constw = QString("PGC%1").arg(n->PGC_nb);

×

UNCOV

2277

                        QString constws = constw.mid(0, objUpper.size());

×

2278

                        if (constws.toUpper()==objUpper)

×

2280

                                result << constws;        // Prevent adding both forms for name

×

UNCOV

2281

                                continue;

×

2283

                        constw = QString("PGC %1").arg(n->PGC_nb);

×

2284

                        constws = constw.mid(0, objUpper.size());

×

2285

                        if (constws.toUpper()==objUpper)

×

UNCOV

2286

                                result << constw;

×

2287

×

2291

        if (objUpper.size()>=1 && objUpper.left(3)=="UGC")

×

2293

                for (const auto& n : dsoArray)

×

UNCOV

2295

                        if (n->UGC_nb==0) continue;

×

UNCOV

2296

                        QString constw = QString("UGC%1").arg(n->UGC_nb);

×

UNCOV

2297

                        QString constws = constw.mid(0, objUpper.size());

×

2298

                        if (constws.toUpper()==objUpper)

×

2300

                                result << constws;

×

UNCOV

2301

                                continue;        // Prevent adding both forms for name

×

2303

                        constw = QString("UGC %1").arg(n->UGC_nb);

×

2304

                        constws = constw.mid(0, objUpper.size());

×

2305

                        if (constws.toUpper()==objUpper)

×

UNCOV

2306

                                result << constw;

×

2307

×

2311

        if (objUpper.size()>=1 && objUpper.at(0)=='C' && objUpper.left(2)!="CR" && objUpper.left(2)!="CE")

×

2313

                for (const auto& n : dsoArray)

×

UNCOV

2315

                        if (n->C_nb==0) continue;

×

UNCOV

2316

                        QString constw = QString("C%1").arg(n->C_nb);

×

UNCOV

2317

                        QString constws = constw.mid(0, objUpper.size());

×

2318

                        if (constws.toUpper()==objUpper)

×

2320

                                result << constws;

×

UNCOV

2321

                                continue;        // Prevent adding both forms for name

×

2323

                        constw = QString("C %1").arg(n->C_nb);

×

2324

                        constws = constw.mid(0, objUpper.size());

×

2325

                        if (constws.toUpper()==objUpper)

×

2326

                                result << constw;

×

UNCOV

2327

×

2331

        if (objUpper.size()>=1 && (objUpper.left(2)=="CR" || objUpper.left(9)=="COLLINDER"))

×

2333

                for (const auto& n : dsoArray)

×

2335

                        if (n->Cr_nb==0) continue;

×

2336

                        QString constw = QString("Cr%1").arg(n->Cr_nb);

×

UNCOV

2337

                        QString constws = constw.mid(0, objUpper.size());

×

UNCOV

2338

                        QString constws2 = QString("Collinder%1").arg(n->Cr_nb).mid(0, objUpper.size());

×

UNCOV

2339

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2341

                                result << constws;

×

2342

                                continue;        // Prevent adding both forms for name

×

2344

                        constw = QString("Cr %1").arg(n->Cr_nb);

×

2345

                        constws = constw.mid(0, objUpper.size());

×

2346

                        constws2 = QString("Collinder %1").arg(n->Cr_nb).mid(0, objUpper.size());

×

2347

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2348

                                result << constw;

×

2349

×

2353

        if (objUpper.size()>=1 && objUpper.left(3)=="CED")

×

2355

                for (const auto& n : dsoArray)

×

UNCOV

2357

                        if (n->Ced_nb.isEmpty()) continue;

×

UNCOV

2358

                        QString constw = QString("Ced%1").arg(n->Ced_nb);

×

UNCOV

2359

                        QString constws = constw.mid(0, objUpper.size());

×

2360

                        if (constws.toUpper()==objUpper)

×

2362

                                result << constws;

×

UNCOV

2363

                                continue;        // Prevent adding both forms for name

×

2365

                        constw = QString("Ced %1").arg(n->Ced_nb);

×

2366

                        constws = constw.mid(0, objUpper.size());

×

2367

                        if (constws.toUpper()==objUpper)

×

UNCOV

2368

                                result << constw;

×

2369

×

2373

        if (objUpper.size()>=1 && objUpper.at(0)=='B')

×

2375

                for (const auto& n : dsoArray)

×

UNCOV

2377

                        if (n->B_nb==0) continue;

×

UNCOV

2378

                        QString constw = QString("B%1").arg(n->B_nb);

×

UNCOV

2379

                        QString constws = constw.mid(0, objUpper.size());

×

2380

                        if (constws.toUpper()==objUpper)

×

2382

                                result << constws;

×

UNCOV

2383

                                continue;        // Prevent adding both forms for name

×

2385

                        constw = QString("B %1").arg(n->B_nb);

×

2386

                        constws = constw.mid(0, objUpper.size());

×

2387

                        if (constws.toUpper()==objUpper)

×

UNCOV

2388

                                result << constw;

×

2389

×

2393

        if (objUpper.size()>=1 && objUpper.left(2)=="SH")

×

2395

                for (const auto& n : dsoArray)

×

UNCOV

2397

                        if (n->Sh2_nb==0) continue;

×

UNCOV

2398

                        QString constw = QString("SH2-%1").arg(n->Sh2_nb);

×

UNCOV

2399

                        QString constws = constw.mid(0, objUpper.size());

×

2400

                        if (constws.toUpper()==objUpper)

×

2402

                                result << constws;

×

UNCOV

2403

                                continue;        // Prevent adding both forms for name

×

2405

                        constw = QString("SH 2-%1").arg(n->Sh2_nb);

×

2406

                        constws = constw.mid(0, objUpper.size());

×

2407

                        if (constws.toUpper()==objUpper)

×

UNCOV

2408

                                result << constw;

×

2409

×

2413

        if (objUpper.size()>=1 && objUpper.left(3)=="VDB" && objUpper.left(6)!="VDB-HA" && objUpper.left(4)!="VDBH")

×

2415

                for (const auto& n : dsoArray)

×

UNCOV

2417

                        if (n->VdB_nb==0) continue;

×

UNCOV

2418

                        QString constw = QString("vdB%1").arg(n->VdB_nb);

×

UNCOV

2419

                        QString constws = constw.mid(0, objUpper.size());

×

2420

                        if (constws.toUpper()==objUpper)

×

2422

                                result << constws;

×

UNCOV

2423

                                continue;        // Prevent adding both forms for name

×

2425

                        constw = QString("vdB %1").arg(n->VdB_nb);

×

2426

                        constws = constw.mid(0, objUpper.size());

×

2427

                        if (constws.toUpper()==objUpper)

×

UNCOV

2428

                                result << constw;

×

2429

×

2433

        if (objUpper.size()>=1 && objUpper.left(3)=="RCW")

×

2435

                for (const auto& n : dsoArray)

×

UNCOV

2437

                        if (n->RCW_nb==0) continue;

×

UNCOV

2438

                        QString constw = QString("RCW%1").arg(n->RCW_nb);

×

UNCOV

2439

                        QString constws = constw.mid(0, objUpper.size());

×

2440

                        if (constws.toUpper()==objUpper)

×

2442

                                result << constws;

×

UNCOV

2443

                                continue;        // Prevent adding both forms for name

×

2445

                        constw = QString("RCW %1").arg(n->RCW_nb);

×

2446

                        constws = constw.mid(0, objUpper.size());

×

2447

                        if (constws.toUpper()==objUpper)

×

UNCOV

2448

                                result << constw;

×

2449

×

2453

        if (objUpper.size()>=1 && objUpper.left(3)=="LDN")

×

2455

                for (const auto& n : dsoArray)

×

UNCOV

2457

                        if (n->LDN_nb==0) continue;

×

UNCOV

2458

                        QString constw = QString("LDN%1").arg(n->LDN_nb);

×

UNCOV

2459

                        QString constws = constw.mid(0, objUpper.size());

×

2460

                        if (constws.toUpper()==objUpper)

×

2462

                                result << constws;

×

UNCOV

2463

                                continue;        // Prevent adding both forms for name

×

2465

                        constw = QString("LDN %1").arg(n->LDN_nb);

×

2466

                        constws = constw.mid(0, objUpper.size());

×

2467

                        if (constws.toUpper()==objUpper)

×

UNCOV

2468

                                result << constw;

×

2469

×

2473

        if (objUpper.size()>=1 && objUpper.left(3)=="LBN")

×

2475

                for (const auto& n : dsoArray)

×

UNCOV

2477

                        if (n->LBN_nb==0) continue;

×

UNCOV

2478

                        QString constw = QString("LBN%1").arg(n->LBN_nb);

×

UNCOV

2479

                        QString constws = constw.mid(0, objUpper.size());

×

2480

                        if (constws.toUpper()==objUpper)

×

2482

                                result << constws;

×

UNCOV

2483

                                continue;        // Prevent adding both forms for name

×

2485

                        constw = QString("LBN %1").arg(n->LBN_nb);

×

2486

                        constws = constw.mid(0, objUpper.size());

×

2487

                        if (constws.toUpper()==objUpper)

×

UNCOV

2488

                                result << constw;

×

2489

×

2493

        if (objUpper.size()>=1 && objUpper.left(3)=="ARP")

×

2495

                for (const auto& n : dsoArray)

×

UNCOV

2497

                        if (n->Arp_nb==0) continue;

×

UNCOV

2498

                        QString constw = QString("Arp%1").arg(n->Arp_nb);

×

UNCOV

2499

                        QString constws = constw.mid(0, objUpper.size());

×

2500

                        if (constws.toUpper()==objUpper)

×

2502

                                result << constws;

×

UNCOV

2503

                                continue;        // Prevent adding both forms for name

×

2505

                        constw = QString("Arp %1").arg(n->Arp_nb);

×

2506

                        constws = constw.mid(0, objUpper.size());

×

2507

                        if (constws.toUpper()==objUpper)

×

UNCOV

2508

                                result << constw;

×

2509

×

2513

        if (objUpper.size()>=1 && objUpper.left(2)=="VV")

×

2515

                for (const auto& n : dsoArray)

×

UNCOV

2517

                        if (n->VV_nb==0) continue;

×

UNCOV

2518

                        QString constw = QString("VV%1").arg(n->VV_nb);

×

UNCOV

2519

                        QString constws = constw.mid(0, objUpper.size());

×

2520

                        if (constws.toUpper()==objUpper)

×

2522

                                result << constws;

×

UNCOV

2523

                                continue;        // Prevent adding both forms for name

×

2525

                        constw = QString("VV %1").arg(n->VV_nb);

×

2526

                        constws = constw.mid(0, objUpper.size());

×

2527

                        if (constws.toUpper()==objUpper)

×

UNCOV

2528

                                result << constw;

×

2529

×

2533

        if (objUpper.size()>=1 && objUpper.left(2)=="PK")

×

2535

                for (const auto& n : dsoArray)

×

UNCOV

2537

                        if (n->PK_nb.isEmpty()) continue;

×

UNCOV

2538

                        QString constw = QString("PK%1").arg(n->PK_nb);

×

UNCOV

2539

                        QString constws = constw.mid(0, objUpper.size());

×

2540

                        if (constws.toUpper()==objUpper)

×

2542

                                result << constws;

×

UNCOV

2543

                                continue;        // Prevent adding both forms for name

×

2545

                        constw = QString("PK %1").arg(n->PK_nb);

×

2546

                        constws = constw.mid(0, objUpper.size());

×

2547

                        if (constws.toUpper()==objUpper)

×

UNCOV

2548

                                result << constw;

×

2549

×

2553

        if (objUpper.size()>=1 && objUpper.left(2)=="PN")

×

2555

                for (const auto& n : dsoArray)

×

UNCOV

2557

                        if (n->PNG_nb.isEmpty()) continue;

×

UNCOV

2558

                        QString constw = QString("PNG%1").arg(n->PNG_nb);

×

UNCOV

2559

                        QString constws = constw.mid(0, objUpper.size());

×

2560

                        if (constws.toUpper()==objUpper)

×

2562

                                result << constws;

×

UNCOV

2563

                                continue;        // Prevent adding both forms for name

×

2565

                        constw = QString("PN G%1").arg(n->PNG_nb);

×

2566

                        constws = constw.mid(0, objUpper.size());

×

2567

                        if (constws.toUpper()==objUpper)

×

UNCOV

2568

                                result << constw;

×

2569

×

2573

        if (objUpper.size()>=1 && objUpper.left(3)=="SNR")

×

2575

                for (const auto& n : dsoArray)

×

UNCOV

2577

                        if (n->SNRG_nb.isEmpty()) continue;

×

UNCOV

2578

                        QString constw = QString("SNRG%1").arg(n->SNRG_nb);

×

UNCOV

2579

                        QString constws = constw.mid(0, objUpper.size());

×

2580

                        if (constws.toUpper()==objUpper)

×

2582

                                result << constws;

×

UNCOV

2583

                                continue;        // Prevent adding both forms for name

×

2585

                        constw = QString("SNR G%1").arg(n->SNRG_nb);

×

2586

                        constws = constw.mid(0, objUpper.size());

×

2587

                        if (constws.toUpper()==objUpper)

×

2588

                                result << constw;

×

UNCOV

2589

×

2593

        if (objUpper.size()>=1 && (objUpper.left(5)=="ABELL" || objUpper.left(3)=="ACO"))

×

2595

                for (const auto& n : dsoArray)

×

2597

                        if (n->ACO_nb.isEmpty()) continue;

×

2598

                        QString constw = QString("Abell%1").arg(n->ACO_nb);

×

UNCOV

2599

                        QString constws = constw.mid(0, objUpper.size());

×

UNCOV

2600

                        QString constws2 = QString("ACO%1").arg(n->ACO_nb).mid(0, objUpper.size());

×

UNCOV

2601

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2603

                                result << constws;

×

2604

                                continue;        // Prevent adding both forms for name

×

2606

                        constw = QString("Abell %1").arg(n->ACO_nb);

×

2607

                        constws = constw.mid(0, objUpper.size());

×

2608

                        constws2 = QString("ACO %1").arg(n->ACO_nb).mid(0, objUpper.size());

×

2609

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2610

                                result << constw;

×

2611

×

2615

        if (objUpper.size()>=1 && objUpper.left(3)=="HCG")

×

2617

                for (const auto& n : dsoArray)

×

UNCOV

2619

                        if (n->HCG_nb.isEmpty()) continue;

×

UNCOV

2620

                        QString constw = QString("HCG%1").arg(n->HCG_nb);

×

UNCOV

2621

                        QString constws = constw.mid(0, objUpper.size());

×

2622

                        if (constws.toUpper()==objUpper)

×

2624

                                result << constws;

×

UNCOV

2625

                                continue;        // Prevent adding both forms for name

×

2627

                        constw = QString("HCG %1").arg(n->HCG_nb);

×

2628

                        constws = constw.mid(0, objUpper.size());

×

2629

                        if (constws.toUpper()==objUpper)

×

UNCOV

2630

                                result << constw;

×

2631

×

2635

        if (objUpper.size()>=1 && objUpper.left(3)=="ESO")

×

2637

                for (const auto& n : dsoArray)

×

UNCOV

2639

                        if (n->ESO_nb.isEmpty()) continue;

×

UNCOV

2640

                        QString constw = QString("ESO%1").arg(n->ESO_nb);

×

UNCOV

2641

                        QString constws = constw.mid(0, objUpper.size());

×

2642

                        if (constws.toUpper()==objUpper)

×

2644

                                result << constws;

×

UNCOV

2645

                                continue;        // Prevent adding both forms for name

×

2647

                        constw = QString("ESO %1").arg(n->ESO_nb);

×

2648

                        constws = constw.mid(0, objUpper.size());

×

2649

                        if (constws.toUpper()==objUpper)

×

UNCOV

2650

                                result << constw;

×

2651

×

2655

        if (objUpper.size()>=1 && objUpper.left(4)=="VDBH")

×

2657

                for (const auto& n : dsoArray)

×

UNCOV

2659

                        if (n->VdBH_nb.isEmpty()) continue;

×

UNCOV

2660

                        QString constw = QString("vdBH%1").arg(n->VdBH_nb);

×

UNCOV

2661

                        QString constws = constw.mid(0, objUpper.size());

×

2662

                        if (constws.toUpper()==objUpper)

×

2664

                                result << constws;

×

UNCOV

2665

                                continue;        // Prevent adding both forms for name

×

2667

                        constw = QString("vdBH %1").arg(n->VdBH_nb);

×

2668

                        constws = constw.mid(0, objUpper.size());

×

2669

                        if (constws.toUpper()==objUpper)

×

UNCOV

2670

                                result << constw;

×

2671

×

2675

        if (objUpper.size()>=1 && objUpper.left(3)=="DWB")

×

2677

                for (const auto& n : dsoArray)

×

UNCOV

2679

                        if (n->DWB_nb==0) continue;

×

UNCOV

2680

                        QString constw = QString("DWB%1").arg(n->DWB_nb);

×

UNCOV

2681

                        QString constws = constw.mid(0, objUpper.size());

×

2682

                        if (constws.toUpper()==objUpper)

×

2684

                                result << constws;

×

UNCOV

2685

                                continue;        // Prevent adding both forms for name

×

2687

                        constw = QString("DWB %1").arg(n->DWB_nb);

×

2688

                        constws = constw.mid(0, objUpper.size());

×

2689

                        if (constws.toUpper()==objUpper)

×

2690

                                result << constw;

×

UNCOV

2691

×

2695

        if (objUpper.size()>=1 && (objUpper.left(8)=="TRUMPLER" || objUpper.left(2)=="TR"))

×

2697

                for (const auto& n : dsoArray)

×

2699

                        if (n->Tr_nb==0) continue;

×

2700

                        QString constw = QString("Tr%1").arg(n->Tr_nb);

×

UNCOV

2701

                        QString constws = constw.mid(0, objUpper.size());

×

UNCOV

2702

                        QString constws2 = QString("Trumpler%1").arg(n->Tr_nb).mid(0, objUpper.size());

×

UNCOV

2703

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2705

                                result << constws;

×

2706

                                continue;        // Prevent adding both forms for name

×

2708

                        constw = QString("Tr %1").arg(n->Tr_nb);

×

2709

                        constws = constw.mid(0, objUpper.size());

×

2710

                        constws2 = QString("Trumpler %1").arg(n->Tr_nb).mid(0, objUpper.size());

×

2711

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

2712

                                result << constw;

×

UNCOV

2713

×

2717

        if (objUpper.size()>=1 && (objUpper.left(5)=="STOCK" || objUpper.left(2)=="ST"))

×

2719

                for (const auto& n : dsoArray)

×

2721

                        if (n->St_nb==0) continue;

×

2722

                        QString constw = QString("St%1").arg(n->St_nb);

×

UNCOV

2723

                        QString constws = constw.mid(0, objUpper.size());

×

UNCOV

2724

                        QString constws2 = QString("Stock%1").arg(n->St_nb).mid(0, objUpper.size());

×

UNCOV

2725

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2727

                                result << constws;

×

2728

                                continue;        // Prevent adding both forms for name

×

2730

                        constw = QString("St %1").arg(n->St_nb);

×

2731

                        constws = constw.mid(0, objUpper.size());

×

2732

                        constws2 = QString("Stock %1").arg(n->St_nb).mid(0, objUpper.size());

×

2733

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

2734

                                result << constw;

×

UNCOV

2735

×

2739

        if (objUpper.size()>=1 && (objUpper.left(8)=="RUPRECHT" || objUpper.left(2)=="RU"))

×

2741

                for (const auto& n : dsoArray)

×

2743

                        if (n->Ru_nb==0) continue;

×

2744

                        QString constw = QString("Ru%1").arg(n->Ru_nb);

×

UNCOV

2745

                        QString constws = constw.mid(0, objUpper.size());

×

UNCOV

2746

                        QString constws2 = QString("Ruprecht%1").arg(n->Ru_nb).mid(0, objUpper.size());

×

UNCOV

2747

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2749

                                result << constws;

×

2750

                                continue;        // Prevent adding both forms for name

×

2752

                        constw = QString("Ru %1").arg(n->Ru_nb);

×

2753

                        constws = constw.mid(0, objUpper.size());

×

2754

                        constws2 = QString("Ruprecht %1").arg(n->Ru_nb).mid(0, objUpper.size());

×

2755

                        if (constws.toUpper()==objUpper || constws2.toUpper()==objUpper)

×

UNCOV

2756

                                result << constw;

×

2757

×

2761

        if (objUpper.size()>=1 && objUpper.left(6)=="VDB-HA")

×

2763

                for (const auto& n : dsoArray)

×

UNCOV

2765

                        if (n->VdBHa_nb==0) continue;

×

UNCOV

2766

                        QString constw = QString("vdB-Ha%1").arg(n->VdBHa_nb);

×

UNCOV

2767

                        QString constws = constw.mid(0, objUpper.size());

×

2768

                        if (constws.toUpper()==objUpper)

×

UNCOV

2770

                                result << constws;

×

2771

                                continue;        // Prevent adding both forms for name

×

2773

                        constw = QString("vdB-Ha %1").arg(n->VdBHa_nb);

×

UNCOV

2774

                        constws = constw.mid(0, objUpper.size());

×

2775

                        if (constws.toUpper()==objUpper)

×

2776

                                result << constw;

×

2777

×

2781

        QStringList names;

×

2782

        for (const auto& n : dsoArray)

×

UNCOV

2784

                names.append(n->nameI18);

×

2785

                names.append(n->englishName);

×

2786

                if (getFlagAdditionalNames())

×

2788

                        names.append(n->nameI18Aliases);

×

2789

                        names.append(n->englishAliases);

×

UNCOV

2793

        QString fullMatch = "";

×

2794

        for (const auto& name : std::as_const(names))

×

UNCOV

2796

                if (!matchObjectName(name, objPrefix, useStartOfWords))

×

2797

                        continue;

×

2799

                if (name==objPrefix)

×

UNCOV

2800

                        fullMatch = name;

×

2802

                        result.append(name);

×

2805

        result.sort();

×

UNCOV

2806

        if (!fullMatch.isEmpty())

×

2807

                result.prepend(fullMatch);

×

2809

        if (result.size() > maxNbItem)

×

2810

                result.erase(result.begin() + maxNbItem, result.end());

×

2812

        return result;

×

UNCOV

2813

×

2815

QStringList NebulaMgr::listAllObjects(bool inEnglish) const

×

2817

        QStringList result;

×

UNCOV

2818

        for (const auto& n : dsoArray)

×

2820

                if (!n->getEnglishName().isEmpty())

×

UNCOV

2822

                        if (inEnglish)

×

2823

                                result << n->getEnglishName();

×

2825

                                result << n->getNameI18n();

×

UNCOV

2828

        return result;

×

2829

×

UNCOV

2831

QStringList NebulaMgr::listAllObjectsByType(const QString &objType, bool inEnglish) const

×

UNCOV

2833

        QStringList result;

×

2834

        int type = objType.toInt();

×

UNCOV

2835

        switch (type)

×

2837

                case 0: // Bright galaxies?

×

UNCOV

2838

                        for (const auto& n : dsoArray)

×

UNCOV

2840

                                if (n->nType==type && qMin(n->vMag, n->bMag)<=10.f)

×

2842

                                        if (!n->getEnglishName().isEmpty())

×

UNCOV

2844

                                                if (inEnglish)

×

2845

                                                        result << n->getEnglishName();

×

2847

                                                        result << n->getNameI18n();

×

2850

                                                result << n->getDSODesignationWIC();

×

2853

                        break;

×

2854

                case 100: // Messier Catalogue?

×

2855

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2856

                                result << QString("M%1").arg(n->M_nb);

×

2857

                        break;

×

2858

                case 101: // Caldwell Catalogue?

×

2859

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2860

                                result << QString("C%1").arg(n->C_nb);

×

2861

                        break;

×

2862

                case 102: // Barnard Catalogue?

×

2863

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2864

                                result << QString("B %1").arg(n->B_nb);

×

2865

                        break;

×

2866

                case 103: // Sharpless Catalogue?

×

2867

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2868

                                result << QString("SH 2-%1").arg(n->Sh2_nb);

×

2869

                        break;

×

2870

                case 104: // van den Bergh Catalogue

×

2871

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2872

                                result << QString("vdB %1").arg(n->VdB_nb);

×

2873

                        break;

×

2874

                case 105: // RCW Catalogue

×

2875

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2876

                                result << QString("RCW %1").arg(n->RCW_nb);

×

2877

                        break;

×

2878

                case 106: // Collinder Catalogue

×

2879

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2880

                                result << QString("Cr %1").arg(n->Cr_nb);

×

2881

                        break;

×

2882

                case 107: // Melotte Catalogue

×

2883

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2884

                                result << QString("Mel %1").arg(n->Mel_nb);

×

2885

                        break;

×

2886

                case 108: // New General Catalogue

×

2887

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2888

                                result << QString("NGC %1").arg(n->NGC_nb);

×

2889

                        break;

×

2890

                case 109: // Index Catalogue

×

2891

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2892

                                result << QString("IC %1").arg(n->IC_nb);

×

2893

                        break;

×

2894

                case 110: // Lynds' Catalogue of Bright Nebulae

×

2895

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2896

                                result << QString("LBN %1").arg(n->LBN_nb);

×

2897

                        break;

×

2898

                case 111: // Lynds' Catalogue of Dark Nebulae

×

2899

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2900

                                result << QString("LDN %1").arg(n->LDN_nb);

×

2901

                        break;

×

2902

                case 114: // Cederblad Catalog

×

2903

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2904

                                result << QString("Ced %1").arg(n->Ced_nb);

×

2905

                        break;

×

2906

                case 115: // Atlas of Peculiar Galaxies (Arp)

×

2907

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2908

                                result << QString("Arp %1").arg(n->Arp_nb);

×

2909

                        break;

×

2910

                case 116: // The Catalogue of Interacting Galaxies by Vorontsov-Velyaminov (VV)

×

2911

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2912

                                result << QString("VV %1").arg(n->VV_nb);

×

2913

                        break;

×

2914

                case 117: // Catalogue of Galactic Planetary Nebulae (PK)

×

2915

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2916

                                result << QString("PK %1").arg(n->PK_nb);

×

2917

                        break;

×

2918

                case 118: // Strasbourg-ESO Catalogue of Galactic Planetary Nebulae by Acker et. al. (PN G)

×

2919

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2920

                                result << QString("PN G%1").arg(n->PNG_nb);

×

2921

                        break;

×

2922

                case 119: // A catalogue of Galactic supernova remnants by Green (SNR G)

×

2923

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2924

                                result << QString("SNR G%1").arg(n->SNRG_nb);

×

2925

                        break;

×

2926

                case 120: // A Catalog of Rich Clusters of Galaxies by Abell et. al. (Abell (ACO))

×

2927

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2928

                                result << QString("Abell %1").arg(n->ACO_nb);

×

2929

                        break;

×

2930

                case 121: // Hickson Compact Group by Hickson et. al. (HCG)

×

2931

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2932

                                result << QString("HCG %1").arg(n->HCG_nb);

×

2933

                        break;

×

2934

                case 122: // ESO/Uppsala Survey of the ESO(B) Atlas (ESO)

×

2935

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2936

                                result << QString("ESO %1").arg(n->ESO_nb);

×

2937

                        break;

×

2938

                case 123: // Catalogue of southern stars embedded in nebulosity (vdBH)

×

2939

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2940

                                result << QString("vdBH %1").arg(n->VdBH_nb);

×

2941

                        break;

×

2942

                case 124: // Catalogue and distances of optically visible H II regions (DWB)

×

2943

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2944

                                result << QString("DWB %1").arg(n->DWB_nb);

×

2945

                        break;

×

2946

                case 125: // Trumpler Catalogue (Tr)

×

2947

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2948

                                result << QString("Tr %1").arg(n->Tr_nb);

×

2949

                        break;

×

2950

                case 126: // Stock Catalogue (St)

×

2951

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2952

                                result << QString("St %1").arg(n->St_nb);

×

2953

                        break;

×

2954

                case 127: // Ruprecht Catalogue (Ru)

×

UNCOV

2955

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2956

                                result << QString("Ru %1").arg(n->Ru_nb);

×

2957

                        break;

×

2958

                case 128: // van den Bergh-Hagen Catalogue (VdB-Ha)

×

UNCOV

2959

                        for (const auto& n : getDeepSkyObjectsByType(objType))

×

2960

                                result << QString("vdB-Ha %1").arg(n->VdBHa_nb);

×

UNCOV

2961

                        break;

×

2962

                case 150: // Dwarf galaxies [see NebulaList.hpp]

×

2964

                        for (unsigned int i = 0; i < sizeof(DWARF_GALAXIES) / sizeof(DWARF_GALAXIES[0]); i++)

×

UNCOV

2965

                                result << QString("PGC %1").arg(DWARF_GALAXIES[i]);

×

2966

                        break;

×

2968

                case 151: // Herschel 400 Catalogue [see NebulaList.hpp]

×

2970

                        for (unsigned int i = 0; i < sizeof(H400_LIST) / sizeof(H400_LIST[0]); i++)

×

2971

                                result << QString("NGC %1").arg(H400_LIST[i]);

×

UNCOV

2972

                        break;

×

UNCOV

2974

                case 152: // Jack Bennett's deep sky catalogue [see NebulaList.hpp]

×

2976

                        for (unsigned int i = 0; i < sizeof(BENNETT_LIST) / sizeof(BENNETT_LIST[0]); i++)

×

2977

                                result << QString("NGC %1").arg(BENNETT_LIST[i]);

×

UNCOV

2978

                        result << "Mel 105" << "IC 1459";

×

2979

                        break;

×

2981

                case 153: // James Dunlop's deep sky catalogue [see NebulaList.hpp]

×

2983

                        for (unsigned int i = 0; i < sizeof(DUNLOP_LIST) / sizeof(DUNLOP_LIST[0]); i++)

×

UNCOV

2984

                                result << QString("NGC %1").arg(DUNLOP_LIST[i]);

×

2985

                        break;

×

2987

                default:

×

UNCOV

2989

                        for (const auto& n : dsoArray)

×

UNCOV

2991

                                if (n->nType==type)

×

2993

                                        if (!n->getEnglishName().isEmpty())

×

UNCOV

2995

                                                if (inEnglish)

×

2996

                                                        result << n->getEnglishName();

×

UNCOV

2998

                                                        result << n->getNameI18n();

×

3001

                                                result << n->getDSODesignationWIC();

×

3004

                        break;

×

3008

        result.removeDuplicates();

×

UNCOV

3009

        return result;

×

3010

×

UNCOV

3012

const QList<NebulaP> NebulaMgr::getDeepSkyObjectsByType(const QString &objType) const

×

3014

        QList<NebulaP> dso;

×

UNCOV

3015

        int type = objType.toInt();

×

3016

        switch (type)

×

3018

                case 100: // Messier Catalogue?

×

UNCOV

3019

                        for (const auto& n : dsoArray)

×

3021

                                if (n->M_nb>0)

×

UNCOV

3022

                                        dso.append(n);

×

3024

                        break;

×

3025

                case 101: // Caldwell Catalogue?

×

UNCOV

3026

                        for (const auto& n : dsoArray)

×

3028

                                if (n->C_nb>0)

×

UNCOV

3029

                                        dso.append(n);

×

3031

                        break;

×

3032

                case 102: // Barnard Catalogue?

×

UNCOV

3033

                        for (const auto& n : dsoArray)

×

3035

                                if (n->B_nb>0)

×

UNCOV

3036

                                        dso.append(n);

×

3038

                        break;

×

3039

                case 103: // Sharpless Catalogue?

×

UNCOV

3040

                        for (const auto& n : dsoArray)

×

3042

                                if (n->Sh2_nb>0)

×

UNCOV

3043

                                        dso.append(n);

×

3045

                        break;

×

3046

                case 104: // van den Bergh Catalogue

×

UNCOV

3047

                        for (const auto& n : dsoArray)

×

3049

                                if (n->VdB_nb>0)

×

UNCOV

3050

                                        dso.append(n);

×

3052

                        break;

×

3053

                case 105: // RCW Catalogue

×

UNCOV

3054

                        for (const auto& n : dsoArray)

×

3056

                                if (n->RCW_nb>0)

×

UNCOV

3057

                                        dso.append(n);

×

3059

                        break;

×

3060

                case 106: // Collinder Catalogue

×

UNCOV

3061

                        for (const auto& n : dsoArray)

×

3063

                                if (n->Cr_nb>0)

×

UNCOV

3064

                                        dso.append(n);

×

3066

                        break;

×

3067

                case 107: // Melotte Catalogue

×

UNCOV

3068

                        for (const auto& n : dsoArray)

×

3070

                                if (n->Mel_nb>0)

×

UNCOV

3071

                                        dso.append(n);

×

3073

                        break;

×

3074

                case 108: // New General Catalogue

×

UNCOV

3075

                        for (const auto& n : dsoArray)

×

3077

                                if (n->NGC_nb>0)

×

UNCOV

3078

                                        dso.append(n);

×

3080

                        break;

×

3081

                case 109: // Index Catalogue

×

UNCOV

3082

                        for (const auto& n : dsoArray)

×

3084

                                if (n->IC_nb>0)

×

UNCOV

3085

                                        dso.append(n);

×

3087

                        break;

×

3088

                case 110: // Lynds' Catalogue of Bright Nebulae

×

UNCOV

3089

                        for (const auto& n : dsoArray)

×

3091

                                if (n->LBN_nb>0)

×

UNCOV

3092

                                        dso.append(n);

×

3094

                        break;

×

3095

                case 111: // Lynds' Catalogue of Dark Nebulae

×

UNCOV

3096

                        for (const auto& n : dsoArray)

×

3098

                                if (n->LDN_nb>0)

×

UNCOV

3099

                                        dso.append(n);

×

3101

                        break;

×

3102

                case 112: // Principal Galaxy Catalog

×

UNCOV

3103

                        for (const auto& n : dsoArray)

×

3105

                                if (n->PGC_nb>0)

×

UNCOV

3106

                                        dso.append(n);

×

3108

                        break;

×

3109

                case 113: // The Uppsala General Catalogue of Galaxies

×

UNCOV

3110

                        for (const auto& n : dsoArray)

×

3112

                                if (n->UGC_nb>0)

×

UNCOV

3113

                                        dso.append(n);

×

3115

                        break;

×

3116

                case 114: // Cederblad Catalog

×

UNCOV

3117

                        for (const auto& n : dsoArray)

×

3119

                                if (!n->Ced_nb.isEmpty())

×

UNCOV

3120

                                        dso.append(n);

×

3122

                        break;

×

3123

                case 115: // Atlas of Peculiar Galaxies (Arp)

×

UNCOV

3124

                        for (const auto& n : dsoArray)

×

3126

                                if (n->Arp_nb>0)

×

UNCOV

3127

                                        dso.append(n);

×

3129

                        break;

×

3130

                case 116: // The Catalogue of Interacting Galaxies by Vorontsov-Velyaminov (VV)

×

UNCOV

3131

                        for (const auto& n : dsoArray)

×

3133

                                if (n->VV_nb>0)

×

UNCOV

3134

                                        dso.append(n);

×

3136

                        break;

×

3137

                case 117: // Catalogue of Galactic Planetary Nebulae (PK)

×

UNCOV

3138

                        for (const auto& n : dsoArray)

×

3140

                                if (!n->PK_nb.isEmpty())

×

UNCOV

3141

                                        dso.append(n);

×

3143

                        break;

×

3144

                case 118: // Strasbourg-ESO Catalogue of Galactic Planetary Nebulae by Acker et. al. (PN G)

×

UNCOV

3145

                        for (const auto& n : dsoArray)

×

3147

                                if (!n->PNG_nb.isEmpty())

×

UNCOV

3148

                                        dso.append(n);

×

3150

                        break;

×

3151

                case 119: // A catalogue of Galactic supernova remnants by Green (SNR G)

×

UNCOV

3152

                        for (const auto& n : dsoArray)

×

3154

                                if (!n->SNRG_nb.isEmpty())

×

UNCOV

3155

                                        dso.append(n);

×

3157

                        break;

×

3158

                case 120: // A Catalog of Rich Clusters of Galaxies by Abell et. al. (ACO)

×

UNCOV

3159

                        for (const auto& n : dsoArray)

×

3161

                                if (!n->ACO_nb.isEmpty())

×

UNCOV

3162

                                        dso.append(n);

×

3164

                        break;

×

3165

                case 121: // Hickson Compact Group by Hickson et. al. (HCG)

×

UNCOV

3166

                        for (const auto& n : dsoArray)

×

3168

                                if (!n->HCG_nb.isEmpty())

×

UNCOV

3169

                                        dso.append(n);

×

3171

                        break;

×

3172

                case 122: // ESO/Uppsala Survey of the ESO(B) Atlas (ESO)

×

UNCOV

3173

                        for (const auto& n : dsoArray)

×

3175

                                if (!n->ESO_nb.isEmpty())

×

UNCOV

3176

                                        dso.append(n);

×

3178

                        break;

×

3179

                case 123: // Catalogue of southern stars embedded in nebulosity (VdBH)

×

UNCOV

3180

                        for (const auto& n : dsoArray)

×

3182

                                if (!n->VdBH_nb.isEmpty())

×

UNCOV

3183

                                        dso.append(n);

×

3185

                        break;

×

3186

                case 124: // Catalogue and distances of optically visible H II regions (DWB)

×

UNCOV

3187

                        for (const auto& n : dsoArray)

×

3189

                                if (n->DWB_nb > 0)

×

UNCOV

3190

                                        dso.append(n);

×

3192

                        break;

×

3193

                case 125: // Trumpler Catalogue (Tr)

×

UNCOV

3194

                        for (const auto& n : dsoArray)

×

3196

                                if (n->Tr_nb > 0)

×

UNCOV

3197

                                        dso.append(n);

×

3199

                        break;

×

3200

                case 126: // Stock Catalogue (St)

×

UNCOV

3201

                        for (const auto& n : dsoArray)

×

3203

                                if (n->St_nb > 0)

×

UNCOV

3204

                                        dso.append(n);

×

3206

                        break;

×

3207

                case 127: // Ruprecht Catalogue (Ru)

×

UNCOV

3208

                        for (const auto& n : dsoArray)

×

3210

                                if (n->Ru_nb > 0)

×

UNCOV

3211

                                        dso.append(n);

×

3213

                        break;

×

UNCOV

3214

                case 128: // van den Bergh-Hagen Catalogue (VdB-Ha)

×

3215

                        for (const auto& n : dsoArray)

×

UNCOV

3217

                                if (n->VdBHa_nb > 0)

×

3218

                                        dso.append(n);

×

3220

                        break;

×

UNCOV

3221

                case 150: // Dwarf galaxies [see NebulaList.hpp]

×

3223

                        NebulaP ds;

×

3224

                        for (unsigned int i = 0; i < sizeof(DWARF_GALAXIES) / sizeof(DWARF_GALAXIES[0]); i++)

×

3226

                                ds = searchPGC(DWARF_GALAXIES[i]);

×

3227

                                if (!ds.isNull())

×

UNCOV

3228

                                        dso.append(ds);

×

3230

                        break;

×

3231

×

UNCOV

3232

                case 151: // Herschel 400 Catalogue [see NebulaList.hpp]

×

3234

                        NebulaP ds;

×

3235

                        for (unsigned int i = 0; i < sizeof(H400_LIST) / sizeof(H400_LIST[0]); i++)

×

3237

                                ds = searchNGC(H400_LIST[i]);

×

3238

                                if (!ds.isNull())

×

UNCOV

3239

                                        dso.append(ds);

×

3241

                        break;

×

3242

×

UNCOV

3243

                case 152: // Jack Bennett's deep sky catalogue [see NebulaList.hpp]

×

3245

                        NebulaP ds;

×

3246

                        for (unsigned int i = 0; i < sizeof(BENNETT_LIST) / sizeof(BENNETT_LIST[0]); i++)

×

3248

                                ds = searchNGC(BENNETT_LIST[i]);

×

3249

                                if (!ds.isNull())

×

3250

                                        dso.append(ds);

×

3252

                        ds = searchMel(105);

×

UNCOV

3253

                        if (!ds.isNull())

×

3254

                                dso.append(ds);

×

3255

                        ds = searchIC(1459);

×

UNCOV

3256

                        if (!ds.isNull())

×

3257

                                dso.append(ds);

×

3258

                        break;

×

3259

×

UNCOV

3260

                case 153: // James Dunlop's deep sky catalogue [see NebulaList.hpp]

×

3262

                        NebulaP ds;

×

3263

                        for (unsigned int i = 0; i < sizeof(DUNLOP_LIST) / sizeof(DUNLOP_LIST[0]); i++)

×

3265

                                ds = searchNGC(DUNLOP_LIST[i]);

×

UNCOV

3266

                                if (!ds.isNull())

×

3267

                                        dso.append(ds);

×

UNCOV

3269

                        break;

×

3270

×

UNCOV

3271

                default:

×

UNCOV

3273

                        for (const auto& n : dsoArray)

×

3275

                                if (n->nType==type)

×

UNCOV

3276

                                        dso.append(n);

×

UNCOV

3278

                        break;

×

UNCOV

3282

        return dso;

×

UNCOV

3283

×

Stellarium / stellarium / 15291801018

Source File
Press 'n' to go to next uncovered line, 'b' for previous

Stellarium / stellarium / 15291801018

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous