vcf_glyph.cpp

Go to the documentation of this file.

Go to the SVN repository for this file.

/*  $Id: vcf_glyph.cpp 47485 2023-05-02 14:46:59Z 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:  Mike DiCuccio, Liangshou Wu
 *
 * File Description:
 *    CVcfGlyph 
 */
 
#include <ncbi_pch.hpp>
#include <gui/widgets/seq_graphic/vcf_glyph.hpp>
#include <gui/widgets/seq_graphic/rendering_ctx.hpp>
#include <gui/widgets/seq_graphic/seqgraphic_utils.hpp>
#include <gui/widgets/seq_graphic/layout_track_impl.hpp>
#include <gui/widgets/seq_graphic/layout_group.hpp>
#include <gui/widgets/seq_graphic/config_utils.hpp>
 
#include <gui/widgets/gl/ruler.hpp>
#include <gui/objutils/obj_fingerprint.hpp>
#include <gui/objutils/utils.hpp>
#include <gui/objutils/gui_object_info_seq_feat.hpp>
#include <gui/objutils/tooltip.hpp>
#include <gui/objutils/snp_gui.hpp>
#include <gui/opengl/gltexturefont.hpp>
#include <gui/opengl/irender.hpp>
 
#include <objects/seqfeat/Variation_ref.hpp>
#include <objects/seqfeat/Variation_inst.hpp>
#include <objects/seqfeat/Delta_item.hpp>
#include <objects/seqfeat/Feat_id.hpp>
#include <objects/general/Dbtag.hpp>
#include <objects/general/Object_id.hpp>
#include <objects/general/User_object.hpp>
#include <objects/seqloc/Seq_interval.hpp>
#include <objects/seq/Seq_literal.hpp>
#include <objects/seqloc/Giimport_id.hpp>
 
#include <objmgr/util/sequence.hpp>
#include <objtools/alnmgr/aln_converters.hpp>
#include <objtools/snputil/snp_utils.hpp>
#include <util/sequtil/sequtil_manip.hpp>
 
#include <util/sequtil/sequtil_manip.hpp>
#include <corelib/ncbi_stack.hpp>
#include <math.h>
 
BEGIN_NCBI_SCOPE
USING_SCOPE(objects);
 
/// feature ruler height.
static const int kRulerHeight = 16;
 
/// vertical space between elements.
static const int kVertSpace = 2;
 
/// Restriction sites marker height (relative to the height of the bar)
static const TModelUnit kRSiteMarkerHeight = 0.5;
 
/// Restriction sites marker width (absolute)
static const TModelUnit kRSiteMarkerWidth = 0.4;
 
/// Restriction sites marker visibility threshold (ie if the marker's width is smaller then the threshold, markers are not drawn)
static const TModelUnit kRSiteMarkerThreshold = 2;
 
/// Shoudl match feature_ds.cpp::kMinScaleForMapping 
/// i.e. what mapping is not created then do not show ruler labels
static const float kMinScaleForRulerLabels = 16.;
 
 
// #define DEBUG_INFO_ON_SCREEN 1
 
 
//
// CVcfGlyph::CVcfGlyph()
//
 
CVcfGlyph::CVcfGlyph(CSeq_id& seq_id,
                     const string& sID, 
                     size_t pos, 
                     const string& ref_allele, 
                     const string& alt_alleles) :
     m_Object(new CVcfVariant(seq_id, sID, pos, ref_allele, alt_alleles))
{
//    LOG_POST(Trace << "<<<< CVcfGlyph(" << sID << "/" << NStr::NumericToString(pos));
    m_Intervals.push_back(GetRange());
}
 
CVcfGlyph::CVcfGlyph(const CVcfVariant *object) :
    m_Object(object)
{
//    LOG_POST(Trace << "<<<< CVcfGlyph(object " << (!object ? string("NULL") : object->GetID() + "/" + NStr::NumericToString(object->GetPos())));
    m_Intervals.push_back(GetRange());
}
 
bool CVcfGlyph::NeedTooltip(const TModelPoint& /*p*/, ITooltipFormatter& /*tt*/, string& t_title) const
{
    return true;
}
 
