Merge lp:~georg-zotti/stellarium/extinction into lp:stellarium

[gzotti]

Extinction for point-like objects

Extinction (reduced symbol size) and textual info on reduced magnitudes work for all (?) point-like and planetary objects.

I don't know how to process Milky Way and the nebulous images, help welcome!

Extinction introduces a new entry in config.ini:
[astro]/flag_extinction_below_horizon=(true|false).
[edited to follow Bogdan's suggestion]

If true, objects lower than -2 degrees are extincted with 42 airmasses (just below horizontal... ;-), if false, 0, i.e., they are bright again below the horizon.

[Alexander Wolf (alexwolf)]

You need add [astro]/subhorizontal_extinction to default_config.ini and set some default setting value. Also we added new plugin with stellar objects - Quasars - I think you can copy code for this plugin from Supernovae plugin.

review: Needs Fixing

[Bogdan Marinov (daggerstab)]

Also, for consistency, it should be something like "astro/flag_extinction_below_horizon".

review: Needs Fixing

[lp:~georg-zotti/stellarium/extinction]

4977. By gzotti on 2011-12-29

added extinction to Quasars plugin.
harmonized infostrings.
renamed flag, added to default_config.ini

4978. By gzotti on 2011-12-29

fixed Supernova::getSelectPriority()

4979. By gzotti on 2011-12-29

updated docs

[Alexander Wolf (alexwolf)]

Work looks is very good!

review: Approve

[lp:~georg-zotti/stellarium/extinction]

4980. By gzotti on 2011-12-29

docfix

[gzotti (georg-zotti)]

@Alex: OK, I was not aware of the default_config.ini. Quasars is done.
@Bogdan: OK, name changed

I hope it's all done now for the point sources.

Note that I also implemented 2 more sets of planetary magnitude computation (I forgot that already...), including the missing Saturn's rings magnitude contribution which was marked TODO. For Stellarium, I think the classical naked-eye "visual" magnitudes are preferrable over instrumental "V" magnitudes. Whichever solution you choose, please do not delete the other implementations.

Yours, Georg.

review: Needs Resubmitting

[gzotti (georg-zotti)]

Oops, we crossed...

The last changes are small, mostly docfixes and cosmetics.

=== modified file 'CHANGES-FROM-TRUNK.txt'
--- CHANGES-FROM-TRUNK.txt	2010-12-07 15:22:03 +0000
+++ CHANGES-FROM-TRUNK.txt	2011-12-29 12:15:27 +0000
@@ -1,35 +1,44 @@
-REFRACTION branch:
+EXTINCTION branch:
 
-Introduces changes necessary for refraction and extinction effects. 
+Introduces changes necessary for extinction effects. 
 
 Status: Partial solution, needs help.
 
 Contributor: [e-mail]
 All changes are donated to the Stellarium project for distribution under opensource licenses like GNU.
 
-COMPUTING:      core/RefractionExtinction. DONE
-STARS:          core/modules/ZoneArray::draw
-           BUG: stars appear to have a problem after magnitude loss.
-+SELECT-MARK:   StarMgr.cpp::drawPointer(). DONE
-CLICK-IDENTIFY: core/StelObjectMgr::cleverFind(core, x, y) DONE
-INFOSTRING:     core/StelObject.cpp::getPositionInfoString(core, flags) DONE
-                new core/StelObject.cpp::getSideralPosRefr(core) DONE
-DEEPSKY:        NebulaMgr::draw(). Influences symbols and labels only.
-+DSO TEXTURES:  ---TODO. May require a vertex shader program, beyond my knowledge.
-+SELECT-MARK:   NebulaMgr::drawPointer(). DONE
-+MILKY WAY:     Should become dimmer in low sky. May require a vertex shader program, beyond my knowledge.
-PLANETS:        ---TODO. Involves StelPainter, 3D spheres, full matrices. 
-                         May require a vertex shader program, beyond my knowledge, sorry.
-+SELECT-MARK:   SolarSystem::drawPointer. DONE
-RA-DEC+GAL.GRIDS: core/GridLinesMgr. TODO OR LEAVE-AS-IS
-                Requires changes in StelPainter's arc drawing methods.
-                Currently this seems not viable and will not be changed.
-SATELLITES:     Not required, practically unobservable on horizon, orbital parameters unsure, etc.
-                Should be easy, however.
-CONSTELLATIONS: Large-scale items. Vertices could be refracted. Extinction would be a nice effect. 
-                Not urgent, later.
-METEORS         NOT NECESSARY.
-OTHER?          ???
+
+
+
+2011-Oct: A new attempt in Extinction:
+=========================================
+
+StelObject and derived classes: getVMagnitude() has new optional arg: withExtinction. 
+This should be set to true only for determining magnitude for drawing (draw()) and also for textual info (getInfoString()),
+not e.g. for selection (getSelectPriority()).
+It will also only change the result if atmosphere rendering is ON.
+
+StelSkyDrawer::drawPointSource
+StelObject::getVMagnitude
+Satellite::getVMagnitude, ::getInfoString
+Supernova::getVMagnitude, ::getInfoString
+Quasar::getVMagnitude,    ::getInfoString
+Satellite::getVMagnitude
+Planet::getVMagnitude, ::getInfoString
+Comet::getVMagnitude, ::getInfoString
+MinorPlanet::getVMagnitude, ::getInfoString
+Nebula::getVMagnitude, ::getInfoString
+StarWrapper::getInfoString
+
+I currently have no solution for extended objects! Therefore ...
+
+TODO: Milky Way, Nebula figures, Constellations??
+
+
+
+================================================================================
+
+TODO, but maybe in yet another branch: See implementation in abandoned refraction branch!
 
 CHANGES IN LANDSCAPE HANDLING:
 1) Moved config.ini:[stars].init_bortle_scale to [landscape] section
@@ -43,9 +52,6 @@
    LandscapeMgr forwards those settings to the respective recipients. 
    TODO: make GUI aware of changed values (how?).
 
-GUI changes: ViewDialog.ui
-added 3 DoubleSpinBoxes for temperature, pressure, extinction coefficient into atmosphereGroupBox
-ViewDialog.cpp: TODO: when switching landscapes, new data only load partially into GUI. No idea why!
 
 CHANGES IN ASTR.COMPUTATIONS
 planetsephems/sideral_time.[hc]: added get_mean_ecliptical_obliquity(double JDE), 

=== modified file 'data/default_config.ini'
--- data/default_config.ini	2011-12-18 20:43:39 +0000
+++ data/default_config.ini	2011-12-29 12:15:27 +0000
@@ -221,6 +221,7 @@
 flag_nebula_name               = false
 flag_nebula_long_name          = false
 flag_nebula_display_no_texture = false
+flag_extinction_below_horizon  = true
 max_mag_nebula_name            = 8
 nebula_scale                   = 1
 flag_milky_way                 = true

=== modified file 'plugins/Quasars/src/Quasar.cpp'
--- plugins/Quasars/src/Quasar.cpp	2011-12-18 15:37:49 +0000
+++ plugins/Quasars/src/Quasar.cpp	2011-12-29 12:15:27 +0000
@@ -75,31 +75,47 @@
 float Quasar::getSelectPriority(const StelCore* core) const
 {
 	//Same as StarWrapper::getSelectPriority()
-	return getVMagnitude(core);
+        return getVMagnitude(core, false);
 }
 
 QString Quasar::getInfoString(const StelCore* core, const InfoStringGroup& flags) const
 {
 	QString str;
 	QTextStream oss(&str);
-	double mag = getVMagnitude(core);
+        double mag = getVMagnitude(core, false);
 
 	if (flags&Name)
 	{
 		oss << "<h2>" << designation << "</h2>";
 	}
-
 	if (flags&Magnitude && mag <= core->getSkyDrawer()->getLimitMagnitude())
 	{
-		if (bV!=0)
+            if (core->getSkyDrawer()->getFlagHasAtmosphere())
+            {
+                if (bV!=0)
 		{
-			oss << q_("Magnitude: <b>%1</b> (B-V: %2)").arg(mag, 0, 'f', 2).arg(bV, 0, 'f', 2) << "<br>";
+                        oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>. B-V: <b>%3</b>)").arg(QString::number(mag, 'f', 2),
+                                                                                                        QString::number(getVMagnitude(core, true),  'f', 2),
+                                                                                                        QString::number(bV, 'f', 2)) << "<br>";
 		}
 		else
 		{
-			oss << q_("Magnitude: <b>%1</b>").arg(mag, 0, 'f', 2) << "<br>";
+                        oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>)").arg(QString::number(mag, 'f', 2),
+                                                                                        QString::number(getVMagnitude(core, true),  'f', 2)) << "<br>";
 		}
