小编Fez*_*vez的帖子

这真的是一个简单的问题:

我正在编写Go程序.我应该用一个QVector<int>或QVector<Player>哪个代表董事会

enum Player
{
    EMPTY = 0,
    BLACK = 1,
    WHITE = 2
};

我想当然,使用Player而不是整数会更慢.但我想知道还有多少,因为我相信使用enum更好的编码.

我做了一些关于分配和比较玩家的测试(相对于int)

QVector<int> vec;
vec.resize(10000000);
int size = vec.size();


for(int i =0; i<size; ++i)
{
    vec[i] = 0;
}


for(int i =0; i<size; ++i)
{
    bool b = (vec[i] == 1);
}


QVector<Player> vec2;
vec2.resize(10000000);
int size = vec2.size();


for(int i =0; i<size; ++i)
{
    vec2[i] = EMPTY;
}


for(int i =0; i<size; ++i)
{
    bool b …

我有一个QMap对象,我正在尝试将其内容写入文件.

QMap<QString, QString> extensions;
//.. 

for(auto e : extensions)
{
  fout << e.first << "," << e.second << '\n';
}  

为什么我得到: error: 'class QString' has no member named 'first' nor 'second'

是e不是类型QPair？

目前的情况:我正在尝试从图像中提取片段.感谢openCV的findContours()方法,我现在有一个每个轮廓的8连接点列表.但是,这些列表不能直接使用,因为它们包含大量重复项.

问题:给定一个包含重复项的8个连接点的列表,从中提取段.

可能的解决方案 :

• 起初,我使用openCV的approxPolyDP()方法.然而,结果非常糟糕......这是缩放的轮廓:

以下是结果approxPolyDP():(9段!有些重叠)

但我想要的更像是:

这很糟糕,因为approxPolyDP()可以在"几个细分"中转换"看起来像几个细分"的东西.但是,我所拥有的是一个点列表,这些点往往会对自己进行多次迭代.

例如,如果我的观点是:

0 1 2 3 4 5 6 7 8 
  9   

然后,点的列表将是0 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1 9......如果点的数量变大(> 100),那么提取的段approxPolyDP()不幸地不是重复的(即:它们彼此重叠,但是不是非常相等,所以我可以'只是说"删除重复",而不是像素一样)

• 也许,我有一个解决方案,但它很长(虽然很有趣).首先,对于所有8个连接列表,我创建一个稀疏矩阵(为了效率),如果像素属于列表,则将矩阵值设置为1.然后,我创建一个图形,其中节点对应于像素,相邻像素之间的边缘.这也意味着我在像素之间添加了所有缺失的边缘(复杂性很小,可能因为稀疏矩阵).然后我删除所有可能的"正方形"(4个neighouring节点),这是可能的,因为我已经在很薄的轮廓上工作.然后我可以启动最小生成树算法.最后,我可以使用openCV来近似树的每个分支approxPolyDP()

细分http://img197.imageshack.us/img197/4488/segmentation.png

这是原始列​​表的精彩图片(感谢Paint!)和相关图表.然后,当我在邻居之间添加边缘时.最后,当我删除边缘并制作最小生成树(这里没用)

总结一下:我有一个乏味的方法,我还没有实现,因为它似乎容易出错.但是,我问你,StackOverflow的人:是否有其他现有的方法,可能有很好的实现？

编辑:澄清一下,一旦我有一棵树,我就可以提取"分支"(分支从叶子或连接到3个或更多其他节点的节点开始)然后,openCV中的算法approxPolyDP()是Ramer-Douglas-Peucker算法,这里是维基百科的图片:

通过这张图片,很容易理解为什么当点可能彼此重复时它会失败

另一个编辑:在我的方法中,有一些东西可能有趣值得注意.当您考虑位于网格中的点(如像素)时,通常,最小生成树算法没有用,因为有许多可能的最小树

X-X-X-X
|
X-X-X-X

在基金会上是非常不同的 …

在我正在编写的软件中,我正在进行数百万乘法或除以2(或2的幂)的值.我真的希望这些值int能够访问bitshift运算符

int a = 1;
int b = a<<24

但是,我不能,而且我必须坚持双打.

我的问题是:由于存在双精度(符号,指数,尾数)的标准表示,是否有一种方法可以与指数一起使用以2的幂来获得快速乘法/除法？

我甚至可以假设位数将被修复(该软件将在总是具有64位长的双倍的机器上工作)

PS:是的,该算法主要只执行这些操作.这是瓶颈(它已经是多线程的).

编辑:或者我完全错了,聪明的编译器已经为我优化了一些东西？

临时结果(用Qt测量时间,矫枉过正,但我​​不在乎):

#include <QtCore/QCoreApplication>
#include <QtCore/QElapsedTimer>
#include <QtCore/QDebug>

#include <iostream>
#include <math.h>

using namespace std;

int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);

while(true)
{
    QElapsedTimer timer;
    timer.start();

    int n=100000000;
    volatile double d=12.4;
    volatile double D;
    for(unsigned int i=0; i<n; ++i)
    {
        //D = d*32;      // 200 ms
        //D = d*(1<<5);  // 200 ms
        D = ldexp (d,5); // 6000 ms
    } …

计算机科学中有几种颜色表示:标准RGB,还有HSV,HSL,CIE XYZ,YCC,CIELAB,CIELUV ......在我看来,大多数时候,这些表示试图近似人类的视觉(颜色)在感知上相同应该有类似的表示)

但我想知道的是,在图片方面,哪种表现最为"稳定".我有一个物体,比方说一瓶可乐,我有几千张这瓶的照片,在不同情况下拍摄(主要区别在于照片的亮度或暗度,但有方向等等...... )

我的问题是:什么颜色表示将凭经验给我最稳定的瓶子颜色表示？标签的"红色"颜色不应有太大变化.好吧,我知道它会有所不同,但我想知道最"稳定"的表现形式.

我已经被告知HSV对于这些东西比RGB更好,但我对其余部分一无所知.

编辑(技术细节):我采取瓶子的特定点.我在这一点的一千张照片中选择了相应的像素.我现在有一堆积分,取决于表现形式.我希望表示最小化此云的"大小",例如最小化云点到其重心的平均距离的表示.

我已经完成了一个Go程序,人类可以在任何时候打断软件来命令它播放.基本上,我有一个算法在另一个线程中运行,每个时刻都有一个"最佳移动",它不断改进.

我的问题是:如何在无限循环中正确中断线程？

我尝试了一些事情,并决定这样做:

class MyWorker : public QObject
{
    Q_OBJECT
public:
    MyWorker();
    ~MyWorker();

public:
    ThreadControl * getThreadControl();

public slots:
    void work();

private:
    void endOfComputation();

private:
    ThreadControl * threadControl;
}

请注意,我不是QThread的子类:

class ThreadControl : public QObject
{
    Q_OBJECT
public:
    ThreadControl();

public:
    bool getAbort();
    Parameter getParameter();
    void setParameter(Parameter & param);

public slots:
    void setAbort(bool b);

private:
    QMutex mutex;
    bool abort;
    Parameter param;
};

最后,无限循环被编码为:

void Myworker::work()
{
    // ...
    forever
    {
        abort = threadControl->getAbort();
        if(abort)
        {
            break;
        }
        // …

我目前正在构建一个小型的实时策略2D引擎.而且我想知道如何处理那些最终会让我的屏幕变得更加精彩的精灵.

仅供参考,我不是针对任何AAA级别的,我只是想尝试实现一些机器学习方法.因此,我选择了魔兽争霸II放弃软件ISO,无耻地采取了一些图形,我在第一个问题上摔倒了.

http://img263.imageshack.us/img263/1480/footman.png

正如你上面所看到的,即使是魔兽争霸II的简单仆人也有大约50个精灵用于动画.这是很多.它会经常改变精灵.(黑线只是检查我的alpha通道是否正确)

因此,最后一个问题:如何有效地实现不断变化的QGraphicsObject？如何有效地实现反复更改其外观的QGraphicsItem？

我是否只是重载paint()QGraphicsPixmapItem 的方法并继续更改屏幕上使用的Pixmap？它会导致一些"口吃"吗？我听说有时候,创建一个所有像素图,隐藏所有像素图并在需要时复制它们是明智/可能的.(复制比其他操作便宜)还有其他任何聪明的想法吗？

感谢您的任何意见!(RTS引擎教程,复杂性等等......)

我正在尝试做一个需要处理大量简单2D对象的项目,当然需要绘制它们.为此,我需要一个可以处理大量"精灵"的好的C++库.

我一直在尝试Qt,因为我认为他们的"40,000芯片"演示非常令人印象深刻.然而,有点玩弄,似乎我的电脑管理160,000芯片有很多麻烦.我不知道技术细节为什么它很慢(CPU？糟糕的OpenGL的GPU使用率？Qt对于大量的项目不好？)

所以,我一直在网上搜索一个适合我需要的图书馆.但我找不到任何东西,主要是因为没有图书馆似乎说"嘿,我擅长管理1,000,000个对象!",但我确信有些图书馆比其他图书馆更有能力.

我不需要像SDL一样"好"的库,如果我没有操纵杆支持或其他什么都没关系.我只需要显示,缩放,旋转和移动大量简单的2D对象.

谢谢!

PS:我测试了Ogre3D.我想知道他们如何设法处理15K三角形并在他们的演示程序中以100fps的速度在我的计算机上运行.而且,它是3D的!如果我去150K三角形,它是否可以很好地扩展？

似乎QtConcurrent可以正常使用QT容器(QList和QVector),但是使用STL容器失败了,而不是文档中声明的内容.

以下是我想在容器上使用的虚拟函数:

void addOne(int & i)
{
    ++i;
}

int addOneC(const int & i)
{
    return i+1;
}

什么有效的例子:

int main( int argc, char** argv )
{
    // Qt containers
    QList<int> l;
    l << 1 << 2 << 4 << 3;
    QList<int> l1 = QtConcurrent::blockingMapped(l, addOneC);
    QtConcurrent::blockingMap(l1, addOne);

    // Standard containers
    vector<int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(4);
    v.push_back(3);
    QtConcurrent::blockingMap(v, addOne);
}

什么不工作:

int main( int argc, char** argv )
{
    // Standard …

我有一个小问题,lambda表达式,而使用remove_if上std::vector

我有一段代码:

    std::remove_if( openList.begin(), openList.end(), 
        [&](BoardNode& i){
            std::cout<< i.getCoordinates() << std::endl;
            std::cout<< currentNode.getCoordinates() << std::endl;
            return i.getCoordinates() == currentNode.getCoordinates(); }
        );

这没有编译器错误,但是从上面的语句返回true的元素不会从向量中删除;

我被打印在屏幕上,例如

[5,5]
[5,5]

但openList遗骸原样.