void CVcfGlyph::x_GetClinVarToolTip(ITooltipFormatter& tooltip) const
{
    // Disable HTML encoding for SV generated links
    tooltip.SetTrustedData(true);
    tooltip.AddRow("ClinVar Variation ID:", tooltip.CreateNcbiLink(m_Object->GetID(), NSnpGui::ClinVarIdURL + m_Object->GetID()));
 
    const auto &info_fields = m_Object->GetInfoColumns();
    auto it = info_fields.find("RS");
    if (it != info_fields.end()) {
        tooltip.AddRow("SNP ID:", tooltip.CreateNcbiLink("rs"+it->second, NSnpGui::snpURL + it->second));
    }
    tooltip.SetTrustedData(false);
    string str_buff;
    it = info_fields.find("CLNSIG");
    if (it != info_fields.end()) {
        string clinsig = it->second;
        NStr::ReplaceInPlace(clinsig, "|", ";");
        tooltip.AddRow("ClinVar interpretation:", NStr::Replace(clinsig, "_", " ", str_buff));
    }
    it = info_fields.find("CLNREVSTAT");
    if (it != info_fields.end()) {
        NStr::Replace(it->second, "_", " ", str_buff);
        if (!str_buff.empty()) {
            str_buff[0] = toupper(str_buff[0]);
        } else {
            str_buff = "None";
        }
        tooltip.AddRow("Review status:", str_buff);
    }
 
    str_buff.clear();
    it = info_fields.find("CLNVCSO");
    if (it != info_fields.end()) {
        static const map<string, string> sm_CLNVCSO2Type = {
            {"SO:0000159", "Deletion"},
            {"SO:1000035", "Duplication"},
            {"SO:1000032", "DELINS"},
            {"SO:0000667", "Insertion"},
            {"SO:1000036", "Inversion"},
            {"SO:0000289", "Microsatellite"},
            {"SO:0001563", "Structural variant"},
            {"SO:1000173", "Tandem_duplication"},
            {"SO:0001059", "Sequence alteration"},
            {"SO:0000199", "Translocation"},
            {"SO:0001742", "Copy number gain"},
            {"SO:0001743", "Copy number loss"},
            {"SO:0001483", "SNV"},
            {"SO:0001013", "MNP"}
        };
        auto clnvcso_it = sm_CLNVCSO2Type.find(it->second);
        if (clnvcso_it != sm_CLNVCSO2Type.end())
            str_buff = clnvcso_it->second;
    }
    if (str_buff.empty()) {
        it = info_fields.find("CLNVC");
        if (it != info_fields.end() && it->second.empty() == false) {
            NStr::Replace(it->second, "_", " ", str_buff);
            str_buff[0] = toupper(str_buff[0]);
        }
    }
    if (str_buff.empty()) 
        str_buff = m_Object->GetVariationTypeAsString();
    
    if (!str_buff.empty()) {
        tooltip.AddRow("Variation type:", str_buff);
    }
 
    string allele;
    if (!m_Object->GetAltAlleles_display().empty() && m_Object->GetAltAlleles_display().front() != ".")
        allele = m_Object->GetAltAlleles_display().front();
    else 
        allele = m_Object->GetRefAllele_display();
 
    tooltip.AddRow("ClinVar allele:", allele);
  
    it = info_fields.find("MC");
    if (it != info_fields.end()) {
        vector<string> v;
        NStr::Split(it->second, ",", v, NStr::fSplit_Tokenize);
        string a, b;
        vector<string> o;
        for (const auto& s : v) {
            if (NStr::SplitInTwo(s, "|", a, b) && !b.empty()) {
                o.push_back(NStr::Replace(b, "_", " ", str_buff));
            }
        }
        if (!o.empty()) {
            tooltip.AddRow("Molecular consequence:", NStr::Join(o, ","));
        }
    }
 
    str_buff.clear();
    ENa_strand strand = sequence::GetStrand(GetLocation());
 
    if (strand == eNa_strand_minus) {
        str_buff = "complement(";
    }
    str_buff += NStr::NumericToString(m_Object->GetPos() + 1, NStr::fWithCommas);
    if (m_Object->GetLen() > 1) {
        str_buff += "..";
        str_buff += NStr::NumericToString(m_Object->GetPos() + m_Object->GetLen(), NStr::fWithCommas);
    }
    if (strand == eNa_strand_minus) {
        str_buff += ")";
    }
    tooltip.AddRow("Location:", str_buff);
}
 
 
void CVcfGlyph::GetTooltip(const TModelPoint& p, ITooltipFormatter& tooltip, string& t_title) const
{
    t_title = m_Object->GetID();
 
    if (m_Object->IsClinVar()) {
        x_GetClinVarToolTip(tooltip);
    } else {
        const auto &info_fields = m_Object->GetInfoColumns();
        tooltip.AddRow("Variation ID:", m_Object->GetID());
        if (m_Object->IsDbVar() == false) {
            tooltip.AddRow("Alleles:", m_Object->GetAllAlleles_display());
            bool all_alt_alleles_same_len(true);
            int allele_len = m_Object->GetLongestAlleleLen(all_alt_alleles_same_len);
            if (allele_len > 0) {
                tooltip.AddRow(string(all_alt_alleles_same_len ? "A" : "Longest a") + "llele length:", NStr::NumericToString(allele_len, NStr::fWithCommas));
            }
        }
        bool var_type_shown{ false };
    
        if (info_fields.size() > 0) {
            if (info_fields.count("SVTYPE")) {
                static const map<string, string> labels{
                    { "DEL", "Deletion" },
                    { "INS", "Insertion" },
                    { "DUP", "Duplication" },
                    { "INV", "Inversion" },
                    { "CNV", "Copy number variation" },
                    { "BND", "Translocation" }
                };
                string svtype = info_fields.at("SVTYPE");
                NStr::ToUpper(svtype);
                if (labels.count(svtype) > 0) {
                    tooltip.AddRow("Variant Type:", labels.at(svtype));
                    var_type_shown = true;
                }
            }
            if (info_fields.count("END"))
                tooltip.AddRow("Endpoint:", info_fields.at("END"));
            if (info_fields.count("CIPOS"))
                tooltip.AddRow("Confidence intervals around POS:", info_fields.at("CIPOS"));
            if (info_fields.count("CIEND"))
                tooltip.AddRow("Confidence intervals around END:", info_fields.at("CIEND"));
            if (info_fields.count("SVLEN")) {
                string svlen = info_fields.at("SVLEN");
                if (svlen.size() > 0) {
                    if (svlen[0] == '-')
                        svlen.erase(0, 1);
                    tooltip.AddRow("Variant length:", svlen);
                }
            }
        }
        if (!var_type_shown) {
            tooltip.AddRow("Variant Type:", m_Object->GetVariationTypeAsString());
        }
        tooltip.AddRow("Position:", NStr::SizetToString(m_Object->GetPos() + 1, NStr::fWithCommas));
    }
    {
        const auto &info_fields = m_Object->GetInfoColumns();
        if (info_fields.count("DBVARID")) {
            tooltip.AddLinksTitle("Links");
            auto dbvarid = info_fields.at("DBVARID");
            string dbvar_link{ "https://www.ncbi.nlm.nih.gov/dbvar/variants/" };
            if (dbvarid == kEmptyStr)
                dbvarid = m_Object->GetID();
            dbvar_link += NStr::HtmlEncode(dbvarid);
            tooltip.AddLinkRow("dbVar:", dbvarid, dbvar_link);
        }
    }
}
 
 
TSeqRange CVcfGlyph::GetRange(void) const
{
    TSeqRange SeqRange(static_cast<TSeqPos>(m_Object->GetPos()), static_cast<TSeqPos>(m_Object->GetPos() + m_Object->GetLen() - 1));
    return SeqRange;
}
 
 
bool CVcfGlyph::GetCustomColor(CRgbaColor& color) const
{
    while (m_CustomColorIsSet == false)  {
        m_CustomColorIsSet = true;
        CGuiRegistry& registry(CGuiRegistry::GetInstance());
        if (m_Object->IsClinVar()) {
            const auto &info_fields = m_Object->GetInfoColumns();
            auto clnsig_it = info_fields.find("CLNSIG");
            string clinsig = "other";
            if (clnsig_it != info_fields.end()) {
                clinsig = NSnpGui::SelectClinSigTerm(clnsig_it->second);
            }
            
            CRegistryReadView ColorView(CSGConfigUtils::GetColorReadView(registry, "GBPlugins.ClinVarFeature", "Default", m_Config->m_ColorTheme));
            m_CustomColorPtr.reset(new CRgbaColor(0.349f, 0.349f, 0.349f)); // grey
            CSGConfigUtils::GetColor(ColorView, clinsig, *m_CustomColorPtr);
            break;
            
        } else if (m_Object->IsDbVar()) {
            const auto &info_fields = m_Object->GetInfoColumns();
            auto svtype_it = info_fields.find("SVTYPE");
            CRegistryReadView ColorView(CSGConfigUtils::GetColorReadView(registry, "GBPlugins.dbVarFeature", "Default", m_Config->m_ColorTheme));
            m_CustomColorPtr.reset(new CRgbaColor(0.788f, 0.788f, 0.788f)); // light grey
            CSGConfigUtils::GetColor(ColorView, svtype_it->second, *m_CustomColorPtr);
            break;
        }
 
        CRegistryReadView ColorView(CSGConfigUtils::GetColorReadView(registry, "GBPlugins.SnpTrack", "Default", m_Config->m_ColorTheme));
        string sColorKey("Default");
 
        switch(m_Object->GetVariationType()) {
            case CVariation_inst::eType_snv:
                sColorKey = "SingleBase";
                break;
            case CVariation_inst::eType_mnp:
                sColorKey = "MultiBase";
                break;
            case CVariation_inst::eType_ins:
                sColorKey = "Insertion";
                break;
            case CVariation_inst::eType_del:
                sColorKey = "Deletion";
                break;
            case CVariation_inst::eType_delins:
                sColorKey = "Dips";
                break;
            default:
                break;
        }
        if(sColorKey != "Default") {
            m_CustomColorPtr.reset(new CRgbaColor);
            CSGConfigUtils::GetColor(ColorView, sColorKey, *m_CustomColorPtr);
        } 
    }
    if (m_CustomColorPtr) {
        color.Set(m_CustomColorPtr->GetRed(), m_CustomColorPtr->GetGreen(), m_CustomColorPtr->GetBlue());
        return true;
    }
    return false;
}
 
 
void CVcfGlyph::GetLabel(string& label, CLabel::ELabelType label_type) const
{
    m_Object->GetLabel(label, label_type);
}
 
