baro_history.cpp

Go to the documentation of this file.

/*************************************************************************
 *  Copyright (C) 2010 by David S. Register                               *
 *                                                                        *
 *  This program is free software; you can redistribute it and/or modify  *
 *  it under the terms of the GNU General Public License as published by  *
 *  the Free Software Foundation; either version 2 of the License, or     *
 *  (at your option) any later version.                                   *
 *                                                                        *
 *  This program is distributed in the hope that it will be useful,       *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *  GNU General Public License for more details.                          *
 *                                                                        *
 *  You should have received a copy of the GNU General Public License     *
 *  along with this program; if not, see <https://www.gnu.org/licenses/>. *
 *************************************************************************/
 
#include <wx/wxprec.h>
 
#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif  // precompiled headers
 
#include "baro_history.h"
 
//*************************************************************************
// History of barometic pressure
//*************************************************************************
 
DashboardInstrument_BaroHistory::DashboardInstrument_BaroHistory(
    wxWindow* parent, wxWindowID id, wxString title,
    InstrumentProperties* Properties)
    : DashboardInstrument(parent, id, title, OCPN_DBP_STC_MDA, Properties) {
  SetDrawSoloInPane(true);
 
  m_max_press = 0;
  m_min_press = (double)1200;
  m_total_max_press = 0;
  m_total_min_press = 1200;
  m_press = 0;
  // Set top line height to leave space for pressure data
  wxClientDC dc(this);
  int w, h;
  wxFont f;
  if (m_Properties)
    f = m_Properties->m_DataFont.GetChosenFont();
  else
    f = g_pFontData->GetChosenFont();
  dc.GetTextExtent("hPa----", &w, &h, 0, 0, &f);
  m_top_line_height = wxMax(30, h);
  m_spd_rec_cnt = 0;
  m_spd_start_val = -1;
  m_is_running = false;
  m_sample_count = 0;
  m_set_new_data = 0;
  m_left_legend = 3;
  m_right_legend = 20;
  for (int idx = 0; idx < BARO_RECORD_COUNT; idx++) {
    m_array_press_history[idx] = -1;
    m_exp_smooth_array_pressure[idx] = -1;
    m_array_rec_time[idx] = wxDateTime::Now().GetTm();
    m_array_rec_time[idx].year = 999;
  }
  alpha = 0.01;  // smoothing constant
  m_window_rect = GetClientRect();
  m_draw_area_rect = GetClientRect();
  m_draw_area_rect.SetHeight(m_window_rect.height - m_top_line_height -
                             m_TitleHeight);
}
 
