source/libmarklin/tracktype.cpp

   1 #include <cmath>
   2 #include "tracktype.h"
   3
   4 using namespace std;
   5
   6 namespace Marklin {
   7
   8 TrackType::TrackType(unsigned a):
   9         art_nr(a)
  10 { }
  11
  12 float TrackType::get_total_length() const
  13 {
  14         return get_route_length(-1);
  15 }
  16
  17 float TrackType::get_route_length(int r) const
  18 {
  19         float len=0;
  20         for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
  21                 if(r<0 || i->route==static_cast<unsigned>(r))
  22                 {
  23                         float l=i->length;
  24                         if(i->radius)
  25                                 l*=abs(i->radius);
  26                         len+=l;
  27                 }
  28         return len;
  29 }
  30
  31 unsigned TrackType::get_n_routes() const
  32 {
  33         unsigned n=1;
  34         for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
  35                 if(i->route>=n)
  36                         n=i->route+1;
  37         return n;
  38 }
  39
  40 void TrackType::collect_endpoints()
  41 {
  42         endpoints.clear();
  43
  44         for(vector<TrackPart>::iterator i=parts.begin(); i!=parts.end(); ++i)
  45                 i->collect_endpoints(endpoints);
  46
  47         for(vector<Endpoint>::iterator i=endpoints.begin(); i!=endpoints.end();)
  48         {
  49                 bool rm=false;
  50                 for(vector<Endpoint>::iterator j=i+1; j!=endpoints.end();)
  51                 {
  52                         float dx=i->x-j->x;
  53                         float dy=i->y-j->y;
  54                         if(dx*dx+dy*dy<0.0001)
  55                         {
  56                                 float da=i->dir-j->dir;
  57                                 if(da<-M_PI)
  58                                         da+=M_PI*2;
  59                                 if(da>M_PI)
  60                                         da-=M_PI*2;
  61                                 if(da<-3.1 || da>3.1)
  62                                         rm=true;
  63                                 i->routes|=j->routes;
  64                                 j=endpoints.erase(j);
  65                         }
  66                         else
  67                                 ++j;
  68                 }
  69
  70                 if(rm)
  71                         i=endpoints.erase(i);
  72                 else
  73                         ++i;
  74         }
  75 }
  76
  77
  78 TrackType::Loader::Loader(TrackType &t):
  79         ttype(t)
  80 {
  81         add("description", &TrackType::description);
  82         add("part",        &Loader::part);
  83 }
  84
  85 void TrackType::Loader::finish()
  86 {
  87         ttype.collect_endpoints();
  88 }
  89
  90 void TrackType::Loader::part()
  91 {
  92         TrackPart p;
  93         load_sub(p);
  94         ttype.parts.push_back(p);
  95 }
  96
  97 } // namespace Marklin