void CVcfGlyph::GetHTMLActiveAreas(TAreaVector* p_areas) const
{
//    string sLabel;
//    GetLabel(sLabel, CLabel::eContent);
//    LOG_POST(Trace << "<<<< CVcfGlyph::GetHTMLActiveAreas() " << this << " \"" << sLabel << " isDbVar: " << IsDbVar(GetFeature()));
 
    CHTMLActiveArea area;
    CSeqGlyph::x_InitHTMLActiveArea(area);
    area.m_PositiveStrand = true;
 
    area.m_Signature = GetSignature();
    
    // a tooltip should be generated for VCF records  to avoid an additional roundtrip and reloading of VCF blob
    string s;
    string title;
    CIRef<ITooltipFormatter> tooltip = ITooltipFormatter::CreateTooltipFormatter(ITooltipFormatter::eTooltipFormatter_CSSTable);
    tooltip->SetTrustedData(false);
    GetTooltip(TModelPoint(-1, -1), *tooltip, title);
    s = tooltip->Render();
    string text = NStr::Replace(s, "\n", "<br/>");
    area.m_Descr = text;
    p_areas->push_back(area);
//        LOG_POST(Trace << ">>>> CVcfGlyph::GetHTMLActiveAreas() area with signature \"" << area.m_Signature << "\" generated for \"" << sLabel <<
//                            "\", rect: " << area.m_Bounds.Left() << ":" << area.m_Bounds.Right() << ":" << area.m_Bounds.Top() << ":" << area.m_Bounds.Bottom());
}
 
 
bool CVcfGlyph::IsClickable() const
{
    return true;
}
 
 
bool CVcfGlyph::SetSelected(bool f)
{
//    LOG_POST(Trace << "==== CVcfGlyph::SetSelected() " << this << " from " << IsSelected() << " to " << f);
    if (f != IsSelected()) {
        CSeqGlyph::SetSelected(f);
    }
    return false;
}
 
void CVcfGlyph::LayoutChanged()
{
    x_OnLayoutChanged();
}
 
void CVcfGlyph::x_DrawHighlight() const
{
    GetRenderingContext()->DrawHighlight(GetModelRect());
}
 
 
void CVcfGlyph::SetHideLabel(bool b)
{
    m_HideLabel = b;
}
 
 
bool CVcfGlyph::HasSideLabel() const
{
    return !m_HideLabel  &&  m_Config->m_LabelPos == CFeatureParams::ePos_Side;
}
 