-		if (AMagnitude!=0)
+            }
+            else
+            {
+                if (bV!=0)
+                {
+                        oss << q_("Magnitude: <b>%1</b> (B-V: <b>%2</b>)").arg(mag, 0, 'f', 2).arg(bV, 0, 'f', 2) << "<br>";
+                }
+                else
+                {
+                        oss << q_("Magnitude: <b>%1</b>").arg(mag, 0, 'f', 2) << "<br>";
+                }
+            }
+            if (AMagnitude!=0)
 		{
 			oss << q_("Absolute Magnitude: %1").arg(AMagnitude, 0, 'f', 2) << "<br>";
 		}
@@ -126,9 +142,17 @@
 	return StelApp::getInstance().getVisionModeNight() ? Vec3f(0.6, 0.0, 0.0) : Vec3f(1.0, 1.0, 1.0);
 }
 
-float Quasar::getVMagnitude(const StelCore* core) const
+float Quasar::getVMagnitude(const StelCore* core, bool withExtinction) const
 {
-	return VMagnitude;	
+    float extinctionMag=0.0; // track magnitude loss
+    if (withExtinction && core->getSkyDrawer()->getFlagHasAtmosphere())
+    {
+        Vec3d altAz=getAltAzPosApparent(core);
+        altAz.normalize();
+        core->getSkyDrawer()->getExtinction().forward(&altAz[2], &extinctionMag);
+    }
+
+        return VMagnitude + extinctionMag;
 }
 
 double Quasar::getAngularSize(const StelCore*) const
@@ -150,7 +174,7 @@
 	double mag;
 
 	StelUtils::spheToRect(qRA, qDE, XYZ);
-	mag = getVMagnitude(core);
+        mag = getVMagnitude(core, true);
 	
 	if (mag <= sd->getLimitMagnitude())
 	{

=== modified file 'plugins/Quasars/src/Quasar.hpp'
--- plugins/Quasars/src/Quasar.hpp	2011-12-11 12:51:25 +0000
+++ plugins/Quasars/src/Quasar.hpp	2011-12-29 12:15:27 +0000
@@ -65,7 +65,7 @@
 	{
 		return XYZ;
 	}
-	virtual float getVMagnitude(const StelCore* core) const;
+        virtual float getVMagnitude(const StelCore* core, bool withExtinction=false) const;
 	virtual double getAngularSize(const StelCore* core) const;
 	virtual QString getNameI18n(void) const
 	{

=== modified file 'plugins/Satellites/src/Satellite.cpp'
--- plugins/Satellites/src/Satellite.cpp	2011-12-17 07:51:42 +0000
+++ plugins/Satellites/src/Satellite.cpp	2011-12-29 12:15:27 +0000
@@ -326,9 +326,17 @@
 	return StelApp::getInstance().getVisionModeNight() ? Vec3f(0.6, 0.0, 0.0) : hintColor;
 }
 
-float Satellite::getVMagnitude(const StelCore*) const
+float Satellite::getVMagnitude(const StelCore* core, bool withExtinction) const
 {
-	return 5.0;
+    float extinctionMag=0.0; // track magnitude loss
+    if (withExtinction && core->getSkyDrawer()->getFlagHasAtmosphere())
+    {
+	Vec3d altAz=getAltAzPosApparent(core);
+	altAz.normalize();
+	core->getSkyDrawer()->getExtinction().forward(&altAz[2], &extinctionMag);
+    }
+
+    return 5.0 + extinctionMag;
 }
 
 double Satellite::getAngularSize(const StelCore*) const

=== modified file 'plugins/Satellites/src/Satellite.hpp'
--- plugins/Satellites/src/Satellite.hpp	2011-12-14 10:31:15 +0000
+++ plugins/Satellites/src/Satellite.hpp	2011-12-29 12:15:27 +0000
@@ -84,7 +84,7 @@
 	{
 		return XYZ;
 	}
-	virtual float getVMagnitude(const StelCore* core=NULL) const;
+	virtual float getVMagnitude(const StelCore* core=NULL, bool withExtinction=false) const;
 	virtual double getAngularSize(const StelCore* core) const;
 	virtual QString getNameI18n(void) const
 	{

=== modified file 'plugins/Supernovae/src/Supernova.cpp'
--- plugins/Supernovae/src/Supernova.cpp	2011-08-28 16:38:25 +0000
+++ plugins/Supernovae/src/Supernova.cpp	2011-12-29 12:15:27 +0000
@@ -77,14 +77,14 @@
 float Supernova::getSelectPriority(const StelCore* core) const
 {
 	//Same as StarWrapper::getSelectPriority()
-	return getVMagnitude(core);
+        return getVMagnitude(core, false);
 }
 
 QString Supernova::getInfoString(const StelCore* core, const InfoStringGroup& flags) const
 {
 	QString str;
 	QTextStream oss(&str);
-	double mag = getVMagnitude(core);
+	double mag = getVMagnitude(core, false);
 
 	if (flags&Name)
 	{
@@ -96,7 +96,13 @@
 	}
 
 	if (flags&Magnitude && mag <= core->getSkyDrawer()->getLimitMagnitude())
+	{
+	    if (core->getSkyDrawer()->getFlagHasAtmosphere())
+		oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>)").arg(QString::number(getVMagnitude(core, false), 'f', 2),
+									       QString::number(getVMagnitude(core, true), 'f', 2)) << "<br>";
+	    else
 		oss << q_("Magnitude: <b>%1</b>").arg(mag, 0, 'f', 2) << "<br>";
+	}
 
 	// Ra/Dec etc.
 	oss << getPositionInfoString(core, flags);
@@ -117,8 +123,16 @@
 	return StelApp::getInstance().getVisionModeNight() ? Vec3f(0.6, 0.0, 0.0) : Vec3f(1.0, 1.0, 1.0);
 }
 
-float Supernova::getVMagnitude(const StelCore* core) const
+float Supernova::getVMagnitude(const StelCore* core, bool withExtinction) const
 {
+	float extinctionMag=0.0; // track magnitude loss
+	if (withExtinction && core->getSkyDrawer()->getFlagHasAtmosphere())
+	{
+	    Vec3d altAz=getAltAzPosApparent(core);
+	    altAz.normalize();
+	    core->getSkyDrawer()->getExtinction().forward(&altAz[2], &extinctionMag);
+	}
+
 	double vmag = 20;
 	double currentJD = core->getJDay();
 	double deltaJD = std::abs(peakJD-currentJD);
@@ -172,7 +186,7 @@
 	if (vmag<maxMagnitude)
 		vmag = maxMagnitude;
 
-	return vmag;	
+	return vmag + extinctionMag;
 }
 
 double Supernova::getAngularSize(const StelCore*) const
@@ -194,7 +208,7 @@
 	double mag;
 
 	StelUtils::spheToRect(snra, snde, XYZ);
