जावा में सबसे सरल त्रिभुज

आपका दिन शुभ हो!
मैं एक दिलचस्प समस्या और इसके समाधान के बारे में बात करना चाहता हूं, जिसे मैंने अपनी एक परियोजना में लागू किया है।
समस्या का सार यह है:
कई सिग्नल डिटेक्टर (उदाहरण के लिए, जीएसएम बेस स्टेशन) हैं। और ये डिटेक्टर एक निश्चित स्रोत के लिए एक सर्वर को सिग्नल स्तर भेजते हैं। मानचित्र पर स्रोत के निर्देशांक की गणना और प्रदर्शित करना आवश्यक है
यदि आप ऐसा करने के लिए इच्छुक हैं, तो बिल्ली में आपका स्वागत है।

भाग 1. सिद्धांत और ज्यामिति का एक सा

A (xa, ya), B (xb, yb), C (xc, yc) एक निश्चित आयताकार निर्देशांक प्रणाली में दिए गए निर्देशांक के साथ सिग्नल डिटेक्टर हैं। O (xo, yo) सिग्नल स्रोत है।
हम स्कूल भौतिकी की पाठ्यपुस्तक से याद करते हैं कि सिग्नल आयाम स्रोत के दूरी के वर्ग के व्युत्क्रमानुपाती होता है। इस प्रकार, स्रोत ए से डिटेक्टर ए तक की दूरी आरए के बराबर होगी

, जहां ka कुछ गुणांक है जो हम उपकरणों को कैलिब्रेट करते समय प्राप्त कर सकते हैं।
हम ज्यामिति के स्कूल पाठ्यक्रम से दूरी a1 की गणना करने के लिए सूत्र लेते हैं (यह यहां देने के लिए शर्म की बात है, लेकिन इसे पूर्णता के लिए रहने दें)।

माध्यम की विषमता उपेक्षित है। हां, यह कुछ त्रुटि देगा, लेकिन इस समस्या का समाधान समस्या के दायरे से बाहर है। हम मानते हैं कि संकेत के प्रसार (उदाहरण के लिए दीवारों की उपस्थिति और सामग्री) को प्रभावित करने वाले निरंतर कारक पहले से ही गुणांक का में शामिल हैं। अस्थायी कारक - हस्तक्षेप, संकेत फिर से प्रतिबिंब, आदि। - वे परिणाम को प्रभावित करेंगे, लेकिन व्यवहार में, यहां तक ​​कि घर के अंदर भी वे बहुत हस्तक्षेप नहीं करते हैं।
इस प्रकार, हमारे पास सभी स्रोतों से दूरी के लिए निर्भरता सूत्र हैं।
यदि हम समस्या को "हेड-ऑन" हल करते हैं - हमारे पास द्विघात समीकरणों की एक प्रणाली है, जिसका समाधान हमें निर्देशांक xo, yo के साथ एक बिंदु देगा। समस्या यह है कि मैं रैखिक बीजगणित में विश्वविद्यालय के पाठ्यक्रम को थोड़ा भूल गया। एक हफ्ते की सोच के बाद, मैं इस तरह से आया।
आइए प्रत्येक डिटेक्टर के चारों ओर एक चक्र बनाएं जिसका त्रिज्या संकेत स्तर के विपरीत आनुपातिक है। सभी सर्कल के चौराहे क्षेत्र में सिग्नल स्रोत होगा। सरलता के लिए, हम यह मान सकते हैं कि स्रोत इस क्षेत्र के केंद्र में है।
हम तीन डिटेक्टरों और एक स्रोत के साथ मामले के लिए एक ड्राइंग बना रहे हैं।

यहां बी और ए सिग्नल के स्रोत के सबसे करीब हैं, इसलिए सर्कल का व्यास छोटा है। C सबसे दूर, व्यास बड़ा। सिग्नल स्तर पर सर्कल के व्यास की निर्भरता प्रयोगात्मक रूप से निर्धारित की जाती है। यह ड्राइंग वास्तविक निर्देशांक (उदाहरण के लिए, मीटर) में बनाया गया है, अभ्यास में जाने के लिए, हम उन्हें सबसे सामान्य तरीके से पिक्सेल में अनुवाद करेंगे। आपको बस पिक्सेल और मीटर में नक्शे (चौड़ाई, ऊंचाई) के आयामों को जानना होगा। प्रक्षेपण की गैर-रैखिकता (यदि यह एक उपग्रह छवि है), पहले की तरह, उपेक्षित है। एक बड़े पैमाने पर योजना का उपयोग करना बेहतर है, मेरी परियोजना में यह एक मंजिल योजना थी।

भाग 2. चलिए अभ्यास करते हैं

तो, एक सरल समाधान पाया गया है, चलो इसे व्यवहार में लाने का प्रयास करें। मेरी परियोजना का सर्वर हिस्सा जावा में विकसित किया गया है, यह टीसीपी से अधिक डेटा से प्राप्त होता है, जो कि एसएसएल एन्क्रिप्शन के साथ json प्रारूप में है। कोड का यह हिस्सा स्वतंत्र है, एक अलग थ्रेड में निष्पादित किया गया है। प्राप्त घटनाओं को mysql डेटाबेस में संग्रहीत किया जाता है।
त्रिकोणासन अपने ही सूत्र में काम करता है, उन घटनाओं का चयन करता है जिन्हें अभी तक mysql डेटाबेस से संसाधित नहीं किया गया है (वर्तमान समय से 3 सेकंड पहले नहीं - सभी स्रोतों से एक ही संकेत के बारे में जानकारी प्राप्त करने के लिए)।
यद्यपि समाधान सरल था और किसी भी गणित की आवश्यकता नहीं होती है, लेकिन हलकों के चौराहे की गणना करना किसी न किसी तरह आवश्यक है। सौभाग्य से, जावा में एक AWT पुस्तकालय है जो हमारे लिए सब कुछ करता है। एक विंडो इंटरफ़ेस की कमी उसे परेशान नहीं करती है, और उसकी कुछ कक्षाएं बैकएंड में सर्वर पर ठीक काम करती हैं।
मैं प्रोजेक्ट से थोड़ा सरलीकृत कोड लाता हूं।