wxSize DashboardInstrument_BaroHistory::GetSize(int orient, wxSize hint) {
  wxClientDC dc(this);
  int w;
  wxFont f;
  if (m_Properties)
    f = m_Properties->m_TitleFont.GetChosenFont();
  else
    f = g_pFontTitle->GetChosenFont();
  dc.GetTextExtent(m_title, &w, &m_TitleHeight, 0, 0, &f);
  if (orient == wxHORIZONTAL) {
    return wxSize(DefaultWidth, wxMax(m_TitleHeight + 140, hint.y));
  } else {
    return wxSize(wxMax(hint.x, DefaultWidth),
                  wxMax(m_TitleHeight + 140, hint.y));
  }
}
void DashboardInstrument_BaroHistory::SetData(DASH_CAP st, double data,
                                              wxString unit) {
  if (st == OCPN_DBP_STC_MDA && data > 700.0 && data < 2000.0) {
    if (m_set_new_data < 1) {
      m_press = data;
      if (m_spd_rec_cnt++ <= 5) m_spd_start_val += data;
 
      if (m_spd_rec_cnt == 5) {
        m_press = m_spd_start_val / 5;
      }
      // start working after we collected 5 records each, as start values for
      // the smoothed curves
      if (m_spd_rec_cnt > 5) {
        m_is_running = true;
        m_sample_count = m_sample_count < BARO_RECORD_COUNT ? m_sample_count + 1
                                                            : BARO_RECORD_COUNT;
        m_max_press = 0;
        ;
        // data shifting
        for (int idx = 1; idx < BARO_RECORD_COUNT; idx++) {
          if (BARO_RECORD_COUNT - m_sample_count <= idx)
            m_max_press = wxMax(m_array_press_history[idx - 1], m_max_press);
          m_min_press = wxMin(m_array_press_history[idx - 1], m_min_press);
          m_array_press_history[idx - 1] = m_array_press_history[idx];
          m_exp_smooth_array_pressure[idx - 1] =
              m_exp_smooth_array_pressure[idx];
          m_array_rec_time[idx - 1] = m_array_rec_time[idx];
        }
        m_array_press_history[BARO_RECORD_COUNT - 1] = m_press;
        if (m_sample_count < 2) {
          m_array_press_history[BARO_RECORD_COUNT - 2] = m_press;
          m_exp_smooth_array_pressure[BARO_RECORD_COUNT - 2] = m_press;
        }
        m_exp_smooth_array_pressure[BARO_RECORD_COUNT - 1] =
            alpha * m_array_press_history[BARO_RECORD_COUNT - 2] +
            (1 - alpha) * m_exp_smooth_array_pressure[BARO_RECORD_COUNT - 2];
        m_array_rec_time[BARO_RECORD_COUNT - 1] = wxDateTime::Now().GetTm();
        m_max_press = wxMax(m_press, m_max_press);
 
        m_min_press = wxMin(m_min_press, m_press);
        if (wxMin(m_press, m_min_press) == -1) {
          m_min_press = wxMin(m_press, 1200);  // to make a OK inital value
        }
        // get the overall max min pressure
        m_total_max_press = wxMax(m_press, m_total_max_press);
        m_total_min_press = wxMin(m_press, m_total_min_press);
        // Wait two turns until new data.
        m_set_new_data = 2;
      }
    } else
      m_set_new_data--;
  } else {
    //  Check for watchdog timeout
    if (isnan(data)) m_press = data;
  }
}
 
void DashboardInstrument_BaroHistory::Draw(wxGCDC* dc) {
  m_window_rect = GetClientRect();
  m_draw_area_rect = GetClientRect();
  m_draw_area_rect.SetHeight(m_window_rect.height - m_top_line_height -
                             m_TitleHeight);
  m_draw_area_rect.SetX(m_left_legend + 3);
  DrawBackground(dc);
  DrawForeground(dc);
}
 
