Dust and H2 to galaxy

Change-Id: I3bd3357fe73fbed68498311e0fd2a969980369a3
Reviewed-by: Mika Salmela <mika.salmela@theqtcompany.com>

4 files changed, 158 insertions, 6 deletions

diff --git a/tests/galaxy/galaxydata.cpp b/tests/galaxy/galaxydata.cpp
index 449e9706..6d572a66 100644
--- a/tests/galaxy/galaxydata.cpp
+++ b/tests/galaxy/galaxydata.cpp
@@ -39,7 +39,9 @@
 
 using namespace QtDataVisualization;
 
-static const int numOfStars = 30000;
+static const int numOfStars = 70000;
+static const int numOfDust = numOfStars / 2;
+static const int numOfH2 = 200;
 static const qreal rand_max = qreal(RAND_MAX);
 
 GalaxyData::GalaxyData(Q3DScatter *scatter,
@@ -50,6 +52,8 @@ GalaxyData::GalaxyData(Q3DScatter *scatter,
                        qreal ex2)
     : m_graph(scatter),
       m_pStars(0),
+      m_pDust(0),
+      m_pH2(0),
       m_radGalaxy(rad),
       m_radCore(radCore),
       m_angleOffset(deltaAng),
@@ -64,6 +68,12 @@ GalaxyData::GalaxyData(Q3DScatter *scatter,
     m_graph->axisX()->setRange(-25000.0f, 25000.0f);
     //m_graph->axisY()->setRange(m_minY, m_minY + m_rangeY);
     m_graph->axisZ()->setRange(-25000.0f, 25000.0f);
+    m_graph->setOptimizationHints(QAbstract3DGraph::OptimizationStatic);
+    //m_graph->activeTheme()->setType(Q3DTheme::ThemeIsabelle);
+    m_graph->activeTheme()->setBackgroundColor(QColor(31, 31, 31));
+    m_graph->activeTheme()->setWindowColor(QColor(31, 31, 31));
+    m_graph->activeTheme()->setLabelBackgroundColor(QColor(31, 31, 31));
+    m_graph->activeTheme()->setLabelTextColor(QColor(31, 31, 31));
 
     QObject::connect(m_graph, &QAbstract3DGraph::currentFpsChanged,
                      this, &GalaxyData::handleFpsChange);
@@ -76,6 +86,12 @@ GalaxyData::GalaxyData(Q3DScatter *scatter,
 GalaxyData::~GalaxyData()
 {
     delete m_graph;
+    if (m_pStars)
+        delete [] m_pStars;
+    if (m_pDust)
+        delete [] m_pDust;
+    if (m_pH2)
+        delete [] m_pH2;
 }
 
 void GalaxyData::createGalaxy()
@@ -84,6 +100,15 @@ void GalaxyData::createGalaxy()
         delete [] m_pStars;
     m_pStars = new Star[numOfStars];
 
+    if (m_pDust)
+        delete [] m_pDust;
+    m_pDust = new Star[numOfDust];
+
+    if (m_pH2)
+        delete [] m_pH2;
+    m_pH2 = new Star[numOfH2 * 2];
+
+
     m_minx = 9999.9;
     m_maxx = -9999.0;
     m_miny = 9999.9;
@@ -137,6 +162,48 @@ void GalaxyData::createGalaxy()
         checkMinMax(m_pStars[i]);
     }
 
+    // Initialize Dust
+    qreal x, y, rad;
+    for (int i = 0; i < numOfDust; ++i)
+    {
+        x = 2.0 * m_radGalaxy * ((double)rand() / RAND_MAX) - m_radGalaxy;
+        y = 2.0 * m_radGalaxy * ((double)rand() / RAND_MAX) - m_radGalaxy;
+        rad = sqrt(x*x + y*y);
+
+        m_pDust[i].m_a = rad;
+        m_pDust[i].m_b = rad * getExcentricity(rad);
+        m_pDust[i].m_angle = getAngularOffset(rad);
+        m_pDust[i].m_theta = 360.0 * ((double)rand() / RAND_MAX);
+        m_pDust[i].m_center = QVector2D(0.0f, 0.0f);
+        m_pDust[i].calcXY();
+
+        checkMinMax(m_pDust[i]);
+    }
+
+    // Initialize H2
+    for (int i = 0; i < numOfH2; ++i)
+    {
+        x = 2*(m_radGalaxy) * ((double)rand() / RAND_MAX) - (m_radGalaxy);
+        y = 2*(m_radGalaxy) * ((double)rand() / RAND_MAX) - (m_radGalaxy);
+        rad = sqrt(x*x + y*y);
+
+        int k1 = 2*i;
+        m_pH2[k1].m_a = rad;
+        m_pH2[k1].m_b = rad * getExcentricity(rad);
+        m_pH2[k1].m_angle = getAngularOffset(rad);
+        m_pH2[k1].m_theta = 360.0 * ((double)rand() / RAND_MAX);
+        m_pH2[k1].m_center = QVector2D(0.0f, 0.0f);
+        m_pH2[k1].calcXY();
+
+        int k2 = 2*i + 1;
+        m_pH2[k2].m_a = rad + 1000.0;
+        m_pH2[k2].m_b = rad * getExcentricity(rad);
+        m_pH2[k2].m_angle = m_pH2[k1].m_angle;
+        m_pH2[k2].m_theta = m_pH2[k1].m_theta;
+        m_pH2[k2].m_center = m_pH2[k1].m_center;
+        m_pH2[k2].calcXY();
+    }
+
     qreal max = qMax(m_maxx, m_maxy);
     qreal min = -qMin(m_minx, m_miny);
     max = qMax(min, max);
@@ -157,9 +224,19 @@ void GalaxyData::createSeries()
     m_normalSeries->setMesh(QAbstract3DSeries::MeshPoint);
     m_graph->addSeries(m_normalSeries);
 
+    QScatterDataProxy *proxyDust = new QScatterDataProxy;
+    m_dustSeries = new QScatter3DSeries(proxyDust);
+    m_dustSeries->setMesh(QAbstract3DSeries::MeshPoint);
+    m_graph->addSeries(m_dustSeries);
+
+    QScatterDataProxy *proxyH2 = new QScatterDataProxy;
+    m_H2Series = new QScatter3DSeries(proxyH2);
+    m_H2Series->setMesh(QAbstract3DSeries::MeshPoint);
+    m_graph->addSeries(m_H2Series);
+
     QScatterDataProxy *proxyFiltered = new QScatterDataProxy;
     m_filteredSeries = new QScatter3DSeries(proxyFiltered);
-    m_filteredSeries->setMesh(QAbstract3DSeries::MeshPoint);
+    m_filteredSeries->setMesh(QAbstract3DSeries::MeshCube);
     m_graph->addSeries(m_filteredSeries);
 
 }
@@ -179,6 +256,38 @@ void GalaxyData::createNormalDataView()
 
     m_normalSeries->dataProxy()->resetArray(dataArray);
     m_normalSeries->setMesh(QAbstract3DSeries::MeshPoint);
+    m_normalSeries->setBaseColor(Qt::white);
+
+    dataArray = new QScatterDataArray;
+    dataArray->resize(numOfDust);
+    ptrToDataArray = &dataArray->first();
+
+    for (uint i = 0; i < numOfDust; i++) {
+        ptrToDataArray->setPosition(QVector3D(m_pDust[i].m_pos.x(),
+                                              0.0f,
+                                              m_pDust[i].m_pos.y()));
+        ptrToDataArray++;
+    }
+
+    m_dustSeries->dataProxy()->resetArray(dataArray);
+    m_dustSeries->setMesh(QAbstract3DSeries::MeshPoint);
+    m_dustSeries->setBaseColor(QColor(131, 111, 255));
+
+    dataArray = new QScatterDataArray;
+    dataArray->resize(numOfDust);
+    ptrToDataArray = &dataArray->first();
+
+    uint H2Count = numOfH2 * 2;
+    for (uint i = 0; i < H2Count; i++) {
+        ptrToDataArray->setPosition(QVector3D(m_pH2[i].m_pos.x(),
+                                              0.0f,
+                                              m_pH2[i].m_pos.y()));
+        ptrToDataArray++;
+    }
+
+    m_H2Series->dataProxy()->resetArray(dataArray);
+    m_H2Series->setMesh(QAbstract3DSeries::MeshPoint);
+    m_H2Series->setBaseColor(Qt::red);
 }
 
 void GalaxyData::createFilteredView()
