5

2D numpy 配列と、いくつかの座標 (i、j) を持つ中心があります (座標は行と列を意味します)。0から画像の端までの可能な距離ごとに、中心から同じ距離（単純なユークリッド距離）にあるすべての配列要素を合計する必要があります。つまり、結果は0番目の要素が距離のピクセルの合計を与える1D配列です中心から 0 (つまり、ちょうど中心)、最初の要素は距離 1 ピクセルにあるすべてのピクセルの合計などです。

私の感覚では、これは for ループなしで実行できるはずですが、残念ながら、これを理解するのに十分なマトリックス python トリックを知りません。

どうもありがとうございました！

4

5 に答える 5

3

これがあなたの望むものかどうかはわかりませんが、役立つかもしれません：

import numpy as np
#create data arrays to work with.
x = np.arange(10)
y = np.arange(10)
v = np.arange(100).reshape(10,10) 
#indices of the "center" of the grid
i,j = 5,5 

#Now calculated the distance of each point to the center point on the grid
#Note that `None` is the same as `np.newaxis`
r = np.sqrt((x[:,None] - x[i])**2 + (y[None,:]-y[j])**2)

#Now sum all the points that are closer than 10 units away.
np.sum(v[r<=10])
于 2012-09-18T15:56:03.423 に答える
2

戦略を提案しますが、動作するコードを提案する時間はありません。次の手順を実行します: (正確な距離を選択することはできませんが、正確な特定の距離にあるポイントはほとんどないため、連続した連続的な RANGES の距離を選択することに注意してください)。

  1. 配列から KDTree を作成します。
  2. 直線的に増加する円について、所定の円の内側にあるすべての点の合計をとります。
  3. 外側の円から内側の円を引いて、各円の間の「シェル」の値を計算します。

次のようになります (もちろん、いくつかの空白を埋める必要があります)。

import numpy
from scipy.spatial import KDTree

tree = scipy.spatial.KDTree(reshaped_array)
sums = [numpy.sum(tree.query_ball_point(dist)) for dist in xrange(desired_distances)]
desired_result = numpy.diff(sums)

お役に立てれば！

于 2012-09-18T19:25:46.547 に答える
2

あなたが使用することができますnp.bincount...

a = np.random.random((20, 22))

def distance(array, xpos, ypos):
    # probably a gazillion methods to create the actual distances...
    # if you array is large and you are only interested to a certain size
    # you sould probably slice out a smaller one first of course.
    dists = np.sqrt(np.arange(-xpos, array.shape [0]-xpos, dtype=float)[:,None]**2
          + np.arange(-ypos, array.shape [1]-ypos, dtype=float)[None,:]**2)
    return dists

# Prepare which bins to use:
dists = distance(a, 10, 11).astype(int)

# Do a bincount with weights.
result = np.bincount(dists.flat, weights=a.flat)
# and add them up:
result = np.add.accumulate(result)

Andは、距離が小さいか等しいすべての値の合計を与えるresult配列です。result[distance]

于 2012-09-18T19:02:06.363 に答える
1

いくつかのサンプル ポイントを作成します。

>>> import numpy as np
>>> vals = np.array([[1,2],[3,4.5],[5,6]])
>>> vals
array([[ 1. ,  2. ],
       [ 3. ,  4.5],
       [ 5. ,  6. ]])

中心点を計算する:

>>> center = np.mean(vals, axis=0)
>>> center
array([ 3.        ,  4.16666667])

中心点からの距離を計算する:

>>> d = vals - center
>>> dist_from_center = np.sqrt(d[:,0]*d[:,0] + d[:,1]*d[:,1])
>>> dist_from_center
array([ 2.94863434,  0.33333333,  2.71313677])
于 2012-09-18T16:03:56.467 に答える
1

これは、超大規模な配列にはうまくスケールアップできず、それほど堅牢ではありませんが、とにかくかわいらしいものです。

テスト配列を作成します。

In [148]: import numpy as np

In [149]: m = np.random.random((8, 9))