-	mag = getVMagnitude(core);
+	mag = getVMagnitude(core, true);
 	
 	if (mag <= sd->getLimitMagnitude())
 	{

=== modified file 'plugins/Supernovae/src/Supernova.hpp'
--- plugins/Supernovae/src/Supernova.hpp	2011-07-25 17:29:18 +0000
+++ plugins/Supernovae/src/Supernova.hpp	2011-12-29 12:15:27 +0000
@@ -65,7 +65,7 @@
 	{
 		return XYZ;
 	}
-	virtual float getVMagnitude(const StelCore* core) const;
+	virtual float getVMagnitude(const StelCore* core, bool withExtinction=false) const;
 	virtual double getAngularSize(const StelCore* core) const;
 	virtual QString getNameI18n(void) const
 	{

=== modified file 'src/core/RefractionExtinction.cpp'
--- src/core/RefractionExtinction.cpp	2011-06-10 11:31:13 +0000
+++ src/core/RefractionExtinction.cpp	2011-12-29 12:15:27 +0000
@@ -20,17 +20,21 @@
  * Principal implementation: 2010-03-23 GZ=Georg Zotti, [e-mail]
  */
 
+#include <qsettings.h>
+#include "StelApp.hpp"
 #include "RefractionExtinction.hpp"
 
 
 // To be decided: The following should be either 0 or 40 (or 42? ;-)
-const float Extinction::SUBHORIZONTAL_AIRMASS=0.0f;
+float Extinction::SUBHORIZONTAL_AIRMASS=0.0f;
 
 Extinction::Extinction() : ext_coeff(0.20f)
 {
+    QSettings* conf = StelApp::getInstance().getSettings();
+    SUBHORIZONTAL_AIRMASS = (conf->value("astro/flag_extinction_below_horizon", true).toBool()? 42.0f : 0.0f);
 }
 
-//  altAzPos is the normalized star position vector AFTER REFRACTION, and its z component sin(altitude).
+//  altAzPos is the NORMALIZED (!!!) star position vector AFTER REFRACTION, and its z component sin(altitude).
 void Extinction::forward(const Vec3d *altAzPos, float *mag, const int num) const
 {
 	for (int i=0; i<num; ++i) mag[i] += airmass(altAzPos[i][2], true) * ext_coeff;
@@ -48,6 +52,14 @@
 {
 	for (int i=0; i<num; ++i) mag[i] += airmass(sinAlt[i], true) * ext_coeff;
 }
+void Extinction::forward(const double *sinAlt, float *mag) const
+{
+	*mag += airmass(*sinAlt, true) * ext_coeff;
+}
+void Extinction::forward(const float *sinAlt, float *mag) const
+{
+	*mag += airmass(*sinAlt, true) * ext_coeff;
+}
 // from observed magnitude in apparent (observed) altitude to atmosphere-free mag, still in apparent, refracted altitude.
 void Extinction::backward(const Vec3d *altAzPos, float *mag, const int num) const
 {
@@ -70,7 +82,7 @@
 // airmass computation for cosine of zenith angle z
 float Extinction::airmass(const float cosZ, const bool apparent_z) const
 {
-	if (cosZ<-0.035f)
+	if (cosZ<-0.035f) // about -2 degrees. Here, RozenbergZ>574 and climbs fast!
 	    return Extinction::SUBHORIZONTAL_AIRMASS; // Safety: 0 or 40 for below -2 degrees.
 
 	float X;
@@ -89,6 +101,7 @@
 	return X;
 }
 
+/* ***************************************************************************************************** */
 
 // The following 4 are to be configured, the rest is derived.
 // Recommendations: -4.9/-4.3/0.1/0.1: sharp but continuous transition, no effects below -5.

=== modified file 'src/core/RefractionExtinction.hpp'
--- src/core/RefractionExtinction.hpp	2011-06-10 11:31:13 +0000
+++ src/core/RefractionExtinction.hpp	2011-12-29 12:15:27 +0000
@@ -31,41 +31,39 @@
 #include "VecMath.hpp"
 #include "StelProjector.hpp"
 
-//! @class RefractionExtinction
-//! This class performs refraction and extinction computations, following literature from atmospheric optics and astronomy.
-//! Airmass computations are limited to meaningful altitudes,
-//! and refraction solutions can only be aproximate, given the turbulent, unpredictable real atmosphere.
+//! @class Extinction
+//! This class performs extinction computations, following literature from atmospheric optics and astronomy.
+//! Airmass computations are limited to meaningful altitudes.
 //! The solution provided here will [hopefully!] result in a visible "zone of avoidance" near the horizon down to altitude -2,
-//! and will show stars in their full brightness at their geometrical positions below -5 degrees.
-//! Of course, plotting stars below the horizon could be coupled to setting of horizon foreground,
-//! it's another usability issue. Typical horizons do not go down below -1, so strange effects between -2 and -5 should be covered.
+//! and may show stars in their full brightness below -2 degrees.
+//! Typical horizons do not go down below -1, so all natural sites should be covered.
 //! Note that forward/backward are no absolute reverse operations!
 //! All the computations should be in effect
 //! (1) only if atmosphere effects are true
-//! (2) only for celestial objects, never for landscape coordinates
-//! (3) only for terrestrial locations, not on Moon/Mars/Saturn etc
+//! (2) only for terrestrial locations, not on Moon/Mars/Saturn etc
+//! config.ini:astro/flag_extinction_below_horizon=true|false controls if extinction kills objects below -2 degrees altitude by setting airmass to 42.
 class Extinction
 {
 public:
 	Extinction();
 	//! Compute extinction effect for arrays of size @param num position vectors and magnitudes.
-	//! @param altAzPos are the normalized (apparent) star position vectors, and their z components sin(apparent_altitude).
+	//! @param altAzPos are the NORMALIZED (!!) (apparent) star position vectors, and their z components sin(apparent_altitude).
 	//! This call must therefore be done after application of Refraction, and only if atmospheric effects are on.
 	//! Note that forward/backward are no absolute reverse operations!
-	void forward(const Vec3d *altAzPos, float *mag, const int num) const;
-	void forward(const Vec3f *altAzPos, float *mag, const int num) const;
-	//! Convenience method for the same
+	void forward(const Vec3d *altAzPos, float *mag, const int num=1) const;
+	void forward(const Vec3f *altAzPos, float *mag, const int num=1) const;
 	void forward(const double *sinAlt,  float *mag, const int num) const;
 	void forward(const float  *sinAlt,  float *mag, const int num) const;
+	void forward(const double *sinAlt,  float *mag) const;
+	void forward(const float  *sinAlt,  float *mag) const;
 
-	//! Compute extinction effect for arrays of size @param size position vectors and magnitudes.
-	//! @param altAzPos are the normalized (apparent) star position vectors, and their z components sin(apparent_altitude).
+	//! Compute inverse extinction effect for arrays of size @param num position vectors and magnitudes.
+	//! @param altAzPos are the NORMALIZED (!!) (apparent) star position vectors, and their z components sin(apparent_altitude).
 	//! Note that forward/backward are no absolute reverse operations!
-	void backward(const Vec3d *altAzPos, float *mag, const int num) const;
-	void backward(const Vec3f *altAzPos, float *mag, const int num) const;
-	//! Convenience method for the same
-	void backward(const double *sinAlt,  float *mag, const int num) const;
-	void backward(const float  *sinAlt,  float *mag, const int num) const;
+	void backward(const Vec3d *altAzPos, float *mag, const int num=1) const;
+	void backward(const Vec3f *altAzPos, float *mag, const int num=1) const;
+	void backward(const double *sinAlt,  float *mag, const int num=1) const;
+	void backward(const float  *sinAlt,  float *mag, const int num=1) const;
 
 	//! Set visual extinction coefficient (mag/airmass), influences extinction computation.
 	//! @param k= 0.1 for highest mountains, 0.2 for very good lowland locations, 0.35 for typical lowland, 0.5 in humid climates.
@@ -84,11 +82,20 @@
 
 	//! k, magnitudes/airmass, in [0.00, ... 1.00], (default 0.20).
 	float ext_coeff;
-	//! should be either 0.0 (stars visible in full brightness below horizon) or 40.0 (practically invisible)
+	//! should be either 0.0 (stars visible in full brightness below horizon) or 40.0 (or 42? ;-) practically invisible)
 	//! Maybe make this a user-configurable option?
-	static const float SUBHORIZONTAL_AIRMASS;
+	static float SUBHORIZONTAL_AIRMASS;
 };
 
+//! @class Refraction
+//! This class performs refraction computations, following literature from atmospheric optics and astronomy.
+//! Refraction solutions can only be aproximate, given the turbulent, unpredictable real atmosphere.
+//! Typical horizons do not go down below -1, so strange effects (distortion) between -2 and -5 should be covered.
+//! Note that forward/backward are no absolute reverse operations!
+//! All the computations should be in effect
+//! (1) only if atmosphere effects are true
+//! (2) only for celestial objects, never for landscape images
+//! (3) only for terrestrial locations, not on Moon/Mars/Saturn etc
 
 class Refraction: public StelProjector::ModelViewTranform
 {

=== modified file 'src/core/StelObject.cpp'
--- src/core/StelObject.cpp	2011-06-08 15:08:06 +0000
+++ src/core/StelObject.cpp	2011-12-29 12:15:27 +0000
@@ -71,6 +71,7 @@
 // Format the positional info string contain J2000/of date/altaz/hour angle positions for the object
 QString StelObject::getPositionInfoString(const StelCore *core, const InfoStringGroup& flags) const
 {
+	bool withAtmosphere=core->getSkyDrawer()->getFlagHasAtmosphere();
 	QString res;
 	if (flags&RaDecJ2000)
 	{
@@ -88,13 +89,18 @@
 
 	if (flags&HourAngle)
 	{
-		double dec_sideral, ra_sideral;
-		StelUtils::rectToSphe(&ra_sideral,&dec_sideral,getSideralPosGeometric(core));
-		ra_sideral = 2.*M_PI-ra_sideral;
-		res += q_("Hour angle/DE: %1/%2").arg(StelUtils::radToHmsStr(ra_sideral), StelUtils::radToDmsStr(dec_sideral)) + " " + q_("(geometric)") + "<br>";
-		StelUtils::rectToSphe(&ra_sideral,&dec_sideral,getSideralPosApparent(core));
-		ra_sideral = 2.*M_PI-ra_sideral;
-		res += q_("Hour angle/DE: %1/%2").arg(StelUtils::radToHmsStr(ra_sideral), StelUtils::radToDmsStr(dec_sideral)) + " " + q_("(apparent)") + "<br>";
+		double dec_sidereal, ra_sidereal;
+		StelUtils::rectToSphe(&ra_sidereal,&dec_sidereal,getSideralPosGeometric(core));
+		ra_sidereal = 2.*M_PI-ra_sidereal;
+		if (withAtmosphere)
+		{
+		    res += q_("Hour angle/DE: %1/%2").arg(StelUtils::radToHmsStr(ra_sidereal), StelUtils::radToDmsStr(dec_sidereal)) + " " + q_("(geometric)") + "<br>";
+		    StelUtils::rectToSphe(&ra_sidereal,&dec_sidereal,getSideralPosApparent(core));
+		    ra_sidereal = 2.*M_PI-ra_sidereal;
+		    res += q_("Hour angle/DE: %1/%2").arg(StelUtils::radToHmsStr(ra_sidereal), StelUtils::radToDmsStr(dec_sidereal)) + " " + q_("(apparent)") + "<br>";
+		}
+		else
+		    res += q_("Hour angle/DE: %1/%2").arg(StelUtils::radToHmsStr(ra_sidereal), StelUtils::radToDmsStr(dec_sidereal)) + " " + "<br>";
 	}
 
 	if (flags&AltAzi)
@@ -105,13 +111,18 @@
 		az = 3.*M_PI - az;  // N is zero, E is 90 degrees
 		if (az > M_PI*2)
 			az -= M_PI*2;
-		res += q_("Az/Alt: %1/%2").arg(StelUtils::radToDmsStr(az), StelUtils::radToDmsStr(alt)) + " " + q_("(geometric)") + "<br>";
+		if (withAtmosphere)
+		{
+		    res += q_("Az/Alt: %1/%2").arg(StelUtils::radToDmsStr(az), StelUtils::radToDmsStr(alt)) + " " + q_("(geometric)") + "<br>";
 
-		StelUtils::rectToSphe(&az,&alt,getAltAzPosApparent(core));
-		az = 3.*M_PI - az;  // N is zero, E is 90 degrees
-		if (az > M_PI*2)
-			az -= M_PI*2;
-		res += q_("Az/Alt: %1/%2").arg(StelUtils::radToDmsStr(az), StelUtils::radToDmsStr(alt)) + " " + q_("(apparent)") + "<br>";
+		    StelUtils::rectToSphe(&az,&alt,getAltAzPosApparent(core));
+		    az = 3.*M_PI - az;  // N is zero, E is 90 degrees
+		    if (az > M_PI*2)
+			    az -= M_PI*2;
+		    res += q_("Az/Alt: %1/%2").arg(StelUtils::radToDmsStr(az), StelUtils::radToDmsStr(alt)) + " " + q_("(apparent)") + "<br>";
+		}
+		else
+		    res += q_("Az/Alt: %1/%2").arg(StelUtils::radToDmsStr(az), StelUtils::radToDmsStr(alt)) + " " + "<br>";
 	}
 	return res;
 }

=== modified file 'src/core/StelObject.hpp'
--- src/core/StelObject.hpp	2011-06-03 09:45:50 +0000
+++ src/core/StelObject.hpp	2011-12-29 12:15:27 +0000
@@ -120,7 +120,7 @@
 	Vec3d getAltAzPosAuto(const StelCore* core) const;
 
 	//! Return object's apparent V magnitude as seen from observer
-	virtual float getVMagnitude(const StelCore*) const {return 99;}
+	virtual float getVMagnitude(const StelCore*, bool withExtinction=false) const {return 99;}
 
 	//! Return a priority value which is used to discriminate objects by priority
 	//! As for magnitudes, the lower is the higher priority

=== modified file 'src/core/StelSkyDrawer.cpp'
--- src/core/StelSkyDrawer.cpp	2011-05-31 13:06:03 +0000
+++ src/core/StelSkyDrawer.cpp	2011-12-29 12:15:27 +0000
@@ -106,7 +106,7 @@
 		ok = true;
 	}
 
-	//GZ: load 3 values from config for now. TODO: make adjustable with GUI!
+	//GZ: load 3 values from config.
 	setExtinctionCoefficient(conf->value("landscape/atmospheric_extinction_coefficient",0.2).toDouble(&ok));
 	if (!ok)
 	{
@@ -242,6 +242,16 @@
 			fov = minAdaptFov;
 	}
 
+	// GZ: Light pollution must take global atmosphere setting into acount!
+	// moved parts from setBortleScale() here
+	// These value have been calibrated by hand, looking at the faintest star in stellarium at around 40 deg FOV
+	// They should roughly match the scale described at http://en.wikipedia.org/wiki/Bortle_Dark-Sky_Scale
+	static const float bortleToInScale[9] = {2.45, 1.55, 1.0, 0.63, 0.40, 0.24, 0.23, 0.145, 0.09};
+	if (getFlagHasAtmosphere())
+	    setInputScale(bortleToInScale[bortleScaleIndex-1]);
+	else
+	    setInputScale(bortleToInScale[0]);
+
 	// This factor is fully arbitrary. It corresponds to the collecting area x exposure time of the instrument
 	// It is based on a power law, so that it varies progressively with the FOV to smoothly switch from human
 	// vision to binocculares/telescope. Use a max of 0.7 because after that the atmosphere starts to glow too much!
@@ -731,11 +741,11 @@
 	}
 
 	bortleScaleIndex = bIndex;
-
+	// GZ: I moved this block to update()
 	// These value have been calibrated by hand, looking at the faintest star in stellarium at around 40 deg FOV
 	// They should roughly match the scale described at http://en.wikipedia.org/wiki/Bortle_Dark-Sky_Scale
-	static const float bortleToInScale[9] = {2.45, 1.55, 1.0, 0.63, 0.40, 0.24, 0.23, 0.145, 0.09};
-	setInputScale(bortleToInScale[bIndex-1]);
+	// static const float bortleToInScale[9] = {2.45, 1.55, 1.0, 0.63, 0.40, 0.24, 0.23, 0.145, 0.09};
+	// setInputScale(bortleToInScale[bIndex-1]);
 }
 
 

=== modified file 'src/core/modules/Comet.cpp'
--- src/core/modules/Comet.cpp	2011-11-25 13:51:35 +0000
+++ src/core/modules/Comet.cpp	2011-12-29 12:15:27 +0000
@@ -115,7 +115,13 @@
 	}
 
 	if (flags&Magnitude)
-		oss << q_("Magnitude: <b>%1</b>").arg(getVMagnitude(core), 0, 'f', 2) << "<br>";
+	{
+	    if (core->getSkyDrawer()->getFlagHasAtmosphere())
+		oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>)").arg(QString::number(getVMagnitude(core, false), 'f', 2),
+									    QString::number(getVMagnitude(core, true), 'f', 2)) << "<br>";
+	    else
+		oss << q_("Magnitude: <b>%1</b>").arg(getVMagnitude(core, false), 0, 'f', 2) << "<br>";
+	}
 
 	if (flags&AbsoluteMagnitude)
 	{
@@ -157,13 +163,21 @@
 	return str;
 }
 
