Cython RandomBoxGeneration

cythonModules/randoms.pyx

+import numpy as np
+cimport numpy as np
+cimport numpy.random
+cimport cython
+
+DTYPE = np.float
+ctypedef np.int32_t INT32_t
+
+
+cdef get_random_topleft(double maxDist, double maxAngle, double radius, double boxSize):
+    cdef double angle, dist, x, y
+    cdef np.ndarray[INT32_t, ndim=1] newTopLeft
+
+    dist = np.random.rand() * maxDist
+    angle = np.random.rand() * maxAngle
+    newTopLeft = np.empty(2, dtype=np.int32)
+    x = dist*np.cos(angle) + radius - boxSize/2
+    y = dist*np.sin(angle) + radius - boxSize/2
+    newTopLeft[0] = np.int32(np.round(x))
+    newTopLeft[1] = np.int32(np.round(y))
+
+    return newTopLeft
+
+
+def get_random_topLefts(int numBoxes, double boxSize, double radius, double maxAngle, int seed=1337, int maxTries=50):
+    cdef np.ndarray[INT32_t, ndim=2] topLefts
+    cdef np.ndarray[INT32_t, ndim=1] newTopLeft
+    cdef double maxDist
+    cdef int outerCounter, counter, x, y, i, j, diffX, diffY, successfullyAdded
+    cdef bint validSolutionFound, boxOverlaps
+
+    np.random.seed(seed)
+    maxDist = radius - np.sqrt((boxSize/2)**2 + (boxSize/2)**2)
+    outerCounter = 0
+    validSolutionFound = False
+
+    while not validSolutionFound and outerCounter < maxTries:
+        successfullyAdded = 0
+        topLefts = np.empty((numBoxes, 2), dtype=np.int32)
+        for i in range(numBoxes):
+            if i == 0:
+                topLefts[0, :] = get_random_topleft(maxDist, maxAngle, radius, boxSize)
+                successfullyAdded += 1
+            else:
+                counter = 0
+                while counter < 50:
+                    newTopLeft = get_random_topleft(maxDist, maxAngle, radius, boxSize)
+                    boxOverlaps = False
+                    for j in range(i):
+                        diffX = abs(np.float(newTopLeft[0] - np.float(topLefts[j, 0])))
+                        diffY = abs(np.float(newTopLeft[1] - np.float(topLefts[j, 1])))
+
+                        if diffX < boxSize and diffY < boxSize:
+                            boxOverlaps = True
+                            break
+
+                    if boxOverlaps:
+                        counter += 1
+                    else:
+                        topLefts[i, :] = newTopLeft
+                        successfullyAdded += 1
+                        break
+
+        if successfullyAdded == numBoxes:
+            validSolutionFound = True
+        else:
+            outerCounter += 1
+
+    return validSolutionFound, topLefts
\ No newline at end of file

cythonModules/setup_cython.py

@@ -9,10 +9,18 @@ if len(sys.argv) == 1:
     sys.argv.append("build_ext")
     sys.argv.append("--inplace")
 
-ext = Extension("rotateContour", ["rotateContour.pyx"], extra_compile_args=['-O3'],)
+# ext = Extension("rotateContour", ["rotateContour.pyx"], extra_compile_args=['-O3'],)
+
+# setup(
+#     name="rotate contour around reference point",
+#     ext_modules=cythonize([ext], annotate=True),  # accepts a glob pattern
+#     include_dirs=[np.get_include()]
+# )
+
+# ext = Extension("getRandomTopLefts", ["getRandomTopLefts.pyx"], extra_compile_args=['-O3'],)
 
 setup(
-    name="rotate contour around reference point",
-    ext_modules=cythonize([ext], annotate=True),  # accepts a glob pattern
+    name="get a given number of random topLefts",
+    ext_modules=cythonize("randoms.pyx", annotate=True),  # accepts a glob pattern
     include_dirs=[np.get_include()]
-)
\ No newline at end of file
+)

evaluation.py

