logger.h

Go to the documentation of this file.

// -*-c++-*-
 
/*
 *Copyright:
 
 Copyright (C) Hidehisa AKIYAMA
 
 This code is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3 of the License, or (at your option) any later version.
 
 This library 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
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 *EndCopyright:
 */
 
 
#ifndef RCSC_PLAYER_LOGGER_H
#define RCSC_PLAYER_LOGGER_H
 
#include <rcsc/geom/vector_2d.h>
#include <rcsc/geom/circle_2d.h>
#include <rcsc/geom/rect_2d.h>
#include <rcsc/geom/sector_2d.h>
#include <rcsc/geom/triangle_2d.h>
 
#include <string>
#include <cstdio>
#include <cstdint>
 
namespace rcsc {
 
class GameTime;
 
class Logger {
public:
 
    static const std::int32_t LEVEL_00 = 0x00000000; 
    static const std::int32_t LEVEL_01 = 0x00000001; 
    static const std::int32_t LEVEL_02 = 0x00000002; 
    static const std::int32_t LEVEL_03 = 0x00000004; 
    static const std::int32_t LEVEL_04 = 0x00000008; 
    static const std::int32_t LEVEL_05 = 0x00000010; 
    static const std::int32_t LEVEL_06 = 0x00000020; 
    static const std::int32_t LEVEL_07 = 0x00000040; 
    static const std::int32_t LEVEL_08 = 0x00000080; 
    static const std::int32_t LEVEL_09 = 0x00000100; 
    static const std::int32_t LEVEL_10 = 0x00000200; 
    static const std::int32_t LEVEL_11 = 0x00000400; 
    static const std::int32_t LEVEL_12 = 0x00000800; 
    static const std::int32_t LEVEL_13 = 0x00001000; 
    static const std::int32_t LEVEL_14 = 0x00002000; 
    static const std::int32_t LEVEL_15 = 0x00004000; 
    static const std::int32_t LEVEL_16 = 0x00008000; 
    static const std::int32_t LEVEL_17 = 0x00010000; 
    static const std::int32_t LEVEL_18 = 0x00020000; 
    static const std::int32_t LEVEL_19 = 0x00040000; 
    static const std::int32_t LEVEL_20 = 0x00080000; 
    static const std::int32_t LEVEL_21 = 0x00100000; 
    static const std::int32_t LEVEL_22 = 0x00200000; 
    static const std::int32_t LEVEL_23 = 0x00400000; 
    static const std::int32_t LEVEL_24 = 0x00800000; 
    static const std::int32_t LEVEL_25 = 0x01000000; 
    static const std::int32_t LEVEL_26 = 0x02000000; 
    static const std::int32_t LEVEL_27 = 0x04000000; 
    static const std::int32_t LEVEL_28 = 0x08000000; 
    static const std::int32_t LEVEL_29 = 0x10000000; 
    static const std::int32_t LEVEL_30 = 0x20000000; 
    static const std::int32_t LEVEL_31 = 0x40000000; 
    static const std::int32_t LEVEL_32 = 0x80000000; 
 
    /*************************************************
    Log Message Line Format:
    Line := <Time> <Level> <Type> <Content>
    Time := integer value
    Level := integer value
    Type :=  M | p | l | a | c | C | t | T | r | R | s | m
        M : log message for text viewer
        p : point
        l: line
        a: arc
        c: circle
        C: filled circle
        t: triangle
        T: filled triangle
        r: rectangle
        R: filled rectangle
        s: sector
        S: filled sector
        m: message painted on the field
    Text := <Str>
    Point := <x:Real> <y:Real>[ <Color>]
    Line := <x1:Real> <y1:Real> <x2:Real> <y2:Real>[ <Color>]
    Arc := <x:Real> <y:Real> <r:Real> <startAngle:Real> <spanAngle:Real>[ <Color>]
    Circle := <x:Real> <y:Real> <r:Real>[ <Color>]
    Triangle := <x1:Real> <y1:Real> <x2:Real> <y2:Real> <x3:Real> <y3:Real>[ <Color>]
    Rectangle := <leftX:Real> <topY:Real> <width:Real> <height:Real>[ <Color>]
    Sector := <x:Real> <y:Real> <minR:Real> <maxR:Real> <startAngle:Real> <spanAngle:Real>[ <Color>]
    Message := <x:Real> <y:Real>[ (c <Color>)] <Str>
    **************************************************/
 
