जीपीएस पॉइंट्स को संपीड़ित करना

Question

मेरे पास एक डिवाइस है जो जीपीएस डेटा रिकॉर्ड करता है। प्रत्येक 2-10 सेकंड में एक पठन लिया जाता है। 2 घंटे लगने वाली गतिविधि के लिए बहुत से जीपीएस अंक हैं।

क्या कोई अनावश्यक डेटा बिंदुओं को हटाकर डेटासेट को संपीड़ित करने के लिए एल्गोरिदम के बारे में जानता है। यानी यदि डेटा बिंदुओं की एक श्रृंखला सीधी रेखा में है तो केवल शुरुआत और अंत बिंदु आवश्यक है।

Answer 1

Douglas Peucker Algorithm देखें जो बहुभुज को सरल बनाने के लिए उपयोग किया जाता है। मैंने प्रदर्शन उद्देश्यों के लिए ग्राहकों को परेशान करते समय जीपीएस मार्ग बिंदुओं की मात्रा को कम करने के लिए सफलतापूर्वक इसका उपयोग किया है।

Answer 2

Compressing GPS Data on Mobile Devices पर एक शोध पत्र है।

इसके अतिरिक्त, आप इस कोडप्रोजेक्ट आलेख को Writing GPS Applications पर देख सकते हैं। मुझे लगता है कि आपके पास जो समस्या होगी वह सीधे बिंदुओं के लिए नहीं है, लेकिन घुमावदार सड़कों पर है। यह सब इस बात पर निर्भर करता है कि आप अपना रास्ता कितना सटीक होना चाहते हैं।

Answer 3

शायद आप अपने पथ x (टी), वाई (टी) को इसके बहुपद अनुमान के साथ अनुमानित करना चाहते हैं। क्या आप इस तरह कुछ ढूंढ रहे हैं: http://www.youtube.com/watch?v=YtcZXlKbDJY ???

Answer 4

आप बाद के बिंदुओं के बीच ढलान की गणना के आधार पर एक बहुत ही बुनियादी सरलीकरण करके अनावश्यक बिंदुओं को हटा सकते हैं।

यहाँ का एक सा है, लेकिन पूरा नहीं सी ++ कोड संभावित एल्गोरिदम पेश:

struct Point 
{ 
    double x; 
    double y; 
}; 

double calculate_slope(Point const& p1, Point const& p2) 
{ 
    //  dy  y2 - y1 
    // m = ---- = --------- 
    //  dx  x2 - x1 
    return ((p2.y - p1.y)/(p2.x - p1.x)); 
} 

// 1. Read first two points from GPS stream source 
Point p0 = ... ; 
Point p1 = ... ; 

// 2. Accept p0 as it's first point 

// 3. Calculate slope 
double m0 = calculate_slope(p0, p1); 

// 4. next point is now previous 
p0 = p1; 

// 5. Read another point 
p1 = ... ; 
double m1 = calculate_slope(p0, p1); 

// 6. Eliminate Compare slopes 
double const tolerance = 0.1; // choose your tolerance 
double const diff = m0 - m1; 
bool if (!((diff <= tolerance) && (diff >= -tolerance))) 
{ 
    // 7. Accept p0 and eliminate p1 

    m0 = m1; 
} 

// Repeat steps from 4 to 7 for the rest of points. 

मुझे आशा है कि यह मदद करता है।

Answer 5

ऊपर दिए गए कोड है कि यह अनुपयुक्त बना सकता है मुद्दों की एक जोड़ी है:

• "एक ही ढलान" सहनशीलता बल्कि कोण से ढाल में अंतर का आकलन करता है, तो NNW को NNE की तुलना में काफी बड़ा अंतर माना जाता है एनई से एसई (माना जाता है कि वाई अक्ष उत्तर-दक्षिण चलाता है)।

  यह संबोधित करने का एक तरीका यह मापने के लिए सहिष्णुता के लिए होगा कि दो खंडों का डॉट उत्पाद उनकी लंबाई के उत्पाद के साथ तुलना करता है। (यह याद रखने में मदद कर सकता है कि दो वैक्टरों का डॉट उत्पाद उनकी लंबाई और उनके बीच कोण के कोसाइन का उत्पाद है।) हालांकि, अगला बिंदु देखें।

• स्थिति त्रुटि के बजाए केवल ढलान त्रुटि को समझता है, इसलिए लंबे ईईई सेगमेंट के बाद एक लंबा एनईई सेगमेंट एनईई और ईएसई के बीच वैकल्पिक खंडों की एक स्ट्रिंग के रूप में एक सेगमेंट में संपीड़ित होने की संभावना है।

दृष्टिकोण है कि मैं के बारे में सोच रहा था क्या वेक्टर ग्राफिक्स अनुप्रयोगों को देखने के लिए होगा की कर्सर घटता के अनुक्रम में निर्देशांक एक सूची कन्वर्ट करने के लिए करते हैं। जैसे lib2geom के bezier-utils.cpp देखें। ध्यान दें कि (i) यह दिशा-आधारित की बजाय लगभग पूरी तरह से स्थिति-आधारित है; और (ii) यह पॉलीलाइन की बजाय आउटपुट के रूप में क्यूबिक बेज़ीर वक्र देता है, हालांकि यदि आप पसंद करते हैं तो पॉलीलाइन आउटपुट देने के लिए आप एक ही दृष्टिकोण का उपयोग कर सकते हैं (इस मामले में न्यूटन-रैफसन चरण अनिवार्य रूप से केवल एक साधारण डॉट उत्पाद बन जाता है)।