-float Comet::getVMagnitude(const StelCore* core) const
+float Comet::getVMagnitude(const StelCore* core, bool withExtinction) const
 {
 	//If the two parameter system is not used,
 	//use the default radius/albedo mechanism
 	if (slopeParameter < 0)
 	{
-		return Planet::getVMagnitude(core);
+		return Planet::getVMagnitude(core, withExtinction);
+	}
+
+	float extinctionMag=0.0; // track magnitude loss
+	if (withExtinction && core->getSkyDrawer()->getFlagHasAtmosphere())
+	{
+	    Vec3d altAz=getAltAzPosApparent(core);
+	    altAz.normalize();
+	    core->getSkyDrawer()->getExtinction().forward(&altAz[2], &extinctionMag);
 	}
 
 	//Calculate distances
@@ -178,5 +192,5 @@
 	//http://www.ayton.id.au/gary/Science/Astronomy/Ast_comets.htm#Comet%20facts:
 	double apparentMagnitude = absoluteMagnitude + 5 * std::log10(observerCometDistance) + 2.5 * slopeParameter * std::log10(cometSunDistance);
 
-	return apparentMagnitude;
+	return apparentMagnitude + extinctionMag;
 }

=== modified file 'src/core/modules/Comet.hpp'
--- src/core/modules/Comet.hpp	2011-06-12 15:30:54 +0000
+++ src/core/modules/Comet.hpp	2011-12-29 12:15:27 +0000
@@ -65,7 +65,7 @@
 	//was not designed to handle different types of objects.
 	//virtual QString getType() const {return "Comet";}
 	//! \todo Find better sources for the g,k system
