source/designer/manipulator.cpp

   1 /* $Id$
   2
   3 This file is part of the MSP Märklin suite
   4 Copyright © 2006-2008 Mikkosoft Productions, Mikko Rasa
   5 Distributed under the GPL
   6 */
   7
   8 #include <algorithm>
   9 #include <cmath>
  10 #include <GL/gl.h>
  11 #include "3d/layout.h"
  12 #include "libmarklin/tracktype.h"
  13 #include "designer.h"
  14 #include "manipulator.h"
  15 #include "selection.h"
  16
  17 using namespace std;
  18 using namespace Marklin;
  19 using namespace Msp;
  20
  21 #include <iostream>
  22
  23 Manipulator::Manipulator(Designer &d):
  24         designer(d),
  25         selection(0),
  26         wrap_rot(0),
  27         mode(NONE),
  28         angle(0)
  29 { }
  30
  31 void Manipulator::set_selection(Selection *s)
  32 {
  33         selection_changed_conn.disconnect();
  34
  35         selection=s;
  36         if(selection)
  37                 selection_changed_conn=selection->signal_changed.connect(sigc::mem_fun(this, &Manipulator::selection_changed));
  38
  39         selection_changed();
  40 }
  41
  42 void Manipulator::start_move()
  43 {
  44         if(mode)
  45                 cancel();
  46
  47         move_origin=gpointer;
  48
  49         mode=MOVE;
  50 }
  51
  52 void Manipulator::start_rotate()
  53 {
  54         if(mode)
  55                 cancel();
  56
  57         rot_origin=atan2(gpointer.y-center.y, gpointer.x-center.x);
  58
  59         mode=ROTATE;
  60 }
  61
  62 void Manipulator::start_elevate()
  63 {
  64         if(mode)
  65                 cancel();
  66
  67         elev_origin=pointer_y;
  68
  69         mode=ELEVATE;
  70 }
  71
  72 void Manipulator::duplicate()
  73 {
  74         if(mode)
  75                 cancel();
  76
  77         list<Track *> new_tracks;
  78         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
  79         {
  80                 Track *track=i->track->copy();
  81                 designer.get_layout()->add_track(*track);
  82                 new_tracks.push_back(track);
  83         }
  84
  85         selection->clear();
  86         for(list<Track *>::iterator i=new_tracks.begin(); i!=new_tracks.end(); ++i)
  87         {
  88                 selection->add_track(*i);
  89                 for(list<Track *>::iterator j=i; j!=new_tracks.end(); ++j)
  90                         if(j!=i)
  91                                 (*i)->snap_to(**j, true);
  92         }
  93 }
  94
  95 void Manipulator::flatten()
  96 {
  97         if(mode)
  98                 cancel();
  99
 100         if(tracks.empty()) return;
 101
 102         float z=0;
 103         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 104                 z+=i->track->get_position().z+i->track->get_slope()/2;
 105         z/=tracks.size();
 106
 107         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 108         {
 109                 Point p=i->track->get_position();
 110                 i->track->set_position(Point(p.x, p.y, z));
 111                 i->track->set_slope(0);
 112         }
 113
 114         for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 115                 (*i)->check_slope();
 116
 117         update_wrap();
 118 }
 119
 120 void Manipulator::even_slope(bool smooth)
 121 {
 122         if(mode)
 123                 cancel();
 124
 125         if(neighbors.size()!=2)
 126                 return;
 127
 128         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 129                 if(i->track->get_type().get_endpoints().size()!=2)
 130                         return;
 131
 132         list<Track *> tracks2;
 133         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 134                 tracks2.push_back(i->track);
 135
 136         float total_len=0;
 137
 138         list<TrackOrder> order;
 139         Track *cur=*neighbors.begin();
 140         while(tracks2.size())
 141         {
 142                 bool rev=false;
 143                 for(list<Track *>::iterator i=tracks2.begin(); i!=tracks2.end(); ++i)
 144                 {
 145                         const vector<Track *> &links=(*i)->get_links();
 146                         if(links[0]==cur)
 147                         {
 148                                 cur=*i;
 149                                 tracks2.erase(i);
 150                                 break;
 151                         }
 152                         else if(links[1]==cur)
 153                         {
 154                                 cur=*i;
 155                                 rev=true;
 156                                 tracks2.erase(i);
 157                                 break;
 158                         }
 159                 }
 160                 order.push_back(TrackOrder(cur, rev));
 161                 total_len+=cur->get_type().get_total_length();
 162         }
 163
 164         set<Track *>::iterator nb=neighbors.begin();
 165         int epi=(*nb)->get_endpoint_by_link(*order.front().track);
 166         float start_z=(*nb)->get_endpoint_position(epi).z;
 167         ++nb;
 168         epi=(*nb)->get_endpoint_by_link(*order.back().track);
 169         float end_z=(*nb)->get_endpoint_position(epi).z;
 170
 171         if(smooth)
 172         {
 173                 float dir=(end_z>start_z)?1:-1;
 174                 float cur_slope=0;
 175                 while((end_z-start_z)*dir/total_len>cur_slope+0.025 && order.size()>2)
 176                 {
 177                         cur_slope+=0.025;
 178
 179                         float dz=order.front().track->get_type().get_total_length()*dir*cur_slope;
 180                         set_slope(order.front(), start_z, dz);
 181                         start_z+=dz;
 182                         total_len-=order.front().track->get_type().get_total_length();
 183                         order.erase(order.begin());
 184
 185                         dz=order.back().track->get_type().get_total_length()*dir*cur_slope;
 186                         set_slope(order.back(), end_z-dz, dz);
 187                         end_z-=dz;
 188                         total_len-=order.back().track->get_type().get_total_length();
 189                         order.erase(--order.end());
 190                 }
 191         }
 192
 193         float cur_z=start_z;
 194         for(list<TrackOrder>::iterator i=order.begin(); i!=order.end(); ++i)
 195         {
 196                 float dz=i->track->get_type().get_total_length()*(end_z-start_z)/total_len;
 197                 set_slope(*i, cur_z, dz);
 198                 cur_z+=dz;
 199         }
 200
 201         for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 202                 (*i)->check_slope();
 203
 204         update_wrap();
 205 }
 206
 207 void Manipulator::cancel()
 208 {
 209         if(!mode)
 210                 return;
 211         mode=NONE;
 212
 213         wrap_pos=center;
 214         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 215         {
 216                 i->track->set_position(Point(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z));
 217                 i->track->set_rotation(i->rot);
 218         }
 219
 220         for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 221                 (*i)->check_slope();
 222
 223         angle=0;
 224         //snapped=0;
 225
 226         signal_done.emit(false);
 227 }
 228
 229 void Manipulator::button_press(int, int, float, float, unsigned btn)
 230 {
 231         if(btn==3)
 232                 cancel();
 233         else if(mode)
 234         {
 235                 mode=NONE;
 236                 update_wrap();
 237                 //snapped=0;
 238
 239                 for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 240                         for(vector<MTrack>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
 241                                 j->track->break_link(**i);
 242
 243                 const set<Track *> &ltracks=designer.get_layout()->get_tracks();
 244                 for(set<Track *>::const_iterator i=ltracks.begin(); i!=ltracks.end(); ++i)
 245                 {
 246                         bool ok=true;
 247                         for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
 248                                 ok=(j->track!=*i);
 249                         if(!ok) continue;
 250
 251                         for(vector<MTrack>::iterator j=tracks.begin(); j!=tracks.end(); ++j)
 252                                 j->track->snap_to(**i, true);
 253                 }
 254
 255                 update_neighbors();
 256
 257                 signal_done.emit(true);
 258         }
 259 }
 260
 261 void Manipulator::pointer_motion(int, int y, float gx, float gy)
 262 {
 263         pointer_y=y;
 264         gpointer=Point(gx, gy, 0);
 265
 266         if(mode==MOVE)
 267         {
 268                 Point delta(gpointer.x-move_origin.x, gpointer.y-move_origin.y, 0);
 269
 270                 wrap_pos=Point(center.x+delta.x, center.y+delta.y, center.z);
 271                 for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 272                 {
 273                         i->track->set_position(Point(wrap_pos.x+i->pos.x, wrap_pos.y+i->pos.y, wrap_pos.z+i->pos.z));
 274                         i->track->set_rotation(i->rot);
 275                 }
 276
 277                 const set<Track *> &ltracks=designer.get_layout()->get_tracks();
 278                 MTrack *snapped=0;
 279                 for(set<Track *>::const_iterator i=ltracks.begin(); (i!=ltracks.end() && !snapped); ++i)
 280                 {
 281                         bool ok=true;
 282                         for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && ok); ++j)
 283                                 ok=(j->track!=*i);
 284                         if(!ok) continue;
 285
 286                         for(vector<MTrack>::iterator j=tracks.begin(); (j!=tracks.end() && !snapped); ++j)
 287                                 if(j->track->snap_to(**i, false))
 288                                         snapped=&*j;
 289                 }
 290
 291                 if(snapped)
 292                 {
 293                         float da=snapped->track->get_rotation()-snapped->rot;
 294                         float c=cos(da);
 295                         float s=sin(da);
 296                         const Point &sp=snapped->track->get_position();
 297                         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 298                         {
 299                                 if(&*i==snapped)
 300                                         continue;
 301
 302                                 Point dp(i->pos.x-snapped->pos.x, i->pos.y-snapped->pos.y, 0);
 303                                 i->track->set_position(Point(sp.x+c*dp.x-s*dp.y, sp.y+s*dp.x+c*dp.y, sp.z));
 304                                 i->track->set_rotation(i->rot+da);
 305                         }
 306                 }
 307         }
 308         else if(mode==ROTATE)
 309         {
 310                 float a=atan2(gpointer.y-center.y, gpointer.x-center.x);
 311                 angle+=a-rot_origin;
 312                 rot_origin=a;
 313
 314                 wrap_rot=angle;
 315                 for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 316                 {
 317                         float c=cos(angle);
 318                         float s=sin(angle);
 319                         i->track->set_position(Point(center.x+c*i->pos.x-s*i->pos.y, center.y+s*i->pos.x+c*i->pos.y, center.z*i->pos.z));
 320                         i->track->set_rotation(angle+i->rot);
 321                 }
 322         }
 323         else if(mode==ELEVATE)
 324         {
 325                 float dz=(y-elev_origin)/1000.;
 326
 327                 ostringstream ss;
 328                 ss.precision(3);
 329                 ss<<"Elevation: "<<dz*1000<<"mm ("<<(center.z+dz)*1000<<"mm)";
 330                 signal_status.emit(ss.str());
 331
 332                 wrap_pos.z=center.z+dz;
 333                 for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 334                         i->track->set_position(Point(center.x+i->pos.x, center.y+i->pos.y, center.z+i->pos.z+dz));
 335
 336                 for(set<Track *>::iterator i=neighbors.begin(); i!=neighbors.end(); ++i)
 337                         (*i)->check_slope();
 338         }
 339 }
 340
 341 void Manipulator::render()
 342 {
 343         glPushMatrix();
 344         glTranslatef(wrap_pos.x, wrap_pos.y, wrap_pos.z);
 345         glRotatef(wrap_rot*180/M_PI, 0, 0, 1);
 346
 347         glLineWidth(2);
 348         glColor4f(0, 1, 0, 0.5);
 349         for(list<TrackWrap>::iterator i=wrap.begin(); i!=wrap.end(); ++i)
 350         {
 351                 glPushMatrix();
 352                 glTranslatef(i->pos.x, i->pos.y, i->pos.z);
 353                 glRotatef(i->rot*180/M_PI, 0, 0, 1);
 354
 355                 glBegin(GL_LINE_LOOP);
 356                 glVertex2f(-i->width/2, -i->height/2);
 357                 glVertex2f(i->width/2, -i->height/2);
 358                 glVertex2f(i->width/2, i->height/2);
 359                 glVertex2f(-i->width/2, i->height/2);
 360                 glEnd();
 361
 362                 glPopMatrix();
 363         }
 364
 365         glPopMatrix();
 366 }
 367
 368 /*** private ***/
 369
 370 void Manipulator::selection_changed()
 371 {
 372         if(mode)
 373                 cancel();
 374
 375         tracks.clear();
 376         if(selection)
 377         {
 378                 const set<Track *> &stracks=selection->get_tracks();
 379                 tracks.insert(tracks.end(), stracks.begin(), stracks.end());
 380         }
 381
 382         update_neighbors();
 383         update_wrap();
 384 }
 385
 386 void Manipulator::update_wrap()
 387 {
 388         wrap.clear();
 389         float min_x=0, max_x=0;
 390         float min_y=0, max_y=0;
 391         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 392         {
 393                 Track3D &t3d=designer.get_layout_3d()->get_track(*i->track);
 394
 395                 TrackWrap tw;
 396                 float min_area=100;
 397                 for(float a=0; a<M_PI; a+=0.01)
 398                 {
 399                         Point minp, maxp;
 400                         t3d.get_bounds(a, minp, maxp);
 401                         float area=(maxp.x-minp.x)*(maxp.y-minp.y);
 402                         if(area<min_area)
 403                         {
 404                                 float c=cos(a);
 405                                 float s=sin(a);
 406                                 float x=(minp.x+maxp.x)/2;
 407                                 float y=(minp.y+maxp.y)/2;
 408                                 tw.pos=Point(c*x-s*y, s*x+c*y, (minp.z+maxp.z)/2);
 409                                 tw.rot=a;
 410                                 tw.width=maxp.x-minp.x+0.01;
 411                                 tw.height=maxp.y-minp.y+0.01;
 412
 413                                 min_area=area;
 414                         }
 415                 }
 416
 417                 if(i==tracks.begin())
 418                 {
 419                         min_x=max_x=tw.pos.x;
 420                         min_y=max_y=tw.pos.y;
 421                 }
 422                 else
 423                 {
 424                         min_x=min(min_x, tw.pos.x);
 425                         max_x=max(max_x, tw.pos.x);
 426                         min_y=min(min_y, tw.pos.y);
 427                         max_y=max(max_y, tw.pos.y);
 428                 }
 429                 wrap.push_back(tw);
 430         }
 431
 432         center=Point((min_x+max_x)/2, (min_y+max_y)/2, 0);
 433         wrap_pos=center;
 434         wrap_rot=0;
 435         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 436         {
 437                 const Point &tp=i->track->get_position();
 438                 i->pos=Point(tp.x-center.x, tp.y-center.y, tp.z);
 439         }
 440         for(list<TrackWrap>::iterator i=wrap.begin(); i!=wrap.end(); ++i)
 441         {
 442                 i->pos.x-=center.x;
 443                 i->pos.y-=center.y;
 444         }
 445 }
 446
 447 void Manipulator::update_neighbors()
 448 {
 449         neighbors.clear();
 450         for(vector<MTrack>::iterator i=tracks.begin(); i!=tracks.end(); ++i)
 451         {
 452                 const vector<Track *> &links=i->track->get_links();
 453                 for(vector<Track *>::const_iterator j=links.begin(); j!=links.end(); ++j)
 454                 {
 455                         if(!*j)
 456                                 continue;
 457                         if(neighbors.count(*j))
 458                                 continue;
 459
 460                         bool ok=true;
 461                         for(vector<MTrack>::iterator k=tracks.begin(); (k!=tracks.end() && ok); ++k)
 462                                 ok=(k->track!=*j);
 463
 464                         if(ok)
 465                                 neighbors.insert(*j);
 466                 }
 467         }
 468 }
 469
 470 void Manipulator::set_slope(TrackOrder &track, float z, float dz)
 471 {
 472         const Point &p=track.track->get_position();
 473         if(track.rev)
 474         {
 475                 track.track->set_position(Point(p.x, p.y, z+dz));
 476                 track.track->set_slope(-dz);
 477         }
 478         else
 479         {
 480                 track.track->set_position(Point(p.x, p.y, z));
 481                 track.track->set_slope(dz);
 482         }
 483 }
 484
 485 Manipulator::MTrack::MTrack(Track *t):
 486         track(t),
 487         pos(track->get_position()),
 488         rot(track->get_rotation())
 489 { }