phylo_tree_force.cpp

Go to the documentation of this file.

/*  $Id: phylo_tree_force.cpp 25384 2012-03-06 19:27:20Z ucko $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Authors:  Vladimir Tereshkov
 *
 * File Description:
 *      Force tree layout
 */

#include <ncbi_pch.hpp>
#include <corelib/ncbitime.hpp>
#include <corelib/ncbistl.hpp>

#include <gui/widgets/phylo_tree/phylo_tree_force.hpp>
#include <gui/widgets/phylo_tree/phylo_tree_pane.hpp>
#include <gui/widgets/phylo_tree/phylo_tree_ds.hpp>
#include <gui/widgets/phylo_tree/phylo_tree_ps.hpp>
#include <gui/opengl/glhelpers.hpp>
#include <gui/graph/igraph_utils.hpp>
//#include <gui/widgets/phylo_tree/phylo_tree_render.hpp>

#include <gui/widgets/gl/attrib_menu.hpp>

#include <gui/utils/event_translator.hpp>
#include <gui/framework/app_task_service.hpp>
#include <gui/utils/app_job_impl.hpp>
#include <gui/utils/view_event.hpp>


#include <math.h>

BEGIN_NCBI_SCOPE

#define PHYLO_RENDER_TIMER_ID 63001

BEGIN_EVENT_MAP(CPhyloForce, CEventHandler)
    ON_MESSAGE(CAppJobNotification, CAppJobNotification::eStateChanged,
               &CPhyloForce::OnAppJobNotification)
    ON_MESSAGE(CAppJobNotification, CAppJobNotification::eProgress,
               &CPhyloForce::OnAppJobProgress)
END_EVENT_MAP()

BEGIN_EVENT_TABLE(CPhyloForce, CPhyloRadial)
    EVT_TIMER(PHYLO_RENDER_TIMER_ID, CPhyloForce::OnTimer)
END_EVENT_TABLE()


CPhyloForce::CPhyloForce()
: m_Timer(this, PHYLO_RENDER_TIMER_ID)
, m_MainThreadPS(NULL)
, m_UseMainThreadPhysics(true)
{
    m_JobID                 = CAppJobDispatcher::eInvalidJobID;

    // If rendering within gbench, use thread for force calculations,
    // otherwise we are probably cgi and should use main thread.
    if (CGuiRegistry::GetInstance().HasField("GBENCH")) {
        m_UseMainThreadPhysics = false;
    }
}

CPhyloForce::CPhyloForce(double w, double h) 
: CPhyloRadial(w, h)
, m_Timer(this, PHYLO_RENDER_TIMER_ID)
, m_MainThreadPS(NULL)
, m_UseMainThreadPhysics(true)
{
    m_JobID                 = CAppJobDispatcher::eInvalidJobID;

    // If rendering within gbench, use thread for force calculations,
    // otherwise we are probably cgi and should use main thread.
    if (CGuiRegistry::GetInstance().HasField("GBENCH")) {
        m_UseMainThreadPhysics = false;      
    }

#ifdef ATTRIB_MENU_SUPPORT
   // CAttribMenu& m = CAttribMenuInstance::GetInstance();

   // CAttribMenu* sub_menu = m.AddSubMenuUnique("Force ext", this);
   
   // sub_menu->AddFloatReadOnly("Vis Left", &vis_left);
   // sub_menu->AddFloatReadOnly("Vis Right", &vis_right);
   // sub_menu->AddFloatReadOnly("Vis Bottom", &vis_bottom);
   // sub_menu->AddFloatReadOnly("Vis Top", &vis_top);

   // sub_menu->AddFloatReadOnly("Ext Left", &ext_left);
   // sub_menu->AddFloatReadOnly("Ext Right", &ext_right);
   // sub_menu->AddFloatReadOnly("Ext Bottom", &ext_bottom);
   // sub_menu->AddFloatReadOnly("Ext top", &ext_top);
#endif  
   
}


CPhyloForce::~CPhyloForce()
{   
    if (m_JobID != CAppJobDispatcher::eInvalidJobID) {
        CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();
        disp.DeleteJob(m_JobID);
    }

    m_Timer.Stop();
}

