kicad/pcbnew/autorouter/ar_autoplacer.cpp

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2012 Jean-Pierre Charras, jean-pierre.charras@ujf-grenoble.fr
 * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
 * Copyright (C) 2011 Wayne Stambaugh <stambaughw@verizon.net>
 *
 * Copyright (C) 1992-2012 KiCad Developers, see change_log.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */

#include <fctsys.h>
#include <class_drawpanel.h>
#include <confirm.h>
#include <pcbnew.h>
#include <pcb_edit_frame.h>
#include <gr_basic.h>
#include <macros.h>
#include <msgpanel.h>

#include <class_board.h>
#include <class_module.h>
#include <class_track.h>
#include <class_drawsegment.h>
#include <class_pad.h>

#include <board_commit.h>

#include <connectivity/connectivity_data.h>
#include <ratsnest_data.h>

#include <widgets/progress_reporter.h>

#include "ar_matrix.h"
#include "ar_cell.h"
#include "ar_autoplacer.h"

#define AR_GAIN            16
#define AR_KEEPOUT_MARGIN  500
#define AR_ABORT_PLACEMENT -1

/* Penalty (cost) for CntRot90 and CntRot180:
 * CntRot90 and CntRot180 are from 0 (rotation allowed) to 10 (rotation not allowed)
 */
static const double OrientationPenalty[11] =
{
    2.0,        // CntRot = 0 rotation prohibited
    1.9,        // CntRot = 1
    1.8,        // CntRot = 2
    1.7,        // CntRot = 3
    1.6,        // CntRot = 4
    1.5,        // CntRot = 5
    1.4,        // CntRot = 5
    1.3,        // CntRot = 7
    1.2,        // CntRot = 8
    1.1,        // CntRot = 9
    1.0         // CntRot = 10 rotation authorized, no penalty
};


AR_AUTOPLACER::AR_AUTOPLACER( BOARD* aBoard )
{
    m_board = aBoard;
    m_connectivity.reset( new CONNECTIVITY_DATA );

    for( auto mod : m_board->Modules() )
        m_connectivity->Add( mod );

    m_gridSize = Millimeter2iu( 0.5 );
    m_progressReporter = nullptr;
    m_refreshCallback = nullptr;
}


void AR_AUTOPLACER::placeModule( MODULE* aModule, bool aDoNotRecreateRatsnest, const wxPoint& aPos )
{
    if( !aModule )
        return;

    aModule->SetPosition( aPos );
    m_connectivity->Update( aModule );
}


int AR_AUTOPLACER::genPlacementRoutingMatrix()
{
    m_matrix.UnInitRoutingMatrix();

    EDA_RECT bbox = m_board->GetBoardEdgesBoundingBox();

    if( bbox.GetWidth() == 0 || bbox.GetHeight() == 0 )
    {
        //DisplayError( NULL, _( "No PCB edge found, unknown board size!" ) );
        // fixme: no wx here
        return 0;
    }

    m_matrix.ComputeMatrixSize( bbox );
    int nbCells = m_matrix.m_Ncols * m_matrix.m_Nrows;

    // Choose the number of board sides.
    m_matrix.m_RoutingLayersCount = 2;
    m_matrix.InitRoutingMatrix();

    m_matrix.m_routeLayerBottom = F_Cu;

    if( m_matrix.m_RoutingLayersCount > 1 )
        m_matrix.m_routeLayerBottom = B_Cu;

    m_matrix.m_routeLayerTop = F_Cu;

    // Place the edge layer segments
    TRACK tmp( NULL );

    tmp.SetLayer( UNDEFINED_LAYER );
    tmp.SetNetCode( -1 );
    tmp.SetWidth( m_matrix.m_GridRouting / 2 );

    for( auto drawing : m_board->Drawings() )
    {
        DRAWSEGMENT* DrawSegm;

        switch( drawing->Type() )
        {
        case PCB_LINE_T:
            DrawSegm = (DRAWSEGMENT*) drawing;

            if( DrawSegm->GetLayer() != Edge_Cuts )
                break;


            //printf("addSeg %p grid %d\n", DrawSegm,  m_matrix.m_GridRouting );
            m_matrix.TraceSegmentPcb( DrawSegm, CELL_IS_HOLE | CELL_IS_EDGE,
                             m_matrix.m_GridRouting, AR_MATRIX::WRITE_CELL );
            break;

        case PCB_TEXT_T:
        default:
            break;
        }
    }

    // Mark cells of the routing matrix to CELL_IS_ZONE
    // (i.e. availlable cell to place a module )
    // Init a starting point of attachment to the area.
    m_matrix.OrCell( m_matrix.m_Nrows / 2, m_matrix.m_Ncols / 2,
                          AR_SIDE_BOTTOM, CELL_IS_ZONE );

    // find and mark all other availlable cells:
    for( int ii = 1; ii != 0; )
        ii = propagate();

    // Initialize top layer. to the same value as the bottom layer
    if( m_matrix.m_BoardSide[AR_SIDE_TOP] )
        memcpy( m_matrix.m_BoardSide[AR_SIDE_TOP], m_matrix.m_BoardSide[AR_SIDE_BOTTOM],
                nbCells * sizeof(AR_MATRIX::MATRIX_CELL) );

    return 1;
}