-	virtual float getVMagnitude(const StelCore* core) const;
+	virtual float getVMagnitude(const StelCore* core, bool withExtinction=false) const;
 
 	//! \brief sets absolute magnitude and slope parameter.
 	//! These are the parameters in the IAU's two-parameter magnitude system

=== modified file 'src/core/modules/Constellation.cpp'
--- src/core/modules/Constellation.cpp	2011-05-31 13:06:03 +0000
+++ src/core/modules/Constellation.cpp	2011-12-29 12:15:27 +0000
@@ -220,7 +220,7 @@
 	// so check all segment endpoints:
 	for (int i=2*numberOfSegments-1;i>=0;i--)
 	{
-		const float Mag = asterism[i]->getVMagnitude(0);
+		const float Mag = asterism[i]->getVMagnitude(0, false);
 		if (Mag < maxMag)
 		{
 			brightest = asterism[i];

=== modified file 'src/core/modules/ConstellationMgr.hpp'
--- src/core/modules/ConstellationMgr.hpp	2011-05-31 13:06:03 +0000
+++ src/core/modules/ConstellationMgr.hpp	2011-12-29 12:15:27 +0000
@@ -189,7 +189,7 @@
 	//!    the boundary separates.
 	//! @param conCatFile the path to the file which contains the constellation boundary data.
 	bool loadBoundaries(const QString& conCatFile);
-	//! Draw the constellation lines at the epoch given by the StelNavigator.
+        //! Draw the constellation lines at the epoch given by the StelCore.
 	void drawLines(StelPainter& sPainter, const StelCore* core) const;
 	//! Draw the constellation art.
 	void drawArt(StelPainter& sPainter) const;

=== modified file 'src/core/modules/LandscapeMgr.cpp'
--- src/core/modules/LandscapeMgr.cpp	2011-09-29 07:14:01 +0000
+++ src/core/modules/LandscapeMgr.cpp	2011-12-29 12:15:27 +0000
@@ -239,7 +239,7 @@
 	else
 		landscapeBrightness = (0.01 + 1.5*(sinSunAngleRad+0.1/1.5));
 	if (moonPos[2] > -0.1/1.5)
-		landscapeBrightness += qMax(0.2/-12.*ssystem->getMoon()->getVMagnitude(core),0.)*moonPos[2];
+		landscapeBrightness += qMax(0.2/-12.*ssystem->getMoon()->getVMagnitude(core, true),0.)*moonPos[2];
 
 	// TODO make this more generic for non-atmosphere planets
 	if(atmosphere->getFadeIntensity() == 1)

=== modified file 'src/core/modules/MinorPlanet.cpp'
--- src/core/modules/MinorPlanet.cpp	2011-11-25 13:51:35 +0000
+++ src/core/modules/MinorPlanet.cpp	2011-12-29 12:15:27 +0000
@@ -190,7 +190,14 @@
 	}
 
 	if (flags&Magnitude)
-		oss << q_("Magnitude: <b>%1</b>").arg(getVMagnitude(core), 0, 'f', 2) << "<br>";
+	{
+	    if (core->getSkyDrawer()->getFlagHasAtmosphere())
+		oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>)").arg(QString::number(getVMagnitude(core, false), 'f', 2),
+										QString::number(getVMagnitude(core, true), 'f', 2)) << "<br>";
+	    else
+		oss << q_("Magnitude: <b>%1</b>").arg(getVMagnitude(core, false), 0, 'f', 2) << "<br>";
+
+	}
 
 	if (flags&AbsoluteMagnitude)
 	{
@@ -198,7 +205,7 @@
 		//If the H-G system is not used, use the default radius/albedo mechanism
 		if (slopeParameter < 0)
 		{
-			oss << q_("Absolute Magnitude: %1").arg(getVMagnitude(core) - 5. * (std::log10(getJ2000EquatorialPos(core).length()*AU/PARSEC)-1.), 0, 'f', 2) << "<br>";
+			oss << q_("Absolute Magnitude: %1").arg(getVMagnitude(core, false) - 5. * (std::log10(getJ2000EquatorialPos(core).length()*AU/PARSEC)-1.), 0, 'f', 2) << "<br>";
 		}
 		else
 		{
@@ -241,17 +248,25 @@
 	return str;
 }
 
-float MinorPlanet::getVMagnitude(const StelCore* core) const
+float MinorPlanet::getVMagnitude(const StelCore* core, bool withExtinction) const
 {
+	float extinctionMag=0.0; // track magnitude loss
+	if (withExtinction)
+	{
+	    Vec3d altAz=getAltAzPosApparent(core);
+	    altAz.normalize();
+	    core->getSkyDrawer()->getExtinction().forward(&altAz[2], &extinctionMag);
+	}
+
 	//If the H-G system is not used, use the default radius/albedo mechanism
 	if (slopeParameter < 0)
 	{
-		return Planet::getVMagnitude(core);
+		return Planet::getVMagnitude(core, withExtinction);
 	}
 
 	//Calculate phase angle
 	//(Code copied from Planet::getVMagnitude())
-	//(LOL, this is actually vector substraction + the cosine theorem :))
+	//(LOL, this is actually vector subtraction + the cosine theorem :))
 	const Vec3d& observerHelioPos = core->getObserverHeliocentricEclipticPos();
 	const double observerRq = observerHelioPos.lengthSquared();
 	const Vec3d& planetHelioPos = getHeliocentricEclipticPos();
@@ -270,7 +285,7 @@
 	//TODO: See if you can "collapse" some calculations
 	double apparentMagnitude = reducedMagnitude + 5 * std::log10(std::sqrt(planetRq * observerPlanetRq));
 
-	return apparentMagnitude;
+	return apparentMagnitude+extinctionMag;
 }
 
 void MinorPlanet::translateName(StelTranslator &translator)

=== modified file 'src/core/modules/MinorPlanet.hpp'
--- src/core/modules/MinorPlanet.hpp	2011-06-12 15:30:54 +0000
+++ src/core/modules/MinorPlanet.hpp	2011-12-29 12:15:27 +0000
@@ -70,7 +70,7 @@
 	//was not designed to handle different types of objects.
 	// \todo Decide if this is going to be "MinorPlanet" or "Asteroid"
 	//virtual QString getType() const {return "MinorPlanet";}
-	virtual float getVMagnitude(const StelCore* core) const;
+	virtual float getVMagnitude(const StelCore* core, bool withExtinction=false) const;
 	//! sets the nameI18 property with the appropriate translation.
 	//! Function overriden to handle the problem with name conflicts.
 	virtual void translateName(StelTranslator& trans);

=== modified file 'src/core/modules/Nebula.cpp'
--- src/core/modules/Nebula.cpp	2011-05-31 13:06:03 +0000
+++ src/core/modules/Nebula.cpp	2011-12-29 12:15:27 +0000
@@ -96,8 +96,13 @@
 		oss << q_("Type: <b>%1</b>").arg(getTypeString()) << "<br>";
 
 	if (mag < 50 && flags&Magnitude)
-		oss << q_("Magnitude: <b>%1</b>").arg(mag, 0, 'f', 2) << "<br>";
-
+	{
+	    if (core->getSkyDrawer()->getFlagHasAtmosphere())
+		oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>)").arg(QString::number(getVMagnitude(core, false), 'f', 2),
+										QString::number(getVMagnitude(core, true), 'f', 2)) << "<br>";
+	    else
+		oss << q_("Magnitude: <b>%1</b>").arg(getVMagnitude(core, false), 0, 'f', 2) << "<br>";
+	}
 	oss << getPositionInfoString(core, flags);
 
 	if (angularSize>0 && flags&Size)