//*********************************************************************************
// draw pressure scale
//*********************************************************************************
void DashboardInstrument_BaroHistory::DrawWindSpeedScale(wxGCDC* dc) {
  wxString label1, label2, label3, label4, label5;
  wxColour cl;
  int width, height;
  cl = wxColour(61, 61, 204, 255);
  if (m_Properties) {
    dc->SetTextForeground(
        GetColourSchemeFont(m_Properties->m_SmallFont.GetColour()));
    dc->SetFont(m_Properties->m_SmallFont.GetChosenFont());
  } else {
    dc->SetTextForeground(GetColourSchemeFont(g_pFontSmall->GetColour()));
    dc->SetFont(g_pFontSmall->GetChosenFont());
  }
  // round m_MaxPress up to the next hpa ...
  if (m_max_press > 1100) m_max_press = 1100;
 
  if (m_total_min_press < 930) m_total_min_press = 930;
 
  m_max_press_scale = (int)((m_max_press + 15) - (m_total_min_press - 15));
 
  if (!m_is_running) {
    label1 = "-- hPa";
    label2 = "-- hPa";
    label3 = "-- hPa";
    label4 = "-- hPa";
    label5 = "-- hPa";
  } else {
    /*
     The goal is to draw the legend with decimals only, if we really have them !
    */
    // top legend for max press
    label1.Printf("%.0f hPa", m_max_press_scale + (m_total_min_press - 18));
 
    // 3/4 legend
 
    label2.Printf("%.0f hPa",
                  m_max_press_scale * 3. / 4 + (m_total_min_press - 18));
 
    // center legend
 
    label3.Printf("%.0f hPa", m_max_press_scale / 2 + (m_total_min_press - 18));
 
    // 1/4 legend
 
    label4.Printf("%.0f hPa", m_max_press_scale / 4 + (m_total_min_press - 18));
 
    // bottom legend for min wind
    label5.Printf("%.0f hPa", (m_total_min_press - 18));
  }
  wxFont f;
  if (m_Properties)
    f = m_Properties->m_SmallFont.GetChosenFont();
  else
    f = g_pFontSmall->GetChosenFont();
  dc->GetTextExtent(label1, &m_left_legend, &height, 0, 0, &f);
  dc->DrawText(label1, 4, (int)(m_top_line_height - height / 2));
  if (m_Properties)
    f = m_Properties->m_SmallFont.GetChosenFont();
  else
    f = g_pFontSmall->GetChosenFont();
  dc->GetTextExtent(label2, &width, &height, 0, 0, &f);
  dc->DrawText(
      label2, 4,
      (int)(m_top_line_height + m_draw_area_rect.height / 4 - height / 2));
  m_left_legend = wxMax(width, m_left_legend);
  if (m_Properties)
    f = m_Properties->m_SmallFont.GetChosenFont();
  else
    f = g_pFontSmall->GetChosenFont();
  dc->GetTextExtent(label3, &width, &height, 0, 0, &f);
  dc->DrawText(
      label3, 4,
      (int)(m_top_line_height + m_draw_area_rect.height / 2 - height / 2));
  m_left_legend = wxMax(width, m_left_legend);
  if (m_Properties)
    f = m_Properties->m_SmallFont.GetChosenFont();
  else
    f = g_pFontSmall->GetChosenFont();
  dc->GetTextExtent(label4, &width, &height, 0, 0, &f);
  dc->DrawText(
      label4, 4,
      (int)(m_top_line_height + m_draw_area_rect.height * 0.75 - height / 2));
  m_left_legend = wxMax(width, m_left_legend);
  if (m_Properties)
    f = m_Properties->m_SmallFont.GetChosenFont();
  else
    f = g_pFontSmall->GetChosenFont();
  dc->GetTextExtent(label5, &width, &height, 0, 0, &f);
  dc->DrawText(label5, 4,
               (int)(m_top_line_height + m_draw_area_rect.height - height / 2));
  m_left_legend = wxMax(width, m_left_legend);
  m_left_legend += 4;
}
 
//*********************************************************************************
// draw background
//*********************************************************************************
void DashboardInstrument_BaroHistory::DrawBackground(wxGCDC* dc) {
  wxString label, label1, label2, label3, label4, label5;
  wxColour cl;
  wxPen pen;
  //---------------------------------------------------------------------------------
  // draw legends for spressure
  //---------------------------------------------------------------------------------
 
  DrawWindSpeedScale(dc);
 
  //---------------------------------------------------------------------------------
  // horizontal lines
  //---------------------------------------------------------------------------------
  GetGlobalColor("UBLCK", &cl);
  pen.SetColour(cl);
  dc->SetPen(pen);
  dc->DrawLine(m_left_legend + 3, m_top_line_height,
               m_window_rect.width - 3 - m_right_legend,
               m_top_line_height);  // the upper line
  dc->DrawLine(m_left_legend + 3,
               (int)(m_top_line_height + m_draw_area_rect.height),
               m_window_rect.width - 3 - m_right_legend,
               (int)(m_top_line_height + m_draw_area_rect.height));
  pen.SetStyle(wxPENSTYLE_DOT);
  dc->SetPen(pen);
  dc->DrawLine(m_left_legend + 3,
               (int)(m_top_line_height + m_draw_area_rect.height * 0.25),
               m_window_rect.width - 3 - m_right_legend,
               (int)(m_top_line_height + m_draw_area_rect.height * 0.25));
  dc->DrawLine(m_left_legend + 3,
               (int)(m_top_line_height + m_draw_area_rect.height * 0.75),
               m_window_rect.width - 3 - m_right_legend,
               (int)(m_top_line_height + m_draw_area_rect.height * 0.75));
#ifdef __WXMSW__
  pen.SetStyle(wxPENSTYLE_SHORT_DASH);
  dc->SetPen(pen);
#endif
  dc->DrawLine(m_left_legend + 3,
               (int)(m_top_line_height + m_draw_area_rect.height * 0.5),
               m_window_rect.width - 3 - m_right_legend,
               (int)(m_top_line_height + m_draw_area_rect.height * 0.5));
}
 