void  CPhyloForce::x_Layout(CPhyloTreeDataSource& ds)
{
    m_pRoot = ds.GetTree();

    bool distMode = m_bDistMode;
    m_bDistMode = false;

    // It is more efficient not to re-run the radial layout each time
    // if, for example, the user simply collapsed some nodes.  Unfortuately
    // some user operations wind up setting all node position values to 0,
    // so be be sure we have to compute the radial tree first each time.
    //if (m_SwitchedLayout)
    CPhyloRadial::x_Layout(ds);   
    m_bDistMode = distMode;

    Int4 leafs = ds.GetSize();
    Int4 width = ds.GetWidth();

    m_xStep = m_DimX /  width;
    m_yStep = m_DimY / ((leafs>1)?(leafs-1):2);

    if (ds.GetNormDistance() > 0){      
         m_NormDistance = m_DimX / ds.GetNormDistance();
    }

    m_Timer.Stop();

    CPhyloTreePS::PhysicsParms p;
    bool retain_parms = false;

    // Set drawing options that are specific to the force layout
    CGlVboNode* edge_node = ds.GetModel().FindGeomNode("TreeEdges");
    CGlVboNode* narrow_edge_node = ds.GetModel().FindGeomNode("NarrowTreeEdges");

    if (edge_node != NULL && narrow_edge_node != NULL) {   
        edge_node->GetState().Enable(GL_LINE_SMOOTH);
        edge_node->GetState().Enable(GL_BLEND);
        edge_node->GetState().SetBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);        

        narrow_edge_node->GetState().Enable(GL_LINE_SMOOTH);
        narrow_edge_node->GetState().Enable(GL_BLEND);
        narrow_edge_node->GetState().SetBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        narrow_edge_node->GetState().SetColor(CRgbaColor(1.0f, 1.0f, 1.0f, 0.7f));
    }

    CGlVboNode* filler_points_node = m_DS->GetModel().FindGeomNode("FillerPoints");
    if (filler_points_node != NULL)
        filler_points_node->SetVisible(false);

    // Special case: no need for particle system if there is only
    // one node.
    if (m_pRoot->IsLeafEx()) {
        TModelRect newRect = ds.GetBoundRect();

        newRect.Inflate(1.0f, 1.0f);
        m_RasterRect = newRect;

        // This handles single node case too.
        ComputeViewingLimits(*m_pPane, false);

        return;
    }

    if (!m_UseMainThreadPhysics) {

        try {
            CForceJob* j = m_Job.GetPointerOrNull();

            // for debugging, copy the particle system parameters from the current 
            // system to the new one (parameters may be updated via attribute
            // menus).
            if (j != NULL) {
                p = j->GetPS()->getPhysicParms();
                retain_parms = true;
            }

            if (m_JobID != CAppJobDispatcher::eInvalidJobID) {
                CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();
                IAppJob::EJobState state = disp.GetJobState(m_JobID);
                if (state == IAppJob::eRunning)
                    disp.CancelJob(m_JobID);
                else
                    disp.DeleteJob(m_JobID);

                m_Job.Reset();
            }

            j = m_Job.GetPointerOrNull();

            if (j == NULL) {
                // This is for debugging - if you run the force update several times,
                // you may change parameters each time and this retains those updates,
                // which probably occured through attribute menus, between updates.
                CForceJob *fj = new CForceJob(ds.GetTree(), ds);

                if (retain_parms) {
                    fj->GetPS()->SetPhysicsParms(p);


#ifdef ATTRIB_MENU_SUPPORT
                    CAttribMenuInstance::GetInstance().SynchToUserValue();
#endif

                }

                m_Job.Reset(fj);        
                m_JobID = CAppJobDispatcher::GetInstance().StartJob(*m_Job, "ThreadPool", *this, 1, true);

                m_Timer.Start(100);
            }
        }
        // Unable to start a job - try to do physics in foreground
        catch (CAppJobException&) {
            m_UseMainThreadPhysics = true;
        }
    }
    else {
        if (!m_MainThreadPS) {
            m_MainThreadPS = new CPhyloTreePS(ds);
            // This makes the system end more quickly since the velocity threshold
            // below which we can stop is raised.
            m_MainThreadPS->SetVelocityThresholdK(0.2f);
        } else {
            m_MainThreadPS->Init(ds);
        }

        //m_Timer.Start(50); // no good for cgi...
        
        // This has to work for a batch, CGI version too - so there are
        // no progressive updates - we just want to iterate until it stabilizes
        // or we reach a maximum iteration count.
        for (int i=0; i<200 && !m_MainThreadPS->IsDone(); ++i)    
            x_SingleThreadPhysics();

        CBoundaryPoints boundary_pts;
        x_CalculateBoundary(m_pRoot, boundary_pts, false);
        ComputeViewingLimits(*m_pPane, false);

        // This is the rect for viewing limits used by cgi.
        m_RasterRect = m_pPane->GetModelLimitsRect();

        return;
    }
}

