structure_set.cpp

ncbi源码

    dataManager->SetDataUnchanged();
}

StructureSet::~StructureSet(void)
{
    delete dataManager;
    delete showHideManager;
    delete styleManager;
    if (alignmentManager) delete alignmentManager;

    GlobalMessenger()->RemoveAllHighlights(false);
    MoleculeIdentifier::ClearIdentifiers();

    BioseqMap::iterator i, ie = bioseqs.end();
    for (i=bioseqs.begin(); i!=ie; ++i) BioseqFree(i->second);
}

BioseqPtr StructureSet::GetOrCreateBioseq(const Sequence *sequence)
{
    if (!sequence || !sequence->isProtein) {
        ERRORMSG("StructureSet::GetOrCreateBioseq() - got non-protein or NULL Sequence");
        return NULL;
    }

    // if already done
    BioseqMap::const_iterator b = bioseqs.find(sequence);
    if (b != bioseqs.end()) return b->second;

    // create new Bioseq and fill it in from Sequence data
    BioseqPtr bioseq = BioseqNew();
    bioseq->mol = Seq_mol_aa;
    bioseq->seq_data_type = Seq_code_ncbieaa;
    bioseq->repr = Seq_repr_raw;
    bioseq->length = sequence->Length();
    bioseq->seq_data = BSNew(bioseq->length);
    BSWrite(bioseq->seq_data, const_cast<char*>(sequence->sequenceString.c_str()), bioseq->length);

    // create Seq-id
    sequence->AddCSeqId(&(bioseq->id), true);

    // store Bioseq
    bioseqs[sequence] = bioseq;

    return bioseq;
}

void StructureSet::CreateAllBioseqs(const BlockMultipleAlignment *multiple)
{
    for (int row=0; row<multiple->NRows(); ++row)
        GetOrCreateBioseq(multiple->GetSequenceOfRow(row));
}

bool StructureSet::AddBiostrucToASN(ncbi::objects::CBiostruc *biostruc)
{
    bool added = dataManager->AddBiostrucToASN(biostruc);
    if (added && objects.size() == 1)
        InitStructureAlignments(objects.front()->mmdbID);
    return added;
}

static const int NO_DOMAIN = -1, MULTI_DOMAIN = 0;

void StructureSet::InitStructureAlignments(int masterMMDBID)
{
    // create or empty the Biostruc-annot-set that will contain these alignments
    // in the asn data, erasing any structure alignments currently stored there
    CBiostruc_annot_set *structureAlignments = dataManager->GetStructureAlignments();
    if (structureAlignments) {
        structureAlignments->SetId().clear();
        structureAlignments->SetDescr().clear();
        structureAlignments->SetFeatures().clear();
    } else {
        structureAlignments = new CBiostruc_annot_set();
        dataManager->SetStructureAlignments(structureAlignments);
    }

    // set up the skeleton of the new Biostruc-annot-set
    // new Mmdb-id
    structureAlignments->SetId().resize(1);
    structureAlignments->SetId().front().Reset(new CBiostruc_id());
    CMmdb_id *mid = new CMmdb_id(masterMMDBID);
    structureAlignments->SetId().front().GetObject().SetMmdb_id(*mid);
    // new Biostruc-feature-set
    CRef<CBiostruc_feature_set> featSet(new CBiostruc_feature_set());
    featSet->SetId().Set(NO_DOMAIN);
    featSet->SetFeatures();    // just create an empty list
    structureAlignments->SetFeatures().resize(1, featSet);

    // flag a change in data
    SetDataChanged(eStructureAlignmentData);
}

