标签: cross-product

我希望有一个二进制运算符cross(交叉产品/笛卡尔积)在Scala中使用遍历运算:

val x = Seq(1, 2)
val y = List('hello', 'world', 'bye')
val z = x cross y    # i can chain as many traversables e.g. x cross y cross w etc

assert z == ((1, 'hello'), (1, 'world'), (1, 'bye'), (2, 'hello'), (2, 'world'), (2, 'bye'))

仅在Scala中执行此操作的最佳方法是什么(即不使用scalaz之类的东西)？

正如标题所说,我想通过使用相邻像素的叉积来计算给定深度图像的表面法线.我想使用Opencv并避免使用PCL,但是我并不真正理解这个过程,因为我的知识在这个主题上非常有限.因此,如果有人可以提供一些提示,我将不胜感激.这里要提到的是除了深度图像和相应的rgb图像之外我没有任何其他信息,所以没有K相机矩阵信息.

因此,假设我们有以下深度图像:

并且我想在相应的点找到具有相应深度值的法向量,如下图所示:

如何使用相邻像素的叉积来做到这一点？我不介意法线是否高度准确.

谢谢.

更新:

好吧,我试图关注@ timday的答案并将他的代码移植到Opencv.使用以下代码:

Mat depth = <my_depth_image> of type CV_32FC1
Mat normals(depth.size(), CV_32FC3);

for(int x = 0; x < depth.rows; ++x)
{
    for(int y = 0; y < depth.cols; ++y)
    {

        float dzdx = (depth.at<float>(x+1, y) - depth.at<float>(x-1, y)) / 2.0;
        float dzdy = (depth.at<float>(x, y+1) - depth.at<float>(x, y-1)) / 2.0;

        Vec3f d(-dzdx, -dzdy, 1.0f);
        Vec3f n = normalize(d);

        normals.at<Vec3f>(x, y) = n;
    }
}

imshow("depth", depth / 255);
imshow("normals", normals);

我得到正确的结果如下(我不得不更换double …

我最终确信这个问题有一个答案,但是对于我的生活来说无法弄清楚如何去做.

假设我有三套:

A = [ 'foo', 'bar', 'baz', 'bah' ]
B = [ 'wibble', 'wobble', 'weeble' ]
C = [ 'nip', 'nop' ]

而且我知道如何计算笛卡尔/十字架产品,(蚂蚁它覆盖了整个地方,在这个网站和其他地方)所以我不会在这里讨论它.

我正在寻找的是一种算法,它允许我简单地从笛卡尔积中选择一个特定项而不生成整个集或迭代直到我到达第n个项.

当然,我可以很容易地迭代一个像这样的小例子集,但我正在处理的代码将使用更大的集合.

因此,我正在寻找一个功能,我们称之为'CP',其中:

CP(1) == [ 'foo', 'wibble', 'nip' ]
CP(2) == [ 'foo', 'wibble', 'nop' ]
CP(3) == [ 'foo', 'wobble', 'nip' ]
CP(4) == [ 'foo', 'wobble', 'nop' ]
CP(5) == [ 'foo', 'weeble', 'nip' ]
CP(6) == [ 'foo', 'weeble', 'nop' ]
CP(7) == [ 'bar', 'wibble', 'nip' ]
...
CP(22) …

我想在Perl中进行排列.例如,我有三个数组:["big", "tiny", "small"]然后我有["red", "yellow", "green"],也有["apple", "pear", "banana"].

如何得到:

["big", "red", "apple"]
["big", "red", "pear"]

..etc..

["small", "green", "banana"]

我理解这叫做排列.但我不知道该怎么做.另外我不知道我可以拥有多少阵列.可能有三个或四个,所以我不想做嵌套循环.

在Hat运算符的 Eigen中是否有现成的函数或方法？这是运算符,返回一个矩阵,模拟与该向量的叉积.我知道,它可以很容易编写,但我想避免它:

Eigen::Vector3d t = // some vector ;
Eigen::Matrix3d t_hat;
t_hat << 0, -t(2), t(1),
    t(2), 0, -t(0),
    -t(1), t(0), 0;

我想这是一个学术问题,但第二个结果对我来说没有意义.它不应该像第一个一样彻底空洞吗？这种行为的理由是什么？

from itertools import product

one_empty = [ [1,2], [] ]
all_empty = []

print [ t for t in product(*one_empty) ]  # []
print [ t for t in product(*all_empty) ]  # [()]

更新

感谢所有的答案 - 非常有用.

维基百科对Nullary Cartesian产品的讨论提供了一个明确的陈述:

没有集合的笛卡尔积......是包含空元组的单例集.

这里有一些代码可以用来处理来自sth的深刻答案:

from itertools import product

def tproduct(*xss):
    return ( sum(rs, ()) for rs in product(*xss) )

def tup(x):
    return (x,)

xs = [ [1, 2],     [3, 4, 5]       ]
ys = [ ['a', …

用于计算左手坐标的交叉积的方法是否改变？

我想计算Fortran 90中两个向量的叉积.例如,在单词中,(1,2,3)和(4,5,6)的叉积结果为(-3,6, -3)在笛卡尔坐标系中.我编写了以下代码(主程序后跟函数定义):

PROGRAM crosstest
  IMPLICIT NONE

  INTEGER, DIMENSION(3) :: m, n
  INTEGER, DIMENSION(3) :: cross
  INTEGER, DIMENSION(3) :: r

  m=(/1, 2, 3/)
  n=(/4, 5, 6/)
  r=cross(m,n)

END PROGRAM crosstest

FUNCTION cross(a, b)
  INTEGER, DIMENSION(3) :: cross
  INTEGER, DIMENSION(3), INTENT(IN) :: a, b

  cross(1) = a(2) * b(3) - a(3) * b(2)
  cross(2) = a(3) * b(1) - a(1) * b(3)
  cross(3) = a(1) * b(2) - a(2) * b(1)
END FUNCTION cross

但是,我收到一条错误消息:

crosstest.f90:10.9:

  r=cross(m,n)
         1
Error: Rank mismatch …

我有以下伪C/Java/C#代码:

int a[]= { 30, 20 };
int b[] = { 40, 50 };
int c[] = {12, 12};

如何计算跨产品ABxAC？

我试图通过可选地应用替换来生成字符串变体.

例如,一种替换方案是删除任何空白字符序列.而不是替换所有出现的事件

>>> re.sub(r'\s+', '', 'a b c')
'abc'

- 相反,我需要为每次出现生成两个变体,因为替换是在一个变体中执行,而不是在另一个变体中执行.对于字符串'a b c' 我想要变种

['a b c', 'a bc', 'ab c', 'abc']

即.所有二元决策的叉积(结果显然包括原始字符串).

对于这种情况,可以使用re.finditer和生成变体itertools.product:

def vary(target, pattern, subst):
    occurrences = [m.span() for m in pattern.finditer(target)]
    for path in itertools.product((True, False), repeat=len(occurrences)):
        variant = ''
        anchor = 0
        for (start, end), apply_this in zip(occurrences, path):
            if apply_this:
                variant += target[anchor:start] + subst
                anchor = end
        variant += target[anchor:]
        yield variant

这为上面的例子产生了所需的输出:

>>> list(vary('a b c', re.compile(r'\s+'), …