void AR_AUTOPLACER::rotateModule( MODULE* module, double angle, bool incremental )
{
    if( module == NULL )
        return;

    if( incremental )
        module->SetOrientation( module->GetOrientation() + angle );
    else
        module->SetOrientation( angle );


    m_board->GetConnectivity()->Update( module );
}


/**
 * Function propagate
 * Used only in autoplace calculations
 * Uses the routing matrix to fill the cells within the zone
 * Search and mark cells within the zone, and agree with DRC options.
 * Requirements:
 * Start from an initial point, to fill zone
 * The zone must have no "copper island"
 *  Algorithm:
 *  If the current cell has a neighbor flagged as "cell in the zone", it
 *  become a cell in the zone
 *  The first point in the zone is the starting point
 *  4 searches within the matrix are made:
 *          1 - Left to right and top to bottom
 *          2 - Right to left and top to bottom
 *          3 - bottom to top and Right to left
 *          4 - bottom to top and Left to right
 *  Given the current cell, for each search, we consider the 2 neighbor cells
 *  the previous cell on the same line and the previous cell on the same column.
 *
 *  This function can request some iterations
 *  Iterations are made until no cell is added to the zone.
 *  @return added cells count (i.e. which the attribute CELL_IS_ZONE is set)
 */

int AR_AUTOPLACER::propagate()
{
    int     row, col;
    long    current_cell, old_cell_H;
    std::vector<int> pt_cell_V;
    int     nbpoints = 0;

    const uint32_t NO_CELL_ZONE = CELL_IS_HOLE | CELL_IS_EDGE | CELL_IS_ZONE;

    pt_cell_V.resize( std::max( m_matrix.m_Nrows, m_matrix.m_Ncols ), CELL_IS_EMPTY );

    // Search from left to right and top to bottom.
    for( row = 0; row < m_matrix.m_Nrows; row++ )
    {
        old_cell_H = 0;

        for( col = 0; col < m_matrix.m_Ncols; col++ )
        {
            current_cell = m_matrix.GetCell( row, col, AR_SIDE_BOTTOM ) & NO_CELL_ZONE;

            if( current_cell == 0 )    // a free cell is found
            {
                if( (old_cell_H & CELL_IS_ZONE) || (pt_cell_V[col] & CELL_IS_ZONE) )
                {
                    m_matrix.OrCell( row, col, AR_SIDE_BOTTOM, CELL_IS_ZONE );
                    current_cell = CELL_IS_ZONE;
                    nbpoints++;
                }
            }

            pt_cell_V[col] = old_cell_H = current_cell;
        }
    }

    // Search from right to left and top to bottom/
    fill( pt_cell_V.begin(), pt_cell_V.end(), CELL_IS_EMPTY );

    for( row = 0; row < m_matrix.m_Nrows; row++ )
    {
        old_cell_H = 0;

        for( col = m_matrix.m_Ncols - 1; col >= 0; col-- )
        {
            current_cell = m_matrix.GetCell( row, col, AR_SIDE_BOTTOM ) & NO_CELL_ZONE;

            if( current_cell == 0 )    // a free cell is found
            {
                if( (old_cell_H & CELL_IS_ZONE) || (pt_cell_V[col] & CELL_IS_ZONE) )
                {
                    m_matrix.OrCell( row, col, AR_SIDE_BOTTOM, CELL_IS_ZONE );
                    current_cell = CELL_IS_ZONE;
                    nbpoints++;
                }
            }

            pt_cell_V[col] = old_cell_H = current_cell;
        }
    }

    // Search from bottom to top and right to left.
    fill( pt_cell_V.begin(), pt_cell_V.end(), CELL_IS_EMPTY );

    for( col = m_matrix.m_Ncols - 1; col >= 0; col-- )
    {
        old_cell_H = 0;

        for( row = m_matrix.m_Nrows - 1; row >= 0; row-- )
        {
            current_cell = m_matrix.GetCell( row, col, AR_SIDE_BOTTOM ) & NO_CELL_ZONE;

            if( current_cell == 0 )    // a free cell is found
            {
                if( (old_cell_H & CELL_IS_ZONE) || (pt_cell_V[row] & CELL_IS_ZONE) )
                {
                    m_matrix.OrCell( row, col, AR_SIDE_BOTTOM, CELL_IS_ZONE );
                    current_cell = CELL_IS_ZONE;
                    nbpoints++;
                }
            }

            pt_cell_V[row] = old_cell_H = current_cell;
        }
    }

    // Search from bottom to top and left to right.
    fill( pt_cell_V.begin(), pt_cell_V.end(), CELL_IS_EMPTY );

    for( col = 0; col < m_matrix.m_Ncols; col++ )
    {
        old_cell_H = 0;

        for( row = m_matrix.m_Nrows - 1; row >= 0; row-- )
        {
            current_cell = m_matrix.GetCell( row, col, AR_SIDE_BOTTOM ) & NO_CELL_ZONE;

            if( current_cell == 0 )    // a free cell is found
            {
                if( (old_cell_H & CELL_IS_ZONE) || (pt_cell_V[row] & CELL_IS_ZONE) )
                {
                    m_matrix.OrCell( row, col, AR_SIDE_BOTTOM, CELL_IS_ZONE );
                    current_cell = CELL_IS_ZONE;
                    nbpoints++;
                }
            }

            pt_cell_V[row] = old_cell_H = current_cell;
        }
    }

    return nbpoints;
}