/// some features may have additional info on the right (currently alleles for variations)
/// that will be shown at the same time as labels
void CVcfGlyph::GetAdditionalInfo(string& sAdditionalInfo) const
{
    if (m_Object->IsClinVar()) {
        if (!m_Object->GetAltAlleles_display().empty() && m_Object->GetAltAlleles_display().front() != ".")
            sAdditionalInfo = m_Object->GetAltAlleles_display().front();
        else  
            sAdditionalInfo = m_Object->GetRefAllele_display(); 
    } else if (m_Object->IsDbVar()) {
         sAdditionalInfo.clear();
    } else {
        sAdditionalInfo = m_Object->GetRefAllele_display() + "/" + NStr::Join(m_Object->GetAltAlleles_display(), "/");
    }
}
 
bool CVcfGlyph::x_isDrawn() const
{
    return true;
}
 
void CVcfGlyph::x_Draw() const
{
    _ASSERT(m_Context);
/*
    LOG_POST(Trace << "<<<<");
// print drawing info
    {
        string sLabel;
        GetLabel(sLabel, CLabel::eContent);
        LOG_POST(Trace << "Attempting to draw " << this << " \"" << sLabel << "\" x_isDrawn: " << x_isDrawn() <<
                          ", m_Height: " << GetHeight() << ", m_Width: " << GetWidth() <<
                          ", m_Pos.m_X: " << GetLeft() << ", m_Pos.m_Y: " << GetTop());
    }
*/
    if (GetHeight() == 0  ||  m_Context->IntersectVisible(GetRange()).Empty() || !x_isDrawn()) {
//        LOG_POST(Trace << ">>>> no draw");
        return;
    }
    // for debugging
    /*
    CScope& scope = GetMappedFeature().GetAnnot().GetScope();
    string sig = CObjFingerprint::GetFeatSignature(GetFeature(), &scope, m_sFilter);
    int subtype;
    CSeq_id_Handle id;
    TSeqPos f, t;
    CObjFingerprint::EObjectType type;
    Uint4   fingerprint;
    CObjFingerprint::ParseSignature(sig, id, f, t, type, subtype, fingerprint);
    cout << ", From: " << f
         << ", To: " << t
         << ", Subtype: " << subtype << endl;
    */
    TModelUnit base = GetTop();
 
    TModelUnit bar_height = x_GetBarHeight();
    x_MaybeDrawLabelAbove(base);
    base += bar_height * 0.5;   // bar center
 
    x_DrawVariationBar(base);
 
    x_MaybeDrawLabelOthers(base);
    x_DrawAdditionalInfo(base);
 
    if (IsSelected()) {
        m_Context->DrawSelection(GetModelRect());
    }
//    LOG_POST(Trace << ">>>> draw done");
}
 
void CVcfGlyph::x_UpdateBoundingBox()
{
    _ASSERT(m_Context);
    // LOG_POST(Trace << "<<<<");
 
    if(x_isDrawn()) {
        TSeqRange SeqRange = GetRange();
        TModelUnit bar_height = x_GetBarHeight();
        SetHeight(bar_height);
        SetWidth(SeqRange.GetLength());
        SetLeft(SeqRange.GetFrom());
 
        bool showLabel = x_ShowLabel();
 
        // we preserve label space if it fits either on side or above
        if (showLabel) {
            IRender& gl = GetGl();
 
            const CGlTextureFont& font = m_Config->m_LabelFont;
            if (m_Config->m_LabelPos == CFeatureParams::ePos_Side) {
                string label;
                GetLabel(label, CLabel::eContent);
                TModelUnit text_w_px = min(gl.TextWidth(&font, label.c_str()), m_Context->GetMaxLabelWidth(font));
                TModelUnit text_w_pos = m_Context->ScreenToSeq(text_w_px + CRenderingContext::kLabelSpacePx);
                SetWidth(GetWidth() + text_w_pos);
                TModelUnit min_text_w_pos = m_Context->GetMinLabelWidthPos(font);
 
                if (x_LabelOnLeft()) {
                    SetLeft(GetLeft() - text_w_pos);
                    TModelRange visible_range_pos = m_Context->IntersectVisible(this);
 
                    if (GetLeft() < 0) {
                        if (visible_range_pos.GetLength() < min_text_w_pos) {
                            // Can't even show the minimal length of label
                            SetWidth(GetWidth() + GetLeft());
                            SetLeft(0.0);
                        }
                    }
                }
                // also reserve some space for additional info
                string sAdditionalInfo;
                GetAdditionalInfo(sAdditionalInfo);
                if (!sAdditionalInfo.empty()) {
                    TModelUnit info_width_px = min(gl.TextWidth(&font, sAdditionalInfo.c_str()), m_Context->GetMaxLabelWidth(font));
                    TModelUnit info_width_pos = m_Context->ScreenToSeq(info_width_px + CRenderingContext::kLabelSpacePx);
                    SetWidth(GetWidth() + info_width_pos);
                    if(!x_LabelOnLeft()) {
                        SetLeft(GetLeft() - info_width_pos);
                        if (GetLeft() < 0) {
                            SetWidth(GetWidth() + GetLeft());
                            SetLeft(0.0);
                        }
                    }
                }
            } else if (m_Config->m_LabelPos == CFeatureParams::ePos_Above) {
                SetHeight(GetHeight() + gl.TextHeight(&font) + kVertSpace + 1);
            }
        }
    } else {
        SetHeight(0);
        SetWidth(0);
        SetLeft(0.0);
        SetTop(0.0);
    }
    // print bounding box info
//    {
//        string sLabel;
//        GetLabel(sLabel, CLabel::eContent);
//        LOG_POST(Trace << "Bounding box for " << this << " \"" << sLabel << "\" x_isDrawn: " << x_isDrawn() <<
//                          ", m_Height: " << GetHeight() << ", m_Width: " << GetWidth() <<
//                          ", m_Pos.m_X: " << GetLeft() << ", m_Pos.m_Y: " << GetTop());
//        LOG_POST(Trace << "Call stack for " << this << ": " << CStackTrace());
 
//        LOG_POST(Trace << ">>>>");
//    }
}
 
