view/rangesCtrl/RangesDrawSurface.cpp

/*!
  \file
  \brief レンジセンサデータの描画コンポーネント

  \author Satofumi KAMIMURA

  $Id$

  \todo 描画オフセットの角度の対応がおかしくないか、を確認する
  \todo 背景色は透明にする
  \todo いずれ、RangesDrawSurface.cpp にする
*/

#include "RangesDrawSurface.h"
#include "RangeSensorInterface.h"
#include "ConvertToGrid.h"
#include "DrawPanelSurface.h"
#include "Component.h"
#include "GuiColors.h"
#include "SdlUtils.h"

using namespace beego;
using namespace SDL;


struct RangesDrawSurface::pImpl {
  RangeSensorInterface& ranges;
  size_t width;
  size_t height;
  bool is_changed;
  std::vector<Grid<int> > points;
  size_t data_max;
  long* data_buffer;
  unsigned long pre_timestamp;
  boost::shared_ptr<DrawPanelSurface> draw_panel;
  Position<int> draw_offset;
  size_t pixels;

  pImpl(RangeSensorInterface& range_sensor, size_t w, size_t h)
    : ranges(range_sensor), width(w), height(h), is_changed(true),
      pre_timestamp(0), draw_panel(new DrawPanelSurface(width, height)),
      pixels(DefalutPixelMagnify) {

    data_max = ranges.getMaxDataLength();
    data_buffer = new long[data_max];

    draw_panel->setNoBackground();
  }

  ~pImpl(void) {
    delete [] data_buffer;
  }

  void drawCaptures(const SDL_Rect& position,
                    std::vector<Grid<int> >& points, unsigned long timestamp) {

    draw_panel->clear();
    int division = (pixels == 0) ? 1 : 1000 / static_cast<int>(pixels);
    for (std::vector<Grid<int> >::iterator it = points.begin();
         it != points.end(); ++it) {
      Grid<int> draw_position;
      set_Grid<int>(&draw_position,
                    position.x + width/2 + (it->x / division),
                    position.y + height/2 + (it->y / division));
      draw_panel->drawPoint(draw_position, White);
    }
  }
};


RangesDrawSurface::RangesDrawSurface(RangeSensorInterface& ranges,
                                     size_t width, size_t height)
  : pimpl(new pImpl(ranges, width, height)) {
}


RangesDrawSurface::~RangesDrawSurface(void) {
}


void RangesDrawSurface::draw(std::vector<SDL_Rect>& update_rects,
                             const SDL_Rect* pos, const SDL_Rect* area,
                             size_t ticks) {

  pimpl->drawCaptures(*pos, pimpl->points, pimpl->pre_timestamp);
  pimpl->draw_panel->draw(update_rects, pos, area);
}


size_t RangesDrawSurface::getWidth(void) {
  return pimpl->width;
}


size_t RangesDrawSurface::getHeight(void) {
  return pimpl->height;
}


void RangesDrawSurface::forceSetChanged(void) {
  pimpl->is_changed = true;
}

bool RangesDrawSurface::isChanged(void) {
  bool ret = pimpl->is_changed;
  pimpl->is_changed = false;
  return ret;
}


bool RangesDrawSurface::isTransparent(void) {

  // !!!
  // !!! 将来的には、透過にもなりうるはず
  return false;
}


void RangesDrawSurface::update(void) {

  // データ取得と描画の更新を行う
  int n = pimpl->ranges.capture(pimpl->data_buffer, pimpl->data_max);
  if (n <= 0) {
    return;
  }
  unsigned long timestamp = pimpl->ranges.getTimestamp();
  if (pimpl->pre_timestamp != timestamp) {
    pimpl->pre_timestamp = timestamp;

    // データを２次元展開して描画
    pimpl->points.clear();
    convertToGrid(pimpl->points, pimpl->data_buffer, n,
                  &pimpl->ranges, pimpl->draw_offset);

    pimpl->is_changed = true;
  }
}


void RangesDrawSurface::setDrawOffset(const Position<int>& offset) {
  pimpl->draw_offset = offset;
}


size_t RangesDrawSurface::setPixelMagnify(size_t pixels) {
  pimpl->pixels = pixels;
  return pimpl->pixels;
}