    static const std::int32_t SYSTEM    = LEVEL_01; 
    static const std::int32_t SENSOR    = LEVEL_02; 
    static const std::int32_t WORLD     = LEVEL_03; 
    static const std::int32_t ACTION    = LEVEL_04; 
    static const std::int32_t INTERCEPT = LEVEL_05; 
    static const std::int32_t KICK      = LEVEL_06; 
    static const std::int32_t HOLD      = LEVEL_07; 
    static const std::int32_t DRIBBLE   = LEVEL_08; 
    static const std::int32_t PASS      = LEVEL_09; 
    static const std::int32_t CROSS     = LEVEL_10; 
    static const std::int32_t SHOOT     = LEVEL_11; 
    static const std::int32_t CLEAR     = LEVEL_12; 
    static const std::int32_t BLOCK     = LEVEL_13; 
    static const std::int32_t MARK      = LEVEL_14; 
    static const std::int32_t POSITIONING = LEVEL_15; 
    static const std::int32_t ROLE      = LEVEL_16; 
    static const std::int32_t TEAM      = LEVEL_17; 
    static const std::int32_t COMMUNICATION = LEVEL_18; 
    static const std::int32_t ANALYZER  = LEVEL_19; 
    static const std::int32_t ACT_SEQ   = LEVEL_20; 
    static const std::int32_t ACTION_CHAIN = ACT_SEQ; 
    static const std::int32_t PLAN      = LEVEL_21; 
 
    static const std::int32_t TRAINING  = LEVEL_32; 
 
    static const std::int32_t LEVEL_ANY = 0xffffffff; 
 
private:
 
    const GameTime * M_time;
 
    FILE * M_fout;
 
    std::int32_t M_flags;
 
    int M_start_time;
    int M_end_time;
 
public:
    Logger();
 
    ~Logger();
 
    void setLogFlag( const GameTime * time,
                     const std::int32_t level,
                     const bool on = true );
 
    void setTimeRange( const int start_time,
                       const int end_time );
 
    bool isEnabled( const std::int32_t level ) const
      {
          return ( level & M_flags );
      }
 
    void open( const std::string & filepath );
 
    void openStandardOutput();
 
    void openStandardError();
 
    void close();
 
    bool isOpen()
      {
          return ( M_fout != NULL );
      }
 
    void flush();
 
    void clear();
 
    void addText( const std::int32_t level,
                  const char * msg,
                  ... );
 
    void addPoint( const std::int32_t level,
                   const double x,
                   const double y,
                   const char * color = NULL );
 
    void addPoint( const std::int32_t level,
                   const Vector2D & pos,
                   const char * color = NULL )
      {
          addPoint( level, pos.x, pos.y, color );
      }
 
    void addPoint( const std::int32_t level,
                   const double x,
                   const double y,
                   const int r, const int g, const int b );
 
    void addPoint( const std::int32_t level,
                   const Vector2D & pos,
                   const int r, const int g, const int b )
      {
          addPoint( level, pos.x, pos.y, r, g, b );
      }
 
    void addLine( const std::int32_t level,
                  const double x1,
                  const double y1,
                  const double x2,
                  const double y2,
                  const char * color = NULL );
 
    void addLine( const std::int32_t level,
                  const Vector2D & start,
                  const Vector2D & end,
                  const char * color = NULL )
      {
          addLine( level, start.x, start.y, end.x, end.y, color );
      }
 
    void addLine( const std::int32_t level,
                  const double x1,
                  const double y1,
                  const double x2,
                  const double y2,
                  const int r, const int g, const int b );
 