@@ -336,6 +445,21 @@ void GalaxyData::setStaticEnabled(bool enabled)
         m_graph->setOptimizationHints(QAbstract3DGraph::OptimizationDefault);
 }
 
+void GalaxyData::setStarsVisible(bool enabled)
+{
+    m_normalSeries->setVisible(enabled);
+}
+
+void GalaxyData::setDustVisible(bool enabled)
+{
+    m_dustSeries->setVisible(enabled);
+}
+
+void GalaxyData::setH2Visible(bool enabled)
+{
+    m_H2Series->setVisible(enabled);
+}
+
 void GalaxyData::resetValues()
 {
     m_radiusGalaxySlider->setValue(15000);
diff --git a/tests/galaxy/galaxydata.h b/tests/galaxy/galaxydata.h
index 298acbb1..0c7c40b9 100644
--- a/tests/galaxy/galaxydata.h
+++ b/tests/galaxy/galaxydata.h
@@ -52,6 +52,9 @@ public:
     void resetValues();
     void setFilteredEnabled(bool enabled);
     void setStaticEnabled(bool enabled);
+    void setStarsVisible(bool enabled);
+    void setDustVisible(bool enabled);
+    void setH2Visible(bool enabled);
     inline void setSliders(QSlider *rg,
                            QSlider *rc,
                            QSlider *ao,
@@ -77,8 +80,12 @@ private:
 private:
     Q3DScatter *m_graph;
     QScatter3DSeries *m_normalSeries;
+    QScatter3DSeries *m_dustSeries;
+    QScatter3DSeries *m_H2Series;
     QScatter3DSeries *m_filteredSeries;
     Star *m_pStars;
+    Star *m_pDust;
+    Star *m_pH2;
 
     qreal m_elEx1;          // Excentricity of the innermost ellipse
     qreal m_elEx2;          // Excentricity of the outermost ellipse
diff --git a/tests/galaxy/main.cpp b/tests/galaxy/main.cpp
index 83e06cff..7b749742 100644
--- a/tests/galaxy/main.cpp
+++ b/tests/galaxy/main.cpp
@@ -87,6 +87,18 @@ int main(int argc, char **argv)
     staticCheckBox->setText(QStringLiteral("Static"));
     staticCheckBox->setChecked(false);
 
+    QCheckBox *starsCheckBox = new QCheckBox(widget);
+    starsCheckBox->setText(QStringLiteral("Stars"));
+    starsCheckBox->setChecked(true);
+
+    QCheckBox *dustCheckBox = new QCheckBox(widget);
+    dustCheckBox->setText(QStringLiteral("Dust"));
+    dustCheckBox->setChecked(true);
+
+    QCheckBox *H2CheckBox = new QCheckBox(widget);
+    H2CheckBox->setText(QStringLiteral("H2"));
+    H2CheckBox->setChecked(true);
+
     QPushButton *resetButton = new QPushButton(widget);
     resetButton->setText(QStringLiteral("Reset values"));
 
@@ -107,6 +119,9 @@ int main(int argc, char **argv)
     vLayout->addWidget(new QLabel(QStringLiteral("Eccentricity outer")));
     vLayout->addWidget(eccentricityOuterSlider);
     vLayout->addWidget(staticCheckBox);
+    vLayout->addWidget(starsCheckBox);
+    vLayout->addWidget(dustCheckBox);
+    vLayout->addWidget(H2CheckBox);
     vLayout->addWidget(resetButton);
     vLayout->addWidget(filteredCheckBox);
     vLayout->addWidget(fpsLabel);
@@ -129,6 +144,12 @@ int main(int argc, char **argv)
                      modifier, &GalaxyData::setFilteredEnabled);
     QObject::connect(staticCheckBox, &QCheckBox::stateChanged,
                      modifier, &GalaxyData::setStaticEnabled);
+    QObject::connect(starsCheckBox, &QCheckBox::stateChanged,
+                     modifier, &GalaxyData::setStarsVisible);
+    QObject::connect(dustCheckBox, &QCheckBox::stateChanged,
+                     modifier, &GalaxyData::setDustVisible);
+    QObject::connect(H2CheckBox, &QCheckBox::stateChanged,
+                     modifier, &GalaxyData::setH2Visible);
 
     modifier->setSliders(radiusGalaxySlider, radiusCoreSlider, angleOffsetSlider,
                          eccentricityInnerSlider, eccentricityOuterSlider);
diff --git a/tests/galaxy/star.h b/tests/galaxy/star.h
index 4b18a405..d285c041 100644
--- a/tests/galaxy/star.h
+++ b/tests/galaxy/star.h
@@ -29,14 +29,14 @@ public:
     const void calcXY();
 
     qreal m_theta;    // position auf der ellipse
-    qreal m_velTheta; // angular velocity
+//    qreal m_velTheta; // angular velocity
     qreal m_angle;    // Schräglage der Ellipse
     qreal m_a;        // kleine halbachse
     qreal m_b;        // große halbachse
-    qreal m_temp;     // star temperature
-    qreal m_mag;      // brightness;
+//    qreal m_temp;     // star temperature
+//    qreal m_mag;      // brightness;
     QVector2D  m_center;   // center of the elliptical orbit
-    QVector2D  m_vel;      // Current velocity (calculated)
+//    QVector2D  m_vel;      // Current velocity (calculated)
     QVector2D  m_pos;      // current position in kartesion koordinates
 };