void CPhyloForce::RemoveCurrentDataSource()
{
    IPhyloTreeRenderer::RemoveCurrentDataSource();

    try {       
        m_Timer.Stop();

        if (m_JobID != CAppJobDispatcher::eInvalidJobID) {
            CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();
            IAppJob::EJobState state = disp.GetJobState(m_JobID);

            if (state == IAppJob::eRunning) {
                disp.CancelJob(m_JobID);

                // Wait until job is really done (current iteration is finished)
                // to move on:
                int count = 0;
                while (count++<20 && disp.GetJobState(m_JobID) == IAppJob::eRunning) {
                    wxMilliSleep(100);
                }
            }
            else {
                disp.DeleteJob(m_JobID);
            }

            m_JobID = CAppJobDispatcher::eInvalidJobID;
            m_Job.Reset();
        }
    }
    catch (CAppJobException&) {    
        _TRACE("Error deleting force layout job");
    }

    m_JobID = CAppJobDispatcher::eInvalidJobID;            
    m_Job.Reset();
}

bool CPhyloForce::Render(CGlPane& pane, CPhyloTreeDataSource& ds)
{
    m_pPane     = &pane;
    m_DS        = &ds;

    // Is a job running? If so make sure we don't draw while the 
    // particle system is syncing with the graphics model.  Otherwise
    // just draw.
    if (m_JobID != CAppJobDispatcher::eInvalidJobID) {               

        CForceJob* j = m_Job.GetPointerOrNull();
        if (j != NULL ) {

            if (j->DataSynched() == CForceJob::eDataSynched) {
                j->SetDataSynched(CForceJob::eRenderInProgress);

#ifdef BUFFERED_RENDER
                /// Need only to drop scale marker for force layout...
                IPhyloTreeRenderer::Render(pane,ds);
#else
                x_Render(pane, ds);
#endif
                j->SetDataSynched(CForceJob::eDataSynched);
            }
            // Unable to render since force thread is busy synchrnizing 
            // the particle system data with the graphics data.
            else {
                return false;
            }
        }
    }
    else {
#ifdef BUFFERED_RENDER
        /// Need only to drop scale marker for force layout...
        IPhyloTreeRenderer::Render(pane,ds);
#else
        x_Render(pane, ds);
#endif
    }

    return true;
}

void  CPhyloForce::x_SingleThreadPhysics() 
{
    if (!m_MainThreadPS)
        return;

    if (!m_MainThreadPS->IsDone()) {    
        for (int j=0; j<10; ++j) {        
            m_MainThreadPS->Update();      
        }

        m_MainThreadPS->UpdateAndSynch();     
    }
    else {
        m_Timer.Stop();
    }
}

void  CPhyloForce::x_Render(CGlPane& pane, CPhyloTreeDataSource& ds)
{
    CRgbaColor bgColor(m_SL->SetColor(CPhyloTreeScheme::eTree,
                                    CPhyloTreeScheme::eBgColor));

    glClearColor(bgColor.GetRed(), bgColor.GetGreen(),
        bgColor.GetBlue(), bgColor.GetAlpha());

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);  
    
    pane.OpenOrtho();

    x_DrawBoundingAreas(ds.GetTree());
    x_DrawTree( ds.GetTree() );
    x_DrawNodes( ds.GetTree() );

    pane.Close();

    x_RenderSelection(pane);
}

void CPhyloForce::x_DrawTree(CPhyloTreeNode * node)
{
    // drawing leaf node
    if (node->GetParent()){     
        x_RenderLine(node->GetParent()->GetValue().X(),
                     node->GetParent()->GetValue().Y(),
                     node->GetValue().X(), node->GetValue().Y(),
                     (**node).GetSelectedState(),
                     GetEdgeColor(node));
    }
    for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBeginEx();
        it != node->SubNodeEndEx(); it++ ){
            x_DrawTree(static_cast<CPhyloTreeNode*>(*it));
    }
}