In [150]: m
Out[150]: 
array([[ 0.36254361,  0.92449435,  0.36954906,  0.13007562,  0.95031795,
         0.1341706 ,  0.6417435 ,  0.25467616,  0.72431605],
       [ 0.75959927,  0.53992222,  0.76544104,  0.94409118,  0.27048638,
         0.44747388,  0.42691671,  0.75695594,  0.10366086],
       [ 0.12424304,  0.06642197,  0.08953764,  0.66546555,  0.30932551,
         0.50375697,  0.1344662 ,  0.31008366,  0.13953257],
       [ 0.28643294,  0.12986936,  0.39022482,  0.72869735,  0.84537494,
         0.62683481,  0.88539889,  0.35697751,  0.96332492],
       [ 0.67678959,  0.60373389,  0.15151052,  0.53586538,  0.50470088,
         0.39664842,  0.93584004,  0.97386657,  0.50405521],
       [ 0.04613492,  0.53676995,  0.60119919,  0.5559467 ,  0.09392262,
         0.69938864,  0.35719754,  0.79775878,  0.16634076],
       [ 0.00879703,  0.60874483,  0.25390384,  0.48368248,  0.52770161,
         0.64563258,  0.27353424,  0.86046696,  0.04489414],
       [ 0.80883157,  0.44484305,  0.52325907,  0.49172028,  0.46731106,
         0.06400542,  0.75671515,  0.55930335,  0.70721442]])

インデックスを取得します。

In [151]: centre = (3,5)

In [152]: ii = np.indices(m.shape)

In [153]: ii
Out[153]: 
array([[[0, 0, 0, 0, 0, 0, 0, 0, 0],
        [1, 1, 1, 1, 1, 1, 1, 1, 1],
        [2, 2, 2, 2, 2, 2, 2, 2, 2],
        [3, 3, 3, 3, 3, 3, 3, 3, 3],
        [4, 4, 4, 4, 4, 4, 4, 4, 4],
        [5, 5, 5, 5, 5, 5, 5, 5, 5],
        [6, 6, 6, 6, 6, 6, 6, 6, 6],
        [7, 7, 7, 7, 7, 7, 7, 7, 7]],

       [[0, 1, 2, 3, 4, 5, 6, 7, 8],
        [0, 1, 2, 3, 4, 5, 6, 7, 8],
        [0, 1, 2, 3, 4, 5, 6, 7, 8],
        [0, 1, 2, 3, 4, 5, 6, 7, 8],
        [0, 1, 2, 3, 4, 5, 6, 7, 8],
        [0, 1, 2, 3, 4, 5, 6, 7, 8],
        [0, 1, 2, 3, 4, 5, 6, 7, 8],
        [0, 1, 2, 3, 4, 5, 6, 7, 8]]])

In [154]: di = ii[0]-centre[0], ii[1]-centre[1]

二乗距離を取得します。

In [155]: dr2 = (di[0]**2+di[1]**2)

In [156]: dr2
Out[156]: 
array([[34, 25, 18, 13, 10,  9, 10, 13, 18],
       [29, 20, 13,  8,  5,  4,  5,  8, 13],
       [26, 17, 10,  5,  2,  1,  2,  5, 10],
       [25, 16,  9,  4,  1,  0,  1,  4,  9],
       [26, 17, 10,  5,  2,  1,  2,  5, 10],
       [29, 20, 13,  8,  5,  4,  5,  8, 13],
       [34, 25, 18, 13, 10,  9, 10, 13, 18],
       [41, 32, 25, 20, 17, 16, 17, 20, 25]])

bincount合計を取得するために使用します。

In [158]: np.bincount(dr2.flat, m.flat)
Out[158]: 
array([ 0.62683481,  2.63117922,  1.88433263,  0.        ,  2.23253738,
        3.63380441,  0.        ,  0.        ,  3.05475259,  2.13335292,
        3.27793323,  0.        ,  0.        ,  3.36554308,  0.        ,
        0.        ,  0.19387479,  1.89418207,  1.3926631 ,  0.        ,
        2.12771579,  0.        ,  0.        ,  0.        ,  0.        ,
        3.05014562,  0.80103263,  0.        ,  0.        ,  0.8057342 ,
        0.        ,  0.        ,  0.44484305,  0.        ,  0.37134064,
        0.        ,  0.        ,  0.        ,  0.        ,  0.        ,
        0.        ,  0.80883157])
于 2012-09-18T17:05:24.860 に答える