Upload 17 files

check_img-vs-msk_size.py

@@ -0,0 +1,35 @@
+import glob
+import os
+from PIL import Image
+import subprocess
+import pdb
+from osgeo import gdal
+import operator
+
+# checks if a mask-patch exists for each image-patch and the pixel size equals
+
+path_images = "/home/maduschek/DATA/mine-sector-detection/patches_img_trainset/"
+path_masks = "/home/maduschek/DATA/mine-sector-detection/patches_mask_trainset/"
+
+filecount = len(glob.glob(path_images + "*.png"))
+print("file count: ", str(filecount))
+
+# pdb.set_trace()
+i = 0
+for img, msk in zip(sorted(glob.glob(path_images + "*.png")), sorted(glob.glob(path_masks + "*.png"))):
+
+    ds_img = gdal.Open(img)
+    ds_msk = gdal.Open(msk)
+
+    i += 1
+    if i % 1000 == 0:
+        print(str(i), " / ", str(filecount))
+
+    if ds_img.RasterXSize != ds_msk.RasterXSize or ds_img.RasterYSize != ds_msk.RasterYSize:
+        print("###################################################")
+        print(img, "    ",  msk)
+        print("image-size: ", ds_img.RasterXSize, "x", ds_img.RasterYSize, " mask-size: ", ds_msk.RasterXSize, "x", ds_msk.RasterYSize)
+        print(" ")
+        input("press")
+
+

crop-to-tiles.sh

@@ -0,0 +1,10 @@
+TARGDIR="/home/maduschek/ssd/mine-sector-detection/images_trainset/"
+FILES="/home/maduschek/ssd/mine-sector-detection/images/*.jp2"
+
+mkdir -p $TARGDIR
+
+for f in $FILES
+do
+  echo "Processing file $f"
+  /usr/bin/gdal_retile.py -resume -v -ps 256 256 -overlap 128 -of PNG -targetDir $TARGDIR $f
+done

crop-to-tiles_masks.sh

@@ -0,0 +1,10 @@
+TARGDIR="/home/maduschek/ssd/mine-sector-detection/masks_trainset/"
+FILES="/home/maduschek/ssd/mine-sector-detection/masks/*.tif"
+
+mkdir -p $TARGDIR
+
+for f in $FILES
+do
+  echo "Processing file $f"
+  /usr/bin/gdal_retile.py -v -ps 256 256 -overlap 128 -of PNG -targetDir $TARGDIR $f
+done

docker-run.sh

@@ -0,0 +1 @@
+sudo docker run -it -v /home/maduschek:/home/maduschek osgeo/gdal:latest /bin/bash

extract_mapbox_files.py

@@ -0,0 +1,50 @@
+import glob
+import os
+from PIL import Image
+import subprocess
+import pdb
+from osgeo import gdal
+
+# gdal_rasterize -l LSM_Chile_sectors_class_epsg3857 -a class -ts 25729.0 13441.0 -a_nodata 0.0 -te -7663806.3641 -2396313.3772 -7633077.4844 -2380260.4069 -ot Float32 -of GTiff "C:/Dropbox/TUM SIPEO/Projekte/RS mining facilities/L-ASM Mining Dataset/ds/LSM_Chile_sectors_class_epsg3857.geojson" C:/Users/matthias/AppData/Local/Temp/processing_KFVIRc/2f32c9c1db924811af36352bf5f8fdf4/OUTPUT.tif
+
+
+# creates mask files based on images and geojson file
+
+Image.MAX_IMAGE_PIXELS = 10000000000
+
+path_images = "C:/data/mine-sectors/mapbox_mines_0.8m_RGB/"
+path_images = "../../ssd/mine-sector-detection/images/"
+path_json = "./"
+os.makedirs("./out", exist_ok=True)
+
+# pdb.set_trace()
+for file in sorted(glob.glob(path_images + "*.jp2")):
+
+    # pdb.set_trace()
+    ds = gdal.Open(file, gdal.GA_ReadOnly)
+    geoTransform = ds.GetGeoTransform()
+    minx = geoTransform[0]
+    maxy = geoTransform[3]
+    maxx = minx + geoTransform[1] * ds.RasterXSize
+    miny = maxy + geoTransform[5] * ds.RasterYSize
+    data = None
+    rb = (ds.GetRasterBand(1)).ReadAsArray()
+    pixelsize = str(rb.shape[1]) + " " + str(rb.shape[0])
+
+    print(file)
+    print([minx, miny, maxx, maxy])
+    print(pixelsize)
+
+    # "-te -7825738.2085 -2675527.0926 -7821399.2129 -2672659.5097 " \
+
+    string = "gdal_rasterize -l LSM_Chile_sectors_class_epsg3857 -a class -ts " + pixelsize + \
+             " -te " + str(minx) + " " + str(miny) + " " + str(maxx) + " " + str(maxy) + " " \
+             "-ot Byte -of GTiff '" + path_json + "LSM_Chile_sectors_class_epsg3857.geojson' " \
+             "./out/mask_" + os.path.basename(file)[:-4] + ".tif"
+
+    print(string)
+    # input("press enter")
+
+    os.system(string)
+
+

keras_seg.py