void AR_AUTOPLACER::genModuleOnRoutingMatrix( MODULE* Module )
{
    int         ox, oy, fx, fy;
    LSET        layerMask;
    EDA_RECT    fpBBox = Module->GetBoundingBox();

    fpBBox.Inflate( m_matrix.m_GridRouting / 2 );
    ox  = fpBBox.GetX();
    fx  = fpBBox.GetRight();
    oy  = fpBBox.GetY();
    fy  = fpBBox.GetBottom();

    if( ox < m_matrix.m_BrdBox.GetX() )
        ox = m_matrix.m_BrdBox.GetX();

    if( ox > m_matrix.m_BrdBox.GetRight() )
        ox = m_matrix.m_BrdBox.GetRight();

    if( fx < m_matrix.m_BrdBox.GetX() )
        fx = m_matrix.m_BrdBox.GetX();

    if( fx > m_matrix.m_BrdBox.GetRight() )
        fx = m_matrix.m_BrdBox.GetRight();

    if( oy < m_matrix.m_BrdBox.GetY() )
        oy = m_matrix.m_BrdBox.GetY();

    if( oy > m_matrix.m_BrdBox.GetBottom() )
        oy = m_matrix.m_BrdBox.GetBottom();

    if( fy < m_matrix.m_BrdBox.GetY() )
        fy = m_matrix.m_BrdBox.GetY();

    if( fy > m_matrix.m_BrdBox.GetBottom() )
        fy = m_matrix.m_BrdBox.GetBottom();

    if( Module->GetLayer() == F_Cu )
        layerMask.set( F_Cu );

    if( Module->GetLayer() == B_Cu )
        layerMask.set( B_Cu );

    m_matrix.TraceFilledRectangle( ox, oy, fx, fy, layerMask,
                          CELL_IS_MODULE, AR_MATRIX::WRITE_OR_CELL );

    // Trace pads + clearance areas.
    for( auto pad : Module->Pads() )
    {
        int margin = (m_matrix.m_GridRouting / 2) + pad->GetClearance();
        m_matrix.PlacePad( pad, CELL_IS_MODULE, margin, AR_MATRIX::WRITE_OR_CELL );
    }

    // Trace clearance.
    int margin = ( m_matrix.m_GridRouting * Module->GetPadCount() ) / AR_GAIN;
    m_matrix.CreateKeepOutRectangle( ox, oy, fx, fy, margin, AR_KEEPOUT_MARGIN , layerMask );
}