@@ -108,6 +113,20 @@
 	return str;
 }
 
+float Nebula::getVMagnitude(const StelCore* core, bool withExtinction) const
+{
+    float extinctionMag=0.0; // track magnitude loss
+    if (withExtinction && core->getSkyDrawer()->getFlagHasAtmosphere())
+    {
+	Vec3d altAz=getAltAzPosApparent(core);
+	altAz.normalize();
+	core->getSkyDrawer()->getExtinction().forward(&altAz[2], &extinctionMag);
+    }
+
+    return mag+extinctionMag;
+}
+
+
 float Nebula::getSelectPriority(const StelCore* core) const
 {
 	if( ((NebulaMgr*)StelApp::getInstance().getModuleMgr().getModule("NebulaMgr"))->getFlagHints() )
@@ -117,8 +136,8 @@
 	}
 	else
 	{
-		if (getVMagnitude(core)>20.f) return 20.f;
-		return getVMagnitude(core);
+		if (getVMagnitude(core, false)>20.f) return 20.f;
+		return getVMagnitude(core, false);
 	}
 }
 

=== modified file 'src/core/modules/Nebula.hpp'
--- src/core/modules/Nebula.hpp	2011-05-31 13:06:03 +0000
+++ src/core/modules/Nebula.hpp	2011-12-29 12:15:27 +0000
@@ -53,7 +53,7 @@
 	virtual QString getType() const {return "Nebula";}
 	virtual Vec3d getJ2000EquatorialPos(const StelCore*) const {return XYZ;}
 	virtual double getCloseViewFov(const StelCore* core = NULL) const;
-	virtual float getVMagnitude(const StelCore* core = NULL) const {Q_UNUSED(core); return mag;}
+	virtual float getVMagnitude(const StelCore* core, bool withExtinction=false) const;
 	virtual float getSelectPriority(const StelCore* core) const;
 	virtual Vec3f getInfoColor() const;
 	virtual QString getNameI18n() const {return nameI18;}

=== modified file 'src/core/modules/Planet.cpp'
--- src/core/modules/Planet.cpp	2011-11-25 13:51:35 +0000
+++ src/core/modules/Planet.cpp	2011-12-29 12:15:27 +0000
@@ -118,10 +118,15 @@
 	}
 
 	if (flags&Magnitude)
-		oss << q_("Magnitude: <b>%1</b>").arg(getVMagnitude(core), 0, 'f', 2) << "<br>";
-
+	{
+		if (core->getSkyDrawer()->getFlagHasAtmosphere())
+		    oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>)").arg(QString::number(getVMagnitude(core, false), 'f', 2),
+										    QString::number(getVMagnitude(core, true), 'f', 2)) << "<br>";
+		else
+		    oss << q_("Magnitude: <b>%1</b>").arg(getVMagnitude(core, false), 0, 'f', 2) << "<br>";
+	}
 	if (flags&AbsoluteMagnitude)
-		oss << q_("Absolute Magnitude: %1").arg(getVMagnitude(core)-5.*(std::log10(getJ2000EquatorialPos(core).length()*AU/PARSEC)-1.), 0, 'f', 2) << "<br>";
+		oss << q_("Absolute Magnitude: %1").arg(getVMagnitude(core, false)-5.*(std::log10(getJ2000EquatorialPos(core).length()*AU/PARSEC)-1.), 0, 'f', 2) << "<br>";
 
 	oss << getPositionInfoString(core, flags);
 
@@ -185,11 +190,11 @@
 	if( ((SolarSystem*)StelApp::getInstance().getModuleMgr().getModule("SolarSystem"))->getFlagHints() )
 	{
 	// easy to select, especially pluto
-		return getVMagnitude(core)-15.f;
+		return getVMagnitude(core, false)-15.f;
 	}
 	else
 	{
-		return getVMagnitude(core) - 8.f;
+		return getVMagnitude(core, false) - 8.f;
 	}
 }
 
@@ -478,13 +483,22 @@
 }
 
 // Computation of the visual magnitude (V band) of the planet.
-float Planet::getVMagnitude(const StelCore* core) const
+float Planet::getVMagnitude(const StelCore* core, bool withExtinction) const
 {
+	float extinctionMag=0.0; // track magnitude loss
+	if (withExtinction && core->getSkyDrawer()->getFlagHasAtmosphere())
+	{
+	    Vec3d altAz=getAltAzPosApparent(core);
+	    altAz.normalize();
+	    core->getSkyDrawer()->getExtinction().forward(&altAz[2], &extinctionMag);
+	}
+
+
 	if (parent == 0)
 	{
 		// sun, compute the apparent magnitude for the absolute mag (4.83) and observer's distance
 		const double distParsec = std::sqrt(core->getObserverHeliocentricEclipticPos().lengthSquared())*AU/PARSEC;
-		return 4.83 + 5.*(std::log10(distParsec)-1.);
+		return 4.83 + 5.*(std::log10(distParsec)-1.) + extinctionMag;
 	}
 
 	// Compute the angular phase
@@ -529,45 +543,118 @@
 	}
 
 	// Use empirical formulae for main planets when seen from earth
