QVector<U2Region> MultipleRangeSelector::getSelectedRegions(){
QVector<U2Region> currentRegions;
if(ui->singleButton->isChecked()){
bool ok = false;
int st = ui->startEdit->text().toInt(&ok);
assert(ok);
int en = ui->endEdit->text().toInt(&ok);
assert(ok);
if (isCircular && st > en ) {
currentRegions.append(U2Region(0, en));
currentRegions.append(U2Region(st - 1, seqLen - st + 1));
}
else {
currentRegions.append(U2Region(st - 1, en - st + 1));
}
}else{
QByteArray locEditText = ui->multipleRegionEdit->text().toLatin1();
U2Location currentLocation;
if (isCircular){
Genbank::LocationParser::parseLocation( locEditText.constData(), ui->multipleRegionEdit->text().length(), currentLocation, seqLen);
}else{
Genbank::LocationParser::parseLocation( locEditText.constData(), ui->multipleRegionEdit->text().length(), currentLocation, -1);
}
assert(!currentLocation->isEmpty());
currentRegions = U2Region::join(currentLocation->regions);
}
return currentRegions;
}
static UHMM3SearchSeqDomainResult getDomainRes( QStringList& tokens ) {
UHMM3SearchSeqDomainResult res;
getNextToken( tokens );
res.isSignificant = getSignificance( getNextToken( tokens ) );
res.score = getFloat( getNextToken( tokens ) );
res.bias = getFloat( getNextToken( tokens ) );
res.cval = getDouble( getNextToken( tokens ) );
res.ival = getDouble( getNextToken( tokens ) );
int hmmFrom = (int)getFloat( getNextToken( tokens ) );
int hmmTo = (int)getFloat( getNextToken( tokens ) );
res.queryRegion = U2Region( hmmFrom, hmmTo - hmmFrom );
getNextToken( tokens );
int aliFrom = (int)getFloat( getNextToken( tokens ) );
int aliTo = (int)getFloat( getNextToken( tokens ) );
res.seqRegion = U2Region( aliFrom - 1, aliTo - aliFrom + 1 );
getNextToken( tokens );
int envFrom = (int)getFloat( getNextToken( tokens ) );
int envTo = (int)getFloat( getNextToken( tokens ) );
res.envRegion = U2Region( envFrom, envTo - envFrom );
getNextToken( tokens );
res.acc = getDouble( getNextToken( tokens ) );
return res;
}
qint64 AssemblyModel::getModelHeight(U2OpStatus & os) {
if(NO_VAL == cachedModelHeight) {
U2AttributeDbi * attributeDbi = dbiHandle.dbi->getAttributeDbi();
if(attributeDbi != NULL) {
U2IntegerAttribute attr = U2AttributeUtils::findIntegerAttribute(attributeDbi, assembly.id, U2BaseAttributeName::max_prow, os);
LOG_OP(os);
if(attr.hasValidId()) {
if(attr.version == assembly.version) {
cachedModelHeight = attr.value;
} else if(checkPermissions(QFile::WriteUser,false)) {
U2AttributeUtils::removeAttribute(attributeDbi, attr.id, os);
LOG_OP(os);
}
}
}
if(cachedModelHeight == NO_VAL) {
// if could not get value from attribute, recompute the value...
cachedModelHeight = assemblyDbi->getMaxPackedRow(assembly.id, U2Region(0, getModelLength(os)), os);
LOG_OP(os);
if(! os.isCoR()) {
// ...and store it in a new attribure
U2IntegerAttribute attr;
U2AttributeUtils::init(attr, assembly, U2BaseAttributeName::max_prow);
attr.value = cachedModelHeight;
attributeDbi->createIntegerAttribute(attr, os);
}
}
if(cachedModelHeight == NO_VAL){
os.setError("Can't get model height, database is corrupted");
LOG_OP(os);
}
}
return cachedModelHeight;
}
QList<SharedAnnotationData> SecStructPredictUtils::saveAlgorithmResultsAsAnnotations(const QByteArray& predicted, const QString& annotationName)
{
char emptyCoil = 'C';
int numAcronyms = predicted.length();
QList<SharedAnnotationData> predictedStructures;
char prevChar = predicted.at(0);
int lastRecordedPos = 0;
for (int i = 1; i < numAcronyms; ++i) {
char curChar = predicted.at(i);
if ((curChar != prevChar) || (i == numAcronyms - 1)) {
if (prevChar != emptyCoil) {
SharedAnnotationData sd(new AnnotationData);
sd->type = U2FeatureTypes::SeconadaryStructure;
sd->name = annotationName;
sd->location->regions.append(U2Region(lastRecordedPos, i - lastRecordedPos));
sd->qualifiers.append(U2Qualifier(BioStruct3D::SecStructTypeQualifierName, getStructNameForCharTag(prevChar)));
predictedStructures.append(sd);
}
lastRecordedPos = i;
}
prevChar = curChar;
}
return predictedStructures;
}
static QVector<U2Region> toRange(const QVector<int>& startPos) {
QVector<U2Region> res;
int prev = 0;
foreach(int pos, startPos) {
res << U2Region(prev, pos - prev);
prev = pos;
}
QList<SharedAnnotationData> FindTandemsToAnnotationsTask::importTandemAnnotations(const QList<Tandem>& tandems, qint64 seqStart, const bool showOverlapped) {
seqStart += s.reportSeqShift;
QList<SharedAnnotationData> res;
foreach(const Tandem& tan, tandems) {
unsigned offset = 0;
const unsigned maxOffset = tan.size % tan.repeatLen;
do{
SharedAnnotationData ad(new AnnotationData());
ad->type = U2FeatureTypes::RepeatRegion;
ad->name = annName;
const quint32 tandemEnd = tan.offset+tan.size+seqStart;
quint32 pos = tan.offset+seqStart+offset;
for(; pos<=tandemEnd-tan.repeatLen; pos+=tan.repeatLen){
ad->location->regions << U2Region(pos, tan.repeatLen);
}
if (ad->location->isEmpty()){
continue;
}
ad->qualifiers.append(U2Qualifier("num_of_repeats", QString::number(tan.size / tan.repeatLen)));
ad->qualifiers.append(U2Qualifier("repeat_length", QString::number(tan.repeatLen)));
ad->qualifiers.append(U2Qualifier("whole_length", QString::number(tan.size)));
U1AnnotationUtils::addDescriptionQualifier(ad, annDescription);
res.append(ad);
offset++;
}while(showOverlapped && offset<=maxOffset);
}
Task::ReportResult GTest_DNASequencePart::report() {
GObject *obj = getContext<GObject>(this,objContextName);
if (obj==NULL) {
stateInfo.setError(QString("wrong value: %1").arg(OBJ_ATTR));
return ReportResult_Finished;
}
U2SequenceObject * objSequence = qobject_cast<U2SequenceObject*>(obj);
if (objSequence==NULL) {
stateInfo.setError(QString("can't cast to sequence from: %1").arg(obj->getGObjectName()));
return ReportResult_Finished;
}
if (objSequence->getSequenceLength() < startPos + subseq.length()) {
stateInfo.setError(QString("sequence size is less that region end: size=%1, region-end=%2, objectName=%3").arg(objSequence->getSequenceLength()).arg(startPos + subseq.length()).arg(obj->getGObjectName()));
return ReportResult_Finished;
}
QByteArray objSubSeq = objSequence->getSequenceData(U2Region(startPos, subseq.length()));
if (!objSequence->getAlphabet()->isCaseSensitive()) {
subseq = subseq.toUpper();
}
if (objSubSeq != subseq){
stateInfo.setError(QString("region not matched: %1, expected %2").arg(objSubSeq.constData()).arg(subseq.constData()));
return ReportResult_Finished;
}
return ReportResult_Finished;
}
void EditFragmentDialog::resetRightOverhang()
{
QByteArray enzymeId = dnaFragment.getRightTerminus().enzymeId;
if (enzymeId.isEmpty()) {
return;
}
const QList<SEnzymeData>& enzymes = EnzymesIO::getDefaultEnzymesList();
SEnzymeData enz = EnzymesIO::findEnzymeById(enzymeId, enzymes);
int rightCutCompl = enz->seq.length() - enz->cutComplement;
int rightCutPos = dnaFragment.getFragmentRegions().last().endPos();
int enzStart = rightCutPos - qMin(enz->cutDirect, rightCutCompl );
int rightOverhangStart = enzStart + qMax(enz->cutDirect, rightCutCompl );
U2OpStatusImpl os;
QByteArray overhang = dnaFragment.getSourceSequenceRegion( U2Region(rightCutPos, rightOverhangStart - rightCutPos), os );
SAFE_POINT_OP(os, );
bool isDirect = enz->cutDirect > rightCutCompl;
if (isDirect) {
rDirectRadioButton->setChecked(true);
rDirectOverhangEdit->setText(overhang);
rComplOverhangEdit->clear();
} else {
rComplRadioButton->setChecked(true);
transl->translate(overhang.data(), overhang.length());
rDirectOverhangEdit->clear();
rComplOverhangEdit->setText(overhang);
}
}
// complementary
foreach(U2Region complementaryRegion, regionsComplementary){
translatedSeq.clear();
U2SequenceImporter importer;
importer.startSequence(stateInfo, dbiRef, U2ObjectDbi::ROOT_FOLDER, seqObj->getSequenceName()+ " " + resultName + QString(" %1").arg(currentSeq) + " complementary", false);
QByteArray complementarySeq;
char* complSeq = NULL;
int blockCounter = 0;
qint64 end = complementaryRegion.endPos() - 1 - complementaryRegion.length / 3 * 3;
for(qint64 i = complementaryRegion.endPos() - 1 ; i > end ;i-=3, blockCounter += 3){
if( (blockCounter % NUM_DB_READ) == 0 ){
importer.addBlock(translatedSeq.constData(), translatedSeq.size(), stateInfo);
complementarySeq.clear();
seq.clear();
translatedSeq.clear();
seq = seqObj->getSequenceData(U2Region(qMax(end + 1, static_cast<qint64>(i - NUM_DB_READ + 1)), qMin(static_cast<qint64>(NUM_DB_READ), i - end)), stateInfo);
CHECK_OP(stateInfo, );
complementarySeq.reserve(seq.size());
complSeq = complementarySeq.data();
TextUtils::translate(complTT->getOne2OneMapper(), seq, seq.size(), complSeq);
TextUtils::reverse(complSeq, seq.size());
blockCounter = 0;
}
SAFE_POINT(complSeq != NULL, "complSeq is NULL", );
translatedSeq.append(aminoTT->translate3to1(complSeq[blockCounter], complSeq[blockCounter + 1], complSeq[blockCounter + 2]));
}
void EditFragmentDialog::resetLeftOverhang() {
QByteArray enzymeId = dnaFragment.getLeftTerminus().enzymeId;
if (enzymeId.isEmpty()) {
return;
}
const QList<SEnzymeData>& enzymes = EnzymesIO::getDefaultEnzymesList();
SEnzymeData enz = EnzymesIO::findEnzymeById(enzymeId, enzymes);
int leftCutCompl = enz->seq.length() - enz->cutComplement;
qint64 cutPos = dnaFragment.getFragmentRegions().first().startPos - qMax(enz->cutDirect, leftCutCompl);
qint64 leftOverhangStart = cutPos + qMin(enz->cutDirect, leftCutCompl);
U2OpStatusImpl os;
QByteArray overhang = dnaFragment.getSourceSequenceRegion( U2Region( leftOverhangStart, dnaFragment.getFragmentRegions().first().startPos - leftOverhangStart), os );
SAFE_POINT_OP(os, );
bool isDirect = enz->cutDirect < leftCutCompl;
if (isDirect) {
lDirectRadioButton->setChecked(true);
lDirectOverhangEdit->setText(overhang);
lComplOverhangEdit->clear();
} else {
lComplRadioButton->setChecked(true);
transl->translate(overhang.data(), overhang.length());
lDirectOverhangEdit->clear();
lComplOverhangEdit->setText(overhang);
}
}
U2Region DetViewMultiLineRenderer::getAnnotationYRange(Annotation *a, int r, const AnnotationSettings *as, const QSize& canvasSize, const U2Region& visibleRange) const {
if (qgetenv(ENV_GUI_TEST).toInt() == 1) {
U2Region res = singleLinePainter->getAnnotationYRange(a, r, as, QSize(canvasSize.width(), getOneLineHeight()), visibleRange);
res.startPos += INDENT_BETWEEN_LINES / 2;
return res;
}
FAIL("The method must never be called", U2Region());
}
void McaEditorReferenceArea::sl_selectMismatch(int pos) {
MaEditorSequenceArea* seqArea = ui->getSequenceArea();
if (seqArea->getFirstVisibleBase() > pos || seqArea->getLastVisibleBase(false) < pos) {
seqArea->centerPos(pos);
}
seqArea->sl_cancelSelection();
setSelection(U2Region(pos, 1));
}
void MuscleAlignDialogController::accept() {
int n = confBox->currentIndex();
assert(n >=0 && n < presets.qlist.size());
const MuscleAlignPreset* p = presets.qlist[n];
p->apply(settings);
if(dynamic_cast<const DefaultModePreset*>(p) != NULL) {
settings.mode = Default;
} else if(dynamic_cast<const LargeModePreset*>(p) != NULL) {
settings.mode = Large;
} else if(dynamic_cast<const RefineModePreset*>(p) != NULL) {
settings.mode = Refine;
} else {
assert(false);
settings.mode = Default;
}
settings.stableMode = stableCB->isChecked();
if (wholeRangeRB->isChecked()) {
settings.regionToAlign = U2Region(0, ma.getLength());
settings.alignRegion = false;
} else {
int startPos = rangeStartSB->value() - 1;
int endPos = rangeEndSB->value() - 1;
if (endPos - startPos < 2) {
QMessageBox::critical(NULL, tr("Error"), tr("Illegal alignment region"));
rangeStartSB->setFocus();
return;
}
settings.alignRegion = true;
settings.regionToAlign = U2Region(startPos, endPos - startPos + 1);
}
if (maxItersCheckBox->isChecked()) {
settings.maxIterations = maxItersSpinBox->value();
assert(settings.maxIterations >= 2);
}
if (maxMinutesCheckBox->isChecked()) {
settings.maxSecs = maxMinutesSpinBox->value() * 60;
assert(settings.maxSecs > 0);
}
QDialog::accept();
}
SharedAnnotationData FindAlgorithmResult::toAnnotation(const QString &name, bool splitCircular, int seqLen) const {
SAFE_POINT(!splitCircular || (seqLen != -1), "Sequence length is not set!", SharedAnnotationData());
SharedAnnotationData data(new AnnotationData);
data->name = name;
if (splitCircular && (region.endPos() > seqLen) ) {
if (region.startPos >= seqLen) {
data->location->regions << U2Region(region.startPos - seqLen, region.length);
} else {
SAFE_POINT(region.startPos < seqLen, "Region is not correct", SharedAnnotationData());
data->location->regions << U2Region(region.startPos, seqLen - region.startPos);
data->location->regions << U2Region(0, region.length - (seqLen - region.startPos));
}
} else {
data->location->regions << region;
}
data->setStrand(strand);
data->qualifiers.append(U2Qualifier("mismatches", QString::number(err)));
return data;
}
PairwiseAlignmentHirschbergTask::PairwiseAlignmentHirschbergTask(PairwiseAlignmentHirschbergTaskSettings* _settings) :
PairwiseAlignmentTask(TaskFlag_NoRun), settings(_settings), kalignSubTask(NULL), workflowKalignSubTask(NULL), ma(NULL) {
SAFE_POINT(settings != NULL, "Task settings are not defined.", );
SAFE_POINT(settings->convertCustomSettings() && settings->isValid(), "Invalide task settings.", );
U2OpStatus2Log os;
DbiConnection con(settings->msaRef.dbiRef, os);
CHECK_OP(os, );
U2Sequence sequence = con.dbi->getSequenceDbi()->getSequenceObject(settings->firstSequenceRef.entityId, os);
CHECK_OP(os, );
first = con.dbi->getSequenceDbi()->getSequenceData(sequence.id, U2Region(0, sequence.length), os);
CHECK_OP(os, );
QString firstName = sequence.visualName;
sequence = con.dbi->getSequenceDbi()->getSequenceObject(settings->secondSequenceRef.entityId, os);
CHECK_OP(os, );
second = con.dbi->getSequenceDbi()->getSequenceData(sequence.id, U2Region(0, sequence.length), os);
CHECK_OP(os, );
QString secondName = sequence.visualName;
con.close(os);
alphabet = U2AlphabetUtils::getById(settings->alphabet);
SAFE_POINT(alphabet != NULL, "Albhabet is invalid.", );
ma = new MAlignment(firstName + " vs. " + secondName, alphabet);
ma->addRow(firstName, first, os);
CHECK_OP(os, );
ma->addRow(secondName, second, os);
CHECK_OP(os, );
KalignTaskSettings kalignSettings;
kalignSettings.gapOpenPenalty = settings->gapOpen;
kalignSettings.gapExtenstionPenalty = settings->gapExtd;
kalignSettings.termGapPenalty = settings->gapTerm;
kalignSettings.secret = settings->bonusScore;
kalignSubTask = new KalignTask(*ma, kalignSettings);
setUseDescriptionFromSubtask(true);
setVerboseLogMode(true);
addSubTask(kalignSubTask);
}
Task* QDORFActor::getAlgorithmTask(const QVector<U2Region>& searchLocation) {
Task* t = NULL;
const DNASequence& dnaSeq = scheme->getSequence();
QMap<QString, Attribute*> params = cfg->getParameters();
switch (getStrandToRun()) {
case QDStrand_Both:
settings.strand = ORFAlgorithmStrand_Both;
break;
case QDStrand_DirectOnly:
settings.strand = ORFAlgorithmStrand_Direct;
break;
case QDStrand_ComplementOnly:
settings.strand = ORFAlgorithmStrand_Complement;
break;
}
settings.minLen = params.value(LEN_ATTR)->getAttributePureValue().toInt();
settings.mustFit = params.value(FIT_ATTR)->getAttributePureValue().toBool();
settings.mustInit = params.value(INIT_ATTR)->getAttributePureValue().toBool();
settings.allowAltStart = params.value(ALT_ATTR)->getAttributePureValue().toBool();
settings.maxResult2Search = params.value(RES_ATTR)->getAttributePureValue().toInt();
settings.searchRegion = U2Region(0, dnaSeq.length());
if (settings.strand != ORFAlgorithmStrand_Direct) {
DNATranslation* compTT = NULL;
if (dnaSeq.alphabet->isNucleic()) {
compTT = AppContext::getDNATranslationRegistry()->
lookupComplementTranslation(dnaSeq.alphabet);
}
if (compTT != NULL) {
settings.complementTT = compTT;
} else {
settings.strand = ORFAlgorithmStrand_Direct;
}
}
const QString& transId = params.value(ID_ATTR)->getAttributeValueWithoutScript<QString>();
settings.proteinTT = AppContext::getDNATranslationRegistry()->
lookupTranslation(dnaSeq.alphabet, DNATranslationType_NUCL_2_AMINO, transId);
if (!settings.proteinTT) {
return new FailTask(tr("Bad sequence"));
}
t = new Task(tr("ORF find"), TaskFlag_NoRun);
assert(orfTasks.isEmpty());
foreach(const U2Region& r, searchLocation) {
ORFAlgorithmSettings stngs(settings);
stngs.searchRegion = r;
ORFFindTask* sub = new ORFFindTask(stngs, scheme->getEntityRef());
orfTasks.append(sub);
t->addSubTask(sub);
}
QVector<U2Region> LRegionsSelection::cropSelection(qint64 sequenceLength, const QVector<U2Region> ®ions) {
QVector<U2Region> result;
foreach (const U2Region ®ion, regions) {
if (region.endPos() < sequenceLength) {
result << region;
} else if (region.startPos < sequenceLength) {
result << U2Region(region.startPos, sequenceLength - region.startPos);
}
}
return result;
}
static void saveSequence( IOAdapter* io, const U2SequenceObject *sequence, U2OpStatus& os ) {
writeHeaderToFile( io, sequence->getSequenceName( ), os );
CHECK_OP( os, );
const int len = sequence->getSequenceLength( );
for ( int i = 0; i < len; i += SAVE_LINE_LEN ) {
int chunkSize = qMin( SAVE_LINE_LEN, len - i );
const QByteArray chunkContent = sequence->getSequenceData( U2Region( i, chunkSize ), os );
CHECK_OP( os, );
writeBlockToFile( io, chunkContent.constData( ), chunkSize, os );
CHECK_OP( os, );
}
}
U2Region RegionSelectorController::getRegion(bool *_ok) const {
SAFE_POINT_EXT(gui.startLineEdit != NULL && gui.endLineEdit != NULL, *_ok = false, U2Region());
bool ok = false;
qint64 v1 = gui.startLineEdit->text().toLongLong(&ok) - 1;
if (!ok || v1 < 0 || v1 > settings.maxLen) {
if (_ok != NULL) {
*_ok = false;
}
return U2Region();
}
int v2 = gui.endLineEdit->text().toLongLong(&ok);
if (!ok || v2 <= 0 || v2 > settings.maxLen) {
if (_ok != NULL) {
*_ok = false;
}
return U2Region();
}
if (v1 > v2 && !settings.circular) { // start > end
if (_ok != NULL) {
*_ok = false;
}
return U2Region();
}
if (_ok != NULL) {
*_ok = true;
}
if (v1 < v2) {
return U2Region(v1, v2 - v1);
} else {
return U2Region(v1, v2 + settings.maxLen - v1);
}
}
void BioStruct3DSubsetEditor::fillRegionEdit() {
if (chainCombo->currentText() != ALL_CHAINS) {
BioStruct3DObject *bso = static_cast<BioStruct3DObject*>( objectCombo->itemData(objectCombo->currentIndex()).value<void*>() );
int chainId = chainCombo->itemData(chainCombo->currentIndex()).value<int>();
int length = bso->getBioStruct3D().moleculeMap.value(chainId)->residueMap.size();
setRegion(U2Region(0, length));
regionEdit->setEnabled(true);
}
else {
regionEdit->setText("");
regionEdit->setDisabled(true);
}
}
bool DetViewMultiLineRenderer::isOnAnnotationLine(const QPoint &p, Annotation *a, int region, const AnnotationSettings *as, const QSize &canvasSize, const U2Region& visibleRange) const {
qint64 symbolsPerLine = getSymbolsPerLine(canvasSize.width());
QSize oneLineMinSize(canvasSize.width(), getMinimumHeight());
U2Region yRange = singleLinePainter->getAnnotationYRange(a, region, as, oneLineMinSize,
U2Region(visibleRange.startPos, qMin(visibleRange.length, symbolsPerLine)));
yRange.startPos += (INDENT_BETWEEN_LINES + extraIndent) / 2;
do {
if (yRange.contains(p.y())) {
return true;
}
yRange.startPos += getOneLineHeight();
} while (canvasSize.height() > yRange.endPos());
return false;
}
U2Region BioStruct3DSubsetEditor::getRegion() {
U2Region ret;
QString text = regionEdit->text();
QStringList broken = text.split("..", QString::SkipEmptyParts);
if (broken.size() != 2) return ret;
bool ok = false;
int start = broken.at(0).toInt(&ok);
if (!ok) return ret;
int end = broken.at(1).toInt(&ok);
if (!ok) return ret;
ret = U2Region(start - 1, end - start + 1);
return ret;
}
McaEditorWgt::McaEditorWgt(McaEditor *editor)
: MaEditorWgt(editor)
{
rowHeightController = new McaRowHeightController(this);
refCharController = new McaReferenceCharController(this, editor);
initActions();
initWidgets();
refArea = new McaEditorReferenceArea(this, getEditor()->getReferenceContext());
connect(refArea, SIGNAL(si_selectionChanged()), statusBar, SLOT(sl_update()));
seqAreaHeaderLayout->insertWidget(0, refArea);
MaEditorConsensusAreaSettings consSettings;
consSettings.visibleElements = MSAEditorConsElement_CONSENSUS_TEXT | MSAEditorConsElement_RULER;
consSettings.highlightMismatches = true;
consArea->setDrawSettings(consSettings);
MSAConsensusAlgorithmFactory* algoFactory = AppContext::getMSAConsensusAlgorithmRegistry()->getAlgorithmFactory(BuiltInConsensusAlgorithms::SIMPLE_EXTENDED_ALGO);
consArea->setConsensusAlgorithm(algoFactory);
QString name = getEditor()->getReferenceContext()->getSequenceObject()->getSequenceName();
QWidget *refName = createHeaderLabelWidget(tr("Reference %1:").arg(name),
Qt::Alignment(Qt::AlignRight | Qt::AlignVCenter), refArea);
refName->setObjectName("reference label container widget");
nameAreaLayout->insertWidget(0, refName);
QVector<U2Region> itemRegions;
for (int i = 0; i < editor->getNumSequences(); i++) {
itemRegions << U2Region(i, 1);
}
collapseModel->setTrivialGroupsPolicy(MSACollapsibleItemModel::Allow);
collapseModel->reset(itemRegions);
collapseModel->collapseAll(false);
collapseModel->setFakeCollapsibleModel(true);
collapsibleMode = true;
McaEditorConsensusArea* mcaConsArea = qobject_cast<McaEditorConsensusArea*>(consArea);
SAFE_POINT(mcaConsArea != NULL, "Failed to cast consensus area to MCA consensus area", );
connect(mcaConsArea->getMismatchController(), SIGNAL(si_selectMismatch(int)), refArea, SLOT(sl_selectMismatch(int)));
}
Task::ReportResult GTest_DNATranslation3to1Test::report() {
GObject *obj = getContext<GObject>(this, objContextName);
if (obj==NULL){
stateInfo.setError(QString("wrong value: %1").arg(OBJ_ATTR));
return ReportResult_Finished;
}
U2SequenceObject * mySequence = qobject_cast<U2SequenceObject*>(obj);
if(mySequence==NULL){
stateInfo.setError(QString("error can't cast to sequence from: %1").arg(obj->getGObjectName()));
return ReportResult_Finished;
}
if(!(mySequence->getAlphabet()->isNucleic())){
stateInfo.setError(QString("error Alphabet is not Nucleic: %1").arg(mySequence->getAlphabet()->getId()));
return ReportResult_Finished;
}
DNATranslation* aminoTransl = 0;
DNATranslationRegistry* tr = AppContext::getDNATranslationRegistry();
QList<DNATranslation*> aminoTs = tr->lookupTranslation(mySequence->getAlphabet(), DNATranslationType_NUCL_2_AMINO);
if (!aminoTs.empty()) {
aminoTransl = tr->getStandardGeneticCodeTranslation(mySequence->getAlphabet());
}
int tempValue;
if(strTo == -1){
tempValue=-1;
} else{
tempValue=(strTo-strFrom+1);
}
QByteArray myByteArray = mySequence->getSequenceData(U2Region(strFrom,tempValue));
QByteArray rezult(myByteArray.length() / 3, 0);
int n = aminoTransl->translate(myByteArray, myByteArray.length(), rezult.data(), rezult.length());
assert(n == rezult.length()); Q_UNUSED(n);
if(rezult != stringValue.toLatin1()){
stateInfo.setError(QString("translated sequence not matched: %1, expected %2 ").arg(rezult.data()).arg(stringValue));
return ReportResult_Finished;
}
return ReportResult_Finished;
}
void ORFDialog::runTask() {
assert(task == NULL);
ORFAlgorithmSettings s;
getSettings(s);
if(!isRegionOk){
rs->showErrorMessage();
return;
}
const U2Region wholeSequenceRegion = U2Region(0, ctx->getSequenceLength());
s.searchRegion = s.searchRegion.intersect(wholeSequenceRegion);
if (s.searchRegion.isEmpty()) {
s.searchRegion = wholeSequenceRegion;
}
task = new ORFFindTask(s, ctx->getSequenceObject()->getEntityRef());
AppContext::getTaskScheduler()->registerTopLevelTask(task);
updateState();
timer->start(400);
}
const U2AssemblyCoverageStat &AssemblyModel::getCoverageStat(U2OpStatus & os) {
QMutexLocker mutexLocker(&mutex);
Q_UNUSED(mutexLocker);
if(cachedCoverageStat.isEmpty()) {
U2AttributeDbi * attributeDbi = dbiHandle.dbi->getAttributeDbi();
if(NULL != attributeDbi) {
U2ByteArrayAttribute attr = U2AttributeUtils::findByteArrayAttribute(attributeDbi, assembly.id, COVERAGE_STAT_ATTRIBUTE_NAME, os);
if(!os.isCoR()) {
if(attr.hasValidId()) {
// TODO: check version
U2AssemblyUtils::deserializeCoverageStat(attr.value, cachedCoverageStat, os);
} else {
qint64 length = getModelLength(os);
if(!os.isCoR()) {
static const qint64 MAX_COVERAGE_CACHE_SIZE = 1000*1000;
int coverageCacheSize = (int)qMin(MAX_COVERAGE_CACHE_SIZE, length);
cachedCoverageStat.resize(coverageCacheSize);
calculateCoverageStat(U2Region(0, length), cachedCoverageStat, os);
if(!os.isCoR()) {
U2ByteArrayAttribute attribute;
attribute.objectId = assembly.id;
attribute.name = COVERAGE_STAT_ATTRIBUTE_NAME;
attribute.value = U2AssemblyUtils::serializeCoverageStat(cachedCoverageStat);
attribute.version = assembly.version;
U2OpStatusImpl opStatus;
attributeDbi->createByteArrayAttribute(attribute, opStatus);
LOG_OP(opStatus);
}
}
}
}
} else {
os.setError("Attribute DBI is not supported");
}
}
return cachedCoverageStat;
}
void CollocationsDialogController::sl_searchClicked() {
resultsList->clear();
assert(usedNames.size() >= 2);
CollocationsAlgorithmSettings cfg;
cfg.distance = regionSpin->value();
assert(task == NULL);
const QList<AnnotationTableObject*>& aObjects = ctx->getAnnotationObjects().toList();
cfg.searchRegion = U2Region(0, ctx->getSequenceLength());
if (!wholeAnnotationsBox->isChecked()) {
cfg.st = CollocationsAlgorithm::PartialSearch;
}
if(rbDirect->isChecked()){
cfg.strand = StrandOption_DirectOnly;
}else if(rbComplement->isChecked()){
cfg.strand = StrandOption_ComplementOnly;
}else if (rbBoth->isChecked()){
cfg.strand = StrandOption_Both;
}
task = new CollocationSearchTask(aObjects, usedNames, cfg);
AppContext::getTaskScheduler()->registerTopLevelTask(task);
timer->start(400);
updateState();
}
void McaEditorReferenceArea::keyPressEvent(QKeyEvent *event) {
const int key = event->key();
bool accepted = false;
DNASequenceSelection * const selection = ctx->getSequenceSelection();
U2Region selectedRegion = (NULL != selection && !selection->isEmpty() ? selection->getSelectedRegions().first() : U2Region());
switch(key) {
case Qt::Key_Left:
if (!selectedRegion.isEmpty() && selectedRegion.startPos > 0) {
selectedRegion.startPos--;
ctx->getSequenceSelection()->setSelectedRegions(QVector<U2Region>() << selectedRegion);
ui->getScrollController()->scrollToBase(selectedRegion.startPos, width());
}
case Qt::Key_Up:
accepted = true;
break;
case Qt::Key_Right:
if (!selectedRegion.isEmpty() && selectedRegion.endPos() < ctx->getSequenceLength()) {
selectedRegion.startPos++;
ctx->getSequenceSelection()->setSelectedRegions(QVector<U2Region>() << selectedRegion);
ui->getScrollController()->scrollToBase(selectedRegion.endPos() - 1, width());
}
case Qt::Key_Down:
accepted = true;
break;
case Qt::Key_Home:
ui->getScrollController()->scrollToEnd(ScrollController::Left);
accepted = true;
break;
case Qt::Key_End:
ui->getScrollController()->scrollToEnd(ScrollController::Right);
accepted = true;
break;
case Qt::Key_PageUp:
ui->getScrollController()->scrollPage(ScrollController::Left);
accepted = true;
break;
case Qt::Key_PageDown:
ui->getScrollController()->scrollPage(ScrollController::Right);
accepted = true;
break;
}
if (accepted) {
event->accept();
} else {
PanView::keyPressEvent(event);
}
}
QList<Task *> SpideyAlignmentTask::onSubTaskFinished(Task *subTask) {
QList<Task *> res;
propagateSubtaskError();
if (hasError() || isCanceled()) {
return res;
}
if (subTask == prepareDataForSpideyTask) {
SAFE_POINT(!prepareDataForSpideyTask->getResultPath().isEmpty(), "Invalid result path!",
res);
tmpOutputUrl = prepareDataForSpideyTask->getResultPath();
const QStringList &arguments = prepareDataForSpideyTask->getArgumentsList();
spideyTask = new ExternalToolRunTask(ET_SPIDEY, arguments, new SpideyLogParser());
spideyTask->setSubtaskProgressWeight(95);
res.append(spideyTask);
} else if (subTask == spideyTask) {
if (!QFile::exists(tmpOutputUrl)) {
if (AppContext::getExternalToolRegistry()->getByName(ET_SPIDEY)->isValid()) {
stateInfo.setError(tr("Output file not found"));
} else {
ExternalTool *spideyTool = AppContext::getExternalToolRegistry()->getByName(ET_SPIDEY);
SAFE_POINT(NULL != spideyTool, "Invalid Spidey tool!", res);
stateInfo.setError(
tr("Output file not found. May be %1 tool path '%2' not valid?")
.arg(spideyTool->getName()).arg(spideyTool->getPath()));
}
return res;
}
// parse result
QFile resultFile(tmpOutputUrl);
if (!resultFile.open(QFile::ReadOnly)) {
setError(tr("Failed to open result file %1").arg(tmpOutputUrl));
return res;
}
QTextStream inStream(&resultFile);
bool strandDirect = true;
U2Location location;
location->op = U2LocationOperator_Join;
while (!inStream.atEnd()) {
QByteArray buf = inStream.readLine().toLatin1();
if (buf.startsWith("Strand")) {
strandDirect = buf.contains("plus");
}
if (buf.startsWith("Exon")) {
// TODO: better to use reg exp here
int startPos = buf.indexOf(":") + 1;
int endPos = buf.indexOf("(gen)");
if (startPos == -1 || endPos == -1) {
continue;
}
QByteArray loc = buf.mid(startPos, endPos - startPos).trimmed();
QList<QByteArray> loci = loc.split('-');
if (loci.size() < 2) {
continue;
}
int start = QString(loci.at(0)).toInt();
int finish = QString(loci.at(1)).toInt();
if (start == finish) {
continue;
}
location->regions.append(U2Region(start - 1, finish - start + 1));
}
}
if (!location->isEmpty()) {
SharedAnnotationData data(new AnnotationData);
data->location = location;
data->setStrand(U2Strand(strandDirect ? U2Strand::Direct : U2Strand::Complementary));
data->type = U2FeatureTypes::Exon;
data->name = "exon";
U1AnnotationUtils::addDescriptionQualifier(data, annDescription);
resultAnnotations.append(data);
}
}
return res;
}
U2Region DetViewMultiLineRenderer::getMirroredYRange(const U2Strand &) const {
FAIL("The method must never be called", U2Region());
}
