小编bgp*_*000的帖子

在下面的代码片段中,为什么行o.margin() = m;编译没有错误？它很容易引起警告,因为它几乎总是一个错误.我实际上认为它是一个错误,因为它在赋值的左侧放置了一个R值.

#include <iostream>

struct Margin
{
    Margin(int val=0) : val(val) {};
    int val;
};

struct Option
{
    Margin m;
    int z=0;

    Margin margin()const { return m; }
    int zoomLevel() { return z; }
};


int main()
{
    Option o;
    std::cout << "Margin is: "<< o.margin().val << std::endl;

    Margin m = { 3 };

    // The following line is a no-op, which generates no warning:
    o.margin() = m;

    // The following line is an error
    // GCC …

当用自制的指针类实现pimpl成语时,我遇到了一个惊人的启示(我知道:为什么要自己滚动？但请耐心等待).以下三个文件包含一个最小示例:

Pointer.h:

#pragma once 

template <typename T>
class Pointer
{
public:
    Pointer(T*p=0)
        : _p(p)
    {
    }
    virtual ~Pointer()
    {
        delete _p;
    }
private:
    void operator=(const Pointer&);
    Pointer(const Pointer&);

private:
    T*_p;
};

foo.h中:

#pragma once
#include "Pointer.h"

struct Foo
{
    Foo();
    ~Foo();

private:
    void operator=(const Foo&);
    Foo(const Foo&);

private:
    Pointer<struct FooPrivate> p;
};

main.cpp中:

#include "Foo.h"

int main(int argc, char* argv[])
{
    Foo foo;
    return 0;
}

别介意内脏的Foo.cpp样子.当我main.cpp使用MSVC 2008 编译时,我收到警告:

pointer.h(13) : warning C4150: deletion of pointer …

我想在c ++中尽可能快地缩小图像.本文介绍如何有效地将32位rgb图像平均降低50%.它很快,看起来很好.

我尝试使用sse intrinsics修改该方法.无论是否启用SSE,下面的代码都可以使用.但令人惊讶的是,加速可以忽略不计.

任何人都可以看到改进SSE代码的方法.创建变量shuffle1和shuffle2的两条线似乎是两个候选者(使用一些聪明的移位或类似).

/*
 * Calculates the average of two rgb32 pixels.
 */
inline static uint32_t avg(uint32_t a, uint32_t b)
{
    return (((a^b) & 0xfefefefeUL) >> 1) + (a&b);
}

/*
 * Calculates the average of four rgb32 pixels.
 */
inline static uint32_t avg(const uint32_t a[2], const uint32_t b[2])
{
    return avg(avg(a[0], a[1]), avg(b[0], b[1]));
}

/*
 * Calculates the average of two rows of rgb32 pixels.
 */
void average2Rows(const uint32_t* src_row1, const uint32_t* src_row2, uint32_t* …

我需要一个好的(稳健的)算法,用于将一个多边形分成两组(左/右)一个线段.我的多边形表示只是一个整数坐标列表(顺序时钟顺序,从不自相交),线段由起点和终点表示.该线始终在多边形外部开始和结束,即与多边形相交偶数次.

这是一个例子:

算法的输出应该是两组(顺时针行进):

• 左:HABCH,FGDEF
• 右:HCDGH,BAB,FEF

我可以通过迭代多边形并检查多边形线是否穿过线来识别点AH,注意尊重边界情况.我还可以确定每条多线所属的哪一侧.但是,对于我的生活,我不能决定如何将这些片段串在一起.

在你建议使用通用剪辑库之前:我正在使用提升多边形,它非常擅长将多边形相互修剪,但是我没有找到任何可以让你在一个线段上剪切多边形的库,一般来说它是不可能的将线段转换为我可以剪辑的多边形.

编辑:我错过了FEF以及多边形可以在线段两侧都有零件的事实.

我有一个使用7参数相机模型投影点的功能:

Vec2 project(const Rot3& R, // camera orientation
             const Vec3& T, // camera pos
             double f_px,   // focal length
             const Vec3& X) // point in world;
{
    const Vec3 P = R * (X-T);               // Subtract camera position and apply rotation
    const Vec2 p = P.hnormalized() * f_px;  // Normalize and apply focal length
    return p;
}

• Rot3是一种方便的旋转表示.假设它是3x3矩阵.
• Vec3 :: hnormalized()返回Vec2(x/z,y/z)

现在我想扩展函数以对我投射的点进行不确定性估计(3x3协方差矩阵 - 世界坐标中的椭球)并返回2x2协方差矩阵(像素坐标中的椭圆).

我认为Hartley&Zisserman 在计算机视觉中 的多视图几何的引用适用于此,但我无法弄清楚它的数学.

我有一个功能可以将 8 位图像缩小两倍。我之前已经用 SSE 优化了 rgb32 案例。现在我想对 gray8 案例做同样的事情。

在核心，有一个函数取两行像素数据，其工作方式如下：

/** 
 * Calculates the average of two rows of gray8 pixels by averaging four pixels.
 */
void average2Rows(const uint8_t* row1, const uint8_t* row2, uint8_t* dst, int size)
{
    for (int i = 0; i < size - 1; i += 2)
        *(dst++) = ((row1[i]+row1[i+1]+row2[i]+row2[i+1])/4)&0xFF;
}

现在，我想出了一个 SSE 变体，它大约快三倍，但它确实涉及很多改组，我认为可能会做得更好。有人看到这里可以优化什么吗？

/* row1: 16 8-bit values A-P
 * row2: 16 8-bit values a-p
 * returns 16 8-bit values (A+B+a+b)/4, (C+D+c+d)/4, ..., …

我正在编写一个类，该类具有带const char*参数的显式构造函数。为了这个问题的目的和目的，它看起来像这样：

struct Symbol
{
    Symbol()=default;
    explicit Symbol(const char*);
};

现在，出于文档目的，我想编写一个示例来初始化一个数组（array / vector / list-我不在乎确切的类型），并且我需要该示例尽可能简洁明了。理想的情况是这样的：

Symbol symbols[] = { "a", "b", "c"};

由于explicit关键字，因此无法编译，因此我不准备将构造函数设为隐式。

我如何使这项工作有效，重点在于使示例代码尽可能具有表现力？

编辑：在Caleth的一点帮助下，我寻求Bolov的解决方案：

struct Symbol
{
    Symbol();
    explicit Symbol(const char*);

    template <class... Args> 
    static std::array<Symbol, sizeof...(Args)> Array(Args... args)
    {
        return {Symbol{args}...}; 
    } 
};

int main()
{
    auto symbols = Symbol::Array("a", "b", "c");
}