CostMapAccessor::CostMapAccessor(const CostMap2D& costMap, double maxSize, double poseX, double poseY)
: ObstacleMapAccessor(computeWX(costMap, maxSize, poseX, poseY),
computeWY(costMap, maxSize, poseX, poseY),
computeSize(maxSize, costMap.getResolution()),
computeSize(maxSize, costMap.getResolution()),
costMap.getResolution()), costMap_(costMap),
maxSize_(maxSize){
setCircumscribedCostLowerBound(costMap.getCircumscribedCostLowerBound());
// Set robot position
updateForRobotPosition(poseX, poseY);
ROS_DEBUG_NAMED("costmap_2d", "Creating Local %d X %d Map\n", getWidth(), getHeight());
}
void MSHashTable::resize(unsigned size_)
{
MSHashEntry **oldBuckets=bucket();
unsigned oldSize=size();
_size=computeSize(size_);
_bucket=new MSHashEntry*[size()];
unsigned i=size();
MSHashEntry **p=bucket();
while(i--) *p++=0;
if (oldBuckets!=0)
{
for (unsigned j=0;j<oldSize;j++)
{
// we want to add them in reverse order of the chains, i.e. add them in the order that they
// were originally added - latest additions are at the top of the bucket chain
MSHashEntry *entry=oldBuckets[j];
MSHashEntry *prev;
while (entry!=0&&entry->next()!=0) entry=entry->next();
while (entry!=0)
{
prev=entry->prev();
entry->prev(0),entry->next(0);
addEntry(entry); // rehash and add to the new table
entry=prev;
}
oldBuckets[j]=0;
}
delete [] oldBuckets;
}
}
TCDynStr::TCDynStr(const TCString& str,uint pos,uint count)
/****************************************************************************
*
* Function: TCDynStr::TCDynStr
* Parameters: str - TCString to copy from
* pos - Starting position in the string
* count - Number of characters to copy
*
* Description: Constructs a string from another string, starting at the
* position 'pos' and including 'count' characters.
*
****************************************************************************/
{
CHECK(str.valid());
if (pos > str.length())
pos = str.length();
if (count > str.length() - pos)
count = str.length() - pos;
len = count+1;
size = computeSize(len);
if ((text = new char[size]) != NULL) {
memcpy(text,(const char *)str+pos,len);
text[count] = '\0'; // Null terminate the string
}
}
void ossimPlanetKmlScreenOverlayNode::update()
{
if((!theIconGeom.valid())||(!theIconGeom->texture().valid())) return;
if(theIconGeom->texture()->getImage())
{
ossim_uint32 w = theIconGeom->texture()->getImage()->s();
ossim_uint32 h = theIconGeom->texture()->getImage()->t();
if(w||h)
{
osg::Vec3d screenOrigin;
osg::Vec3d overlayOrigin;
osg::Vec3d size;
computeScreenXY(screenOrigin);
computeOverlayXY(overlayOrigin);
computeSize(size);
// std::cout << "oringx = " << origin[0] << std::endl;
// std::cout << "oringy = " << origin[1] << std::endl;
theIconGeom->setGeometry(screenOrigin-overlayOrigin,
osg::Vec3d(size[0], 0.0, 0.0),
osg::Vec3d(0.0, size[1], 0.0));
// std::cout << "W = " << theIconGeom->texture()->getImage()->s() << std::endl;
theNeedsUpdateFlag = false;
}
else
{
theNeedsUpdateFlag = true;
}
}
else
{
theNeedsUpdateFlag = true;
// std::cout << "NOT VALID!!!" << std::endl;
}
}
TCDynStr& TCDynStr::operator = (const TCString& str)
/****************************************************************************
*
* Function: TCDynStr::operator =
* Parameters: str - TCString to assign from
* Returns: Reference to the newly created string.
*
* Description: Assignment operator given a string. We delete the old text
* and then create a new string.
*
****************************************************************************/
{
// If the amount of memory required for the new string is the same as
// for the old string, we do not need to delete the memory allocated
// to the text!
CHECK(valid() && str.valid());
uint newsize = computeSize(str.length()+1);
char *temp = text;
if (size != newsize)
temp = new char[newsize];
if (temp) {
len = str.length()+1;
memcpy(temp,str,len);
if (size != newsize) {
size = newsize;
delete [] text;
text = temp;
}
text[len-1] = '\0'; // Null Terminate string
}
return *this;
}
void TCDynStr::shrink()
/****************************************************************************
*
* Function: TCDynStr::shrink
*
* Description: Shrinks the size of the allocated memory down to the
* smallest possible amount.
*
****************************************************************************/
{
char *temp;
CHECK(valid());
if ((size - len) > granularity) {
// Determine the smallest possible size (in increments of
// granularity and allocate the new memory
size = computeSize(len);
temp = new char[size];
// Copy the text and delete the old text
if (temp)
memcpy(temp,text,len);
delete [] text;
text = temp;
}
}
void MSCheckPopupMenu::updateData(void)
{
if (MSView::model()!=0)
{
freeze();
const MSStringVector& aStringVector=stringVector();
unsigned currentCount(itemCount());
unsigned i;
MSWidgetVector itemVector(children());
MSCheckMenuItem *pMenuItem;
for (i=0;i<aStringVector.length();i++)
{
if (i<itemVector.length())
{
pMenuItem=(MSCheckMenuItem *)itemVector(i);
pMenuItem->label(aStringVector(i));
pMenuItem->state(MSFalse);
}
else
{
pMenuItem=new MSCheckMenuItem(this,aStringVector(i),0,i);
pMenuItem->selectColor(_selectColor);
}
setItem(pMenuItem,i);
}
for (i=aStringVector.length();i<itemVector.length();i++)
{
pMenuItem=(MSCheckMenuItem *)itemVector(i);
delete pMenuItem;
}
unfreeze();
computeSize();
}
else removeAllItems();
}
void Text::setFont(const std::string& f, float size)
{
m_font = f;
m_pts = size;
shrinkLines();
computeSize();
}
QRectF QGraphicsItemComposite::boundingRect() const
{
// variables
qreal xmin, xmax, ymin, ymax;
computeSize(xmin, xmax, ymin, ymax);
return QRectF(QPointF(), QRectF(QPointF(xmin, ymin), QPointF(xmax, ymax)).size());
}
int Compressor::getBestRatio(unsigned dataLength)
{
int bestBit = 0;
int compressedLength = -1;
for (int bits = 1; bits <= 7; bits++)
{
int compressed = 0;
int neededBits;
for (int i = 0; i < (1 << bits) - 1; i++)
{
if ((int)mFrequency.size() <= i)
break;
compressed += mFrequency[i].count;
}
neededBits = computeSize(bits, dataLength, compressed);
if (neededBits < compressedLength || compressedLength == -1)
{
compressedLength = neededBits;
bestBit = bits;
}
}
return bestBit;
}
TCDynStr::TCDynStr(const char *cstr,uint pos,uint count)
/****************************************************************************
*
* Function: TCDynStr::TCDynStr
* Parameters: cstr - C style string to copy from
* pos - Starting position in the string
* count - Number of characters to copy
*
* Description: Constructs a string from a C string, starting at the
* position 'pos' and including 'count' characters.
*
****************************************************************************/
{
CHECK(cstr != NULL);
len = strlen(cstr) + 1;
if (pos >= len)
pos = len-1;
if (count >= len - pos)
count = len-1 - pos;
len = count+1;
size = computeSize(len);
if ((text = new char[size]) != NULL) {
memcpy(text,cstr+pos,count);
text[count] = '\0'; // Null terminate the string
}
}
void MSOptionPopupMenu::update(const MSIndexVector& index_)
{
if (MSView::model()!=0)
{
if (index_.length()==0)
{
if (optionsModel().length()==itemCount())
{
MSMenuItem *mi;
int i,n=itemCount();
for(i=0;i<n;i++)
{
mi=(MSMenuItem *)itemVector()(i);
mi->label(optionsModel()(i));
}
computeSize();
optionMenu()->setSelectedItem(0);
optionMenu()->computeSize();
}
else rebuildMenu();
}
else
{
MSIndexVector iv(index_);
iv.sortUp();
if (iv(0)==itemCount())
{
for (unsigned i=0,j=itemCount();i<iv.length();i++,j++)
{
MSMenuItem *pMenuItem=new MSMenuItem(this,optionsModel()(j),0,j);
setItem(pMenuItem,j);
}
}
else
{
for (unsigned i=0;i<iv.length();i++)
{
unsigned index=iv(i);
MSMenuItem *mi=menuItem(index);
if (mi!=0) mi->label(optionsModel()(index));
}
}
}
computeSize();
optionMenu()->computeSize();
}
}
bool NetworkGraphics::positionBranch(raw_address root, QPointF topLeft){
if(!cloudAddrMap.contains(root)){
return false;
}
GraphicNetCloud* cloud = getCloudByAddress(root);
qDebug() << "NetworkGraphics::positionBranch - Moving cloud:" << cloud->getAddress().toString().c_str();
QSizeF size = computeSize(root);
qreal centerX = topLeft.x() + (size.width()/2.0);
cloud->setY(topLeft.y());
cloud->setX(centerX - (cloud->boundingRect().width() / 2.0));
//Update to start in next row
topLeft.setY(topLeft.y() + cloud->boundingRect().height());
QMultiMap<uint8_t, raw_address> branch = network->getBranchAddresses(root);
QList<uint8_t> keys = branch.uniqueKeys();
if(keys.size() > 1){
//for(int i=1; i<keys.size(); i++){
QPointF cloudPos = topLeft;
QList<GraphicNetCloud*> clouds = getCloudsByAddress(branch.values(keys[1]));
qreal maxHeight = 0.0;
for(int j=0; j<clouds.size(); j++){
GraphicNetCloud* cloud = clouds[j];
//cloud->setPos(cloudPos);
QSizeF size = computeSize(cloud->getAddress());
positionBranch(cloud->getAddress(), cloudPos);
cloudPos.setX(cloudPos.x() + size.width());
maxHeight = fmax(cloud->boundingRect().height(), maxHeight);
}
//topLeft.setY(topLeft.y() + maxHeight);
}
return true;
}
void MSToggleButtonBase::toggleShadowThickness(int thickness_)
{
if (toggleShadowThickness()!=thickness_)
{
_toggleShadowThickness=thickness_;
computeSize();
}
}
void Button::removeEditor()
{
m_editor->hide();
m_editor->deleteLater();
m_editor = 0;
computeSize();
repaint();
emit needsUpdate();
}
void ILayoutBox::clearChildren()
{
for (std::list<TLayoutItem>::const_iterator it = m_children.begin(); it != m_children.end(); ++it)
{
delete it->widget;
}
m_children.clear();
computeSize();
}
void
TextPainter::setText(std::string text) {
{
boost::mutex::scoped_lock lock(_dataMutex);
_text = text;
computeSize(_lastRoi, _lastResolution);
}
}
void onDraw(SkCanvas* canvas) override {
canvas->translate(10, 10);
for (size_t i = 0; i < SK_ARRAY_COUNT(fMatrix); ++i) {
SkSize size = computeSize(fBM, fMatrix[i]);
size.fWidth += 20;
size.fHeight += 20;
draw_row(canvas, fBM, fMatrix[i], size.fWidth);
canvas->translate(0, size.fHeight);
}
}
ComputeSize MakeStencilComputeSize(const glm::ivec2& size, int radius)
{
ComputeSize computeSize(ComputeSize::Default2D());
auto localSize = ComputeSize::GetLocalSize2D();
computeSize.DomainSize = size;
computeSize.LocalSize = localSize;
computeSize.WorkSize = glm::ceil(glm::vec2(size) / glm::vec2(localSize - glm::ivec2(2 * radius)));
return computeSize;
}
void
TextPainter::setTextSize(double size) {
{
boost::mutex::scoped_lock lock(_dataMutex);
_textSize = size;
_padding = size/2;
computeSize(_lastRoi, _lastResolution);
}
}
void MSTextRect::font(Font fid_)
{
if (fid_!=0&&fid_!=font())
{
Font oldfid=_fid;
_fid=fid_;
textMSGC().font(fid_);
_textFontStruct=(XFontStruct *)server()->fontStruct(font());
computeSize();
updateFont(oldfid);
}
}
void MSHashTable::init(unsigned size_)
{
if (bucket()==0)
{
_size=computeSize(size_);
_bucket=new MSHashEntry*[size()];
unsigned i=size();
MSHashEntry **p=bucket();
while(i--) *p++=0;
}
else resize(size_);
}
FormDataIODevice::FormDataIODevice(FormData* data)
: m_currentFile(0)
, m_currentDelta(0)
, m_fileSize(0)
, m_dataSize(0)
{
setOpenMode(FormDataIODevice::ReadOnly);
prepareFormElements(data);
prepareCurrentElement();
computeSize();
}
uint32_t ABCFile::size()
{
AvmAssert(scriptCount != 0);
AvmAssert(methodCount != 0);
AvmAssert(methodbodyCount != 0);
AvmAssert(classCount == instanceCount);
uint32_t method_size = computeSize(methods.get());
uint32_t metadata_size = computeSize(metadatas.get());
uint32_t instance_size = computeSize(instances.get());
uint32_t class_size = computeSize(classes.get());
uint32_t script_size = computeSize(scripts.get());
uint32_t body_size = computeSize(bodies.get());
reported_size = (4 +
lenU30(intCount) + intBuf.size() +
lenU30(uintCount) + uintBuf.size() +
lenU30(doubleCount) + doubleBuf.size() +
lenU30(stringCount) + stringBuf.size() +
lenU30(namespaceCount) + namespaceBuf.size() +
lenU30(nssetCount) + nssetBuf.size() +
lenU30(multinameCount) + multinameBuf.size() +
lenU30(methodCount) + method_size +
lenU30(metadataCount) + metadata_size +
lenU30(instanceCount) + instance_size + class_size +
lenU30(scriptCount) + script_size +
lenU30(methodbodyCount) + body_size);
return reported_size;
}
// Take a deep copy of the FormDataElement
FormDataIODevice::FormDataIODevice(FormData* data)
: m_formElements(data ? data->elements() : Vector<FormDataElement>())
, m_currentFile(0)
, m_currentDelta(0)
, m_fileSize(0)
, m_dataSize(0)
{
setOpenMode(FormDataIODevice::ReadOnly);
if (!m_formElements.isEmpty() && m_formElements[0].m_type == FormDataElement::encodedFile)
openFileForCurrentElement();
computeSize();
}
size_type computeSize(const Teuchos::Array< DIM_TYPE > & dimensions)
{
// In the MDArray<T>(const MDArrayView<T> &) constructor, I try to
// pass the MDArrayView dimensions to computeSize(), but they come
// in as ArrayView<const T> (for reasons I can't determine) and
// cause all sorts of const-correctness problems. So I copy them
// into a new Array<T> and pass its view to the main computeSize()
// function. Fortunately, the array of dimensions is small.
Teuchos::Array< DIM_TYPE > nonConstDims(0);
nonConstDims.insert(nonConstDims.begin(),
dimensions.begin(),
dimensions.end());
return computeSize(nonConstDims());
}
ComputeSize MakeCheckerboardComputeSize(const glm::ivec2& size)
{
auto localSize = ComputeSize::GetLocalSize2D();
localSize.x /= 2;
localSize.y *= 2;
ComputeSize computeSize(ComputeSize::Default2D());
computeSize.DomainSize = size;
computeSize.LocalSize = localSize;
computeSize.WorkSize =
glm::ceil(glm::vec2(size) / (glm::vec2(localSize) * glm::vec2(2.0f, 1.0f)));
return computeSize;
}
void ossimPlanetKmlScreenOverlayNode::computeOverlayXY(osg::Vec3d& position)
{
osg::Vec3d size;
computeSize(size);
switch(theOverlayXUnits)
{
case ossimPlanetKmlUnits_FRACTION:
{
position[0] = theOverlayOrigin[0]*size[0];
break;
}
case ossimPlanetKmlUnits_PIXELS:
{
position[0] = theOverlayOrigin[0];
break;
}
case ossimPlanetKmlUnits_INSET_PIXELS:
{
break;
}
default:
{
break;
}
}
switch(theScreenYUnits)
{
case ossimPlanetKmlUnits_FRACTION:
{
position[1] = theOverlayOrigin[1]*size[1];
break;
}
case ossimPlanetKmlUnits_PIXELS:
{
position[1] = theOverlayOrigin[1];
break;
}
case ossimPlanetKmlUnits_INSET_PIXELS:
{
break;
}
default:
{
break;
}
}
}
void ToolTipWidget::run(const QPoint &point, QAbstractItemModel *model,
const QModelIndex &index, const QString & /* msg */)
{
move(point);
setModel(model);
setRootIndex(index.parent());
computeSize();
setRootIsDecorated(model->hasChildren(index));
// FIXME: use something more sensible
QPalette pal = palette();
QColor bg = pal.color(QPalette::Base);
bg.setAlpha(20);
pal.setColor(QPalette::Base, bg);
setPalette(pal);
//viewport()->setPalette(pal);
}
Button::Button(WelcomeScreen* parent, const QIcon& icon,
const QFont& font, const QString& text)
: QObject(parent)
, KGameCanvasPixmap(parent)
, m_icon(icon)
, m_font(font)
, m_text(text)
, m_fixed_width(false)
, m_down(false)
, m_hover(false)
, m_brightness(BRIGHTNESS_NORMAL)
, m_editor(0)
{
computeSize();
repaint();
}