void StructureSet::AddStructureAlignment(CBiostruc_feature *feature,
    int masterDomainID, int slaveDomainID)
{
    CBiostruc_annot_set *structureAlignments = dataManager->GetStructureAlignments();
    if (!structureAlignments) {
        WARNINGMSG("StructureSet::AddStructureAlignment() - creating new structure alignment list");
        InitStructureAlignments(objects.front()->mmdbID);
        structureAlignments = dataManager->GetStructureAlignments();
    }

    // check master domain ID, to see if alignments have crossed master's domain boundaries
    int *currentMasterDomainID = &(structureAlignments->SetFeatures().front().GetObject().SetId().Set());
    if (*currentMasterDomainID == NO_DOMAIN)
        *currentMasterDomainID = masterDomainID;
    else if ((*currentMasterDomainID % 100) != (masterDomainID % 100))
        *currentMasterDomainID = (*currentMasterDomainID / 100) * 100;

    // check to see if this slave domain already has an alignment; if so, increment alignment #
    CBiostruc_feature_set::TFeatures::const_iterator
        f, fe = structureAlignments->GetFeatures().front().GetObject().GetFeatures().end();
    for (f=structureAlignments->GetFeatures().front().GetObject().GetFeatures().begin(); f!=fe; ++f) {
        if ((f->GetObject().GetId().Get() / 10) == (slaveDomainID / 10))
            ++slaveDomainID;
    }
    CBiostruc_feature_id id(slaveDomainID);
    feature->SetId(id);

    CRef<CBiostruc_feature> featureRef(feature);
    structureAlignments->SetFeatures().front().GetObject().SetFeatures().resize(
        structureAlignments->GetFeatures().front().GetObject().GetFeatures().size() + 1, featureRef);

    // flag a change in data
    SetDataChanged(eStructureAlignmentData);
}

void StructureSet::RemoveStructureAlignments(void)
{
    dataManager->SetStructureAlignments(NULL);
    // flag a change in data
    SetDataChanged(eStructureAlignmentData);
}

void StructureSet::ReplaceAlignmentSet(AlignmentSet *newAlignmentSet)
{
    ASNDataManager::SeqAnnotList *seqAnnots = dataManager->GetOrCreateSequenceAlignments();
    if (!seqAnnots) {
        ERRORMSG("StructureSet::ReplaceAlignmentSet() - "
            << "can't figure out where in the asn the alignments are to go");
        return;
    }

    // update the AlignmentSet
    if (alignmentSet) {
        _RemoveChild(alignmentSet);
        delete alignmentSet;
    }
    alignmentSet = newAlignmentSet;

    // update the asn alignments
    seqAnnots->resize(alignmentSet->newAsnAlignmentData->size());
    ASNDataManager::SeqAnnotList::iterator o = seqAnnots->begin();
    ASNDataManager::SeqAnnotList::iterator n, ne = alignmentSet->newAsnAlignmentData->end();
    for (n=alignmentSet->newAsnAlignmentData->begin(); n!=ne; ++n, ++o)
        o->Reset(n->GetPointer());   // copy each Seq-annot CRef

    // don't set data PSSM/row order flags here; done by AlignmentManager::SavePairwiseFromMultiple()
    SetDataChanged(eAnyAlignmentData);
}

void StructureSet::ReplaceUpdates(ncbi::objects::CCdd::TPending& newUpdates)
{
    dataManager->ReplaceUpdates(newUpdates);
}

void StructureSet::RemoveUnusedSequences(void)
{
	ASNDataManager::SequenceList updateSequences;
    if (alignmentManager) alignmentManager->GetUpdateSequences(&updateSequences);
    dataManager->RemoveUnusedSequences(alignmentSet, updateSequences);
}

bool StructureSet::SaveASNData(const char *filename, bool doBinary, unsigned int *changeFlags)
{
    // force a save of any edits to alignment and updates first (it's okay if this has already been done)
    GlobalMessenger()->SequenceWindowsSave(true);
    /*if (dataManager->HasDataChanged())*/ RemoveUnusedSequences();

    // create and temporarily attach a style dictionary, and annotation set + camera info
    // to the data (and then remove it again, so it's never out of date)
    CRef < CCn3d_style_dictionary > styleDictionary(styleManager->CreateASNStyleDictionary());
    dataManager->SetStyleDictionary(*styleDictionary);
    CRef < CCn3d_user_annotations > userAnnotations(new CCn3d_user_annotations());
    if (!styleManager->SaveToASNUserAnnotations(userAnnotations.GetPointer()) ||
        (objects.size() >= 1 && !renderer->SaveToASNViewSettings(userAnnotations.GetPointer()))) {
        ERRORMSG("StructureSet::SaveASNData() - error creating user annotations blob");
        return false;
    }
    if (userAnnotations->IsSetAnnotations() || userAnnotations->IsSetView())
        dataManager->SetUserAnnotations(*userAnnotations);

    string err;
    bool writeOK = dataManager->WriteDataToFile(filename, doBinary, &err, eFNP_Replace);

    // remove style dictionary and annotations from asn
    dataManager->RemoveStyleDictionary();
    dataManager->RemoveUserAnnotations();

    if (writeOK) {
        *changeFlags = dataManager->GetDataChanged();
        dataManager->SetDataUnchanged();
    } else {
        ERRORMSG("Write failed: " << err);
    }
    return writeOK;
}