@@ -0,0 +1,523 @@
+import random
+import glob
+import os
+import time
+from datetime import datetime
+import pdb
+import platform
+# from IPython.display import display
+from tensorflow.keras.preprocessing.image import load_img
+from PIL import ImageOps, Image
+from matplotlib import pyplot as plt
+from tensorflow import keras
+import tensorflow as tf
+import numpy as np
+from tensorflow.keras.preprocessing.image import load_img
+from tensorflow.keras import layers
+from imgrender import render
+from sklearn.metrics import confusion_matrix
+np.set_printoptions(edgeitems=30, linewidth=100000,
+    formatter=dict(float=lambda x: "%.3g" % x))
+
+# TODO:
+# The predicted output masks are somewhat working, but the output is not the class value (0-10), it is a proportional
+# value from 0-1 * 255 (e.g. 3 -> 76 or 229 -> 9)
+
+
+'''
+base_dir = "../../data/cats_dogs/"
+input_dir_train = base_dir + "images/"
+target_dir_train = base_dir + "annotations/trimaps"
+input_dir_test = base_dir + "images/"
+target_dir_test = base_dir + "annotations/trimaps"
+img_size = (160, 160)
+num_classes = 3
+batch_size = 32
+'''
+
+# a priori knowledge
+# class weights gained from seg_stats.py
+class_weights = {0: 1,
+                 1: 50.3606,
+                 2: 195.0304,
+                 3: 202.9463,
+                 4: 64.3299,
+                 5: 83.5509,
+                 6: 745.9514,
+                 7: 119.1049,
+                 8: 41.1413,
+                 9: 33.946,
+                 10: 33216.4873}
+
+# mine sectors
+if platform.system() == "Windows":
+    base_dir = "C:/DATA/mine-sector-detection/"
+else:
+    base_dir = "/home/maduschek/DATA/mine-sector-detection/"
+    # base_dir = "/home/maduschek/ssd/mine-sector-detection/DEBUG/"
+
+# path to train and test set
+input_dir_train = base_dir + "patches_img_trainset/"
+target_dir_train = base_dir + "patches_mask_trainset/"
+input_dir_test = base_dir + "patches_img_trainset/"
+target_dir_test = base_dir + "patches_mask_trainset/"
+img_size = (256, 256)
+num_classes = 10
+batch_size = 16
+
+epochs = int(input("epochs: "))
+subset_percent = float(input("subset_size in %: "))/100
+
+
+# load the image files
+input_img_paths_train = sorted(
+    [
+        os.path.join(input_dir_train, fname)
+        for fname in os.listdir(input_dir_train)
+        if fname.endswith(".png")
+    ]
+)
+
+# load the mask files
+target_img_paths_train = sorted(
+    [
+        os.path.join(target_dir_train, fname)
+        for fname in os.listdir(target_dir_train)
+        if fname.endswith(".png") and not fname.startswith(".")
+    ]
+)
+
+# load the image files
+input_img_paths_test = sorted(
+    [
+        os.path.join(input_dir_test, fname)
+        for fname in os.listdir(input_dir_test)
+        if fname.endswith(".png")
+    ]
+)
+
+# load the mask files
+target_img_paths_test = sorted(
+    [
+        os.path.join(target_dir_test, fname)
+        for fname in os.listdir(target_dir_test)
+        if fname.endswith(".png") and not fname.startswith(".")
+    ]
+)
+
+
+# random subset for faster DEBUGGING
+if subset_percent != 0:
+    np.random.seed(42)
+    subset_idx_train = (np.random.random(int(len(input_img_paths_train) * subset_percent)) * len(input_img_paths_train)).astype(int)
+    input_img_paths_train = np.asarray(input_img_paths_train)[subset_idx_train]
+    target_img_paths_train = np.asarray(target_img_paths_train)[subset_idx_train]
+
+    np.random.seed(42)
+    subset_idx_test = (np.random.random(int(len(input_img_paths_test) * subset_percent)) * len(input_img_paths_test)).astype(int)
+    input_img_paths_test = np.asarray(input_img_paths_test)[subset_idx_test]
+    target_img_paths_test = np.asarray(target_img_paths_test)[subset_idx_test]
+
+print("Number of train samples:", len(input_img_paths_train))
+for i in range(5):
+    print(input_img_paths_train[i])
+print("...")
+print("Number of test samples:", len(input_img_paths_test))
+for i in range(5):
+    print(input_img_paths_test[i])
+print("...")
+
+
+# show image and its mask
+for input_path, target_path in zip(input_img_paths_train[:], target_img_paths_train[:]):
+    arr = np.array(Image.open(target_path))
+
+    # the following step is necessarey becaus all 0 valued mask-pixels are set to 255
+    # if arr.min() == 0:
+    #     print(target_path, " mask pixels +1")
+    #     Image.fromarray(arr + 1).save(target_path)
+
+    # if arr.max() > 3 or len(arr.shape) > :
+    #     print(input_path, "|", target_path, " max: ", str(arr.max()))
+
+
+if False:
+    rnd_idx = (np.random.random(10)*len(input_img_paths_train)).astype(int)
+    for i in rnd_idx:
+        os.system('clear')
+        render(os.path.join(input_img_paths_train[i]), scale=(128, 128))
+        print(input_img_paths_train[i])
+        print("---------------------------------------")
+
+        mask = Image.open(os.path.join(target_img_paths_train[i]))
+        ImageOps.autocontrast(mask).save(
+            os.path.join("./", "mask_contrast" + str(i) + ".png"))
+        render(os.path.join("./", "mask_contrast" + str(i) + ".png"), scale=(128, 128))
+        print(target_img_paths_train[i])
+        time.sleep(5)
+
+
+
+class MineSectorHelper(keras.utils.Sequence):
+    """Helper to iterate over the data (as Numpy arrays)."""
+
+    def __init__(self, batch_size, img_size, input_img_paths, target_img_paths):
+        self.batch_size = batch_size
+        self.img_size = img_size
+        self.input_img_paths = input_img_paths
+        self.target_img_paths = target_img_paths
+
+    def __len__(self):
+        return len(self.target_img_paths) // self.batch_size
+
+    def __getitem__(self, idx):
+        """Returns tuple (input, target) correspond to batch #idx."""
+        i = idx * self.batch_size
+        batch_input_img_paths = self.input_img_paths[i: i + self.batch_size]
+        batch_target_img_paths = self.target_img_paths[i: i + self.batch_size]
+
+        x = np.zeros((self.batch_size,) + self.img_size + (3,), dtype="uint8")
+        for j, path in enumerate(batch_input_img_paths):
+            # print(path)
+            img = load_img(path, target_size=self.img_size)
+            x[j] = img
+
+        y = np.zeros((self.batch_size,) + self.img_size + (1,), dtype="uint8")
+        for j, path in enumerate(batch_target_img_paths):
+            img = load_img(path, target_size=self.img_size, color_mode="grayscale")
+            y[j] = np.expand_dims(img, 2)
+            # Ground truth labels are 1, 2, 3. Subtract one to make them 0, 1, 2:
+            # y[j] -= 1
+
+        w = generate_sample_weights(y, class_weights)
+
+        return x, y, w
+
+
+def get_item(idx):
+    """Returns tuple (input, target) correspond to batch #idx."""
+    i = idx * self.batch_size
+    batch_input_img_paths = self.input_img_paths[i: i + self.batch_size]
+    batch_target_img_paths = self.target_img_paths[i: i + self.batch_size]
+    x = np.zeros((self.batch_size,) + self.img_size + (3,), dtype="uint8")
+
+    for j, path in enumerate(batch_input_img_paths):
+        # print(path)
+        img = load_img(path, target_size=self.img_size)
+        x[j] = img
+    y = np.zeros((self.batch_size,) + self.img_size + (1,), dtype="uint8")
+
+    for j, path in enumerate(batch_target_img_paths):
+        img = load_img(path, target_size=self.img_size, color_mode="grayscale")
+        y[j] = np.expand_dims(img, 2)
+        # Ground truth labels are 1, 2, 3. Subtract one to make them 0, 1, 2:
+        y[j] -= 1
+    return x, y
+
+
+def get_model(img_size, num_classes):
+    inputs = keras.Input(shape=img_size + (3,))
+
+    ### [First half of the network: downsampling inputs] ###
+
+    # Entry block
+    x = layers.Conv2D(32, 3, strides=2, padding="same")(inputs)
+    x = layers.BatchNormalization()(x)
+    x = layers.Activation("relu")(x)
+
+    previous_block_activation = x  # Set aside residual
+
+    # Blocks 1, 2, 3 are identical apart from the feature depth.
+    for filters in [64, 128, 256]:
+        x = layers.Activation("relu")(x)
+        x = layers.SeparableConv2D(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.Activation("relu")(x)
+        x = layers.SeparableConv2D(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.MaxPooling2D(3, strides=2, padding="same")(x)
+
+        # Project residual
+        residual = layers.Conv2D(filters, 1, strides=2, padding="same")(
+            previous_block_activation
+        )
+        x = layers.add([x, residual])  # Add back residual
+        previous_block_activation = x  # Set aside next residual
+
+    ### [Second half of the network: upsampling inputs] ###
+
+    for filters in [256, 128, 64, 32]:
+        x = layers.Activation("relu")(x)
+        x = layers.Conv2DTranspose(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.Activation("relu")(x)
+        x = layers.Conv2DTranspose(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.UpSampling2D(2)(x)
+
+        # Project residual
+        residual = layers.UpSampling2D(2)(previous_block_activation)
+        residual = layers.Conv2D(filters, 1, padding="same")(residual)
+        x = layers.add([x, residual])  # Add back residual
+        previous_block_activation = x  # Set aside next residual
+
+    # Add a per-pixel classification layer
+    outputs = layers.Conv2D(num_classes, 3, activation="softmax", padding="same")(x)
+
+    # Define the model
+    model = keras.Model(inputs, outputs)
+    return model
+
+
+def generate_sample_weights(training_data, class_weights):
+
+    # replaces values for up to 3 classes with the values from class_weights
+    sample_weights = [np.where(y == 0, class_weights[0],
+                      np.where(y == 1, class_weights[1],
+                      np.where(y == 2, class_weights[2],
+                      np.where(y == 3, class_weights[3],
+                      np.where(y == 4, class_weights[4],
+                      np.where(y == 5, class_weights[5],
+                      np.where(y == 6, class_weights[6],
+                      np.where(y == 7, class_weights[7],
+                      np.where(y == 8, class_weights[8],
+                      np.where(y == 9, class_weights[9],
+                      np.where(y == 10, class_weights[10], y))))))))))) for y in training_data]
+
+    return np.asarray(sample_weights)
+
+
+def get_optimizer(optimizer="adam"):
+
+    if optimizer == "adam":
+        return keras.optimizers.Adam(
+            learning_rate=0.0001,
+            beta_1=0.9,
+            beta_2=0.999,
+            epsilon=1e-07,
+            amsgrad=False)
+
+    if optimizer == "sgd":
+        return keras.optimizers.SGD(
+            learning_rate=0.01,
+            momentum=0.0,
+            nesterov=False,
+            weight_decay=None)
+
+    if optimizer == "rmsprop":
+        return keras.optimizers.RMSprop(
+            learning_rate=0.0001,
+            rho=0.9,
+            momentum=0.0,
+            epsilon=1e-07,
+            centered=False)
+
+    if optimizer == "adagrad":
+        return keras.optimizers.Adagrad(
+            learning_rate=0.001,
+            initial_accumulator_value=0.1,
+            epsilon=1e-07,
+            weight_decay=None)
+
+
+if __name__ == "__main__":
+    # Free up RAM in case the model definition cells were run multiple times
+    keras.backend.clear_session()
+
+    # Build model
+    model = get_model(img_size, num_classes)
+    model.summary()
+
+    """
+    ## Set aside a validation split
+    """
+
+    # Split our img paths into a training and a validation set
+    train_input_img_paths = input_img_paths_train
+    train_target_img_paths = target_img_paths_train
+
+    val_input_img_paths = input_img_paths_test
+    val_target_img_paths = target_img_paths_test
+
+    print(val_input_img_paths[0])
+    print(train_input_img_paths[0])
+
+    # Instantiate data Sequences for each split
+    train_gen = MineSectorHelper(batch_size, img_size, train_input_img_paths, train_target_img_paths)
+    val_gen = MineSectorHelper(batch_size, img_size, val_input_img_paths, val_target_img_paths)
+
+
+    # load the model
+    model_file = "mining-segments-model.h5"
+    if os.path.isfile(model_file):
+        model = keras.models.load_model("mining-segments-model.h5")
+    else:
+
+        # Train the model
+        # Configure the model for training.
+        # We use the "sparse" version of categorical_crossentropy
+        # because our target data is integers.
+
+        model.compile(optimizer=get_optimizer("adam"), loss="sparse_categorical_crossentropy")
+        log_dir = "logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
+        tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
+
+        callbacks = [
+            keras.callbacks.ModelCheckpoint("mining-segments-model.h5", save_best_only=True),
+            tensorboard_callback]
+
+        # apply class weights as sample weights
+        # for train_batch in train_gen:
+        # sample_weights = generate_sample_weights(train_batch[1], class_weights)
+
+        '''
+        model.fit(x=train_gen[0][0],
+                  y=train_gen[0][1],
+                  epochs=epochs,
+                  validation_data=val_gen,
+                  callbacks=callbacks,
+                  sample_weight=train_gen[0][2])
+        '''
+
+        model.fit(train_gen,
+                  epochs=epochs,
+                  validation_data=val_gen,
+                  callbacks=callbacks)
+
+
+        '''
+        loss_fn = keras.losses.SparseCategoricalCrossentropy(from_logits=True)
+        # optimizer = keras.optimizers.SGD(learning_rate=1e-3)
+        optimizer = get_optimizer("adam")
+
+        # Train the model in manual loop
+        for epoch in range(epochs):
+            print("\nStart of epoch %d" % (epoch,))
+
+            # Iterate over the batches of the dataset.
+            for step, train_batch in enumerate(train_gen):
+
+                # Open a GradientTape to record the operations run
+                # during the forward pass, which enables auto-differentiation.
+                with tf.GradientTape() as tape:
+
+                    # Run the forward pass of the layer.
+                    # The operations that the layer applies
+                    # to its inputs are going to be recorded
+                    # on the GradientTape.
+                    logits = model(train_batch[0], training=True)  # Logits for this minibatch
+
+                    # Compute the loss value for this minibatch.
+                    loss_value = loss_fn(train_batch[1], logits)
+
+                # Use the gradient tape to automatically retrieve
+                # the gradients of the trainable variables with respect to the loss.
+                grads = tape.gradient(loss_value, model.trainable_weights)
+
+                # Run one step of gradient descent by updating
+                # the value of the variables to minimize the loss.
+                optimizer.apply_gradients(zip(grads, model.trainable_weights))
+
+                # Log every 200 batches.
+                print("Training loss (for one batch) at step %d: %.4f"
+                        % (step, float(loss_value)))
+
+                print("Seen so far: %s samples" % ((step + 1) * batch_size))
+
+        '''
+
+
+
+    # Visualize predictions
+
+    # Generate predictions for all images in the validation set
+    # val_gen = MineSectorHelper(batch_size, img_size, val_input_img_paths, val_target_img_paths)
+    # val_preds = model.predict(val_gen, workers=1, max_queue_size=2)
+
+    sum_conf_mat = np.array([])
+    acc_total = 0
+    count = 0
+    for img_path, mask_path in zip(val_input_img_paths, val_target_img_paths):
+        count += 1
+        img_arr = np.asarray(Image.open(img_path))
+        mask_arr = np.asarray(Image.open(mask_path))
+
+        # pdb.set_trace()
+
+        dict_metrics = model.evaluate(x=np.expand_dims(img_arr, axis=0), y=np.expand_dims(mask_arr, axis=0), return_dict=True)
+        pred_mask = model.predict(np.expand_dims(img_arr, axis=0))
+
+        # save the predicted mask file and compare with gt target
+        os.makedirs("output", exist_ok=True)
+        pred_mask_path = os.path.join("./", "output", "mask_pred" + os.path.basename(img_path) + ".png")
+        pred_mask = np.argmax(pred_mask, axis=-1)
+        # pred_mask = np.expand_dims(pred_mask[0], axis=-1)
+
+        Image.fromarray(((pred_mask/10)*255).astype('B')[0]).save(pred_mask_path)
+
+        os.system('clear')
+        # os.system("cls")
+        render(img_path)
+        print("-------------")
+        render(mask_path)
+        print("-------------")
+        render(pred_mask_path)
+
+        res = (mask_arr == pred_mask[0]).astype(int)
+        acc = np.sum(res)/np.size(res)
+        acc_total += acc
+        print("total accuracy: ", acc_total / count)
+
+
+        if sum_conf_mat.size == 0:
+            sum_conf_mat = confusion_matrix(y_true=mask_arr.flatten(), y_pred=pred_mask[0].flatten(), labels=range(10))
+        else:
+            conf_mat = confusion_matrix(y_true=mask_arr.flatten(), y_pred=pred_mask[0].flatten(), labels=range(10))
+            sum_conf_mat += conf_mat
+            # print(sum_conf_mat)
+
+    plt.matshow(sum_conf_mat)
+
+    a = input("continue...")
+
+
+
+
+
+
+    def display_img_mask_gt(i):
+        os.makedirs("images", exist_ok=True)
+
+        pred_mask_path = os.path.join("./", "images", "mask" + str(i) + ".png")
+        gt_mask_path = os.path.join("./", "images", "mask_gt" + str(i) + ".png")
+        img_path = os.path.join("./", "images", "img" + str(i) + ".png")
+
+        # predicted mask
+        pred_mask = np.argmax(val_preds[i], axis=-1)
+        pred_mask = np.expand_dims(pred_mask, axis=-1)
+        ImageOps.autocontrast(keras.preprocessing.image.array_to_img(pred_mask)).\
+            save(pred_mask_path)
+
+        # ground truth mask
+        gt_mask = np.asarray(Image.open(val_target_img_paths[i]))
+        gt_mask = np.expand_dims(gt_mask, axis=-1)
+        ImageOps.autocontrast(keras.preprocessing.image.array_to_img(gt_mask)). \
+            save(gt_mask_path)
+
+        # input image
+        Image.open(val_input_img_paths[i]).\
+            save(img_path)
+
+        os.system('clear')
+        render(pred_mask_path)
+        print("---------------")
+        render(gt_mask_path)
+        print("---------------")
+        render(img_path)
+        time.sleep(5)
+
+    # for i in range(10): display_img_mask_gt(i)

keras_seg_cats_dogs.py

@@ -0,0 +1,253 @@
+import random
+from tensorflow.keras import layers
+import os
+from datetime import datetime
+from tensorflow import keras
+import numpy as np
+from tensorflow.keras.preprocessing.image import load_img
+from tensorflow.keras.preprocessing.image import load_img
+from PIL import ImageOps, Image
+from datetime import datetime
+import io
+import itertools
+from packaging import version
+import tensorflow as tf
+from tensorflow import keras
+import matplotlib.pyplot as plt
+import numpy as np
+import sklearn.metrics
+
+
+input_dir = "../../data/cats_dogs/images/"
+target_dir = "../../data/cats_dogs/annotations/trimaps/"
+img_size = (160, 160)
+num_classes = 3
+batch_size = 32
+
+input_img_paths = sorted(
+    [
+        os.path.join(input_dir, fname)
+        for fname in os.listdir(input_dir)
+        if fname.endswith(".jpg")
+    ]
+)
+target_img_paths = sorted(
+    [
+        os.path.join(target_dir, fname)
+        for fname in os.listdir(target_dir)
+        if fname.endswith(".png") and not fname.startswith(".")
+    ]
+)
+
+print("Number of samples:", len(input_img_paths))
+
+for input_path, target_path in zip(input_img_paths[:10], target_img_paths[:10]):
+    print(input_path, "|", target_path)
+
+
+
+def plot_to_image(figure):
+    """Converts the matplotlib plot specified by 'figure' to a PNG image and
+    returns it. The supplied figure is closed and inaccessible after this call."""
+    # Save the plot to a PNG in memory.
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png')
+    # Closing the figure prevents it from being displayed directly inside
+    # the notebook.
+    plt.close(figure)
+    buf.seek(0)
+    # Convert PNG buffer to TF image
+    image = tf.image.decode_png(buf.getvalue(), channels=4)
+    # Add the batch dimension
+    image = tf.expand_dims(image, 0)
+    return image
+
+
+def image_grid():
+    """Return a 5x5 grid of the MNIST images as a matplotlib figure."""
+    # Create a figure to contain the plot.
+    figure = plt.figure(figsize=(10,10))
+    for i in range(25):
+        # Start next subplot.
+        plt.subplot(5, 5, i + 1, title=class_names[train_labels[i]])
+        plt.xticks([])
+        plt.yticks([])
+        plt.grid(False)
+        plt.imshow(train_images[i], cmap=plt.cm.binary)
+
+    return figure
+
+
+class OxfordPets(keras.utils.Sequence):
+    """Helper to iterate over the data (as Numpy arrays)."""
+
+    def __init__(self, batch_size, img_size, input_img_paths, target_img_paths):
+        self.batch_size = batch_size
+        self.img_size = img_size
+        self.input_img_paths = input_img_paths
+        self.target_img_paths = target_img_paths
+
+    def __len__(self):
+        return len(self.target_img_paths) // self.batch_size
+
+    def __getitem__(self, idx):
+        """Returns tuple (input, target) correspond to batch #idx."""
+        i = idx * self.batch_size
+        batch_input_img_paths = self.input_img_paths[i : i + self.batch_size]
+        batch_target_img_paths = self.target_img_paths[i : i + self.batch_size]
+        x = np.zeros((self.batch_size,) + self.img_size + (3,), dtype="float32")
+        for j, path in enumerate(batch_input_img_paths):
+            img = load_img(path, target_size=self.img_size)
+            x[j] = img
+        y = np.zeros((self.batch_size,) + self.img_size + (1,), dtype="uint8")
+        for j, path in enumerate(batch_target_img_paths):
+            img = load_img(path, target_size=self.img_size, color_mode="grayscale")
+            y[j] = np.expand_dims(img, 2)
+            # Ground truth labels are 1, 2, 3. Subtract one to make them 0, 1, 2:
+            y[j] -= 1
+        return x, y
+
+
+# Prepare U-Net Xception-style model
+def get_model(img_size, num_classes):
+    inputs = keras.Input(shape=img_size + (3,))
+
+    # [First half of the network: down-sampling inputs] #
+
+    # Entry block
+    x = layers.Conv2D(32, 3, strides=2, padding="same")(inputs)
+    x = layers.BatchNormalization()(x)
+    x = layers.Activation("relu")(x)
+
+    previous_block_activation = x  # Set aside residual
+
+    # Blocks 1, 2, 3 are identical apart from the feature depth.
+    for filters in [64, 128, 256]:
+        x = layers.Activation("relu")(x)
+        x = layers.SeparableConv2D(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.Activation("relu")(x)
+        x = layers.SeparableConv2D(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.MaxPooling2D(3, strides=2, padding="same")(x)
+
+        # Project residual
+        residual = layers.Conv2D(filters, 1, strides=2, padding="same")(
+            previous_block_activation
+        )
+        x = layers.add([x, residual])  # Add back residual
+        previous_block_activation = x  # Set aside next residual
+
+    ### [Second half of the network: upsampling inputs] ###
+
+    for filters in [256, 128, 64, 32]:
+        x = layers.Activation("relu")(x)
+        x = layers.Conv2DTranspose(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.Activation("relu")(x)
+        x = layers.Conv2DTranspose(filters, 3, padding="same")(x)
+        x = layers.BatchNormalization()(x)
+
+        x = layers.UpSampling2D(2)(x)
+
+        # Project residual
+        residual = layers.UpSampling2D(2)(previous_block_activation)
+        residual = layers.Conv2D(filters, 1, padding="same")(residual)
+        x = layers.add([x, residual])  # Add back residual
+        previous_block_activation = x  # Set aside next residual
+
+    # Add a per-pixel classification layer
+    outputs = layers.Conv2D(num_classes, 3, activation="softmax", padding="same")(x)
+
+    # Define the model
+    model = keras.Model(inputs, outputs)
+    return model
+
+
+# Free up RAM in case the model definition cells were run multiple times
+keras.backend.clear_session()
+
+# Build model
+model = get_model(img_size, num_classes)
+model.summary()
+
+"""
+## Set aside a validation split
+"""
+
+
+# Split our img paths into a training and a validation set
+val_samples = 1000
+random.Random(1337).shuffle(input_img_paths)
+random.Random(1337).shuffle(target_img_paths)
+train_input_img_paths = input_img_paths[:-val_samples]
+train_target_img_paths = target_img_paths[:-val_samples]
+val_input_img_paths = input_img_paths[-val_samples:]
+val_target_img_paths = target_img_paths[-val_samples:]
+
+# Instantiate data Sequences for each split
+train_gen = OxfordPets(
+    batch_size, img_size, train_input_img_paths, train_target_img_paths
+)
+val_gen = OxfordPets(batch_size, img_size, val_input_img_paths, val_target_img_paths)
+
+"""
+## Train the model
+"""
+
+# Configure the model for training.
+# We use the "sparse" version of categorical_crossentropy
+# because our target data is integers.
+model.compile(optimizer="rmsprop", loss="sparse_categorical_crossentropy")
+log_dir = "logs/fit/" + datetime.now().strftime("%Y%m%d-%H%M%S")
+tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
+
+callbacks = [
+    keras.callbacks.ModelCheckpoint("oxford_segmentation.h5", save_best_only=True),
+    tensorboard_callback
+]
+
+logdir = "logs/plots/" + datetime.now().strftime("%Y%m%d-%H%M%S")
+file_writer = tf.summary.create_file_writer(logdir)
+
+# Prepare the plot
+figure = image_grid()
+
+# Convert to image and log
+with file_writer.as_default():
+    tf.summary.image("Training data", plot_to_image(figure), step=0)
+
+# Train the model, doing validation at the end of each epoch.
+epochs = 15
+model.fit(train_gen, epochs=epochs, validation_data=val_gen, callbacks=callbacks)
+
+"""
+## Visualize predictions
+"""
+
+# Generate predictions for all images in the validation set
+
+val_gen = OxfordPets(batch_size, img_size, val_input_img_paths, val_target_img_paths)
+val_preds = model.predict(val_gen)
+
+
+def display_mask(i):
+    """Quick utility to display a model's prediction."""
+    mask = np.argmax(val_preds[i], axis=-1)
+    mask = np.expand_dims(mask, axis=-1)
+    img = ImageOps.autocontrast(keras.preprocessing.image.array_to_img(mask))
+
+
+
+# Display results for validation image #10
+i = 10
+
+# Display input image
+Image.open(val_input_img_paths[i]).save(str(i) + ".png")
+
+# Display ground-truth target mask
+img = ImageOps.autocontrast(load_img(val_target_img_paths[i]))
+Image.open(val_input_img_paths[i]).save(str(i) + "_mask.png")

mask-rcnn.py

@@ -0,0 +1,378 @@
+"""
+Mask R-CNN
+Train on the toy Balloon dataset and implement color splash effect.
+
+Copyright (c) 2018 Matterport, Inc.
+Licensed under the MIT License (see LICENSE for details)
+Written by Waleed Abdulla
+
+------------------------------------------------------------
+
+Usage: import the module (see Jupyter notebooks for examples), or run from
+       the command line as such:
+
+    # Train a new model starting from pre-trained COCO weights
+    python3 balloon.py train --dataset=/path/to/balloon/dataset --weights=coco
+
+    # Resume training a model that you had trained earlier
+    python3 balloon.py train --dataset=/path/to/balloon/dataset --weights=last
+
+    # Train a new model starting from ImageNet weights
+    python3 balloon.py train --dataset=/path/to/balloon/dataset --weights=imagenet
+
+    # Apply color splash to an image
+    python3 balloon.py splash --weights=/path/to/weights/file.h5 --image=<URL or path to file>
+
+    # Apply color splash to video using the last weights you trained
+    python3 balloon.py splash --weights=last --video=<URL or path to file>
+"""
+import glob
+import os
+import pdb
+import sys
+import json
+import datetime
+import numpy as np
+import skimage.draw
+import platform
+import pdb
+import glob
+from PIL import Image
+
+# Root directory of the project
+ROOT_DIR = os.path.abspath("../../../")
+
+# mine sectors
+if platform.system() == "Windows":
+    base_dir = "C:/data/"
+else:
+    base_dir = "/root/host/ssd/mine-sector-detection/"
+    # base_dir = "/home/maduschek/ssd/mine-sector-detection/DEBUG/"
+
+# Import Mask RCNN
+sys.path.append(ROOT_DIR)  # To find local version of the library
+from mrcnn.config import Config
+from mrcnn import model as modellib, utils
+
+# Path to trained weights file
+COCO_WEIGHTS_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
+
+# Directory to save logs and model checkpoints, if not provided
+# through the command line argument --logs
+DEFAULT_LOGS_DIR = os.path.join(ROOT_DIR, "logs")
+
+############################################################
+#  Configurations
+############################################################
+
+
+class BalloonConfig(Config):
+    """Configuration for training on the toy dataset.
+    Derives from the base Config class and overrides some values.
+    """
+    # Give the configuration a recognizable name
+    NAME = "mining_sectors"
+
+    # We use a GPU with 12GB memory, which can fit two images.
+    # Adjust down if you use a smaller GPU.
+    IMAGES_PER_GPU = 1
+
+    # Number of classes (including background)
+    NUM_CLASSES = 10  # Background + balloon
+
+    # Number of training steps per epoch
+    STEPS_PER_EPOCH = 50
+
+    # Skip detections with < 90% confidence
+    DETECTION_MIN_CONFIDENCE = 0.9
+
+
+############################################################
+#  Dataset
+############################################################
+
+class BalloonDataset(utils.Dataset):
+
+    def load_balloon(self, dataset_dir, subset):
+        """Load a subset of the Balloon dataset.
+        dataset_dir: Root directory of the dataset.
+        subset: Subset to load: train or val
+        """
+        # Add classes.
+        self.add_class("balloon", 0, "surrounding")
+        self.add_class("balloon", 1, "ASM")
+        self.add_class("balloon", 2, "LSM")
+        self.add_class("balloon", 3, "Leaching Heap")
+        self.add_class("balloon", 4, "Mining Facilities")
+        self.add_class("balloon", 5, "Open Pit")
+        self.add_class("balloon", 6, "Processing Plant")
+        self.add_class("balloon", 7, "Stockyard")
+        self.add_class("balloon", 8, "Tailings Storage Facility")
+        self.add_class("balloon", 9, "Waste Rock Dump")
+
+        # Train or validation dataset?
+        assert subset in ["images_trainset", "images_testset"]
+        dataset_dir = os.path.join(dataset_dir, subset)
+
+        image_paths = sorted(glob.glob(os.path.join(dataset_dir, "*.png")))
+
+        for idx, image_path in enumerate(image_paths):
+            filename = os.path.basename(image_path)
+            self.add_image(
+                "balloon",
+                image_id=idx,  # use file name as a unique image id
+                image_fname=os.path.basename(image_path),
+                path=image_path,
+                width=256,
+                height=256)
+
+
+
+
+
+
+
+
+    def load_mask(self, image_id):
+
+        """Generate instance masks for an image.
+       Returns:
+        masks: A bool array of shape [height, width, instance count] with
+            one mask per instance.
+        class_ids: a 1D array of class IDs of the instance masks.
+        """
+        # print(image_id)
+
+        # If not a balloon dataset image, delegate to parent class.
+        image_info = self.image_info[image_id]
+        if image_info["source"] != "balloon":
+            return super(self.__class__, self).load_mask(image_id)
+
+        # Convert polygons to a bitmap mask of shape
+        # [height, width, instance_count]
+        info = self.image_info[image_id]
+
+        # get number of classes in this mask image and create for each class a binary mask
+        # img = Image.open(info.path)
+        # instance_count = np.unique(np.asarray(img, dtype=np.uint8))
+
+        mask = np.zeros([256, 256, 1], dtype=np.uint8)
+        return mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32)
+
+        '''
+        mask = np.zeros([info["height"], info["width"], len(info["polygons"])],
+                        dtype=np.uint8)
+        for i, p in enumerate(info["polygons"]):
+            # Get indexes of pixels inside the polygon and set them to 1
+            rr, cc = skimage.draw.polygon(p['all_points_y'], p['all_points_x'])
+            mask[rr, cc, i] = 1
+
+        # Return mask, and array of class IDs of each instance. Since we have
+        # one class ID only, we return an array of 1s
+        return mask.astype(np.bool), np.ones([mask.shape[-1]], dtype=np.int32)
+        '''
+
+    def image_reference(self, image_id):
+        """Return the path of the image."""
+        info = self.image_info[image_id]
+        if info["source"] == "balloon":
+            return info["path"]
+        else:
+            super(self.__class__, self).image_reference(image_id)
+
+
+def train(model):
+
+    """Train the model."""
+    # Training dataset.
+    dataset_train = BalloonDataset()
+    dataset_train.load_balloon(args.dataset, "images_trainset")
+    dataset_train.prepare()
+
+    # Validation dataset
+    dataset_val = BalloonDataset()
+    dataset_val.load_balloon(args.dataset, "images_testset")
+    dataset_val.prepare()
+
+    dataset_train.load_mask(23)
+
+    # *** This training schedule is an example. Update to your needs ***
+    # Since we're using a very small dataset, and starting from
+    # COCO trained weights, we don't need to train too long. Also,
+    # no need to train all layers, just the heads should do it.
+    print("Training network heads")
+    model.train(dataset_train, dataset_val,
+                learning_rate=config.LEARNING_RATE,
+                epochs=30,
+                layers='heads')
+
+
+def color_splash(image, mask):
+    """Apply color splash effect.
+    image: RGB image [height, width, 3]
+    mask: instance segmentation mask [height, width, instance count]
+
+    Returns result image.
+    """
+    # Make a grayscale copy of the image. The grayscale copy still
+    # has 3 RGB channels, though.
+    gray = skimage.color.gray2rgb(skimage.color.rgb2gray(image)) * 255
+    # Copy color pixels from the original color image where mask is set
+    if mask.shape[-1] > 0:
+        # We're treating all instances as one, so collapse the mask into one layer
+        mask = (np.sum(mask, -1, keepdims=True) >= 1)
+        splash = np.where(mask, image, gray).astype(np.uint8)
+    else:
+        splash = gray.astype(np.uint8)
+    return splash
+
+
+def detect_and_color_splash(model, image_path=None, video_path=None):
+    assert image_path or video_path
+
+    # Image or video?
+    if image_path:
+        # Run model detection and generate the color splash effect
+        print("Running on {}".format(args.image))
+        # Read image
+        image = skimage.io.imread(args.image)
+        # Detect objects
+        r = model.detect([image], verbose=1)[0]
+        # Color splash
+        splash = color_splash(image, r['masks'])
+        # Save output
+        file_name = "splash_{:%Y%m%dT%H%M%S}.png".format(datetime.datetime.now())
+        skimage.io.imsave(file_name, splash)
+    elif video_path:
+        import cv2
+        # Video capture
+        vcapture = cv2.VideoCapture(video_path)
+        width = int(vcapture.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(vcapture.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = vcapture.get(cv2.CAP_PROP_FPS)
+
+        # Define codec and create video writer
+        file_name = "splash_{:%Y%m%dT%H%M%S}.avi".format(datetime.datetime.now())
+        vwriter = cv2.VideoWriter(file_name,
+                                  cv2.VideoWriter_fourcc(*'MJPG'),
+                                  fps, (width, height))
+
+        count = 0
+        success = True
+        while success:
+            print("frame: ", count)
+            # Read next image
+            success, image = vcapture.read()
+            if success:
+                # OpenCV returns images as BGR, convert to RGB
+                image = image[..., ::-1]
+                # Detect objects
+                r = model.detect([image], verbose=0)[0]
+                # Color splash
+                splash = color_splash(image, r['masks'])
+                # RGB -> BGR to save image to video
+                splash = splash[..., ::-1]
+                # Add image to video writer
+                vwriter.write(splash)
+                count += 1
+        vwriter.release()
+    print("Saved to ", file_name)
+
+
+############################################################
+#  Training
+############################################################
+
+if __name__ == '__main__':
+    import argparse
+
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(
+        description='Train Mask R-CNN to detect balloons.')
+    parser.add_argument("command",
+                        metavar="<command>",
+                        help="'train' or 'splash'")
+    parser.add_argument('--dataset', required=False,
+                        metavar="/path/to/balloon/dataset/",
+                        help='Directory of the Balloon dataset')
+    parser.add_argument('--weights', required=True,
+                        metavar="/path/to/weights.h5",
+                        help="Path to weights .h5 file or 'coco'")
+    parser.add_argument('--logs', required=False,
+                        default=DEFAULT_LOGS_DIR,
+                        metavar="/path/to/logs/",
+                        help='Logs and checkpoints directory (default=logs/)')
+    parser.add_argument('--image', required=False,
+                        metavar="path or URL to image",
+                        help='Image to apply the color splash effect on')
+    parser.add_argument('--video', required=False,
+                        metavar="path or URL to video",
+                        help='Video to apply the color splash effect on')
+    args = parser.parse_args()
+
+    # Validate arguments
+    if args.command == "train":
+        assert args.dataset, "Argument --dataset is required for training"
+    elif args.command == "splash":
+        assert args.image or args.video,\
+               "Provide --image or --video to apply color splash"
+
+    print("Weights: ", args.weights)
+    print("Dataset: ", args.dataset)
+    print("Logs: ", args.logs)
+
+    # Configurations
+    if args.command == "train":
+        config = BalloonConfig()
+    else:
+        class InferenceConfig(BalloonConfig):
+            # Set batch size to 1 since we'll be running inference on
+            # one image at a time. Batch size = GPU_COUNT * IMAGES_PER_GPU
+            GPU_COUNT = 1
+            IMAGES_PER_GPU = 1
+        config = InferenceConfig()
+    config.display()
+
+    # Create model
+    if args.command == "train":
+        model = modellib.MaskRCNN(mode="training", config=config,
+                                  model_dir=args.logs)
+    else:
+        model = modellib.MaskRCNN(mode="inference", config=config,
+                                  model_dir=args.logs)
+
+    # Select weights file to load
+    if args.weights.lower() == "coco":
+        weights_path = COCO_WEIGHTS_PATH
+        # Download weights file
+        if not os.path.exists(weights_path):
+            utils.download_trained_weights(weights_path)
+    elif args.weights.lower() == "last":
+        # Find last trained weights
+        weights_path = model.find_last()
+    elif args.weights.lower() == "imagenet":
+        # Start from ImageNet trained weights
+        weights_path = model.get_imagenet_weights()
+    else:
+        weights_path = args.weights
+
+    # Load weights
+    print("Loading weights ", weights_path)
+    if args.weights.lower() == "coco":
+        # Exclude the last layers because they require a matching
+        # number of classes
+        model.load_weights(weights_path, by_name=True, exclude=[
+            "mrcnn_class_logits", "mrcnn_bbox_fc",
+            "mrcnn_bbox", "mrcnn_mask"])
+    else:
+        model.load_weights(weights_path, by_name=True)
+
+    # Train or evaluate
+    if args.command == "train":
+        train(model)
+    elif args.command == "splash":
+        detect_and_color_splash(model, image_path=args.image,
+                                video_path=args.video)
+    else:
+        print("'{}' is not recognized. "
+              "Use 'train' or 'splash'".format(args.command))

pad-files.py

@@ -0,0 +1,41 @@
+import glob
+import os
+import time
+from datetime import datetime
+import pdb
+import platform
+# from IPython.display import display
+from tensorflow.keras.preprocessing.image import load_img
+from PIL import ImageOps, Image
+from tensorflow import keras
+import numpy as np
+from tensorflow.keras.preprocessing.image import load_img
+from tensorflow.keras import layers
+from imgrender import render
+
+
+# mine sectors
+if platform.system() == "Windows":
+    base_dir = "C:/data/"
+else:
+    base_dir = "/home/maduschek/ssd/mine-sector-detection/"
+
+datasets = [base_dir + "images_trainset/",
+            base_dir + "masks_trainset/",
+            base_dir + "images_testset/",
+            base_dir + "masks_testset/"]
+
+
+for dataset in datasets:
+    for img_path in glob.glob(os.path.join(dataset, "*.png")):
+        img = Image.open(img_path)
+        print(img_path)
+
+        if img.size != (256, 256):
+            print("file: ", img_path, ', size: ', str(img.size))
+            width, height = img.size
+            right = 256 - width
+            bottom = 256 - height
+            padded_img = Image.new(img.mode, (width + right, height + bottom))
+            padded_img.paste(img, (0, 0))
+            padded_img.save(img_path)

pytorch_seg.py

@@ -0,0 +1,23 @@
+from torchvision.io.image import read_image
+from torchvision.models.segmentation import fcn_resnet50, FCN_ResNet50_Weights
+from torchvision.transforms.functional import to_pil_image
+
+img = read_image("gallery/assets/dog1.jpg")
+
+# Step 1: Initialize model with the best available weights
+weights = FCN_ResNet50_Weights.DEFAULT
+model = fcn_resnet50(weights=weights)
+model.eval()
+
+# Step 2: Initialize the inference transforms
+preprocess = weights.transforms()
+
+# Step 3: Apply inference preprocessing transforms
+batch = preprocess(img).unsqueeze(0)
+
+# Step 4: Use the model and visualize the prediction
+prediction = model(batch)["out"]
+normalized_masks = prediction.softmax(dim=1)
+class_to_idx = {cls: idx for (idx, cls) in enumerate(weights.meta["categories"])}
+mask = normalized_masks[0, class_to_idx["dog"]]
+to_pil_image(mask).show()

requirements.txt

@@ -0,0 +1,13 @@
+imgrender==0.0.4
+matplotlib==3.7.1
+mrcnn==0.2
+numpy==1.23.5
+osgeo==0.0.1
+packaging==23.1
+pandas==2.0.2
+Pillow==9.5.0
+Pillow==9.5.0
+scikit_learn==1.2.2
+scikit_image
+tensorflow==2.12.0
+torchvision==0.15.2

run.py

@@ -0,0 +1,194 @@
+import os
+import sys
+import random
+import math
+import re
+import time
+import numpy as np
+import cv2
+import matplotlib
+import matplotlib.pyplot as plt
+import pandas as pd
+import pdb
+from sklearn.model_selection import train_test_split
+import glob
+
+
+# Root directory of the project
+ROOT_DIR = os.path.abspath("./Mask_RCNN/")
+
+# Import Mask RCNN
+sys.path.append(ROOT_DIR)  # To find local version of the library
+from mrcnn.config import Config
+from mrcnn import utils
+import mrcnn.model as modellib
+from mrcnn import visualize
+from mrcnn.model import log
+
+# Directory to save logs and trained model
+MODEL_DIR = os.path.join(ROOT_DIR, "logs")
+
+# Local path to trained weights file
+COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")
+
+# Download COCO trained weights from Releases if needed
+if not os.path.exists(COCO_MODEL_PATH):
+    utils.download_trained_weights(COCO_MODEL_PATH)
+
+
+class MineSectorConfig(Config):
+    """Configuration for training on the toy shapes dataset.
+    Derives from the base Config class and overrides values specific
+    to the toy shapes dataset.
+    """
+    # Give the configuration a recognizable name
+    NAME = "mining-sectors"
+
+    # Train on 1 GPU and 8 images per GPU. We can put multiple images on each
+    # GPU because the images are small. Batch size is 8 (GPUs * images/GPU).
+    GPU_COUNT = 1
+    IMAGES_PER_GPU = 8
+
+    # Number of classes (including background)
+    NUM_CLASSES = 1 + 9  # background + 3 shapes
+
+    # Use small images for faster training. Set the limits of the small side
+    # the large side, and that determines the image shape.
+    IMAGE_MIN_DIM = 128
+    IMAGE_MAX_DIM = 128
+
+    # Use smaller anchors because our image and objects are small
+    RPN_ANCHOR_SCALES = (8, 16, 32, 64, 128)  # anchor side in pixels
+
+    # Reduce training ROIs per image because the images are small and have
+    # few objects. Aim to allow ROI sampling to pick 33% positive ROIs.
+    TRAIN_ROIS_PER_IMAGE = 32
+
+    # Use a small epoch since the data is simple
+    STEPS_PER_EPOCH = 100
+
+    # use small validation steps since the epoch is small
+    VALIDATION_STEPS = 5
+
+
+config = MineSectorConfig()
+config.display()
+
+
+class MineSectDataset(utils.Dataset):
+
+    def __init__(self, path):
+        self.path = path
+        self.mine_ids = []
+
+        
+    def load_mine_sectors(self):
+        """Generate the requested number of synthetic images.
+        count: number of images to generate.
+        height, width: the size of the generated images.
+        """
+
+        self.add_class("shapes", 1, "square")
+        self.add_class("shapes", 2, "circle")
+        self.add_class("shapes", 3, "triangle")
+
+        # Add classes
+        '''
+        self.add_class("mine_sector", 3, "lh")
+        self.add_class("mine_sector", 4, "mf")
+        self.add_class("mine_sector", 5, "op")
+        self.add_class("mine_sector", 6, "pp")
+        self.add_class("mine_sector", 7, "sy")
+        self.add_class("mine_sector", 8, "tsf")
+        self.add_class("mine_sector", 9, "wr")
+        '''
+
+
+        # Add images
+        # Generate random specifications of images (i.e. color and
+        # list of shapes sizes and locations). This is more compact than
+        # actual images. Images are generated on the fly in load_image().
+        df = create_df()
+        print('Total Images: ', len(df))
+        mine_ids = np.array([])
+
+        # split mines into train, valid and test
+
+        # get unique mine ids
+        for patch in df['id'].values:
+            mine_id = int(patch.split(".")[0])
+            if mine_id not in mine_ids:
+                self.mine_ids = np.append(self.mine_ids, mine_id)
+
+    
+    def load_image(self, filename):
+        # loads the image from a file, but
+
+        pdb.set_trace()
+        fpath = os.path.join(self.path, filename)
+        image = cv2.imread(fpath)
+        return image
+
+    def load_mask(self, filename):
+        # loads the image from a file, but
+
+        pdb.set_trace()
+        fpath = os.path.join(self.path, filename)
+        image = cv2.imread(fpath)
+        return image
+
+
+    def image_reference(self, image_id):
+        """Return the shapes data of the image."""
+        info = self.image_info[image_id]
+        if info["source"] == "shapes":
+            return info["shapes"]
+        else:
+            super(self.__class__).image_reference(self, image_id)
+
+
+IMG_PATH = 'dataset/images/'
+MASK_PATH = 'dataset/masks/'
+
+batch_size = 32
+num_classes = 10
+
+
+# create dataframe to get the image name/index in order
+def create_df():
+    name = []
+    for dir, subdir, filenames in os.walk(IMG_PATH):
+        for filename in filenames:
+            name.append(filename[:-4])
+
+    return pd.DataFrame({'id': name}, index=np.arange(0, len(name)))
+
+
+if __name__ == "__main__":
+
+    # pdb.set_trace()
+    mine_sect_ds = MineSectDataset(IMG_PATH)
+    mine_sect_ds.load_mine_sectors()
+    mine_sect_ds.load_image(mine_sect_ds.mine_ids[0])
+
+
+
+    MID_trainval, MID_test = train_test_split(mine_ids, test_size=0.15, random_state=42)
+    MID_train, MID_val = train_test_split(MID_trainval, test_size=0.25, random_state=42)
+
+    X_train = np.array([])
+    for id in MID_train:
+        X_train = np.append(X_train, np.transpose([os.path.basename(x) for x in glob.glob(os.path.join(IMG_PATH, str(int(id)) + "*.tif"))]))
+
+    X_val = np.array([])
+    for id in MID_val:
+        X_val = np.append(X_val, np.transpose([os.path.basename(x) for x in glob.glob(os.path.join(IMG_PATH, str(int(id)) + "*.tif"))]))
+
+    X_test = np.array([])
+    for id in MID_test:
+        X_test = np.append(X_test, np.transpose([os.path.basename(x) for x in glob.glob(os.path.join(IMG_PATH, str(int(id)) + "*.tif"))]))
+
+
+    print('Train Size: ', len(X_train))
+    print('Validation Size: ', len(X_val))
+    print('Test Size: ', len(X_test))

run_maskrcnn.sh

@@ -0,0 +1,2 @@
+python mask-rcnn.py train --dataset "/root/host/ssd/mine-sector-detection" --weights=mask_rcnn_coco.h5
+

seg_stats.py

@@ -0,0 +1,56 @@
+import glob
+import os.path
+import platform
+import numpy as np
+from PIL import Image
+
+
+# mine sectors
+if platform.system() == "Windows":
+    base_dir = "C:/data/mine-sectors/"
+else:
+    base_dir = "/home/maduschek/ssd/mine-sector-detection/"
+    # base_dir = "/home/maduschek/data/cats_dogs/"
+
+input_dir_train = base_dir + "images_trainset/"
+target_dir_train = base_dir + "masks_trainset/"
+input_dir_test = base_dir + "images_testset/"
+target_dir_test = base_dir + "masks_testset/"
+
+
+shape_img_list = []
+shape_mask_list = []
+class_instances = dict()
+
+k = 0
+for img_path, mask_path in zip(glob.glob(os.path.join(input_dir_train, "*.png")), glob.glob(os.path.join(target_dir_train, "*.png"))):
+
+    k += 1
+
+    # get shape of all images
+    img = Image.open(img_path)
+    if img.size not in shape_img_list:
+        shape_img_list.append(img.size)
+        print("img shape", img.size)
+
+    # get shape of all masks
+    mask = Image.open(mask_path)
+    if mask.size not in shape_mask_list:
+        shape_mask_list.append(mask.size)
+        print("mask size", mask.size)
+
+    # get all possible classes
+    vals, counts = np.unique(np.asarray(mask), return_counts=True)
+
+    for val, count in zip(vals, counts):
+        if val in class_instances:
+            class_instances[val] += count
+        else:
+            class_instances[val] = count
+
+    if k % 100 == 0:
+        os.system("clear")
+        print(k)
+        for key in class_instances.keys():
+            print("class ", key, ": ", class_instances[key])
+

subset.py

@@ -0,0 +1,60 @@
+# create a subset of files in a folder
+import argparse
+import glob
+import os
+import numpy as np
+import pdb
+
+# for repeatability
+ratio = 0.25
+np.random.seed(42)
+
+if __name__ == "__main__":
+
+    # get path from cmd parameter
+
+    # pdb.set_trace()
+
+    ap = argparse.ArgumentParser()
+    ap.add_argument("-i", "--pathimage", required=True, help="path to folder")
+    ap.add_argument("-t", "--pathtarget", required=True, help="path to folder")
+    args = vars(ap.parse_args())
+
+    root = args["pathimage"]
+    root2 = args["pathtarget"]
+    os.makedirs(os.path.join(root, "subset"), exist_ok=True)
+    os.makedirs(os.path.join(root2, "subset"), exist_ok=True)
+
+    man_set_ratio = int(input("set the percentage of the subset (eg. 25): "))
+
+    # set ratio if man_set_ratio is valid
+    if 100 > man_set_ratio > 0:
+        ratio = man_set_ratio/100
+
+    # get all files of certain type
+    f_types = ('*.jpg', '*.jpeg', '*.png', '*.bmp', '*.tif')
+    all_files_images = []
+    all_files_target = []
+    for f_type in f_types:
+        all_files_images.extend(sorted(glob.glob(os.path.join(root, f_type))))
+        all_files_target.extend(sorted(glob.glob(os.path.join(root2, f_type))))
+
+    # get random idx
+    randomIdx = np.random.permutation(len(all_files_images))
+    files_sel_idx = randomIdx[0:int(ratio * len(all_files_images))]
+
+    for n, idx in enumerate(files_sel_idx):
+        # os.system('cls')
+        print(int(n/len(files_sel_idx)*10000)/100)
+        os.rename(all_files_images[idx], os.path.join(root, "subset", os.path.basename(all_files_images[idx])))
+        os.rename(all_files_target[idx], os.path.join(root2, "subset", os.path.basename(all_files_target[idx])))
+
+        '''
+        # move potentially existing label file
+        if os.path.exists(all_files[idx][:-3] + "xml"):
+            os.rename(all_files[idx][:-3] + "xml", root + "\\subset\\" + os.path.basename(all_files[idx][:-3] + "xml"))
+        if os.path.exists(all_files[idx][:-3] + "json"):
+            os.rename(all_files[idx][:-3] + "json", root + "\\subset\\" + os.path.basename(all_files[idx][:-3] + "json"))
+        if os.path.exists(all_files[idx][:-3] + "txt"):
+            os.rename(all_files[idx][:-3] + "txt", root + "\\subset\\" + os.path.basename(all_files[idx][:-3] + "txt"))
+        '''