source/designer/extendtool.cpp

   1 #include <msp/strings/format.h>
   2 #include "libr2c2/articlenumber.h"
   3 #include "designer.h"
   4 #include "extendtool.h"
   5
   6 using namespace std;
   7 using namespace Msp;
   8 using namespace R2C2;
   9
  10 ExtendTool::ExtendTool(Designer &d, Input::Keyboard &k, Input::Mouse &m, const set<Object *> &objects):
  11         Tool(d, k, m)
  12 {
  13         for(set<Object *>::const_iterator i=objects.begin(); i!=objects.end(); ++i)
  14                 if(Track *t = dynamic_cast<Track *>(*i))
  15                 {
  16                         unsigned nls = t->get_n_link_slots();
  17                         for(unsigned j=0; j<nls; ++j)
  18                                 if(!t->get_link(j))
  19                                         unlinked_endpoints.push_back(TrackIter(t, j));
  20                 }
  21
  22         if(unlinked_endpoints.empty())
  23         {
  24                 done = true;
  25                 set_status("No free endpoints");
  26         }
  27 }
  28
  29 ExtendTool::~ExtendTool()
  30 {
  31         if(!accepted)
  32         {
  33                 for(vector<R2C2::Track *>::iterator i=extend_tracks.begin(); i!=extend_tracks.end(); ++i)
  34                         delete *i;
  35         }
  36 }
  37
  38 void ExtendTool::connect()
  39 {
  40         float limit = designer.get_layout().get_catalogue().get_gauge()/10;
  41
  42         Track *start_track = 0;
  43         Track *end_track = 0;
  44         Snap start_sn;
  45         bool ok = false;
  46         float gap = 0;
  47         for(vector<TrackIter>::const_iterator i=unlinked_endpoints.begin(); i!=unlinked_endpoints.end(); ++i)
  48         {
  49                 start_sn = (*i)->get_snap_node(i->entry());
  50
  51                 for(vector<TrackIter>::const_iterator j=i; ++j!=unlinked_endpoints.end(); )
  52                 {
  53                         Snap end_sn = (*j)->get_snap_node(j->entry());
  54
  55                         float dz = end_sn.position.z-start_sn.position.z;
  56                         if(abs(dz)>0.02)
  57                                 continue;
  58
  59                         Angle adiff = wrap_balanced(start_sn.rotation+Angle::half_turn()-end_sn.rotation);
  60                         if(abs(adiff).radians()>0.01)
  61                                 continue;
  62
  63                         Vector delta = rotated_vector(end_sn.position-start_sn.position, -start_sn.rotation);
  64                         if(abs(delta.y)>limit)
  65                                 continue;
  66
  67                         gap = delta.x;
  68                         if(gap<0)
  69                                 continue;
  70
  71                         ok = true;
  72                 }
  73
  74                 if(ok)
  75                         break;
  76         }
  77
  78         if(!ok)
  79         {
  80                 set_status("No aligned endpoints found");
  81                 return;
  82         }
  83
  84         extend_tracks = create_straight(start_sn.position, start_sn.rotation, gap, limit);
  85
  86         if(extend_tracks.empty())
  87         {
  88                 set_status("No connection possible");
  89                 return;
  90         }
  91
  92         extend_tracks.front()->link_to(*start_track);
  93         extend_tracks.back()->link_to(*end_track);
  94
  95         set_done(true);
  96 }
  97
  98 void ExtendTool::pointer_motion()
  99 {
 100         Vector pos;
 101         Angle dir;
 102         float length = 0;
 103
 104         for(vector<TrackIter>::const_iterator i=unlinked_endpoints.begin(); i!=unlinked_endpoints.end(); ++i)
 105         {
 106                 Snap sn = (*i)->get_snap_node(i->entry());
 107                 Vector delta = rotated_vector(ground_pointer-sn.position, -sn.rotation);
 108
 109                 if(delta.x<length)
 110                         continue;
 111
 112                 pos = sn.position;
 113                 dir = sn.rotation;
 114                 length = delta.x;
 115         }
 116
 117         if(length)
 118         {
 119                 vector<Track *> trks = create_straight(pos, dir, length, max(length/500, 0.001f));
 120
 121                 if(!trks.empty())
 122                 {
 123                         for(vector<Track *>::iterator i=extend_tracks.begin(); i!=extend_tracks.end(); ++i)
 124                                 delete *i;
 125                         extend_tracks = trks;
 126
 127                         map<ArticleNumber, unsigned> counts;
 128                         length = 0;
 129                         for(vector<Track *>::iterator i=extend_tracks.begin(); i!=extend_tracks.end(); ++i)
 130                         {
 131                                 length += (*i)->get_type().get_total_length();
 132                                 ++counts[(*i)->get_type().get_article_number()];
 133                         }
 134
 135                         string detail;
 136                         for(map<ArticleNumber, unsigned>::const_iterator i=counts.begin(); i!=counts.end(); ++i)
 137                         {
 138                                 if(!detail.empty())
 139                                         detail += ", ";
 140                                 detail += format("%dx %s", i->second, i->first);
 141                         }
 142
 143                         signal_status.emit(format("Extend: %.0fmm (%s)", length*1000, detail));
 144                 }
 145         }
 146 }
 147
 148 void ExtendTool::finish()
 149 {
 150         for(vector<TrackIter>::const_iterator i=unlinked_endpoints.begin(); i!=unlinked_endpoints.end(); ++i)
 151                 if(extend_tracks.front()->link_to(**i))
 152                         break;
 153 }
 154
 155 vector<Track *> ExtendTool::create_straight(const Vector &start, const Angle &dir, float length, float limit)
 156 {
 157         const Catalogue::ObjectMap &object_types = designer.get_catalogue().get_all();
 158         map<float, const TrackType *> types_by_length;
 159         unsigned preference = 0;
 160         for(Catalogue::ObjectMap::const_iterator i=object_types.begin(); i!=object_types.end(); ++i)
 161                 if(const TrackType *tt = dynamic_cast<const TrackType *>(i->second))
 162                 {
 163                         const vector<TrackPart> &parts = tt->get_parts();
 164                         if(parts.size()!=1)
 165                                 continue;
 166                         if(parts.front().is_curved() || parts.front().is_dead_end())
 167                                 continue;
 168
 169                         types_by_length[parts.front().get_length()] = tt;
 170                         preference = max(preference, tt->get_autofit_preference());
 171                 }
 172
 173         vector<float> lengths;
 174         float removed = 0;
 175         while(length>limit)
 176         {
 177                 bool found = false;
 178                 for(map<float, const TrackType *>::iterator i=types_by_length.end(); i!=types_by_length.begin(); )
 179                 {
 180                         --i;
 181                         if(i->second->get_autofit_preference()<preference)
 182                                 continue;
 183                         if((!removed || i->first<removed) && i->first<length+limit)
 184                         {
 185                                 unsigned n = static_cast<unsigned>((length+limit)/i->first);
 186                                 lengths.insert(lengths.end(), n, i->first);
 187                                 length -= n*i->first;
 188                                 found = true;
 189                                 break;
 190                         }
 191                 }
 192
 193                 if(found)
 194                         continue;
 195
 196                 if(lengths.empty())
 197                 {
 198                         if(preference>0)
 199                         {
 200                                 --preference;
 201                                 removed = 0;
 202                                 continue;
 203                         }
 204                         break;
 205                 }
 206
 207                 length += lengths.back();
 208                 removed = lengths.back();
 209                 lengths.pop_back();
 210         }
 211
 212         vector<Track *> trks;
 213
 214         if(!lengths.empty())
 215         {
 216                 Vector pos = start;
 217                 Transform trans = Transform::rotation(dir, Vector(0, 0, 1));
 218                 for(vector<float>::iterator i=lengths.begin(); i!=lengths.end(); ++i)
 219                 {
 220                         Track *track = new Track(designer.get_layout(), *get_item(types_by_length, *i));
 221                         track->set_position(pos);
 222                         track->set_rotation(dir);
 223
 224                         if(!trks.empty())
 225                                 track->link_to(*trks.back());
 226                         trks.push_back(track);
 227
 228                         pos += trans.transform(Vector(*i, 0, 0));
 229                 }
 230         }
 231
 232         return trks;
 233 }
 234
 235 void ExtendTool::update_selection(Selection &sel) const
 236 {
 237         if(accepted)
 238                 sel.replace(extend_tracks.begin(), extend_tracks.end());
 239 }