void ROUTER::markViolations( NODE* aNode, ITEM_SET& aCurrent,
NODE::ITEM_VECTOR& aRemoved )
{
for( ITEM* item : aCurrent.Items() )
{
NODE::OBSTACLES obstacles;
aNode->QueryColliding( item, obstacles, ITEM::ANY_T );
if( item->OfKind( ITEM::LINE_T ) )
{
LINE* l = static_cast<LINE*>( item );
if( l->EndsWithVia() )
{
VIA v( l->Via() );
aNode->QueryColliding( &v, obstacles, ITEM::ANY_T );
}
}
for( OBSTACLE& obs : obstacles )
{
int clearance = aNode->GetClearance( item, obs.m_item );
std::unique_ptr<ITEM> tmp( obs.m_item->Clone() );
tmp->Mark( MK_VIOLATION );
m_iface->DisplayItem( tmp.get(), -1, clearance );
aRemoved.push_back( obs.m_item );
}
}
}
POLYGON compute_poly(const LINE& l)
{
POLYGON sb;
int o1,o2,o3,o4;
list<POINT> poly;
POINT inter;
cout << "line:" << l << "\n";
o1=orientation(l,p_xmin_ymin);
if (o1!= -1) poly.push(p_xmin_ymin);
o2=orientation(l,p_xmin_ymax);
if (o1 != o2 && o1 != 0 && o2 != 0) {
//poly.push(point(min_dbl, l.y_proj(min_dbl)));
l.intersection(LG1,inter);
poly.push(inter);
}
if (o2 != -1) poly.push(p_xmin_ymax);
o3=orientation(l,p_xmax_ymax);
if (o2 != o3 && o2 != 0 && o3 != 0) {
//poly.push(point(l.x_proj(max_dbl),max_dbl));
l.intersection(LG2,inter);
poly.push(inter);
}
if (o3 != -1) poly.push(p_xmax_ymax);
o4=orientation(l,p_xmax_ymin);
if (o3 != o4 && o3 != 0 && o4 != 0) {
//poly.push(point(max_dbl,l.y_proj(max_dbl)));
l.intersection(LG3,inter);
poly.push(inter);
}
if (o4 != -1) poly.push(p_xmax_ymin);
if (o1 != o4 && o1 != 0 && o4 != 0) {
//poly.push(point(l.x_proj(min_dbl),min_dbl));
l.intersection(LG4,inter);
poly.push(inter);
}
cout << o1 << " " << o2 << " " << o3 << " " << o4 << "\n";
cout << "points:" << poly.size() << "\n";
cout.flush();
cout << "Poly" << poly << "\n";
cout.flush();
sb= POLYGON(poly);
cout << "gen_polygon constructed!\n";
cout.flush();
return sb;
}
void efodo(LINE & FODO)
{
double ang = 2*M_PI/12/2;
double quadK = 5.0;
double lBend = 0.4;
double lQuad = 0.1;
double lDrift_ = 0.2;
ELEMENT temp;
for(int i=0;i<12;i++){
temp.SetElem(DRIFT_,0.5*lDrift_);temp.Nint=30;
FODO.Append(temp);
temp.SetElem(eBEND_,lBend, ang);temp.Nint=120;
FODO.Append(temp);
temp.SetElem(DRIFT_,lDrift_);temp.Nint=60;
FODO.Append(temp);
temp.SetElem(eQUAD_,lQuad, quadK);temp.Nint=30;
FODO.Append(temp);
temp.SetElem(DRIFT_,lDrift_);temp.Nint=60;
FODO.Append(temp);
temp.SetElem(eBEND_,lBend, ang);temp.Nint=120;
FODO.Append(temp);
temp.SetElem(DRIFT_,lDrift_);temp.Nint=60;
FODO.Append(temp);
temp.SetElem(eQUAD_,lQuad, -quadK);temp.Nint=30;
FODO.Append(temp);
temp.SetElem(DRIFT_,0.5*lDrift_);temp.Nint=30;
FODO.Append(temp);
}
const double cSpeed=299792458;
const double revFreq = (BETA*cSpeed)/FODO.Length;
temp.SetElem(RFcav_,1000.0, 3.0*revFreq, 0.0);
FODO.Append(temp);
}
WALKAROUND::WALKAROUND_STATUS WALKAROUND::singleStep( LINE& aPath,
bool aWindingDirection )
{
optional<OBSTACLE>& current_obs =
aWindingDirection ? m_currentObstacle[0] : m_currentObstacle[1];
bool& prev_recursive = aWindingDirection ? m_recursiveCollision[0] : m_recursiveCollision[1];
if( !current_obs )
return DONE;
SHAPE_LINE_CHAIN path_pre[2], path_walk[2], path_post[2];
VECTOR2I last = aPath.CPoint( -1 );
if( ( current_obs->m_hull ).PointInside( last ) || ( current_obs->m_hull ).PointOnEdge( last ) )
{
m_recursiveBlockageCount++;
if( m_recursiveBlockageCount < 3 )
aPath.Line().Append( current_obs->m_hull.NearestPoint( last ) );
else
{
aPath = aPath.ClipToNearestObstacle( m_world );
return DONE;
}
}
aPath.Walkaround( current_obs->m_hull, path_pre[0], path_walk[0],
path_post[0], aWindingDirection );
aPath.Walkaround( current_obs->m_hull, path_pre[1], path_walk[1],
path_post[1], !aWindingDirection );
#ifdef DEBUG
m_logger.NewGroup( aWindingDirection ? "walk-cw" : "walk-ccw", m_iteration );
m_logger.Log( &path_walk[0], 0, "path-walk" );
m_logger.Log( &path_pre[0], 1, "path-pre" );
m_logger.Log( &path_post[0], 4, "path-post" );
m_logger.Log( ¤t_obs->m_hull, 2, "hull" );
m_logger.Log( current_obs->m_item, 3, "item" );
#endif
int len_pre = path_walk[0].Length();
int len_alt = path_walk[1].Length();
LINE walk_path( aPath, path_walk[1] );
bool alt_collides = static_cast<bool>( m_world->CheckColliding( &walk_path, m_itemMask ) );
SHAPE_LINE_CHAIN pnew;
if( !m_forceLongerPath && len_alt < len_pre && !alt_collides && !prev_recursive )
{
pnew = path_pre[1];
pnew.Append( path_walk[1] );
pnew.Append( path_post[1] );
if( !path_post[1].PointCount() || !path_walk[1].PointCount() )
current_obs = nearestObstacle( LINE( aPath, path_pre[1] ) );
else
current_obs = nearestObstacle( LINE( aPath, path_post[1] ) );
prev_recursive = false;
}
else
{
pnew = path_pre[0];
pnew.Append( path_walk[0] );
pnew.Append( path_post[0] );
if( !path_post[0].PointCount() || !path_walk[0].PointCount() )
current_obs = nearestObstacle( LINE( aPath, path_pre[0] ) );
else
current_obs = nearestObstacle( LINE( aPath, path_walk[0] ) );
if( !current_obs )
{
prev_recursive = false;
current_obs = nearestObstacle( LINE( aPath, path_post[0] ) );
}
else
prev_recursive = true;
}
pnew.Simplify();
aPath.SetShape( pnew );
return IN_PROGRESS;
}
WALKAROUND::WALKAROUND_STATUS WALKAROUND::Route( const LINE& aInitialPath,
LINE& aWalkPath, bool aOptimize )
{
LINE path_cw( aInitialPath ), path_ccw( aInitialPath );
WALKAROUND_STATUS s_cw = IN_PROGRESS, s_ccw = IN_PROGRESS;
SHAPE_LINE_CHAIN best_path;
// special case for via-in-the-middle-of-track placement
if( aInitialPath.PointCount() <= 1 )
{
if( aInitialPath.EndsWithVia() && m_world->CheckColliding( &aInitialPath.Via(), m_itemMask ) )
return STUCK;
aWalkPath = aInitialPath;
return DONE;
}
start( aInitialPath );
m_currentObstacle[0] = m_currentObstacle[1] = nearestObstacle( aInitialPath );
m_recursiveBlockageCount = 0;
aWalkPath = aInitialPath;
if( m_forceWinding )
{
s_cw = m_forceCw ? IN_PROGRESS : STUCK;
s_ccw = m_forceCw ? STUCK : IN_PROGRESS;
m_forceSingleDirection = true;
} else {
m_forceSingleDirection = false;
}
while( m_iteration < m_iterationLimit )
{
if( s_cw != STUCK )
s_cw = singleStep( path_cw, true );
if( s_ccw != STUCK )
s_ccw = singleStep( path_ccw, false );
if( ( s_cw == DONE && s_ccw == DONE ) || ( s_cw == STUCK && s_ccw == STUCK ) )
{
int len_cw = path_cw.CLine().Length();
int len_ccw = path_ccw.CLine().Length();
if( m_forceLongerPath )
aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
else
aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );
break;
}
else if( s_cw == DONE && !m_forceLongerPath )
{
aWalkPath = path_cw;
break;
}
else if( s_ccw == DONE && !m_forceLongerPath )
{
aWalkPath = path_ccw;
break;
}
m_iteration++;
}
if( m_iteration == m_iterationLimit )
{
int len_cw = path_cw.CLine().Length();
int len_ccw = path_ccw.CLine().Length();
if( m_forceLongerPath )
aWalkPath = ( len_cw > len_ccw ? path_cw : path_ccw );
else
aWalkPath = ( len_cw < len_ccw ? path_cw : path_ccw );
}
if( m_cursorApproachMode )
{
// int len_cw = path_cw.GetCLine().Length();
// int len_ccw = path_ccw.GetCLine().Length();
bool found = false;
SHAPE_LINE_CHAIN l = aWalkPath.CLine();
for( int i = 0; i < l.SegmentCount(); i++ )
{
const SEG s = l.Segment( i );
VECTOR2I nearest = s.NearestPoint( m_cursorPos );
VECTOR2I::extended_type dist_a = ( s.A - m_cursorPos ).SquaredEuclideanNorm();
VECTOR2I::extended_type dist_b = ( s.B - m_cursorPos ).SquaredEuclideanNorm();
VECTOR2I::extended_type dist_n = ( nearest - m_cursorPos ).SquaredEuclideanNorm();
if( dist_n <= dist_a && dist_n < dist_b )
{
l.Remove( i + 1, -1 );
l.Append( nearest );
l.Simplify();
found = true;
break;
}
}
if( found )
{
aWalkPath = aInitialPath;
aWalkPath.SetShape( l );
}
}
aWalkPath.Line().Simplify();
if( aWalkPath.SegmentCount() < 1 )
return STUCK;
if( aWalkPath.CPoint( -1 ) != aInitialPath.CPoint( -1 ) )
return STUCK;
if( aWalkPath.CPoint( 0 ) != aInitialPath.CPoint( 0 ) )
return STUCK;
WALKAROUND_STATUS st = s_ccw == DONE || s_cw == DONE ? DONE : STUCK;
if( st == DONE )
{
if( aOptimize )
OPTIMIZER::Optimize( &aWalkPath, OPTIMIZER::MERGE_OBTUSE, m_world );
}
return st;
}
OPT_BOX2I ChangedArea( const LINE& aLineA, const LINE& aLineB )
{
return aLineA.ChangedArea( &aLineB );
}
