void QSplitter::moveAfter( int pos, int id, bool upLeft )
{
QSplitterLayoutStruct *s = id < int(data->list.count()) ?
data->list.at(id) : 0;
if ( !s )
return;
QWidget *w = s->wid;
if ( w->isHidden() ) {
moveAfter( pos, id+1, upLeft );
} else if ( pick( w->pos() ) == pos ) {
//No need to do anything if it's already there.
return;
} else if ( s->isSplitter ) {
int dd = s->sizer;
if ( upLeft ) {
setG( w, pos, dd );
moveAfter( pos+dd, id+1, upLeft );
} else {
moveAfter( pos+dd, id+1, upLeft );
setG( w, pos, dd );
}
} else {
int right = pick( w->geometry().bottomRight() );
int dd = right - pos + 1;
dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
int newRight = pos+dd-1;
setG( w, pos, dd );
moveAfter( newRight+1, id+1, upLeft );
}
}
void QSplitter::moveBefore( int pos, int id, bool upLeft )
{
QSplitterLayoutStruct *s = data->list.at(id);
if ( !s )
return;
QWidget *w = s->wid;
if ( w->isHidden() ) {
moveBefore( pos, id-1, upLeft );
} else if ( s->isSplitter ) {
int dd = s->sizer;
if ( upLeft ) {
setG( w, pos-dd+1, dd );
moveBefore( pos-dd, id-1, upLeft );
} else {
moveBefore( pos-dd, id-1, upLeft );
setG( w, pos-dd+1, dd );
}
} else {
int left = pick( w->pos() );
int dd = pos - left + 1;
dd = QMAX( pick(minSize(w)), QMIN(dd, pick(w->maximumSize())));
int newLeft = pos-dd+1;
setG( w, newLeft, dd );
if ( left != newLeft )
moveBefore( newLeft-1, id-1, upLeft );
}
}
/* int Dstar::computeShortestPath()
* --------------------------
* As per [S. Koenig, 2002] except for 2 main modifications:
* 1. We stop planning after a number of steps, 'maxsteps' we do this
* because this algorithm can plan forever if the start is
* surrounded by obstacles.
* 2. We lazily remove states from the open list so we never have to
* iterate through it.
*/
int Dstar::computeShortestPath() {
list<state> s;
list<state>::iterator i;
if (openList.empty()) return 1;
int k=0;
while ((!openList.empty()) &&
(openList.top() < (calculateKey(s_start))) ||
(!isConsistent(s_start))) {
if (k++ > maxSteps) {
fprintf(stderr, "At maxsteps\n");
return -1;
}
state u;
// check consistency (one of the loop conditions)
bool test = isConsistent(s_start);
//(getRHS(s_start) != getG(s_start));
// lazy remove
while(1) {
if (openList.empty()) return 1; // checks outer loop condition #1
u = openList.top();
if (!queuePop()) continue;
if (!(u < s_start) && test) return 2; // checks outer loop conditions #2,3 still hold
break;
}
state k_old = u;
if (k_old < calculateKey(u)) { // u is out of date
insert(u); // u has been removed already, reinsert into pq with new key
} else if (getG(u) > getRHS(u)) { // needs update (got better)
setG(u,getRHS(u));
getPred(u,s);
for (i=s.begin();i != s.end(); i++) {
updateVertex(*i);
}
} else { // g <= rhs, state has got worse
setG(u,INFINITY);
getPred(u,s);
for (i=s.begin();i != s.end(); i++) {
updateVertex(*i);
}
updateVertex(u);
}
}
return 0;
}
/* int Dstar::computeShortestPath()
* --------------------------
* As per [S. Koenig, 2002] except for 2 main modifications:
* 1. We stop planning after a number of steps, 'maxsteps' we do this
* because this algorithm can plan forever if the start is
* surrounded by obstacles.
* 2. We lazily remove states from the open list so we never have to
* iterate through it.
*/
int Dstar::computeShortestPath() {
list<state> s;
list<state>::iterator i;
if (openList.empty()) return 1;
int k=0;
while ((!openList.empty()) &&
(openList.top() < (s_start = calculateKey(s_start))) ||
(getRHS(s_start) != getG(s_start))) {
if (k++ > maxSteps) {
fprintf(stderr, "At maxsteps\n");
return -1;
}
state u;
bool test = (getRHS(s_start) != getG(s_start));
// lazy remove
while(1) {
if (openList.empty()) return 1;
u = openList.top();
openList.pop();
if (!isValid(u)) continue;
if (!(u < s_start) && (!test)) return 2;
break;
}
ds_oh::iterator cur = openHash.find(u);
openHash.erase(cur);
state k_old = u;
if (k_old < calculateKey(u)) { // u is out of date
insert(u);
} else if (getG(u) > getRHS(u)) { // needs update (got better)
setG(u,getRHS(u));
getPred(u,s);
for (i=s.begin();i != s.end(); i++) {
updateVertex(*i);
}
} else { // g <= rhs, state has got worse
setG(u,INFINITY);
getPred(u,s);
for (i=s.begin();i != s.end(); i++) {
updateVertex(*i);
}
updateVertex(u);
}
}
return 0;
}
// RGBVec: private methods
void RGBVec::normalise() {
// simply clip the colour
if (r() > 1.0) setR(1.0);
if (g() > 1.0) setG(1.0);
if (b() > 1.0) setB(1.0);
if (r() < 0.0) setR(0.0);
if (g() < 0.0) setG(0.0);
if (b() < 0.0) setB(0.0);
}
// Set from OpenSSL representation
void OSSLDSAPublicKey::setFromOSSL(const DSA* inDSA)
{
const BIGNUM* bn_p = NULL;
const BIGNUM* bn_q = NULL;
const BIGNUM* bn_g = NULL;
const BIGNUM* bn_pub_key = NULL;
DSA_get0_pqg(inDSA, &bn_p, &bn_q, &bn_g);
DSA_get0_key(inDSA, &bn_pub_key, NULL);
if (bn_p)
{
ByteString inP = OSSL::bn2ByteString(bn_p);
setP(inP);
}
if (bn_q)
{
ByteString inQ = OSSL::bn2ByteString(bn_q);
setQ(inQ);
}
if (bn_g)
{
ByteString inG = OSSL::bn2ByteString(bn_g);
setG(inG);
}
if (bn_pub_key)
{
ByteString inY = OSSL::bn2ByteString(bn_pub_key);
setY(inY);
}
}
// Set from OpenSSL representation
void OSSLDSAPrivateKey::setFromOSSL(const DSA* dsa)
{
if (dsa->p) { ByteString p = OSSL::bn2ByteString(dsa->p); setP(p); }
if (dsa->q) { ByteString q = OSSL::bn2ByteString(dsa->q); setQ(q); }
if (dsa->g) { ByteString g = OSSL::bn2ByteString(dsa->g); setG(g); }
if (dsa->priv_key) { ByteString x = OSSL::bn2ByteString(dsa->priv_key); setX(x); }
}
// Set from OpenSSL representation
void OSSLDHPublicKey::setFromOSSL(const DH* inDH)
{
const BIGNUM* bn_p = NULL;
const BIGNUM* bn_g = NULL;
const BIGNUM* bn_pub_key = NULL;
DH_get0_pqg(inDH, &bn_p, NULL, &bn_g);
DH_get0_key(inDH, &bn_pub_key, NULL);
if (bn_p)
{
ByteString inP = OSSL::bn2ByteString(bn_p);
setP(inP);
}
if (bn_g)
{
ByteString inG = OSSL::bn2ByteString(bn_g);
setG(inG);
}
if (bn_pub_key)
{
ByteString inY = OSSL::bn2ByteString(bn_pub_key);
setY(inY);
}
}
// Set from Botan representation
void BotanDHPublicKey::setFromBotan(const Botan::DH_PublicKey* dh)
{
ByteString p = BotanUtil::bigInt2ByteString(dh->group_p());
setP(p);
ByteString g = BotanUtil::bigInt2ByteString(dh->group_g());
setG(g);
ByteString y = BotanUtil::bigInt2ByteString(dh->get_y());
setY(y);
}
// Set from Botan representation
void BotanDSAPrivateKey::setFromBotan(const Botan::DSA_PrivateKey* dsa)
{
ByteString p = BotanUtil::bigInt2ByteString(dsa->group_p());
setP(p);
ByteString q = BotanUtil::bigInt2ByteString(dsa->group_q());
setQ(q);
ByteString g = BotanUtil::bigInt2ByteString(dsa->group_g());
setG(g);
ByteString x = BotanUtil::bigInt2ByteString(dsa->get_x());
setX(x);
}
// Set from Botan representation
void BotanDSAPrivateKey::setFromBotan(const Botan::DSA_PrivateKey* inDSA)
{
ByteString inP = BotanUtil::bigInt2ByteString(inDSA->group_p());
setP(inP);
ByteString inQ = BotanUtil::bigInt2ByteString(inDSA->group_q());
setQ(inQ);
ByteString inG = BotanUtil::bigInt2ByteString(inDSA->group_g());
setG(inG);
ByteString inX = BotanUtil::bigInt2ByteString(inDSA->get_x());
setX(inX);
}
/* void Dstar::updateStart(int x, int y)
* --------------------------
* Update the position of the robot, this does not force a replan.
*/
void Dstar::updateStart(int x, int y) {
s_start.x = x;
s_start.y = y;
k_m += heuristic(s_last,s_start);
setRHS(s_start,INFINITY);
setG(s_start,INFINITY);
s_start = calculateKey(s_start);
s_last = s_start;
}
bool DHParameters::deserialise(ByteString& serialised)
{
ByteString dP = ByteString::chainDeserialise(serialised);
ByteString dG = ByteString::chainDeserialise(serialised);
if ((dP.size() == 0) ||
(dG.size() == 0))
{
return false;
}
setP(dP);
setG(dG);
return true;
}
void TGAImage::initFirstLOD( unsigned char* srcData)
{
lodData[0] = new unsigned char[ getLODwidth(0) * getLODheight(0) * BPP ] ;
for( int i = 0 ; i < getLODwidth(0) ; i++ )
for( int j = 0 ; j < getLODheight(0) ; j++ )
{
unsigned char r, g, b, a ;
if( srcData ) getRGBA( srcData, i, getLODheight(0) - 1 - j, r, g, b, a ) ;
else r = g = b = a = 0 ;
setR( 0, i, j, r ) ;
setG( 0, i, j, g ) ;
setB( 0, i, j, b ) ;
setA( 0, i, j, a ) ;
}
goodLOD = 0 ;
}
bool Astar::checkOpen(int col, int row, int id)
{
// 检查open列表中是否有更小的步长，并排序
for(int i = _open->count() - 1; i > 0; i--) {
auto item = (AstarItem*)_open->getObjectAtIndex(i);
if(item->getCol() == col && item->getRow() == row) {
int tempG = getG(col, row, id);
if(tempG < item->getG()) {
item->setG(tempG);
item->setFid(id);
item->setF(tempG + item->getH());
resetSort(i);
}
return false;
}
}
return true;
}
bool DHPrivateKey::deserialise(ByteString& serialised)
{
ByteString dP = ByteString::chainDeserialise(serialised);
ByteString dG = ByteString::chainDeserialise(serialised);
ByteString dX = ByteString::chainDeserialise(serialised);
if ((dP.size() == 0) ||
(dG.size() == 0) ||
(dX.size() == 0))
{
return false;
}
setP(dP);
setG(dG);
setX(dX);
return true;
}
CSeaData::CSeaData( const CSeaData &object )
{
setWaveInputType( object.waveInputType() );
setWaveAngle( object.waveAngle() );
setWaveHeight( object.waveHeight() );
setWaveMaxHeight( object.waveMaxHeight() );
setWaveSpreading( object.waveSpreading() );
setWaveType( object.waveType() );
setWaveLength( object.waveLength() );
setWavePeriod( object.wavePeriod() );
setCurrentInputType( object.currentInputType() );
setFlowAngle( object.flowAngle() );
setFlowSpeed( object.flowSpeed() );
setSeaTemperature( object.seaTemperature() );
setSeaTemperaturechange( object.seaTemperatureChange() );
setIceThickness( object.iceThickness() );
setR( object.r() );
setB( object.b() );
setG( object.g() );
}
CSeaData::CSeaData():
m_dbWaveInputType( false ),
m_dWaveAngle( 0.0 ),
m_dWaveHeight( 0.0 ),
m_dWaveMaxHeight( 0.0 ),
m_diWaveSpreading( 0 ),
m_dWaveType( 0.0 ),
m_dWaveLength( 0.0 ),
m_dWavePeriod( 0.0 ),
m_dbCurrentInputType( false ),
m_dFlowAngle( 0.0 ),
m_dFlowSpeed( 0.0 ),
m_dSeaTemperature( 0.0 ),
m_dSeaTemperaturechange( 0.0 ),
m_dIceThickness( 0.0 )
{
setR(0);
setB(0);
setG(0);
}
void TGAImage::generateLOD( int lod )
{
int dstW = getLODwidth(lod) ;
int dstH = getLODheight(lod);
if( lodData[lod] == NULL ) lodData[lod] = new unsigned char[ dstW * dstH * BPP ] ;
int s = getLODwidth(0) / dstW ;
int t = getLODheight(0) / dstH ;
for( int i = 0 ; i < dstW ; i++ )
for( int j = 0 ; j < dstH ; j++ )
{
int r = 0, g = 0, b = 0, a = 0 ;
for( int k = 0 ; k < s ; k++ )
for( int l = 0 ; l < t ; l++ )
{
r += getR( 0, i * s + k, j * t + l ) ;
g += getG( 0, i * s + k, j * t + l ) ;
b += getB( 0, i * s + k, j * t + l ) ;
a += getA( 0, i * s + k, j * t + l ) ;
}
r /= s * t ;
g /= s * t ;
b /= s * t ;
a /= s * t ;
setR( lod, i, j, r ) ;
setG( lod, i, j, g ) ;
setB( lod, i, j, b ) ;
setA( lod, i, j, a ) ;
}
goodLOD = lod ;
}
// Set from OpenSSL representation
void OSSLDHPrivateKey::setFromOSSL(const DH* dh)
{
if (dh->p) { ByteString p = OSSL::bn2ByteString(dh->p); setP(p); }
if (dh->g) { ByteString g = OSSL::bn2ByteString(dh->g); setG(g); }
if (dh->priv_key) { ByteString x = OSSL::bn2ByteString(dh->priv_key); setX(x); }
}
void TGAImage::setG( int i, int j, int v )
{
setG( 0, i, j, v ) ;
}