// because the frame map (for each frame, a list of diplay lists) is complicated
// to create, this just verifies that all display lists occur exactly once
// in the map. Also, make sure that total # display lists in all frames adds up.
void StructureSet::VerifyFrameMap(void) const
{
    for (unsigned int l=OpenGLRenderer::FIRST_LIST; l<=lastDisplayList; ++l) {
        bool found = false;
        for (unsigned int f=0; f<frameMap.size(); ++f) {
            DisplayLists::const_iterator d, de=frameMap[f].end();
            for (d=frameMap[f].begin(); d!=de; ++d) {
                if (*d == l) {
                    if (!found)
                        found = true;
                    else
                        ERRORMSG("frameMap: repeated display list " << l);
                }
            }
        }
        if (!found)
            ERRORMSG("display list " << l << " not in frameMap");
    }

    unsigned int nLists = 0;
    for (unsigned int f=0; f<frameMap.size(); ++f) {
        DisplayLists::const_iterator d, de=frameMap[f].end();
        for (d=frameMap[f].begin(); d!=de; ++d) ++nLists;
    }
    if (nLists != lastDisplayList)
        ERRORMSG("frameMap has too many display lists");
}

void StructureSet::SetCenter(const Vector *given)
{
    Vector siteSum;
    int nAtoms = 0;
    double dist;
    maxDistFromCenter = 0.0;

    // set new center if given one
    if (given) center = *given;

    // loop trough all atoms twice - once to get average center, then once to
    // find max distance from this center
    for (int i=0; i<2; ++i) {
        if (given && i==0) continue; // skip center calculation if given one
        ObjectList::const_iterator o, oe=objects.end();
        for (o=objects.begin(); o!=oe; ++o) {
            StructureObject::CoordSetList::const_iterator c, ce=(*o)->coordSets.end();
            for (c=(*o)->coordSets.begin(); c!=ce; ++c) {
                AtomSet::AtomMap::const_iterator a, ae=(*c)->atomSet->atomMap.end();
                for (a=(*c)->atomSet->atomMap.begin(); a!=ae; ++a) {
                    Vector site(a->second.front()->site);
                    if ((*o)->IsSlave() && (*o)->transformToMaster)
                        ApplyTransformation(&site, *((*o)->transformToMaster));
                    if (i==0) {
                        siteSum += site;
                        ++nAtoms;
                    } else {
                        dist = (site - center).length();
                        if (dist > maxDistFromCenter)
                            maxDistFromCenter = dist;
                    }
                }
            }
        }
        if (i==0) {
            if (nAtoms == 0) {
                center.Set(0.0, 0.0, 0.0);
                break;
            }
            center = siteSum / nAtoms;
        }
    }
    TRACEMSG("center: " << center << ", maxDistFromCenter " << maxDistFromCenter);
    rotationCenter = center;
}

void StructureSet::CenterViewOnAlignedResidues(void)
{
    const BlockMultipleAlignment *alignment = alignmentManager->GetCurrentMultipleAlignment();
    if (!alignment || !alignment->GetSequenceOfRow(0) || !alignment->GetSequenceOfRow(0))
        return;                     // no alignment
    const Molecule *masterMolecule = alignment->GetSequenceOfRow(0)->molecule;
    if (!masterMolecule) return;    // no structured master
    const StructureObject *masterObject;
    if (!masterMolecule->GetParentOfType(&masterObject)) return;

    // get coords of all aligned c-alphas
    deque < Vector > coords;
    Molecule::ResidueMap::const_iterator r, re = masterMolecule->residues.end();
    for (r=masterMolecule->residues.begin(); r!=re; ++r) {