/* Test if the rectangular area (ux, ux .. y0, y1):
 * - is a free zone (except OCCUPED_By_MODULE returns)
 * - is on the working surface of the board (otherwise returns OUT_OF_BOARD)
 *
 * Returns OUT_OF_BOARD, or OCCUPED_By_MODULE or FREE_CELL if OK
 */
int AR_AUTOPLACER::testRectangle( const EDA_RECT& aRect, int side )
{
    EDA_RECT rect = aRect;

    rect.Inflate( m_matrix.m_GridRouting / 2 );

    wxPoint start   = rect.GetOrigin();
    wxPoint end     = rect.GetEnd();

    start   -= m_matrix.m_BrdBox.GetOrigin();
    end     -= m_matrix.m_BrdBox.GetOrigin();

    int row_min = start.y / m_matrix.m_GridRouting;
    int row_max = end.y / m_matrix.m_GridRouting;
    int col_min = start.x / m_matrix.m_GridRouting;
    int col_max = end.x / m_matrix.m_GridRouting;

    if( start.y > row_min * m_matrix.m_GridRouting )
        row_min++;

    if( start.x > col_min * m_matrix.m_GridRouting )
        col_min++;

    if( row_min < 0 )
        row_min = 0;

    if( row_max >= ( m_matrix.m_Nrows - 1 ) )
        row_max = m_matrix.m_Nrows - 1;

    if( col_min < 0 )
        col_min = 0;

    if( col_max >= ( m_matrix.m_Ncols - 1 ) )
        col_max = m_matrix.m_Ncols - 1;

    for( int row = row_min; row <= row_max; row++ )
    {
        for( int col = col_min; col <= col_max; col++ )
        {
            unsigned int data = m_matrix.GetCell( row, col, side );

            if( ( data & CELL_IS_ZONE ) == 0 )
                return AR_OUT_OF_BOARD;

            if( (data & CELL_IS_MODULE) )
                return AR_OCCUIPED_BY_MODULE;
        }
    }

    return AR_FREE_CELL;
}


/* Calculates and returns the clearance area of the rectangular surface
 * aRect):
 * (Sum of cells in terms of distance)
 */
unsigned int AR_AUTOPLACER::calculateKeepOutArea( const EDA_RECT& aRect, int side )
{
    wxPoint start   = aRect.GetOrigin();
    wxPoint end     = aRect.GetEnd();

    start   -= m_matrix.m_BrdBox.GetOrigin();
    end     -= m_matrix.m_BrdBox.GetOrigin();

    int row_min = start.y / m_matrix.m_GridRouting;
    int row_max = end.y / m_matrix.m_GridRouting;
    int col_min = start.x / m_matrix.m_GridRouting;
    int col_max = end.x / m_matrix.m_GridRouting;

    if( start.y > row_min * m_matrix.m_GridRouting )
        row_min++;

    if( start.x > col_min * m_matrix.m_GridRouting )
        col_min++;

    if( row_min < 0 )
        row_min = 0;

    if( row_max >= ( m_matrix.m_Nrows - 1 ) )
        row_max = m_matrix.m_Nrows - 1;

    if( col_min < 0 )
        col_min = 0;

    if( col_max >= ( m_matrix.m_Ncols - 1 ) )
        col_max = m_matrix.m_Ncols - 1;

    unsigned int keepOutCost = 0;

    for( int row = row_min; row <= row_max; row++ )
    {
        for( int col = col_min; col <= col_max; col++ )
        {
            // m_matrix.GetDist returns the "cost" of the cell
            // at position (row, col)
            // in autoplace this is the cost of the cell, if it is
            // inside aRect
            keepOutCost += m_matrix.GetDist( row, col, side );
        }
    }

    return keepOutCost;
}


/* Test if the module can be placed on the board.
 * Returns the value TstRectangle().
 * Module is known by its bounding box
 */
