psychlops/extension/standard/figure/psychlops_figure_standard.cpp

   1 /*
   2  *  psychlops_figure_standard.cpp
   3  *  Psychlops Standard Library (Universal)
   4  *
   5  *  Last Modified 2005/10/05 by Kenchi HOSOKAWA
   6  *  (C) 2005 Kenchi HOSOKAWA, Kazushi MARUYA, Takao SATO
   7  */
   8
   9 #include "psychlops_figure_standard.h"
  10 #include <string.h>
  11
  12
  13 namespace Psychlops {
  14 namespace Figures {
  15
  16
  17
  18         ////////        Arrow   ////////
  19         Polygon Arrow::default_head;
  20
  21         void Arrow::createDefaultHead() {
  22                 default_head.append(Point(0,0));
  23                 default_head.append(Point( 5,20));
  24                 default_head.append(Point(-5,20));
  25         }
  26         void Arrow::setDefaultHead() {
  27                 if(default_head.empty()) createDefaultHead();
  28                 if(head==0) head = &default_head;
  29                 gr.append(head);
  30         }
  31
  32         Arrow::Arrow() : Line(), head(0) {
  33                 setDefaultHead();
  34         }
  35         Arrow::Arrow(const double x1, const double y1, const double x2, const double y2) : Line(x1, y1, x2, y2), head(0) {
  36                 setDefaultHead();
  37         }
  38         Arrow::Arrow(const Point &dbegin, const Point &dvec) : Line(dbegin, dvec), head(0) {
  39                 setDefaultHead();
  40         }
  41         Arrow& Arrow::set(const double x1, const double y1, const double x2, const double y2) {
  42                 Point b(x1, y1), e(x2, y2);
  43                 return set(b, e);
  44         }
  45         Arrow& Arrow::set(const Point &dbegin, const Point &dend) {
  46                 datum = dbegin, end = dend;
  47                 setDefaultHead();
  48                 return *this;
  49         }
  50
  51         Arrow& Arrow::draw(Drawable& target) {
  52                 Shape::draw_base(target);
  53                 return *this;
  54         }
  55         Arrow& Arrow::draw(const Color &col, Drawable& target) {
  56                 target.line(*this, col);
  57                 gr.centering(this->end);
  58                 Point vec = this->end-this->datum;
  59                 gr.rotation = 180-atan2(vec.x, vec.y)/2.0/PI*360;
  60                 head->fill = col;
  61                 head->stroke = Stroke::null_line;
  62                 target.figures(gr);
  63                 return *this;
  64         }
  65         Arrow& Arrow::draw(const Stroke &strk, Drawable& target) {
  66                 target.line(*this, strk);
  67                 gr.centering(this->end);
  68                 Point vec = this->end-this->datum;
  69                 gr.rotation = 180-atan2(vec.x, vec.y)/2.0/PI*360;
  70                 head->fill = strk.color;
  71                 head->stroke = Stroke::null_line;
  72                 target.figures(gr);
  73                 return *this;
  74         }
  75
  76
  77
  78         ////////        Cross   ////////
  79         Cross::Cross() { stroke = Stroke::hair_line; }
  80         Cross::Cross(const Rectangle& rect, Stroke dstrk) {
  81                 set(rect, dstrk);
  82         }
  83         Cross::Cross(double wid, double hei, Stroke dstrk) {
  84                 set(wid, hei, dstrk);
  85         }
  86         Cross::~Cross() {}
  87         Cross& Cross::set(const Rectangle& rect, Stroke dstrk) {
  88                 width = rect.getWidth();
  89                 height = rect.getHeight();
  90                 stroke = dstrk;
  91                 return *this;
  92         }
  93         Cross& Cross::set(double wid, double hei, Stroke dstrk) {
  94                 width = wid;
  95                 height = hei;
  96                 stroke = dstrk;
  97                 return *this;
  98         }
  99         Cross& Cross::centering() {
 100                 if(Drawable::prime!=0) {\r
 101                         centering(Drawable::prime->getCenter());\r
 102                 }
 103                 return *this;
 104         }
 105         Cross& Cross::centering(const Point &p) {
 106                 datum = p;
 107                 return *this;
 108         }
 109         Cross& Cross::draw(Drawable &target) {
 110                 draw(stroke, target);
 111                 return *this;
 112         }
 113         Cross& Cross::draw(const Color &col, Drawable &target) {
 114                 Line lx(datum.x - width/2, datum.y, datum.x + width/2, datum.y);
 115                 Line ly(datum.x, datum.y - height/2, datum.x, datum.y + height/2);
 116                 target.line(lx, col);
 117                 target.line(ly, col);
 118                 return *this;
 119         }
 120         Cross& Cross::draw(const Stroke &strk, Drawable &target) {
 121                 Line lx(datum.x - width/2, datum.y, datum.x + width/2, datum.y);
 122                 Line ly(datum.x, datum.y - height/2, datum.x, datum.y + height/2);
 123                 target.line(lx, strk);
 124                 target.line(ly, strk);
 125                 return *this;
 126         }
 127
 128
 129
 130
 131         Movie::Movie()
 132         {
 133                 current_frame_index = 0;
 134         }
 135         Movie::~Movie()
 136         {
 137                 clear();
 138         }
 139
 140         Movie & Movie::clear()
 141         {
 142                 for(int i=0; i<frames.size(); i++)
 143                 {
 144                         delete frames[i];
 145                 }
 146                 return *this;
 147         }
 148         Movie & Movie::reserveFrames(int frame_num)
 149         {
 150                 clear();
 151                 frames.resize(frame_num);
 152                 for(int i=0; i<frames.size(); i++)
 153                 {
 154                         frames[i] = new Image();
 155                 }
 156                 return *this;
 157         }
 158         Movie & Movie::set(Image* input_frames, int frame_num)
 159         {
 160                 reserveFrames(frame_num);
 161                 for(int i=0; i<frame_num; i++)
 162                 {
 163                         frames[i]->from(input_frames[i]);
 164                 }
 165                 return *this;
 166         }
 167
 168         Image& Movie::operator[](int frame_num)
 169         {
 170                 return *frames[frame_num];
 171         }
 172         int Movie::getCurrentIndex()
 173         {
 174                 return current_frame_index;
 175         }
 176         int Movie::setCurrentIndex(int new_current)
 177         {
 178                 return current_frame_index = new_current;
 179         }
 180
 181 \r
 182         Movie& Movie::nextFrame()\r
 183         {\r
 184                 if(current_frame_index<frames.size())\r
 185                 {\r
 186                         current_frame_index++;\r
 187                 }
 188                 return *this;\r
 189         }
 190         Movie& Movie::draw(Drawable& target)
 191         {
 192                 current_frame_index %= frames.size();
 193                 //frame[current_frame_index]->move_to(this->getDatum().x, this->getDatum().y);
 194                 frames[current_frame_index]->draw(target);
 195                 current_frame_index++;
 196                 return *this;
 197         }
 198
 199         Movie& Movie::captureOnce()
 200         {
 201                 captureOnce(source_area);
 202                 return *this;
 203         }
 204         Movie& Movie::captureOnce(const Rectangle &source_area_)
 205         {
 206                 Image *img = new Image();
 207                 frames.push_back(img);
 208                 if(Drawable::prime_is_a_canvas())\r
 209                 {\r
 210                         Canvas *a = dynamic_cast<Canvas *>(Drawable::prime);\r
 211                         a->to(*img, source_area_);\r
 212                 }
 213                 return *this;
 214         }
 215         Movie& Movie::captureOnce(int target_frame)
 216         {
 217                 captureOnce(source_area, target_frame);
 218                 return *this;
 219         }
 220         Movie& Movie::captureOnce(const Rectangle &source_area_, int target_frame)
 221         {
 222                 if(Drawable::prime_is_a_canvas())
 223                 {
 224                         dynamic_cast<Canvas *>(Drawable::prime)->to(*(frames[target_frame]), source_area_);
 225                 }
 226                 return *this;
 227         }
 228         Movie& Movie::saveEachFrames(const std::string filePrefix)
 229         {
 230                 char buf[256];
 231                 for(int i=0; i<frames.size(); i++) {
 232                         memset(buf, 0, 256);
 233                         sprintf(buf, "%u", i);
 234                         frames[i]->save(filePrefix+"_"+buf+".png");
 235                 }
 236                 //clear();
 237                 return *this;
 238         }
 239
 240 }
 241 }       /*      <- namespace Psycholops         */
 242
 243