小编Fno*_*ord的帖子

我需要在python中计算3D bspline曲线.我查看了scipy.interpolate.splprep和其他一些scipy模块,但找不到任何能让我满意的东西.所以我在下面写了自己的模块.代码工作正常,但速度很慢(测试函数运行在0.03秒,考虑到我只需要100个带有6个控制顶点的样本,这似乎很多).

有没有办法通过一些scipy模块调用来简化下面的代码,这可能会加快它的速度？如果没有,我可以对我的代码做些什么来改善其性能？

import numpy as np

# cv = np.array of 3d control vertices
# n = number of samples (default: 100)
# d = curve degree (default: cubic)
# closed = is the curve closed (periodic) or open? (default: open)
def bspline(cv, n=100, d=3, closed=False):

    # Create a range of u values
    count = len(cv)
    knots = None
    u = None
    if not closed:
        u = np.arange(0,n,dtype='float')/(n-1) * (count-d)
        knots = np.array([0]*d + range(count-d+1) + [count-d]*d,dtype='int')
    else:
        u …

在这个问题中，我向社区询问如何计算样条线基础。我的目标是通过预先计算 ascipy.interpolate.splev来更快地计算样条线，并通过点积生成曲线。splevbspline basisbasiscontrol point

从那时起，一个新的scipy.interpolate.BSpline插值器被添加到scipy. 它带有一个basis_elementfunction，我认为该函数可用于返回用于计算样条线的基础。

例如，使用此处的代码和以下输入：

import numpy as np

# Control points
cv = np.array([[ 50.,  25., 0.],
       [ 59.,  12., 0.],
       [ 50.,  10., 0.],
       [ 57.,   2., 0.],
       [ 40.,   4., 0.],
       [ 40.,   14., 0.]])

kv = [0, 0, 0, 0, 1, 2, 3, 3, 3, 3] # knot vector
n = 10  # 10 samples …

我需要在 python 中评估 b 样条线。为此，我编写了下面的代码，效果非常好。

import numpy as np
import scipy.interpolate as si

def scipy_bspline(cv,n,degree):
    """ bspline basis function
        c        = list of control points.
        n        = number of points on the curve.
        degree   = curve degree
    """
    # Create a range of u values
    c = cv.shape[0]
    kv = np.clip(np.arange(c+degree+1)-degree,0,c-degree)
    u  = np.linspace(0,c-degree,n)
    
    # Calculate result
    return np.array(si.splev(u, (kv,cv.T,degree))).T

给它 6 个控制点并要求它评估曲线上的 100k 个点是一件轻而易举的事：