int AR_AUTOPLACER::testModuleOnBoard( MODULE* aModule, bool TstOtherSide, const wxPoint& aOffset )
{
    int side = AR_SIDE_TOP;
    int otherside = AR_SIDE_BOTTOM;

    if( aModule->GetLayer() == B_Cu )
    {
        side = AR_SIDE_BOTTOM; otherside = AR_SIDE_TOP;
    }

    EDA_RECT    fpBBox = aModule->GetFootprintRect();
    fpBBox.Move( -aOffset );

    int         diag = testRectangle( fpBBox, side );

    if( diag != AR_FREE_CELL )
        return diag;

    if( TstOtherSide )
    {
        diag = testRectangle( fpBBox, otherside );

        if( diag != AR_FREE_CELL )
            return diag;
    }

    int marge = ( m_matrix.m_GridRouting * aModule->GetPadCount() ) / AR_GAIN;

    fpBBox.Inflate( marge );
    return calculateKeepOutArea( fpBBox, side );
}


int AR_AUTOPLACER::getOptimalModulePlacement(MODULE* aModule)
{
    int     error = 1;
    wxPoint LastPosOK;
    double  min_cost, curr_cost, Score;
    bool    TstOtherSide;

    aModule->CalculateBoundingBox();

    LastPosOK = m_matrix.m_BrdBox.GetOrigin();

    wxPoint     mod_pos = aModule->GetPosition();
    EDA_RECT    fpBBox  = aModule->GetFootprintRect();

    // Move fpBBox to have the footprint position at (0,0)
    fpBBox.Move( -mod_pos );
    wxPoint fpBBoxOrg = fpBBox.GetOrigin();

    // Calculate the limit of the footprint position, relative
    // to the routing matrix area
    wxPoint xylimit = m_matrix.m_BrdBox.GetEnd() - fpBBox.GetEnd();

    wxPoint initialPos = m_matrix.m_BrdBox.GetOrigin() - fpBBoxOrg;

    // Stay on grid.
    initialPos.x    -= initialPos.x % m_matrix.m_GridRouting;
    initialPos.y    -= initialPos.y % m_matrix.m_GridRouting;

    m_curPosition = initialPos;
    auto moduleOffset = mod_pos - m_curPosition;

    /* Examine pads, and set TstOtherSide to true if a footprint
     * has at least 1 pad through.
     */
    TstOtherSide = false;

    if( m_matrix.m_RoutingLayersCount > 1 )
    {
        LSET    other( aModule->GetLayer() == B_Cu  ? F_Cu : B_Cu );

        for( auto pad : aModule->Pads() )
        {
            if( !( pad->GetLayerSet() & other ).any() )
                continue;

            TstOtherSide = true;
            break;
        }
    }

    fpBBox.SetOrigin( fpBBoxOrg + m_curPosition );

    min_cost = -1.0;
//    m_frame->SetStatusText( wxT( "Score ??, pos ??" ) );


    for( ; m_curPosition.x < xylimit.x; m_curPosition.x += m_matrix.m_GridRouting )
    {
        if ( m_refreshCallback )
        {
            if ( m_refreshCallback() == AR_ABORT_PLACEMENT )
                return AR_ABORT_PLACEMENT;
        }

        m_curPosition.y = initialPos.y;

        for( ; m_curPosition.y < xylimit.y; m_curPosition.y += m_matrix.m_GridRouting )
        {

            fpBBox.SetOrigin( fpBBoxOrg + m_curPosition );
            moduleOffset = mod_pos - m_curPosition;
            int keepOutCost = testModuleOnBoard( aModule, TstOtherSide, moduleOffset );

            if( keepOutCost >= 0 )    // i.e. if the module can be put here
            {
                error = 0;
                // m_frame->build_ratsnest_module( aModule ); // fixme
                curr_cost   = computePlacementRatsnestCost( aModule, moduleOffset );
                Score       = curr_cost + keepOutCost;

                if( (min_cost >= Score ) || (min_cost < 0 ) )
                {
                    LastPosOK   = m_curPosition;
                    min_cost    = Score;
                    wxString msg;
/*                    msg.Printf( wxT( "Score %g, pos %s, %s" ),
                                min_cost,
                                GetChars( ::CoordinateToString( LastPosOK.x ) ),
                                GetChars( ::CoordinateToString( LastPosOK.y ) ) );
                    m_frame->SetStatusText( msg );*/
                }
            }
        }
    }

    // Regeneration of the modified variable.
    m_curPosition = LastPosOK;

    m_minCost = min_cost;
    return error;
}


