visobject.c

robocup rcssmonitor-11.1.1.zip

/*
 * Copyright (c) 1999 - 2001, Artur Merke <[e-mail]>
 *
 * This file is part of FrameView2d.
 *
 * FrameView2d 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, or (at your option)
 * any later version.
 *
 * FrameView2d 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 FrameView2d; see the file COPYING.  If not, write to
 * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "visobject.h"

VisualObject2d::VisualObject2d() {
  key= 0;
  layer = 0;
  visible= true;
}

#if 0
void VisualObject2d::set_color(const RGBcolor & col) {
  if (color != col ) {
    color= col;
    if (d_obj)
      d_obj->mark_col_change();
  }
}
#endif

VisualPoint2d::VisualPoint2d() 
  : VisualObject2d() {
  init();
}

VisualPoint2d::VisualPoint2d(int my_key, int my_layer, const RGBcolor & my_color, const Point2d & my_data)
  : VisualObject2d() {
  init();

  key= my_key;
  layer= my_layer;
  color= my_color;
  rel= my_data;
}

void VisualPoint2d::init() {
  changed= true;
  use_intersects_area= true;
  key= 0;
  layer= 0;
  d_obj= 0;
}

void VisualPoint2d::draw(DisplayBase * disp, const Area2d & area, const Frame2d & p_frame, bool chg) {
  if ( !visible )
    return;

  actualize(p_frame,chg);

  if ( use_intersects_area && !intersects_area(area) ) 
    return;

  if (!d_obj)
    d_obj= disp->create_point();

  disp->draw_point(d_obj,color,abs);
}

void VisualPoint2d::actualize(const Frame2d & f, bool chg) {
  if (!chg && !changed)
    return;

  abs = f*rel;
  if (d_obj)
    d_obj->mark_pos_change();

  changed= false;
}

void VisualPoint2d::set_color(const RGBcolor & col) {
  if (color != col ) {
    color= col;
    if (d_obj)
      d_obj->mark_col_change();
  }
}

bool VisualPoint2d::intersects_area(const Area2d & a) {
  return a.intersects(abs);
}
////
VisualPoints2d::VisualPoints2d() 
  : VisualObject2d() {
  init();
}

VisualPoints2d::VisualPoints2d(int my_key, int my_layer, const RGBcolor & my_color, int len_data, const Point2d * data) 
  : VisualObject2d() {
  init();
  
  key= my_key;
  layer= my_layer;
  color= my_color;

  rel.clone(len_data,data);
  abs= rel;
}

void VisualPoints2d::init() {
  changed= true;
  use_intersects_area= true;
  key= 0;
  layer= 0;
  d_obj= 0;
}

void VisualPoints2d::draw(DisplayBase * disp, const Area2d & area, const Frame2d & p_frame, bool chg) {
  if ( !visible )
    return;

  actualize(p_frame,chg);

  if ( use_intersects_area && !intersects_area(area) ) 
    return;

  if (!d_obj)
    d_obj= disp->create_points(abs.max_size);

  disp->draw_points(d_obj,color,abs.cur_size,abs.tab);
}

void VisualPoints2d::actualize(const Frame2d & f, bool chg) {
  if (!chg && !changed)
    return;

  for (int i=0; i<abs.cur_size; i++)
    abs.tab[i] = f*rel.tab[i];
  if (d_obj)
    d_obj->mark_pos_change();

  changed= false;
}

void VisualPoints2d::set_color(const RGBcolor & col) {
  if (color != col ) {
    color= col;
    if (d_obj)
      d_obj->mark_col_change();
  }
}

void VisualPoints2d::set_points(int len_data, const Point2d * data) {
  if (d_obj) 
    d_obj->set_max_size(len_data);

  rel.clone(len_data,data);
  abs= rel;
  changed= true;
}

bool VisualPoints2d::intersects_area(const Area2d & a) {
  for (int i=0; i<abs.cur_size; i++)
    if (a.intersects(abs.tab[i])) return true;
  return false;
}
/*****************************************************************************/

VisualLine2d::VisualLine2d() 
  : VisualObject2d() {
  init();
}

VisualLine2d::VisualLine2d(int my_key, int my_layer, const RGBcolor & my_color, const Line2d & my_data)
  : VisualObject2d() {
  init();
  
  key= my_key;
  layer= my_layer;
  color= my_color;

  rel= my_data;
}

void VisualLine2d::init() {
  changed= true;
  use_intersects_area= true;
  key= 0;
  layer= 0;
  d_obj= 0;
}

void VisualLine2d::draw(DisplayBase * disp, const Area2d & area, const Frame2d & p_frame, bool chg) {
  if ( !visible )
    return;

  actualize(p_frame,chg);

  if ( use_intersects_area && !intersects_area(area) ) 
    return;

  if (!d_obj)
    d_obj= disp->create_line();

  disp->draw_line(d_obj,color,abs);
}

void VisualLine2d::actualize(const Frame2d & f, bool chg) {
  if (!chg && !changed)
    return;

  abs.p1 = f* rel.p1;
  abs.p2 = f* rel.p2;
  if (d_obj)
    d_obj->mark_pos_change();

  changed= false;
}

void VisualLine2d::set_color(const RGBcolor & col) {
  if (color != col ) {
    color= col;
    if (d_obj)
      d_obj->mark_col_change();
  }
}