@@ -32,7 +32,7 @@ def get_methods_to_test(dataset: dataset.DataSet, fractions: list = []) -> list:
     :return: list of measurement Objects that are applicable
     """
     if len(fractions) == 0:
-        fractions: list = [0.05, 0.1]
+        fractions: list = [0.02, 0.05, 0.1, 0.2, 0.3, 0.5, 0.7, 0.9]
     methods: list = []
     particleContainer = dataset.particleContainer
 
@@ -247,7 +247,7 @@ class SampleResult(object):
     """
     An object the stores all generated results per sample and can update and report on them.
     """
-    def __init__(self, filepath: str, numVariations: int = 1):
+    def __init__(self, filepath: str, numVariations: int = 10):
         super(SampleResult, self).__init__()
         self.filepath: str = filepath
         self.dataset: dataset.DataSet = None

geometricMethods.py

@@ -6,6 +6,7 @@ import sys
 sys.path.append("C://Users//xbrjos//Desktop//Python")
 from gepard import dataset
 import helpers
+from cythonModules import randoms
 
 
 def box_overlaps_other_box(topLeft1: list, topLeft2: list, boxSize: float) -> bool:
@@ -190,6 +191,7 @@ class BoxSelectionCreator(object):
         diameter, offset = self._get_diameter_and_offset()
         randomBoxSampler: RandomQuarterBoxes = RandomQuarterBoxes(None, desiredFraction)
         randomBoxSampler.update_max_fractions()
+
         for numBoxes in randomBoxSampler.possibleBoxNumbers:
             randomBoxSampler.numBoxes = numBoxes
             if randomBoxSampler.config_is_valid():
@@ -392,18 +394,29 @@ class RandomBoxSampling(BoxSelectionSubsamplingMethod):
         return equals
 
     def get_topLeft_of_boxes(self) -> list:
+        #
+        # valid, topLefts = randoms.get_random_topLefts(self.numBoxes, self.boxSize,
+        #                                               self.filterDiameter/2, self.__maxAngle,
+        #                                               seed=self.randomSeed, maxTries=self.maxTries)
+        #
+        # if not valid:
+        #     raise AttributeError
+        #
+        # topLefts: list = [[topLefts[i, 0], topLefts[i, 1]] for i in range(topLefts.shape[0])]
+
+        #
         def get_random_topleft() -> list:
             angle = np.random.rand() * self.__maxAngle
             dist = np.random.rand() * maxDist
-            x: float = dist * np.cos(angle) + radius - boxSize/2
-            y: float = dist * np.sin(angle) + radius - boxSize/2
+            x: float = dist * np.cos(angle) + radius - boxSize / 2
+            y: float = dist * np.sin(angle) + radius - boxSize / 2
             return [x, y]
 
         np.random.seed(self.randomSeed)
         topLefts: list = []
         boxSize: float = self.boxSize
-        radius: float = self.filterDiameter/2
-        maxDist: float = radius - np.sqrt((boxSize/2)**2 + (boxSize/2)**2)
+        radius: float = self.filterDiameter / 2
+        maxDist: float = radius - np.sqrt((boxSize / 2) ** 2 + (boxSize / 2) ** 2)
         outerCounter: int = 0
         validSolutionFound: bool = False
 
@@ -459,7 +472,7 @@ def determine_max_achievable_frac(method: BoxSelectionSubsamplingMethod, numBoxe
     method.numBoxes = numBoxes
     frac: float = 0.0
     lastvalidFrac: float = 0.0
-    for frac in np.linspace(0.05, 0.6, 50):
+    for frac in np.linspace(0.01, 0.6, 50):
         method.fraction = frac
 
         valid: bool = False
@@ -475,4 +488,5 @@ def determine_max_achievable_frac(method: BoxSelectionSubsamplingMethod, numBoxe
 
     method.fraction = origFrac
     method.numBoxes = origBoxNum
+    # print(method.label, numBoxes, lastvalidFrac)
     return lastvalidFrac

subsampling.py

@@ -12,7 +12,8 @@ SET GEPARD TO EVALUATION BRANCH (WITHOUT THE TILING STUFF), OTHERWISE SOME OF TH
 """
 
 if __name__ == '__main__':
-    results: TotalResults = TotalResults()
+#     results: TotalResults = TotalResults()
+    results: TotalResults = load_results('results1.res')
     pklsInFolders = get_pkls_from_directory(r'C:\Users\xbrjos\Desktop\temp MP\NewDatasets')
 
     for folder in pklsInFolders.keys():
@@ -26,7 +27,7 @@ if __name__ == '__main__':
     print('updating all took', time.time()-t0, 'seconds')
 
     save_results('results1.res', results)
-    # results: TotalResults = load_results('results1.res')
+    results: TotalResults = load_results('results1.res')
 
     plot: Figure = get_error_vs_frac_plot(results, attributes=[['air', 'water'], ['sediment', 'soil', 'beach', 'slush']],
                                           methods=[])