相关疑难解决方法(0)

我刚刚在React Native中构建了一个相对复杂的图像编辑UI.

该体验旨在与Instagram非常相似,并具有双指缩放,平移和旋转功能.

转换存储为数据,例如:

transformation: {
  bottomBoundary: 1989,
  leftBoundary: 410,
  rightBoundary: 1634,
  topBoundary: 765,
  rotation: 0,
},

其中topBoundary和bottomBoundary都是偏离图像顶部的偏移,leftBoundary并且rightBoundary都是图像左侧的偏移.

旋转时,因为React Native使用对象的中心作为变换原点,所以当处于90°或270°方向时,图像需要偏移,这样它们仍然可以"粘"到顶部/左角并且可以偏移:

calculateRotationOffset.js

export default function (width, height) {
  const transform = [
    { rotate: `${this.rotation}deg` },
  ]

  /*
    RN rotates around centre point, so we need to
    manually offset the rotation to stick the image
    to the top left corner so that our offsets will
    work.
  */
  if (this.rotation === 90) {
    transform.push( …

我开始学习3D渲染,我一直在取得很好的进展.我已经了解了很多关于矩阵和可以在它们上执行的一般操作.

我还没有完全关注的一件事是OpenGL使用矩阵.我看到这个(以及类似的东西)相当多:

x y z n
-------
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1

所以我最好的理解是,它是一个标准化(无量级)的4维列主矩阵.此外,该矩阵特别称为"单位矩阵".

一些问题:

• 什么是"第n"维度？
• 这些如何以及何时适用？

我最大的困惑来自于OpenGL如何利用这种数据.

我正在读一本关于3D概念和OpenGL的书.这本书总是讲述世界空间,眼睛空间等等.

• 电脑显示器屏幕内究竟是什么世界？

• 什么是世界空间？

• 什么是眼睛空间？它是投影的同义词吗？

我们试图在#python通道中弄清楚如何使用sympy从视图矩阵中计算出眼睛/目标/向上矢量.一种可行的方法可能是:

from sympy import *
from pprint import pprint

v1, v2, v3, v4 = symbols('v1 v2 v3 v4')
v5, v6, v7, v8 = symbols('v5 v6 v7 v8')
v9, v10, v11, v12 = symbols('v9 v10 v11 v12')
v13, v14, v15, v16 = symbols('v13 v14 v15 v16')

V = Matrix([
    [v1, v2, v3, v4],
    [v5, v6, v7, v8],
    [v9, v10, v11, v12],
    [v13, v14, v15, v16],
    ])
u1, u2, u3 = symbols('u1 u2 u3', real=True)
t1, t2, t3 = symbols('t1 …

我见过几个类似的问题，并对我可能尝试的内容有一些想法，但我不记得看到过任何有关传播的内容。

所以：我正在开发一个测量系统，最终基于计算机视觉。

我进行 N 个捕获，并使用一个库来处理它们，该库以平移和旋转的 4x4 仿射变换矩阵的形式输出姿势估计。

这些姿势估计中有一些噪音。每个旋转轴的欧拉角的标准偏差小于 2.5 度，因此所有方向都非常接近（对于所有欧拉角都接近 0 或 180 的情况）。小于 0.25 度的标准误差对我来说很重要。但我已经遇到了欧拉角特有的问题。

我想对所有这些非常接近的姿势估计进行平均以获得单个最终姿势估计。我还想找到一些传播的衡量标准，以便我可以估计准确性。

我知道“平均”对于轮换实际上并没有很好的定义。

（郑重声明，我的代码是使用 Numpy 的 Python 编写的。）

我也可能想对这个平均值进行加权，因为已知某些捕获（和某些轴）比其他捕获更准确。

我的印象是，我可以只取平移向量的平均值和标准差，对于旋转，我可以转换为四元数，取平均值，并以良好的精度重新归一化，因为这些四元数非常接近。

我还听说过所有四元数中的最小二乘法，但我对如何实现这一点的大部分研究都以惨败告终。

这可行吗？在这种情况下是否有一个合理明确的传播衡量标准？

我正在尝试使用GPU进行布料模拟,我遇到了一些不同硬件的问题.我使用threejs作为框架,但我认为这与我遇到的问题无关.

基本上我做的是上传一个矩阵和该矩阵的逆矩阵,以便将点从局部坐标转换为世界,在世界坐标中进行一些数学运算(如碰撞检测),然后将它们转换回本地.当我使用浮点纹理时,这在我的笔记本电脑上工作得很好,但是我在手机上注意到有一些奇怪的文物:

正确:

不正确的:

在做了一些调试后,我把它缩小到两个问题.它们都与小数精度有关.由于约束(以及约束期间的精度问题)导致的顶点折叠以及使用矩阵乘法和逆时的精度损失.

我认为这个问题与精度有关的原因是因为如果我使用浮点纹理它可以在我的计算机上工作,但如果我使用半浮点数我会遇到同样的问题.我的手机支持浮点纹理,这也是我为什么会在手机上发生这种情况的原因之一.我把问题缩小了,所以所有的布料模拟都被禁用了,如果我在我的计算机上运行半浮动纹理的应用程序,没有任何重力但是转换并反转平面类型的闪烁以奇怪的方式

如果转换和反转被禁用,那么它看起来很正常.

我不知道如何处理这个问题,或者我是否正走在正确的道路上.我相信半浮点纹理具有有限的小数精度,但我不明白为什么这会导致我的问题,因为它应该只影响着色器的输出,而不是着色器中的数学运算.

着色器的代码如下所示:

    '   vec2 cellSize  = 1.0 / res;',
    '   vec4 pos = texture2D(vertexPositions, vuv.xy );',


    '   vec2 newUV;',
    '   if(type == 0.0){',
        '   float px = floor(vuv.x * res.x );',
        '   float spacingx = px- (2.0 * floor(px/2.0));',
        '   float py = floor(vuv.y * res.y );',
        '   float spacingy = py- (2.0 * floor(py/2.0));',
        '   float total = spacingx + spacingy;',
        '   total = total- (2.0 * floor(total/2.0));',

        '   if(total == 0.0){', …

我目前正在学习OpenGL和GLSL编写一个简单的软件来加载模型,在屏幕上显示它们,转换它们等等.

作为第一阶段,我在不使用OpenGL的情况下编写了一个纯C++程序.它工作得很好,它使用Row-major矩阵表示:

因此,例如mat [i] [j]表示第i行和第j列.

class mat4
{
    vec4 _m[4]; // vec4 is a struct with 4 fields
    ...
}

这是相关的矩阵乘法:

mat4 operator*(const mat4& m) const
{
    mat4 a(0.0);

    for (int i = 0; i < 4; ++i)
    {
        for (int j = 0; j < 4; ++j)
        {
            for (int k = 0; k < 4; ++k)
            {
                a[i][j] += _m[i][k] * m[k][j];
            }
        }
    }

    return a;
}

为了从模型空间到剪辑空间,我在C++中做如下:

vec4 vertexInClipSpace =  projectionMat4 * viewMat4 * modelMat4 * …

我试图在three.js中制作一个弯曲的3D箭头.为了完成这项任务,我创建了一个遵循弯曲路径的管和一个圆锥形的圆柱(通过将radiusTop设置为微小).他们目前看起来像这样:

我试图将箭头(圆柱形状为锥形)定位在管的末端,如下所示:( Photoshop)

我在数学上并不是非常强大,而且对于three.js来说还不是很新.有人可以帮我理解如何连接这两个？

这是我目前的代码:

        import T from 'three';

        var findY = function(r, x)
        {
           return Math.sqrt((r * r) - (x * x));
        }

        var radius = 25;
        var x = 0;
        var z = 0;
        var numberOfPoints = 10;
        var interval =  (radius/numberOfPoints);
        var points = [];

        for (var i = numberOfPoints; i >= 0; i--) 
        {
           var y = findY(radius, x);
           points.push(new T.Vector3(x, y, z))
           x = x + interval;
        }

        x = x …

我有2个刚体（a＆b）和1个固定关节约束（带有相对转换rela）。

我的目标是实现：

1 b.transform = a.transform * rela
号。2号。质心（a+ b）不变。
No.3。 （第3牛顿法则）整个系统的速度（a+ b）不变。
No.4。 （第3牛顿法则）整个系统的角速度（a+ b）不变。
否。5 .最小化两个物体的移动/旋转以解决问题。

我希望对两个物体施加冲击/扭矩，以使它们逐渐满足要求。
这部影片可以描绘出我想要的-（youtube链接）。

如何解决适用于每个身体的冲动/扭矩值？
我想要一个大概的主意/算法。
它可以是没有任何代码的描述文本。

例

这是一个示例问题及其正确的解决方案（即最终的静止状态）：

代码（草稿）

这是我当前的代码段，以防万一：

class Transform {
    Vec3 pos;
    Matrix33 basis;
};

每个刚体具有以下领域：

class RigidBody {
    float mass;
    Matrix33 inertiaTensor;
    Transform transform;
    Vec3 velocity;
    Vec3 angularVelocity;
};

该修复关节约束是： -

class FixConstraint {
    Transform …

首先，我根本不是数学专家。请容忍我的数学错误并在必要时纠正我，我很乐意学习。

我有一个立方体，它使用带有变换的 css 动画进行旋转：matrix3d(4x4)。我还可以手动旋转立方体，将用户操作转换为相同的矩阵3d 转换。

我想要的是当用户停止交互时带有 css 的旋转立方体，从用户离开的位置开始。这是我通过获取立方体的变换矩阵 3d 值并使用乘法动态设置 css 关键帧成功完成的事情。

然而，当用户开始与立方体交互时，立方体会跳转到其最后一个已知的手动旋转点并从那里继续，因为我无法弄清楚如何从 4x4 矩阵获取 X 和 Y 轴上的旋转。

我目前正在使用以下库Rematrix，它可以帮助我从手动旋转变为 css 旋转，如上所述。

我一直在研究有关欧拉的文章，以及如何从欧拉到矩阵，反之亦然，但正如我之前提到的，我认为这就是我缺乏数学知识阻碍我的地方。我似乎无法弄清楚。

作为参考，这里是我读过的一些文章，试图解决我的问题。

• https://medium.com/@behreajj/3d-rotations-in-processing-vectors-matrices-quaternions-10e2fed5f0a3
• http://www.gregslabaugh.net/publications/euler.pdf
• https://www.learnopencv.com/rotation-matrix-to-euler-angles/
• https://css-tricks.com/get-value-of-css-rotation-through-javascript/

最后一个来源对我来说最有意义，但如果我是正确的，那么在这种情况下没有用，因为它是关于 2D 变换，而不是 3D。

我通过以下方式获取当前的matrix3d：

const style = getComputedStyle(this.element).transform
const matrix = Rematrix.parse(style)

对于手动旋转，我使用基于用户鼠标位置（positionY、positionX）的矩阵乘法。

const r1 = Rematrix.rotateX(this.positionY)
const r2 = Rematrix.rotateY(this.positionX)

const transform = [r1, r2].reduce(Rematrix.multiply)

this.element.style[userPrefix.js + 'Transform'] = Rematrix.toString(transform)

从手动旋转到 css 旋转，我使用以下函数：

const setCssAnimationKeyframes = (lastTransform, animationData) => {
  const rotationIncrement = 90

  let matrixes = [] …