const D_PAD* AR_AUTOPLACER::nearestPad( MODULE *aRefModule, D_PAD* aRefPad, const wxPoint& aOffset)
{
    const D_PAD* nearest = nullptr;
    int64_t nearestDist = INT64_MAX;

    for ( auto mod : m_board->Modules() )
    {
        if ( mod == aRefModule )
            continue;

        if( !m_matrix.m_BrdBox.Contains( mod->GetPosition() ) )
            continue;

        for ( auto pad: mod->Pads() )
        {
            if ( pad->GetNetCode() != aRefPad->GetNetCode() || pad->GetNetCode() <= 0 )
                continue;

            auto dist = (VECTOR2I( aRefPad->GetPosition() - aOffset ) - VECTOR2I( pad->GetPosition() ) ).EuclideanNorm();

            //printf("Dist %lld pad %p\n", dist, pad );

            if ( dist < nearestDist )
            {
                nearestDist = dist;
                nearest = pad;
            }
        }
    }

    return nearest;
}


double AR_AUTOPLACER::computePlacementRatsnestCost( MODULE *aModule, const wxPoint& aOffset )
{
    double  curr_cost;
    VECTOR2I start;      // start point of a ratsnest
    VECTOR2I end;        // end point of a ratsnest
    int     dx, dy;

    curr_cost = 0;

    for ( auto pad : aModule->Pads() )
    {
        auto nearest = nearestPad( aModule, pad, aOffset );

        if( !nearest )
            continue;

        //printf("pad %s nearest %s\n", (const char *)aModule->GetReference().c_str(), (const char *)nearest->GetParent()->GetReference().c_str());

        start   = VECTOR2I( pad->GetPosition() ) - VECTOR2I(aOffset);
        end     = VECTOR2I( nearest->GetPosition() );

        //m_overlay->SetIsStroke( true );
        //m_overlay->SetStrokeColor( COLOR4D(0.0, 1.0, 0.0, 1.0) );
        //m_overlay->Line( start, end );

        // Cost of the ratsnest.
        dx  = end.x - start.x;
        dy  = end.y - start.y;

        dx  = abs( dx );
        dy  = abs( dy );

        // ttry to have always dx >= dy to calculate the cost of the rastsnet
        if( dx < dy )
            std::swap( dx, dy );

        // Cost of the connection = length + penalty due to the slope
        // dx is the biggest length relative to the X or Y axis
        // the penalty is max for 45 degrees ratsnests,
        // and 0 for horizontal or vertical ratsnests.
        // For Horizontal and Vertical ratsnests, dy = 0;
        double conn_cost = hypot( dx, dy * 2.0 );
        curr_cost += conn_cost;    // Total cost = sum of costs of each connection
    }

    return curr_cost;
}


// Sort routines
static bool sortFootprintsByComplexity( MODULE* ref, MODULE* compare )
{
    double ff1, ff2;

    ff1 = ref->GetArea() * ref->GetPadCount();
    ff2 = compare->GetArea() * compare->GetPadCount();

    return ff2 < ff1;
}


static bool sortFootprintsByRatsnestSize( MODULE* ref, MODULE* compare )
{
    double ff1, ff2;

    ff1 = ref->GetArea() * ref->GetFlag();
    ff2 = compare->GetArea() * compare->GetFlag();
    return ff2 < ff1;
}


/**
 * Function Module
 * find the "best" module place
 * The criteria are:
 * - Maximum ratsnest with modules already placed
 * - Max size, and number of pads max
 */
