From 613b7d8250cc3386e88b8f58cbe7f541202a86d2 Mon Sep 17 00:00:00 2001 From: Tanner Swanson Date: Tue, 26 Nov 2024 12:23:08 -0500 Subject: [PATCH] Uploading files --- PopulateTrainingData.py | 77 +++++++++++++++++++++++++++++++++++++++++ main.py | 68 ++++++++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+) create mode 100644 PopulateTrainingData.py create mode 100644 main.py diff --git a/PopulateTrainingData.py b/PopulateTrainingData.py new file mode 100644 index 0000000..b3cca48 --- /dev/null +++ b/PopulateTrainingData.py @@ -0,0 +1,77 @@ +import numpy as np +from perlin_noise import PerlinNoise +import random +import sys +import cv2 + +def Generate_Perlin_Noise(): # generates 100x100 map of perlin noise + noise = PerlinNoise(octaves=10, seed=int(random.random())) + xpix, ypix = 100, 100 + img = np.array([[noise([i / xpix, j / ypix]) for j in range(xpix)] for i in range(ypix)], dtype=np.float32) + return PossibleAnomaly(img) # possibly add anomaly to the result + +def ShipHull_Gen(): # creates a 256x256 map of gradient + row_values = np.repeat(np.arange(256), 1) + result_array = np.tile(row_values[:, None], (1, 256)) + return PossibleAnomaly(result_array) # possibly add anomaly to the result + +def Add_Anomaly(img, xSize, ySize, xPos, yPos, shape): + anomaly_size = (xSize, ySize) + center = (xPos, yPos) + + mask = np.zeros_like(img, dtype=np.uint8) + + if (shape == 0): # ellipse + cv2.ellipse(mask, center, anomaly_size, angle=0, startAngle=0, endAngle=360, color=255, thickness=-1) + elif (shape == 1): #square + print("Unimpemeneted: square anomaly") + #return + elif (shape == 2): # other? + print("unimplemented: other anomaly") + #return + + img[mask == 255] = 1.0 # set all values in mask range to 1.0 + return img + +def WriteToFile(fileName, fileval): + with open(fileName, "w") as f: + vals = np.array2string( + fileval, + precision=16, # Precision for floating point values + suppress_small=False, # Avoid suppressing small values + separator=', ', + threshold=np.prod(fileval.shape) # Prevent truncation for large arrays + ) + f.write(vals) + +def PossibleAnomaly(img): + # TODO: + Xsize, Ysize = img.shape[0], img.shape[1] + if random.randint(0, 1) == 1: # if random int = 1, we add anomaly + print("Adding anomaly") + xPos = random.randint(0, Xsize) + yPos = random.randint(0, Ysize) + + shape = random.randint(0, 2) + + img = Add_Anomaly(img, Xsize, Ysize, xPos, yPos, shape) + return img + + +if __name__ == "__main__": + filePath = "TrainingData/" + + iterations_for_perlin = int(sys.argv[1]) + iterations_for_hull = int(sys.argv[2]) + + + for i in range(0, iterations_for_hull): + fileName = filePath + f"hull_gradient{i}" + arr = ShipHull_Gen() + + WriteToFile(fileName, arr) + + for i in range(0, iterations_for_perlin): + fileName = filePath + f"perlin{i}" + arr = Generate_Perlin_Noise() + WriteToFile(fileName, arr) \ No newline at end of file diff --git a/main.py b/main.py new file mode 100644 index 0000000..f4fe5e7 --- /dev/null +++ b/main.py @@ -0,0 +1,68 @@ +import numpy as np +from scipy.ndimage import gaussian_laplace, convolve +import matplotlib +matplotlib.use('Agg') +import matplotlib.pyplot as plt +import cv2 +import ast +import sys + +def get_anomaly_map(img, params): + f_bank = np.zeros((img.shape[0], img.shape[1], params['n_scales'])) # create a filter bank + + for i in range(params['n_scales']): + img_sd = scale_down(img, params['scales'][i]) # scale down + img_log = gaussian_laplace(img_sd, sigma=params['log_kernel']) # LoG filtering + img_su = scale_up(img_log, img.shape) # scale up + img_su = (img_su - np.min(img_su)) / (np.max(img_su) - np.min(img_su)) # normalize + f_bank[:, :, i] = img_su # add to filter bank + + diff_kernel = np.ones((3, 3, params['n_scales'])) # Histogram difference metric for local + diff_kernel[1, 1, :] = -8 # variation of a pixel w.r.t. its neighbors + sal_map = convolve(f_bank, diff_kernel) # Convultion of filter bank + + return sal_map + +def scale_down(img, scale): # scale to lower size to reduce computation + new_size = (int(img.shape[0] * scale), int(img.shape[1] * scale)) + img_sd = cv2.resize(img, new_size, interpolation=cv2.INTER_AREA) + return img_sd + +def scale_up(img, target_shape): # scale back up for the filter bank + img_su = cv2.resize(img, (target_shape[0], target_shape[1]), interpolation=cv2.INTER_LINEAR) + return img_su + +if __name__ == "__main__": + if (len(sys.argv) < 3): + print("Error!") + else: + inputData = sys.argv[1] + clippingValue = int(sys.argv[2]) + fileName = inputData.split("/")[1] # get the file name, drop the TrainingData/ + + with open(inputData, "r") as f: + strData = f.read() + npArray = np.array(ast.literal_eval(strData), dtype=np.float32) + + params = { + 'n_scales': 1, + 'scales': [1], # Scale factors + 'log_kernel': 1.5 # LoG kernel size + } + + anomaly_map = get_anomaly_map(npArray, params) + anomaly_map_clipped = anomaly_map # dont clip + if clippingValue == 2: + anomaly_map_clipped = np.clip(anomaly_map, 0, 1) # limit range from 0 - 1. If outside, round to that value + elif clippingValue == 3: + anomaly_map_clipped = np.where(anomaly_map >= 0.5, 1, 0) # set value to either 0 or 1. rounds up if >= 0.5, else down + + plt.imshow(npArray, cmap='hot') + plt.title("Original Map") + plt.colorbar() + plt.savefig(f"OutputData/{fileName}_{clippingValue}_original") + + plt.imshow(anomaly_map_clipped, cmap='hot') + plt.title("Anomaly Map") + plt.colorbar() + plt.savefig(f"OutputData/{fileName}_{clippingValue}_analyzed") \ No newline at end of file