# Control points
cv = np.array([[ 50.,  25., 0.],
       [ 59.,  12., 0.],
       [ 50., …

简介:是否可以将iPython设置为普通用户(cd,ls,mkdir,rm等)的基本dos/bash命令行终端,然后公开一些额外的专有命令？

深度:我在一家视频游戏公司工作,用户从未在生产管道中体验过"好"的CLI.所以作为回应,我已经工作了一段时间在python中使用cmd.py编写CLI,重新创建常用的dos命令,然后使用我自己的自定义命令扩充它们以执行各种操作,例如:快速跳过预定义的生产文件夹,简化的perforce管理命令,使用递归的ant-glob模式查找/导入文件到我们的创作工具......等等......

在这个过程中,我偶然发现了ipython.我对它不是很熟悉,但我已经感觉到它应该是我应该使用的,因为它可以免费提供我想要的许多东西.它完美地处理了ansi的颜色.所有shell命令都可以通过"!"获得,可以免费使用"|,>,<"和所有内置的shell函数,其好处还在继续......

需要注意的是,我的目标受众很容易受到CLI的威胁......所以当他们输入"more textfile.txt"作为输入时,他们会期望打印文件内容的默认dos行为,而不是:

In [42]: more textfile.txt
  File "<ipython-input-42-e442b4ca857b>", line 1
    more file.txt
            ^
SyntaxError: invalid syntax

当然,"!more textfile.txt"会做他们期望的,但我不希望他们必须输入"!" 对于他们将使用的基本上95%的命令.

所以我正在寻找一种方式以一种完全简化的方式启动ipython,在我的理想(幻想或许)世界中:

• 所有shell命令(cd,ls/dir,mkdir,more,rm/del等等)都可以在最前面访问,而不需要任何"!"
• 所有python命令(import,def,class,for,print,while等等)都是不可访问的,除了从预定义的几个专有命令进行各种管道操作,可能会保留基本的算术命令？

作为奖励:一种在默认ipython和非常克制和简化的命令shell替换版本之间交替的方法,我梦想着... ex:输入"normal"将恢复所有ipython的默认行为......并输入"cli" "会回到简化版.

最后的注意事项:我正在寻找的可能是一个傻瓜的差事,我应该坚持使用我自己的笨拙的CLI脚本在命令shell中启动python.exe,并称它为一天......但我想如果我是像iPython这样做是远程可能的,Stackoverflow是我快速得到答案的地方:)

给定一个旋转角度列表（让我们说一下 X 轴）：

import numpy as np
x_axis_rotations = np.radians([0,10,32,44,165])

我可以通过这样做创建匹配这些角度的矩阵数组：

matrices = []
for angle in x_axis_rotations:
    matrices.append(np.asarray([[1 , 0 , 0],[0, np.cos(angle), -np.sin(angle)], [0, np.sin(angle), np.cos(angle)]]))
matrices = np.array(matrices)

这会起作用，但它没有利用 numpy 处理大型数组的优势......所以如果我的角度数组是数百万，那么这样做不会很快。

有没有更好（更快）的方法来从输入数组创建变换矩阵数组？

我想在 python 中创建一个简单的物理系统，它的工作quaternions方式与velocity/position. 它的主要目标是模拟一个被拖动的对象，并随着时间的推移尝试赶上另一个对象。模拟使用 3 个变量：：k弹簧常数，d：阻尼因子，和m：拖动对象的质量。

使用经典的欧拉积分，我可以用以下方法解决位置：

import numpy as np
from numpy.core.umath_tests import inner1d

# init simulation values
dt = 1./30. # delta t @ 30fps
k = 0.5 # Spring constant
d = 0.1 # Damping
m = 0.1 # Mass

p_ = np.array([0,0,0]) # initial position of the dragged object
p  = np.array([1,2,0]) # position to catch up to, in real life this value could change over …

我需要编写一个python脚本,它将找到最接近由4个顶点定义的平面的点(使用右手规则顺序给出).作为奖励,获得最近点的UV坐标会很棒.

Arrows along the edges show UV direction

p0 = [1.15, 0.62, -1.01]
p1 = [1.74, 0.86, -0.88]
p2 = [1.79, 0.40, -1.46]
p3 = [0.91, 0.79, -1.84]
p =  [1.17, 0.94, -1.52]
RESULT SHOULD BE APPROX:
Closest Point: 1.116 0.705 -1.527
Closest U Value: 0.164
Closest V Value: 0.682

这是我为解决问题而编写的代码.请让我知道如何改进/加快速度.

import numpy as np

# Define constants
LARGE_VALUE=99999999.0
SMALL_VALUE=0.00000001
SUBSAMPLES=10.0

def closestPointOnLineSegment(a,b,c):
    ''' Given two points (a,b) defining a line segment and a query point (c)
        return the closest …

我写了一个python脚本,它从查询点(p)中找到表面上最近点的UV坐标.表面由四个线性边缘限定,这四个线性边缘由逆时针列出的四个已知点(p0,p1,p2,p3)组成.

(请忽略小红球)

我的方法的问题是它非常慢(使用低精度阈值进行5000次查询约10秒).

我正在寻找一种更好的方法来实现我想要的,或者建议使我的代码更有效率.我唯一的限制是它必须用python编写.

import numpy as np

# Define constants
LARGE_VALUE=99999999.0
SMALL_VALUE=0.00000001
SUBSAMPLES=10.0

def closestPointOnLineSegment(a,b,c):
    ''' Given two points (a,b) defining a line segment and a query point (c)
        return the closest point on that segment, the distance between
        query and closest points, and a u value derived from the results
    '''

    # Check if c is same as a or b
    ac=c-a
    AC=np.linalg.norm(ac)
    if AC==0.:
        return c,0.,0.

    bc=c-b
    BC=np.linalg.norm(bc)
    if BC==0.:
        return c,0.,1.


    # See if segment length …

我有一个numpy的数据数组，我只需要保留n最高值，而将其他所有内容都清零。

我当前的解决方案：

import numpy as np
np.random.seed(30)

# keep only the n highest values
n = 3

# Simple 2x5 data field for this example, real life application will be exteremely large
data = np.random.random((2,5))
#[[ 0.64414354  0.38074849  0.66304791  0.16365073  0.96260781]
# [ 0.34666184  0.99175099  0.2350579   0.58569427  0.4066901 ]]


# find indices of the n highest values per row
idx = np.argsort(data)[:,-n:]
#[[0 2 4]
# [4 3 1]]


# put those values back in a blank array …

Numba 文档指定其他编译函数可以内联并从其他编译函数调用。提前编译时似乎并非如此。

例如：这里有两个函数计算两个向量数组之间的内部点积，其中一个执行实际的乘积，另一个在循环内进行内联调用：

# Module test.py
import numpy as np
from numba import njit, float64

@njit(float64(float64[:], float64[:]))
def product(a, b):
    prod = 0
    for i in range(a.size):
        prod += a[i] * b[i]
    return prod

@njit(float64[:](float64[:,:], float64[:,:]))
def n_inner1d(a, b):
    prod = np.empty(a.shape[0])    
    for i in range(a.shape[0]):
        prod[i] = product(a[i], b[i])

    return prod

照原样，我可以完美地使用import test和使用。test.n_inner1d现在让我们做一些修改，以便可以将其编译为 .pyd

# Module test.py
import numpy as np
from numba import float64
from numba.pycc import CC

cc = CC('test')
cc.verbose …