VarExprReturnSP LitMatrixExprReturn::convertToVarExprReturn( VarExprReturn &varExprReturn ) {
SFC::DT dt = getDT();
// assert( dt == varExprReturn.getDT() );
SFCTypesManager::DimensionVector dimensionVector = SFCTypesManager::getDimensions( dt );
if ( dimensionVector.empty() ) {
Exprs exprs = DE( getSequence().front() );
VarExprReturnSP varExprReturnSP = VarExprReturn::create( getBlock(), exprs, ExprsProxyVector(), SFCTypesManager::getSingleton().getBasicType( "double" ) );
varExprReturn.combine( "=", varExprReturnSP )->collapse();
return VarExprReturn::create( varExprReturn );
}
SFCTypesManager::DimensionVector countVector( dimensionVector.size(), 0 );
for( Sequence::iterator sqnItr = getSequence().begin() ; sqnItr != getSequence().end() ; ++sqnItr ) {
for( unsigned int ix = 0 ; ix < (unsigned int) dimensionVector.size() ; ++ix ) {
varExprReturn.getExprsProxyVector()[ ix ].setExprs( IE( countVector[ ix ] ) );
}
Exprs exprs = BE( varExprReturn.getExprs(), "=", DE( *sqnItr ) );
exprs.buildUdm( getBlock(), SFC::CompoundStatement::meta_stmnt );
for( int ix = dimensionVector.size() ; --ix >= 0 ;) {
if ( ++countVector[ix] < dimensionVector[ix] ) break;
countVector[ix] = 0;
}
}
return VarExprReturn::create( varExprReturn );
}
//This function gets the node's sequence. The full parameter only has an effect
//for Velvet LastGraph files where the sequences are shifted from their reverse
//complement. If full is true and the graph is from Velvet, this function will
//extend the sequence using either the reverse complement or upstream nodes.
QByteArray DeBruijnNode::getFullSequence() const
{
if (g_assemblyGraph->m_graphFileType != LAST_GRAPH)
return getSequence();
//If the code got here, then we are getting a full sequence from a Velvet
//LastGraph graph, so we need to extend the beginning of the sequence.
int extensionLength = g_assemblyGraph->m_kmer - 1;
//If the node is at least k-1 in length, then the necessary sequence can be
//deduced from the reverse complement node.
if (getLength() >= extensionLength)
{
QByteArray revCompSeq = getReverseComplement()->getSequence();
QByteArray endOfRevCompSeq = revCompSeq.right(extensionLength);
QByteArray extension = AssemblyGraph::getReverseComplement(endOfRevCompSeq);
return extension + getSequence();
}
//If the node is not long enough, then we must look in upstream nodes for
//the rest of the sequence.
else
{
QByteArray extension = getUpstreamSequence(extensionLength);
if (extension.length() < extensionLength)
{
int additionalBases = extensionLength - extension.length();
QByteArray n;
n.fill('N', additionalBases);
extension = n + extension;
}
return extension + getSequence();
}
}
bool UniPAX::DnaReference::merge(DnaReference& object)
{
if (subRegion != 0)
{
if (object.getSubRegion() != 0)
{
if (subRegion->getUnipaxId() != object.getSubRegion()->getUnipaxId())
{
std::cerr << "Error during merging: UniPAX::DnaReference::subRegion not equal ..."
<< subRegion->getUnipaxId() << " != " << object.getSubRegion()->getUnipaxId() << std::endl;
return false;
}
}
}
else
{
setSubRegion(object.getSubRegion());
}
if (organism != 0)
{
if (object.getOrganism() != 0)
{
if (organism->getUnipaxId() != object.getOrganism()->getUnipaxId())
{
std::cerr << "Error during merging: UniPAX::DnaReference::organism not equal ..."
<< organism->getUnipaxId() << " != " << object.getOrganism()->getUnipaxId() << std::endl;
return false;
}
}
}
else
{
setOrganism(object.getOrganism());
}
if (!object.getSequence().empty())
{
if (!getSequence().empty())
{
if (getSequence() != object.getSequence())
{
std::cerr << "Error during merging: UniPAX::DnaReference::sequence not equal ..."
<< getSequence() << " != " << object.getSequence() << std::endl;
return false;
}
}
else
setSequence(object.getSequence());
}
return UniPAX::EntityReference::merge(object);
}
ExprReturnSP LitMatrixExprReturn::collapseLogical() {
if ( getDT().type() != SFC::Array::meta ) return create( *this );
Sequence::iterator sqnItr = getSequence().begin();
SFC::LocalVar localVar = SFCManager::createUniqueLocalVar( getBlock(), "test" );
bool value = *sqnItr != 0;
while( ++sqnItr != getSequence().end() ) value = value && ( *sqnItr != 0 );
return create( getBlock(), value );
}
VarMatrixExprReturnSP LitMatrixExprReturn::convertToVarMatrixExprReturn( void ) {
VarMatrixExprReturn::Sequence sequence;
if ( !getSequence().empty() ) {
SFC::DT dt = SFCTypesManager::getSingleton().getBaseDT( getDT() );
for( Sequence::iterator sqnItr = getSequence().begin() ; sqnItr != getSequence().end() ; (void)++sqnItr ) {
Exprs exprs = DE( *sqnItr );
sequence.push_back( VarExprReturn::create( getBlock(), exprs, ExprsProxyVector(), dt ) );
}
}
return VarMatrixExprReturn::create( getBlock(), getDT(), sequence );
}
void FineSegmenter::findCDR3(){
JUNCTIONstart = box_V->marked_pos;
JUNCTIONend = box_J->marked_pos;
// There are two cases when we can not detect a JUNCTION/CDR3:
// - Germline V or J gene has no 'marked_pos'
// - Sequence may be too short on either side, and thus the backtrack did not find a suitable 'marked_pos'
if (JUNCTIONstart == 0 || JUNCTIONend == 0)
return;
// We require at least two codons
if (JUNCTIONend - JUNCTIONstart + 1 < 6) {
JUNCTIONstart = -1 ;
JUNCTIONend = -1 ;
return ;
}
// We require at least one more nucleotide to export a CDR3
if (JUNCTIONend - JUNCTIONstart + 1 < 7) {
JUNCTIONproductive = false ;
return ;
}
// IMGT-CDR3 is, on each side, 3 nucleotides shorter than IMGT-JUNCTION
CDR3start = JUNCTIONstart + 3;
CDR3end = JUNCTIONend - 3;
CDR3nuc = subsequence(getSequence().sequence, CDR3start, CDR3end);
if (CDR3nuc.length() % 3 == 0)
{
CDR3aa = nuc_to_aa(CDR3nuc);
}
else
{
// start of codon fully included in the germline J
int CDR3startJfull = JUNCTIONend - ((JUNCTIONend - box_J->start) / 3) * 3 + 1 ;
CDR3aa =
nuc_to_aa(subsequence(getSequence().sequence, CDR3start, CDR3startJfull-1)) +
nuc_to_aa(subsequence(getSequence().sequence, CDR3startJfull, CDR3end));
}
JUNCTIONaa = nuc_to_aa(subsequence(getSequence().sequence, JUNCTIONstart, CDR3start-1))
+ CDR3aa + nuc_to_aa(subsequence(getSequence().sequence, CDR3end+1, JUNCTIONend));
JUNCTIONproductive = (CDR3nuc.length() % 3 == 0) && (JUNCTIONaa.find('*') == string::npos);
}
void TSThread::activateTriggers(F32 a, F32 b)
{
S32 i;
const TSShape * shape = mShapeInstance->mShape;
S32 firstTrigger = getSequence()->firstTrigger;
S32 numTriggers = getSequence()->numTriggers;
// first find triggers at position a and b
// we assume there aren't many triggers, so
// search is linear
F32 lastPos = -1.0f;
S32 aIndex = numTriggers+firstTrigger; // initialized to handle case where pos past all triggers
S32 bIndex = numTriggers+firstTrigger; // initialized to handle case where pos past all triggers
for (i=firstTrigger; i<numTriggers+firstTrigger; i++)
{
TSShape::Trigger currentTrigger = shape->triggers[i];
// is a between this trigger and previous one...
if (a>lastPos && a <= currentTrigger.pos)
aIndex = i;
// is b between this trigger and previous one...
if (b>lastPos && b <= currentTrigger.pos)
bIndex = i;
lastPos = currentTrigger.pos;
}
// activate triggers between aIndex and bIndex (depends on direction)
if (aIndex<=bIndex)
{
for (i=aIndex; i<bIndex; i++)
{
U32 state = shape->triggers[i].state;
bool on = (state & TSShape::Trigger::StateOn)!=0;
mShapeInstance->setTriggerStateBit(state & TSShape::Trigger::StateMask, on);
}
}
else
{
for (i=aIndex-1; i>=bIndex; i--)
{
U32 state = shape->triggers[i].state;
bool on = (state & TSShape::Trigger::StateOn)!=0;
if (state & TSShape::Trigger::InvertOnReverse)
on = !on;
mShapeInstance->setTriggerStateBit(state & TSShape::Trigger::StateMask, on);
}
}
}
void TSThread::transitionToSequence(S32 seq, F32 toPos, F32 duration, bool continuePlay)
{
AssertFatal(duration>=0.0f,"TSThread::transitionToSequence: negative duration not allowed");
// make sure these nodes are smoothly interpolated to new positions...
// basically, any node we controlled just prior to transition, or at any stage
// of the transition is interpolated. If we start to transtion from A to B,
// but before reaching B we transtion to C, we interpolate all nodes controlled
// by A, B, or C to their new position.
if (transitionData.inTransition)
{
transitionData.oldRotationNodes.overlap(getSequence()->rotationMatters);
transitionData.oldTranslationNodes.overlap(getSequence()->translationMatters);
transitionData.oldScaleNodes.overlap(getSequence()->scaleMatters);
}
else
{
transitionData.oldRotationNodes = getSequence()->rotationMatters;
transitionData.oldTranslationNodes = getSequence()->translationMatters;
transitionData.oldScaleNodes = getSequence()->scaleMatters;
}
// set time characteristics of transition
transitionData.oldSequence = sequence;
transitionData.oldPos = pos;
transitionData.duration = duration;
transitionData.pos = 0.0f;
transitionData.direction = timeScale>0.0f ? 1.0f : -1.0f;
transitionData.targetScale = continuePlay ? 1.0f : 0.0f;
// in transition...
transitionData.inTransition = true;
// set target sequence data
sequence = seq;
priority = getSequence()->priority;
pos = toPos;
makePath = getSequence()->makePath();
path.start = path.end = 0;
path.loop = 0;
// 1.0f doesn't exist on cyclic sequences
if (pos>0.9999f && getSequence()->isCyclic())
pos = 0.9999f;
// select keyframes
selectKeyframes(pos,getSequence(),&keyNum1,&keyNum2,&keyPos);
}
/*
Binary to struct helper for RSA public keys.
*/
int32 matrixRsaParsePubKey(psPool_t *pool, unsigned char *keyBuf,
int32 keyBufLen, sslRsaKey_t **key)
{
unsigned char *p, *end;
int32 len;
p = keyBuf;
end = p + keyBufLen;
/*
Supporting both the PKCS#1 RSAPublicKey format and the
X.509 SubjectPublicKeyInfo format. If encoding doesn't start with
the SEQUENCE identifier for the SubjectPublicKeyInfo format, jump down
to the RSAPublicKey subset parser and try that
*/
if (getSequence(&p, (int32)(end - p), &len) == 0) {
if (getAlgorithmIdentifier(&p, (int32)(end - p), &len, 1) < 0) {
return -1;
}
}
/*
Now have the DER stream to extract from in asnp
*/
*key = psMalloc(pool, sizeof(sslRsaKey_t));
if (*key == NULL) {
return -8; /* SSL_MEM_ERROR */
}
memset(*key, 0x0, sizeof(sslRsaKey_t));
if (getPubKey(pool, &p, (int32)(end - p), *key) < 0) {
matrixRsaFreeKey(*key);
*key = NULL;
matrixStrDebugMsg("Unable to ASN parse public key\n", NULL);
return -1;
}
return 0;
}
int CClientAmxController::startClient(int msqKey)
{
_log(LOG_TAG" Connecting to AMX controller validation service %s:%d",
serverIp.c_str(), validationPort);
int nRet = connectWithCallback(serverIp.c_str(), validationPort, msqKey,
[](CATcpClient *caller, pthread_t msgRecvTid, pthread_t pktRecvTid) -> void
{
pthread_setname_np(msgRecvTid, "AmxMsgRecv");
pthread_setname_np(pktRecvTid, "AmxPktRecv");
});
if (nRet < 0)
{
_log(LOG_TAG" startClient() Connecting to AMX controller FAILED");
return FALSE;
}
tokenCache.clear();
nRet = request(getSocketfd(), bind_request, STATUS_ROK, getSequence(), NULL);
if (nRet < 0)
{
_log(LOG_TAG" startClient() Binding to AMX controller FAILED");
return FALSE;
}
// enquireLinkYo starts in onResponse(), when binding response is received
return TRUE;
}
INode * REParser::getSequence(char start, char end)
{
INode * ret = new FinalChar(start);
if (start != end)
ret = new Or(ret, getSequence(start + 1, end));
return ret;
}
void Widget::on_Gene_done_clicked()
{
QString temp=ui->gene->text();
gene_sequence=temp.toStdString();
QAction::connect(this,SIGNAL(pass_sequence(string,string)),console_ui,SLOT(getSequence(string,string)));
emit pass_sequence(promoter_sequence,gene_sequence);
for(int i=0;i<GENEAM;i++)
{
QAction::connect(this,SIGNAL(pass_information(GeneIM,int)),console_ui,SLOT(getInformation(GeneIM,int)));
emit pass_information(ecoli[i],i);
}
this->hide();
console_ui->show();
if((int)promoter_sequence.size()<50||(int)gene_sequence.size()<50)
{
console_ui->ui->analyze->setStyleSheet("#analyze{border-image: url(:/picture/picture/gray1.png);color:white;font: 75 18pt \"Arial\";}#analyze:hover{border-image: url(:/picture/picture/gray2.png);}");
console_ui->analyze_flag=1;
console_ui->ui->tips->setText("Sleepy?");
}
else
{
console_ui->ui->analyze->setStyleSheet("#analyze{border-image: url(:/picture/picture/blue1.png);color:white;font: 75 18pt \"Arial\";}#analyze:hover{border-image: url(:/picture/picture/blue2.png);}");
console_ui->analyze_flag=0;
console_ui->ui->tips->setText("Sleepy?");
}
}
void PacketQueue::add(const void* data, int len)
{
switch (getProtocolOpcode(data))
{
case OP_Combined:
readCombined(data, len);
break;
case OP_Packet:
case OP_Fragment:
{
uint16_t seq = getSequence(data);
if (seq == m_nextSeq)
{
m_connection.sendToLocal(data, len);
sendQueued(seq + 1);
}
else
{
enqueue(data, len, seq);
}
break;
}
case OP_SessionDisconnect:
m_connection.endSession();
// Fallthrough
default:
// Forward anything that didn't need special handling
m_connection.sendToLocal(data, len);
break;
}
}
SequenceVector Contig::getVariants() const
{
SequenceVector out;
out.push_back(getSequence());
out.insert(out.end(), m_variants.begin(), m_variants.end());
return out;
}
void TSThread::animateTriggers()
{
if (!getSequence()->numTriggers)
return;
switch (path.loop)
{
case -1 :
activateTriggers(path.start,0);
activateTriggers(1,path.end);
break;
case 0 :
activateTriggers(path.start,path.end);
break;
case 1 :
activateTriggers(path.start,1);
activateTriggers(0,path.end);
break;
default:
{
if (path.loop>0)
{
activateTriggers(path.end,1);
activateTriggers(0,path.end);
}
else
{
activateTriggers(path.end,0);
activateTriggers(1,path.end);
}
}
}
}
void print_sequence(int seqId)
{
char *seqDes = descriptions_getDescription_mem(readdb_sequenceData[seqId].descriptionStart, readdb_sequenceData[seqId].descriptionLength);
char *seq = getSequence(seqId);
printf(">%s\n%s\n", seqDes, seq);
free(seqDes); free(seq);
}
QList<double> QuickSort::Sort(){
curList = getSequence();
if ( curList.count() > 0 ){
sortIt(0,curList.count()-1);
}
return curList;
}
/*!
* \brief Functions::getSequence returns the next available sequence of specified table from database.
* \param className refers to the class name, which is the table name in database.
* \param db refers to the database connection.
* \return next available sequence of specified table.
*/
qlonglong Functions::getSequence(const QString &className, QSqlDatabase *db)
{
qlonglong result = -1;
try {
SqlQuery query(db);
query.prepare("select nextvalue from sequences where name = :name");
query.bindValue(":name", className);
query.exec();
if(query.next()){
// If sequence exists, update the table with the new available sequence.
result = query.value(0).toLongLong();
SqlQuery updateQuery(db);
updateQuery.prepare("update sequences set nextvalue = :value where name = :name");
qlonglong nextValue = result + 1;
updateQuery.bindValue(":value", nextValue);
updateQuery.bindValue(":name", className);
updateQuery.exec();
}else{
// If sequence does not exists, the system creates one and returns its next value
SqlQuery query(db);
query.prepare("insert into sequences(name, initialvalue, nextvalue)"
"values(:name, :initialvalue, :nextvalue)");
query.bindValue(":name", className);
query.bindValue(":initialvalue", 1);
query.bindValue(":nextvalue", 1);
query.exec();
return getSequence(className, db);
}
}catch(SqlException &ex){
Logger::instance()->writeRecord(Logger::severity_level::critical, "PersistenceModule", Q_FUNC_INFO, QString("Transaction Error: %1").arg(ex.what()));
return -1;
}
return result;
}
string FastaReference::getTargetSubSequence(FastaRegion& target) {
if (target.startPos == -1) {
return getSequence(target.startSeq);
} else {
return getSubSequence(target.startSeq, target.startPos - 1, target.length());
}
}
static void down_to_transport(CnetEvent ev, CnetTimer timer, CnetData data) {
/* our packet */
TR_PACKET p;
/* destination address to pass to network layer */
CnetAddr temp;
p.length = sizeof(p.msg);
CHECK(CNET_read_application(&temp, p.msg, &p.length));
CNET_disable_application(temp);
/* establish sequence number */
unsigned long seq = getSequence(temp);
if( seq == -1) {
addAddress(temp,0);
p.sequence_number = 0;
}
else {
unsigned long newseq = seq + p.length;
setSequence(temp,newseq);
p.sequence_number = newseq;
}
p.checksum = checksum_crc32( ((char*)&p)+sizeof(unsigned int)
, TR_PACKET_SIZE(p) - sizeof(unsigned int));
down_to_network( (char*)&p , TR_PACKET_SIZE(p) , temp);
/* enqueuePacket((char*)&p, TR_PACKET_SIZE(p), temp); */
CNET_start_timer(EV_TIMER1, 1000, (CnetData)1);
}
/*
Get the BIT STRING key and plug into RSA structure. Not included in
asn1.c because it deals directly with the sslRsaKey_t struct.
*/
int32 getPubKey(psPool_t *pool, unsigned char **pp, int32 len,
sslRsaKey_t *pubKey)
{
unsigned char *p = *pp;
int32 pubKeyLen, ignore_bits, seqLen;
if (len < 1 || (*(p++) != ASN_BIT_STRING) ||
asnParseLength(&p, len - 1, &pubKeyLen) < 0 ||
(len - 1) < pubKeyLen) {
return -1;
}
ignore_bits = *p++;
/*
We assume this is always zero
*/
sslAssert(ignore_bits == 0);
if (getSequence(&p, pubKeyLen, &seqLen) < 0 ||
getBig(pool, &p, seqLen, &pubKey->N) < 0 ||
getBig(pool, &p, seqLen, &pubKey->e) < 0) {
return -1;
}
pubKey->size = mp_unsigned_bin_size(&pubKey->N);
*pp = p;
return 0;
}
set<TS_UINT64> CBlock::scanMissingPackets() {
set<TS_UINT64> answers; // 将数组号转换成的序列号
iop_lock(&mapLock);
for (auto iter = blockContents.begin(); iter != blockContents.end();) { // 搜包
set<int> results; // 获取保存的位置号
CPackage* pack = iter->second;
if (pack->isFull()) {
straWrite->onMsgScanStrategy(pack); // 写文件扫描触发
if (straDestroy->onMsgScanStrategy(pack)) { // 销毁包扫描触发
delete iter->second; // 若返回true则销毁
iter->second = NULL;
blockContents.erase(iter++);
} else {
iter++;
}
} else {
int answer = pack->scanMissingPackets(results); // 获取包内丢失packet的位置
for (auto i = results.begin(); i != results.end(); i++) {
answers.insert(getSequence(iter->first, (*i))); // 根据包号，位置号，得到序号
}
iter++;
}
}
iop_unlock(&mapLock);
return answers;
}
MatrixExprReturnSP LitMatrixExprReturn::appendColumns( LitMatrixExprReturn &litMatrixExprReturn ) {
__int64 thisRows, thisColumns;
getRowsAndColumns( thisRows, thisColumns );
if ( thisRows == 0 ) return LitMatrixExprReturn::create( litMatrixExprReturn );
__int64 rhsRows, rhsColumns;
litMatrixExprReturn.getRowsAndColumns( rhsRows, rhsColumns );
if ( rhsRows == 0 ) return LitMatrixExprReturn::create( *this );
assert( thisRows == rhsRows );
Sequence sequence;
Sequence::iterator sqnItr1 = getSequence().begin();
Sequence::iterator sqnItr2 = litMatrixExprReturn.getSequence().begin();
for( int ix = 0 ; ix < thisRows ; (void)++ix ) {
for ( int jx = 0 ; jx < thisColumns ; (void)++jx ) {
sequence.push_back( *sqnItr1 );
(void)++sqnItr1;
}
for ( int jx = 0 ; jx < rhsColumns ; (void)++jx ) {
sequence.push_back( *sqnItr2 );
(void)++sqnItr2;
}
}
SFC::DT dominantDT = SFCTypesManager::getDominantType( getDT(), litMatrixExprReturn.getDT() );
return create( getBlock(), (int) thisRows, (int) thisColumns + rhsColumns, dominantDT, sequence );
}
ExprReturnSP LitMatrixExprReturn::applyUnaryOp( const std::string &op ) {
UnaryFunction unaryFunction = getUnaryFunction( op );
if ( unaryFunction == 0 ) {
std::cerr << "WARNING: operation \"" << op << "\" not supported on literals." << std::endl;
VarExprReturnSP varExprReturnSP = convertToVarExprReturn();
return varExprReturnSP->applyUnaryOp( op );
}
Sequence sequence;
for( Sequence::iterator sqnItr = getSequence().begin() ; sqnItr != getSequence().end() ; (void)++sqnItr ) {
sequence.push_back( unaryFunction( *sqnItr ) );
}
return create( getBlock(), getDT(), sequence );
}
ExprReturnSP LitMatrixExprReturn::multiply( LitMatrixExprReturn &litMatrixExprReturn ) {
__int64 rows1, columns1;
getRowsAndColumns( rows1, columns1 );
__int64 rows2, columns2;
litMatrixExprReturn.getRowsAndColumns( rows2, columns2 );
if ( rows1 == 1 && columns1 == 1 ) {
double multiplier = getSequence()[0];
Sequence sequence = litMatrixExprReturn.getSequence();
for( Sequence::iterator sqnItr = sequence.begin() ; sqnItr != sequence.end() ; (void)++sqnItr ) {
*sqnItr *= multiplier;
}
return create( getBlock(), litMatrixExprReturn.getDT(), sequence );
}
if ( rows2 == 1 && columns2 == 1 ) {
double multiplier = litMatrixExprReturn.getSequence()[0];
Sequence sequence = getSequence();
for( Sequence::iterator sqnItr = sequence.begin() ; sqnItr != sequence.end() ; (void)++sqnItr ) {
*sqnItr *= multiplier;
}
return create( getBlock(), getDT(), sequence );
}
if ( columns1 != rows2 ) {
if ( ( rows1 == 1 || columns1 == 1 ) && rows1 == rows2 ) std::swap( rows1, columns1 );
else if ( ( rows2 == 1 || columns2 == 1 ) && columns1 == columns2 ) std::swap( rows2, columns2 );
else { /* THROW ERROR */ }
}
Sequence sequence;
Sequence &rhsSequence = litMatrixExprReturn.getSequence();
for( long long ix = 0 ; ix < rows1 ; (void)++ix ) {
for( long long jx = 0 ; jx < columns2 ; (void)++jx ) {
double sum = 0;
for( long long kx = 0 ; kx < columns1 ; (void)++kx ) {
sum += getSequence()[ ix*rows1 + kx ] * rhsSequence[ kx*rows2 + jx ];
}
sequence.push_back( sum );
}
}
SFC::DT dominantDT = SFCTypesManager::getDominantType( getDT(), litMatrixExprReturn.getDT() );
return create( getBlock(), (int) rows1, (int) columns2, dominantDT, sequence );
}
/****************************************************************************
**
** Copyright (C) 2016 - 2017
**
** This file is generated by the Magus toolkit
**
** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
**
****************************************************************************/
// Include
#include <float.h>
#include <QMessageBox>
#include <QSettings>
#include "constants.h"
#include "hlms_node_samplerblock.h"
#include "hlms_node_porttypes.h"
//****************************************************************************/
HlmsNodeSamplerblock::HlmsNodeSamplerblock(QString title, QGraphicsItem* parent) :
Magus::QtNode(title, parent),
mTextureType(0),
mTextureIndex(0),
mSamplerblockEnabled(true),
mTextureAddressingModeU(0),
mTextureAddressingModeV(0),
mTextureAddressingModeW(0),
mMipLodBias(0.0f),
mMaxAnisotropy(1.0f),
mCompareFunction(8),
mMinLod(-FLT_MAX),
mMaxLod(FLT_MAX),
mBorderColourRed(255.0f),
mBorderColourGreen(255.0f),
mBorderColourBlue(255.0f),
mUvSet(0),
mBlendMode(0),
mMapWeight(1.0f),
mEmissiveColourRed(0.0f),
mEmissiveColourGreen(0.0f),
mEmissiveColourBlue(0.0f),
mAnimationEnabled(false),
mSequenceNumber(-1)
{
mFileNameTexture = QString("");
mBaseNameTexture = QString("");
mPathTexture = QString("");
mOffset = QVector2D(0.0f, 0.0f);
mScale = QVector2D(1.0f, 1.0f);
mAnimationScale = QVector2D(1.0f, 1.0f);
mAnimationTranslate = QVector2D(0.0f, 0.0f);
// Define the connection policy
HlmsPbsDatablockSamplerblockPortType hlmsPbsDatablockSamplerblockPortType;
HlmsSamplerblockDatablockPortType hlmsSamplerblockDatablockPortType;
hlmsPbsDatablockSamplerblockPortType.addPortTypeToConnectionPolicy(hlmsSamplerblockDatablockPortType);
// Apply values from settings.cfg
QSettings settings(FILE_SETTINGS, QSettings::IniFormat);
mTextureMinFilter = settings.value(SETTINGS_SAMPLERBLOCK_FILTER_INDEX).toInt();
mTextureMagFilter = settings.value(SETTINGS_SAMPLERBLOCK_FILTER_INDEX).toInt();
mTextureMipFilter = settings.value(SETTINGS_SAMPLERBLOCK_FILTER_INDEX).toInt();
// Custome node settings
setTitleColor(Qt::white);
setHeaderTitleIcon(ICON_SAMPLERBLOCK);
setAction1Icon(ICON_MINMAX);
setAction2Icon(ICON_CLOSE);
alignTitle(Magus::ALIGNED_LEFT);
setHeaderColor(QColor("#874E96"));
mPort = createPort(PORT_ID_SAMPLERBLOCK,
PORT_DATABLOCK,
hlmsPbsDatablockSamplerblockPortType,
QColor("#874E96"),
Magus::PORT_SHAPE_CIRCLE,
Magus::ALIGNED_LEFT,
QColor("#874E96"));
setPortNameColor(Qt::white);
setZoom(0.9);
}
//****************************************************************************/
HlmsNodeSamplerblock::~HlmsNodeSamplerblock(void)
{
}
//****************************************************************************/
void HlmsNodeSamplerblock::setFileNameTexture(const QString fileNameTexture, const QPixmap* pixmap)
{
mFileNameTexture = fileNameTexture;
if (pixmap)
copyImage(pixmap);
else
setImage(fileNameTexture);
}
//****************************************************************************/
void HlmsNodeSamplerblock::nodeConnected(QtPort* port, QtConnection* connection)
{
QMessageBox::information(0, QString("Info"), QString("Node connected"));
}
//****************************************************************************/
int HlmsNodeSamplerblock::getSequenceNumber (void)
{
// Only get the sequencenumber once and if it is asked for
if (mSequenceNumber < 0)
mSequenceNumber = getSequence();
return mSequenceNumber;
}
void TSThread::getGround(F32 t, MatrixF * pMat)
{
static const QuatF unitRotation(0,0,0,1);
static const Point3F unitTranslation = Point3F::Zero;
const QuatF * q1, * q2;
QuatF rot1,rot2;
const Point3F * p1, * p2;
// if N = sequence->numGroundFrames, then there are N+1 positions we
// interpolate betweeen: 0/N, 1/N ... N/N
// we need to convert the p passed to us into 2 ground keyframes:
// the 0.99999f is in case 'p' is exactly 1.0f, which is legal but 'kf'
// needs to be strictly less than 'sequence->numGroundFrames'
F32 kf = 0.999999f * t * (F32) getSequence()->numGroundFrames;
// get frame number and interp param (kpos)
S32 frame = (S32)kf;
F32 kpos = kf - (F32)frame;
// now point pT1 and pT2 at transforms for keyframes 'frame' and 'frame+1'
// following a little strange: first ground keyframe (0/N in comment above) is
// assumed to be ident. and not found in the list.
if (frame)
{
p1 = &mShapeInstance->mShape->groundTranslations[getSequence()->firstGroundFrame + frame - 1];
q1 = &mShapeInstance->mShape->groundRotations[getSequence()->firstGroundFrame + frame - 1].getQuatF(&rot1);
}
else
{
p1 = &unitTranslation;
q1 = &unitRotation;
}
// similar to above, ground keyframe number 'frame+1' is actually offset by 'frame'
p2 = &mShapeInstance->mShape->groundTranslations[getSequence()->firstGroundFrame + frame];
q2 = &mShapeInstance->mShape->groundRotations[getSequence()->firstGroundFrame + frame].getQuatF(&rot2);
QuatF q;
Point3F p;
TSTransform::interpolate(*q1,*q2,kpos,&q);
TSTransform::interpolate(*p1,*p2,kpos,&p);
TSTransform::setMatrix(q,p,pMat);
}
/*
Implementation specific OID parser for suppported RSA algorithms
*/
int32 getAlgorithmIdentifier(unsigned char **pp, int32 len, int32 *oi,
int32 isPubKey)
{
unsigned char *p = *pp, *end;
int32 arcLen, llen;
end = p + len;
if (len < 1 || getSequence(&p, len, &llen) < 0) {
return -1;
}
if (end - p < 1) {
return -1;
}
if (*(p++) != ASN_OID || asnParseLength(&p, (int32)(end - p), &arcLen) < 0 ||
llen < arcLen) {
return -1;
}
/*
List of expected (currently supported) OIDs
algorithm summed length hex
sha1 88 05 2b0e03021a
md2 646 08 2a864886f70d0202
md5 649 08 2a864886f70d0205
rsaEncryption 645 09 2a864886f70d010101
md2WithRSAEncryption: 646 09 2a864886f70d010102
md5WithRSAEncryption 648 09 2a864886f70d010104
sha-1WithRSAEncryption 649 09 2a864886f70d010105
Yes, the summing isn't ideal (as can be seen with the duplicate 649),
but the specific implementation makes this ok.
*/
if (end - p < 2) {
return -1;
}
if (isPubKey && (*p != 0x2a) && (*(p + 1) != 0x86)) {
/*
Expecting DSA here if not RSA, but OID doesn't always match
*/
matrixStrDebugMsg("Unsupported algorithm identifier\n", NULL);
return -1;
}
*oi = 0;
while (arcLen-- > 0) {
*oi += (int32)*p++;
}
/*
Each of these cases might have a trailing NULL parameter. Skip it
*/
if (*p != ASN_NULL) {
*pp = p;
return 0;
}
if (end - p < 2) {
return -1;
}
*pp = p + 2;
return 0;
}
void TSThread::setKeyframeNumber(S32 kf)
{
AssertFatal(kf>=0 && kf<= getSequence()->numKeyframes,
"TSThread::setKeyframeNumber: invalid frame specified.");
AssertFatal(!transitionData.inTransition,"TSThread::setKeyframeNumber: not while in transition");
keyNum1 = keyNum2 = kf;
keyPos = 0;
pos = 0;
}
bool UniPAX::DnaReference::getAttribute(std::vector<std::pair<std::string,std::string> >& value, PersistenceManager& manager) {
if (!UniPAX::EntityReference::getAttribute(value, manager))
return false;
std::string tmp = "";
if (subRegion == 0)
{
// value.push_back(std::pair<std::string,std::string>("#subRegion", "NIL"));
}
else
{
tmp.clear();
if (!manager.getId(subRegion,tmp))
{
return false;
}
value.push_back(std::pair<std::string,std::string>("#subRegion", tmp));
}
tmp.clear();
if (organism == 0)
{
// value.push_back(std::pair<std::string,std::string>("#organism", "NIL"));
}
else
{
tmp.clear();
if (!manager.getId(organism,tmp))
{
return false;
}
value.push_back(std::pair<std::string,std::string>("#organism", tmp));
}
tmp.clear();
if (!getSequence().empty())
value.push_back(std::pair<std::string,std::string>("sequence", getSequence()));
return true;
}