bool CVcfGlyph::x_RedundantLabelCheck(const string& label) const
{
    // If label is redundant with the title (is contained in the title) for the
    // track, and all glyphs in the track are the same type, do not display the label.
    // This only applies though if the label for the track starts with '[' and ends with ']'
    const CSeqGlyph* parent = m_Parent;
    bool redundant = false;
    bool all_same_type = false;
 
    if (label.length() > 0 && label[0] == '[' && label[label.size()-1] == ']') {
        while (parent != NULL) {
            const CLayoutGroup* lg = dynamic_cast<const CLayoutGroup*>(parent);
            if (lg != NULL) {
                all_same_type = lg->AllChildrenSameType();
            }
 
            const CLayoutTrack* lt = dynamic_cast<const CLayoutTrack*>(parent);
            if (lt != NULL) {
                // trim blanks, brackets etc from glyph display string - e.g. [intron] to intron
                string track_title = lt->GetFullTitle();
                size_t start_idx = label.find_first_not_of(" ()[]'\" <>,.@#$&*");
                size_t stop_idx = label.find_last_not_of(" ()[]'\" <>,.@#$&*");
                size_t len = stop_idx-start_idx;
 
                if (len > 0 &&
                    NStr::FindNoCase(track_title, label.substr(start_idx, len)) != NPOS) {
                        redundant = true;
                }
                break;
            }
            parent = parent->GetParent();
        }
    }
 
    return (all_same_type && redundant);
}
 
 
bool CVcfGlyph::x_LabelOnLeft() const
{
    return true;
}
 
void CVcfGlyph::x_MaybeDrawLabelAbove(TModelUnit& base) const
{
    if ( !x_ShowLabel() || m_Config->m_LabelPos != CFeatureParams::ePos_Above) {
        return;
    }
    x_DrawLabelWithXPinned(base);
}
 
void CVcfGlyph::x_MaybeDrawLabelOthers(TModelUnit base) const
{
    if ( !x_ShowLabel()) {
        return;
    }
    if (CFeatureParams::ePos_Side != m_Config->m_LabelPos)
            return;
 
    x_DrawLabelWithYPinned(base);
}
 
 
 
void CVcfGlyph::x_DrawLabelWithXPinned(TModelUnit& base) const
{
    if (m_Config->m_LabelPos != CFeatureParams::ePos_Above) {
        return;
    }
    IRender& gl = GetGl();
 
    // visible part of the whole glyph (feature bar + label + additional info)
    TModelRange visible_range = m_Context->IntersectVisible(this);
 
    const CGlTextureFont& font = m_Config->m_LabelFont;
    TModelUnit font_height = gl.TextHeight(&font);
 
    if (m_Context->WillLabelFit(visible_range)) {
        // label text that will be shown
        string sLabelTextOut;
 
        GetLabel(sLabelTextOut, CLabel::eContent);
        // shorten the text if it is wider than visible range
        sLabelTextOut = font.Truncate(sLabelTextOut.c_str(), m_Context->SeqToScreen(visible_range.GetLength()));
 
        // both above and inside labels should be centered relatively to feature bar on x axis
        TModelUnit LabelX = visible_range.GetFrom() + visible_range.GetLength() * 0.5;
        TModelUnit LabelY = base;
        if (m_Config->m_LabelPos == CFeatureParams::ePos_Above) {
            // move the base to give space for the text above the feature bar
            base += font_height;
            LabelY = base;
            base += kVertSpace + 1;
        }
        if (IsSelected()) {
            gl.ColorC(m_Context->GetSelLabelColor());
        }  else if (m_Config->m_LabelPos == CFeatureParams::ePos_Inside) {
            gl.ColorC(m_Config->m_fgColor.ContrastingColor());
        } else {
            gl.ColorC(m_Config->m_LabelColor);
        }
        m_Context->TextOut(&font, sLabelTextOut.c_str(), LabelX, LabelY, true, true);
    }
}
 
void CVcfGlyph::x_DrawInnerLabels(TModelUnit base, vector<TModelRange> *labels_range, TSeqRange* interval) const
{
    if (m_HideLabel)
        return;
    if ((m_Config->m_LabelPos != CFeatureParams::ePos_Side) && (m_Config->m_LabelPos != CFeatureParams::ePos_Inside)) 
        return;
    TSeqRange exon_int;
    if (interval) {
        exon_int = interval->IntersectionWith(m_Context->GetVisSeqRange());
        if (exon_int.Empty())
            return;
    }
 
    // visible part of the whole glyph (feature bar + label + additional info)
    TModelRange visible_range = m_Context->IntersectVisible(this);
 
    const CGlTextureFont &font = m_Config->m_LabelFont;
 
    // location of feature bar, must not be overwritten by the label
    TSeqRange FeatureBarRange(GetRange());
    TModelUnit FeatureBarLeft(FeatureBarRange.GetFrom());
    TModelUnit FeatureBarRight(FeatureBarRange.GetToOpen());
 
    bool side_lbl{ false };
    if (CFeatureParams::ePos_Side == m_Config->m_LabelPos) {
        // how much of the space (in sequence coords) is available for the label
        TModelUnit LabelVisibleWidth{ 0 };
        if (x_LabelOnLeft()) {
            LabelVisibleWidth = (FeatureBarLeft < visible_range.GetFrom() ? 0 : FeatureBarLeft - visible_range.GetFrom());
        }
        else {
            LabelVisibleWidth = (FeatureBarRight > visible_range.GetTo() ? 0 : visible_range.GetTo() - FeatureBarRight);
        }
        side_lbl = (LabelVisibleWidth >= m_Context->GetMinLabelWidthPos());
    }
 
    string fl_content;
    GetLabel(fl_content, CLabel::eContent);
 
    CRgbaColor inner_color(m_Config->m_fgColor);
    GetCustomColor(inner_color);
    inner_color = inner_color.ContrastingColor();
 
    bool inside_only = m_Config->m_LabelPos == CFeatureParams::ePos_Inside;
    CSeqGlyph::x_DrawInnerLabels(base, fl_content, inner_color, font, side_lbl, inside_only, labels_range, exon_int.Empty() ? nullptr : &exon_int);
}
 