void CPhyloForce::x_CalculateBoundary(CPhyloTreeNode * node, 
                                      CBoundaryPoints& parent_boundary_pts,
                                      bool compute_boundary)
{
    if ((**node).GetBoundedDisplay() == IPhyGraphicsNode::eBounded)
        compute_boundary = true;

    CBoundaryPoints node_boundary_pts;

    if (!node->IsLeafEx()) {
        for(CPhyloTreeNode::TNodeList_I  it = node->SubNodeBeginEx();
            it != node->SubNodeEnd(); it++)  {
            CPhyloTreeNode* subnode = static_cast<CPhyloTreeNode*>(*it);
            x_CalculateBoundary(subnode, node_boundary_pts, compute_boundary);
        }
    }

    x_ComputeNodeBoundary(node, compute_boundary, node_boundary_pts, "ForceLayout");

    // Each node that computes a boundary has to add in the points (and text rectangles)
    // for all nodes below it in the tree
    if (compute_boundary) {
        parent_boundary_pts.AddBoundedPoints(node_boundary_pts);
    }
}

void CPhyloForce::StartRendering(bool b) 
{ 
    IPhyloTreeRenderer::StartRendering(b);
    
    if (!b) {
        CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();      
        disp.DeleteJob(m_JobID);
        m_Timer.Stop();
    }
}


/// handles "state changed" notification from CAppJobDispatcher
void CPhyloForce::OnAppJobNotification(CEvent* evt)
{
    CAppJobNotification* notn = dynamic_cast<CAppJobNotification*>(evt);
    _ASSERT(notn);


    IAppJob::EJobState state = IAppJob::eInvalid;
    int job_id = 0;

    if(notn) {
        job_id = notn->GetJobID();
        if(job_id) {
            state = notn->GetState();
        }
    }
   
    if (state != IAppJob::eRunning) {        
        // Only redraw if job completed normally - not if it was cancellled.
        if (state == IAppJob::eCompleted) {
            CBoundaryPoints boundary_pts;
            x_CalculateBoundary(m_pRoot, boundary_pts, false);
            ComputeViewingLimits(*m_pPane, false);
            if (m_pHost != NULL)
                m_pHost->HMGH_UpdateLimits(true);
    
            x_Render(*m_pPane, *m_DS);
        }

        // Stop timer if job is not running.  Can't just use job status since
        // when layout it called it stops the current job but then immediately
        // starts a new one, so this can be called from the cancelled job
        // even though the timer is needed for the newly created job.
        if (job_id == m_JobID) {
            m_Timer.Stop();
            m_JobID = CAppJobDispatcher::eInvalidJobID;
            m_Job.Reset();
        }           
    }
}

void CPhyloForce::OnTimer(wxTimerEvent& /* evt */)
{
    // If there is a valid (deform) job running and it has 
    // synchronized the visual data with the physics data
    // since the last time called, recompute the tree boundaries
    // and redraw.
    if (!m_UseMainThreadPhysics &&
        m_JobID != CAppJobDispatcher::eInvalidJobID) {
        
        CAppJobDispatcher& disp = CAppJobDispatcher::GetInstance();
        IAppJob::EJobState state = disp.GetJobState(m_JobID);

        CForceJob* j = m_Job.GetPointerOrNull();
        if (j != NULL ) {
            CMutexGuard guard(j->GetMutex());
            if (state == IAppJob::eRunning && 
                j->DataSynched() == CForceJob::eDataRefreshed) {
                    j->SetDataSynched(CForceJob::eRenderInProgress);
                    CBoundaryPoints boundary_pts;
                    x_CalculateBoundary(m_pRoot, boundary_pts, false);
                    ComputeViewingLimits(*m_pPane, false);
                    m_pHost->HMGH_UpdateLimits(true);
                    j->SetDataSynched(CForceJob::eDataSynched);
            }
        }
        else if (m_UseMainThreadPhysics) {
            x_SingleThreadPhysics();
    
            CBoundaryPoints boundary_pts;
            x_CalculateBoundary(m_pRoot, boundary_pts, false);
            ComputeViewingLimits(*m_pPane, false);
            if (m_pHost != NULL)
                m_pHost->HMGH_UpdateLimits(true);
        }
    }
}