public static TriangulationPoint triangulate(AlertDbo sourceAlert, AlertDbo[] children, MapFileDbo map) { … double ppx = map.getWidth() / map.getRealWidth(); //pixels per feet horizontal double ppy = map.getHeight() / map.getRealHeight(); //pixels per feet vertical 

तो, ppx / ppy जैसा कि आप इसे समझते हैं - ये पिक्सेल में वास्तविक निर्देशांक के अनुवाद के लिए गुणांक हैं।
हम पहले डिटेक्टर के लिए सिग्नल स्तर लेते हैं, स्रोत से दूरी की गणना करते हैं, हम प्राप्त त्रिज्या के साथ ज्ञात निर्देशांक के अनुसार एक सर्कल बनाते हैं।

  double strength = sourceAlert.getSignalStrength(); double distance = calculateDistance(strength *sourceAlert.getDetector().getKoef()); MapCoordDbo coord = sourceAlert.getCoords(); … Area area = new Area(new Ellipse2D.Double(coord.getX(), coord.getY(), distance*2, distance*2)); 

अब हम शेष सभी स्रोतों से गुजरते हैं और वही करते हैं। हम परिणामस्वरूप सर्कल के साथ पहले सर्कल को काटते हैं, शेष डिटेक्टरों के लिए लूप में परिणाम का उपयोग करते हैं। एक अतिरिक्त चाल - हम कमरे की आयत के साथ पार करते हैं, अन्यथा ऐसा हो सकता है कि परिणाम इसके परे जाता है, जिसकी हमें आवश्यकता नहीं है।

  for(int j=0;j<children.length;j++) { … strength = children[j].getSignalStrength(); distance = calculateDistance(strength * children[j].getDetector().getKoef()); coord = children[j].getCoords(); area.intersect(new Area( new Ellipse2D.Double(coord.getX(), coord.getY(), distance*2, distance*2) )); area.intersect(new Area(new Rectangle(0, 0, map.getWidth(), map.getHeight()))); } 

ठीक है, अंत में, हम जांचते हैं कि हमारे पास कम से कम कुछ बचा है, इसके अलावा हम गणना की त्रुटि की गणना करते हैं (आयत का आधा विकर्ण जिसमें परिणामी क्षेत्र उत्कीर्ण है)।

  if(area.getBounds().getWidth()>0 && area.getBounds().getHeight()>0) { TriangulationPoint tp = new TriangulationPoint(); tp.x = area.getBounds().getCenterX(); tp.y = area.getBounds().getCenterY(); double dx = area.getBounds().getWidth() / 2; double dy = area.getBounds().getHeight() / 2; tp.err = Math.sqrt(dx*dx + dy*dy) /2; return tp; } return null; } 

यह एक दूरी की गणना का कार्य है।

 public static double calculateDistance(double db) { double[] dbs = {…}; double[] fts = {…}; double koef = -…; double prevDb = 70; double prevDist = 0; for(int i=0;i<dbs.length;i++) { if(dbs[i]<db) { break; } koef = (dbs[i] - prevDb) / (fts[i] - prevDist); prevDb = dbs[i]; prevDist = fts[i]; } return prevDist + koef * (db - prevDb); } 

पहले, यह एक लघुगणक कार्य था, लेकिन, दुर्भाग्य से, वास्तविक संकेत का क्षीणन अलग है, मुझे प्रयोगशाला में कई बिंदुओं पर संकेत स्तर को देखना था और संकेत स्तर और नीचे की दूरी को दो सरणियों में लिखना था।
बस मामले में, मैंने वास्तविक संख्याओं को हटा दिया, ताकि एनडीए का उल्लंघन न हो।
वैसे, C # में ठीक वैसा ही समाधान संभव है। एरिया के बजाय, आपको ग्राफिक्सपैथ का उपयोग करने की आवश्यकता है, एक इंटरसेक्ट विधि है। एकमात्र कठिनाई परिणामी चौराहे का केंद्र ढूंढ रही है। यहाँ C # में एक क्षेत्र के केंद्र को खोजने के लिए कोड है:

  private PointF RegionCentroid(Region region, Matrix transform) { float mx = 0; float my = 0; float total_weight = 0; foreach (RectangleF rect in region.GetRegionScans(transform)) { float rect_weight = rect.Width * rect.Height; mx += rect_weight * (rect.Left + rect.Width / 2f); my += rect_weight * (rect.Top + rect.Height / 2f); total_weight += rect_weight; } return new PointF(mx / total_weight, my / total_weight); } 

इसलिए, कुछ मान्यताओं के साथ, गणित और भौतिकी में पर्याप्त ज्ञान रखने के बिना, बल्कि जटिल समस्या को हल करना संभव है।
आपका ध्यान के लिए धन्यवाद!