-	// Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
 	if (core->getCurrentLocation().planetName=="Earth")
 	{
-		phase*=180./M_PI;
+		const double phaseDeg=phase*180./M_PI;
 		const double d = 5. * log10(sqrt(observerPlanetRq*planetRq));
-		double f1 = phase/100.;
+		//double f1 = phaseDeg/100.;
 
+		/*
+		// Algorithm provided by Pere Planesas (Observatorio Astronomico Nacional)
 		if (englishName=="Mercury")
 		{
-			if ( phase > 150. ) f1 = 1.5;
-			return -0.36 + d + 3.8*f1 - 2.73*f1*f1 + 2*f1*f1*f1;
+			if ( phaseDeg > 150. ) f1 = 1.5;
+			return -0.36 + d + 3.8*f1 - 2.73*f1*f1 + 2*f1*f1*f1 + extinctionMag;
 		}
 		if (englishName=="Venus")
-			return -4.29 + d + 0.09*f1 + 2.39*f1*f1 - 0.65*f1*f1*f1;
+			return -4.29 + d + 0.09*f1 + 2.39*f1*f1 - 0.65*f1*f1*f1 + extinctionMag;
 		if (englishName=="Mars")
-			return -1.52 + d + 0.016*phase;
+			return -1.52 + d + 0.016*phaseDeg + extinctionMag;
 		if (englishName=="Jupiter")
-			return -9.25 + d + 0.005*phase;
+			return -9.25 + d + 0.005*phaseDeg + extinctionMag;
 		if (englishName=="Saturn")
 		{
 			// TODO re-add rings computation
 			// double rings = -2.6*sinx + 1.25*sinx*sinx;
-			return -8.88 + d + 0.044*phase;// + rings;
-		}
-
-		if (englishName=="Uranus")
-			return -7.19 + d + 0.0028*phase;
-		if (englishName=="Neptune")
-			return -6.87 + d;
-		if (englishName=="Pluto")
-			return -1.01 + d + 0.041*phase;
-
-		phase/=180./M_PI;
+			return -8.88 + d + 0.044*phaseDeg + extinctionMag;// + rings;
+		}
+		if (englishName=="Uranus")
+			return -7.19 + d + 0.0028*phaseDeg + extinctionMag;
+		if (englishName=="Neptune")
+			return -6.87 + d + extinctionMag;
+		if (englishName=="Pluto")
+			return -1.01 + d + 0.041*phaseDeg + extinctionMag;
+		*/
+		// GZ: I prefer the values given by Meeus, Astronomical Algorithms (1992).
+		// There are two solutions:
+		// (1) G. Müller, based on visual observations 1877-91. [Expl.Suppl.1961]
+		// (2) Astronomical Almanac 1984 and later. These give V (instrumental) magnitudes.
+		// The structure is almost identical, just the numbers are different!
+		// I activate (1) for now, because we want to simulate the eye's impression. (Esp. Venus!)
+		// (1)
+		if (englishName=="Mercury")
+		    {
+			double ph50=phaseDeg-50.0;
+			return 1.16 + d + 0.02838*ph50 + 0.0001023*ph50*ph50 + extinctionMag;
+		    }
+		if (englishName=="Venus")
+			return -4.0 + d + 0.01322*phaseDeg + 0.0000004247*phaseDeg*phaseDeg*phaseDeg + extinctionMag;
+		if (englishName=="Mars")
+			return -1.3 + d + 0.01486*phaseDeg + extinctionMag;
+		if (englishName=="Jupiter")
+			return -8.93 + d + extinctionMag;
+		if (englishName=="Saturn")
+		{
+			// TODO re-add rings computation
+			// GZ: implemented from Meeus, Astr.Alg.1992
+			const double jd=core->getJDay();
+			const double T=(jd-2451545.0)/36525.0;
+			const double i=((0.000004*T-0.012998)*T+28.075216)*M_PI/180.0;
+			const double Omega=((0.000412*T+1.394681)*T+169.508470)*M_PI/180.0;
+			static SolarSystem *ssystem=GETSTELMODULE(SolarSystem);
+			const Vec3d saturnEarth=getHeliocentricEclipticPos() - ssystem->getEarth()->getHeliocentricEclipticPos();
+			double lambda=atan2(saturnEarth[1], saturnEarth[0]);
+			double beta=atan2(saturnEarth[2], sqrt(saturnEarth[0]*saturnEarth[0]+saturnEarth[1]*saturnEarth[1]));
+			const double sinB=sin(i)*cos(beta)*sin(lambda-Omega)-cos(i)*sin(beta);
+			double rings = -2.6*fabs(sinB) + 1.25*sinB*sinB; // sinx=sinB, saturnicentric latitude of earth. longish, see Meeus.
+			return -8.68 + d + 0.044*phaseDeg + rings + extinctionMag;
+		}
+		if (englishName=="Uranus")
+			return -6.85 + d + extinctionMag;
+		if (englishName=="Neptune")
+			return -7.05 + d + extinctionMag;
+		if (englishName=="Pluto")
+			return -1.0 + d + extinctionMag;
+		/*
+		// (2)
+		if (englishName=="Mercury")
+			return 0.42 + d + .038*phaseDeg - 0.000273*phaseDeg*phaseDeg + 0.000002*phaseDeg*phaseDeg*phaseDeg + extinctionMag;
+		if (englishName=="Venus")
+			return -4.40 + d + 0.0009*phaseDeg + 0.000239*phaseDeg*phaseDeg - 0.00000065*phaseDeg*phaseDeg*phaseDeg + extinctionMag;
+		if (englishName=="Mars")
+			return -1.52 + d + 0.016*phaseDeg + extinctionMag;
+		if (englishName=="Jupiter")
+			return -9.40 + d + 0.005*phaseDeg + extinctionMag;
+		if (englishName=="Saturn")
+		{
+			// TODO re-add rings computation
+			// GZ: implemented from Meeus, Astr.Alg.1992
+			const double jd=core->getJDay();
+			const double T=(jd-2451545.0)/36525.0;
+			const double i=((0.000004*T-0.012998)*T+28.075216)*M_PI/180.0;
+			const double Omega=((0.000412*T+1.394681)*T+169.508470)*M_PI/180.0;
+			static SolarSystem *ssystem=GETSTELMODULE(SolarSystem);
+			const Vec3d saturnEarth=getHeliocentricEclipticPos() - ssystem->getEarth()->getHeliocentricEclipticPos();
+			double lambda=atan2(saturnEarth[1], saturnEarth[0]);
+			double beta=atan2(saturnEarth[2], sqrt(saturnEarth[0]*saturnEarth[0]+saturnEarth[1]*saturnEarth[1]));
+			const double sinB=sin(i)*cos(beta)*sin(lambda-Omega)-cos(i)*sin(beta);
+			double rings = -2.6*fabs(sinB) + 1.25*sinB*sinB; // sinx=sinB, saturnicentric latitude of earth. longish, see Meeus.
+			return -8.88 + d + 0.044*phaseDeg + rings + extinctionMag;
+		}
+		if (englishName=="Uranus")
+			return -7.19f + d + extinctionMag;
+		if (englishName=="Neptune")
+			return -6.87f + d + extinctionMag;
+		if (englishName=="Pluto")
+			return -1.00f + d + extinctionMag;
+	*/
+	// TODO: decide which set of formulae is best?
 	}
 
 	// This formula seems to give wrong results
 	const double p = (1.0 - phase/M_PI) * cos_chi + std::sqrt(1.0 - cos_chi*cos_chi) / M_PI;
 	double F = 2.0 * albedo * radius * radius * p / (3.0*observerPlanetRq*planetRq) * shadowFactor;
-	return -26.73 - 2.5 * std::log10(F);
+	return -26.73 - 2.5 * std::log10(F) + extinctionMag;
 }
 
 double Planet::getAngularSize(const StelCore* core) const
@@ -742,7 +829,7 @@
 
 	StelPainter sPainter(core->getProjection(StelCore::FrameJ2000));
 	Vec3d tmp = getJ2000EquatorialPos(core);
-	core->getSkyDrawer()->postDrawSky3dModel(&sPainter, Vec3f(tmp[0], tmp[1], tmp[2]), surfArcMin2, getVMagnitude(core), color);
+	core->getSkyDrawer()->postDrawSky3dModel(&sPainter, Vec3f(tmp[0], tmp[1], tmp[2]), surfArcMin2, getVMagnitude(core, true), color);
 }
 
 

=== modified file 'src/core/modules/Planet.hpp'
--- src/core/modules/Planet.hpp	2011-05-31 15:56:59 +0000
+++ src/core/modules/Planet.hpp	2011-12-29 12:15:27 +0000
@@ -119,7 +119,7 @@
 	virtual double getCloseViewFov(const StelCore* core) const;
 	virtual double getSatellitesFov(const StelCore* core) const;
 	virtual double getParentSatellitesFov(const StelCore* core) const;
-	virtual float getVMagnitude(const StelCore* core) const;
+	virtual float getVMagnitude(const StelCore* core, bool withExtinction=false) const;
 	virtual float getSelectPriority(const StelCore* core) const;
 	virtual Vec3f getInfoColor(void) const;
 	virtual QString getType(void) const {return "Planet";}

=== modified file 'src/core/modules/StarMgr.cpp'
--- src/core/modules/StarMgr.cpp	2011-10-28 07:57:30 +0000
+++ src/core/modules/StarMgr.cpp	2011-12-29 12:15:27 +0000
@@ -644,13 +644,18 @@
 	skyDrawer->preDrawPointSource(&sPainter);
 
 	// draw all the stars of all the selected zones
