केवल 2 डी में "वैध" अंक SciPy/Numpy

Question

का उपयोग कर बादल बिंदु के प्रक्षेप जाओ मैं एक बादल बिंदु एक व्यक्ति के पीछे से photogrammetry से प्राप्त की है। मैं नियमित ग्रिड प्राप्त करने के लिए इसे अलग करने की कोशिश कर रहा हूं, और इसके लिए मैं अब तक अच्छे परिणाम के साथ scipy.interpolate का उपयोग कर रहा हूं। समस्या है: समारोह मैं (scipy.interpolate.griddata) का उपयोग कर रहा में विमान एक्स, वाई cloudpoint के उत्तल पतवार का उपयोग करता है, इस प्रकार कुछ मूल्यों है कि मूल सतह है, जो एक अवतल परिधि है में मौजूद नहीं है परिणाम के रूप में दे रही है।

निम्न उदाहरण से पता चलता बाईं ओर स्थित मूल cloudpoint, परिणाम (जो क्षैतिज लाइनों के रूप में प्रदर्शित किया जाता है वास्तव में अंक के एक घने लाइन के आकार का बादल है) कि griddata मुझे बीच में देता है, और परिणाम मैं चाहते हैं एक्स, वाई विमान पर क्लाउडपॉइंट की "छाया" के दाएं - सही तरीके से प्राप्त करें, जहां मूल सतह में मौजूद गैर-मौजूदा बिंदु शून्य या नैन होंगे।

मैं मैं निकाल सकते जेड cloudpoint पर समन्वय और निकटता के लिए प्रत्येक ग्रिड स्थिति की जांच पता है, लेकिन यह इतना जानवर बल है, और मेरा मानना ​​है कि इस बिंदु-क्लाउड एप्लिकेशन पर एक आम समस्या नहीं होनी चाहिए । एक और संभावना बिंदु बादल से अधिक प्रदर्शन करने के लिए, एक numpy मुखौटा या बूलियन 2 डी सरणी के लिए griddata से परिणाम पर "लागू" खोजने कुछ numpy आपरेशन हो सकता है, लेकिन मैं किसी भी नहीं मिला (इन आपरेशनों से परे एक सा कर रहे हैं मेरे बेवकूफ/Scipy ज्ञान)।

कोई सुझाव?

पढ़ने के लिए धन्यवाद!

Answer 1

उपयुक्त मास्क तेजी KDTree का प्रयोग कर बनाया जा सकता है। Griddata द्वारा उपयोग किए गए इंटरपोलेशन एल्गोरिदम में "वैध" बिंदुओं की धारणा नहीं है, इसलिए आपको इंटरपोलेशन से पहले या बाद में अपने डेटा को समायोजित करने की आवश्यकता है।

से पहले:

import numpy as np 
from scipy.spatial import cKDTree as KDTree 
from scipy.interpolate import griddata 
import matplotlib.pyplot as plt 

# Some input data 
t = 1.2*np.pi*np.random.rand(3000) 
r = 1 + np.random.rand(t.size) 
x = r*np.cos(t) 
y = r*np.sin(t) 
z = x**2 - y**2 

# -- Way 1: seed input with nan 

def excluding_mesh(x, y, nx=30, ny=30): 
    """ 
    Construct a grid of points, that are some distance away from points (x, 
    """ 

    dx = x.ptp()/nx 
    dy = y.ptp()/ny 

    xp, yp = np.mgrid[x.min()-2*dx:x.max()+2*dx:(nx+2)*1j, 
         y.min()-2*dy:y.max()+2*dy:(ny+2)*1j] 
    xp = xp.ravel() 
    yp = yp.ravel() 

    # Use KDTree to answer the question: "which point of set (x,y) is the 
    # nearest neighbors of those in (xp, yp)" 
    tree = KDTree(np.c_[x, y]) 
    dist, j = tree.query(np.c_[xp, yp], k=1) 

    # Select points sufficiently far away 
    m = (dist > np.hypot(dx, dy)) 
    return xp[m], yp[m] 

# Prepare fake data points 
xp, yp = excluding_mesh(x, y, nx=35, ny=35) 
zp = np.nan + np.zeros_like(xp) 

# Grid the data plus fake data points 
xi, yi = np.ogrid[-3:3:350j, -3:3:350j] 
zi = griddata((np.r_[x,xp], np.r_[y,yp]), np.r_[z, zp], (xi, yi), 
       method='linear') 
plt.imshow(zi) 
plt.show() 

विचार "बीज" nan मूल्यों से युक्त नकली बिंदुओं के साथ इनपुट डेटा के लिए है। रैखिक इंटरपोलेशन का उपयोग करते समय, वे उस छवि के उन क्षेत्रों को मिटा देंगे जिनके पास पास कोई वास्तविक डेटा बिंदु नहीं है।

तुम भी प्रक्षेप के बाद अमान्य डेटा कभी याद नहीं कर सकते हैं:

# -- Way 2: blot out afterward 

xi, yi = np.mgrid[-3:3:350j, -3:3:350j] 
zi = griddata((x, y), z, (xi, yi)) 

tree = KDTree(np.c_[x, y]) 
dist, _ = tree.query(np.c_[xi.ravel(), yi.ravel()], k=1) 
dist = dist.reshape(xi.shape) 
zi[dist > 0.1] = np.nan 

plt.imshow(zi) 
plt.show()