//*********************************************************************************
// draw foreground
//*********************************************************************************
void DashboardInstrument_BaroHistory::DrawForeground(wxGCDC* dc) {
  wxColour col;
  double ratioH;
  int degw, degh;
  int width, height, min, hour;
  wxString WindAngle, WindSpeed;
  wxPen pen;
  wxString label;
 
  //---------------------------------------------------------------------------------
  // Pressure
  //---------------------------------------------------------------------------------
  // col = wxColour(61, 61, 204, 255);  // blue, opaque
  wxFont f;
  if (m_Properties) {
    dc->SetFont(m_Properties->m_DataFont.GetChosenFont());
    dc->SetTextForeground(
        GetColourSchemeFont(m_Properties->m_DataFont.GetColour()));
  } else {
    dc->SetFont(g_pFontData->GetChosenFont());
    dc->SetTextForeground(GetColourSchemeFont(g_pFontData->GetColour()));
  }
  if (!std::isnan(m_press))
    WindSpeed = wxString::Format("hPa %3.1f  ", m_press);
  else
    WindSpeed = wxString::Format("hPa ---  ");
  if (m_Properties)
    f = m_Properties->m_DataFont.GetChosenFont();
  else
    f = g_pFontData->GetChosenFont();
  dc->GetTextExtent(WindSpeed, &degw, &degh, 0, 0, &f);
 
  dc->DrawText(WindSpeed, m_left_legend + 3, 1);
  if (m_Properties) {
    dc->SetFont(m_Properties->m_LabelFont.GetChosenFont());
    dc->SetTextForeground(
        GetColourSchemeFont(m_Properties->m_LabelFont.GetColour()));
  } else {
    dc->SetFont(g_pFontLabel->GetChosenFont());
    dc->SetTextForeground(GetColourSchemeFont(g_pFontLabel->GetColour()));
  }
  int labelw, labelh;
  if (m_Properties)
    f = m_Properties->m_LabelFont.GetChosenFont();
  else
    f = g_pFontLabel->GetChosenFont();
  dc->GetTextExtent(WindSpeed, &labelw, &labelh, 0, 0, &f);
  // determine the time range of the available data (=oldest data value)
  int i = 0;
  while (m_array_rec_time[i].year == 999 && i < BARO_RECORD_COUNT - 1) i++;
  if (i == BARO_RECORD_COUNT - 1) {
    min = 0;
    hour = 0;
 
  } else {
    wxDateTime localTime(m_array_rec_time[i]);
    min = localTime.GetMinute();
    hour = localTime.GetHour();
  }
  m_draw_area_rect.SetWidth(m_window_rect.width - 3 - m_left_legend -
                            m_right_legend);
  m_ratio_w = double(m_draw_area_rect.width) / (BARO_RECORD_COUNT - 1);
 
  dc->DrawText(
      wxString::Format(
          _(" Max %.1f since %02d:%02d  Overall Max %.1f Min %.1f "),
          m_max_press, hour, min, m_total_max_press, m_total_min_press),
      m_left_legend + 2 + degw, m_top_line_height - 2 - labelh);
  pen.SetStyle(wxPENSTYLE_SOLID);
  pen.SetColour(wxColour(61, 61, 204, 255));  // blue, opaque
  pen.SetWidth(3);
  dc->SetPen(pen);
  ratioH = (double)m_draw_area_rect.height / (double)m_max_press_scale;
 
  wxPoint pointsSpd[BARO_RECORD_COUNT + 2];
  wxPoint bdDraw[BARO_RECORD_COUNT + 2];
  int ls = 0;
  bdDraw[ls].x = 1 * m_ratio_w + 3 + m_left_legend;
  bdDraw[ls].y =
      m_top_line_height + m_draw_area_rect.height -
      ((m_array_press_history[1] - (double)m_total_min_press + 18) * ratioH);
 
  //---------------------------------------------------------------------------------
  // live pressure data
  //---------------------------------------------------------------------------------
 
  for (int idx = 1; idx < BARO_RECORD_COUNT; idx++) {
    pointsSpd[idx].x = idx * m_ratio_w + 3 + m_left_legend;
    // Print the smoothed value to avoid jumps in the single line.
    pointsSpd[idx].y =
        m_top_line_height + m_draw_area_rect.height -
        ((m_exp_smooth_array_pressure[idx] - m_total_min_press + 18.0) *
         ratioH);
    if (BARO_RECORD_COUNT - m_sample_count <= idx &&
        pointsSpd[idx].y > m_top_line_height &&
        pointsSpd[idx].y <= m_top_line_height + m_draw_area_rect.height) {
      bdDraw[ls] = pointsSpd[idx];
      ls++;
    }
  }
  if (ls > 1) dc->DrawLines(ls, bdDraw);
 
  //---------------------------------------------------------------------------------
  // exponential smoothing of barometric pressure
  //---------------------------------------------------------------------------------
  /*
   // For now i cant see the reason for implementing smoothing for barometric
   pressure. pen.SetStyle(wxSOLID); pen.SetColour(wxColour(61,61,204,255));
   //blue, opaque pen.SetWidth(2); dc->SetPen( pen );
    pointSpeed_old.x=m_LeftLegend+3;
    pointSpeed_old.y = m_TopLineHeight+m_DrawAreaRect.height -
   m_ExpSmoothArrayWindSpd[0] * ratioH;
 
    for (int idx = 1; idx < BARO_RECORD_COUNT; idx++) {
      pointsSpd[idx].x = idx * m_ratioW + 3 + m_LeftLegend;
      pointsSpd[idx].y = m_ExpSmoothArrayWindSpd[idx] * ratioH;
      if(BARO_RECORD_COUNT-m_SampleCount <= idx && pointsSpd[idx].y >
   m_TopLineHeight && pointSpeed_old.y > m_TopLineHeight && pointsSpd[idx].y
   <=m_TopLineHeight+m_DrawAreaRect.height &&
   pointSpeed_old.y<=m_TopLineHeight+m_DrawAreaRect.height) dc->DrawLine(
   pointSpeed_old.x, pointSpeed_old.y, pointsSpd[idx].x,pointsSpd[idx].y );
      pointSpeed_old.x=pointsSpd[idx].x;
      pointSpeed_old.y=pointsSpd[idx].y;
    }
 
  */
  //---------------------------------------------------------------------------------
  // Draw vertical timelines every 60 minutes
  //---------------------------------------------------------------------------------
  GetGlobalColor("DASHL", &col);
  pen.SetColour(col);
  pen.SetStyle(wxPENSTYLE_DOT);
  dc->SetPen(pen);
  dc->SetTextForeground(col);
  dc->SetFont((g_pFontSmall->GetChosenFont()));
  int done = -1;
  wxPoint pointTime;
  for (int idx = 0; idx < BARO_RECORD_COUNT; idx++) {
    if (m_array_rec_time[idx].year != 999) {
      wxDateTime localTime(m_array_rec_time[idx]);
      hour = localTime.GetHour();
      min = localTime.GetMinute();
      if ((hour * 100 + min) != done && (min == 0)) {
        pointTime.x = idx * m_ratio_w + 3 + m_left_legend;
        dc->DrawLine(pointTime.x, m_top_line_height + 1, pointTime.x,
                     (m_top_line_height + m_draw_area_rect.height + 1));
        label.Printf("%02d:%02d", hour, min);
        f = g_pFontSmall->GetChosenFont();
        dc->GetTextExtent(label, &width, &height, 0, 0, &f);
        dc->DrawText(label, pointTime.x - width / 2,
                     m_window_rect.height - height);
        done = hour * 100 + min;
      }
    }
  }
}