///////////////////////////////////////////////////////////////////////////////
//
// Background job for running force update on a separate thread
//
///////////////////////////////////////////////////////////////////////////////
CForceJob::CForceJob(CPhyloTreeNode * node, CPhyloTreeDataSource& ds)
: m_Node(node)
, m_PS(NULL)
, m_DataSynched(eDataSynched)
, m_UpdatesSincLastSync(0)
{
    m_PS = new CPhyloTreePS(ds);
}

CForceJob::~CForceJob()
{
    delete m_PS;
    m_PS =  NULL;
}

IAppJob::EJobState CForceJob::Run()
{
    // Loop a large number of times.  Ideally, system will stop when
    // velocity drops (checked in x_Calculate)
    for (int i=0; i<20000 && !Cancelled(); i++) 
        x_Calculate();

    return eCompleted;    
}

void CForceJob::x_Calculate()
{
    if (Cancelled()) {
        return;
    }

    // updates should be timer based, but make sure that
    // a minimum number happen (otherwise it will slow down
    // progress of the particle system)
    double i = 0.0f;

    CStopWatch sw;
    sw.Start();

    // Update the system a fixed number of times or until 0.5 seconds
    // has passed.  
    while (i * sw.Elapsed() < 1.0) {        
        m_PS->Update(); 
        i += 2.0;
        ++m_UpdatesSincLastSync;
    }

    // Do a special update that synchronizes the tree data with the particle
    // system.  To keep rendering (kind of ) smooth during updates of larger
    // trees, don't do this if there were less than a (low) number of iterations
    // since synch blocks rendering.
    if (!Cancelled() && 
        m_DataSynched != eRenderInProgress &&
        m_UpdatesSincLastSync > 5) {
            m_UpdatesSincLastSync = 0;
            CMutexGuard guard(m_Mutex);
            m_DataSynched = eDataNotSynched;
            m_PS->UpdateAndSynch();
            m_DataSynched = eDataRefreshed;

            /// If velocity has dropped low enough, stop system.
            if (m_PS->IsDone())
                RequestCancel();
    }                  
}

void CForceJob::RequestCancel()
{
    CMutexGuard guard(m_Mutex);
    m_StopRequested = true;
}

CForceJob::TDataSynchStatus CForceJob::DataSynched()
{
    return m_DataSynched;
}

void CForceJob::SetDataSynched(TDataSynchStatus s)
{
    CMutexGuard guard(m_Mutex);
    m_DataSynched = s;
}

CConstIRef<IAppJobProgress> CForceJob::GetProgress()
{
    return CConstIRef<IAppJobProgress>(new CAppJobProgress(1.0, "Finished"));
}

CRef<CObject> CForceJob::GetResult()
{
    CMutexGuard guard(m_Mutex);
    CRef<CObject> result(new CObject());
    return result;
}

CConstIRef<IAppJobError> CForceJob::GetError()
{
    return CConstIRef<IAppJobError>(new CAppJobError("No errors"));
}

string CForceJob::GetDescr() const
{
    return "Building Force Layout";
}

void CForceJob::x_CheckCancelled() const
{
    CMutexGuard guard(m_Mutex);
    if (Cancelled())
        NCBI_THROW(CException, eUnknown, "Job Cancelled");
}

void CPhyloForce::OnAppJobProgress(CEvent* evt)
{
    CAppJobNotification* notn =
        dynamic_cast<CAppJobNotification*>(evt);
    _ASSERT(notn);

    if(notn) {      

        // Could redraw on this with code below, but we use a separate timer
        // since this is called to infrequently to be helpful 
        // (only called around 1/sec)
        /*       
        CForceJob* j = m_Job.GetPointerOrNull();
        if (j != NULL) {

        CMutexGuard guard(j->GetMutex());

        CBoundaryPoints boundary_pts;
        x_CalculateBoundary(m_pRoot, boundary_pts, false);
        ComputeViewingLimits(*m_pPane, false);
        m_pHost->HMGH_UpdateLimits(true);
        //x_GetParent()->GetPort().SetModelLimitsRect(m_MatrixPane.GetModelLimitsRect());
        //x_GetParent()->GetPort().SetVisibleRect(m_MatrixPane.GetVisibleRect());
        m_pPane->OpenOrtho();

        x_DrawBoundingAreas(m_DS->GetTree());
        x_DrawTree( m_DS->GetTree() );
        x_DrawNodes( m_DS->GetTree() );

        m_pPane->Close();
        }
        */
    }
    
}




END_NCBI_SCOPE