-	float rcmag_table[2*256];
+        // GZ: This table must be enlarged from 2x256 to many more entries. CORRELATE IN Zonearray.cpp!
+	//float rcmag_table[2*256];
+        //float rcmag_table[2*16384];
+        float rcmag_table[2*4096];
 
 	for (ZoneArrayMap::const_iterator it(zoneArrays.constBegin()); it!=zoneArrays.constEnd();++it)
 	{
 		const float mag_min = 0.001f*it.value()->mag_min;
-		const float k = (0.001f*it.value()->mag_range)/it.value()->mag_steps;
-		for (int i=it.value()->mag_steps-1;i>=0;--i)
+		const float k = (0.001f*it.value()->mag_range)/it.value()->mag_steps; // MagStepIncrement
+		// GZ: add a huge number of entries to rcMag
+		//for (int i=it.value()->mag_steps-1;i>=0;--i)
+                for (int i=4096-1;i>=0;--i)
 		{
 			const float mag = mag_min+k*i;
 			if (skyDrawer->computeRCMag(mag,rcmag_table + 2*i)==false)

=== modified file 'src/core/modules/StarMgr.hpp'
--- src/core/modules/StarMgr.hpp	2011-05-31 13:06:03 +0000
+++ src/core/modules/StarMgr.hpp	2011-12-29 12:15:27 +0000
@@ -82,7 +82,7 @@
 	virtual void init();
 
 	//! Draw the stars and the star selection indicator if necessary.
-	virtual void draw(StelCore* core); //! Draw all the stars
+	virtual void draw(StelCore* core);
 
 	//! Update any time-dependent features.
 	//! Includes fading in and out stars and labels when they are turned on and off.

=== modified file 'src/core/modules/StarWrapper.cpp'
--- src/core/modules/StarWrapper.cpp	2011-05-31 13:06:03 +0000
+++ src/core/modules/StarWrapper.cpp	2011-12-29 12:15:27 +0000
@@ -48,9 +48,14 @@
 	QTextStream oss(&str);
 
 	if (flags&Magnitude)
-		oss << q_("Magnitude: <b>%1</b> (B-V: %2)").arg(QString::number(getVMagnitude(core), 'f', 2), QString::number(getBV(), 'f', 2)) << "<br>";
-
-	oss << getPositionInfoString(core, flags);
+	{
+	    oss << q_("Magnitude: <b>%1</b> (B-V: %2)").arg(QString::number(getVMagnitude(core, false), 'f', 2), QString::number(getBV(), 'f', 2)) << "<br>";
+            if (core->getSkyDrawer()->getFlagHasAtmosphere())
+            {
+                oss << q_("Apparent Magnitude: <b>%1</b> (by extinction)").arg(QString::number(getVMagnitude(core, true), 'f', 2)) << "<br>";
+            }
+        }
+        oss << getPositionInfoString(core, flags);
 
 	StelObject::postProcessInfoString(str, flags);
 
@@ -105,11 +110,18 @@
 	}
 
 	if (flags&Magnitude)
-		oss << q_("Magnitude: <b>%1</b> (B-V: %2)").arg(QString::number(getVMagnitude(core), 'f', 2),
-														QString::number(s->getBV(), 'f', 2)) << "<br>";
+	{
+	    if (core->getSkyDrawer()->getFlagHasAtmosphere())
+                oss << q_("Magnitude: <b>%1</b> (extincted to: <b>%2</b>. B-V: <b>%3</b>)").arg(QString::number(getVMagnitude(core, false), 'f', 2),
+											      QString::number(getVMagnitude(core, true), 'f', 2),
+											      QString::number(s->getBV(), 'f', 2)) << "<br>";
+	    else
+		oss << q_("Magnitude: <b>%1</b> (B-V: <b>%2</b>)").arg(QString::number(getVMagnitude(core, false), 'f', 2),
+								       QString::number(s->getBV(), 'f', 2)) << "<br>";
+	}
 
 	if ((flags&AbsoluteMagnitude) && s->plx && !isNan(s->plx) && !isInf(s->plx))
-		oss << q_("Absolute Magnitude: %1").arg(getVMagnitude(core)+5.*(1.+std::log10(0.00001*s->plx)), 0, 'f', 2) << "<br>";
+		oss << q_("Absolute Magnitude: %1").arg(getVMagnitude(core, false)+5.*(1.+std::log10(0.00001*s->plx)), 0, 'f', 2) << "<br>";
 
 	oss << getPositionInfoString(core, flags);
 

=== modified file 'src/core/modules/StarWrapper.hpp'
--- src/core/modules/StarWrapper.hpp	2011-05-31 13:06:03 +0000
+++ src/core/modules/StarWrapper.hpp	2011-12-29 12:15:27 +0000
@@ -85,11 +85,18 @@
 	{
 		return StelApp::getInstance().getVisionModeNight() ? Vec3f(0.8, 0.2, 0.2) : StelSkyDrawer::indexToColor(s->bV);
 	}
-	float getVMagnitude(const StelCore*) const
+	float getVMagnitude(const StelCore* core, bool withExtinction=false) const
 	{
-		return 0.001f*a->mag_min + s->mag*(0.001f*a->mag_range)/a->mag_steps;
+	    float extinctionMag=0.0; // track magnitude loss
+	    if (withExtinction && core->getSkyDrawer()->getFlagHasAtmosphere())
+	    {
+		double alt=getAltAzPosApparent(core)[2];
+		core->getSkyDrawer()->getExtinction().forward(&alt, &extinctionMag);
+	    }
+
+		return 0.001f*a->mag_min + s->mag*(0.001f*a->mag_range)/a->mag_steps  + extinctionMag;
 	}
-	float getSelectPriority(const StelCore* core) const {return getVMagnitude(core);}
+	float getSelectPriority(const StelCore* core) const {return getVMagnitude(core, false);}
 	float getBV(void) const {return s->getBV();}
 	QString getEnglishName(void) const {return QString();}
 	QString getNameI18n(void) const {return s->getNameI18n();}

=== modified file 'src/core/modules/ZoneArray.cpp'
--- src/core/modules/ZoneArray.cpp	2011-06-23 11:26:56 +0000
+++ src/core/modules/ZoneArray.cpp	2011-12-29 12:15:27 +0000
@@ -476,27 +476,44 @@
 void SpecialZoneArray<Star>::draw(StelPainter* sPainter, int index, bool is_inside, const float *rcmag_table, StelCore* core, unsigned int maxMagStarName,
 				  float names_brightness) const
 {
-	StelSkyDrawer* drawer = core->getSkyDrawer();
-	SpecialZoneData<Star> *const z = getZones() + index;
-	Vec3f vf;	
-	const Star *const end = z->getStars() + z->size;
-	static const double d2000 = 2451545.0;
-	const double movementFactor = (M_PI/180)*(0.0001/3600) * ((core->getJDay()-d2000)/365.25) / star_position_scale;
-	const float* tmpRcmag;
-	for (const Star *s=z->getStars();s<end;++s)
-	{
-		tmpRcmag = rcmag_table+2*s->mag;
-		if (*tmpRcmag<=0.f)
-			break;
-		s->getJ2000Pos(z,movementFactor, vf);
-		if (drawer->drawPointSource(sPainter, vf, tmpRcmag, s->bV, !is_inside) && s->hasName() && s->mag < maxMagStarName && s->hasComponentID()<=1)
-		{
-			const float offset = *tmpRcmag*0.7f;
-			const Vec3f& colorr = (StelApp::getInstance().getVisionModeNight() ? Vec3f(0.8f, 0.2f, 0.2f) : StelSkyDrawer::indexToColor(s->bV))*0.75f;
-			sPainter->setColor(colorr[0], colorr[1], colorr[2],names_brightness);
-			sPainter->drawText(Vec3d(vf[0], vf[1], vf[2]), s->getNameI18n(), 0, offset, offset, false);
-		}
-	}
+    StelSkyDrawer* drawer = core->getSkyDrawer();
+    SpecialZoneData<Star> *const z = getZones() + index;
+    Vec3f vf;
+    const Star *const end = z->getStars() + z->size;
+    static const double d2000 = 2451545.0;
+    const double movementFactor = (M_PI/180)*(0.0001/3600) * ((core->getJDay()-d2000)/365.25) / star_position_scale;
+    const float* tmpRcmag; // will point to precomputed rC in table
+    // GZ, added for extinction
+    Extinction extinction=core->getSkyDrawer()->getExtinction();
+    const bool withExtinction=(drawer->getFlagHasAtmosphere() && extinction.getExtinctionCoefficient()>=0.01f);
+    const float k = (0.001f*mag_range)/mag_steps; // from StarMgr.cpp line 654
+
+    // go through all stars, which are sorted by magnitude (bright stars first)
+    for (const Star *s=z->getStars();s<end;++s)
+    {
+	tmpRcmag = rcmag_table+2*s->mag;
+	if (*tmpRcmag<=0.f) break; // no size for this and following (even dimmer, unextincted) stars? --> early exit
+	s->getJ2000Pos(z,movementFactor, vf);
+
+	// GZ new:
+	if (withExtinction)
+	{
+	    //GZ: We must compute position first, then shift magnitude.
+	    Vec3d altAz=core->j2000ToAltAz(Vec3d(vf[0], vf[1], vf[2]), StelCore::RefractionOn);
+	    float extMagShift=0.0f;
+	    extinction.forward(&altAz, &extMagShift);
+            int extMagShiftStep=qMin((int)floor(extMagShift/k), 4096-mag_steps); // this number muist be equal StarMgr.cpp line 649
+	    tmpRcmag = rcmag_table+2*(s->mag+extMagShiftStep);
+	}
+
+	if (drawer->drawPointSource(sPainter, vf, tmpRcmag, s->bV, !is_inside) && s->hasName() && s->mag < maxMagStarName && s->hasComponentID()<=1)
+	{
+	    const float offset = *tmpRcmag*0.7f;
+	    const Vec3f& colorr = (StelApp::getInstance().getVisionModeNight() ? Vec3f(0.8f, 0.2f, 0.2f) : StelSkyDrawer::indexToColor(s->bV))*0.75f;
+	    sPainter->setColor(colorr[0], colorr[1], colorr[2],names_brightness);
+	    sPainter->drawText(Vec3d(vf[0], vf[1], vf[2]), s->getNameI18n(), 0, offset, offset, false);
+	}
+    }
 }
 
 template<class Star>