MODULE* AR_AUTOPLACER::pickModule( )
{
    MODULE* module;
    std::vector <MODULE*> moduleList;


    for( auto m : m_board->Modules() )
    {
        m->CalculateBoundingBox();
        moduleList.push_back( m );
    }

    sort( moduleList.begin(), moduleList.end(), sortFootprintsByComplexity );

    for( unsigned kk = 0; kk < moduleList.size(); kk++ )
    {
        module = moduleList[kk];
        module->SetFlag( 0 );

        if( !module->NeedsPlaced() )
            continue;

        m_connectivity->Update( module );
    }

    m_connectivity->RecalculateRatsnest();

    for( unsigned kk = 0; kk < moduleList.size(); kk++ )
    {
        module = moduleList[kk];

        auto edges = m_connectivity->GetRatsnestForComponent( module, true );

        module->SetFlag( edges.size() ) ;
    }

    sort( moduleList.begin(), moduleList.end(), sortFootprintsByRatsnestSize );

    // Search for "best" module.
    MODULE* bestModule  = nullptr;
    MODULE* altModule   = nullptr;

    for( unsigned ii = 0; ii < moduleList.size(); ii++ )
    {
        module = moduleList[ii];

        if( !module->NeedsPlaced() )
            continue;

        altModule = module;

        if( module->GetFlag() == 0 )
            continue;

        bestModule = module;
        break;
    }

    if( bestModule )
        return bestModule;
    else
        return altModule;
}


void AR_AUTOPLACER::drawPlacementRoutingMatrix( )
{
    int         ii, jj;
    COLOR4D     color;
    int         ox, oy;
    AR_MATRIX::MATRIX_CELL top_state, bottom_state;


    for( ii = 0; ii < m_matrix.m_Nrows; ii++ )
    {
        oy = m_matrix.m_BrdBox.GetY() + ( ii * m_matrix.m_GridRouting );

        for( jj = 0; jj < m_matrix.m_Ncols; jj++ )
        {
            ox      = m_matrix.m_BrdBox.GetX() + (jj * m_matrix.m_GridRouting);
            color   = COLOR4D::BLACK;

            top_state       = m_matrix.GetCell( ii, jj, AR_SIDE_TOP );
            bottom_state    = m_matrix.GetCell( ii, jj, AR_SIDE_BOTTOM );

            if(top_state || bottom_state)
            {
             //   printf("[%d, %d] [%d, %d] TS %x BS %x\n",ii,jj, ox, oy, top_state, bottom_state );
            }

            if( top_state & CELL_IS_ZONE )
                color = COLOR4D( BLUE );

            // obstacles
            if( ( top_state & CELL_IS_EDGE ) || ( bottom_state & CELL_IS_EDGE ) )
                color = COLOR4D::WHITE;
            else if( top_state & ( CELL_IS_HOLE | CELL_IS_MODULE ) )
                color = COLOR4D( LIGHTRED );
            else if( bottom_state & ( CELL_IS_HOLE | CELL_IS_MODULE) )
                color = COLOR4D( LIGHTGREEN );
            else    // Display the filling and keep out regions.
            {
                if( m_matrix.GetDist( ii, jj, AR_SIDE_TOP )
                    || m_matrix.GetDist( ii, jj, AR_SIDE_BOTTOM ) )
                    color = DARKGRAY;
            }

            m_overlay->SetIsFill(true);
            m_overlay->SetFillColor( color );

            VECTOR2D p(ox, oy);
            m_overlay->Circle(p, m_matrix.m_GridRouting/4 );
        }
    }
}

