开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
cn3d_ba_interface.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：23k
源码类别：

生物技术

开发平台：

C/C++

cn3d_ba_interface.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: cn3d_ba_interface.cpp,v $
  4.  * PRODUCTION Revision 1000.2  2004/06/01 18:28:07  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.33
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: cn3d_ba_interface.cpp,v 1000.2 2004/06/01 18:28:07 gouriano Exp $
  11. * ===========================================================================
  12. *
  13. *                            PUBLIC DOMAIN NOTICE
  14. *               National Center for Biotechnology Information
  15. *
  16. *  This software/database is a "United States Government Work" under the
  17. *  terms of the United States Copyright Act.  It was written as part of
  18. *  the author's official duties as a United States Government employee and
  19. *  thus cannot be copyrighted.  This software/database is freely available
  20. *  to the public for use. The National Library of Medicine and the U.S.
  21. *  Government have not placed any restriction on its use or reproduction.
  22. *
  23. *  Although all reasonable efforts have been taken to ensure the accuracy
  24. *  and reliability of the software and data, the NLM and the U.S.
  25. *  Government do not and cannot warrant the performance or results that
  26. *  may be obtained by using this software or data. The NLM and the U.S.
  27. *  Government disclaim all warranties, express or implied, including
  28. *  warranties of performance, merchantability or fitness for any particular
  29. *  purpose.
  30. *
  31. *  Please cite the author in any work or product based on this material.
  32. *
  33. * ===========================================================================
  34. *
  35. * Authors:  Paul Thiessen
  36. *
  37. * File Description:
  38. *      Interface to Alejandro's block alignment algorithm
  39. *
  40. * ===========================================================================
  41. */
  43. #ifdef _MSC_VER
  44. #pragma warning(disable:4018)   // disable signed/unsigned mismatch warning in MSVC
  45. #endif
  47. #include <ncbi_pch.hpp>
  48. #include <corelib/ncbistd.hpp>
  49. #include <corelib/ncbi_limits.h>
  51. #include <objects/seqalign/Seq_align.hpp>
  52. #include <objects/seqalign/Seq_align_set.hpp>
  53. #include <objects/seqalign/Dense_seg.hpp>
  54. #include <objects/seqalign/Score.hpp>
  55. #include <objects/general/Object_id.hpp>
  57. #ifdef __WXMSW__
  58. #include <windows.h>
  59. #include <wx/msw/winundef.h>
  60. #endif
  61. #include <wx/wx.h>
  63. #include <algo/structure/struct_dp/struct_dp.h>
  65. #include "cn3d_ba_interface.hpp"
  66. #include "block_multiple_alignment.hpp"
  67. #include "sequence_set.hpp"
  68. #include "structure_set.hpp"
  69. #include "asn_converter.hpp"
  70. #include "molecule_identifier.hpp"
  71. #include "wx_tools.hpp"
  72. #include "cn3d_tools.hpp"
  73. #include "cn3d_blast.hpp"
  75. USING_NCBI_SCOPE;
  76. USING_SCOPE(objects);
  79. BEGIN_SCOPE(Cn3D)
  81. class BlockAlignerOptionsDialog : public wxDialog
  82. {
  83. public:
  84.     BlockAlignerOptionsDialog(wxWindow* parent, const BlockAligner::BlockAlignerOptions& init);
  85.     ~BlockAlignerOptionsDialog(void);
  87.     bool GetValues(BlockAligner::BlockAlignerOptions *options);
  89. private:
  90.     IntegerSpinCtrl *iExtension, *iCutoff;
  91.     FloatingPointSpinCtrl *fpPercent;
  92.     wxCheckBox *cGlobal, *cKeep, *cMerge;
  94.     void OnCloseWindow(wxCloseEvent& event);
  95.     void OnButton(wxCommandEvent& event);
  96.     DECLARE_EVENT_TABLE()
  97. };
  99. BlockAligner::BlockAligner(void)
  100. {
  101.     // default options
  102.     currentOptions.loopPercentile = 0.6;
  103.     currentOptions.loopExtension = 10;
  104.     currentOptions.loopCutoff = 0;
  105.     currentOptions.globalAlignment = false;
  106.     currentOptions.keepExistingBlocks = false;
  107.     currentOptions.mergeAfterEachSequence = false;
  108. }
  110. static void FreezeBlocks(const BlockMultipleAlignment *multiple,
  111.     const BlockMultipleAlignment *pairwise, DP_BlockInfo *blockInfo)
  112. {
  113.     BlockMultipleAlignment::UngappedAlignedBlockList multipleABlocks, pairwiseABlocks;
  114.     multiple->GetUngappedAlignedBlocks(&multipleABlocks);
  115.     pairwise->GetUngappedAlignedBlocks(&pairwiseABlocks);
  117.     // if a block in the multiple is contained in the pairwise (looking at master coords),
  118.     // then add a constraint to keep it there
  119.     BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator
  120.         m, me = multipleABlocks.end(), p, pe = pairwiseABlocks.end();
  121.     const Block::Range *multipleRangeMaster, *pairwiseRangeMaster, *pairwiseRangeSlave;
  122.     int i;
  123.     for (i=0, m=multipleABlocks.begin(); m!=me; ++i, ++m) {
  124.         multipleRangeMaster = (*m)->GetRangeOfRow(0);
  125.         for (p=pairwiseABlocks.begin(); p!=pe; ++p) {
  126.             pairwiseRangeMaster = (*p)->GetRangeOfRow(0);
  127.             if (pairwiseRangeMaster->from <= multipleRangeMaster->from &&
  128.                     pairwiseRangeMaster->to >= multipleRangeMaster->to) {
  129.                 pairwiseRangeSlave = (*p)->GetRangeOfRow(1);
  130.                 blockInfo->freezeBlocks[i] = pairwiseRangeSlave->from +
  131.                     (multipleRangeMaster->from - pairwiseRangeMaster->from);
  132.                 break;
  133.             }
  134.         }
  135.         if (p == pe)
  136.             blockInfo->freezeBlocks[i] = -1;
  137. //        if (blockInfo->freezeBlocks[i] >= 0)
  138. //            TESTMSG("block " << (i+1) << " frozen at query pos " << (blockInfo->freezeBlocks[i]+1));
  139. //        else
  140. //            TESTMSG("block " << (i+1) << " unfrozen");
  141.     }
  142. }
  144. // global stuff for DP block aligner score callback
  145. DP_BlockInfo *dpBlocks = NULL;
  146. const BLAST_Matrix *dpPSSM = NULL;
  147. const Sequence *dpQuery = NULL;
  149. // sum of scores for residue vs. PSSM
  150. int dpScoreFunction(unsigned int block, unsigned int queryPos)
  151. {
  152.     if (!dpBlocks || !dpPSSM || !dpQuery || block >= dpBlocks->nBlocks ||
  153.         queryPos > dpQuery->Length() - dpBlocks->blockSizes[block])
  154.     {
  155.         ERRORMSG("dpScoreFunction() - bad parameters");
  156.         return DP_NEGATIVE_INFINITY;
  157.     }
  159.     int i, masterPos = dpBlocks->blockPositions[block], score = 0;
  160.     for (i=0; i<dpBlocks->blockSizes[block]; ++i)
  161.         score += dpPSSM->matrix[masterPos + i]
  162.             [LookupBLASTResidueNumberFromCharacter(dpQuery->sequenceString[queryPos + i])];
  164.     return score;
  165. }
  167. static BlockMultipleAlignment * UnpackDPResult(DP_BlockInfo *blocks, DP_AlignmentResult *result,
  168.     const Sequence *master, const Sequence *query)
  169. {
  170.     // create new alignment structure
  171.     BlockMultipleAlignment::SequenceList *seqs = new BlockMultipleAlignment::SequenceList(2);
  172.     (*seqs)[0] = master;
  173.     (*seqs)[1] = query;
  174.     auto_ptr<BlockMultipleAlignment>
  175.         bma(new BlockMultipleAlignment(seqs, master->parentSet->alignmentManager));
  177.     // unpack result blocks
  178.     for (unsigned int b=0; b<result->nBlocks; ++b) {
  179.         UngappedAlignedBlock *newBlock = new UngappedAlignedBlock(bma.get());
  180.         newBlock->width = blocks->blockSizes[b + result->firstBlock];
  181.         newBlock->SetRangeOfRow(0,
  182.             blocks->blockPositions[b + result->firstBlock],
  183.             blocks->blockPositions[b + result->firstBlock] + newBlock->width - 1);
  184.         newBlock->SetRangeOfRow(1,
  185.             result->blockPositions[b],
  186.             result->blockPositions[b] + newBlock->width - 1);
  187.         bma->AddAlignedBlockAtEnd(newBlock);
  188.         TRACEMSG("block " << (b+1)
  189.             << " position: " << (result->blockPositions[b]+1)
  190.             << " score: " << dpScoreFunction(b, result->blockPositions[b]));
  191.     }
  193.     // finalize the alignment
  194.     if (!bma->AddUnalignedBlocks() || !bma->UpdateBlockMapAndColors(false)) {
  195.         ERRORMSG("Error finalizing new alignment!");
  196.         return NULL;
  197.     }
  199.     // get scores
  200.     wxString score;
  201.     score.Printf(" raw score: %i", result->score);
  202.     bma->SetRowStatusLine(0, score.c_str());
  203.     bma->SetRowStatusLine(1, score.c_str());
  205.     // success
  206.     return bma.release();
  207. }
  209. bool BlockAligner::CreateNewPairwiseAlignmentsByBlockAlignment(BlockMultipleAlignment *multiple,
  210.     const AlignmentList& toRealign, AlignmentList *newAlignments, int *nRowsAddedToMultiple,
  211.     bool canMerge)
  212. {
  213.     // show options dialog each time block aligner is run
  214.     if (!SetOptions(NULL)) return false;
  215.     if (currentOptions.mergeAfterEachSequence && !canMerge) {
  216.         ERRORMSG("Can only merge when editing is enabled in the sequence window");
  217.         return false;
  218.     }
  220.     newAlignments->clear();
  221.     BlockMultipleAlignment::UngappedAlignedBlockList blocks;
  222.     multiple->GetUngappedAlignedBlocks(&blocks);
  223.     BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator b, be = blocks.end();
  224.     if (nRowsAddedToMultiple) *nRowsAddedToMultiple = 0;
  225.     int i;
  227.     // set up block info
  228.     dpBlocks = DP_CreateBlockInfo(blocks.size());
  229.     unsigned int *loopLengths = new unsigned int[multiple->NRows()];
  230.     BlockMultipleAlignment::UngappedAlignedBlockList::const_iterator n;
  231.     const Block::Range *range, *nextRange;
  232.     for (i=0, b=blocks.begin(); b!=be; ++i, ++b) {
  233.         range = (*b)->GetRangeOfRow(0);
  234.         dpBlocks->blockPositions[i] = range->from;
  235.         dpBlocks->blockSizes[i] = range->to - range->from + 1;
  237.         // calculate max loop lengths
  238.         if (i < blocks.size() - 1) {
  239.             n = b;
  240.             ++n;
  241.             for (int r=0; r<multiple->NRows(); ++r) {
  242.                 range = (*b)->GetRangeOfRow(r);
  243.                 nextRange = (*n)->GetRangeOfRow(r);
  244.                 loopLengths[r] = nextRange->from - range->to - 1;
  245.             }
  246.             dpBlocks->maxLoops[i] = DP_CalculateMaxLoopLength(multiple->NRows(), loopLengths,
  247.                 currentOptions.loopPercentile, currentOptions.loopExtension, currentOptions.loopCutoff);
  248.             TRACEMSG("allowed gap after block " << (i+1) << ": " << dpBlocks->maxLoops[i]);
  249.         }
  250.     }
  251.     delete loopLengths;
  253.     // set up PSSM
  254.     dpPSSM = multiple->GetPSSM();
  256.     bool errorsEncountered = false;
  258.     AlignmentList::const_iterator s, se = toRealign.end();
  259.     for (s=toRealign.begin(); s!=se; ++s) {
  260.         if (multiple && (*s)->GetMaster() != multiple->GetMaster())
  261.             ERRORMSG("master sequence mismatch");
  263.         // slave sequence info
  264.         dpQuery = (*s)->GetSequenceOfRow(1);
  265.         int startQueryPosition =
  266.             ((*s)->alignSlaveFrom >= 0 && (*s)->alignSlaveFrom < dpQuery->Length()) ?
  267.                 (*s)->alignSlaveFrom : 0;
  268.         int endQueryPosition =
  269.             ((*s)->alignSlaveTo >= 0 && (*s)->alignSlaveTo < dpQuery->Length()) ?
  270.                 (*s)->alignSlaveTo : dpQuery->Length() - 1;
  271.         TRACEMSG("query region: " << (startQueryPosition+1) << " to " << (endQueryPosition+1));
  273.         // set frozen blocks
  274.         if (!currentOptions.keepExistingBlocks) {
  275.             for (i=0; i<blocks.size(); ++i)
  276.                 dpBlocks->freezeBlocks[i] = DP_UNFROZEN_BLOCK;
  277.         } else {
  278.             FreezeBlocks(multiple, *s, dpBlocks);
  279.         }
  281.         SetDialogSevereErrors(false);
  283.         // actually do the block alignment
  284.         DP_AlignmentResult *dpResult = NULL;
  285.         int dpStatus;
  286.         if (currentOptions.globalAlignment)
  287.             dpStatus = DP_GlobalBlockAlign(dpBlocks, dpScoreFunction,
  288.                 startQueryPosition, endQueryPosition, &dpResult);
  289.         else
  290.             dpStatus = DP_LocalBlockAlign(dpBlocks, dpScoreFunction,
  291.                 startQueryPosition, endQueryPosition, &dpResult);
  293.         SetDialogSevereErrors(true);
  295.         // create new alignment from DP result
  296.         BlockMultipleAlignment *dpAlignment = NULL;
  297.         if (dpResult) {
  298.             dpAlignment = UnpackDPResult(dpBlocks, dpResult, multiple->GetMaster(), dpQuery);
  299.             if (!dpAlignment)
  300.                 ERRORMSG("Couldn't create BlockMultipleAlignment from DP result");
  301.         }
  303.         if (dpStatus == STRUCT_DP_FOUND_ALIGNMENT && dpAlignment) {
  305.             // merge or add alignment to list
  306.             if (currentOptions.mergeAfterEachSequence && multiple->MergeAlignment(dpAlignment)) {
  307.                 delete dpAlignment; // if merge is successful, we can delete this alignment;
  308.                 if (nRowsAddedToMultiple)
  309.                     (*nRowsAddedToMultiple)++;
  310.                 else
  311.                     ERRORMSG("BlockAligner::CreateNewPairwiseAlignmentsByBlockAlignment() "
  312.                         "called with merge on, but NULL nRowsAddedToMultiple pointer");
  313.                 // recalculate PSSM
  314.                 dpPSSM = multiple->GetPSSM();
  316.             } else {
  317.                 newAlignments->push_back(dpAlignment);
  318.             }
  319.         }
  321.         // no alignment or block aligner failed - add old alignment to list so it doesn't get lost
  322.         else {
  323.             string status;
  324.             if (dpStatus == STRUCT_DP_NO_ALIGNMENT) {
  325.                 WARNINGMSG("block aligner found no significant alignment - current alignment unchanged");
  326.                 status = "alignment unchanged";
  327.             } else {
  328.                 WARNINGMSG("block aligner encountered a problem - current alignment unchanged");
  329.                 errorsEncountered = true;
  330.                 status = "block aligner error!";
  331.             }
  332.             BlockMultipleAlignment *newAlignment = (*s)->Clone();
  333.             newAlignment->SetRowDouble(0, -1.0);
  334.             newAlignment->SetRowDouble(1, -1.0);
  335.             newAlignment->SetRowStatusLine(0, status);
  336.             newAlignment->SetRowStatusLine(1, status);
  337.             newAlignments->push_back(newAlignment);
  338.         }
  340.         // cleanup
  341.         DP_DestroyAlignmentResult(dpResult);
  342.     }
  344.     if (errorsEncountered)
  345.         ERRORMSG("Block aligner encountered problem(s) - see message log for details");
  347.     // cleanup
  348.     DP_DestroyBlockInfo(dpBlocks);
  349.     dpBlocks = NULL;
  350.     dpPSSM = NULL;
  351.     dpQuery = NULL;
  353.     return true;
  354. }
  356. bool BlockAligner::SetOptions(wxWindow* parent)
  357. {
  358.     BlockAlignerOptionsDialog dialog(parent, currentOptions);
  359.     bool ok = (dialog.ShowModal() == wxOK);
  360.     if (ok && !dialog.GetValues(&currentOptions))
  361.         ERRORMSG("Error getting options from dialog!");
  362.     return ok;
  363. }
  366. /////////////////////////////////////////////////////////////////////////////////////
  367. ////// BlockAlignerOptionsDialog stuff
  368. ////// taken (and modified) from block_aligner_dialog.wdr code
  369. /////////////////////////////////////////////////////////////////////////////////////
  371. #define ID_TEXT 10000
  372. #define ID_T_PERCENT 10001
  373. #define ID_S_EXT 10002
  374. #define ID_T_EXTENSION 10003
  375. #define ID_S_PERCENT 10004
  376. #define ID_T_CUTOFF 10005
  377. #define ID_S_LAMBDA 10006
  378. #define ID_C_GLOBAL 10007
  379. #define ID_C_KEEP 10008
  380. #define ID_C_MERGE 10009
  381. #define ID_B_OK 10010
  382. #define ID_B_CANCEL 10011
  384. BEGIN_EVENT_TABLE(BlockAlignerOptionsDialog, wxDialog)
  385.     EVT_BUTTON(-1,  BlockAlignerOptionsDialog::OnButton)
  386.     EVT_CLOSE (     BlockAlignerOptionsDialog::OnCloseWindow)
  387. END_EVENT_TABLE()
  389. BlockAlignerOptionsDialog::BlockAlignerOptionsDialog(
  390.     wxWindow* parent, const BlockAligner::BlockAlignerOptions& init) :
  391.         wxDialog(parent, -1, "Set Block Aligner Options", wxPoint(100,100), wxDefaultSize,
  392.             wxCAPTION | wxSYSTEM_MENU) // not resizable
  393. {
  394.     wxPanel *panel = new wxPanel(this, -1);
  395.     wxBoxSizer *item0 = new wxBoxSizer( wxVERTICAL );
  396.     wxStaticBox *item2 = new wxStaticBox( panel, -1, wxT("Block Aligner Options") );
  397.     wxStaticBoxSizer *item1 = new wxStaticBoxSizer( item2, wxVERTICAL );
  398.     wxFlexGridSizer *item3 = new wxFlexGridSizer( 3, 0, 0 );
  399.     item3->AddGrowableCol( 1 );
  401.     wxStaticText *item4 = new wxStaticText( panel, ID_TEXT, wxT("Loop percentile:"), wxDefaultPosition, wxDefaultSize, 0 );
  402.     item3->Add( item4, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
  403.     fpPercent = new FloatingPointSpinCtrl(panel,
  404.         0.0, 100.0, 0.6, init.loopPercentile,
  405.         wxDefaultPosition, wxSize(80, SPIN_CTRL_HEIGHT), 0,
  406.         wxDefaultPosition, wxSize(-1, SPIN_CTRL_HEIGHT));
  407.     item3->Add(fpPercent->GetTextCtrl(), 0, wxALIGN_CENTRE|wxLEFT|wxTOP|wxBOTTOM, 5);
  408.     item3->Add(fpPercent->GetSpinButton(), 0, wxALIGN_CENTER_VERTICAL|wxRIGHT|wxTOP|wxBOTTOM, 5);
  410.     wxStaticText *item7 = new wxStaticText( panel, ID_TEXT, wxT("Loop extension:"), wxDefaultPosition, wxDefaultSize, 0 );
  411.     item3->Add( item7, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
  412.     iExtension = new IntegerSpinCtrl(panel,
  413.         0, 100000, 10, init.loopExtension,
  414.         wxDefaultPosition, wxSize(80, SPIN_CTRL_HEIGHT), 0,
  415.         wxDefaultPosition, wxSize(-1, SPIN_CTRL_HEIGHT));
  416.     item3->Add(iExtension->GetTextCtrl(), 0, wxALIGN_CENTRE|wxLEFT|wxTOP|wxBOTTOM, 5);
  417.     item3->Add(iExtension->GetSpinButton(), 0, wxALIGN_CENTER_VERTICAL|wxRIGHT|wxTOP|wxBOTTOM, 5);
  419.     wxStaticText *item10 = new wxStaticText( panel, ID_TEXT, wxT("Loop cutoff (0=none):"), wxDefaultPosition, wxDefaultSize, 0 );
  420.     item3->Add( item10, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
  421.     iCutoff = new IntegerSpinCtrl(panel,
  422.         0, 100000, 0, init.loopCutoff,
  423.         wxDefaultPosition, wxSize(80, SPIN_CTRL_HEIGHT), 0,
  424.         wxDefaultPosition, wxSize(-1, SPIN_CTRL_HEIGHT));
  425.     item3->Add(iCutoff->GetTextCtrl(), 0, wxALIGN_CENTRE|wxLEFT|wxTOP|wxBOTTOM, 5);
  426.     item3->Add(iCutoff->GetSpinButton(), 0, wxALIGN_CENTER_VERTICAL|wxRIGHT|wxTOP|wxBOTTOM, 5);
  428.     item3->Add( 5, 5, 0, wxALIGN_CENTRE|wxALL, 5 );
  429.     item3->Add( 5, 5, 0, wxALIGN_CENTRE|wxALL, 5 );
  430.     item3->Add( 5, 5, 0, wxALIGN_CENTRE|wxALL, 5 );
  432.     wxStaticText *item13 = new wxStaticText( panel, ID_TEXT, wxT("Global alignment:"), wxDefaultPosition, wxDefaultSize, 0 );
  433.     item3->Add( item13, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
  434.     cGlobal = new wxCheckBox( panel, ID_C_GLOBAL, wxT(""), wxDefaultPosition, wxDefaultSize, 0 );
  435.     cGlobal->SetValue(init.globalAlignment);
  436.     item3->Add( cGlobal, 0, wxALIGN_CENTRE|wxALL, 5 );
  437.     item3->Add( 5, 5, 0, wxALIGN_CENTRE, 5 );
  439.     wxStaticText *item15 = new wxStaticText( panel, ID_TEXT, wxT("Keep existing blocks (global only):"), wxDefaultPosition, wxDefaultSize, 0 );
  440.     item3->Add( item15, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
  441.     cKeep = new wxCheckBox( panel, ID_C_KEEP, wxT(""), wxDefaultPosition, wxDefaultSize, 0 );
  442.     cKeep->SetValue(init.keepExistingBlocks);
  443.     item3->Add( cKeep, 0, wxALIGN_CENTRE|wxALL, 5 );
  444.     item3->Add( 5, 5, 0, wxALIGN_CENTRE, 5 );
  446.     wxStaticText *item17 = new wxStaticText( panel, ID_TEXT, wxT("Merge after each row aligned:"), wxDefaultPosition, wxDefaultSize, 0 );
  447.     item3->Add( item17, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
  448.     cMerge = new wxCheckBox( panel, ID_C_MERGE, wxT(""), wxDefaultPosition, wxDefaultSize, 0 );
  449.     cMerge->SetValue(init.mergeAfterEachSequence);
  450.     item3->Add( cMerge, 0, wxALIGN_CENTRE|wxALL, 5 );
  451.     item3->Add( 5, 5, 0, wxALIGN_CENTRE, 5 );
  453.     item1->Add( item3, 0, wxALIGN_CENTRE, 5 );
  454.     item0->Add( item1, 0, wxALIGN_CENTRE|wxALL, 5 );
  455.     wxBoxSizer *item19 = new wxBoxSizer( wxHORIZONTAL );
  456.     wxButton *item20 = new wxButton( panel, ID_B_OK, wxT("OK"), wxDefaultPosition, wxDefaultSize, 0 );
  457.     item19->Add( item20, 0, wxALIGN_CENTRE|wxALL, 5 );
  458.     item19->Add( 20, 20, 0, wxALIGN_CENTRE|wxALL, 5 );
  459.     wxButton *item21 = new wxButton( panel, ID_B_CANCEL, wxT("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
  460.     item19->Add( item21, 0, wxALIGN_CENTRE|wxALL, 5 );
  461.     item0->Add( item19, 0, wxALIGN_CENTRE|wxALL, 5 );
  463.     panel->SetAutoLayout(true);
  464.     panel->SetSizer(item0);
  465.     item0->Fit(this);
  466.     item0->Fit(panel);
  467.     item0->SetSizeHints(this);
  468. }
  470. BlockAlignerOptionsDialog::~BlockAlignerOptionsDialog(void)
  471. {
  472.     delete iCutoff;
  473.     delete iExtension;
  474.     delete fpPercent;
  475. }
  477. bool BlockAlignerOptionsDialog::GetValues(BlockAligner::BlockAlignerOptions *options)
  478. {
  479.     options->globalAlignment = cGlobal->IsChecked();
  480.     options->keepExistingBlocks = cKeep->IsChecked();
  481.     options->mergeAfterEachSequence = cMerge->IsChecked();
  482.     return (
  483.         fpPercent->GetDouble(&(options->loopPercentile)) &&
  484.         iExtension->GetInteger(&(options->loopExtension)) &&
  485.         iCutoff->GetInteger(&(options->loopCutoff))
  486.     );
  487. }
  489. void BlockAlignerOptionsDialog::OnCloseWindow(wxCloseEvent& event)
  490. {
  491.     EndModal(wxCANCEL);
  492. }
  494. void BlockAlignerOptionsDialog::OnButton(wxCommandEvent& event)
  495. {
  496.     if (event.GetId() == ID_B_OK) {
  497. BlockAligner::BlockAlignerOptions dummy;
  498.         if (GetValues(&dummy))  // can't successfully quit if values aren't valid
  499.             EndModal(wxOK);
  500.         else
  501.             wxBell();
  502.     } else if (event.GetId() == ID_B_CANCEL) {
  503.         EndModal(wxCANCEL);
  504.     } else {
  505.         event.Skip();
  506.     }
  507. }
  509. END_SCOPE(Cn3D)
  511. /*
  512. * ---------------------------------------------------------------------------
  513. * $Log: cn3d_ba_interface.cpp,v $
  514. * Revision 1000.2  2004/06/01 18:28:07  gouriano
  515. * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.33
  516. *
  517. * Revision 1.33  2004/05/21 21:41:39  gorelenk
  518. * Added PCH ncbi_pch.hpp
  519. *
  520. * Revision 1.32  2004/03/15 18:19:23  thiessen
  521. * prefer prefix vs. postfix ++/-- operators
  522. *
  523. * Revision 1.31  2004/03/10 23:15:51  thiessen
  524. * add ability to turn off/on error dialogs; group block aligner errors in message log
  525. *
  526. * Revision 1.30  2004/02/19 17:04:48  thiessen
  527. * remove cn3d/ from include paths; add pragma to disable annoying msvc warning
  528. *
  529. * Revision 1.29  2004/02/19 02:16:06  thiessen
  530. * fix struct_dp.h path
  531. *
  532. * Revision 1.28  2003/08/23 22:26:23  thiessen
  533. * switch to new dp block aligner, remove Alejandro's
  534. *
  535. * Revision 1.27  2003/07/21 19:54:10  thiessen
  536. * fix firstBlock error
  537. *
  538. * Revision 1.26  2003/07/14 18:35:27  thiessen
  539. * run DP and Alejandro's block aligners, and compare results
  540. *
  541. * Revision 1.25  2003/03/27 18:45:59  thiessen
  542. * update blockaligner code
  543. *
  544. * Revision 1.24  2003/02/03 19:20:02  thiessen
  545. * format changes: move CVS Log to bottom of file, remove std:: from .cpp files, and use new diagnostic macros
  546. *
  547. * Revision 1.23  2003/01/23 20:03:05  thiessen
  548. * add BLAST Neighbor algorithm
  549. *
  550. * Revision 1.22  2003/01/22 14:47:30  thiessen
  551. * cache PSSM in BlockMultipleAlignment
  552. *
  553. * Revision 1.21  2002/12/20 02:51:46  thiessen
  554. * fix Prinf to self problems
  555. *
  556. * Revision 1.20  2002/12/09 16:25:04  thiessen
  557. * allow negative score threshholds
  558. *
  559. * Revision 1.19  2002/11/06 00:18:10  thiessen
  560. * fixes for new CRef/const rules in objects
  561. *
  562. * Revision 1.18  2002/09/30 17:13:02  thiessen
  563. * change structure import to do sequences as well; change cache to hold mimes; change block aligner vocabulary; fix block aligner dialog bugs
  564. *
  565. * Revision 1.17  2002/09/23 19:12:32  thiessen
  566. * add option to allow long gaps between frozen blocks
  567. *
  568. * Revision 1.16  2002/09/21 12:36:28  thiessen
  569. * add frozen block position validation; add select-other-by-distance
  570. *
  571. * Revision 1.15  2002/09/20 17:48:39  thiessen
  572. * fancier trace statements
  573. *
  574. * Revision 1.14  2002/09/19 14:09:41  thiessen
  575. * position options dialog higher up
  576. *
  577. * Revision 1.13  2002/09/19 12:51:08  thiessen
  578. * fix block aligner / update bug; add distance select for other molecules only
  579. *
  580. * Revision 1.12  2002/09/16 21:24:58  thiessen
  581. * add block freezing to block aligner
  582. *
  583. * Revision 1.11  2002/08/15 22:13:13  thiessen
  584. * update for wx2.3.2+ only; add structure pick dialog; fix MultitextDialog bug
  585. *
  586. * Revision 1.10  2002/08/14 00:02:08  thiessen
  587. * combined block/global aligner from Alejandro
  588. *
  589. * Revision 1.8  2002/08/09 18:24:08  thiessen
  590. * improve/add magic formula to avoid Windows symbol clashes
  591. *
  592. * Revision 1.7  2002/08/04 21:41:05  thiessen
  593. * fix GetObject problem
  594. *
  595. * Revision 1.6  2002/08/01 12:51:36  thiessen
  596. * add E-value display to block aligner
  597. *
  598. * Revision 1.5  2002/08/01 01:55:16  thiessen
  599. * add block aligner options dialog
  600. *
  601. * Revision 1.4  2002/07/29 19:22:46  thiessen
  602. * another blockalign bug fix; set better parameters to block aligner
  603. *
  604. * Revision 1.3  2002/07/29 13:25:42  thiessen
  605. * add range restriction to block aligner
  606. *
  607. * Revision 1.2  2002/07/27 12:29:51  thiessen
  608. * fix block aligner crash
  609. *
  610. * Revision 1.1  2002/07/26 15:28:45  thiessen
  611. * add Alejandro's block alignment algorithm
  612. *
  613. */