    void addLine( const std::int32_t level,
                  const Vector2D & start,
                  const Vector2D & end,
                  const int r, const int g, const int b )
      {
          addLine( level, start.x, start.y, end.x, end.y, r, g, b );
      }
 
    void addArc( const std::int32_t level,
                 const double x,
                 const double y,
                 const double radius,
                 const AngleDeg & start_angle,
                 const double span_angle,
                 const char * color = NULL );
 
    void addArc( const std::int32_t level,
                 const Vector2D & center,
                 const double radius,
                 const AngleDeg & start_angle,
                 const double span_angle,
                 const char * color = NULL )
      {
          addArc( level, center.x, center.y, radius, start_angle, span_angle, color );
      }
 
    void addArc( const std::int32_t level,
                 const double x,
                 const double y,
                 const double radius,
                 const AngleDeg & start_angle,
                 const double span_angle,
                 const int r, const int g, const int b );
 
    void addArc( const std::int32_t level,
                 const Vector2D & center,
                 const double radius,
                 const AngleDeg & start_angle,
                 const double span_angle,
                 const int r, const int g, const int b )
      {
          addArc( level, center.x, center.y, radius, start_angle, span_angle, r, g, b );
      }
 
    void addCircle( const std::int32_t level,
                    const double x,
                    const double y,
                    const double radius,
                    const char * color = NULL,
                    const bool fill = false );
 
    void addCircle( const std::int32_t level,
                    const Vector2D & center,
                    const double radius,
                    const char * color = NULL,
                    const bool fill = false )
      {
          addCircle( level, center.x, center.y, radius, color, fill );
      }
 
    void addCircle( const std::int32_t level,
                    const Circle2D & circle,
                    const char * color = NULL,
                    const bool fill = false )
      {
          addCircle( level, circle.center().x, circle.center().y, circle.radius(), color, fill );
      }
 
    void addCircle( const std::int32_t level,
                    const double x,
                    const double y,
                    const double radius,
                    const int r, const int g, const int b,
                    const bool fill = false );
 
    void addCircle( const std::int32_t level,
                    const Vector2D & center,
                    const double radius,
                    const int r, const int g, const int b,
                    const bool fill = false )
      {
          addCircle( level, center.x, center.y, radius, r, g, b, fill );
      }
 
    void addCircle( const std::int32_t level,
                    const Circle2D & circle,
                    const int r, const int g, const int b,
                    const bool fill = false )
      {
          addCircle( level,
                     circle.center().x, circle.center().y, circle.radius(),
                     r, g, b,
                     fill );
      }
 
    void addTriangle( const std::int32_t level,
                      const double x1,
                      const double y1,
                      const double x2,
                      const double y2,
                      const double x3,
                      const double y3,
                      const char * color = NULL,
                      const bool fill = false );
 
    void addTriangle( const std::int32_t level,
                      const Vector2D & p1,
                      const Vector2D & p2,
                      const Vector2D & p3,
                      const char * color = NULL,
                      const bool fill = false )
      {
          addTriangle( level,
                       p1.x, p1.y,
                       p2.x, p2.y,
                       p3.x, p3.y,
                       color,
                       fill );
      }
 
    void addTriangle( const std::int32_t level,
                      const Triangle2D & tri,
                      const char * color = NULL,
                      const bool fill = false )
      {
          addTriangle( level,
                       tri.a().x, tri.a().y,
                       tri.b().x, tri.b().y,
                       tri.c().x, tri.c().y,
                       color,
                       fill );
      }
 
    void addTriangle( const std::int32_t level,
                      const double x1,
                      const double y1,
                      const double x2,
                      const double y2,
                      const double x3,
                      const double y3,
                      const int r, const int g, const int b,
                      const bool fill = false );
 
