using namespace std;
using namespace Msp;
-#include <iostream>
-
namespace Marklin {
Track::Track(const TrackType &t):
void Track::set_position(const Point &p)
{
- pos=p;
+ pos = p;
}
void Track::set_rotation(float r)
{
- rot=r;
+ rot = r;
while(rot<0)
- rot+=M_PI*2;
+ rot += M_PI*2;
while(rot>M_PI*2)
- rot-=M_PI*2;
+ rot -= M_PI*2;
}
void Track::set_slope(float s)
{
if(links.size()!=2) return;
- slope=s;
+ slope = s;
}
void Track::set_flex(bool f)
{
- flex=f;
+ flex = f;
+}
+
+void Track::check_slope()
+{
+ if(links.size()!=2)
+ return;
+
+ if(links[0] && links[1])
+ {
+ Point epp0 = links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
+ Point epp1 = links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
+ pos.z = epp0.z;
+ slope = epp1.z-pos.z;
+ }
+ else
+ {
+ slope = 0;
+ if(links[0])
+ {
+ Point epp = links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
+ pos.z = epp.z;
+ }
+ else if(links[1])
+ {
+ Point epp = links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
+ pos.z = epp.z;
+ }
+ }
}
void Track::set_turnout_id(unsigned i)
{
- turnout_id=i;
+ turnout_id = i;
}
void Track::set_sensor_id(unsigned i)
{
- sensor_id=i;
+ sensor_id = i;
}
int Track::get_endpoint_by_link(const Track &other) const
Point Track::get_endpoint_position(unsigned epi) const
{
- const vector<Endpoint> &eps=type.get_endpoints();
+ const vector<Endpoint> &eps = type.get_endpoints();
if(epi>=eps.size())
throw InvalidParameterValue("Endpoint index out of range");
- const Endpoint &ep=eps[epi];
+ const Endpoint &ep = eps[epi];
- float c=cos(rot);
- float s=sin(rot);
+ float c = cos(rot);
+ float s = sin(rot);
Point p(pos.x+c*ep.pos.x-s*ep.pos.y, pos.y+s*ep.pos.x+c*ep.pos.y, pos.z);
if(eps.size()==2 && epi==1)
- p.z+=slope;
+ p.z += slope;
return p;
}
float Track::get_endpoint_direction(unsigned epi) const
{
- const vector<Endpoint> &eps=type.get_endpoints();
+ const vector<Endpoint> &eps = type.get_endpoints();
if(epi>=eps.size())
throw InvalidParameterValue("Endpoint index out of range");
- const Endpoint &ep=eps[epi];
+ const Endpoint &ep = eps[epi];
return rot+ep.dir;
}
bool Track::snap_to(Track &other, bool link)
{
- float limit=(link && !flex) ? 1e-6 : 1e-4;
- const vector<Endpoint> &eps=type.get_endpoints();
- const vector<Endpoint> &other_eps=other.get_type().get_endpoints();
+ float limit = (link && !flex) ? 1e-6 : 1e-4;
+ const vector<Endpoint> &eps = type.get_endpoints();
+ const vector<Endpoint> &other_eps = other.get_type().get_endpoints();
for(unsigned i=0; i<eps.size(); ++i)
{
- Point epp=get_endpoint_position(i);
+ Point epp = get_endpoint_position(i);
for(unsigned j=0; j<other_eps.size(); ++j)
{
if(other.get_link(j))
continue;
- Point epp2=other.get_endpoint_position(j);
- float dx=epp2.x-epp.x;
- float dy=epp2.y-epp.y;
+ Point epp2 = other.get_endpoint_position(j);
+ float dx = epp2.x-epp.x;
+ float dy = epp2.y-epp.y;
if(dx*dx+dy*dy<limit)
{
set_rotation(other.rot+other_eps[j].dir-eps[i].dir+M_PI);
- set_position(Point(epp2.x-(eps[i].pos.x*cos(rot)-eps[i].pos.y*sin(rot)), epp2.y-(eps[i].pos.y*cos(rot)+eps[i].pos.x*sin(rot)), epp2.z));
+ Point p(epp2.x-(eps[i].pos.x*cos(rot)-eps[i].pos.y*sin(rot)),
+ epp2.y-(eps[i].pos.y*cos(rot)+eps[i].pos.x*sin(rot)),
+ epp2.z);
+ if(eps.size()==2 && i==1)
+ p.z -= slope;
+ set_position(p);
if(link)
{
if(links[i])
break_link(*links[i]);
- links[i]=&other;
- other.links[j]=this;
+ links[i] = &other;
+ other.links[j] = this;
}
return true;
bool Track::snap(Point &pt, float &d) const
{
- const vector<Endpoint> &eps=type.get_endpoints();
+ const vector<Endpoint> &eps = type.get_endpoints();
for(unsigned i=0; i<eps.size(); ++i)
{
- Point epp=get_endpoint_position(i);
- float dx=pt.x-epp.x;
- float dy=pt.y-epp.y;
+ Point epp = get_endpoint_position(i);
+ float dx = pt.x-epp.x;
+ float dy = pt.y-epp.y;
if(dx*dx+dy*dy<1e-4)
{
- pt=epp;
- d=rot+eps[i].dir;
+ pt = epp;
+ d = rot+eps[i].dir;
return true;
}
}
for(vector<Track *>::iterator i=links.begin(); i!=links.end(); ++i)
if(*i==&trk)
{
- *i=0;
+ *i = 0;
trk.break_link(*this);
return;
}
for(vector<Track *>::iterator i=links.begin(); i!=links.end(); ++i)
if(Track *trk=*i)
{
- *i=0;
+ *i = 0;
trk->break_link(*this);
}
}
return links[i];
}
-void Track::check_slope()
+int Track::traverse(unsigned i, unsigned path) const
{
- if(links.size()!=2)
- return;
-
- if(links[0] && links[1])
- {
- Point epp0=links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
- Point epp1=links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
- pos.z=epp0.z;
- slope=epp1.z-pos.z;
- }
- else
- {
- slope=0;
- if(links[0])
- {
- Point epp=links[0]->get_endpoint_position(links[0]->get_endpoint_by_link(*this));
- pos.z=epp.z;
- }
- else if(links[1])
- {
- Point epp=links[1]->get_endpoint_position(links[1]->get_endpoint_by_link(*this));
- pos.z=epp.z;
- }
- }
-}
-
-int Track::traverse(unsigned i, unsigned route) const
-{
- const vector<Endpoint> &eps=type.get_endpoints();
+ const vector<Endpoint> &eps = type.get_endpoints();
if(i>=eps.size())
throw InvalidParameterValue("Endpoint index out of range");
- const Endpoint &ep=eps[i];
+ const Endpoint &ep = eps[i];
- if(ep.routes&(1<<route))
+ if(ep.paths&(1<<path))
{
- // Find the other endpoint for this route
+ // Find the other endpoint for this path
for(unsigned j=0; j<eps.size(); ++j)
- if((eps[j].routes&(1<<route)) && j!=i)
+ if((eps[j].paths&(1<<path)) && j!=i)
return j;
}
else
{
- // Find an endpoint that's connected to this one and has the requested route
+ // Find an endpoint that's connected to this one and has the requested path
for(unsigned j=0; j<eps.size(); ++j)
- if((eps[j].routes&(1<<route)) && (eps[j].routes&ep.routes))
+ if((eps[j].paths&(1<<path)) && (eps[j].paths&ep.paths))
return j;
}
return -1;
}
-Point Track::get_point(unsigned epi, unsigned route, float d) const
+Point Track::get_point(unsigned epi, unsigned path, float d) const
{
- const vector<Endpoint> &eps=type.get_endpoints();
+ const vector<Endpoint> &eps = type.get_endpoints();
if(epi>=eps.size())
throw InvalidParameterValue("Endpoint index out of range");
- float x=eps[epi].pos.x;
- float y=eps[epi].pos.y;
+ float x = eps[epi].pos.x;
+ float y = eps[epi].pos.y;
- const vector<TrackPart> &parts=type.get_parts();
- const TrackPart *last_part=0;
+ const vector<TrackPart> &parts = type.get_parts();
+ const TrackPart *last_part = 0;
while(1)
{
for(vector<TrackPart>::const_iterator i=parts.begin(); i!=parts.end(); ++i)
{
- if((eps[epi].routes&(1<<route)) && i->route!=route)
+ if((eps[epi].paths&(1<<path)) && i->path!=path)
continue;
if(&*i==last_part)
continue;
i->collect_endpoints(part_eps);
for(unsigned j=0; j<part_eps.size(); ++j)
{
- float dx=part_eps[j].pos.x-x;
- float dy=part_eps[j].pos.y-y;
+ float dx = part_eps[j].pos.x-x;
+ float dy = part_eps[j].pos.y-y;
if(dx*dx+dy*dy<1e-6)
{
- float plen=i->length;
+ float plen = i->length;
if(i->radius)
- plen*=abs(i->radius);
+ plen *= abs(i->radius);
if(d<plen)
{
if(j==1)
- d=plen-d;
- Point p=i->get_point(d);
- float c=cos(rot);
- float s=sin(rot);
+ d = plen-d;
+ Point p = i->get_point(d);
+ float c = cos(rot);
+ float s = sin(rot);
return Point(pos.x+c*p.x-s*p.y, pos.y+c*p.y+s*p.x);
}
else if(part_eps.size()>1)
{
- d-=plen;
- x=part_eps[1-j].pos.x;
- y=part_eps[1-j].pos.y;
- last_part=&*i;
- i=parts.begin();
+ d -= plen;
+ x = part_eps[1-j].pos.x;
+ y = part_eps[1-j].pos.y;
+ last_part = &*i;
+ i = parts.begin();
break;
}
else
Track *Track::copy() const
{
- Track *trk=new Track(type);
+ Track *trk = new Track(type);
trk->set_position(pos);
trk->set_rotation(rot);
trk->set_slope(slope);
return trk;
}
-/*******************
-** Track::Loader
-*/
+void Track::save(list<DataFile::Statement> &st) const
+{
+ st.push_back((DataFile::Statement("position"), pos.x, pos.y, pos.z));
+ st.push_back((DataFile::Statement("rotation"), rot));
+ st.push_back((DataFile::Statement("slope"), slope));
+ if(turnout_id)
+ st.push_back((DataFile::Statement("turnout_id"), turnout_id));
+ if(sensor_id)
+ st.push_back((DataFile::Statement("sensor_id"), sensor_id));
+ if(flex)
+ st.push_back((DataFile::Statement("flex"), true));
+}
+
Track::Loader::Loader(Track &t):
- track(t)
+ DataFile::BasicLoader<Track>(t)
{
- add("position", &Loader::position);
- add("rotation", &Track::rot);
- add("slope", &Track::slope);
- add("turnout_id", &Track::turnout_id);
- add("sensor_id", &Track::sensor_id);
- add("flex", &Track::flex);
+ add("position", &Loader::position);
+ add("rotation", &Track::rot);
+ add("slope", &Track::slope);
+ add("turnout_id", &Track::turnout_id);
+ add("sensor_id", &Track::sensor_id);
+ add("flex", &Track::flex);
}
void Track::Loader::position(float x, float y, float z)
{
- track.pos=Point(x, y, z);
+ obj.pos = Point(x, y, z);
}
} // namespace Marklin