opensfdi 0.1.0__tar.gz

opensfdi-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.1
+Name: opensfdi
+Version: 0.1.0
+Summary: 
+Author: Daniel Weston
+Author-email: psydw2@nottingham.ac.uk
+Requires-Python: ==3.11.7
+Classifier: Programming Language :: Python :: 3
+Requires-Dist: imageio (>=2.34.2,<3.0.0)
+Requires-Dist: matplotlib (>=3.9.1,<4.0.0)
+Requires-Dist: numpy (>=2.0.1,<3.0.0)
+Requires-Dist: numpy-stl (>=3.1.1,<4.0.0)
+Requires-Dist: opencv-python (>=4.10.0.84,<5.0.0.0)
+Requires-Dist: pillow (>=10.4.0,<11.0.0)
+Requires-Dist: scikit-image (>=0.24.0,<0.25.0)
+Requires-Dist: scikit-learn (>=1.5.1,<2.0.0)
+Requires-Dist: scipy (>=1.14.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+# OPTIMlab-benchtop-sfdi
+
+TODO

opensfdi-0.1.0/README.md

@@ -0,0 +1,3 @@
+# OPTIMlab-benchtop-sfdi
+
+TODO

opensfdi-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[tool.poetry]
+name = "opensfdi"
+version = "0.1.0"
+description = ""
+authors = ["Daniel Weston <psydw2@nottingham.ac.uk>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "3.11.7"
+matplotlib = "^3.9.1"
+scipy = "^1.14.0"
+numpy = "^2.0.1"
+numpy-stl = "^3.1.1"
+imageio = "^2.34.2"
+opencv-python = "^4.10.0.84"
+pillow = "^10.4.0"
+scikit-learn = "^1.5.1"
+scikit-image = "^0.24.0"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

opensfdi-0.1.0/src/opensfdi/__init__.py

@@ -0,0 +1,99 @@
+from skimage.restoration import unwrap_phase
+
+import numpy as np
+import cv2
+from matplotlib import pyplot as plt
+
+import logging
+import sys
+import argparse
+
+parser = argparse.ArgumentParser()
+
+parser.add_argument('--debug', action='store_true')
+
+args, unknown = parser.parse_known_args()
+
+args = vars(args)
+
+DEBUG = args["debug"]
+
+logger = logging.getLogger('opensfdi')
+
+#formatter = logging.Formatter(fmt='%(threadName)s:%(message)s')
+formatter = logging.Formatter(fmt='[%(levelname)s] %(message)s')
+
+handler = logging.StreamHandler(sys.stdout)
+handler.setFormatter(formatter)
+
+logger.addHandler(handler)
+logger.setLevel(logging.DEBUG if DEBUG else logging.INFO)
+
+def show_surface(data):
+    hf = plt.figure()
+
+    ha = hf.add_subplot(111, projection='3d')
+
+    X, Y = np.meshgrid(range(len(data[0])), range(len(data)))  # `plot_surface` expects `x` and `y` data to be 2D
+    temp = np.mean(data, axis=2) if data.ndim == 3 else data
+    ha.plot_surface(X, Y, temp)
+
+    plt.show()
+
+def display_image(img, grey=False, title='', vmin=0.0, vmax=1.0):
+    if grey:
+        cmap='gray'
+    else:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = cv2.normalize(img, None, 0.0, 1.0, cv2.NORM_MINMAX, cv2.CV_32F)
+        cmap='jet'
+
+    plt.imshow(img, cmap=cmap, vmin=vmin, vmax=vmax)
+    plt.title(title)
+    plt.show()
+
+def centre_crop_img(img, x1, y1, x2:int = 0, y2:int = 0):
+    if x2 == 0:
+        x2 = img.shape[1] if x1 == 0 else -x1
+        
+    if y2 == 0:
+        y2 = img.shape[0] if y1 == 0 else -y1
+    
+    return img[y1 : y2, x1 : x2]
+
+def normalise_image(img):
+    return ((img - img.min()) / (img.max() - img.min()))
+
+def rgb2grey(img):
+    r, g, b = img[:,:,0], img[:,:,1], img[:,:,2]
+    return 0.2989 * r + 0.5870 * g + 0.1140 * b
+
+def unwrapped_phase(phi_imgs):
+    return unwrap_phase(phi_imgs)
+
+def wrapped_phase(imgs):
+    p = np.zeros(imgs[0].shape, dtype=np.float32)
+    q = np.zeros(imgs[0].shape, dtype=np.float32)
+
+    for i, img in enumerate(imgs):
+        phase = (2.0  * np.pi * i) / len(imgs)
+        p = np.add(p, img * np.sin(phase), dtype=np.float32)
+        q = np.add(q, img * np.cos(phase), dtype=np.float32)
+
+    return np.negative(np.arctan2(p, q), dtype=np.float32)
+
+def ac_imgs(imgs: list):
+    return np.divide(np.sum(imgs, axis=0), len(imgs))
+
+def dc_imgs(imgs: list):
+    N = len(imgs)
+    
+    p = q = np.zeros(imgs[0].shape, dtype=np.float32)
+    
+    for i, img in enumerate(imgs):
+        phase = (2.0 * np.pi * i) / N
+        
+        p = np.add(p, img * np.sin(phase))
+        q = np.add(q, img * np.cos(phase))
+        
+    return (2.0 / N) * np.sqrt((p * p) + (q * q))

opensfdi-0.1.0/src/opensfdi/calibration.py

@@ -0,0 +1,200 @@
+import cv2
+import logging
+import numpy as np
+
+import matplotlib.pyplot as plt
+
+from opensfdi import DEBUG
+from opensfdi import rgb2grey, display_image
+from opensfdi.definitions import CALIBRATION_DIR
+from opensfdi.io.std import Serializable
+
+from abc import ABC, abstractmethod
+
+def apply_correction(img, coeffs, x1=0.0, x2=1.0):
+    poly_func = np.poly1d(coeffs)
+
+    corrected_img = poly_func(img)
+
+    corrected_img[corrected_img < x1] = x1 # Cutoff values less than x1
+    corrected_img[corrected_img > x2] = x2 # Cutoff values greater than x2
+
+    return corrected_img
+
+class Calibration(Serializable, ABC):
+    def __init__(self):
+        self.logger = logging.getLogger("opensfdi")
+        
+    @abstractmethod
+    def calibrate(self):
+        raise NotImplementedError
+
+class GammaCalibration(Calibration):
+    def __init__(self, camera, projector, delta, crop_size=0.25, order=5, intensity_count=32):
+        super().__init__()
+        
+        self.camera = camera
+        self.projector = projector
+        
+        self._delta = delta
+        self._crop_size = crop_size
+        self._order = order
+        self._intensity_count = intensity_count
+        
+        self.coeffs = None
+        self.visible = None
+
+    def calibrate(self):
+        intensities = np.linspace(0.0, 1.0, self._intensity_count, dtype=np.float32)
+        w, h = self.camera.resolution
+        self.projector.imgs = np.array([(np.ones((h, w, 3), dtype=np.float32) * i) for i in intensities]) # 3 channels for rgb
+        
+        # Need to get some images
+        captured_imgs = np.empty((self._intensity_count,), dtype=np.ndarray)
+        
+        # Capture all of the images
+        for i in range(self._intensity_count):
+            self.projector.display()
+            captured_imgs[i] = self.camera.capture()
+        
+        cap_height, cap_width, _ = captured_imgs[0].shape
+
+        # Calculate region of interest values
+        roi = int(cap_width * self._crop_size)
+        mid_height = int(cap_height / 2)
+        mid_width = int(cap_width / 2)
+        rows = [x + mid_height for x in range(-roi, roi)]
+        cols = [x + mid_width for x in range(-roi, roi)]
+
+        # Calculate average pixel value for each image
+        averages = [np.mean(x[rows, cols]) for x in captured_imgs]
+
+        # Find sfirst observable change of values for averages (left and right sides) i.e >= delta
+        s, f = self._detectable_indices(averages, self._delta)
+
+        vis_averages = averages[s:f+1]
+        vis_intensities = intensities[s:f+1]
+
+        self.coeffs = np.polyfit(vis_averages, vis_intensities, self._order)
+        self.visible = intensities[s:f+1]
+
+        if DEBUG: # Plot results
+            plt.plot(vis_averages, vis_intensities, 'o')
+            trendpoly = np.poly1d(self.coeffs)
+            plt.title('Gamma Calibration Curve Results')
+            
+            plt.xlabel("Measured")
+            plt.ylabel("Actual")
+            
+            plt.plot(vis_averages, trendpoly(vis_averages))
+            plt.show()
+
+        return self.coeffs, self.visible
+
+    def serialize(self):
+        return {
+                "coeffs"                : self.coeffs.tolist(),
+                "visible_intensities"   : self.visible.tolist()
+            }
+        
+    def deserialize(self):
+        return None
+
+    def _detectable_indices(self, values, delta):
+        start = finish = None
+
+        for i in range(1, len(values) - 1):
+            x1 = values[i - 1]
+            x2 = values[i]
+
+            y1 = values[len(values) - i - 1]
+            y2 = values[len(values) - i]
+
+            if not start and abs(x1 - x2) >= delta:
+                start = i
+
+            if not finish and abs(y1 - y2) >= delta:
+                finish = len(values) - i - 1
+
+        return start, finish
+
+class CameraCalibration(Calibration):
+    def __init__(self, camera, img_count=10, cb_size=(8, 6)):
+        super().__init__()
+        
+        self.camera = camera
+        
+        self._cb_size = cb_size
+        
+        if img_count < 10:
+            raise Exception("10 or more images are required to calibrate cameras")
+
+        self._img_count = img_count
+        
+        self.cam_mat = self.dist_mat = self.optimal_mat = None
+
+    def on_checkboard_change(self, i):
+        '''
+            (i) = Image number just completed (doesn't take into account multiple cameras)
+        '''
+        pass
+
+    def calibrate(self):
+        self.logger.info(f"Using {self._img_count} checkerboard images to calibrate {self.camera.name}")
+        
+        imgs = np.empty((self._img_count), dtype=np.ndarray)
+        
+        for i in range(len(imgs)):
+            img = self.camera.capture()
+            imgs[i] = img
+
+            self.on_checkerboard_change(i)
+        
+        CHECKERBOARD = (self._cb_size[0] - 1, self._cb_size[1] - 1)
+
+        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 30, 0.001)
+
+        threedpoints = []
+        twodpoints = []
+
+        objectp3d = np.zeros((1, CHECKERBOARD[0] * CHECKERBOARD[1], 3), np.float32)
+        objectp3d[0, :, :2] = np.mgrid[0:CHECKERBOARD[0], 0:CHECKERBOARD[1]].T.reshape(-1, 2)
+
+        for i, image in enumerate(imgs):
+            image = cv2.normalize(image, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+            grey_img = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+
+            ret, corners = cv2.findChessboardCorners(grey_img, CHECKERBOARD, cv2.CALIB_CB_ADAPTIVE_THRESH + cv2.CALIB_CB_FAST_CHECK + cv2.CALIB_CB_NORMALIZE_IMAGE)
+
+            if ret:
+                threedpoints.append(objectp3d)
+
+                corners2 = cv2.cornerSubPix(grey_img, corners, (11, 11), (-1, -1), criteria)
+
+                twodpoints.append(corners2)
+                
+                #image = cv2.drawChessboardCorners(image, CHECKERBOARD, corners2, ret)
+            else:
+                self.logger.warning(f'{self.camera.name} failed to find checkerboard on image {i}')
+
+        h, w = imgs[0].shape[:2]
+
+        ret, self.cam_mat, self.dist_mat, r_vecs, t_vecs = cv2.calibrateCamera(threedpoints, twodpoints, grey_img.shape[::-1], None, None)
+
+        if not ret: raise
+
+        self.optimal_mat, roi = cv2.getOptimalNewCameraMatrix(self.cam_mat, self.dist_mat, (w, h), 1, (w, h))
+        
+        return self.cam_mat, self.dist_mat, self.optimal_mat
+
+    def serialize(self):
+        return {
+                "checkerboard_size" : self._cb_size,
+                "image_count"       : self._img_count,
+                "cam_mat"           : self.cam_mat.tolist(),
+                "dist_mat"          : self.dist_mat.tolist(),
+                "optimal_mat"       : self.optimal_mat.tolist()
+            }
+
+    def deserialize(self):
+        return None

opensfdi-0.1.0/src/opensfdi/definitions.py

@@ -0,0 +1,43 @@
+import os
+
+from pathlib import Path
+
+ROOT_DIR = os.path.dirname(os.path.abspath(__file__))   # Root of the entire codebase
+
+DATA_DIR = os.path.join(ROOT_DIR, 'data')               # IO data location
+
+RESULTS_DIR = os.path.join(DATA_DIR, "results")         # Directory for results to be written to
+
+FRINGES_DIR = os.path.join(DATA_DIR, "fringes")         # Fringes are to be used from this directory
+
+CALIBRATION_DIR = os.path.join(DATA_DIR, "calibration") # Location where calibration data is dumped
+
+def make_structure():
+    global ROOT_DIR
+    global DATA_DIR
+    global RESULTS_DIR
+    global FRINGES_DIR
+    global CALIBRATION_DIR
+    
+    Path(ROOT_DIR).mkdir(exist_ok=True)
+    Path(DATA_DIR).mkdir(exist_ok=True)
+    Path(RESULTS_DIR).mkdir(exist_ok=True)
+    Path(FRINGES_DIR).mkdir(exist_ok=True)
+    Path(CALIBRATION_DIR).mkdir(exist_ok=True)
+
+def update_root(new_root, mkdirs=True):
+    global ROOT_DIR
+    global DATA_DIR
+    global RESULTS_DIR
+    global FRINGES_DIR
+    global CALIBRATION_DIR
+    
+    ROOT_DIR = new_root
+    DATA_DIR = os.path.join(ROOT_DIR, 'data')               # IO data location
+    RESULTS_DIR = os.path.join(DATA_DIR, "results")         # Directory for results to be written to
+    FRINGES_DIR = os.path.join(DATA_DIR, "fringes")         # Fringes are to be used from this directory
+    CALIBRATION_DIR = os.path.join(DATA_DIR, "calibration") # Location where calibration data is dumped
+    
+    if mkdirs: make_structure()
+    
+make_structure()

opensfdi-0.1.0/src/opensfdi/experiment.py

@@ -0,0 +1,266 @@
+
+import numpy as np
+
+import logging
+
+from time import sleep
+from scipy.ndimage import gaussian_filter
+from scipy.interpolate import griddata
+
+from opensfdi.profilometry import ClassicPhaseHeight
+from opensfdi.video import FringeProjector
+from opensfdi.utils import maths
+
+class Photogrammetry:
+    def __init__(self, cameras, delay):
+        if len(cameras) < 2: raise Exception("You need at least 2 cameras to run an experiment") 
+        
+        self.logger = logging.getLogger('opensfdi')
+        self.cameras = cameras
+        self.delay = delay
+        
+    def run(self):
+        if 0 < self.delay: sleep(self.delay)
+        return [camera.capture() for camera in self.cameras]
+
+class FringeProjection:
+    def __init__(self, cameras, projector: FringeProjector, delay=0.0):
+        if projector is None: 
+            raise Exception("You need a projector to run an experiment")
+        
+        if len(cameras) == 0: 
+            raise Exception("You need at least 1 camera to run an experiment") 
+        
+        self.logger = logging.getLogger('opensfdi')
+        
+        self.cameras = cameras
+        self.projector = projector
+        self.delay = delay
+
+    def run(self):
+        self.projector.display()
+        if 0 < self.delay: sleep(self.delay)
+        return [camera.capture() for camera in self.cameras]
+    
+    def next(self):
+        self.projector.next()
+
+""" 
+    def stream(self):
+        self.stream = True
+        
+        while self.stream:
+            yield self.run()
+            
+        self.logger.info('Finished streaming') """
+
+class LightCalc:
+    def __init__(self, mu_a, mu_sp, refr_index, sf = [0.0, 0.2], std_dev = 3):
+        self.mu_a = mu_a 
+        self.mu_sp = mu_sp
+        self.refr_index = refr_index
+        self.sf = sf
+        self.std_dev = std_dev
+    
+    def __calculate(self, mu_a, mu_sp, refr_index):
+        # Effective Reflection Coefficient
+        R_eff = 0.0636 * refr_index + 0.668 + 0.710 / refr_index - 1.44 / (refr_index ** 2)     
+        
+        A = (1 - R_eff) / (2 * (1 + R_eff)) # Proportionality Constant
+        mu_tr = mu_sp + mu_a                # Transport Coefficient
+        ap = mu_sp / mu_tr                  # Reduced albedo
+        
+        return R_eff, A, mu_tr, ap
+    
+    def calculate(self, imgs, ref_imgs):
+        R_eff, A, mu_tr, ap = self.__calculate(self.mu_a, self.mu_sp, self.refr_index)
+        
+        ref_img_ac = maths.AC(ref_imgs)
+        ref_img_dc = maths.DC(ref_imgs)
+        
+        # Apply some gaussian filtering if necessary
+        if 0 < self.std_dev:
+            ref_img_dc = gaussian_filter(ref_img_dc, self.std_dev)
+            ref_img_ac = gaussian_filter(ref_img_ac, self.std_dev)
+
+        # Get AC/DC Reflectance values using diffusion approximation
+        r_ac, r_dc = maths.diffusion_approximation(A, ap, mu_tr, f[1])
+
+        R_d_AC2 = (imgs_ac / ref_img_ac) * r_ac
+        R_d_DC2 = (imgs_dc / ref_img_dc) * r_dc
+
+        xi = []
+        x, y = R_d_AC2.shape
+        # Put the DC and AC diffuse reflectance values into an array
+        for i in range(x):
+            for j in range(y):
+                freq = [R_d_DC2[i][j], R_d_AC2[i][j]]
+                xi.append(freq)
+
+        # Get an array of reflectance values and corresponding optical properties
+        # We are setting the absorption coefficient range
+        mu_a = np.arange(0, 0.5, 0.001)
+        mu_sp = np.arange(0.1, 5, 0.01)
+
+        # THE DIFFUSION APPROXIMATION
+        # Getting the diffuse reflectance AC values corresponding to specific absorption and reduced scattering coefficients
+        Reflectance_AC = []
+        Reflectance_DC = []
+        op_mua = []
+        op_sp = []
+        for i in range(len(mu_a)):
+            for j in range(len(mu_sp)):
+                # 1.43 is the refractive index of tissue
+                R_eff, A, mu_tr, ap = self.__calculate(mu_a[i], mu_sp[j], 1.43)
+
+                g = lambda mu_effp: (3 * A * ap) / (((mu_effp / mu_tr) + 1) * ((mu_effp / mu_tr) + 3 * A))
+
+                ac = maths.mu_eff(mu_a[i], mu_tr, f[1])
+                dc = maths.mu_eff(mu_a[i], mu_tr, f[0])
+
+                Reflectance_AC.append(g(ac))
+                Reflectance_DC.append(g(dc))
+
+                op_mua.append(mu_a[i])
+                op_sp.append(mu_sp[j])
+
+        # putting the DC and AC diffuse reflectance values generated from the Diffusion Approximation into an array
+        points = []
+        for k in range(len(mu_a) * len(mu_sp)):
+            freq = [Reflectance_DC[k], Reflectance_AC[k]]
+            points.append(freq)
+
+        points_array = np.array(points)
+        
+        #putting the optical properties into two seperate arrays
+        op_mua_array = np.array(op_mua)
+        op_sp_array = np.array(op_sp)
+
+        #using scipy.interpolate.griddata to perform cubic interpolation of diffuse reflectance values to match
+        #the generated diffuse reflectance values from image to calculated optical properties
+        interp_method = 'cubic'
+        coeff_abs = griddata(points_array, op_mua_array, xi, method=interp_method) #mua
+        coeff_sct = griddata(points_array, op_sp_array, xi, method=interp_method) #musp
+
+        abs_plot = np.reshape(coeff_abs, (R_d_AC2.shape[0], R_d_AC2.shape[1]))
+        sct_plot = np.reshape(coeff_sct, (R_d_AC2.shape[0], R_d_AC2.shape[1]))
+
+        absorption = np.nanmean(abs_plot)
+        absorption_std = np.std(abs_plot)
+
+        scattering = np.nanmean(sct_plot)
+        scattering_std = np.std(sct_plot)
+
+
+        self.logger.info(f'Absorption: {absorption}')
+        self.logger.info(f'Deviation std: {absorption_std}')
+
+        self.logger.info(f'Scattering: {scattering}')
+        self.logger.info(f'Scattering std: {scattering_std}')
+
+        return absorption, scattering, absorption_std, scattering_std
+
+class Experiment:
+    def __init__(self, test):
+        self.logger = logging.getLogger("opensfdi")
+
+        self.test = test
+        
+        self.streaming = False
+    
+        self.save_results = False
+    
+    def stream(self):
+        self.streaming = True
+        
+        while self.streaming:
+            yield self.run()
+            
+        self.logger.info('Finished streaming')
+
+    # Subclass Experiment to declare your own default run behaviour
+    def run(self):
+        self.logger.info(f'Taking a measurement')
+        
+        result = self.test.run()
+        
+        return result
+
+class FPExperiment(Experiment):
+    def __init__(self, test: FringeProjection):
+        super().__init__(test)
+
+    # Subclass Experiment to declare your own default run behaviour
+    def run(self):
+        self.logger.info(f'Taking a measurement')
+        
+        result = self.test.run()
+        
+        return result
+
+class NStepFPExperiment(FPExperiment):
+    def __init__(self, test: FringeProjection, steps=3):
+        super().__init__(test)
+        
+        self._pre_cbs = []
+        self._post_cbs = []
+
+        self.steps = steps
+
+        proj_phases = len(test.projector.phases)
+
+        if proj_phases < self.steps: 
+            raise Exception(f"You need {steps} phases to run a {steps}-step experiment ({proj_phases} provided)")
+
+    def run(self):
+        # Run the experiment n times for both reference and measurement images
+        
+        # Run pre-reference image callbacks
+        for cb in self._pre_cbs: cb()
+        
+        ref_imgs = []
+        for _ in range(self.steps):
+            ref_imgs.append(self.test.run())
+            self.test.next()
+            
+        # Run post-ref callbacks
+        for cb in self._post_cbs: cb()
+        
+        imgs = []
+        for _ in range(self.steps):
+            imgs.append(self.test.run())
+            self.test.next()
+        
+        self.logger.info(f'Measurement completed')
+        
+        ref_imgs = np.transpose(ref_imgs, (1, 0, 2, 3, 4))
+        imgs = np.transpose(imgs, (1, 0, 2, 3, 4))
+        
+        return ref_imgs, imgs
+
+    def classic_ph(self, ref_imgs, imgs, sf, cam_plane_dists, cam_proj_dists):
+        cameras = imgs.shape[0]
+        
+        if len(cam_plane_dists) != cameras:
+            raise Exception("You must provide a distance for all cameras to the ref plane")
+            return None
+        
+        if len(cam_proj_dists) != cameras:
+            raise Exception("You must provide a distance for all cameras to the projector")
+            return None
+        
+        heightmaps = []
+        
+        for i in range(cameras):
+            ph = ClassicPhaseHeight(sf, cam_plane_dists[i], cam_proj_dists[i])
+            heightmap = ph.heightmap(ref_imgs[i], imgs[i], convert_grey=True, crop=None)
+            
+            heightmaps.append(heightmap)
+        
+        return heightmaps
+
+    def add_pre_ref_callback(self, cb):
+        self._pre_cbs.append(cb)
+        
+    def add_post_ref_callback(self, cb):
+        self._post_cbs.append(cb)

opensfdi-0.1.0/src/opensfdi/fringes.py

@@ -0,0 +1,56 @@
+import cv2
+
+import numpy as np
+
+class FringeFactory:
+    @staticmethod
+    def MakeBinary(frequency, phase_count, orientation, width=1024, height=1024):
+        # Maybe not a good idea to rely upon sinusoidal function but works for now :)
+        imgs = FringeFactory.MakeSinusoidal(frequency, phase_count, orientation, width, height)
+
+        width, height, _ = imgs[0].shape
+        
+        for i in range(phase_count):
+            for col in range(width):
+                for row in range(height):
+                    imgs[i][col][row] = 0.0 if imgs[i][col][row] < 0.5 else 1.0
+
+        return imgs
+
+    @staticmethod
+    def MakeBinaryRGB(frequency, phase_count, orientation, width=1024, height=1024):
+        imgs = FringeFactory.MakeBinary(frequency, phase_count, orientation, width, height)
+        
+        return FringeFactory.GrayToRGB(imgs)
+
+    @staticmethod
+    def MakeSinusoidal(frequency, phase_count, orientation, width=1024, height=1024):
+        imgs = np.empty((phase_count, width, height))
+        
+        for i in range(phase_count):
+            x, y = np.meshgrid(np.arange(width, dtype=int), np.arange(height, dtype=int))
+
+            gradient = np.sin(orientation) * x - np.cos(orientation) * y
+
+            imgs[i] = np.sin(((2.0 * np.pi * gradient) / frequency) + phase_count)
+            
+            imgs[i] = cv2.normalize(imgs[i], None, 0.0, 1.0, cv2.NORM_MINMAX, cv2.CV_32F)
+        
+        return imgs
+
+    @staticmethod
+    def MakeSinusoidalRGB(frequency, phase_count, orientation, width=1024, height=1024):
+        imgs = FringeFactory.MakeSinusoidal(frequency, phase_count, orientation, width, height)
+        
+        return FringeFactory.GrayToRGB(imgs)
+
+    @staticmethod
+    def GrayToRGB(imgs):
+        count, width, height = imgs.shape
+        
+        rgb_imgs = np.empty((count, width, height, 3))
+        
+        for i in range(count):
+           rgb_imgs[i] = cv2.cvtColor(imgs[i], cv2.COLOR_GRAY2RGB)
+           
+        return rgb_imgs

opensfdi-0.1.0/src/opensfdi/io/repositories.py

@@ -0,0 +1,175 @@
+import cv2
+import os
+import pickle
+
+from abc import ABC, abstractmethod
+
+class Repo(ABC):
+    @abstractmethod
+    def commit(self):
+        pass
+
+class ImageRepo(Repo):
+    @abstractmethod
+    def add_image(self, img, name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def load_image(self, name):
+        raise NotImplementedError
+
+class ResultRepo(Repo):
+    @abstractmethod
+    def add_fringe(self, imgs, name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def add_image(self, imgs, name):
+        raise NotImplementedError
+
+    @abstractmethod
+    def add_ref_image(self, imgs, name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def add_heightmap(self, heightmap, name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def load_fringe(self, name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def load_image(self, name):
+        raise NotImplementedError
+
+    @abstractmethod
+    def load_ref_image(self, name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def load_heightmap(self, name):
+        raise NotImplementedError
+
+class CalibrationRepo(Repo):
+    @abstractmethod
+    def add_gamma(self, data):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def add_lens(self, data):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def add_proj(self, data):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def load_gamma(self, cam_name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def load_lens(self, cam_name):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def load_proj(self, proj_name):
+        raise NotImplementedError
+
+### CONCRETE IMPLEMENTATIONS ###
+
+class BinRepo(Repo):
+    def __init__(self, file):
+        self._file = file
+        
+        self._outdated = True
+        self._load_cache = None
+
+        self._changes = []
+
+    def add_bin(self, data):
+        self._changes.append(data)
+
+    def load_bin(self):
+        if self._outdated:
+            with open(os.path.join(self._file), 'rb') as infile:
+                self._load_cache = pickle.load(infile)
+                
+            self._outdated = False
+            
+        return self._load_cache
+
+    def commit(self):
+        out = {}
+        for d in self._changes:
+            out = out | d
+        
+        with open(os.path.join(self._file), 'wb') as outfile:
+            pickle.dump(out, outfile, protocol=pickle.HIGHEST_PROTOCOL)
+
+        self._outdated = True
+
+class FileImageRepo(ImageRepo):
+    def __init__(self, path):
+        self._path = path
+        self._changes = {}
+
+    def add_image(self, img, name):
+        self._changes[name] = cv2.normalize(img, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+
+    def load_image(self, name):
+        # BGR Format
+        return cv2.imread(os.path.join(self._path, name), cv2.IMREAD_COLOR)
+
+    def commit(self):
+        # Write all images
+        for name, img in self._changes.items():
+            cv2.imwrite(os.path.join(self._path, name), img)
+
+        self._changes = dict()
+
+class BinCalibrationRepo(CalibrationRepo):
+    def __init__(self, file):
+        self._repo = BinRepo(file)
+        
+        self._data = dict()
+
+    def add_gamma(self, data):
+        cam_name = data.camera.name
+        
+        self.__if_ne(cam_name)
+        
+        self._data[cam_name]["gamma"] = data.serialize()
+    
+    def add_lens(self, data):
+        cam_name = data.camera.name
+        
+        self.__if_ne(cam_name)
+        
+        self._data[cam_name]["lens"] = data.serialize()
+
+    def add_proj(self, data):
+        projector = data.projector.name
+        
+        self._data[proj_name] = data.serialize()
+    
+    def load_gamma(self, cam_name):
+        data = self._repo.load_bin()[cam_name]
+        return data["gamma"]
+    
+    def load_lens(self, cam_name):
+        data = self._repo.load_bin()[cam_name]
+        return data["lens"]
+    
+    def load_proj(self, proj_name):
+        #data = self._repo.load_bin()[proj_name]
+        return None
+    
+    def commit(self):
+        self._repo.add_bin(self._data)
+        
+        self._repo.commit()
+        
+    def __if_ne(self, name):
+        if not (name in self._data):
+            self._data[name] = dict()

opensfdi-0.1.0/src/opensfdi/io/std.py

@@ -0,0 +1,34 @@
+import os
+import sys
+
+from contextlib import contextmanager
+
+from abc import ABC, abstractmethod
+
+# Serialise/Deserialize libraries
+class Serializable(ABC):
+    @abstractmethod
+    def serialize(self):
+        raise NotImplementedError
+    
+    @abstractmethod
+    def deserialize(self):
+        raise NotImplementedError
+
+# Redirect stdout to /dev/null
+@contextmanager
+def stdout_redirected(to=os.devnull):
+    fd = sys.stdout.fileno()
+
+    def _redirect_stdout(to):
+        sys.stdout.close()
+        os.dup2(to.fileno(), fd)
+        sys.stdout = os.fdopen(fd, 'w')
+
+    with os.fdopen(os.dup(fd), 'w') as old_stdout:
+        with open(to, 'w') as file:
+            _redirect_stdout(to=file)
+        try:
+            yield
+        finally:
+            _redirect_stdout(to=old_stdout)

opensfdi-0.1.0/src/opensfdi/profilometry.py

@@ -0,0 +1,148 @@
+import numpy as np
+
+from matplotlib import pyplot as plt
+from numpy.polynomial import polynomial as P
+
+from abc import ABC
+from stl import mesh
+
+from opensfdi import wrapped_phase, unwrapped_phase, centre_crop_img, rgb2grey
+
+def show_heightmap(heightmap, title='Heightmap'):
+    x, y = np.meshgrid(range(heightmap.shape[0]), range(heightmap.shape[1]))
+
+    fig = plt.figure()
+    ax = fig.add_subplot(111, projection='3d')
+    ax.plot_surface(x, y, np.transpose(heightmap))
+    plt.title(title)
+    plt.show()
+
+class PhaseHeight(ABC):
+    def phasemap(self, imgs):
+        w_phase = wrapped_phase(imgs)
+        
+        return unwrapped_phase(w_phase)
+    
+    def to_stl(self, heightmap):
+        # Create vertices from the heightmap
+        vertices = []
+        for y in range(heightmap.shape[0]):
+            for x in range(heightmap.shape[1]):
+                vertices.append([x, y, heightmap[y, x]])
+
+        vertices = np.array(vertices)
+
+        # Create faces for the mesh
+        faces = []
+        for y in range(heightmap.shape[0] - 1):
+            for x in range(heightmap.shape[1] - 1):
+                v1 = x + y * heightmap.shape[1]
+                v2 = (x + 1) + y * heightmap.shape[1]
+                v3 = x + (y + 1) * heightmap.shape[1]
+                v4 = (x + 1) + (y + 1) * heightmap.shape[1]
+
+                # First triangle
+                faces.append([v1, v2, v3])
+                # Second triangle
+                faces.append([v2, v4, v3])
+
+        # Create the mesh object
+        mesh_data = mesh.Mesh(np.zeros(len(faces), dtype=mesh.Mesh.dtype))
+        for i, f in enumerate(faces):
+            for j in range(3):
+                mesh_data.vectors[i][j] = vertices[f[j]]
+
+        mesh_data.save('heightmap_mesh.stl')
+
+class ClassicPhaseHeight(PhaseHeight):
+    # ℎ = 𝜙𝐷𝐸 ⋅ 𝑝 ⋅ 𝑑 / 𝜙𝐷𝐸 ⋅ 𝑝 + 2𝜋𝑙
+    # p = stripe width
+    # d = distance between camera and reference plane
+    # l = distance between camera and projector
+        
+    def __init__(self, p, d, l):
+        super().__init__()
+        
+        self.p = p
+        self.d = d 
+        self.l = l
+    
+    def heightmap(self, ref_imgs, imgs, convert_grey=False, crop=None):
+        if convert_grey:
+            imgs = np.array([rgb2grey(img) for img in imgs])
+            ref_imgs = np.array([rgb2grey(img) for img in ref_imgs])
+  
+        if crop is not None:
+            h, w = imgs[0].shape[:2]
+            if len(crop) == 2:
+                crop_x1 = int(crop[0] * w)
+                crop_x2 = w - crop_x1 - 1
+                crop_y1 = int(crop[1] * h)
+                crop_y2 = h - crop_y1 - 1
+            elif len(crop) == 4:
+                crop_x1 = int(crop[0] * w)
+                crop_y1 = int(crop[1] * h)
+                crop_x2 = w - int(crop[2] * w) - 1
+                crop_y2 = h - int(crop[3] * h) - 1
+            else: raise Exception("Invalid crop tuple passed")
+            
+            imgs = np.array([centre_crop_img(img, crop_x1, crop_y1, crop_x2, crop_y2) for img in imgs])
+            ref_imgs = np.array([centre_crop_img(img, crop_x1, crop_y1, crop_x2, crop_y2) for img in ref_imgs])
+        
+        ref_phase, measured_phase = self.phasemap(ref_imgs), self.phasemap(imgs)
+
+        phase_diff = measured_phase - ref_phase
+        
+        return np.divide(self.l * phase_diff, phase_diff - (2.0 * np.pi * self.p * self.d), dtype=np.float32)
+
+class TriangularStereoHeight(PhaseHeight):
+    def __init__(self, ref_dist, sensor_dist, freq):
+        super().__init__()
+        
+        self.ref_dist = ref_dist
+        self.sensor_dist = sensor_dist
+        self.freq = freq
+    
+    def heightmap(self, imgs):
+        phase = self.phasemap(imgs)
+
+        #heightmap = np.divide(self.ref_dist * phase_diff, 2.0 * np.pi * self.sensor_dist * self.freq)
+        
+        #heightmap[heightmap <= 0] = 0 # Remove negative values
+
+        return None
+
+class PolyPhaseHeight(PhaseHeight):
+    def __init__(self, coeffs=None):
+        super().__init__()
+        
+        self.coeffs = coeffs
+    
+    def calibrate(self, heightmap, ref_imgs, imgs, deg=1):
+        ref_phase, measured_phase = self.phasemap(ref_imgs), self.phasemap(imgs)
+        
+        diff = ref_phase - measured_phase
+
+        total = np.zeros(ref_phase.shape, dtype=np.float64)
+        
+        for i in range(deg):
+            total += np.power(diff, i)
+
+        # Coefficients are in ascending order
+
+        self.coeffs, stats = P.polyfit(diff.ravel(), heightmap.ravel(), deg=deg, full=True)
+            
+        return self.coeffs, stats[0][0]
+
+    def heightmap(self, ref_imgs, imgs):
+        ref_phase, measured_phase = self.phasemaps(ref_imgs, imgs)
+        
+        diff = ref_phase - measured_phase
+        
+        result = np.zeros(ref_phase.shape, dtype=np.float64)
+        
+        for i, a_i in enumerate(self.coeffs):
+            print(f'{round(a_i, ndigits=3)} X_{i}')
+            result += (np.power(diff, i) * a_i)
+        
+        return result

opensfdi-0.1.0/src/opensfdi/services.py

@@ -0,0 +1,99 @@
+import os
+import logging
+import numpy as np
+
+from datetime import datetime
+
+from opensfdi.io.repositories import ImageRepo, FileImageRepo, CalibrationRepo, BinRepo, BinCalibrationRepo
+from opensfdi.definitions import RESULTS_DIR, CALIBRATION_DIR
+
+class CalibrationService():
+    def __init__(self, data_repo:CalibrationRepo = None):       
+        self._logger = logging.getLogger('opensfdi')
+
+        self._data_repo = data_repo
+
+        if self._data_repo is None: # Default to bin repo
+            output = os.path.join(CALIBRATION_DIR, 'calibration.json')
+            self._data_repo = BinCalibrationRepo(output)
+            
+            self._logger.debug(f'Using calibration data file {output}')
+
+    def save_calibrations(self, gamma_calib=None, lens_calib=None, proj_calib=None):
+        updated = False
+        if gamma_calib:
+            self._data_repo.add_gamma(gamma_calib)
+            updated = True
+            
+        if lens_calib: 
+            self._data_repo.add_lens(lens_calib)
+            updated = True
+            
+        if proj_calib: 
+            self._data_repo.add_proj(proj_calib)
+            updated = True
+        
+        if updated: 
+            self._data_repo.commit()
+
+    def load_calibrations(self, cam_name, proj_name):
+        return self._data_repo.load_gamma(cam_name), self._data_repo.load_lens(cam_name), self._data_repo.load_proj(proj_name)
+
+class ResultService():
+    def __init__(self, data_repo:BinRepo, image_repo:ImageRepo):
+        self._logger = logging.getLogger('opensfdi')
+        
+        self._data_repo = data_repo
+        self._image_repo = image_repo
+
+    @staticmethod
+    def default(directory=None):
+        if directory is None: directory = str(datetime.now().strftime("%Y%m%d_%H%M%S"))
+    
+        loc = os.path.join(RESULTS_DIR, directory)
+        
+        if not os.path.exists(loc): os.mkdir(loc, 0o770)
+        
+        data_out = os.path.join(loc, 'results.bin')
+        
+        return ResultService(BinRepo(data_out), FileImageRepo(loc))
+
+    def save_data(self, data=None, fringes=None, imgs=None, ref_imgs=None):
+        if data is not None:
+            self._data_repo.add_bin(data)
+            self._data_repo.commit()
+
+        updated = False
+            
+        if fringes is not None:
+            updated = True
+            for i, img in enumerate(fringes): 
+                self._image_repo.add_image(img, f'fringes{i}.jpg') 
+            
+        if imgs is not None:
+            updated = True
+            for cam_i, xs in enumerate(imgs):
+                for i, img in enumerate(xs):
+                    self._image_repo.add_image(img, f'cam{cam_i}_img{i}.jpg')
+                    
+        if ref_imgs is not None:
+            updated = True
+            for cam_i, xs in enumerate(ref_imgs):
+                for i, img in enumerate(xs):
+                    self._image_repo.add_image(img, f'cam{cam_i}_refimg{i}.jpg')
+
+        if updated: self._image_repo.commit()
+
+    def load_data(self):
+        data = self._data_repo.load_bin()
+        cam_count = len(data["cameras"].keys())
+        phases = data["phases"]
+        
+        imgs = np.empty((cam_count, phases), dtype=np.ndarray)
+        ref_imgs = np.empty((cam_count, phases), dtype=np.ndarray)
+        for cam_i in range(cam_count):
+            for i in range(phases):
+                imgs[cam_i][i] = self._image_repo.load_image(f'cam{cam_i}_img{i}.jpg')
+                ref_imgs[cam_i][i] = self._image_repo.load_image(f'cam{cam_i}_refimg{i}.jpg')
+
+        return ref_imgs, imgs, data

opensfdi-0.1.0/src/opensfdi/utils/maths.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+# Demodulation (array input)
+def AC(imgs: list):
+    return (2 ** 0.5 / 3) * (((imgs[0] - imgs[1]) ** 2 + (imgs[1] - imgs[2]) ** 2 + (imgs[2] - imgs[0]) ** 2) ** 0.5)
+
+def DC(imgs: list):
+    return sum(imgs) / len(imgs)
+
+def mu_eff(mu_a, mu_tr, f):
+    a = (2 * np.pi * f) ** 2
+    return mu_tr * (3 * (mu_a / mu_tr) + a / mu_tr ** 2) ** 0.5
+
+def diffusion_approximation(A, ap, mu_tr, f_ac):
+    r_ac = (3 * A * ap) / (((2 * np.pi * f_ac) / mu_tr) ** 2 + ((2 * np.pi * f_ac) / mu_tr) * (1 + 3 * A) + 3 * A)
+    r_dc = (3 * A * ap) / (3 * (1 - ap) + (1 + 3 * A) * np.sqrt(3 * (1 - ap)) + 3 * A)
+
+    return r_ac, r_dc

opensfdi-0.1.0/src/opensfdi/video.py

@@ -0,0 +1,122 @@
+
+from abc import ABC, abstractmethod
+
+import logging
+import cv2
+
+class Projector(ABC):
+    @abstractmethod
+    def __init__(self, name):
+        self.logger = logging.getLogger('opensfdi')
+
+        self.name = name
+        
+    @abstractmethod
+    def display(self):
+        pass
+
+class ImageProjector(Projector):
+    @abstractmethod
+    def __init__(self, name):
+        super().__init__(name)
+        
+        self.img = None
+
+    @abstractmethod
+    def set_image(self, img):
+        self.img = img
+
+    @abstractmethod
+    def display(self):
+        return self.img
+
+class FringeProjector(Projector):
+    @abstractmethod
+    def __init__(self, name, frequency, orientation, resolution, phases=[]):
+        super().__init__(name)
+        
+        self.frequency = frequency
+        
+        self.orientation = orientation
+        
+        self.resolution = resolution
+
+        self.phases = phases
+        self.current = 0
+
+    @abstractmethod
+    def display(self):
+        pass
+
+    def get_phase(self):
+        return 0.0 if len(self.phases) == 0 else self.phases[self.current]
+
+    def set_phases(self, phases, reset=False):
+        self.phases = phases
+
+        if reset: self.current = 0
+
+    def next(self):
+        self.current = (self.current + 1) % len(self.phases)
+
+class Camera(ABC):
+    def __init__(self, resolution=(1280, 720), name='Camera1', cam_mat=None, dist_mat = None, optimal_mat=None):
+        self.logger = logging.getLogger('opensfdi')
+        
+        self.resolution = resolution
+        
+        self.name = name
+
+        self.cam_mat = cam_mat
+        self.dist_mat = dist_mat
+        self.optimal_mat = optimal_mat
+    
+    @abstractmethod
+    def capture(self):
+        pass
+    
+    def set_resolution(self, res):
+        self.resolution = res
+
+    def try_undistort_img(self, img):
+        if self.cam_mat is not None and self.dist_mat is not None and self.optimal_mat is not None:
+            self.logger.debug('Undistorting camera image...')
+            return cv2.undistort(img, self.cam_mat, self.dist_mat, None, self.optimal_mat)
+        
+        return img
+
+class FakeCamera(Camera):
+    def __init__(self, imgs=[], name='Camera1', cam_mat=None, dist_mat = None, optimal_mat=None):
+        super().__init__(name='Camera1', cam_mat=cam_mat, dist_mat=dist_mat, optimal_mat=optimal_mat)
+        
+        self.img_num = 0
+
+        self.imgs = imgs
+
+    def capture(self):
+        img = next(self.imgs)
+        
+        if not self.loop and len(self.imgs) <= self.img_num:
+            self.img_num = 0
+            return None
+        
+        self.img_num += 1
+        
+        self.logger.info(f'Returning an image')
+
+        return img
+    
+    def __iter__(self):
+        return iter(self.imgs)
+
+    def add_image(self, img):
+        self._images.append(img)
+        return self
+
+class FileCamera(FakeCamera):
+    def __init__(self, img_paths, name='Camera1', cam_mat=None, dist_mat = None, optimal_mat=None):
+        super().__init__(name='Camera1', cam_mat=cam_mat, dist_mat=dist_mat, optimal_mat=optimal_mat)
+        
+        # Load all images into memory
+        for path in img_paths:
+            self.imgs.append(cv2.imread(path, 1))