    void addTriangle( const std::int32_t level,
                      const Vector2D & p1,
                      const Vector2D & p2,
                      const Vector2D & p3,
                      const int r, const int g, const int b,
                      const bool fill = false )
      {
          addTriangle( level,
                       p1.x, p1.y,
                       p2.x, p2.y,
                       p3.x, p3.y,
                       r, g, b,
                       fill );
      }
 
    void addTriangle( const std::int32_t level,
                      const Triangle2D & tri,
                      const int r, const int g, const int b,
                      const bool fill = false )
      {
          addTriangle( level,
                       tri.a().x, tri.a().y,
                       tri.b().x, tri.b().y,
                       tri.c().x, tri.c().y,
                       r, g, b,
                       fill );
      }
 
    void addRect( const std::int32_t level,
                  const double left,
                  const double top,
                  const double length,
                  const double width,
                  const char * color = NULL,
                  const bool fill = false );
 
    void addRect( const std::int32_t level,
                  const Rect2D & rect,
                  const char * color = NULL,
                  const bool fill = false )
      {
          addRect( level,
                   rect.left(), rect.top(),
                   rect.size().length(), rect.size().width(),
                   color,
                   fill );
      }
 
    void addRect( const std::int32_t level,
                  const double left,
                  const double top,
                  const double length,
                  const double width,
                  const int r, const int g, const int b,
                  const bool fill = false );
 
    void addRect( const std::int32_t level,
                  const Rect2D & rect,
                  const int r, const int g, const int b,
                  const bool fill = false )
      {
          addRect( level,
                   rect.left(), rect.top(),
                   rect.size().length(), rect.size().width(),
                   r, g, b,
                   fill );
      }
 
    void addSector( const std::int32_t level,
                    const double x,
                    const double y,
                    const double min_radius,
                    const double max_radius,
                    const AngleDeg & start_angle,
                    const double span_angle,
                    const char * color = NULL,
                    const bool fill = false );
 
    void addSector( const std::int32_t level,
                    const Vector2D & center,
                    const double min_radius,
                    const double max_radius,
                    const AngleDeg & start_angle,
                    const double span_angle,
                    const char * color = NULL,
                    const bool fill = false )
      {
          addSector( level,
                     center.x, center.y, min_radius, max_radius,
                     start_angle, span_angle,
                     color,
                     fill );
      }
 
    void addSector( const std::int32_t level,
                    const double x,
                    const double y,
                    const double min_radius,
                    const double max_radius,
                    const AngleDeg & start_angle,
                    const double span_angle,
                    const int r, const int g, const int b,
                    const bool fill = false );
 
    void addSector( const std::int32_t level,
                    const Vector2D & center,
                    const double min_radius,
                    const double max_radius,
                    const AngleDeg & start_angle,
                    const double span_angle,
                    const int r, const int g, const int b,
                    const bool fill = false )
      {
          addSector( level,
                     center.x, center.y, min_radius, max_radius,
                     start_angle, span_angle,
                     r, g, b,
                     fill );
      }
 
    void addSector( const std::int32_t level,
                    const Sector2D & sector,
                    const char * color = NULL,
                    const bool fill = false );
 
    void addSector( const std::int32_t level,
                    const Sector2D & sector,
                    const int r, const int g, const int b,
                    const bool fill = false );
 
    void addMessage( const std::int32_t level,
                     const double x,
                     const double y,
                     const char * msg,
                     const char * color = NULL );
 
    void addMessage( const std::int32_t level,
                     const Vector2D & pos,
                     const char * msg,
                     const char * color = NULL )
      {
          addMessage( level,
                      pos.x, pos.y, msg,
                      color );
      }
 
    void addMessage( const std::int32_t level,
                     const double x,
                     const double y,
                     const char * msg,
                     const int r, const int g, const int b );
 
    void addMessage( const std::int32_t level,
                     const Vector2D & pos,
                     const char * msg,
                     const int r, const int g, const int b )
      {
          addMessage( level,
                      pos.x, pos.y, msg,
                      r, g, b );
      }
 
};
 
extern Logger dlog;
 
}
 
#endif