Line data    Source code

       1             : //# Plotter.cc: Highest level plotting object that holds one or more canvases.
       2             : //# Copyright (C) 2009
       3             : //# Associated Universities, Inc. Washington DC, USA.
       4             : //#
       5             : //# This library is free software; you can redistribute it and/or modify it
       6             : //# under the terms of the GNU Library General Public License as published by
       7             : //# the Free Software Foundation; either version 2 of the License, or (at your
       8             : //# option) any later version.
       9             : //#
      10             : //# This library is distributed in the hope that it will be useful, but WITHOUT
      11             : //# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      12             : //# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
      13             : //# License for more details.
      14             : //#
      15             : //# You should have received a copy of the GNU Library General Public License
      16             : //# along with this library; if not, write to the Free Software Foundation,
      17             : //# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
      18             : //#
      19             : //# Correspondence concerning AIPS++ should be addressed as follows:
      20             : //#        Internet email: aips2-request@nrao.edu.
      21             : //#        Postal address: AIPS++ Project Office
      22             : //#                        National Radio Astronomy Observatory
      23             : //#                        520 Edgemont Road
      24             : //#                        Charlottesville, VA 22903-2475 USA
      25             : //#
      26             : //# $Id: $
      27             : #include <graphics/GenericPlotter/Plotter.h>
      28             : 
      29             : #include <casacore/casa/OS/Time.h>
      30             : 
      31             : #include <ctype.h>
      32             : #include <iomanip>
      33             : #include <stdint.h>
      34             : 
      35             : using namespace std;
      36             : 
      37             : using namespace casacore;
      38             : namespace casa {
      39             : 
      40             : /////////////////////////
      41             : // PLOTTER DEFINITIONS //
      42             : /////////////////////////
      43             : 
      44             : // Static //
      45             : 
      46             : const String Plotter::DEFAULT_DATE_FORMAT = "%y/%m/%d\n%h:%n:%s";
      47             : const String Plotter::DEFAULT_RELATIVE_DATE_FORMAT = "%h:%n:%s";
      48             : 
      49           0 : String Plotter::formattedDateString(const String& format, double value,
      50             :             PlotAxisScale scale, bool isRelative, int secPrecision) {
      51             :     // Values to be used in formatted String.
      52           0 :     Time t;
      53           0 :     int64_t hours = 0;
      54           0 :     uint64_t minutes = 0;
      55           0 :     double seconds = 0;
      56           0 :     stringstream ss;
      57             :     
      58             :     // Calculate relative values, if needed.
      59           0 :     if(isRelative) {
      60             :         // Put - in front for negative value.
      61           0 :         if(scale == DATE_MJ_DAY) {
      62           0 :             double temp = value * 24;
      63           0 :             hours = int64_t(temp);
      64           0 :             temp -= hours;
      65           0 :             temp *= 60;
      66           0 :             minutes = uint64_t(std::abs(temp));
      67           0 :             temp *= 60;
      68           0 :             seconds = std::abs(temp);
      69           0 :         } else if(scale == DATE_MJ_SEC) {
      70           0 :             hours = (int64_t)(value / 3600);
      71           0 :             double temp = value - (hours * 3600);
      72           0 :             minutes = (uint64_t)(std::abs(temp / 60));
      73           0 :             temp = std::abs(temp) - minutes * 60;
      74           0 :             seconds = temp;
      75             :         }
      76             :         
      77             :     // Calculate absolute values, if needed.
      78             :     } else {
      79           0 :         if(scale == DATE_MJ_SEC) {
      80           0 :             t = Time((value / 86400) + 2400000.5);
      81           0 :             seconds = modf(value, &seconds);
      82           0 :         } else if(scale == DATE_MJ_DAY) {
      83           0 :             t = Time(value + 2400000.5);
      84           0 :             seconds = modf(value * 86400, &seconds);
      85             :         }
      86             :     }
      87             :     
      88           0 :     int defPrec = ss.precision(); // change and restore for seconds
      89             :     char c;
      90           0 :     for(unsigned int i = 0; i < format.length(); i++) {
      91           0 :         c = format[i];
      92           0 :         if(c == '%' && i < format.length() - 1) {
      93           0 :             c = format[++i];
      94           0 :             switch(c) {
      95           0 :             case 'y': case 'Y':
      96           0 :                 if(!isRelative) ss << t.year();
      97           0 :                 break;
      98             :                 
      99           0 :             case 'm': case 'M':
     100           0 :                 if(!isRelative) {
     101           0 :                     if(t.month() < 10) ss << '0';
     102           0 :                     ss << t.month();
     103             :                 }
     104           0 :                 break;
     105             :                 
     106           0 :             case 'd': case 'D':
     107           0 :                 if(!isRelative) {
     108           0 :                     if(t.dayOfMonth() < 10) ss << '0';
     109           0 :                     ss << t.dayOfMonth();
     110             :                 }
     111           0 :                 break;
     112             :                 
     113           0 :             case 'h': case 'H':
     114           0 :                 if(!isRelative) {
     115           0 :                     if(t.hours() < 10) ss << '0';
     116           0 :                     ss << t.hours();
     117             :                 } else {
     118           0 :                     if (hours < 10) ss << '0';
     119           0 :                     ss << hours;
     120             :                 }
     121           0 :                 break;
     122             :                 
     123           0 :             case 'n': case 'N':
     124           0 :                 if(!isRelative) {
     125           0 :                     if(t.minutes() < 10) ss << '0';
     126           0 :                     ss << t.minutes();
     127             :                 } else {
     128           0 :                     if(minutes < 10) ss << '0';
     129           0 :                     ss << minutes;
     130             :                 }
     131           0 :                 break;
     132             :                 
     133           0 :             case 's': case 'S':
     134           0 :                                 if (secPrecision >=0)
     135           0 :                                         ss.precision(secPrecision);
     136             :                                 else
     137           0 :                                         ss.precision(4);
     138           0 :                 if(!isRelative) {
     139           0 :                     if(t.seconds() < 10) ss << '0';
     140           0 :                     ss << fixed << (t.seconds() + seconds);
     141             :                 } else {
     142           0 :                     if(seconds < 10) ss << '0';
     143           0 :                     ss << fixed << seconds;
     144             :                 }
     145           0 :                 ss.precision(defPrec);
     146           0 :                 break;
     147             :                 
     148           0 :             case 'p': case 'P': {
     149           0 :                 if(i >= format.length() - 1 || (!isdigit(format[i + 1]) &&
     150           0 :                    format[i + 1] != '-' && format[i + 1] != '+')) break;
     151             : 
     152           0 :                 i++;
     153           0 :                 unsigned int j = i + 1;
     154           0 :                 for(; j < format.length() && isdigit(format[j]); j++);
     155             :                     
     156           0 :                 String sprec = format.substr(i, j - i);
     157             :                 int prec;
     158           0 :                 sscanf(sprec.c_str(), "%d", &prec);
     159           0 :                 if(prec < 0) prec = defPrec;
     160           0 :                 ss.precision(prec);
     161             :                 
     162           0 :                 if(prec >= 0) ss << setprecision(prec);
     163           0 :                 break; }
     164             :                 
     165           0 :             default: ss << format[i - 1] << c; break;
     166             :             }
     167           0 :         } else ss << c;
     168             :     }
     169             : 
     170           0 :     return ss.str();
     171             : }
     172             : 
     173             : 
     174             : // Non-Static //
     175             : 
     176           0 : Plotter::Plotter() {
     177           0 :         commonAxisX = false;
     178           0 :         commonAxisY = false;
     179           0 : }
     180             : 
     181           0 : Plotter::~Plotter() { }
     182             : 
     183             : 
     184           0 : PlotCanvasPtr Plotter::canvasAt(const PlotLayoutCoordinate& coord) {
     185           0 :     PlotCanvasLayoutPtr layout = canvasLayout();
     186           0 :     if(!layout.null()) return layout->canvasAt(coord);
     187           0 :     else               return PlotCanvasPtr();
     188             : }
     189             : 
     190           0 : PlotCanvasPtr Plotter::canvas() {
     191           0 :     PlotCanvasLayoutPtr layout = canvasLayout();
     192           0 :     if(!layout.null()) return layout->canvas();
     193           0 :     else               return PlotCanvasPtr();
     194             : }
     195             : 
     196           0 : void Plotter::setCanvasCachedAxesStackImageSize( int width, int height ){
     197           0 :         PlotCanvasLayoutPtr layout = canvasLayout();
     198           0 :         if ( !layout.null() ) {
     199           0 :                 vector<PlotCanvasPtr> canv = layout->allCanvases();
     200           0 :             for(unsigned int i = 0; i < canv.size(); i++){
     201           0 :                 if(!canv[i].null()){
     202           0 :                         canv[i]->setCachedAxesStackImageSize(width,height);
     203             :                 }
     204             :             }
     205             :         }
     206           0 : }
     207             : 
     208           0 : void Plotter::setCanvas(PlotCanvasPtr canvas) {
     209           0 :     if(!canvas.null())
     210           0 :         setCanvasLayout(PlotCanvasLayoutPtr(new PlotLayoutSingle(canvas)));
     211           0 : }
     212             : 
     213           0 : void Plotter::setCommonAxisX(Bool commonAxis ){
     214           0 :         commonAxisX = commonAxis;
     215           0 : }
     216             : 
     217           0 : void Plotter::setCommonAxisY(Bool commonAxis ){
     218           0 :         commonAxisY = commonAxis;
     219           0 : }
     220             : 
     221             : 
     222           0 : bool Plotter::isCommonAxisX() const {
     223           0 :         return commonAxisX;
     224             : }
     225             : 
     226           0 : bool Plotter::isCommonAxisY() const {
     227           0 :         return commonAxisY;
     228             : }
     229             : 
     230           0 : void Plotter::setAxisLocation( PlotAxis xLocation, PlotAxis yLocation ){
     231           0 :         axisLocationX = xLocation;
     232           0 :         axisLocationY = yLocation;
     233           0 : }
     234             : 
     235           0 : PlotAxis Plotter::getAxisLocationX() const {
     236           0 :         return axisLocationX;
     237             : }
     238             : 
     239           0 : PlotAxis Plotter::getAxisLocationY() const {
     240           0 :         return axisLocationY;
     241             : }
     242             : 
     243           0 : LogMessage::Priority Plotter::logFilterMinPriority() const {
     244           0 :     return logger()->filterMinPriority(); }
     245           0 : void Plotter::setLogFilterMinPriority(PlotLogMessage::Priority minPriority) {
     246           0 :     logger()->setFilterMinPriority(minPriority); }
     247             : 
     248           0 : bool Plotter::logFilterEventFlag(int flag) const {
     249           0 :     return logger()->filterEventFlag(flag); }
     250           0 : void Plotter::setLogFilterEventFlag(int flag, bool on) {
     251           0 :     logger()->setFilterEventFlag(flag, on); }
     252             : 
     253           0 : int Plotter::logFilterEventFlags() const{ return logger()->filterEventFlags();}
     254           0 : void Plotter::setLogFilterEventFlags(int flags) {
     255           0 :     logger()->setFilterEventFlags(flags); }
     256             : 
     257           0 : PlotLoggerPtr Plotter::logger() const {
     258           0 :     if(m_logger.null())
     259           0 :         const_cast<PlotLoggerPtr&>(m_logger) = new PlotLogger(
     260           0 :                 const_cast<Plotter*>(this));
     261           0 :     return m_logger;
     262             : }
     263             : 
     264           0 : bool Plotter::isVisible(PlotCanvasPtr& canvas ){
     265           0 :         vector<PlotCanvasPtr> currentPlots = canvasLayout()->allCanvases();
     266           0 :         int plotCount = currentPlots.size();
     267           0 :         bool visible = false;
     268           0 :         for ( int i = 0; i < plotCount; i++  ){
     269           0 :                 if ( currentPlots[i] == canvas ){
     270           0 :                         visible = true;
     271           0 :                         break;
     272             :                 }
     273             :         }
     274           0 :         return visible;
     275             : }
     276             : 
     277             : }