losing my mind, 5 hrs wasted over this algorithm for trying to achieve a O(log n) time over a dummy project. Hey atleast i figured it... ig?

Author: gokturkDev

designStuff/coordinateAlgorithm/coordinateAlgorithm.txt

@@ -0,0 +1,13 @@
+basically a binary tree but partitions its childs through their geographic planes
+well since we have latitude and longitude, we can use Rtree
+https://en.wikipedia.org/wiki/R-tree
+just what we want
+or we can also use https://en.wikipedia.org/wiki/K-d_tree and use x,y coordinates, which is the same thing whatever
+then perform range search
+
+i am not sure whether we need optimization since we dont need nearest neighbour search. Edit: Well we do dumbass
+
+
+search algo:
+
+go recursively deep as a normal insert precudere, check if dist lower than 1km or whatever, add to all nodes, then from parent look at the other branch and from current dim (x or y) calculate if curr dim is bigger than 1km  already, if not go check

lib/main.dart

@@ -1,8 +1,10 @@
 import 'package:flutter/material.dart';
+import 'package:harmony/services/kdtree_service.dart';
 
 import 'starting_page.dart';
 
 void main() {
+  KDTreeService.initTree();
   runApp(const MyApp());
 }
 

lib/services/firestore.dart

@@ -1,15 +1,41 @@
 import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:harmony/utilites/kdtree_implementation/kdtree.dart';
+import 'package:harmony/utilites/kdtree_implementation/kdtree.dart';
+import 'package:harmony/models/place.dart';
 
 class FireStoreService{
-  FirebaseFirestore _firestore = FirebaseFirestore.instance;
+  static FirebaseFirestore _firestore = FirebaseFirestore.instance;
 
-  CollectionReference users = FirebaseFirestore.instance.collection('users');
-  CollectionReference places = FirebaseFirestore.instance.collection('places');
-  CollectionReference reviews = FirebaseFirestore.instance.collection('reviews');
+  static CollectionReference users = FirebaseFirestore.instance.collection('users');
+  static CollectionReference places = FirebaseFirestore.instance.collection('places');
+  static CollectionReference reviews = FirebaseFirestore.instance.collection('reviews');
+  static CollectionReference place_kdtree = FirebaseFirestore.instance.collection("place-kdtree");
+
+  Future<KDTree> initKDTree() async{
+    return await place_kdtree.
+    doc("TREE").
+    get().
+    then(
+            (value) => KDTree.fromJson(value.data()! as Map<String, dynamic>)
+    );
+  }
 
   Stream<QuerySnapshot> getPlacesStream(){
     return places.snapshots();
   }
 
 
+
+
+
+  void addPlace(){
+    //IMPLEMENTATION AND SO WHAT
+    //Add to place kd tree for optimization
+    ///addToPlaceKDTree();
+  }
+
+  void addToPlaceKDTree(Place place){
+    //TODO
+  }
+
 }

lib/services/kdtree_service.dart