void CVcfGlyph::x_DrawLabelWithYPinned(TModelUnit base) const
{
    if(m_Config->m_LabelPos != CFeatureParams::ePos_Side) return;
 
    IRender& gl = GetGl();
 
    // visible part of the whole glyph (feature bar + label + additional info)
    TModelRange visible_range_pos = m_Context->IntersectVisible(this);
 
    const CGlTextureFont &font = m_Config->m_LabelFont;
    TModelUnit font_height = gl.TextHeight(&font);
 
    // location of feature bar, must not be overwritten by the label
    TSeqRange FeatureBarRange(GetRange());
    TModelUnit FeatureBarLeft(FeatureBarRange.GetFrom());
    // this is an open position i.e. +1 of the real end pos
    TModelUnit FeatureBarRight(FeatureBarRange.GetToOpen());
 
    // how much of the space (in sequence position coords) is available for the label
    TModelUnit AvailableLabelVisibleWidthPos(x_LabelOnLeft() ?
        (FeatureBarLeft < visible_range_pos.GetFrom() ? 0 : FeatureBarLeft - visible_range_pos.GetFrom())
        :
        (FeatureBarRight > visible_range_pos.GetToOpen() ? 0 :  visible_range_pos.GetToOpen() - FeatureBarRight));
 
    string fl_content;
    GetLabel(fl_content, CLabel::eContent);
 
    CRgbaColor inner_color(m_Config->m_fgColor);
    GetCustomColor(inner_color);
    inner_color = inner_color.ContrastingColor();
 
 
    if (AvailableLabelVisibleWidthPos < m_Context->GetMinLabelWidthPos(font)) {
        return;
    }
 
    // these widths are in screen pixels
    TModelUnit label_width_px = gl.TextWidth(&font, fl_content.c_str());
    TModelUnit max_width_px = min(m_Context->SeqToScreen(AvailableLabelVisibleWidthPos),
        m_Context->GetMaxLabelWidth(font));
    if (label_width_px > max_width_px) {
        label_width_px = max_width_px;
        fl_content = font.Truncate(fl_content.c_str(), label_width_px);
        if ((string::npos != fl_content.find("...")) && (fl_content.length() <= 5))
            return;
    }
    // convert back to sequence position coords
    TModelUnit label_width_pos = m_Context->ScreenToSeq(label_width_px);
    TModelUnit label_x_pos = 0.0;
    TModelUnit label_base = base;
    TModelUnit label_clear_base = base;
    TModelUnit label_clear_height = font_height;
    label_base += (font_height * 0.5);
 
    // draw background - larger of font height or
    // bar height (if label on same line, e.g. not label first)
    TModelUnit bar_height = m_Config->m_BarHeight;
    label_clear_base = label_base;
    if (bar_height > font_height) {
        label_clear_height = bar_height;
        label_clear_base = floor(base) + (label_clear_height * 0.5);
    }
    if (x_LabelOnLeft()) {
        label_x_pos = visible_range_pos.GetFrom();
        if (label_x_pos > GetLeft()) {
            gl.ColorC(m_Config->m_bgColor);
            m_Context->DrawBackground(
                TModelRect(label_x_pos, label_clear_base + 1, label_x_pos + label_width_pos,
                    label_clear_base - label_clear_height - 1), 0);
        }
    } else {
        label_x_pos = visible_range_pos.GetToOpen() - label_width_pos;
        if (visible_range_pos.GetTo() < GetRight()) {
            gl.ColorC(m_Config->m_bgColor);
            m_Context->DrawBackground(
                TModelRect(label_x_pos, label_clear_base + 1, visible_range_pos.GetToOpen(),
                    label_clear_base - label_clear_height - 1), 0);
        }
    }
    gl.ColorC(IsSelected() ?
        m_Context->GetSelLabelColor() : m_Config->m_LabelColor);
 
    m_Context->TextOut(&font, fl_content.c_str(), label_x_pos,
        label_base, false, true);
}
 
