int main()
{
Align align;
align.OpenFile();
//align.CutAlign();
//align.LimitAlign();
align.ByWidthAlign();
align.Write();
return 0;
}
IntCoord Window::_getActionScale(Widget* _widget)
{
if (_widget->isUserString("Scale"))
{
IntCoord result = IntCoord::parse(_widget->getUserString("Scale"));
if (result == IntCoord(1, 1, 0, 0) && !mMovable)
result.clear();
return result;
}
else if (_widget->isUserString("Action"))
{
const std::string& action = _widget->getUserString("Action");
if (action == "Move")
{
if (mMovable)
return IntCoord(1, 1, 0, 0);
else
return IntCoord();
}
IntCoord coord;
Align align = Align::parse(action);
if (align.isLeft())
{
coord.left = 1;
coord.width = -1;
}
else if (align.isRight())
{
coord.width = 1;
}
if (align.isTop())
{
coord.top = 1;
coord.height = -1;
}
else if (align.isBottom())
{
coord.height = 1;
}
return coord;
}
return IntCoord();
}
bool operator()(Align const & a1, Align const & a2) const
{
if (a1.getStart() == a2.getStart())
//return (&a1 > &a2); // just arbitrarily pick the one with higher pointer
return a1.getName() > a2.getName();
else
return (a1.getStart() > a2.getStart());
}
int main()
{
unsigned key = 0;
Align align;
do
{
cout<<"1 - first task"<<endl;
cout<<"2 - second task"<<endl;
cout<<"3 - third task"<<endl;
cout<<"4 - save data to file"<<endl;
cout<<"5 - input the way to file"<<endl;
cout<<"0 - exit"<<endl;
cin>>key;
switch (key)
{
case 1:
align.CutAlign();
break;
case 2:
align.LimitAlign();
break;
case 3:
align.ByWidthAlign();
break;
case 4:
align.Write();
break;
case 5:
align.OpenFile();
break;
case 0:
exit(EXIT_SUCCESS);
break;
default:
cout<<"Incorrect command"<<endl;
}
cout.flush();
} while (true);
return 0;
}
void ScrollViewBase::updateScrollPosition()
{
// размер контекста
IntSize contentSize = getContentSize();
// текущее смещение контекста
IntPoint contentPoint = getContentPosition();
// расчетное смещение
IntPoint offset = contentPoint;
IntSize viewSize = getViewSize();
Align align = getContentAlign();
if (contentSize.width > viewSize.width)
{
// максимальный выход влево
if ((offset.left + viewSize.width) > contentSize.width)
{
offset.left = contentSize.width - viewSize.width;
}
// максимальный выход вправо
else if (offset.left < 0)
{
offset.left = 0;
}
}
else
{
if (align.isLeft())
{
offset.left = 0;
}
else if (align.isRight())
{
offset.left = contentSize.width - viewSize.width;
}
else
{
offset.left = (contentSize.width - viewSize.width) / 2;
}
}
if (contentSize.height > viewSize.height)
{
// максимальный выход вверх
if ((offset.top + viewSize.height) > contentSize.height)
{
offset.top = contentSize.height - viewSize.height;
}
// максимальный выход вниз
else if (offset.top < 0)
{
offset.top = 0;
}
}
else
{
if (align.isTop())
{
offset.top = 0;
}
else if (align.isBottom())
{
offset.top = contentSize.height - viewSize.height;
}
else
{
offset.top = (contentSize.height - viewSize.height) / 2;
}
}
if (offset != contentPoint)
{
if (nullptr != mVScroll) mVScroll->setScrollPosition(offset.top);
if (nullptr != mHScroll) mHScroll->setScrollPosition(offset.left);
setContentPosition(offset);
}
}
void TextView::update(const UString& _text, IFont* _font, int _height, Align _align, VertexColourType _format, int _maxheight)
{
mFontHeight = _height;
// массив дл¤ быстрой конвертации цветов
static const char convert_colour[64] =
{
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0,
0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
mViewSize.clear();
RollBackPoint roll_back;
IntSize result;
int width = 0;
size_t count = 0;
mLength = 0;
mLineInfo.clear();
LineInfo line_info;
int font_height = _font->getDefaultHeight();
UString::const_iterator end = _text.end();
UString::const_iterator index = _text.begin();
/*if (index == end)
return;*/
result.height += _height;
for (; index != end; ++index)
{
Char character = *index;
// нова¤ строка
if (character == FontCodeType::CR
|| character == FontCodeType::NEL
|| character == FontCodeType::LF)
{
if (character == FontCodeType::CR)
{
UString::const_iterator peeki = index;
++peeki;
if ((peeki != end) && (*peeki == FontCodeType::LF))
index = peeki; // skip both as one newline
}
line_info.width = width;
line_info.count = count;
mLength += line_info.count + 1;
result.height += _height;
if (result.width < width)
result.width = width;
width = 0;
count = 0;
mLineInfo.push_back(line_info);
line_info.clear();
// отмен¤ем откат
roll_back.clear();
continue;
}
// тег
else if (character == L'#')
{
// берем следующий символ
++ index;
if (index == end)
{
--index; // это защита
continue;
}
character = *index;
// если два подр¤д, то рисуем один шарп, если нет то мен¤ем цвет
if (character != L'#')
{
// парсим первый символ
uint32 colour = convert_colour[(character-48) & 0x3F];
// и еще п¤ть символов после шарпа
for (char i = 0; i < 5; i++)
{
++ index;
if (index == end)
{
--index; // это защита
continue;
}
colour <<= 4;
colour += convert_colour[ ((*index) - 48) & 0x3F ];
}
// если нужно, то мен¤ем красный и синий компоненты
texture_utility::convertColour(colour, _format);
line_info.simbols.push_back( CharInfo(colour) );
continue;
}
}
GlyphInfo* info = _font->getGlyphInfo(character);
if (FontCodeType::Space == character)
{
roll_back.set(line_info.simbols.size(), index, count, width);
}
else if (FontCodeType::Tab == character)
{
roll_back.set(line_info.simbols.size(), index, count, width);
}
int char_width = info->width;
if (font_height != _height)
{
char_width = char_width * _height / font_height;
if (!char_width) char_width = 1;
}
// перенос слов
if (_maxheight != -1
&& (width + char_width) > _maxheight
&& !roll_back.empty())
{
// откатываем до последнего пробела
width = roll_back.getLenght();
count = roll_back.getCount();
index = roll_back.getTextIter();
line_info.simbols.erase(line_info.simbols.begin() + roll_back.getPosition(), line_info.simbols.end());
// запоминаем место отката, как полную строку
line_info.width = width;
line_info.count = count;
mLength += line_info.count + 1;
result.height += _height;
if (result.width < width)
result.width = width;
width = 0;
count = 0;
mLineInfo.push_back(line_info);
line_info.clear();
// отмен¤ем откат
roll_back.clear();
continue;
}
line_info.simbols.push_back(CharInfo(info->uvRect, char_width));
width += char_width;
count ++;
}
line_info.width = width;
line_info.count = count;
mLength += line_info.count;
mLineInfo.push_back(line_info);
if (result.width < width)
result.width = width;
// теперь выравниванием строки
for (VectorLineInfo::iterator line = mLineInfo.begin(); line != mLineInfo.end(); ++line)
{
if (_align.isRight())
line->offset = result.width - line->width;
else if (_align.isHCenter())
line->offset = (result.width - line->width) / 2;
}
mViewSize = result;
}
bool BamProcessor::processRecord ()
{
trclog << "\nProcessing record " << read_cnt_ << " - " << rec_.getReadName () << ", " << rec_.get0BasedUnclippedEnd () << "->" << rec_.getReadLength () << ", ref " << rec_.getReferenceName () << std::endl;
const char* seq = rec_.getSequence ();
unsigned position = rec_.get0BasedPosition ();
unsigned new_position = position;
bool reverse_match = (rec_.getFlag () & 0x10);
Cigar* cigar_p = rec_.getCigarInfo ();
if (!cigar_p->size ()) // can not recreate reference is cigar is missing. Keep record unaligned.
{ // TODO: allow to specify and load external reference
++ unaligned_cnt_;
return true;
}
myassert (cigar_p);
const String *mdval = rec_.getStringTag ("MD");
if (!mdval) // can not recreate reference is MD tag is missing. Keep record as is.
{
warn << "No MD Tag for record " << proc_cnt_ << ". Skipping record." << std::endl;
++nomd_cnt_;
return true; // record will be kept as-is.
}
std::string md_tag = mdval->c_str ();
// find the non-clipped region
uint32_t clean_len;
EndClips clips;
const char* clean_read = clip_seq (seq, *cigar_p, clean_len, clips);
// find length needed for the reference
// this reserves space enough for entire refference, including softclipped ends.
unsigned ref_len = cigar_p->getExpectedReferenceBaseCount ();
if (ref_buffer_sz_ < ref_len)
{
ref_buffer_sz_ = (1 + ref_len / REF_BUF_INCR) * REF_BUF_INCR;
ref_buffer_.reset (ref_buffer_sz_);
}
if (clean_len > MAX_SEQ_LEN || ref_len > MAX_SEQ_LEN)
{
++ toolongs_;
return true;
}
// recreate reference by Query, Cigar, and MD tag. Do not include softclipped ends in the recreated sequence (use default last parameter)
recreate_ref (seq, rec_.getReadLength (), cigar_p, md_tag.c_str (), ref_buffer_, ref_buffer_sz_);
unsigned qry_ins; // extra bases in query == width_left
unsigned ref_ins; // extra bases in reference == width_right
band_width (*cigar_p, qry_ins, ref_ins);
if (log_matr_ || log_base_)
{
logfile_ << "Record " << read_cnt_ << ": " << rec_.getReadName () << "\n"
<< " sequence (" << rec_.getReadLength () << " bases)\n";
}
CigarRoller roller;
int ref_shift = 0; // shift of the new alignment position on refereance relative the original
unsigned qry_off, ref_off; // offsets on the query and reference of the first non-clipped aligned bases
double new_score = 0;
switch (p_->algo ())
{
case ContalignParams::TEMPL:
{
// call aligner
new_score = taligner_.eval (clean_read, clean_len, ref_buffer_, ref_len, 0, band_width_);
// read traceback
// TODO: convert directly to cigar
genstr::Alignment* al = taligner_.trace ();
// convert alignment to cigar
ref_shift = roll_cigar (roller, *al, clean_len, clips, qry_off, ref_off);
}
break;
case ContalignParams::PLAIN:
{
new_score = aligner_.align_band (
clean_read, // xseq
clean_len, // xlen
ref_buffer_, // yseq
ref_len, // ylen
0, // xpos
0, // ypos
std::max (clean_len, ref_len), // segment length
qry_ins + band_width_, // width_left
false, // unpack
ref_ins + band_width_, // width_right - forces to width_left
true, // to_beg
true // to_end
);
unsigned bno = aligner_.backtrace (
batches_, // BATCH buffer
max_batch_no_, // size of BATCH buffer
false, // fill the BATCH array in reverse direction
ref_ins + band_width_ // width
);
// convert alignment to cigar
ref_shift = roll_cigar (roller, batches_, bno, clean_len, clips, qry_off, ref_off);
}
break;
case ContalignParams::POLY:
{
new_score = contalign_.align_band (
clean_read, // xseq
clean_len, // xlen
ref_buffer_, // yseq
ref_len, // ylen
0, // xpos
0, // ypos
std::max (clean_len, ref_len), // segment length
qry_ins + band_width_, // width_left
false, // unpack
ref_ins + band_width_, // width_right - forces to width_left
true, // to_beg
true // to_end
);
unsigned bno = contalign_.backtrace (
batches_, // BATCH buffer
max_batch_no_, // size of BATCH buffer
false, // fill the BATCH array in reverse direction
ref_ins + band_width_ // width
);
// convert alignment to cigar
ref_shift = roll_cigar (roller, batches_, bno, clean_len, clips, qry_off, ref_off);
}
break;
default:
break;
}
++realigned_cnt_;
// compare original and new cigar (and location)
if (ref_shift || !(*cigar_p == roller))
{
// save original cigar and position for reporting
std::string orig_cigar_str;
rec_.getCigarInfo ()->getCigarString (orig_cigar_str);
int32_t prior_pos = rec_.get0BasedPosition ();
// replace cigar
rec_.setCigar (roller);
++ modified_cnt_;
// update pos_adjusted_cnt if position changed
if (ref_shift != 0)
{
myassert (prior_pos + ref_shift >= 0);
rec_.set0BasedPosition (prior_pos + ref_shift);
++ pos_adjusted_cnt_;
}
if (log_diff_)
{
const unsigned MAX_BATCH_PRINTED = 100;
BATCH batches [MAX_BATCH_PRINTED];
std::string new_cigar_str;
unsigned bno;
int swscore;
rec_.getCigarInfo ()->getCigarString (new_cigar_str);
if (!log_base_ && !log_matr_)
logfile_ << "Record " << read_cnt_ << ": " << rec_.getReadName () << " (" << rec_.getReadLength () << " bases)\n";
logfile_ << " ORIG ALIGNMENT:" << std::right << std::setw (9) << prior_pos+1 << "->" << orig_cigar_str << "\n";
bno = cigar_to_batches (orig_cigar_str, batches, MAX_BATCH_PRINTED);
swscore = align_score (batches, bno, clean_read, ref_buffer_, p_->gip (), p_->gep (), p_->mat (), p_->mis ());
print_batches (clean_read, clean_len, false, ref_buffer_, ref_len, false, batches, bno, logfile_, false, prior_pos + clips.soft_beg_, clips.soft_beg_, 0, 160);
logfile_ << "\n 'classic' SW score is " << swscore << "\n";
logfile_ << " NEW ALIGNMENT:" << std::right << std::setw (9) << rec_.get1BasedPosition () << "->" << new_cigar_str << std::endl;
bno = cigar_to_batches (new_cigar_str, batches, MAX_BATCH_PRINTED);
swscore = align_score (batches, bno, clean_read + qry_off, ref_buffer_ + ref_off, p_->gip (), p_->gep (), p_->mat (), p_->mis ());
print_batches (clean_read + qry_off, clean_len - qry_off, false, ref_buffer_ + ref_off, ref_len - ref_off, false, batches, bno, logfile_, false, prior_pos + clips.soft_beg_ + ref_off, clips.soft_beg_ + qry_off, 0, 160);
logfile_ << "\n 'classic' SW score is " << swscore;
logfile_ << "\n alternate (context-aware) score is " << new_score << ", used bandwidth left: " << qry_ins + band_width_ << ", right: " << ref_ins + band_width_ << "\n" << std::endl;
}
else if (log_base_)
{
logfile_ << "Recomputed alignment differs from original:\n";
logfile_ << " ORIG ALIGNMENT:" << std::right << std::setw (9) << prior_pos+1 << "->" << orig_cigar_str << "\n";
std::string new_cigar_str;
rec_.getCigarInfo ()->getCigarString (new_cigar_str);
logfile_ << " NEW ALIGNMENT:" << std::right << std::setw (9) << rec_.get1BasedPosition () << "->" << new_cigar_str << "\n" << std::endl;
}
}
else
{
if (log_base_)
{
logfile_ << "Recomputed alignment matches the original:\n";
std::string orig_cigar_str;
rec_.getCigarInfo ()->getCigarString (orig_cigar_str);
int32_t prior_pos = rec_.get0BasedPosition ();
logfile_ << " " << std::right << std::setw (9) << prior_pos+1 << "->" << orig_cigar_str << "\n" << std::endl;
}
}
return true;
}
bool BamProcessor::init (const ContalignParams& p)
{
read_cnt_ = proc_cnt_ = toolongs_ = unaligned_cnt_ = fail_cnt_ = nomd_cnt_ = realigned_cnt_ = modified_cnt_ = pos_adjusted_cnt_ = 0;
log_diff_ = log_matr_ = log_base_ = false;
p_ = &p;
if (!*p.inbam ())
ers << "Input file name not specified" << Throw;
limit_ = p.limit ();
skip_ = p.skip ();
infile_.OpenForRead (p.inbam ());
if (!infile_.IsOpen ())
ers << p.inbam () << ThrowEx (FileNotFoundRerror);
bool index_ok = false;
if (*p.bamidx ())
{
index_ok = infile_.ReadBamIndex (p.bamidx ());
if (!index_ok)
warn << "Unable to open specified BAM index: " << p.bamidx () << ". Default index will be attempted" << std::endl;
}
if (!index_ok)
{
try
{
index_ok = infile_.ReadBamIndex ();
}
catch (std::exception& e)
{
// for some reason not converted into return status by libStatGen
}
if (!index_ok)
warn << "Unable to open default BAM index for " << p.inbam () << std::endl;
}
if (*p.refname () || p.refno () != -1)
{
if (!index_ok)
ers << "Reference section specified, but the BAM index could not be open." << Throw;
if (*p.refname ())
{
if (p.endpos () != 0)
{
infile_.SetReadSection (p.refname (), p.begpos (), p.endpos ());
info << "Read section set : " << p.refname () << ": " << p.begpos () << "-" << p.endpos () << std::endl;
}
else
{
infile_.SetReadSection (p.refname ());
info << "Read section set : " << p.refname () << std::endl;
}
}
else
{
if (p.endpos () != 0)
{
info << "Read section set : ref# " << p.refno () << ": " << p.begpos () << "-" << p.endpos () << std::endl;
infile_.SetReadSection (p.refno (), p.begpos (), p.endpos ());
}
else
{
info << "Read section set : ref# " << p.refno () << std::endl;
infile_.SetReadSection (p.refno ());
}
}
}
if (*p.outbam ())
{
if (!p.overwrite () && file_exists (p.outbam ()))
ers << "Output file " << p.outbam () << " exists. Use --ov key to allow overwriting" << Throw;
outfile_.OpenForWrite (p.outbam ());
if (!outfile_.IsOpen ())
ers << "Unable to open output file " << p.outbam () << std::endl;
}
if (*p.logfname ())
{
if (!p.overwrite () && file_exists (p.logfname ()))
ers << "Log file " << p.logfname () << " exists. Use --ov key to allow overwriting" << Throw;
logfile_.open (p.logfname (), std::fstream::out);
if (!logfile_.is_open ())
ers << "Unable to open log file " << p.logfname () << std::endl;
time_t t = time (NULL);
logfile_ << "Context-aware realigner log\nStarted at " << asctime (localtime (&t)) << "\nParameters:\n";
logfile_ << *(p.parameters_);
logfile_ << std::endl;
log_base_ = p.logging ("base");
log_diff_ = p.logging ("diff");
log_matr_ = p.logging ("matr");
}
band_width_ = p.bwid ();
switch (p.algo ())
{
case ContalignParams::TEMPL:
{
matrix_.configure (genstr::nucleotides.symbols (), genstr::nucleotides.size (), genstr::NegUnitaryMatrix <int, 4>().values ());
gap_cost_.configure (p.gip (), p.gep ());
taligner_.configure (&matrix_, &gap_cost_, &gap_cost_, &genstr::nn2num, &genstr::nn2num);
}
break;
case ContalignParams::PLAIN:
{
batches_.reset (max_batch_no_);
aligner_.init (MAX_SEQ_LEN, MAX_SEQ_LEN*MAX_BAND_WIDTH, p.gip (), p.gep (), p.mat (), -p.mis ());
if (log_matr_)
aligner_.set_log (logfile_);
if (p.debug () > 5)
aligner_.set_trace (true);
}
break;
case ContalignParams::POLY:
{
batches_.reset (max_batch_no_);
contalign_.init (MAX_SEQ_LEN, MAX_RSEQ_LEN, MAX_SEQ_LEN*MAX_BAND_WIDTH, p.gip (), p.gep (), p.mat (), -p.mis ());
if (log_matr_)
contalign_.set_log (logfile_);
if (p.debug () > 5)
contalign_.set_trace (true);
}
break;
default:
{
ers << "Alignment algorithm " << p.algostr () << " not yet supported" << Throw;
}
}
timer_.reset (DEFAULT_REPORT_IVAL, 1);
return true;
}
