void Console::on_show() { const auto screen_r = screen_rect(); display.scroll_set_area(screen_r.top(), screen_r.bottom()); clear(); }
/*! \property QIntValidator::top \brief the validator's highest acceptable value By default, this property's value is derived from the highest signed integer available (typically 2147483647). \sa setRange() */ void QIntValidator::setTop(int top) { setRange(bottom(), top); }
void QDoubleValidator::setDecimals(int decimals) { setRange(bottom(), top(), decimals); }
bool IntRect::contains(const IntRect& other) const { return x() <= other.x() && right() >= other.right() && y() <= other.y() && bottom() >= other.bottom(); }
T cy() const { return (top() + bottom()) / 2; }
const Scalar Box2<Scalar>::height() const { return std::abs(bottom() - top()); }
qreal FrameSvgItemMargins::vertical() const { return top() + bottom(); }
// Check if this AABB contains the sent point bool Rec::contains(float x, float y){ if (x > mX && x < right() && y > mY && y < bottom()) return true; return false; }
// Check if this AABB contains the sent point at the sent offset bool Rec::contains(float x, float y, float offx, float offy){ if (x > mX + offx && x < right() + offx && y > mY + offy && y < bottom() + offy) return true; return false; }
inline vector2d<T> rightBottom() const { return vector2d<T>{right(), bottom()}; }
inline vector2d<T> leftBottom() const { return vector2d<T>{left, bottom()}; }
QRectF CartesianChartLayout::calculateAxisGeometry(const QRectF &geometry, const QList<ChartAxisElement *> &axes) const { QSizeF left(0,0); QSizeF minLeft(0,0); QSizeF right(0,0); QSizeF minRight(0,0); QSizeF bottom(0,0); QSizeF minBottom(0,0); QSizeF top(0,0); QSizeF minTop(0,0); QSizeF labelExtents(0,0); int leftCount = 0; int rightCount = 0; int topCount = 0; int bottomCount = 0; foreach (ChartAxisElement *axis , axes) { if (!axis->isVisible()) continue; QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize); //this is used to get single thick font size QSizeF minSize = axis->effectiveSizeHint(Qt::MinimumSize); switch (axis->axis()->alignment()) { case Qt::AlignLeft: left.setWidth(left.width()+size.width()); left.setHeight(qMax(left.height(),size.height())); minLeft.setWidth(minLeft.width()+minSize.width()); minLeft.setHeight(qMax(minLeft.height(),minSize.height())); labelExtents.setHeight(qMax(size.height(), labelExtents.height())); leftCount++; break; case Qt::AlignRight: right.setWidth(right.width()+size.width()); right.setHeight(qMax(right.height(),size.height())); minRight.setWidth(minRight.width()+minSize.width()); minRight.setHeight(qMax(minRight.height(),minSize.height())); labelExtents.setHeight(qMax(size.height(), labelExtents.height())); rightCount++; break; case Qt::AlignTop: top.setWidth(qMax(top.width(),size.width())); top.setHeight(top.height()+size.height()); minTop.setWidth(qMax(minTop.width(),minSize.width())); minTop.setHeight(minTop.height()+minSize.height()); labelExtents.setWidth(qMax(size.width(), labelExtents.width())); topCount++; break; case Qt::AlignBottom: bottom.setWidth(qMax(bottom.width(), size.width())); bottom.setHeight(bottom.height() + size.height()); minBottom.setWidth(qMax(minBottom.width(),minSize.width())); minBottom.setHeight(minBottom.height() + minSize.height()); labelExtents.setWidth(qMax(size.width(), labelExtents.width())); bottomCount++; break; default: qWarning()<<"Axis is without alignment !"; break; } } qreal totalVerticalAxes = leftCount + rightCount; qreal leftSqueezeRatio = 1.0; qreal rightSqueezeRatio = 1.0; qreal vratio = 0; if (totalVerticalAxes > 0) vratio = (maxAxisPortion * geometry.width()) / totalVerticalAxes; if (leftCount > 0) { int maxWidth = vratio * leftCount; if (left.width() > maxWidth) { leftSqueezeRatio = maxWidth / left.width(); left.setWidth(maxWidth); } } if (rightCount > 0) { int maxWidth = vratio * rightCount; if (right.width() > maxWidth) { rightSqueezeRatio = maxWidth / right.width(); right.setWidth(maxWidth); } } qreal totalHorizontalAxes = topCount + bottomCount; qreal topSqueezeRatio = 1.0; qreal bottomSqueezeRatio = 1.0; qreal hratio = 0; if (totalHorizontalAxes > 0) hratio = (maxAxisPortion * geometry.height()) / totalHorizontalAxes; if (topCount > 0) { int maxHeight = hratio * topCount; if (top.height() > maxHeight) { topSqueezeRatio = maxHeight / top.height(); top.setHeight(maxHeight); } } if (bottomCount > 0) { int maxHeight = hratio * bottomCount; if (bottom.height() > maxHeight) { bottomSqueezeRatio = maxHeight / bottom.height(); bottom.setHeight(maxHeight); } } qreal minHeight = qMax(minLeft.height(),minRight.height()) + 1; qreal minWidth = qMax(minTop.width(),minBottom.width()) + 1; // Ensure that there is enough space for first and last tick labels. left.setWidth(qMax(labelExtents.width(), left.width())); right.setWidth(qMax(labelExtents.width(), right.width())); top.setHeight(qMax(labelExtents.height(), top.height())); bottom.setHeight(qMax(labelExtents.height(), bottom.height())); QRectF chartRect = geometry.adjusted(qMax(left.width(),minWidth/2), qMax(top.height(), minHeight/2),-qMax(right.width(),minWidth/2),-qMax(bottom.height(),minHeight/2)); qreal leftOffset = 0; qreal rightOffset = 0; qreal topOffset = 0; qreal bottomOffset = 0; foreach (ChartAxisElement *axis , axes) { if (!axis->isVisible()) continue; QSizeF size = axis->effectiveSizeHint(Qt::PreferredSize); switch (axis->axis()->alignment()){ case Qt::AlignLeft:{ qreal width = size.width(); if (leftSqueezeRatio < 1.0) width *= leftSqueezeRatio; leftOffset+=width; axis->setGeometry(QRect(chartRect.left()-leftOffset, geometry.top(),width, geometry.bottom()),chartRect); break; } case Qt::AlignRight:{ qreal width = size.width(); if (rightSqueezeRatio < 1.0) width *= rightSqueezeRatio; axis->setGeometry(QRect(chartRect.right()+rightOffset,geometry.top(),width,geometry.bottom()),chartRect); rightOffset+=width; break; } case Qt::AlignTop: { qreal height = size.height(); if (topSqueezeRatio < 1.0) height *= topSqueezeRatio; axis->setGeometry(QRect(geometry.left(), chartRect.top() - topOffset - height, geometry.width(), height), chartRect); topOffset += height; break; } case Qt::AlignBottom: qreal height = size.height(); if (bottomSqueezeRatio < 1.0) height *= bottomSqueezeRatio; axis->setGeometry(QRect(geometry.left(), chartRect.bottom() + bottomOffset, geometry.width(), height), chartRect); bottomOffset += height; break; } } return chartRect; }
void PilotListBox::update() { aObject::update(); timeSinceStart += frameLength; if ( timeSinceStart < 1.0 ) return; if ( this->curItem >= itemCount ) { for ( int i = 0; i < itemCount; i++ ) { GetItem( i )->showGUIWindow( true ); GetItem( i )->update(); } bDone = true; return; }// done for ( int i = 0; i < itemCount; i++ ) { bDone = 0; aListItem* item = GetItem( i ); if ( item ) { if ( i < curItem ) { item->showGUIWindow( true ); } else if ( i == curItem ) { PilotListItem* pilotItem = dynamic_cast<PilotListItem*>(item); if ( pilotItem ) { if ( pilotItem->isDone() ) { pilotItem = NULL; while ( !pilotItem ) { curItem++; scrollTime = 0.f; oldScroll = scrollBar->GetScrollPos(); if ( curItem <= itemCount ) { item = GetItem( curItem ); pilotItem = dynamic_cast<PilotListItem*>(item); } else { curItem++; break; } } if ( pilotItem ) { pilotItem->begin(); } } else pilotItem->update(); } else curItem++; if ( item ) { float itemTop = item->globalY(); if ( itemTop > bottom() - 3 * height() / 4 && !newScroll ) { // need to scroll oldScroll = scrollBar->GetScrollPos(); newScroll = oldScroll + itemTop - bottom() + 3 * height() / 4; if ( newScroll < oldScroll ) newScroll = 0; } else if ( !newScroll ) items[curItem]->showGUIWindow(1); } } else { item->showGUIWindow( false ); } } } if ( newScroll ) { scrollTime += frameLength; long delta = 140.f * scrollTime; if ( delta + oldScroll < newScroll && delta + oldScroll < scrollBar->GetScrollMax() ) scrollBar->SetScroll( oldScroll + delta ); else { scrollBar->SetScroll( newScroll ); if ( items[curItem] ) items[curItem]->showGUIWindow(1); newScroll = 0; scrollTime = 0; } } }
char* top() const { return bottom() + _len; }
FloatRect::operator SkRect() const { SkRect rect = { x(), y(), right(), bottom() }; return rect; }
void Nonbreakable::draw(bool update) { if (type_ != REGULAR){ glColor3ub(255,204,0); glBegin(GL_POLYGON); glVertex2d(left(),bottom()); glVertex2d(right(),bottom()); glVertex2d(right(),top()); glVertex2d(left(),top()); glEnd(); if (type_ == QUESTION) { glColor3ub(255, 0, 0); glBegin(GL_POLYGON); glVertex2d(left()+6, bottom()+6); glVertex2d(left()+10, bottom()+6); glVertex2d(left()+10, bottom()+14); glVertex2d(left()+6, bottom()+14); glEnd(); glBegin(GL_POLYGON); glVertex2d(left()+6, bottom()+2); glVertex2d(left()+10, bottom()+2); glVertex2d(left()+10, bottom()+4); glVertex2d(left()+6, bottom()+4); glEnd(); } glColor3ub(0, 0, 0); glPointSize(2.0); glBegin(GL_POINTS); glVertex2d(left()+2, bottom()+2); glVertex2d(left()+2, top()-2); glVertex2d(right()-2, bottom()+2); glVertex2d(right()-2, top()-2); glEnd(); glColor3ub(0, 0, 0); glBegin(GL_LINE_LOOP); glVertex2d(left(), bottom()); glVertex2d(left(), top()); glVertex2d(right(), top()); glVertex2d(right(), bottom()); glEnd(); } else{ glColor3ub(0, 0, 0); glBegin(GL_POLYGON); glVertex2d(left(), bottom()); glVertex2d(right(), bottom()); glVertex2d(right(), top()); glEnd(); glColor3ub(199, 133, 120); glBegin(GL_POLYGON); glVertex2d(right(), top()); glVertex2d(left(), top()); glVertex2d(left(), bottom()); glEnd(); glColor3b(0, 0, 0); glBegin(GL_LINES); glVertex2d(left(), bottom()); glVertex2d(right(), top()); glEnd(); glColor3ub(199, 133, 64); glBegin(GL_LINES); glVertex2d(left(), bottom()); glVertex2d(right(), top()); glEnd(); glBegin(GL_POLYGON); glVertex2d(left()+4, bottom()+4); glVertex2d(left()+4, top()-4); glVertex2d(right()-4, top()-4); glVertex2d(right()-4, bottom()+4); glEnd(); } }
Coord View::y() const { return bottom() + XYView::height()/2.; }
int ncols() const { return _grid.empty() ? 0 : bottom().size(); }
const QRect XfitMan::availableGeometry(int screen) const { QDesktopWidget *d = QApplication::desktop(); if (screen < 0 || screen >= d->screenCount()) screen = d->primaryScreen(); QRect available = d->screenGeometry(screen); // Iterate over all the client windows and subtract from the available // area the space they reserved on the edges (struts). // Note: _NET_WORKAREA is not reliable as it exposes only one // rectangular area spanning all screens. Display *display = QX11Info::display(); int x11Screen = d->isVirtualDesktop() ? DefaultScreen(display) : screen; Atom ret; int format, status; uchar* data = 0; ulong nitems, after; status = XGetWindowProperty(display, QX11Info::appRootWindow(x11Screen), atom("_NET_CLIENT_LIST"), 0L, ~0L, False, XA_WINDOW, &ret, &format, &nitems, &after, &data); if (status == Success && ret == XA_WINDOW && format == 32 && nitems) { const QRect desktopGeometry = d->rect(); Window* xids = (Window*) data; for (quint32 i = 0; i < nitems; ++i) { ulong nitems2; uchar* data2 = 0; status = XGetWindowProperty(display, xids[i], atom("_NET_WM_STRUT_PARTIAL"), 0, 12, False, XA_CARDINAL, &ret, &format, &nitems2, &after, &data2); if (status == Success && ret == XA_CARDINAL && format == 32 && nitems2 == 12) { ulong* struts = (ulong*) data2; QRect left(desktopGeometry.x(), desktopGeometry.y() + struts[4], struts[0], struts[5] - struts[4]); if (available.intersects(left)) available.setX(left.width()); QRect right(desktopGeometry.x() + desktopGeometry.width() - struts[1], desktopGeometry.y() + struts[6], struts[1], struts[7] - struts[6]); if (available.intersects(right)) available.setWidth(right.x() - available.x()); QRect top(desktopGeometry.x() + struts[8], desktopGeometry.y(), struts[9] - struts[8], struts[2]); if (available.intersects(top)) available.setY(top.height()); QRect bottom(desktopGeometry.x() + struts[10], desktopGeometry.y() + desktopGeometry.height() - struts[3], struts[11] - struts[10], struts[3]); if (available.intersects(bottom)) available.setHeight(bottom.y() - available.y()); } if (data2) XFree(data2); } } if (data) XFree(data); return available; }
double LinearRegression::gain() { double g = bottom()!=0 ? top()/bottom():0; return (g); }
void PrevailingWindDemo::createPalmTree ( hkpWorld* world, const hkpWind* wind, const hkVector4& pos ) { const hkReal trunkHeight = 4.0f; const hkReal trunkBottomRadius = 0.5f; const hkReal trunkTopRadius = 0.2f; const hkReal trunkStiffness = 0.1f; const hkReal segmentMass = 0.6f; const int numberOfSegments = 4; const hkReal segmentGap = 0.2f; const int numberOfFronds = 6; const hkReal frondWidth = 2.0f; const hkReal frondLength = 3.0f; const hkReal frondMass = 0.4f; // The trunk hkArray<hkpRigidBody*> trunk; const hkReal segmentHeight = (trunkHeight - ((numberOfSegments - 1) * segmentGap)) / numberOfSegments; const hkReal radiusIncrement = (trunkBottomRadius - trunkTopRadius) / numberOfSegments; for ( int i = 0; i < numberOfSegments; i++ ) { hkpShape* segmentShape; hkpRigidBodyCinfo info; { hkVector4 bottom( 0.0f, (segmentHeight + segmentGap) * i, 0.0f ); hkVector4 top( 0.0f, (segmentHeight + segmentGap) * i + segmentHeight, 0.0f ); hkReal radius = trunkBottomRadius - (radiusIncrement * i); segmentShape = new hkpCylinderShape( bottom, top, radius, 0.03f ); info.m_shape = segmentShape; info.m_position = pos; if (i == 0) { info.m_motionType = hkpMotion::MOTION_FIXED; } else { hkpMassProperties massProperties; { hkpInertiaTensorComputer::computeCylinderVolumeMassProperties( bottom, top, radius, segmentMass, massProperties ); } info.m_motionType = hkpMotion::MOTION_DYNAMIC; info.m_mass = massProperties.m_mass; info.m_inertiaTensor = massProperties.m_inertiaTensor; info.m_centerOfMass = massProperties.m_centerOfMass; } } hkpRigidBody* segment = new hkpRigidBody( info ); segmentShape->removeReference(); trunk.pushBack( segment ); world->addEntity( segment ); segment->removeReference(); if (i > 0) { hkpWindAction* action = new hkpWindAction( segment, wind, 0.1f ); world->addAction(action); action->removeReference(); } } for ( int i = 1; i < numberOfSegments; i++ ) { // We model the connection between the segments with a ragdoll constraint. hkpRagdollConstraintData* rdc; { hkReal planeMin = HK_REAL_PI * -0.025f; hkReal planeMax = HK_REAL_PI * 0.025f; hkReal twistMin = HK_REAL_PI * -0.025f; hkReal twistMax = HK_REAL_PI * 0.025f; hkReal coneMin = HK_REAL_PI * -0.05f; hkReal coneMax = HK_REAL_PI * 0.05f; rdc = new hkpRagdollConstraintData(); rdc->setPlaneMinAngularLimit( planeMin ); rdc->setPlaneMaxAngularLimit( planeMax ); rdc->setTwistMinAngularLimit( twistMin ); rdc->setTwistMaxAngularLimit( twistMax ); hkVector4 twistAxis( 0.0f, 1.0f, 0.0f ); hkVector4 planeAxis( 0.0f, 0.0f, 1.0f ); hkVector4 pivot( 0.0f, (segmentHeight + segmentGap) * i, 0.0f ); rdc->setInBodySpace( pivot, pivot, planeAxis, planeAxis, twistAxis, twistAxis ); rdc->setAsymmetricConeAngle( coneMin, coneMax ); //world->createAndAddConstraintInstance( trunk[i - 1], trunk[i], rdc )->removeReference(); hkpConstraintInstance* constraint = new hkpConstraintInstance( trunk[i - 1], trunk[i], rdc ); world->addConstraint(constraint); hkpPositionConstraintMotor* motor = new hkpPositionConstraintMotor( 0 ); motor->m_tau = trunkStiffness; motor->m_maxForce = 1000.0f; motor->m_constantRecoveryVelocity = 0.1f; rdc->setTwistMotor( motor ); rdc->setConeMotor( motor ); rdc->setPlaneMotor( motor ); rdc->setMotorsActive(constraint, true); motor->removeReference(); constraint->removeReference(); rdc->removeReference(); } } // The angle that the leaves make with the ground in their half lifted position. hkQuaternion tilt; { hkVector4 axis( 0.0f, 0.0f, 1.0f ); tilt.setAxisAngle( axis, HK_REAL_PI * 0.1f ); } hkQuaternion tiltRot; // The fronds for ( int i = 0; i < numberOfFronds; i++ ) { hkQuaternion rotation; { hkVector4 axis( 0.0f, 1.0f, 0.0f ); rotation.setAxisAngle( axis, HK_REAL_PI * 2.0f * ( i / (hkReal) numberOfFronds ) ); rotation.normalize(); } hkpShape* frondShape; hkpRigidBodyCinfo info; { hkVector4 vertexA( 0.0f, 0.0f, 0.0f ); hkVector4 vertexB( frondLength, 0.0f, frondWidth / 2.0f ); hkVector4 vertexC( frondLength, 0.0f, - frondWidth / 2.0f ); frondShape = new hkpTriangleShape( vertexA, vertexB, vertexC, 0.01f ); info.m_shape = frondShape; hkVector4 relPos; relPos.setRotatedDir( rotation, hkVector4( trunkTopRadius + 0.3f, trunkHeight, 0.0f ) ); info.m_position.setAdd4( pos, relPos ); hkpMassProperties massProperties; { hkReal mass = frondMass; hkpInertiaTensorComputer::computeTriangleSurfaceMassProperties( vertexA, vertexB, vertexC, mass, 0.01f, massProperties ); } info.m_motionType = hkpMotion::MOTION_DYNAMIC; info.m_mass = massProperties.m_mass; info.m_inertiaTensor = massProperties.m_inertiaTensor; info.m_centerOfMass = massProperties.m_centerOfMass; tiltRot.setMul( rotation, tilt ); info.m_rotation = tiltRot; } hkpRigidBody* frond = new hkpRigidBody( info ); frondShape->removeReference(); world->addEntity( frond ); hkpWindAction* action = new hkpWindAction( frond, wind, 0.1f ); world->addAction(action); action->removeReference(); // We model the connection between the fronds and the trunk with a ragdoll constraint. hkpRagdollConstraintData* rdc; { hkReal planeMin = HK_REAL_PI * -0.005f; hkReal planeMax = HK_REAL_PI * 0.005f; hkReal twistMin = HK_REAL_PI * -0.05f; hkReal twistMax = HK_REAL_PI * 0.05f; hkReal coneMin = HK_REAL_PI * -0.2f; hkReal coneMax = HK_REAL_PI * 0.2f; rdc = new hkpRagdollConstraintData(); rdc->setPlaneMinAngularLimit( planeMin ); rdc->setPlaneMaxAngularLimit( planeMax ); rdc->setTwistMinAngularLimit( twistMin ); rdc->setTwistMaxAngularLimit( twistMax ); hkVector4 twistAxisFrond( 1.0f, 0.0f, 0.0f ); hkVector4 twistAxisTrunk; twistAxisTrunk.setRotatedDir( tiltRot, twistAxisFrond ); hkVector4 planeAxisFrond( 0.0f, 0.0f, 1.0f ); hkVector4 planeAxisTrunk; planeAxisTrunk.setRotatedDir( tiltRot, planeAxisFrond ); hkVector4 pivotFrond( 0.0f, 0.0f, 0.0f ); hkVector4 pivotTrunk; pivotTrunk.setRotatedDir( rotation, hkVector4( trunkTopRadius + 0.3f, trunkHeight, 0.0f ) ); rdc->setInBodySpace( pivotTrunk, pivotFrond, planeAxisTrunk, planeAxisFrond, twistAxisTrunk, twistAxisFrond ); rdc->setAsymmetricConeAngle( coneMin, coneMax ); world->createAndAddConstraintInstance( trunk[ numberOfSegments - 1 ], frond, rdc )->removeReference(); rdc->removeReference(); frond->removeReference(); } } }
LowFrequencyCharactersDemo::LowFrequencyCharactersDemo(hkDemoEnvironment* env) : hkDefaultPhysicsDemo(env) { // // Setup the camera // { hkVector4 from( 0.0f, 20.0f, -80.0f); hkVector4 to ( 0.0f, 0.0f, 0.0f); hkVector4 up ( 0.0f, 1.0f, 0.0f); setupDefaultCameras( env, from, to, up ); forceShadowState(false); } // // Create the world // { hkpWorldCinfo info; info.setBroadPhaseWorldSize( 350.0f ); info.m_gravity.set(0, -9.8f, 0); info.m_collisionTolerance = 0.1f; m_world = new hkpWorld( info ); m_world->lock(); hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher()); setupGraphics(); } // // Create a terrain // TerrainHeightFieldShape* heightFieldShape; { hkpSampledHeightFieldBaseCinfo ci; ci.m_xRes = 64; ci.m_zRes = 64; ci.m_scale.set(4,1,4); // // Fill in a data array // m_data = hkAllocate<hkReal>(ci.m_xRes * ci.m_zRes, HK_MEMORY_CLASS_DEMO); for (int x = 0; x < ci.m_xRes; x++) { for (int z = 0; z < ci.m_xRes; z++) { hkReal dx,dz,height = 0; int octave = 1; // Add togther a few sine and cose waves for (int i=0; i< 3; i++) { dx = hkReal(x * octave) / ci.m_xRes; dz = hkReal(z * octave) / ci.m_zRes; height += (5 - (i * 2)) * hkMath::cos(dx * HK_REAL_PI) * hkMath::sin(dz * HK_REAL_PI); octave *= 4; } m_data[x*ci.m_zRes + z] = height; } } heightFieldShape = new TerrainHeightFieldShape( ci , m_data ); // // Create a fixed rigid body // { hkpRigidBodyCinfo rci; rci.m_motionType = hkpMotion::MOTION_FIXED; rci.m_position.setMul4( -0.5f, heightFieldShape->m_extents ); // center the heightfield rci.m_shape = heightFieldShape; rci.m_friction = 0.05f; hkpRigidBody* body = new hkpRigidBody( rci ); m_world->addEntity(body)->removeReference(); } heightFieldShape->removeReference(); } // // Create a character proxy object // { m_numBoxes = 0; m_numCapsules = 0; m_numSpheres = 0; // We'll store the simulation frequency in this hkpPropertyValue val; // Construct shape phantoms for the characters hkPseudoRandomGenerator random(123); for (int i=0; i < NUM_CHARACTERS; i++) { // Create a random shape to represent the character hkpConvexShape* shape = HK_NULL; { hkReal scale = random.getRandReal01() * 0.25f + 0.75f; //Set the simulation frequency val.setInt( random.getRand32() % 3 ); switch (val.getInt()) { case 0: { hkVector4 top(0, scale * 0.4f, 0); hkVector4 bottom(0, -scale * 0.4f, 0); shape = new hkpCapsuleShape(top, bottom, scale * 0.6f); m_numCapsules++; } break; case 1: { hkVector4 size(scale * 0.5f, scale , scale * 0.5f); shape = new hkpBoxShape(size); m_numBoxes++; } break; default: { shape = new hkpSphereShape(scale); m_numSpheres++; } break; } } hkpShapePhantom* phantom = new hkpSimpleShapePhantom( shape, hkTransform::getIdentity() ); shape->removeReference(); // Add the phantom to the world m_world->addPhantom(phantom); phantom->removeReference(); HK_SET_OBJECT_COLOR( (hkUlong)phantom->getCollidable(), 0x7fffffff & hkColor::getRandomColor() ); // Construct a character proxy hkpCharacterProxyCinfo cpci; random.getRandomVector11( cpci.m_position ); cpci.m_position.mul4(32); cpci.m_position(1) = 10; cpci.m_up.setNeg4( m_world->getGravity() ); cpci.m_up.normalize3(); cpci.m_shapePhantom = phantom; m_characterProxy[i] = new hkpCharacterProxy( cpci ); // Player is simulated at full frequency if (i==0) { val.setInt(0); } // Add the schedule property phantom->addProperty(HK_SCHEDULE_FREQUENCY, val); } } // // Create the Character state machine and context // hkpCharacterStateManager* manager; { hkpCharacterState* state; manager = new hkpCharacterStateManager(); state = new hkpCharacterStateOnGround(); manager->registerState( state, HK_CHARACTER_ON_GROUND); state->removeReference(); state = new hkpCharacterStateInAir(); manager->registerState( state, HK_CHARACTER_IN_AIR); state->removeReference(); state = new hkpCharacterStateJumping(); manager->registerState( state, HK_CHARACTER_JUMPING); state->removeReference(); state = new hkpCharacterStateClimbing(); manager->registerState( state, HK_CHARACTER_CLIMBING); state->removeReference(); } // Create a context for each character { for (int i=0; i < NUM_CHARACTERS; i++) { m_characterContext[i] = new hkpCharacterContext(manager, HK_CHARACTER_ON_GROUND); } manager->removeReference(); } // Current camera angle about up m_currentAngle = 0.0f; //Initialised the round robin counter m_tick = 0; m_world->unlock(); }
void Annotation1DCaret::draw(Spectrum1DCanvas* const canvas, QPainter& painter, bool flipped) { painter.save(); painter.setPen(color_); // translate mz/intensity to pixel coordinates QPoint position_widget, caret_position_widget; canvas->dataToWidget(position_.getX(), position_.getY(), position_widget, flipped, true); canvas->dataToWidget(caret_positions_[0].getX(), caret_positions_[0].getY(), caret_position_widget, flipped, true); //std::cerr << "color" << color_.value() << " "; // draw ticks (for now) if (!caret_positions_.empty()) { QPoint caret; // draw ^ to indicate theoretical position for (PositionsType::iterator it = caret_positions_.begin(); it != caret_positions_.end(); ++it) { canvas->dataToWidget(it->getX(), it->getY(), caret, flipped, true); painter.drawLine(caret.x(), caret.y(), caret.x()+4, caret.y() + 4); painter.drawLine(caret.x(), caret.y(), caret.x()-4, caret.y() + 4); //std::cout << "caret: " << caret.x() << "," << caret.y() << "\n"; } } // compute bounding box of text_item on the specified painter bounding_box_ = QRectF(position_widget, st_.size()); //std::cout << "posP: " << position_.getX() << "," << position_.getY() << "\n"; //std::cout << "posW: " << position_widget.x() << "," << position_widget.y() << "\n"; //std::cout <<"init BB topleft: " << bounding_box_.topLeft().x() << "," << bounding_box_.topLeft().y() <<"\n"; DoubleReal vertical_shift = 0; DoubleReal horizontal_shift = 0; if (canvas->isMzToXAxis()) { // shift pos - annotation should be over peak or, if not possible, next to it vertical_shift = bounding_box_.height() / 2 + 5; if (!flipped) { vertical_shift *= -1; } bounding_box_.translate(0.0, vertical_shift); if (flipped && bounding_box_.bottom() > canvas->height()) { bounding_box_.moveBottom(canvas->height()); bounding_box_.moveLeft(position_widget.x() + 5.0); } else if (!flipped && bounding_box_.top() < 0.0) { bounding_box_.moveTop(0.0); bounding_box_.moveLeft(position_widget.x() + 5.0); } } else { // annotation should be next to the peak (to its right) horizontal_shift = bounding_box_.width() / 2 + 5; bounding_box_.translate(horizontal_shift, 0.0); if (bounding_box_.right() > canvas->width()) { bounding_box_.moveRight(canvas->width()); } } // draw connection line between anchor point and current position if pixel coordinates differ significantly if ((position_widget - caret_position_widget).manhattanLength() > 2) { // check if line crosses bounding box, if so move line startpoint to correct bounding box intersection QLineF line(caret_position_widget, position_widget + QPoint(horizontal_shift, vertical_shift)); QLineF top(bounding_box_.x(), bounding_box_.y(), bounding_box_.x() + bounding_box_.width(), bounding_box_.y()); QLineF left(bounding_box_.x(), bounding_box_.y(), bounding_box_.x(), bounding_box_.y() + bounding_box_.height()); QLineF right(bounding_box_.x() + bounding_box_.width(), bounding_box_.y(), bounding_box_.x() + bounding_box_.width(), bounding_box_.y() + bounding_box_.height()); QLineF bottom(bounding_box_.x(), bounding_box_.y() + bounding_box_.height(), bounding_box_.x() + bounding_box_.width(), bounding_box_.y() + bounding_box_.height()); QLineF::IntersectType itype; QPointF * ip = new QPointF(); QPointF * closest_ip = new QPointF(-10e10, -10e10); bool found_intersection = false; // intersection with top itype = line.intersect(top, ip); if (itype == QLineF::BoundedIntersection && QLineF(caret_position_widget, *ip).length() < QLineF(caret_position_widget, *closest_ip).length()) { found_intersection = true; *closest_ip = *ip; } // intersection with left itype = line.intersect(left, ip); if (itype == QLineF::BoundedIntersection && QLineF(caret_position_widget, *ip).length() < QLineF(caret_position_widget, *closest_ip).length()) { found_intersection = true; *closest_ip = *ip; } // intersection with right itype = line.intersect(right, ip); if (itype == QLineF::BoundedIntersection && QLineF(caret_position_widget, *ip).length() < QLineF(caret_position_widget, *closest_ip).length()) { found_intersection = true; *closest_ip = *ip; } // intersection with bottom itype = line.intersect(bottom, ip); if (itype == QLineF::BoundedIntersection && QLineF(caret_position_widget, *ip).length() < QLineF(caret_position_widget, *closest_ip).length()) { found_intersection = true; *closest_ip = *ip; } painter.save(); painter.setPen(Qt::DashLine); if (!found_intersection) // no intersection with bounding box of text -> normal drawing { painter.drawLine(caret_position_widget, position_widget); painter.drawLine(caret_position_widget, position_widget); } else { painter.drawLine(caret_position_widget, *closest_ip); painter.drawLine(caret_position_widget, *closest_ip); } painter.restore(); delete(ip); delete(closest_ip); } //painter.drawText(bounding_box_, Qt::AlignLeft, text_); //std::cout << "Text to draw: " << st_.text() << " @ " << bounding_box_.topLeft().x() << "," << bounding_box_.topLeft().y() << "\n\n"; painter.drawStaticText(bounding_box_.topLeft(), st_); //QRect rect = QRect(10, 30, 180, 20); //painter.translate( rect.topLeft() ); //doc_.drawContents( &painter, bounding_box_ ); //painter. if (selected_) { drawBoundingBox_(painter); } painter.restore(); }
void QLongLongValidator::setTop(qlonglong top) { setRange(bottom(), top); }
bool is_inside(const PosT& p) const { return p.x_ >= left() && p.x_ < right() && p.y_ >= top() && p.y_ < bottom(); }
void ImmutableSpace::print() const { print_short(); tty->print_cr(" [%#-6lx,%#-6lx)", bottom(), end()); }
void QDoubleValidator::setTop(double top) { setRange(bottom(), top, decimals()); }
geometry_msgs::Pose2D findTarget(cv::Mat img) { cv::Mat cdst, mdst; mdst = img - img; std::vector<cv::Vec4i>lines; cv::Point center_point; center_point.x = 0, center_point.y = 0; double center_angle = 0.0; cdst = img; cv::HoughLinesP(cdst, lines, 1, CV_PI / 180, 25, 15, 5); int image_halfy=0; cv::Point top(0,0), bottom(0,0); int c=0; for (int i = 0; i < lines.size(); i++) { cv::Vec4i l = lines[i]; cv::line(mdst, cv::Point(l[0], l[1]), cv::Point(l[2], l[3]), cv::Scalar(255, 255, 255), 3, CV_AA); } for (int i = 0; i < lines.size(); i++) { cv::Vec4i p = lines[i]; center_point.x += (p[0] + p[2]) / 2; center_point.y += (p[1] + p[3]) / 2; if ((p[1] - p[3]) != 0) { double theta = std::atan2((p[1] - p[3]), (p[0] - p[2])); if (theta < 0) theta = 3.14 + theta; center_angle += (theta); } else { center_angle+=1.57; } } if (lines.size() != 0) { center_angle = center_angle / lines.size(); center_point.x = center_point.x / lines.size(); center_point.y = center_point.y / lines.size(); } else { center_angle= 1.57; center_point.x= bot_x; center_point.y= bot_y; } double m = tan(center_angle); if (m == HUGE_VAL) { m = 10000; } cv::Point leftCenter(0, 0), rightCenter(0, 0); double leftSlope = 0.0, rightSlope = 0.0, leftCount = 0, rightCount = 0; cv::Point proj,target; geometry_msgs::Pose2D target_pose; for (int i = 0; i < lines.size(); i++) { cv::Vec4i p = lines[i]; cv::Point midPoint = cv::Point((p[0] + p[2]) / 2, (p[1] + p[3]) / 2); if(m==0) continue; double L11 = (0 - center_point.y) / m - (0 - center_point.x); double L22 = (midPoint.y - center_point.y) / m - (midPoint.x - center_point.x + 0.0); if (L11 * L22 > 0) { leftCenter.x += midPoint.x; leftCenter.y += midPoint.y; if ((lines[i][0] - lines[i][2]) != 0) { leftSlope += -(lines[i][1] - lines[i][3]) / (lines[i][0] - lines[i][2]); } leftCount++; } else { rightCenter.x += midPoint.x; rightCenter.y += midPoint.y; if ((lines[i][0] - lines[i][2]) != 0) { rightSlope += -(lines[i][1] - lines[i][3]) / (lines[i][0] - lines[i][2]); } rightCount++; } } if(leftCount!=0 && rightCount!=0){ leftCenter.x /= leftCount; leftCenter.y /= leftCount; leftSlope /= leftCount; rightCenter.x /= rightCount; rightCenter.y /= rightCount; rightSlope /= rightCount; if ((center_point.x - leftCenter.x) < 50 || (leftCenter.x - center_point.x) < 50) { center_point.x += 150; //Target must not lie on the lane target.x = 150; } if ((rightCenter.x - center_point.x) < 50 || (center_point.x - rightCenter.x) < 50) { center_point.x = center_point.x - 150; target.x -= 150; } } proj.x = (bot_x + m * (bot_y - center_point.y) + m * m * center_point.x) / (1 + m * m); // Verified proj.y = (center_point.y + m * (bot_x - center_point.x) + m * m * bot_y) / (1 + m * m); // Verify it target.x += proj.x + cos(center_angle) * step_move; target.y = proj.y + sin(center_angle) * step_move; center_angle = -1 * center_angle * 180 / CV_PI; target_pose.x = target.x; target_pose.y = (-1 * target.y + origin.y); target_pose.theta = center_angle; if(target_pose.x>img.cols) target_pose.x=img.cols; if(target_pose.y>img.rows) target_pose.y=img.rows; if(target_pose.y<0) target_pose.y=0; std::cout << "target.x: " << target_pose.x << " target.y: " << target_pose.y << std::endl; //std::cout << "proj.x: " << proj.x << " " << "proj.y: " << proj.y << std::endl; //cv::line(mdst, cv::Point(bot_x, bot_y), target, cv::Scalar(255), 2, 8); //cv::namedWindow("Center_path", cv::WINDOW_NORMAL); //cv::imshow("Center_path", mdst); //cv::waitKey(0); return target_pose; }
int OCRText::middle() { return (top() + bottom()) / 2; }
// Size computations. Sizes are in bytes. size_t capacity() const { return byte_size(bottom(), end()); }