void CVcfGlyph::x_DrawAdditionalInfo(TModelUnit base) const
{
    if ( !x_ShowLabel() ) {
        return;
    }
 
    if (m_Config->m_LabelPos != CFeatureParams::ePos_Side) 
        return;
 
    string sAdditionalInfo;
    GetAdditionalInfo(sAdditionalInfo);
    if (sAdditionalInfo.empty())
        return;
 
    // visible part of the whole glyph (feature bar + label + additional info)
    TModelRange visible_range = m_Context->IntersectVisible(this);
    const CGlTextureFont& font = m_Config->m_LabelFont;
 
    // location of feature bar, must not be overwritten by the additional info
    TSeqRange FeatureBarRange(GetRange());
    TModelUnit FeatureBarLeft(FeatureBarRange.GetFrom());
    TModelUnit FeatureBarRight(FeatureBarRange.GetToOpen());
 
    // how much of the space (in sequence coords) is available for the additional info
    // left/right location of additional info is complementary to that of the label
    TModelUnit AvailableAdditionalInfoVisibleWidthPos(!x_LabelOnLeft() ?
                    (FeatureBarLeft < visible_range.GetFrom() ? 0 : FeatureBarLeft - visible_range.GetFrom())
                    :
                    (FeatureBarRight > visible_range.GetToOpen() ? 0 :  visible_range.GetToOpen() - FeatureBarRight));
 
    // add CRenderingContext::kLabelSpacePx(5px) to make sure that single letter labels exceed MinLabelWidth 
    AvailableAdditionalInfoVisibleWidthPos += m_Context->ScreenToSeq(5); 
    if(AvailableAdditionalInfoVisibleWidthPos < m_Context->GetMinLabelWidthPos(font)) {
        return;
    }
 
    IRender& gl = GetGl();
    TModelUnit font_height = gl.TextHeight(&font);
//        LOG_POST(Trace << "sAdditionalInfo: " << sAdditionalInfo);
//        LOG_POST(Trace << "AvailableAdditionalInfoVisibleWidthPos: " << AvailableAdditionalInfoVisibleWidthPos);
    // widths are in screen pixels
    TModelUnit info_width_px = gl.TextWidth(&font, sAdditionalInfo.c_str());
//        LOG_POST(Trace << "initial info_width_px: " << info_width_px);
 
    TModelUnit max_width_px = min(m_Context->SeqToScreen(AvailableAdditionalInfoVisibleWidthPos),
                                m_Context->GetMaxLabelWidth(font));
//        LOG_POST(Trace << "max_width_px: " << max_width_px);
    if (info_width_px > max_width_px) {
        info_width_px = max_width_px;
        sAdditionalInfo = font.Truncate(sAdditionalInfo.c_str(), info_width_px);
    }
//        LOG_POST(Trace << "modified sAdditionalInfo: " << sAdditionalInfo << " and info_width_px: " << info_width_px);
    // convert back to sequence coords
    TModelUnit info_width_pos = m_Context->ScreenToSeq(info_width_px);
    TModelUnit info_x_pos = 0.0;
    TModelUnit info_base = base;
    TModelUnit info_clear_base = base;
    TModelUnit info_clear_height = font_height;
    info_base += (font_height * 0.5);
 
//        LOG_POST(Trace << "info_width_pos: " << info_width_pos);
    // draw background - larger of font height or
    // bar height (if label on same line, e.g. not label first)
    TModelUnit bar_height = m_Config->m_BarHeight;
    info_clear_base = info_base;
    if (bar_height > font_height) {
        info_clear_height = bar_height;
        info_clear_base = floor(base) + (info_clear_height * 0.5);
    }
    if (!x_LabelOnLeft()) {
        info_x_pos = visible_range.GetFrom();
        if (info_x_pos > GetLeft()) {
//                LOG_POST(Trace << " drawing background at left: " << info_x_pos << " with offset: " << m_Context->GetOffset());
            gl.ColorC(m_Config->m_bgColor);
            m_Context->DrawBackground(
                TModelRect(info_x_pos, info_clear_base + 1, info_x_pos + info_width_pos,
                    info_clear_base - info_clear_height - 1), 0);
        }
    } else {
        info_x_pos = visible_range.GetToOpen() - info_width_pos;
        if (visible_range.GetTo() < GetRight()) {
//                LOG_POST(Trace << " drawing background at right: " << info_x_pos << " with offset: " << m_Context->GetOffset());
            gl.ColorC(m_Config->m_bgColor);
            m_Context->DrawBackground(
                TModelRect(info_x_pos, info_clear_base + 1, visible_range.GetToOpen(),
                    info_clear_base - info_clear_height - 1), 0);
        }
    }
    gl.ColorC(IsSelected() ?  m_Context->GetSelLabelColor() : m_Config->m_LabelColor);
 
//        LOG_POST(Trace << "info_x_pos: " << info_x_pos);
    m_Context->TextOut(&font, sAdditionalInfo.c_str(), info_x_pos, info_base, false, true);
}
 
 
void CVcfGlyph::x_DrawInsertion(TModelUnit SeqPosTriangleMidPointX,
                                 TModelUnit BoundaryYLow,
                                 TModelUnit BoundaryYHigh,
                                 TModelUnit YCenterLine) const
{
    // half the insertion triangle width in sequence coordinates
    TModelUnit SeqTriangleHalf = m_Context->ScreenToSeq(4.0);
 
    TModelUnit TriangleOffsetY = 1.0;
    m_Context->DrawLine(SeqPosTriangleMidPointX, BoundaryYLow, SeqPosTriangleMidPointX, BoundaryYHigh);
    m_Context->DrawTriangle(SeqPosTriangleMidPointX, YCenterLine,
        SeqPosTriangleMidPointX + SeqTriangleHalf, BoundaryYLow - TriangleOffsetY,
        SeqPosTriangleMidPointX - SeqTriangleHalf, BoundaryYLow - TriangleOffsetY);
    m_Context->DrawTriangle(SeqPosTriangleMidPointX, YCenterLine,
        SeqPosTriangleMidPointX + SeqTriangleHalf, BoundaryYHigh + TriangleOffsetY,
        SeqPosTriangleMidPointX - SeqTriangleHalf, BoundaryYHigh + TriangleOffsetY);
}
 
void CVcfGlyph::x_DrawDeletion(TModelUnit SeqPosTriangleMidPointX,
                                 TModelUnit BoundaryYLow,
                                 TModelUnit BoundaryYHigh) const
{
    // half the insertion triangle width in sequence coordinates
    TModelUnit SeqTriangleHalf = m_Context->ScreenToSeq(4.0);
 
    TModelUnit TriangleOffsetY = 1.0;
//    IRender& gl = GetGl();
//    gl.ShadeModel(GL_SMOOTH);
    m_Context->DrawTriangle(SeqPosTriangleMidPointX, BoundaryYHigh + TriangleOffsetY,
        SeqPosTriangleMidPointX + SeqTriangleHalf, BoundaryYLow - TriangleOffsetY,
        SeqPosTriangleMidPointX - SeqTriangleHalf, BoundaryYLow - TriangleOffsetY);
//    gl.ShadeModel(GL_FLAT);
 
}
 
bool CVcfGlyph::HitTestHor(TSeqPos x, const CObject *obj)
{
    return CSeqGlyph::HitTestHor(x, obj);
}
 