bool VisualLine2d::intersects_area(const Area2d & a) {
  return a.intersects(abs);
}
////
VisualLines2d::VisualLines2d() 
  : VisualObject2d() {
  init();
}

VisualLines2d::VisualLines2d(int my_key, int my_layer, const RGBcolor & my_color, int len_data, const Line2d * data)
  : VisualObject2d() {
  init();
  
  key= my_key;
  layer= my_layer;
  color= my_color;

  rel.clone(len_data,data);
  abs= rel;
  d_obj= 0;
}

void VisualLines2d::init() {
  changed= true;
  use_intersects_area= true;
  key= 0;
  layer= 0;
  d_obj= 0;
}

void VisualLines2d::draw(DisplayBase * disp, const Area2d & area, const Frame2d & p_frame, bool chg) {
  if ( !visible )
    return;

  actualize(p_frame,chg);

  if ( use_intersects_area && !intersects_area(area) ) 
    return;

  if (!d_obj)
    d_obj= disp->create_lines(abs.max_size);

  disp->draw_lines(d_obj,color,abs.cur_size,abs.tab);
}

void VisualLines2d::actualize(const Frame2d & f, bool chg) {
  if (!chg && !changed)
    return;

  for (int i=0; i<abs.cur_size; i++) {
    abs.tab[i].p1 = f*rel.tab[i].p1;
    abs.tab[i].p2 = f*rel.tab[i].p2;
  }
  if (d_obj)
    d_obj->mark_pos_change();

  changed= false;
}

void VisualLines2d::set_color(const RGBcolor & col) {
  if (color != col ) {
    color= col;
    if (d_obj)
      d_obj->mark_col_change();
  }
}

void VisualLines2d::set_lines(int len_data, const Line2d * data) {
  if (d_obj) 
    d_obj->set_max_size(len_data);

  rel.clone(len_data,data);
  abs= rel;
  changed= true;
}

bool VisualLines2d::intersects_area(const Area2d & a) {
  for (int i=0; i<abs.cur_size; i++)
    if (a.intersects(abs.tab[i])) return true;
  return false;
}
/*****************************************************************************/

VisualCircle2d::VisualCircle2d() { 
  init();
}

VisualCircle2d::VisualCircle2d(int my_key, int my_layer, const RGBcolor & my_color, const Circle2d & my_data)
  : VisualObject2d() {
  init();
  
  key= my_key;
  layer= my_layer;
  color= my_color;

  rel= my_data;
  abs= rel;
}

void VisualCircle2d::init() {
  changed= true;
  use_intersects_area= true;
  key= 0;
  layer= 0;
  d_obj= 0;
  filled= false;
}

void VisualCircle2d::draw(DisplayBase * disp, const Area2d & area, const Frame2d & p_frame, bool chg) {
  if ( !visible )
    return;

  actualize(p_frame,chg);

  if ( use_intersects_area && !intersects_area(area) ) 
    return;

  if (!d_obj)
    d_obj= disp->create_circle();

  if (!filled) 
    disp->draw_circle(d_obj,color,abs);
  else
    disp->fill_circle(d_obj,color,abs);
}

void VisualCircle2d::actualize(const Frame2d & f, bool chg) {
  if (!chg && !changed)
    return;

  abs.center = f* rel.center;
  abs.radius = f.get_scale() * rel.radius;
  if (d_obj)
    d_obj->mark_pos_change();

  changed= false;
}

void VisualCircle2d::set_color(const RGBcolor & col) {
  if (color != col ) {
    color= col;
    if (d_obj)
      d_obj->mark_col_change();
  }
}

bool VisualCircle2d::intersects_area(const Area2d & a) {
  if (!filled)
    return a.intersects(abs);
  return a.intersects_area_of(abs);
}
////
VisualCircles2d::VisualCircles2d() 
  : VisualObject2d() {
  init();
}

VisualCircles2d::VisualCircles2d(int my_key, int my_layer, const RGBcolor & my_color, int len_data, const Circle2d * data)
  : VisualObject2d() {
  init();
  
  key= my_key;
  layer= my_layer;
  color= my_color;

  rel.clone(len_data,data);
  abs= rel;
}

void VisualCircles2d::init() {
  changed= true;
  use_intersects_area= true;
  key= 0;
  layer= 0;
  d_obj= 0;
  filled= false;
}

void VisualCircles2d::draw(DisplayBase * disp, const Area2d & area, const Frame2d & p_frame, bool chg) {
  if ( !visible )
    return;

  actualize(p_frame,chg);

  if ( use_intersects_area && !intersects_area(area) ) 
    return;

  if (!d_obj)
    d_obj= disp->create_circles(abs.max_size);

  if (!filled)
    disp->draw_circles(d_obj,color,abs.cur_size,abs.tab);
  else
    disp->fill_circles(d_obj,color,abs.cur_size,abs.tab);
}

void VisualCircles2d::actualize(const Frame2d & f, bool chg) {
  if (!chg && !changed)
    return;

  for (int i=0; i<abs.cur_size; i++) {
    abs.tab[i].center = f*rel.tab[i].center;
    abs.tab[i].radius = f.get_scale() * rel.tab[i].radius;
  }
  if (d_obj)
    d_obj->mark_pos_change();

  changed= false;
}