@@ -0,0 +1,124 @@
+import 'dart:ffi';
+import 'dart:math';
+
+import 'package:cloud_firestore/cloud_firestore.dart';
+import 'package:harmony/utilites/custom_exception.dart';
+import 'package:harmony/utilites/kdtree_implementation/kdtree.dart';
+import 'package:harmony/services/firestore.dart';
+import 'package:harmony/utilites/kdtree_implementation/node.dart';
+//https://www.cs.cmu.edu/~ckingsf/bioinfo-lectures/kdtrees.pdf
+class KDTreeService{
+
+  static KDTree? tree; //I am actually not sure how to not make this nullable, find a solution if you can
+
+
+  static void  initTree() async{
+    tree = await FireStoreService().initKDTree();
+
+    KDTreeService().insertPosition([1,1,3]);
+  }
+
+  void insertPosition(List<double> cartesianCoordinate){
+    ///Requires a Cartesian Coordinate, an x,y coordinate
+    ///May be time expensive, wait for it
+    if(cartesianCoordinate.length != 2){
+      throw new CustomException("Cartesian Coordinate list must include 2 vars, x,y");
+    }
+    try{
+      tree!.rootNode = _insert(cartesianCoordinate, tree!.rootNode);
+    } catch(e){
+        print(e.toString());
+    }
+  }
+
+  void deletePosition(List<double> cartesianCoordinate){
+    ///Requires a Cartesian Coordinate, an x,y coordinate
+    ///May be time expensive, wait for it
+    if(cartesianCoordinate.length != 2){
+      throw new CustomException("Cartesian Coordinate list must include 2 vars, x,y");
+    }
+    try{
+      tree!.rootNode = _delete(cartesianCoordinate, tree!.rootNode, 2);
+    } catch(e){
+      print(e.toString());
+    }
+  }
+
+
+
+
+  Node _insert(List<double> point, Node? node, {int cd : 0}){
+    int k = point.length;
+    if (node == null) {
+      node = Node(point: point);
+    }
+    else if(point == node.point){
+      return throw new CustomException("Duplicate Node!");
+    }
+    else if(point[cd] < node.point[cd]) {
+      node.leftChild = _insert(point, node.leftChild, cd : (cd+1) % k);
+    }
+    else {
+      node.rightChild = _insert(point, node.rightChild, cd : (cd+1) % k);
+    }
+    return node;
+  }
+
+  List<double> _findmin(Node? T, int dim, int cd){
+    if (T == null) return throw new CustomException("Empty tree!"); //empty tree
+
+    // T splits on the dimension we’re searching
+    // => only visit left subtree
+    if (cd == dim){
+      if (T.leftChild == null) return T.point; //Smallest in this subtree
+      else return _findmin(T.leftChild, dim, (cd+1) % dim);
+    }
+
+    // T splits on a different dimension
+    // => have to search both subtrees
+    else {
+      List<List<double>> list = [
+        _findmin(T.leftChild, dim, (cd+1) % dim),
+        _findmin(T.leftChild, dim, (cd+1) % dim),
+        T.point
+      ];
+      list.sort((a,b) => a[dim].compareTo(b[dim])); //find min of dimension
+      return list[0];
+    }
+  }
+
+  Node? _delete(List<double> x, Node? T,int dim, {int cd : 0}){
+    if (T == null) return throw new CustomException("Empty tree!");
+    int next_cd = (cd+1) % dim;
+
+    // This is the point to delete:
+    if(x == T.point){
+      // use min(cd) from right subtree:
+      if(T.rightChild != null){
+        //Basically switch
+        T.point = _findmin(T.rightChild, dim, next_cd);
+        T.rightChild = _delete(T.point, T.rightChild, dim, cd: next_cd);
+      }
+      else if(T.leftChild != null){ // swap subtrees and use min(cd) from new right:
+        T.point = _findmin(T.leftChild, dim, next_cd);
+        T.leftChild = _delete(T.point, T.leftChild, dim , cd: next_cd);
+      }
+      else{
+        T = null; // we’re a leaf: just remove
+      }
+    }
+    // this is not the point, so search for it:
+    else if(x[cd] < T.point[cd]){
+      T.leftChild = _delete(x, T.leftChild, dim , cd: next_cd);
+    }
+    else {
+      T.rightChild = _delete(x, T.rightChild, dim , cd: next_cd);
+    }
+    return T;
+  }
+
+  Node balanceTree(){
+
+  }
+
+}

lib/utilites/custom_exception.dart

@@ -0,0 +1,4 @@
+class CustomException implements Exception {
+  String cause;
+  CustomException(this.cause);
+}

lib/utilites/kdtree_implementation/kdtree.dart

@@ -0,0 +1,39 @@
+import 'package:harmony/utilites/kdtree_implementation/node.dart';
+
+class KDTree{
+  Node? rootNode;
+
+  KDTree({this.rootNode});
+
+
+
+
+  factory KDTree.fromJson(Map<String, dynamic> treeData){
+    if (treeData.isEmpty){
+      return KDTree();
+    }
+    return KDTree(
+      rootNode: createNode(treeData['root_node'])
+    );
+  }
+
+  static Node createNode(Map<String, dynamic> nodeData){
+    Node node = Node(
+        point: nodeData['coordinate'] as List<double>
+    );
+
+    if (nodeData['left_child'] != null){
+      Node leftChild = createNode(nodeData['left_child']);
+      node.leftChild = leftChild;
+    }
+    if(nodeData["right_child"] != null){
+      Node rightChild = createNode(nodeData["right_child"]);
+      node.rightChild = rightChild;
+    }
+
+    return node;
+  }
+
+
+
+}

lib/utilites/kdtree_implementation/node.dart

@@ -0,0 +1,10 @@
+class Node{
+
+  Node? leftChild;
+  Node? rightChild;
+
+  List<double> point;
+
+  Node({required this.point, this.leftChild, this.rightChild});
+
+}

lib/viewmodel/discover_page_viewmodel.dart

@@ -0,0 +1,8 @@
+import 'package:cloud_firestore/cloud_firestore.dart';
+
+class DiscoverPageViewModel{
+
+
+
+
+}

lib/views/discover/place_builder.dart

@@ -18,24 +18,10 @@ class _PlaceBuilderState extends State<PlaceBuilder> {
   }
   @override
   Widget build(BuildContext context) {
-    return StreamBuilder<QuerySnapshot>(
-      stream: FireStoreService().getPlacesStream(),
-      builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) { //
-        if (snapshot.hasError) {
-          return Text('Something went wrong');
-        }
 
-        if (snapshot.connectionState == ConnectionState.waiting) {
-          return CircularProgressIndicator();
-        }
+    return ListView.builder(
+      itemBuilder: (BuildContext context, int index){
 
-        return ListView.builder(
-          itemBuilder: (BuildContext context, int index) {
-            return Text("h");
-          },
-
-
-        );
       },
     );
   }