QTCOMMERCIALCHART_USE_NAMESPACE
ChartView::ChartView(QWidget *parent)
: QChartView(new QChart(), parent),
m_scatter(0),
m_scatter2(0)
{
setRenderHint(QPainter::Antialiasing);
chart()->setTitle("Click to interact with scatter points");
m_scatter = new QScatterSeries();
for(qreal x(0.5); x <= 4.0; x += 0.5) {
for(qreal y(0.5); y <= 4.0; y += 0.5) {
*m_scatter << QPointF(x, y);
}
}
m_scatter2 = new QScatterSeries();
chart()->addSeries(m_scatter2);
chart()->addSeries(m_scatter);
chart()->axisX()->setRange(0, 4.5);
chart()->axisY()->setRange(0, 4.5);
connect(m_scatter, SIGNAL(clicked(QPointF)), this, SLOT(handleClickedPoint(QPointF)));
}
void
RenderSpeed(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const FlightStatistics &fs,
const NMEAInfo &nmea_info,
const DerivedInfo &derived_info,
const TaskManager &task)
{
ChartRenderer chart(chart_look, canvas, rc);
if (!fs.task_speed.HasResult() || !task.CheckOrderedTask()) {
chart.DrawNoData();
return;
}
chart.ScaleXFromData(fs.task_speed);
chart.ScaleYFromData(fs.task_speed);
chart.ScaleYFromValue(0);
chart.ScaleXFromValue(fs.task_speed.GetMinX());
DrawLegs(chart, task, nmea_info, derived_info, true);
chart.DrawXGrid(0.5,
ChartLook::STYLE_THINDASHPAPER, 0.5, true);
chart.DrawYGrid(Units::ToSysTaskSpeed(10),
ChartLook::STYLE_THINDASHPAPER, 10, true);
chart.DrawLineGraph(fs.task_speed, ChartLook::STYLE_MEDIUMBLACK);
chart.DrawTrend(fs.task_speed, ChartLook::STYLE_BLUETHIN);
chart.DrawXLabel(_T("t"), _T("hr"));
chart.DrawYLabel(_T("h"), Units::GetTaskSpeedName());
}
void
ThermalBandRenderer::DrawThermalBand(const MoreData &basic,
const DerivedInfo& calculated,
const ComputerSettings &settings_computer,
Canvas &canvas,
const PixelRect &rc,
const TaskBehaviour& task_props,
const bool is_map,
const OrderedTaskBehaviour *ordered_props) const
{
ChartRenderer chart(chart_look, canvas, rc);
if (is_map) {
chart.padding_bottom = 0;
chart.padding_left = 0;
}
ScaleChart(calculated, settings_computer, chart);
_DrawThermalBand(basic, calculated, settings_computer,
chart, task_props, false, ordered_props);
if (!is_map) {
chart.DrawXGrid(Units::ToSysVSpeed(fixed(1)),
ChartLook::STYLE_THINDASHPAPER, fixed(1), true);
chart.DrawYGrid(Units::ToSysAltitude(fixed(1000)),
ChartLook::STYLE_THINDASHPAPER,
fixed(1000), true);
chart.DrawXLabel(_T("w"), Units::GetVerticalSpeedName());
chart.DrawYLabel(_T("h AGL"), Units::GetAltitudeName());
}
}
/*****************************************************
**
** PrintoutHelper --- writeVedicDefault
**
******************************************************/
void PrintoutHelper::writeVedicDefault( Table *table )
{
int i;
Lang lang;
VargaHoroscope chart( h, 0 );
VargaHoroscope nchart( h, 1 );
JaiminiExpert jexpert( &nchart );
jexpert.calcCharaKarakas();
NakshatraExpert nexpert;
table->setHeader( 2, _( "Planet" ), false, 1 );
table->setHeader( 4, _( "Length" ), false, 1 );
table->setHeader( 6, _( "Nakshatra" ));
table->setHeader( 7, _( "D-9" ));
table->setHeader( 8, _( "Karaka" ));
table->col_line[5] = true;
int line = 1;
vector<int> obs = PlanetList().getVedicObjectList( OBJECTS_INCLUDE_ASCENDANT | OBJECTS_INCLUDE_DRAGONTAIL | OBJECTS_INCLUDE_DRAGONHEAD );
for ( unsigned int p = 0; p < obs.size(); p++ )
{
i = obs[p];
writePlanetaryObject( table, 2, line, i, false, true );
table->setEntry( 6, line, lang.getNakshatraName(::getNakshatra(h->getObjectPosition( i, true ).length, N27), N27, TLARGE ) );
table->setEntry( 7, line, writer->getSignName(nchart.getRasi( i ), config->signPrecision ), config->useSignSymbols );
if ( p < 8 ) table->setEntry( 8, line, lang.getKarakaName( jexpert.getCharaKarakaProperty(p)) );
line++;
}
}
void
RenderMacCready(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const GlidePolar &glide_polar)
{
ChartRenderer chart(chart_look, canvas, rc);
if (!glide_polar.IsValid()) {
chart.DrawNoData();
return;
}
chart.ScaleXFromValue(0);
chart.ScaleXFromValue(MAX_MACCREADY);
chart.ScaleYFromValue(0);
chart.ScaleYFromValue(glide_polar.GetVMax());
chart.DrawXGrid(Units::ToSysVSpeed(1), 1, ChartRenderer::UnitFormat::NUMERIC);
chart.DrawYGrid(Units::ToSysSpeed(10), 10, ChartRenderer::UnitFormat::NUMERIC);
GlidePolar gp = glide_polar;
double m = 0;
double m_last;
gp.SetMC(m);
double v_last = gp.GetVBestLD();
double vav_last = 0;
do {
m_last = m;
m+= MAX_MACCREADY/STEPS_MACCREADY;
gp.SetMC(m);
const double v = gp.GetVBestLD();
const double vav = gp.GetAverageSpeed();
chart.DrawLine(m_last, v_last, m, v, ChartLook::STYLE_BLACK);
chart.DrawLine(m_last, vav_last, m, vav, ChartLook::STYLE_BLUETHINDASH);
v_last = v;
vav_last = vav;
} while (m<MAX_MACCREADY);
// draw current MC setting
chart.DrawLine(glide_polar.GetMC(), 0, glide_polar.GetMC(), glide_polar.GetVMax(),
ChartLook::STYLE_REDTHICKDASH);
// draw labels and other overlays
gp.SetMC(0.9*MAX_MACCREADY);
chart.DrawLabel(_T("Vopt"), 0.9*MAX_MACCREADY, gp.GetVBestLD());
gp.SetMC(0.9*MAX_MACCREADY);
chart.DrawLabel(_T("Vave"), 0.9*MAX_MACCREADY, gp.GetAverageSpeed());
chart.DrawYLabel(_T("V"), Units::GetSpeedName());
chart.DrawXLabel(_T("MC"), Units::GetVerticalSpeedName());
RenderGlidePolarInfo(canvas, rc, chart_look, glide_polar);
}
void ChartView::keyPressEvent(QKeyEvent *event)
{
switch (event->key()) {
case Qt::Key_Plus:
chart()->zoomIn();
break;
case Qt::Key_Minus:
chart()->zoomOut();
break;
case Qt::Key_Left:
chart()->scroll(-1.0, 0);
break;
case Qt::Key_Right:
chart()->scroll(1.0, 0);
break;
case Qt::Key_Up:
chart()->scroll(0, 1.0);
break;
case Qt::Key_Down:
chart()->scroll(0, -1.0);
break;
default:
QGraphicsView::keyPressEvent(event);
break;
}
}
void
ThermalBandRenderer::DrawThermalBandSpark(const MoreData &basic,
const DerivedInfo& calculated,
const ComputerSettings &settings_computer,
Canvas &canvas,
const PixelRect &rc,
const TaskBehaviour &task_props) const
{
ChartRenderer chart(chart_look, canvas, rc);
chart.padding_bottom = 0;
chart.padding_left = Layout::Scale(3);
ScaleChart(calculated, settings_computer, chart);
_DrawThermalBand(basic, calculated, settings_computer,
chart, task_props, true, NULL);
}
/*****************************************************
**
** PrintoutHelper --- writeVedicKp
**
******************************************************/
void PrintoutHelper::writeVedicKp( Table *table )
{
int i;
wxString s;
Lang lang;
VargaHoroscope chart( h, 0 );
VargaHoroscope nchart( h, 1 );
JaiminiExpert jexpert( &nchart );
jexpert.calcCharaKarakas();
NakshatraExpert nexpert;
h->updateKP( 0 );
table->setHeader( 2, _( "Planet" ), false, 1 );
table->setHeader( 4, _( "Length" ), false, 1 );
table->setHeader( 6, _( "Naks" ));
table->setHeader( 7, _( "L" ));
table->setHeader( 8, _( "SL" ));
table->setHeader( 9, _( "SSL" ));
table->setHeader( 10, _( "Cusp" ), false, 4 );
table->setHeader( 15, _( "L" ));
table->setHeader( 16, _( "SL" ));
table->setHeader( 17, _( "SSL" ));
table->col_line[9] = true;
int line = 1;
vector<int> obs = PlanetList().getVedicObjectList( OBJECTS_INCLUDE_ASCENDANT | OBJECTS_INCLUDE_DRAGONTAIL | OBJECTS_INCLUDE_DRAGONHEAD );
for ( unsigned int p = 0; p < obs.size(); p++ )
{
i = obs[p];
writePlanetaryObject( table, 2, line, i, false, true, true );
table->setEntry( 6, line, lang.getNakshatraName(::getNakshatra(h->getObjectPosition( i, true ).length, N27), N27, TMEDIUM ) );
KpData kp = h->getKPLords( i );
table->setEntry( 7, line, writer->getObjectName( kp.lord, TSHORT, true ), config->usePlanetSymbols );
table->setEntry( 8, line, writer->getObjectName( kp.sublord, TSHORT, true ), config->usePlanetSymbols );
table->setEntry( 9, line, writer->getObjectName( kp.subsublord, TSHORT, true ), config->usePlanetSymbols );
line++;
}
line = 1;
for ( i = 2; i <= 12 ; i++ )
{
writeHouse( table, 10, line++, i, true );
}
}
void
RenderBarograph(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const CrossSectionLook &cross_section_look,
const FlightStatistics &fs,
const NMEAInfo &nmea_info,
const DerivedInfo &derived_info,
const ProtectedTaskManager *_task)
{
ChartRenderer chart(chart_look, canvas, rc);
if (!fs.altitude.HasResult()) {
chart.DrawNoData();
return;
}
chart.ScaleXFromData(fs.altitude);
chart.ScaleYFromData(fs.altitude);
chart.ScaleYFromValue(0);
chart.ScaleXFromValue(fs.altitude.GetMinX());
if (_task != nullptr) {
ProtectedTaskManager::Lease task(*_task);
DrawLegs(chart, task, nmea_info, derived_info, false);
}
canvas.SelectNullPen();
canvas.Select(cross_section_look.terrain_brush);
chart.DrawFilledLineGraph(fs.altitude_terrain);
canvas.SelectWhitePen();
canvas.SelectWhiteBrush();
chart.DrawXGrid(0.5,
ChartLook::STYLE_THINDASHPAPER, 0.5, true);
chart.DrawYGrid(Units::ToSysAltitude(1000),
ChartLook::STYLE_THINDASHPAPER, 1000, true);
chart.DrawLineGraph(fs.altitude, ChartLook::STYLE_MEDIUMBLACK);
chart.DrawTrend(fs.altitude_base, ChartLook::STYLE_BLUETHIN);
chart.DrawTrend(fs.altitude_ceiling, ChartLook::STYLE_BLUETHIN);
chart.DrawXLabel(_T("t"), _T("hr"));
chart.DrawYLabel(_T("h"), Units::GetAltitudeName());
}
void
CrossSectionWindow::Paint(Canvas &canvas, const PixelRect rc)
{
fixed hmin = max(fixed_zero, gps_info.nav_altitude - fixed(3300));
fixed hmax = max(fixed(3300), gps_info.nav_altitude + fixed(1000));
Chart chart(chart_look, canvas, rc);
chart.ResetScale();
chart.ScaleXFromValue(fixed_zero);
chart.ScaleXFromValue(vec.distance);
chart.ScaleYFromValue(hmin);
chart.ScaleYFromValue(hmax);
PaintAirspaces(canvas, chart);
PaintTerrain(canvas, chart);
PaintGlide(chart);
PaintAircraft(canvas, chart, rc);
PaintGrid(canvas, chart);
}
void
CrossSectionRenderer::Paint(Canvas &canvas, const PixelRect rc) const
{
DrawVerticalGradient(canvas, rc,
look.sky_color, look.background_color,
look.background_color);
canvas.SetTextColor(look.text_color);
canvas.Select(*look.grid_font);
ChartRenderer chart(chart_look, canvas, rc);
if (!vec.IsValid() || !start.IsValid()) {
chart.DrawNoData();
return;
}
const fixed nav_altitude = gps_info.NavAltitudeAvailable()
? gps_info.nav_altitude
: fixed(0);
fixed hmin = std::max(fixed(0), nav_altitude - fixed(3300));
fixed hmax = std::max(fixed(3300), nav_altitude + fixed(1000));
chart.ResetScale();
chart.ScaleXFromValue(fixed(0));
chart.ScaleXFromValue(vec.distance);
chart.ScaleYFromValue(hmin);
chart.ScaleYFromValue(hmax);
short elevations[NUM_SLICES];
UpdateTerrain(elevations);
if (airspace_database != nullptr) {
const AircraftState aircraft = ToAircraftState(Basic(), Calculated());
airspace_renderer.Draw(canvas, chart, *airspace_database, start, vec,
aircraft);
}
terrain_renderer.Draw(canvas, chart, elevations);
PaintGlide(chart);
PaintAircraft(canvas, chart, rc);
PaintGrid(canvas, chart);
}
void
RenderBarographSpark(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const CrossSectionLook &cross_section_look,
bool inverse,
const FlightStatistics &fs,
const NMEAInfo &nmea_info,
const DerivedInfo &derived_info,
const ProtectedTaskManager *_task)
{
ScopeLock lock(fs.mutex);
ChartRenderer chart(chart_look, canvas, rc, false);
if (!fs.altitude.HasResult())
return;
chart.ScaleXFromData(fs.altitude);
chart.ScaleYFromData(fs.altitude);
chart.ScaleYFromValue(0);
if (_task != nullptr) {
ProtectedTaskManager::Lease task(*_task);
canvas.SelectHollowBrush();
RenderTaskLegs(chart, task, nmea_info, derived_info, -1);
}
canvas.SelectNullPen();
canvas.Select(cross_section_look.terrain_brush);
chart.DrawFilledLineGraph(fs.altitude_terrain);
chart.DrawLineGraph(fs.altitude, inverse? ChartLook::STYLE_WHITE: ChartLook::STYLE_BLACK);
// draw dot
if (fs.altitude.GetCount()) {
if (inverse)
chart.GetCanvas().SelectWhiteBrush();
else
chart.GetCanvas().SelectBlackBrush();
const auto &s = fs.altitude.GetSlots()[fs.altitude.GetCount()-1];
chart.DrawDot(s.x, s.y, Layout::Scale(2));
}
}
void
TraceHistoryRenderer::RenderVario(Canvas& canvas,
const PixelRect rc,
const TraceVariableHistory& var,
const bool centered,
const fixed mc) const
{
ChartRenderer chart(chart_look, canvas, rc);
ScaleChart(chart, var, centered);
chart.ScaleYFromValue(mc);
if (positive(mc)) {
canvas.SetBackgroundTransparent();
chart.DrawLine(fixed(0), mc,
fixed(var.capacity()-1), mc,
ChartLook::STYLE_DASHGREEN);
}
render_filled_posneg(chart, var);
RenderAxis(chart, var);
}
void
RenderClimbChart(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const FlightStatistics &fs,
const GlidePolar &glide_polar)
{
ChartRenderer chart(chart_look, canvas, rc);
if (fs.thermal_average.IsEmpty()) {
chart.DrawNoData();
return;
}
fixed MACCREADY = glide_polar.GetMC();
chart.ScaleYFromData(fs.thermal_average);
chart.ScaleYFromValue(MACCREADY + fixed(0.5));
chart.ScaleYFromValue(fixed(0));
chart.ScaleXFromValue(fixed(-1));
chart.ScaleXFromValue(fixed(fs.thermal_average.GetCount()));
chart.DrawYGrid(Units::ToSysVSpeed(fixed(1)),
ChartLook::STYLE_THINDASHPAPER, fixed(1), true);
chart.DrawBarChart(fs.thermal_average);
chart.DrawLine(fixed(0), MACCREADY,
fixed(fs.thermal_average.GetCount()), MACCREADY,
ChartLook::STYLE_REDTHICK);
chart.DrawLabel(_T("MC"),
std::max(fixed(0.5),
fs.thermal_average.GetGradient() - fixed(1)),
MACCREADY);
chart.DrawTrendN(fs.thermal_average, ChartLook::STYLE_BLUETHIN);
chart.DrawXLabel(_T("n"));
chart.DrawYLabel(_T("w"), Units::GetVerticalSpeedName());
}
void AnalyzerTest::testResiduals() {
debug(LOG_DEBUG, DEBUG_LOG, 0, "testResiduals() begin");
// read the chart image
FITSinfile<float> chart("testimages/deneb-chart.fits");
Image<float> *image1 = chart.read();
TypeReductionAdapter<double, float> base(*image1);
// read the projected image
FITSinfile<double> projected("testimages/deneb-projected.fits");
Image<double> *image2 = projected.read();
// compute the residuals
Analyzer analyzer(base);
std::vector<Residual> residuals = analyzer(*image2);
debug(LOG_DEBUG, DEBUG_LOG, 0, "%d residuals", residuals.size());
std::vector<Residual>::const_iterator r;
for (r = residuals.begin(); r != residuals.end(); r++) {
// std::cout << r->first << " -> " << r->second << std::endl;
}
debug(LOG_DEBUG, DEBUG_LOG, 0, "testResiduals() end");
}
void
RenderBarographSpark(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const CrossSectionLook &cross_section_look,
bool inverse,
const FlightStatistics &fs,
const NMEAInfo &nmea_info,
const DerivedInfo &derived_info,
const ProtectedTaskManager *_task)
{
ScopeLock lock(fs.mutex);
ChartRenderer chart(chart_look, canvas, rc);
chart.padding_bottom = 0;
chart.padding_left = 0;
if (!fs.altitude.HasResult())
return;
chart.ScaleXFromData(fs.altitude);
chart.ScaleYFromData(fs.altitude);
chart.ScaleYFromValue(0);
if (_task != nullptr) {
ProtectedTaskManager::Lease task(*_task);
canvas.SelectHollowBrush();
DrawLegs(chart, task, nmea_info, derived_info, false);
}
canvas.SelectNullPen();
canvas.Select(cross_section_look.terrain_brush);
chart.DrawFilledLineGraph(fs.altitude_terrain);
Pen pen(2, inverse ? COLOR_WHITE : COLOR_BLACK);
chart.DrawLineGraph(fs.altitude, pen);
}
void
RenderWindChart(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const FlightStatistics &fs,
const NMEAInfo &nmea_info,
const WindStore &wind_store)
{
int numsteps = 10;
int i;
fixed h;
Vector wind;
bool found = true;
fixed mag;
LeastSquares windstats_mag;
ChartRenderer chart(chart_look, canvas, rc);
if (fs.altitude_ceiling.y_max - fs.altitude_ceiling.y_min <= fixed_ten) {
chart.DrawNoData();
return;
}
for (i = 0; i < numsteps; i++) {
h = fixed(fs.altitude_ceiling.y_max - fs.altitude_base.y_min) * i /
(numsteps - 1) + fixed(fs.altitude_base.y_min);
wind = wind_store.GetWind(nmea_info.time, h, found);
mag = hypot(wind.x, wind.y);
windstats_mag.LeastSquaresUpdate(mag, h);
}
chart.ScaleXFromData(windstats_mag);
chart.ScaleXFromValue(fixed_zero);
chart.ScaleXFromValue(fixed_ten);
chart.ScaleYFromData(windstats_mag);
chart.DrawXGrid(Units::ToSysSpeed(fixed(5)), fixed_zero,
ChartLook::STYLE_THINDASHPAPER, fixed(5), true);
chart.DrawYGrid(Units::ToSysAltitude(fixed(1000)),
fixed_zero,
ChartLook::STYLE_THINDASHPAPER, fixed(1000), true);
chart.DrawLineGraph(windstats_mag, ChartLook::STYLE_MEDIUMBLACK);
#define WINDVECTORMAG 25
numsteps = (int)((rc.bottom - rc.top) / WINDVECTORMAG) - 1;
// draw direction vectors
fixed hfact;
for (i = 0; i < numsteps; i++) {
hfact = fixed(i + 1) / (numsteps + 1);
h = fixed(fs.altitude_ceiling.y_max - fs.altitude_base.y_min) * hfact +
fixed(fs.altitude_base.y_min);
wind = wind_store.GetWind(nmea_info.time, h, found);
if (windstats_mag.x_max == fixed_zero)
windstats_mag.x_max = fixed_one; // prevent /0 problems
wind.x /= fixed(windstats_mag.x_max);
wind.y /= fixed(windstats_mag.x_max);
mag = hypot(wind.x, wind.y);
if (negative(mag))
continue;
Angle angle = Angle::Radians(atan2(-wind.x, wind.y));
chart.DrawArrow((chart.GetXMin() + chart.GetXMax()) / 2, h,
mag * WINDVECTORMAG, angle, ChartLook::STYLE_MEDIUMBLACK);
}
chart.DrawXLabel(_T("w"), Units::GetSpeedName());
chart.DrawYLabel(_T("h"), Units::GetAltitudeName());
}
void srscan(int l) {
static char requests[][3] =
{"","da","co","po","ls","wa","en","to","sh","kl","ti"};
char *cp;
int leftside=TRUE, rightside=TRUE, i, j, jj, k=0, nn=FALSE;
int goodScan=TRUE;
switch (l) {
case 1: // SRSCAN
if (damage[DSRSENS] != 0) {
/* Allow base's sensors if docked */
if (condit != IHDOCKED) {
prout("SHORT-RANGE SENSORS DAMAGED");
goodScan=FALSE;
}
else
prout("[Using starbase's sensors]");
}
if (goodScan)
starch[quadx][quady] = damage[DRADIO]>0.0 ?
d.galaxy[quadx][quady]+1000:1;
scan();
if (isit("chart")) nn = TRUE;
if (isit("no")) rightside = FALSE;
chew();
prout("\n 1 2 3 4 5 6 7 8 9 10");
break;
case 2: // REQUEST
while (scan() == IHEOL)
printf("Information desired? ");
chew();
for (k = 1; k <= 10; k++)
if (strncmp(citem,requests[k],min(2,strlen(citem)))==0)
break;
if (k > 10) {
prout("UNRECOGNIZED REQUEST. Legal requests are:\n"
" date, condition, position, lsupport, warpfactor,\n"
" energy, torpedoes, shields, klingons, time.");
return;
}
// no "break"
case 3: // STATUS
chew();
leftside = FALSE;
skip(1);
}
for (i = 1; i <= 10; i++) {
int jj = (k!=0 ? k : i);
if (leftside) {
printf("%2d ", i);
for (j = 1; j <= 10; j++) {
if (goodScan || (abs(i-sectx)<= 1 && abs(j-secty) <= 1))
printf("%c ",quad[i][j]);
else
printf("- ");
}
}
if (rightside) {
switch (jj) {
case 1:
printf(" Stardate %.1f", d.date);
break;
case 2:
if (condit != IHDOCKED) newcnd();
switch (condit) {
case IHRED: cp = "RED"; break;
case IHGREEN: cp = "GREEN"; break;
case IHYELLOW: cp = "YELLOW"; break;
case IHDOCKED: cp = "DOCKED"; break;
}
printf(" Condition %s", cp);
break;
case 3:
printf(" Position ");
cramlc(0, quadx, quady);
putchar(',');
cramlc(0, sectx, secty);
break;
case 4:
printf(" Life Support ");
if (damage[DLIFSUP] != 0.0) {
if (condit == IHDOCKED)
printf("DAMAGED, supported by starbase");
else
printf("DAMAGED, reserves=%4.2f", lsupres);
}
else
printf("ACTIVE");
break;
case 5:
printf(" Warp Factor %.1f", warpfac);
break;
case 6:
printf(" Energy %.2f", energy);
break;
case 7:
printf(" Torpedoes %d", torps);
break;
case 8:
printf(" Shields ");
if (damage[DSHIELD] != 0)
printf("DAMAGED,");
else if (shldup)
printf("UP,");
else
printf("DOWN,");
printf(" %d%% %.1f units",
(int)((100.0*shield)/inshld + 0.5), shield);
break;
case 9:
printf(" Klingons Left %d", d.remkl);
break;
case 10:
printf(" Time Left %.2f", d.remtime);
break;
}
}
skip(1);
if (k!=0) return;
}
if (nn) chart(1);
}
void
RenderVarioHistogram(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const FlightStatistics &fs,
const GlidePolar &glide_polar)
{
ChartRenderer chart(chart_look, canvas, rc);
const auto acc = std::max(fs.vario_cruise_histogram.GetAccumulator(),
fs.vario_circling_histogram.GetAccumulator());
if (!acc) {
chart.DrawNoData();
return;
}
const auto scale = std::max(fs.vario_cruise_histogram.GetMaxY(),
fs.vario_circling_histogram.GetMaxY()) * 1.2;
chart.ScaleXFromValue(0);
chart.ScaleXFromValue(scale);
const auto s = -glide_polar.GetSBestLD();
const auto mc = glide_polar.GetMC();
chart.ScaleYFromValue(fs.vario_cruise_histogram.GetMinX());
chart.ScaleYFromValue(fs.vario_cruise_histogram.GetMaxX());
chart.ScaleYFromValue(s);
chart.ScaleYFromValue(mc);
// draw red area at higher than cruise sink rate, blue area above mc
{
PixelRect rc_upper = chart.GetChartRect();
rc_upper.bottom = chart.ScreenY(mc);
DrawVerticalGradient(canvas, rc_upper,
chart_look.color_positive, COLOR_WHITE, COLOR_WHITE);
}
{
PixelRect rc_lower = chart.GetChartRect();
rc_lower.top = chart.ScreenY(s);
DrawVerticalGradient(canvas, rc_lower,
COLOR_WHITE, chart_look.color_negative, COLOR_WHITE);
}
canvas.SelectNullPen();
canvas.Select(chart_look.black_brush);
chart.DrawFilledLineGraph(fs.vario_circling_histogram, true);
canvas.Select(chart_look.blank_brush);
chart.DrawFilledLineGraph(fs.vario_cruise_histogram, true);
// draw these after shaded regions, so they overlay
chart.DrawLineGraph(fs.vario_cruise_histogram, ChartLook::STYLE_GREEN, true);
chart.DrawLineGraph(fs.vario_circling_histogram, ChartLook::STYLE_RED, true);
// draw current MC setting
chart.DrawLine(0, mc, scale, mc, ChartLook::STYLE_REDTHICKDASH);
chart.DrawLine(0, s, scale, s, ChartLook::STYLE_BLUETHINDASH);
// draw labels and other overlays
chart.DrawYGrid(Units::ToSysVSpeed(1), 1, ChartRenderer::UnitFormat::NUMERIC);
const double tref = chart.GetXMin()*0.1+chart.GetXMax()*0.9;
chart.DrawLabel(_T("MC"), tref, mc);
chart.DrawLabel(_T("S cruise"), tref, s);
chart.DrawYLabel(_T("w"), Units::GetVerticalSpeedName());
}
//------------------------------------------------------------------------------
GDChart & GDChart::createChart()
{
create(width_,height_);
bool isIntergerOnlyValues = true;
intptr_t i, j, xCount = 0, x, y, x0 = 0, y0 = 0;
// calc min max
ldouble minValue = DBL_MAX, maxValue = -DBL_MAX;
for( i = data_.count() - 1; i >= 0; i-- ){
j = data_[i].count();
xCount = tmax(xCount,j);
const Array<ldouble> & data = data_[i];
for( j = data.count() - 1; j >= 0; j-- ){
volatile intmax_t v = intmax_t(data[j]);
volatile ldouble lv = ldouble(v);
if( lv != data[j] ) isIntergerOnlyValues = false;
minValue = tmin(minValue,data[j]);
maxValue = tmax(maxValue,data[j]);
}
}
ldouble yAxis = (maxValue - minValue) / (height_ - topBorder_ - bottomBorder_);
intptr_t leftBorderDelta = 0, rightBorderDelta = 0, topBorderDelta = 0, bottomBorderDelta = 0;
// clear image
fill(0,0,colorAllocate(255,255,255));
// draw lines
intptr_t lineColor = colorAllocate(230,230,230);
// draw vert grid lines
for( j = 0; j < xCount; j++ ){
x = (width_ - leftBorder_ - rightBorder_) * j / (xCount - 1) + leftBorder_;
line(x,topBorder_,x,height_ - bottomBorder_,lineColor);
}
intptr_t yLabelColor = makeColor(ldouble(j),ldouble(j),ldouble(j));
for( y = topBorder_; uintptr_t(y) <= height_ - bottomBorder_; y += fontHeight(font_) * 2 ){
ldouble v = maxValue - (y - topBorder_) * yAxis;
// draw horiz grid line
line(leftBorder_,y,width_ - rightBorder_,y,lineColor);
// draw ylabel
utf8::String label;
if( isIntergerOnlyValues ){
label = printTraffic(intmax_t(v),true);//utf8::String::print("%"PRIdPTR,intptr_t(v));
}
else {
label = utf8::String::print("%.2"PRF_LDBL"f",v);
}
uintptr_t sz = label.size();
x = leftBorder_ - sz * fontWidth(font_);
string(GD::font(font_),x,y,label.c_str(),yLabelColor);
if( x < 0 && -x > leftBorderDelta ) leftBorderDelta = -x;
}
// draw data lines
for( i = 0; uintptr_t(i) < data_.count(); i++ ){
intptr_t color = makeColor(ldouble(i + 1),ldouble(i + 1),ldouble(i + 1));
const Array<ldouble> & data = data_[i];
for( j = 0; uintptr_t(j) < data.count(); j++ ){
x = (width_ - leftBorder_ - rightBorder_) * j / (xCount - 1) + leftBorder_;
y = intptr_t(height_ - topBorder_ - bottomBorder_ - (data[j] - minValue) / yAxis) + topBorder_;
if( j > 0 ) line(x0,y0,x,y,color);
x0 = x;
y0 = y;
}
}
intptr_t xBarSize = 2, yBarSize = 2;
intptr_t barColor = colorAllocate(255,0,0);
intptr_t xLabelColor = makeColor(ldouble(i + 1),ldouble(i + 1),ldouble(i + 1));
for( i = 0; uintptr_t(i) < data_.count(); i++ ){
const Array<ldouble> & data = data_[i];
for( j = 0; uintptr_t(j) < data.count(); j++ ){
x = (width_ - leftBorder_ - rightBorder_) * j / (xCount - 1) + leftBorder_;
y = intptr_t(height_ - topBorder_ - bottomBorder_ - (data[j] - minValue) / yAxis) + topBorder_;
// draw bar
filledRectangle(
tmax(leftBorder_,uintptr_t(x - xBarSize)),
tmax(topBorder_,uintptr_t(y - yBarSize)),
tmin(width_ - rightBorder_,uintptr_t(x + xBarSize)),
tmin(height_ - bottomBorder_,uintptr_t(y + yBarSize)),
barColor
);
x0 = x;
y0 = y;
// draw xlabel
y = height_ - bottomBorder_ + xBarSize;
utf8::String label(utf8::String::print("%"PRIdPTR,intptr_t(j + xlvs_)));
string(GD::font(font_),x + xBarSize,y,label.c_str(),xLabelColor);
if( y + fontHeight(font_) >= height_ )
bottomBorderDelta = y + fontHeight(font_) - height_ + 1;
x = x + xBarSize + fontWidth(font_) * label.size();
if( uintptr_t(x) >= width_ ) rightBorderDelta = x - width_ + 1;
}
}
if( leftBorderDelta != 0 || rightBorderDelta != 0 || topBorderDelta != 0 || bottomBorderDelta != 0 ){
GDChart chart(*this);
chart.leftBorder_ += leftBorderDelta;
chart.rightBorder_ += rightBorderDelta;
chart.topBorder_ += topBorderDelta;
chart.bottomBorder_ += bottomBorderDelta;
chart.createChart();
xchg(image_,chart.image_);
xchg(png_,chart.png_);
xchg(pngSize_,chart.pngSize_);
}
else {
gdFree(png_);
png_ = pngPtrEx(&pngSize_,9);
}
return *this;
}
static void makemoves(void) {
int i, hitme;
char ch;
while (TRUE) { /* command loop */
hitme = FALSE;
justin = 0;
Time = 0.0;
i = -1;
while (TRUE) { /* get a command */
chew();
skip(1);
proutn("COMMAND> ");
if (scan() == IHEOL) continue;
for (i=0; i < 29; i++) // Abbreviations allowed for the first 29 commands, only.
if (isit(commands[i]))
break;
if (i < 29) break;
for (; i < NUMCOMMANDS; i++)
if (strcmp(commands[i], citem) == 0) break;
if (i < NUMCOMMANDS
#ifndef CLOAKING
&& i != 26 // ignore the CLOAK command
#endif
#ifndef CAPTURE
&& i != 27 // ignore the CAPTURE command
#endif
#ifndef SCORE
&& i != 28 // ignore the SCORE command
#endif
#ifndef DEBUG
&& i != 33 // ignore the DEBUG command
#endif
) break;
if (skill <= SFAIR) {
prout("UNRECOGNIZED COMMAND. LEGAL COMMANDS ARE:");
listCommands(TRUE);
}
else prout("UNRECOGNIZED COMMAND.");
}
switch (i) { /* command switch */
case 0: // srscan
srscan(1);
break;
case 1: // lrscan
lrscan();
break;
case 2: // phasers
phasers();
if (ididit) {
#ifdef CLOAKING
if (irhere && d.date >= ALGERON && !isviolreported && iscloaked) {
prout("The Romulan ship discovers you are breaking the Treaty of Algeron!");
ncviol++;
isviolreported = TRUE;
}
#endif
hitme = TRUE;
}
break;
case 3: // photons
photon();
if (ididit) {
#ifdef CLOAKING
if (irhere && d.date >= ALGERON && !isviolreported && iscloaked) {
prout("The Romulan ship discovers you are breaking the Treaty of Algeron!");
ncviol++;
isviolreported = TRUE;
}
#endif
hitme = TRUE;
}
break;
case 4: // move
warp(1);
break;
case 5: // shields
sheild(1);
if (ididit) {
attack(2);
shldchg = 0;
}
break;
case 6: // dock
dock();
break;
case 7: // damages
dreprt();
break;
case 8: // chart
chart(0);
break;
case 9: // impulse
impuls();
break;
case 10: // rest
waiting();
if (ididit) hitme = TRUE;
break;
case 11: // warp
setwrp();
break;
case 12: // status
srscan(3);
break;
case 13: // sensors
sensor();
break;
case 14: // orbit
orbit();
if (ididit) hitme = TRUE;
break;
case 15: // transport "beam"
beam();
break;
case 16: // mine
mine();
if (ididit) hitme = TRUE;
break;
case 17: // crystals
usecrystals();
break;
case 18: // shuttle
shuttle();
if (ididit) hitme = TRUE;
break;
case 19: // Planet list
preport();
break;
case 20: // Status information
srscan(2);
break;
case 21: // Game Report
report(0);
break;
case 22: // use COMPUTER!
eta();
break;
case 23:
listCommands(TRUE);
break;
case 24: // Emergency exit
clearscreen(); // Hide screen
freeze(TRUE); // forced save
exit(1); // And quick exit
break;
case 25:
probe(); // Launch probe
break;
#ifdef CLOAKING
case 26:
cloak(); // turn on/off cloaking
if (iscloaking) {
attack(2); // We will be seen while we cloak
iscloaking = FALSE;
iscloaked = TRUE;
}
break;
#endif
#ifdef CAPTURE
case 27:
capture(); // Attempt to get Klingon ship to surrender
if (ididit) hitme = TRUE;
break;
#endif
#ifdef SCORE
case 28:
score(1); // get the score
break;
#endif
case 29: // Abandon Ship
abandn();
break;
case 30: // Self Destruct
dstrct();
break;
case 31: // Save Game
freeze(FALSE);
if (skill > SGOOD)
prout("WARNING--Frozen games produce no plaques!");
break;
case 32: // Try a desparation measure
deathray();
if (ididit) hitme = TRUE;
break;
#ifdef DEBUG
case 33: // What do we want for debug???
debugme();
break;
#endif
case 34: // Call for help
help();
break;
case 35:
alldone = 1; // quit the game
#ifdef DEBUG
if (idebug) score(0);
#endif
break;
case 36:
helpme(); // get help
break;
}
for (;;) {
if (alldone) break; // Game has ended
#ifdef DEBUG
if (idebug) prout("2500");
#endif
if (Time != 0.0) {
events();
if (alldone) break; // Events did us in
}
if (d.galaxy[quadx][quady] == 1000) { // Galaxy went Nova!
atover(0);
continue;
}
if (nenhere == 0) movetho();
if (hitme && justin==0) {
attack(2);
if (alldone) break;
if (d.galaxy[quadx][quady] == 1000) { // went NOVA!
atover(0);
hitme = TRUE;
continue;
}
}
break;
}
if (alldone) break;
}
}
static void makemoves(void) {
int i, hitme;
char ch;
while (TRUE) { /* command loop */
hitme = FALSE;
justin = 0;
Time = 0.0;
i = -1;
while (TRUE) { /* get a command */
chew();
skip(1);
proutn("COMMAND> ");
// Use of scan() here (after chew) will get a new line of input
// and will return IHEOL iff new line of input contains nothing
// or a numeric input is detected but conversion fails.
if (scan() == IHEOL) continue;
for (i=0; i < 26; i++)
if (isit(commands[i]))
break;
if (i < 26) break;
for (; i < NUMCOMMANDS; i++)
if (strcmp(commands[i], citem) == 0) break;
if (i < NUMCOMMANDS) break;
// we get here iff the first parsed input from the line does not
// match one of the commands. In this case, the rest of the line
// is discarded, the below message is printed, and we go back to
// get a new command.
if (skill <= 2) {
prout("UNRECOGNIZED COMMAND. LEGAL COMMANDS ARE:");
listCommands(TRUE);
}
else prout("UNRECOGNIZED COMMAND.");
} // end get command loop
// we get here iff the first parsed input from the line matches one
// of the commands (i.e., command i). We use i to dispatch the
// handling of the command. The line may still contain additional
// inputs (i.e., parameters of the command) that is to be parsed by
// the dispatched command handler. If the line does not contain
// all the necessary parameters, the dispatched command handler is
// responsible to get additional input(s) interactively using scan().
// The dispatched command handler is also responsible to handle any
// input errors.
switch (i) { /* command switch */
case 0: // srscan
srscan(1);
break;
case 1: // lrscan
lrscan();
break;
case 2: // phasers
phasers();
if (ididit) hitme = TRUE;
break;
case 3: // photons
photon();
if (ididit) hitme = TRUE;
break;
case 4: // move
warp(1);
break;
case 5: // shields
sheild(1);
if (ididit) {
attack(2);
shldchg = 0;
}
break;
case 6: // dock
dock();
break;
case 7: // damages
dreprt();
break;
case 8: // chart
chart(0);
break;
case 9: // impulse
impuls();
break;
case 10: // rest
waiting();
if (ididit) hitme = TRUE;
break;
case 11: // warp
setwrp();
break;
case 12: // status
srscan(3);
break;
case 13: // sensors
sensor();
break;
case 14: // orbit
orbit();
if (ididit) hitme = TRUE;
break;
case 15: // transport "beam"
beam();
break;
case 16: // mine
mine();
if (ididit) hitme = TRUE;
break;
case 17: // crystals
usecrystals();
break;
case 18: // shuttle
shuttle();
if (ididit) hitme = TRUE;
break;
case 19: // Planet list
preport();
break;
case 20: // Status information
srscan(2);
break;
case 21: // Game Report
report(0);
break;
case 22: // use COMPUTER!
eta();
break;
case 23:
listCommands(TRUE);
break;
case 24: // Emergency exit
clearscreen(); // Hide screen
freeze(TRUE); // forced save
exit(1); // And quick exit
break;
case 25:
probe(); // Launch probe
break;
case 26: // Abandon Ship
abandn();
break;
case 27: // Self Destruct
dstrct();
break;
case 28: // Save Game
freeze(FALSE);
if (skill > 3)
prout("WARNING--Frozen games produce no plaques!");
break;
case 29: // Try a desparation measure
deathray();
if (ididit) hitme = TRUE;
break;
case 30: // What do we want for debug???
#ifdef DEBUG
debugme();
#endif
break;
case 31: // Call for help
help();
break;
case 32:
alldone = 1; // quit the game
#ifdef DEBUG
if (idebug) score();
#endif
break;
case 33:
helpme(); // get help
break;
} // end command switch
for (;;) {
if (alldone) break; // Game has ended
#ifdef DEBUG
if (idebug) prout("2500");
#endif
if (Time != 0.0) {
events();
if (alldone) break; // Events did us in
}
if (d.galaxy[quadx][quady] == 1000) { // Galaxy went Nova!
atover(0);
continue;
}
if (nenhere == 0) movetho();
if (hitme && justin==0) {
attack(2);
if (alldone) break;
if (d.galaxy[quadx][quady] == 1000) { // went NOVA!
atover(0);
hitme = TRUE;
continue;
}
}
break;
} // end event loop
if (alldone) break;
} // end command loop
}
/*****************************************************
**
** TextHelper --- writeVedicPlanetReport
**
******************************************************/
int TextHelper::writeVedicPlanetReport()
{
VargaExpert expert;
int i, j;
Lang lang;
Calculator *calculator = CalculatorFactory().getCalculator();
wxString s1;
double len;
int ret = 0;
VargaHoroscope chart( horoscope, 0 );
VargaHoroscope nchart( horoscope, 1 );
JaiminiExpert jexpert( &nchart );
jexpert.calcCharaKarakas();
NakshatraExpert nexpert;
if ( show_header ) writer->writeHeader1( _( "Vedic Planets" ));
vector<int> obs = chartprops->getVedicPlanetList();
Table table( 5, obs.size() + 1 );
table.setHeader( 0, _( "Planet" ));
table.setHeader( 1, _( "Length" ));
table.setHeader( 2, _( "Karaka" ));
table.setHeader( 3, _( "Navamsa" ));
table.setHeader( 4, _( "Nakshatra" ));
table.col_alignment[0] = Align::Center;
table.col_alignment[1] = Align::Right;
table.col_alignment[3] = Align::Center;
//const int inode = config->iLunarNodeMode == LUNAR_NODE_TRUE ? OTRUENODE : OMEANNODE;
int line = 1;
for ( unsigned int p = 0; p < obs.size(); p++ )
{
i = obs[p];
len = horoscope->getVedicLength( i );
if ( len == 0 ) ret++;
table.setEntry( 0, line, writer->getObjectName( i, TLARGE, true ));
table.setEntry( 1, line, writer->getPosFormatted( len, horoscope->isRetrograde( i )));
if ( i <= OSATURN ) j = i;
else if ( i == OMEANNODE || i == OTRUENODE ) j = 7;
else j = -1;
if ( j != -1 ) table.setEntry( 2, line, lang.getKarakaName( jexpert.getCharaKarakaProperty( j )));
table.setEntry( 3, line, writer->getSignName(nchart.getRasi( i ), config->signPrecision ));
table.setEntry( 4, line, lang.getNakshatraName( getNakshatra( len, N27), N27, TLARGE ) );
line++;
}
writer->writeTable( table );
writer->writeHeader2( _( "Qualities" ));
Table t4( 2, 5 );
t4.setHeader( 0, _( "Quality" ));
t4.setHeader( 1, _( "Value" ));
double mlen = horoscope->getVedicLength( OMOON );
line = 1;
t4.setEntry( 0, line, _( "Varna" ) );
t4.setEntry( 1, line++, lang.getVarnaName( getVarna( mlen )));
t4.setEntry( 0, line, _( "Yoni" ) );
t4.setEntry( 1, line++, lang.getYoniName( nexpert.getYoni( mlen )));
t4.setEntry( 0, line, _( "Gana" ) );
t4.setEntry( 1, line++, lang.getGanaName( nexpert.getGana( mlen )));
t4.setEntry( 0, line, _( "Nadi" ) );
t4.setEntry( 1, line++, lang.getNadiName( nexpert.getNadi( mlen )));
writer->writeTable( t4 );
writer->writeHeader2( _( "Moon's Nakshatra and Pada Portions" ));
Table t5( 3, 3 );
t5.setHeader( 0, _( "Quality" ));
t5.setHeader( 1, _( "Value" ));
t5.setHeader( 2, _( "Value (Percent)" ));
t5.setEntry( 0, 1, _( "Nakshatra" ) );
double nportion = calculator->calcNakshatraPortion( horoscope->getDataSet(), mlen, false );
s1.Printf( wxT( "%1.6f" ), nportion );
t5.setEntry( 1, 1, s1 );
s1.Printf( wxT( "%01.2f%%" ), 100.0 * nportion );
t5.setEntry( 2, 1, s1 );
t5.setEntry( 0, 2, _( "Pada" ) );
double pportion = calculator->calcNakshatraPortion( horoscope->getDataSet(), mlen, true );
s1.Printf( wxT( "%1.6f" ), pportion );
t5.setEntry( 1, 2, s1 );
s1.Printf( wxT( "%01.2f%%" ), 100.0 * pportion );
t5.setEntry( 2, 2, s1 );
writer->writeTable( t5 );
return ret;
}
/*****************************************************
**
** TextHelper --- writeTextAnalysis
**
******************************************************/
int TextHelper::writeTextAnalysis( const int &mode, const int varga, const int dasa )
{
int ret = 0;
switch ( mode )
{
case TEXT_MODE_BASE:
writeBaseData();
break;
case TEXT_MODE_WESTERN_PLANETS:
ret = writeWesternPlanetReport();
break;
case TEXT_MODE_VEDIC_PLANETS:
ret = writeVedicPlanetReport();
break;
case TEXT_MODE_NAKSHATRA:
{
NakshatraExpert( horoscope ).write( writer, chartprops, show_header );
}
break;
case TEXT_MODE_ASHTAKAVARGA:
{
VargaHoroscope chart( horoscope, varga );
AshtakavargaExpert aexpert( &chart );
aexpert.update();
aexpert.write( writer, show_header );
}
break;
case TEXT_MODE_KP:
ret = writeKp( dasa );
break;
case TEXT_MODE_BHAVA:
writeBhavas();
break;
case TEXT_MODE_ARABICPARTS:
{
ArabicPartsExpert( horoscope ).write( writer, chartprops->isVedic(), show_header );
}
break;
case TEXT_MODE_VEDIC_ASPECTARIUM:
{
AspectExpert aspexpert( horoscope );
aspexpert.writeVedicAspectarium( horoscope, writer, chartprops, show_header );
}
break;
case TEXT_MODE_WESTERN_ASPECTARIUM:
{
AspectExpert aspexpert( horoscope );
aspexpert.update( horoscope, chartprops );
if ( show_header ) writer->writeHeader1( _( "Aspectarium" ));
aspexpert.writeWesternAspectarium( writer, chartprops );
aspexpert.writeWesternAspectList( writer, chartprops );
}
break;
case TEXT_MODE_WESTERN_ASPECTARIUM_PLAIN:
{
AspectExpert aspexpert( horoscope );
aspexpert.update( horoscope, chartprops );
aspexpert.writeWesternAspectarium( writer, chartprops );
}
break;
case TEXT_MODE_ASTRONOMICAL:
ret = writeAstronomicalData();
break;
case TEXT_MODE_VARGA:
{
VargaExpert vexpert( horoscope );
vexpert.write( writer, chartprops->getVedicObjectStyle(), show_header );
}
break;
case TEXT_MODE_DASA:
assert( dasa >= 0 && dasa < (int)DasaExpertFactory::MAX_DASAEXPERTS );
DasaExpertFactory::get()->getDasaExpert( dasa )->write( writer, horoscope, varga, show_header );
break;
case TEXT_MODE_DASACOMPACT:
assert( dasa >= 0 && dasa < (int)DasaExpertFactory::MAX_DASAEXPERTS );
DasaExpertFactory::get()->getDasaExpert( dasa )->writeCompact( writer, horoscope, varga, show_header );
break;
case TEXT_MODE_DASALONG:
assert( dasa >= 0 && dasa < (int)DasaExpertFactory::MAX_DASAEXPERTS );
DasaExpertFactory::get()->getDasaExpert( dasa )->writeMore( writer, horoscope, varga, show_header );
break;
case TEXT_MODE_JAIMINI:
{
VargaHoroscope chart( horoscope, varga );
JaiminiExpert jexpert( &chart );
jexpert.update();
jexpert.write( writer, show_header );
}
break;
case TEXT_MODE_MAIN_VIEW:
ret = writePlanets();
break;
default:
assert( false );
break;
}
if ( ret ) printf( "Warn: %d objects couldn't be calculated\n", ret );
return ret;
}
/*****************************************************
**
** TextHelper --- writeVedicPlanets
**
******************************************************/
int TextHelper::writeVedicPlanets()
{
#define HOUSE_QUALIFIER 1000
wxString s;
int pindex, rowindex = 1, shast, col = 1, p, ret = 0;
int numcols;
unsigned int i;
ObjectPosition pos;
Formatter *f = Formatter::get();
Lang lang;
int nakshatramode = ( config->vNakshatraMode28 ? N28 : N27 );
VargaHoroscope chart( horoscope, VARGA_RASI );
VargaHoroscope bchart( horoscope, VARGA_BHAVA );
JaiminiExpert expert( &chart );
AshtakavargaExpert aexpert( &chart );
Planet *planet;
int istyle = chartprops->getVedicMainStyle();
int extraObjects = 0;
if ( chartprops->getVedicObjectStyle() & OBJECTS_INCLUDE_D9_LAGNA ) extraObjects |= OBJECTS_INCLUDE_D9_LAGNA;
vector<int> obs = chartprops->getVedicPlanetList( extraObjects );
int opt_lord, opt_dig, opt_nav, opt_kara, opt_shast, opt_nak, opt_dasa, opt_bha, opt_kp, opt_ashtaka, opt_pada,
opt_houses, opt_declinations;
opt_lord = opt_dig = opt_nav = opt_kara = opt_shast = opt_nak = opt_dasa = opt_bha = opt_kp = opt_ashtaka = opt_pada
= opt_houses = opt_declinations = 0;
numcols = 2;
if ( istyle & MAIN_CHILD_SHOW_LORD ) {
opt_lord = true;
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_DIGNITY ) {
opt_dig = true;
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_NAVAMSA ) {
opt_nav = true;
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_KARAKA ) {
opt_kara = true;
expert.calcCharaKarakas();
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_SHASTIAMSA ) {
opt_shast = true;
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_NAKSHATRA ) {
opt_nak = true;
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_DASAVARGA ) {
opt_dasa = true;
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_HOUSEPOS ) {
opt_bha = true;
numcols++;
}
if ( istyle & MAIN_CHILD_SHOW_ASHTAKA ) {
opt_ashtaka = true;
aexpert.update();
numcols += 1;
}
if ( istyle & MAIN_CHILD_SHOW_PADA ) {
opt_pada = true;
numcols += 1;
}
if ( istyle & MAIN_CHILD_SHOW_KP ) {
opt_kp = true;
horoscope->updateKP( 0 );
numcols += 3;
}
if ( istyle & MAIN_CHILD_SHOW_DECLINATION ) {
opt_declinations = true;
numcols ++;
}
if ( istyle & MAIN_CHILD_SHOW_HOUSES )
{
opt_houses = true;
for ( i = HOUSE1; i <= HOUSE12; i++ ) obs.push_back( i + HOUSE_QUALIFIER );
}
Table table( numcols, obs.size() + 1 );
table.setHeader( 0, _( "Planet" ));
table.setHeader( 1, _( "Length" ));
i = 2;
if ( opt_declinations ) table.setHeader( i++, _( "Declination" ));
if ( opt_lord ) table.setHeader( i++, _( "Lord" ));
if ( opt_dig ) table.setHeader( i++, _( "Dignity" ));
if ( opt_nav ) table.setHeader( i++, _( "D-9" ));
if ( opt_nak ) table.setHeader( i++, _( "Nakshatra" ));
if ( opt_pada ) table.setHeader( i++, _( "Pada" ));
if ( opt_kp )
{
table.setHeader( i++, _( "KP Lord" ));
table.setHeader( i++, _( "Sublord" ));
table.setHeader( i++, _( "Subsublord" ));
}
if ( opt_shast ) table.setHeader( i++, _( "Shastiamsa" ));
if ( opt_dasa ) table.setHeader( i++, _( "Dasa Varga" ));
if ( opt_bha ) table.setHeader( i++, _( "Bhava" ));
if ( opt_kara ) table.setHeader( i++, _( "Karaka" ));
if ( opt_ashtaka ) table.setHeader( i++, _( "AV" ));
for ( i = 0; i < obs.size(); i++ )
{
pindex = obs[i];
if ( pindex >= HOUSE_QUALIFIER )
{
pos.length = horoscope->getHouse( pindex - HOUSE_QUALIFIER, true, false );
pos.latitude = 0;
pos.retro = false;
}
else
{
pos = horoscope->getObjectPosition( pindex, true );
// pos.length is 0 for unclaculated planets because Ayanamsa isn't subtracted in that case
if ( pos.length == 0 && pindex != OARIES ) ret++;
}
planet = 0;
col = 2;
assert( (int)table.nb_rows >= rowindex );
table.setEntry( 0, rowindex,
( pindex <= LAST_ARABIC_OBJECT ? writer->getObjectName( pindex, TLARGE, true ) : lang.getBhavaName( pindex - HOUSE_QUALIFIER )));
if ( pindex <= OSATURN ) planet = horoscope->getPlanet( pindex );
table.setEntry( 1, rowindex, writer->getPosFormatted( pos.length, pos.retro ));
// Declination
if ( opt_declinations )
table.setEntry( col++, rowindex, f->getLatitudeFormatted( pos.latitude, DEG_PRECISION_SECOND ));
// Lord
if ( opt_lord )
table.setEntry( col++, rowindex, writer->getObjectName( getLord( getRasi( pos.length )), TLARGE, true ));
// Dignity
if ( opt_dig )
{
if ( pindex >= OSUN && pindex <= OSATURN && obs[i] < MAX_EPHEM_OBJECTS )
table.setEntry( col, rowindex, lang.getDignityName( horoscope->getVargaData( pindex, VARGA_RASI )->getDignity(), TLARGE ));
col++;
}
// Navamsa
if ( opt_nav )
table.setEntry( col++, rowindex, writer->getSignName( getRasi( pos.length * 9 ), config->signPrecision ));
// Nakshatra
if ( opt_nak )
table.setEntry( col++, rowindex,
lang.getNakshatraName( getNakshatra( pos.length, nakshatramode ), nakshatramode, TMEDIUM ));
// Pada
if ( opt_pada )
{
s.Printf( wxT( "%d" ), (int)(getNakshatraLength( pos.length, nakshatramode ) / 3.3333333333 ) + 1 );
table.setEntry( col++, rowindex, s );
}
// Krishnamurti
if ( opt_kp )
{
KpData kp;
if ( pindex <= LAST_ARABIC_OBJECT )
{
kp = horoscope->getKPLords( obs[i] );
}
else
{
kp = horoscope->getHouseKPLords( pindex - HOUSE_QUALIFIER );
}
table.setEntry( col++, rowindex, writer->getObjectName( kp.lord, TLARGE, true ));
table.setEntry( col++, rowindex, writer->getObjectName( kp.sublord, TLARGE, true ));
table.setEntry( col++, rowindex, writer->getObjectName( kp.subsublord, TLARGE, true ));
}
// Shastiamsa
if ( opt_shast )
{
shast = (int)( a_red( pos.length, 30 ) * 2 );
if ( isEvenRasi( pos.length )) shast = 59 - shast;
assert( shast >= 0 && shast < 60 );
s.Printf( wxT( "%s (%c)" ), (const wxChar*)lang.getShastiamsaName( shast),
( k_shastiamsa_benefic[(int)shast] ? 'B' : 'M' ));
table.setEntry( col, rowindex, s );
col++;
}
// Dasavarga Dignity
if ( opt_dasa )
{
if ( pindex <= OSATURN && obs[i] < MAX_EPHEM_OBJECTS )
{
VargaExpert expert;
table.setEntry( col, rowindex, lang.getVimsopakaDignityName( 2, planet->getVimsopakaBalaGoodVargas( 2 )) );
}
col++;
}
// Bhava
if ( opt_bha && obs[i] <= MAX_EPHEM_OBJECTS )
{
s.Printf( wxT( "%d" ), red12( bchart.getRasi( pindex ) - bchart.getRasi( OASCENDANT )) + 1 );
table.setEntry( col++, rowindex, s );
}
// Karaka
if ( opt_kara )
{
if ( pindex <= OSATURN ) p = pindex;
else if ( pindex == OMEANNODE || pindex == OTRUENODE ) p = 7;
else p = -1;
if ( p >= 0 ) table.setEntry( col, rowindex, lang.getKarakaName( expert.getCharaKarakaProperty( p )) );
col++;
}
// Ashtaka Varga
if ( opt_ashtaka )
{
if ((( pindex >= OSUN && pindex <= OSATURN ) || pindex == OASCENDANT ) && obs[i] <= MAX_EPHEM_OBJECTS )
{
s.Printf( wxT( "%d" ), aexpert.getItem( REKHA, pindex, getRasi( pos.length )));
table.setEntry( col++, rowindex, s );
}
col++;
}
rowindex++;
}
writer->writeTable( table );
return ret;
}
void Printer::print(Buffer* buffer, OUT_PARAMS & outParams){
const int WEIGHT = 380;
const int HEIGHT = 280;
const int OFFSET = 20;
const int LINE_HEIGHT = 15;
svg::Dimensions dimensions(WEIGHT + OFFSET, HEIGHT + OFFSET);
svg::Document doc(string(outParams.file + ".svg").c_str(), svg::Layout(dimensions, svg::Layout::BottomLeft));
svg::Polygon border(svg::Stroke(1, svg::Color::Black));
border << svg::Point(0, 0) << svg::Point(dimensions.width, 0)
<< svg::Point(dimensions.width, dimensions.height) << svg::Point(0, dimensions.height);
doc << border;
svg::LineChart chart(dimensions);
svg::Polyline bt_line(svg::Stroke(.5, svg::Color::Blue));
svg::Polyline it_line(svg::Stroke(.5, svg::Color::Aqua));
svg::Polyline it_calc_line(svg::Stroke(.5, svg::Color::Fuchsia));
APPROXPOINT point;
point = *(*++buffer->bg->data.begin());
double minxValue = point.x;
point = *(*--buffer->bg->data.end());
double maxxValue = point.x;
double maxY = 0;
vector<APPROXPOINT*>* bg = &buffer->bg->data;
vector<APPROXPOINT*>* ig = &buffer->ig->data;
vector<APPROXPOINT*>* result = &buffer->result->data;
//identifying max Y value
for(unsigned int i = 0; i < bg->size(); i++)
{
point = *(*bg)[i];
if(point.y > maxY)
maxY = point.y;
}
for(unsigned int i = 0; i < ig->size(); i++)
{
point = *(*ig)[i];
if(point.y > maxY)
maxY = point.y;
}
for(unsigned int i = 0; i < result->size(); i++)
{
point = *(*result)[i];
if(point.y > maxY)
maxY = point.y;
}
//drawing lines
for(unsigned int i = 0; i < bg->size(); i++)
{
point = *(*bg)[i];
bt_line << svg::Point((point.x - minxValue)/(maxxValue - minxValue) * WEIGHT + OFFSET / 2, (point.y / maxY) * HEIGHT );
}
for(unsigned int i = 0; i < ig->size(); i++)
{
point = *(*ig)[i];
it_line << svg::Point((point.x - minxValue)/(maxxValue - minxValue) * WEIGHT + OFFSET / 2, (point.y / maxY) * HEIGHT );
}
for(unsigned int i = 0; i < result->size(); i++)
{
point = *(*result)[i];
it_calc_line << svg::Point((point.x - minxValue)/(maxxValue - minxValue) * WEIGHT + OFFSET / 2, (point.y / maxY) * HEIGHT );
}
doc << svg::Text(svg::Point(10, HEIGHT - LINE_HEIGHT), "Provided b(t)", svg::Color::Blue, svg::Font(10, "Verdana"));
doc << svg::Text(svg::Point(10, HEIGHT - 2 * LINE_HEIGHT), "Provided i(t)", svg::Color::Aqua, svg::Font(10, "Verdana"));
doc << svg::Text(svg::Point(10, HEIGHT - 3 * LINE_HEIGHT), "Calculated i(t)", svg::Color::Fuchsia, svg::Font(10, "Verdana"));
std::stringstream p, c, cg, dt, k;
p << "p = " << outParams.p;
c << "c = " << outParams.c;
cg << "cg = " << outParams.cg;
dt << "dt = " << outParams.dt;
k << "k = " << outParams.k;
doc << svg::Text(svg::Point(10, 50), p.str(), svg::Color::Black, svg::Font(10, "Verdana"));
doc << svg::Text(svg::Point(10, 40), c.str(), svg::Color::Black, svg::Font(10, "Verdana"));
doc << svg::Text(svg::Point(10, 30), cg.str(), svg::Color::Black, svg::Font(10, "Verdana"));
doc << svg::Text(svg::Point(10, 20), dt.str(), svg::Color::Black, svg::Font(10, "Verdana"));
doc << svg::Text(svg::Point(10, 10), k.str(), svg::Color::Black, svg::Font(10, "Verdana"));
cout << "Buffered" << endl;
doc << chart << bt_line << it_line << it_calc_line;
cout << "Streams written." << endl;
doc.save();
cout << "Saved." << endl;
}
void
RenderBarograph(Canvas &canvas, const PixelRect rc,
const ChartLook &chart_look,
const CrossSectionLook &cross_section_look,
const FlightStatistics &fs,
const NMEAInfo &nmea_info,
const DerivedInfo &derived_info,
const ProtectedTaskManager *_task)
{
ChartRenderer chart(chart_look, canvas, rc);
if (!fs.altitude.HasResult()) {
chart.DrawNoData();
return;
}
DrawVerticalGradient(canvas, chart.GetChartRect(),
cross_section_look.sky_color, cross_section_look.background_color,
cross_section_look.background_color);
chart.ScaleXFromData(fs.altitude);
chart.ScaleYFromData(fs.altitude);
chart.ScaleYFromValue(0);
chart.ScaleXFromValue(fs.altitude.GetMinX());
if (derived_info.flight.flying)
chart.ScaleXFromValue(derived_info.flight.flight_time/3600);
if (!fs.altitude_ceiling.IsEmpty()) {
chart.ScaleYFromValue(fs.altitude_ceiling.GetMaxY());
}
if (_task != nullptr) {
ProtectedTaskManager::Lease task(*_task);
RenderTaskLegs(chart, task, nmea_info, derived_info, 0.33);
}
canvas.SelectNullPen();
canvas.Select(cross_section_look.terrain_brush);
chart.DrawFilledLineGraph(fs.altitude_terrain);
canvas.SelectWhitePen();
canvas.SelectWhiteBrush();
chart.DrawXGrid(0.25, 0.25, ChartRenderer::UnitFormat::TIME);
chart.DrawYGrid(Units::ToSysAltitude(1000), 1000, ChartRenderer::UnitFormat::NUMERIC);
if (fs.altitude_base.HasResult()) {
chart.DrawLineGraph(fs.altitude_base, ChartLook::STYLE_REDTHICKDASH);
} else if (!fs.altitude_base.IsEmpty()) {
chart.DrawTrend(fs.altitude_base, ChartLook::STYLE_REDTHICKDASH);
}
if (fs.altitude_ceiling.HasResult()) {
chart.DrawLineGraph(fs.altitude_ceiling, ChartLook::STYLE_BLUETHINDASH);
} else if (!fs.altitude_ceiling.IsEmpty()) {
chart.DrawTrend(fs.altitude_ceiling, ChartLook::STYLE_BLUETHINDASH);
}
chart.DrawLineGraph(fs.altitude, ChartLook::STYLE_BLACK);
chart.DrawXLabel(_T("t"), _T("hr"));
chart.DrawYLabel(_T("h"), Units::GetAltitudeName());
}