AR_RESULT AR_AUTOPLACER::AutoplaceModules( std::vector<MODULE*> aModules, BOARD_COMMIT* aCommit, bool aPlaceOffboardModules )
{
    wxPoint             PosOK;
    wxPoint             memopos;
    int                 error;
    MODULE* module = nullptr;
    bool cancelled = false;

    memopos = m_curPosition;

    //printf("set grid: %d\n", m_gridSize);

    m_matrix.m_GridRouting = m_gridSize; //(int) m_frame->GetScreen()->GetGridSize().x;

    // Ensure Board.m_GridRouting has a reasonable value:
    if( m_matrix.m_GridRouting < Millimeter2iu( 0.25 ) )
        m_matrix.m_GridRouting = Millimeter2iu( 0.25 );

    // Compute module parameters used in auto place
    if( genPlacementRoutingMatrix( ) == 0 )
        return AR_FAILURE;

    int moduleCount = 0;

    for ( auto m : m_board->Modules() )
    {
        m->SetNeedsPlaced( false );
    }

    std::vector<MODULE *> offboardMods;

    if( aPlaceOffboardModules )
    {
        for ( auto m : m_board->Modules() )
        {
            if( !m_matrix.m_BrdBox.Contains( m->GetPosition() ) )
            {
                offboardMods.push_back( m );
            }
        }
    }

    for ( auto m : aModules )
    {
        m->SetNeedsPlaced( true );
        aCommit->Modify(m);
    }

    for ( auto m : offboardMods )
    {
        m->SetNeedsPlaced( true );
        aCommit->Modify(m);
    }

    for ( auto m : m_board->Modules() )
    {
        if( m->NeedsPlaced() )    // Erase from screen
        {
            moduleCount++;
        }
        else
        {
            genModuleOnRoutingMatrix( m );
        }
    }

    drawPlacementRoutingMatrix();

    int         cnt = 0;
    wxString    msg;

    if( m_progressReporter )
    {
        m_progressReporter->Report( _( "Autoplacing components..." ) );
        m_progressReporter->SetMaxProgress( moduleCount );
    }

    while( ( module = pickModule( ) ) != nullptr )
    {
        // Display some info about activity, module placement can take a while:
        //printf( _( "Place footprint %d of %d [%s]\n" ), cnt, moduleCount, (const char *)module->GetReference().c_str() );
        //m_frame->SetStatusText( msg );

        double initialOrient = module->GetOrientation();
        // Display fill area of interest, barriers, penalties.
        //drawPlacementRoutingMatrix( );

        error = getOptimalModulePlacement( module );
        double bestScore = m_minCost;
        double bestRotation = 0.0;
        int rotAllowed;
        PosOK = m_curPosition;

        if( error == AR_ABORT_PLACEMENT )
            goto end_of_tst;

        // Try orientations 90, 180, 270 degrees from initial orientation
        rotAllowed = module->GetPlacementCost180();

        //printf("rotAllowed %d\n", rotAllowed);

        if( rotAllowed != 0 )
        {
            rotateModule( module, 1800.0, true );
            error   = getOptimalModulePlacement( module );
            m_minCost *= OrientationPenalty[rotAllowed];

            if( bestScore > m_minCost )    // This orientation is better.
            {
                PosOK       = m_curPosition;
                bestScore   = m_minCost;
                bestRotation = 1800.0;
            }
            else
            {
                rotateModule( module, initialOrient, false );
            }

            if( error == AR_ABORT_PLACEMENT )
                goto end_of_tst;
        }

        // Determine if the best orientation of a module is 90.
        rotAllowed = module->GetPlacementCost90();
        if( rotAllowed != 0 )
        {
            rotateModule( module, 900.0, true );
            error   = getOptimalModulePlacement( module );
            m_minCost *= OrientationPenalty[rotAllowed];

            if( bestScore > m_minCost )    // This orientation is better.
            {
                PosOK       = m_curPosition;
                bestScore   = m_minCost;
                bestRotation = 900.0;
            }
            else
            {
                rotateModule( module, initialOrient, false );
            }

            if( error == AR_ABORT_PLACEMENT )
                goto end_of_tst;
        }

        // Determine if the best orientation of a module is -90.
        if( rotAllowed != 0 )
        {
            rotateModule( module, 2700.0, true );
            error   = getOptimalModulePlacement( module );
            m_minCost *= OrientationPenalty[rotAllowed];

            if( bestScore > m_minCost )    // This orientation is better.
            {
                PosOK       = m_curPosition;
                bestScore   = m_minCost;
                bestRotation = 2700.0;
            }
            else
            {
                rotateModule( module, initialOrient, false );
            }

            if( error == AR_ABORT_PLACEMENT )
                goto end_of_tst;
        }

end_of_tst:

        if( error == AR_ABORT_PLACEMENT )
            break;


        bestRotation += initialOrient;

        if( bestRotation != module->GetOrientation() )
        {
            //printf("best rotation %d\n",  bestRotation );
            rotateModule( module, bestRotation, false );
        }

        // Place module.
        placeModule( module, true, m_curPosition );

        module->CalculateBoundingBox();
        genModuleOnRoutingMatrix( module );
        module->SetIsPlaced( true );
        module->SetNeedsPlaced( false );


        if( m_progressReporter )
        {
            m_progressReporter->AdvanceProgress();
            if ( !m_progressReporter->KeepRefreshing( false ) )
            {
                cancelled = true;
                break;
            }
        }
        cnt++;
    }

    m_curPosition = memopos;

    m_matrix.UnInitRoutingMatrix();

    for ( auto m : m_board->Modules() )
    {
        m->CalculateBoundingBox();
    }

    return cancelled ? AR_CANCELLED : AR_COMPLETED;
}