bool CVcfGlyph::LessBySeqPos(const CSeqGlyph& obj) const
{
    // use default, compare by SeqRanges
    return CSeqGlyph::LessBySeqPos(obj);
}
 
void CVcfGlyph::x_DrawVariationBar(TModelUnit base) const
{
    IRender& gl = GetGl();
 
    TModelUnit bar_height = m_Config->m_BarHeight;
    if (m_Context->IsOverviewMode()  &&  m_HideLabel) {
        bar_height = floor(bar_height * m_Config->m_OverviewFactor);
    }
    TModelUnit YCenterLine = base;
    TModelUnit BoundaryYLow = YCenterLine - bar_height * 0.5f;
    TModelUnit BoundaryYHigh = YCenterLine + bar_height * 0.5f;
 
    CRgbaColor color;
    if ( !GetCustomColor(color) ) {
        color = m_Config->m_fgColor;
    }
    // a lighter version of color
    CRgbaColor color_t = color;
    if (m_Object->IsClinVar() == false && m_Object->IsDbVar() == false)
        color_t.SetAlpha(0.35f);
 
    // Draw variation bar
    TSeqRange SeqRange = GetRange();
    TSeqPos SeqPosFrom = SeqRange.GetFrom();
    TSeqPos SeqPosTo = SeqRange.GetTo();
    x_IntersectVisible<TSeqPos>(SeqRange, SeqPosFrom, SeqPosTo);
 
    if (SeqRange.GetLength() > m_Context->ScreenToSeq(2.0)) {  // At least 2 pixel
        if (m_Object->IsClinVar()) {
            gl.ColorC(color_t);
            m_Context->DrawQuad(SeqPosFrom, BoundaryYLow, (SeqPosTo >= m_Context->GetVisibleTo()) ? SeqPosTo : SeqPosTo + 1.0, BoundaryYHigh);
        } else {
            m_Context->Draw3DQuad(SeqPosFrom, BoundaryYLow, SeqPosTo, BoundaryYHigh, color);
        } 
        
        if (m_Object->GetVariationType() == CVariation_inst::eType_ins) {
            // draw insertion
            CRgbaColor color_insert;
            GetCustomColor(CCustomFeatureColor::eInsertion, color_insert);
            gl.ColorC(color_insert);
            x_DrawInsertion((SeqPosFrom + SeqPosTo) * 0.5 + 0.5, BoundaryYLow, BoundaryYHigh, YCenterLine);
        } else if (m_Object->GetVariationType() == CVariation_inst::eType_del) {
            static CRgbaColor color_delete("black");
            gl.ColorC(color_delete);
            x_DrawDeletion((SeqPosFrom + SeqPosTo) * 0.5 + 0.5, BoundaryYLow, BoundaryYHigh);
        } 
        gl.ColorC(color_t);
        x_DrawInnerLabels(base);
    } else {
        if (m_Object->IsClinVar()) {
            gl.ColorC(color_t);
            m_Context->DrawQuad(SeqPosFrom, BoundaryYLow, SeqPosTo, BoundaryYHigh, true);
        } else
            m_Context->Draw3DQuad(SeqPosFrom, BoundaryYLow, SeqPosTo, BoundaryYHigh, color, true);
    }
}
 
 
TModelUnit CVcfGlyph::x_GetBarHeight() const
{
    TModelUnit height = m_Config->GetBarHeight(
        m_Context->IsOverviewMode()  &&  m_HideLabel);
 
    return height;
}
 
 
 
bool CVcfGlyph::x_ShowLabel() const
{
    bool shown = false;
    if (m_Config->m_LabelPos != CFeatureParams::ePos_NoLabel) {
        if (m_Config->m_LabelPos == CFeatureParams::ePos_Side) {
            // in MSA context, the whole range can be very small and label can be skipped altogether
            //if (m_Context->WillLabelFit(m_Context->GetVisibleRange())) {
                shown = !m_HideLabel;
            //} 
        } else { // can be either ePos_Above or ePos_Inside
            TModelRange r = m_Context->IntersectVisible(this);
            if (m_Context->WillLabelFit(r)) {
                shown = !m_HideLabel  ||  IsSelected();
            }
            if (shown) {
                string fl_content;
                GetLabel(fl_content, CLabel::eContent);
                IRender& gl = GetGl();
                TModelUnit available_width = m_Context->SeqToScreen(r.GetLength());
                TModelUnit label_width = gl.TextWidth(&(m_Config->m_LabelFont), fl_content.c_str());
                if (label_width > available_width) {
                    fl_content = m_Config->m_LabelFont.Truncate(fl_content.c_str(), available_width);
                    if ((string::npos != fl_content.find("...")) && (fl_content.length() <= 5))
                        shown = false;
                }
            }
        }
 
        // Check if label is redudant with track name and if so, hide:
        if (shown) {
            string fl_content;
            GetLabel(fl_content, CLabel::eContent);
            if (x_RedundantLabelCheck(fl_content))
                shown = false;
        }
    }
    return shown;
}
 
 
const CSeq_loc& CVcfGlyph::GetLocation(void) const
{
    return m_Object->GetLocation();
}
 
 
CConstRef<CObject> CVcfGlyph::GetObject(TSeqPos) const
{
    return m_Object;
}
 
 
void  CVcfGlyph::GetObjects(vector<CConstRef<CObject> >& objs) const
{
    objs.push_back(m_Object);
}
 
 
bool CVcfGlyph::HasObject(CConstRef<CObject> obj) const
{
    return m_Object == obj;
}
 
string CVcfGlyph::GetSignature() const
{
    string sig = CObjFingerprint::GetVcfVariantSignature(*m_Object, &m_Context->GetScope());
    return sig;
}
 
 
const CVcfGlyph::TIntervals& CVcfGlyph::GetIntervals(void) const
{
    return m_Intervals;
}
 
 
 
 
END_NCBI_SCOPE