Fix: move large model files to LFS

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.keras filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,32 @@
+# Use a lightweight Python image with TensorFlow pre-installed if possible, 
+# or a standard slim python image.
+FROM python:3.11-slim
+
+# Set the working directory
+WORKDIR /code
+
+# System deps often needed by opencv-python-headless
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender1 \
+  && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code
+COPY . .
+
+# Create a directory for the model if it doesn't exist (to match your app.py logic)
+RUN mkdir -p /code/model
+
+# Expose the port Hugging Face uses
+EXPOSE 7860
+
+# Run the application. 
+# We use Gunicorn for production-grade freedom from Flask's built-in server issues.
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "app:app"]

FingerprintImageEnhancer.py

@@ -0,0 +1,515 @@
+import numpy as np
+import cv2
+from scipy import signal
+from scipy import ndimage
+import math
+import scipy
+
+class FingerprintImageEnhancer(object):
+    def __init__(self):
+        self.ridge_segment_blksze = 32
+        self.ridge_segment_thresh = 0.1
+        self.gradient_sigma = 1
+        self.block_sigma = 7
+        self.orient_smooth_sigma = 7
+        self.ridge_freq_blksze = 38
+        self.ridge_freq_windsze = 15 #width change (thick -> 15) (default -> 5)
+        self.min_wave_length = 7
+        self.max_wave_length = 15
+        self.kx = 0.65
+        self.ky = 0.65
+        self.angleInc = 3
+        self.ridge_filter_thresh = -3
+
+
+        self._mask = []
+        self._normim = []
+        self._orientim = []
+        self._mean_freq = []
+        self._median_freq = []
+        self._freq = []
+        self._freqim = []
+        self._binim = []
+
+    def __normalise(self, img, mean, std):
+        normed = (img - np.mean(img)) / (np.std(img))
+        return (normed)
+
+    def __ridge_segment(self, img):
+        # RIDGESEGMENT - Normalises fingerprint image and segments ridge region
+        #
+        # Function identifies ridge regions of a fingerprint image and returns a
+        # mask identifying this region.  It also normalises the intesity values of
+        # the image so that the ridge regions have zero mean, unit standard
+        # deviation.
+        #
+        # This function breaks the image up into blocks of size blksze x blksze and
+        # evaluates the standard deviation in each region.  If the standard
+        # deviation is above the threshold it is deemed part of the fingerprint.
+        # Note that the image is normalised to have zero mean, unit standard
+        # deviation prior to performing this process so that the threshold you
+        # specify is relative to a unit standard deviation.
+        #
+        # Usage:   [normim, mask, maskind] = ridgesegment(im, blksze, thresh)
+        #
+        # Arguments:   im     - Fingerprint image to be segmented.
+        #              blksze - Block size over which the the standard
+        #                       deviation is determined (try a value of 16).
+        #              thresh - Threshold of standard deviation to decide if a
+        #                       block is a ridge region (Try a value 0.1 - 0.2)
+        #
+        # Ouput:     normim - Image where the ridge regions are renormalised to
+        #                       have zero mean, unit standard deviation.
+        #              mask   - Mask indicating ridge-like regions of the image,
+        #                       0 for non ridge regions, 1 for ridge regions.
+        #              maskind - Vector of indices of locations within the mask.
+        #
+        # Suggested values for a 500dpi fingerprint image:
+        #
+        #   [normim, mask, maskind] = ridgesegment(im, 16, 0.1)
+        #
+        # See also: RIDGEORIENT, RIDGEFREQ, RIDGEFILTER
+
+        ### REFERENCES
+
+        # Peter Kovesi
+        # School of Computer Science & Software Engineering
+        # The University of Western Australia
+        # pk at csse uwa edu au
+        # http://www.csse.uwa.edu.au/~pk
+        rows, cols = img.shape
+        im = self.__normalise(img, 0, 1)  # normalise to get zero mean and unit standard deviation
+
+        new_rows = int(self.ridge_segment_blksze * np.ceil((float(rows)) / (float(self.ridge_segment_blksze))))
+        new_cols = int(self.ridge_segment_blksze * np.ceil((float(cols)) / (float(self.ridge_segment_blksze))))
+
+        padded_img = np.zeros((new_rows, new_cols))
+        stddevim = np.zeros((new_rows, new_cols))
+        padded_img[0:rows][:, 0:cols] = im
+        for i in range(0, new_rows, self.ridge_segment_blksze):
+            for j in range(0, new_cols, self.ridge_segment_blksze):
+                block = padded_img[i:i + self.ridge_segment_blksze][:, j:j + self.ridge_segment_blksze]
+
+                stddevim[i:i + self.ridge_segment_blksze][:, j:j + self.ridge_segment_blksze] = np.std(block) * np.ones(block.shape)
+
+        stddevim = stddevim[0:rows][:, 0:cols]
+        self._mask = stddevim > self.ridge_segment_thresh
+        mean_val = np.mean(im[self._mask])
+        std_val = np.std(im[self._mask])
+        self._normim = (im - mean_val) / (std_val)
+
+    def __ridge_orient(self):
+        # RIDGEORIENT - Estimates the local orientation of ridges in a fingerprint
+        #
+        # Usage:  [orientim, reliability, coherence] = ridgeorientation(im, gradientsigma,...
+        #                                             blocksigma, ...
+        #                                             orientsmoothsigma)
+        #
+        # Arguments:  im                - A normalised input image.
+        #             gradientsigma     - Sigma of the derivative of Gaussian
+        #                                 used to compute image gradients.
+        #             blocksigma        - Sigma of the Gaussian weighting used to
+        #                                 sum the gradient moments.
+        #             orientsmoothsigma - Sigma of the Gaussian used to smooth
+        #                                 the final orientation vector field.
+        #                                 Optional: if ommitted it defaults to 0
+        #
+        # Output:    orientim          - The orientation image in radians.
+        #                                 Orientation values are +ve clockwise
+        #                                 and give the direction *along* the
+        #                                 ridges.
+        #             reliability       - Measure of the reliability of the
+        #                                 orientation measure.  This is a value
+        #                                 between 0 and 1. I think a value above
+        #                                 about 0.5 can be considered 'reliable'.
+        #                                 reliability = 1 - Imin./(Imax+.001);
+        #             coherence         - A measure of the degree to which the local
+        #                                 area is oriented.
+        #                                 coherence = ((Imax-Imin)./(Imax+Imin)).^2;
+        #
+        # With a fingerprint image at a 'standard' resolution of 500dpi suggested
+        # parameter values might be:
+        #
+        #    [orientim, reliability] = ridgeorient(im, 1, 3, 3);
+        #
+        # See also: RIDGESEGMENT, RIDGEFREQ, RIDGEFILTER
+
+        ### REFERENCES
+
+        # May 2003      Original version by Raymond Thai,
+        # January 2005  Reworked by Peter Kovesi
+        # October 2011  Added coherence computation and orientsmoothsigma made optional
+        #
+        # School of Computer Science & Software Engineering
+        # The University of Western Australia
+        # pk at csse uwa edu au
+        # http://www.csse.uwa.edu.au/~pk
+
+        rows,cols = self._normim.shape
+        #Calculate image gradients.
+        sze = np.fix(6*self.gradient_sigma)
+        if np.remainder(sze,2) == 0:
+            sze = sze+1
+
+        gauss = cv2.getGaussianKernel(int(sze),self.gradient_sigma)
+        f = gauss * gauss.T
+
+        fy,fx = np.gradient(f)                               #Gradient of Gaussian
+
+        Gx = signal.convolve2d(self._normim, fx, mode='same')
+        Gy = signal.convolve2d(self._normim, fy, mode='same')
+
+        Gxx = np.power(Gx,2)
+        Gyy = np.power(Gy,2)
+        Gxy = Gx*Gy
+
+        #Now smooth the covariance data to perform a weighted summation of the data.
+        sze = np.fix(6*self.block_sigma)
+
+        gauss = cv2.getGaussianKernel(int(sze), self.block_sigma)
+        f = gauss * gauss.T
+
+        Gxx = ndimage.convolve(Gxx,f)
+        Gyy = ndimage.convolve(Gyy,f)
+        Gxy = 2*ndimage.convolve(Gxy,f)
+
+        # Analytic solution of principal direction
+        denom = np.sqrt(np.power(Gxy,2) + np.power((Gxx - Gyy),2)) + np.finfo(float).eps
+
+        sin2theta = Gxy/denom                   # Sine and cosine of doubled angles
+        cos2theta = (Gxx-Gyy)/denom
+
+
+        if self.orient_smooth_sigma:
+            sze = np.fix(6*self.orient_smooth_sigma)
+            if np.remainder(sze,2) == 0:
+                sze = sze+1
+            gauss = cv2.getGaussianKernel(int(sze), self.orient_smooth_sigma)
+            f = gauss * gauss.T
+            cos2theta = ndimage.convolve(cos2theta,f)                   # Smoothed sine and cosine of
+            sin2theta = ndimage.convolve(sin2theta,f)                   # doubled angles
+
+        self._orientim = np.pi/2 + np.arctan2(sin2theta,cos2theta)/2
+
+    def __ridge_freq(self):
+        # RIDGEFREQ - Calculates a ridge frequency image
+        #
+        # Function to estimate the fingerprint ridge frequency across a
+        # fingerprint image. This is done by considering blocks of the image and
+        # determining a ridgecount within each block by a call to FREQEST.
+        #
+        # Usage:
+        #  [freqim, medianfreq] =  ridgefreq(im, mask, orientim, blksze, windsze, ...
+        #                                    minWaveLength, maxWaveLength)
+        #
+        # Arguments:
+        #         im       - Image to be processed.
+        #         mask     - Mask defining ridge regions (obtained from RIDGESEGMENT)
+        #         orientim - Ridge orientation image (obtained from RIDGORIENT)
+        #         blksze   - Size of image block to use (say 32)
+        #         windsze  - Window length used to identify peaks. This should be
+        #                    an odd integer, say 3 or 5.
+        #         minWaveLength,  maxWaveLength - Minimum and maximum ridge
+        #                     wavelengths, in pixels, considered acceptable.
+        #
+        # Output:
+        #         freqim     - An image  the same size as im with  values set to
+        #                      the estimated ridge spatial frequency within each
+        #                      image block.  If a  ridge frequency cannot be
+        #                      found within a block, or cannot be found within the
+        #                      limits set by min and max Wavlength freqim is set
+        #                      to zeros within that block.
+        #         medianfreq - Median frequency value evaluated over all the
+        #                      valid regions of the image.
+        #
+        # Suggested parameters for a 500dpi fingerprint image
+        #   [freqim, medianfreq] = ridgefreq(im,orientim, 32, 5, 5, 15);
+        #
+
+        # See also: RIDGEORIENT, FREQEST, RIDGESEGMENT
+
+        # Reference:
+        # Hong, L., Wan, Y., and Jain, A. K. Fingerprint image enhancement:
+        # Algorithm and performance evaluation. IEEE Transactions on Pattern
+        # Analysis and Machine Intelligence 20, 8 (1998), 777 789.
+
+        ### REFERENCES
+
+        # Peter Kovesi
+        # School of Computer Science & Software Engineering
+        # The University of Western Australia
+        # pk at csse uwa edu au
+        # http://www.csse.uwa.edu.au/~pk
+
+        rows, cols = self._normim.shape
+        freq = np.zeros((rows, cols))
+
+        for r in range(0, rows - self.ridge_freq_blksze, self.ridge_freq_blksze):
+            for c in range(0, cols - self.ridge_freq_blksze, self.ridge_freq_blksze):
+                blkim = self._normim[r:r + self.ridge_freq_blksze][:, c:c + self.ridge_freq_blksze]
+                blkor = self._orientim[r:r + self.ridge_freq_blksze][:, c:c + self.ridge_freq_blksze]
+
+                freq[r:r + self.ridge_freq_blksze][:, c:c + self.ridge_freq_blksze] = self.__frequest(blkim, blkor)
+
+        self._freq = freq * self._mask
+        freq_1d = np.reshape(self._freq, (1, rows * cols))
+        ind = np.where(freq_1d > 0)
+
+        ind = np.array(ind)
+        ind = ind[1, :]
+
+        non_zero_elems_in_freq = freq_1d[0][ind]
+
+        self._mean_freq = np.mean(non_zero_elems_in_freq)
+        self._median_freq = np.median(non_zero_elems_in_freq)  # does not work properly
+
+        self._freq = self._mean_freq * self._mask
+
+    def __frequest(self, blkim, blkor):
+        # FREQEST - Estimate fingerprint ridge frequency within image block
+        #
+        # Function to estimate the fingerprint ridge frequency within a small block
+        # of a fingerprint image.  This function is used by RIDGEFREQ
+        #
+        # Usage:
+        #  freqim =  freqest(im, orientim, windsze, minWaveLength, maxWaveLength)
+        #
+        # Arguments:
+        #         im       - Image block to be processed.
+        #         orientim - Ridge orientation image of image block.
+        #         windsze  - Window length used to identify peaks. This should be
+        #                    an odd integer, say 3 or 5.
+        #         minWaveLength,  maxWaveLength - Minimum and maximum ridge
+        #                     wavelengths, in pixels, considered acceptable.
+        #
+        # Output:
+        #         freqim    - An image block the same size as im with all values
+        #                     set to the estimated ridge spatial frequency.  If a
+        #                     ridge frequency cannot be found, or cannot be found
+        #                     within the limits set by min and max Wavlength
+        #                     freqim is set to zeros.
+        #
+        # Suggested parameters for a 500dpi fingerprint image
+        #   freqim = freqest(im,orientim, 5, 5, 15);
+        #
+        # See also:  RIDGEFREQ, RIDGEORIENT, RIDGESEGMENT
+
+        ### REFERENCES
+
+        # Peter Kovesi
+        # School of Computer Science & Software Engineering
+        # The University of Western Australia
+        # pk at csse uwa edu au
+        # http://www.csse.uwa.edu.au/~pk
+
+        rows, cols = np.shape(blkim)
+
+        # Find mean orientation within the block. This is done by averaging the
+        # sines and cosines of the doubled angles before reconstructing the
+        # angle again.  This avoids wraparound problems at the origin.
+
+        cosorient = np.mean(np.cos(2 * blkor))
+        sinorient = np.mean(np.sin(2 * blkor))
+        orient = math.atan2(sinorient, cosorient) / 2
+
+        # Rotate the image block so that the ridges are vertical
+
+        # ROT_mat = cv2.getRotationMatrix2D((cols/2,rows/2),orient/np.pi*180 + 90,1)
+        # rotim = cv2.warpAffine(im,ROT_mat,(cols,rows))
+        rotim = scipy.ndimage.rotate(blkim, orient / np.pi * 180 + 90, axes=(1, 0), reshape=False, order=3,
+                                     mode='nearest')
+
+        # Now crop the image so that the rotated image does not contain any
+        # invalid regions.  This prevents the projection down the columns
+        # from being mucked up.
+
+        cropsze = int(np.fix(rows / np.sqrt(2)))
+        offset = int(np.fix((rows - cropsze) / 2))
+        rotim = rotim[offset:offset + cropsze][:, offset:offset + cropsze]
+
+        # Sum down the columns to get a projection of the grey values down
+        # the ridges.
+
+        proj = np.sum(rotim, axis=0)
+        dilation = scipy.ndimage.grey_dilation(proj, self.ridge_freq_windsze, structure=np.ones(self.ridge_freq_windsze))
+
+        temp = np.abs(dilation - proj)
+
+        peak_thresh = 2
+
+        maxpts = (temp < peak_thresh) & (proj > np.mean(proj))
+        maxind = np.where(maxpts)
+
+        rows_maxind, cols_maxind = np.shape(maxind)
+
+        # Determine the spatial frequency of the ridges by divinding the
+        # distance between the 1st and last peaks by the (No of peaks-1). If no
+        # peaks are detected, or the wavelength is outside the allowed bounds,
+        # the frequency image is set to 0
+
+        if (cols_maxind < 2):
+            return(np.zeros(blkim.shape))
+        else:
+            NoOfPeaks = cols_maxind
+            waveLength = (maxind[0][cols_maxind - 1] - maxind[0][0]) / (NoOfPeaks - 1)
+            if waveLength >= self.min_wave_length and waveLength <= self.max_wave_length:
+                return(1 / np.double(waveLength) * np.ones(blkim.shape))
+            else:
+                return(np.zeros(blkim.shape))
+
+    def __ridge_filter(self):
+        # RIDGEFILTER - enhances fingerprint image via oriented filters
+        #
+        # Function to enhance fingerprint image via oriented filters
+        #
+        # Usage:
+        #  newim =  ridgefilter(im, orientim, freqim, kx, ky, showfilter)
+        #
+        # Arguments:
+        #         im       - Image to be processed.
+        #         orientim - Ridge orientation image, obtained from RIDGEORIENT.
+        #         freqim   - Ridge frequency image, obtained from RIDGEFREQ.
+        #         kx, ky   - Scale factors specifying the filter sigma relative
+        #                    to the wavelength of the filter.  This is done so
+        #                    that the shapes of the filters are invariant to the
+        #                    scale.  kx controls the sigma in the x direction
+        #                    which is along the filter, and hence controls the
+        #                    bandwidth of the filter.  ky controls the sigma
+        #                    across the filter and hence controls the
+        #                    orientational selectivity of the filter. A value of
+        #                    0.5 for both kx and ky is a good starting point.
+        #         showfilter - An optional flag 0/1.  When set an image of the
+        #                      largest scale filter is displayed for inspection.
+        #
+        # Output:
+        #         newim    - The enhanced image
+        #
+        # See also: RIDGEORIENT, RIDGEFREQ, RIDGESEGMENT
+
+        # Reference:
+        # Hong, L., Wan, Y., and Jain, A. K. Fingerprint image enhancement:
+        # Algorithm and performance evaluation. IEEE Transactions on Pattern
+        # Analysis and Machine Intelligence 20, 8 (1998), 777 789.
+
+        ### REFERENCES
+
+        # Peter Kovesi
+        # School of Computer Science & Software Engineering
+        # The University of Western Australia
+        # pk at csse uwa edu au
+        # http://www.csse.uwa.edu.au/~pk
+
+        im = np.double(self._normim)
+        rows, cols = im.shape
+        newim = np.zeros((rows, cols))
+
+        freq_1d = np.reshape(self._freq, (1, rows * cols))
+        ind = np.where(freq_1d > 0)
+
+        ind = np.array(ind)
+        ind = ind[1, :]
+
+        # Round the array of frequencies to the nearest 0.01 to reduce the
+        # number of distinct frequencies we have to deal with.
+
+        non_zero_elems_in_freq = freq_1d[0][ind]
+        non_zero_elems_in_freq = np.double(np.round((non_zero_elems_in_freq * 100))) / 100
+
+        unfreq = np.unique(non_zero_elems_in_freq)
+
+        # Generate filters corresponding to these distinct frequencies and
+        # orientations in 'angleInc' increments.
+
+        sigmax = 1 / unfreq[0] * self.kx
+        sigmay = 1 / unfreq[0] * self.ky
+
+        sze = int(np.round(3 * np.max([sigmax, sigmay])))
+
+        x, y = np.meshgrid(np.linspace(-sze, sze, (2 * sze + 1)), np.linspace(-sze, sze, (2 * sze + 1)))
+
+        reffilter = np.exp(-(((np.power(x, 2)) / (sigmax * sigmax) + (np.power(y, 2)) / (sigmay * sigmay)))) * np.cos(
+            2 * np.pi * unfreq[0] * x)        # this is the original gabor filter
+
+        filt_rows, filt_cols = reffilter.shape
+
+        angleRange = int(180 / self.angleInc)
+
+        gabor_filter = np.array(np.zeros((angleRange, filt_rows, filt_cols)))
+
+        for o in range(0, angleRange):
+            # Generate rotated versions of the filter.  Note orientation
+            # image provides orientation *along* the ridges, hence +90
+            # degrees, and imrotate requires angles +ve anticlockwise, hence
+            # the minus sign.
+
+            rot_filt = scipy.ndimage.rotate(reffilter, -(o * self.angleInc + 90), reshape=False)
+            gabor_filter[o] = rot_filt
+
+        # Find indices of matrix points greater than maxsze from the image
+        # boundary
+
+        maxsze = int(sze)
+
+        temp = self._freq > 0
+        validr, validc = np.where(temp)
+
+        temp1 = validr > maxsze
+        temp2 = validr < rows - maxsze
+        temp3 = validc > maxsze
+        temp4 = validc < cols - maxsze
+
+        final_temp = temp1 & temp2 & temp3 & temp4
+
+        finalind = np.where(final_temp)
+
+        # Convert orientation matrix values from radians to an index value
+        # that corresponds to round(degrees/angleInc)
+
+        maxorientindex = np.round(180 / self.angleInc)
+        orientindex = np.round(self._orientim / np.pi * 180 / self.angleInc)
+
+        # do the filtering
+        for i in range(0, rows):
+            for j in range(0, cols):
+                if (orientindex[i][j] < 1):
+                    orientindex[i][j] = orientindex[i][j] + maxorientindex
+                if (orientindex[i][j] > maxorientindex):
+                    orientindex[i][j] = orientindex[i][j] - maxorientindex
+        finalind_rows, finalind_cols = np.shape(finalind)
+        sze = int(sze)
+        for k in range(0, finalind_cols):
+            r = validr[finalind[0][k]]
+            c = validc[finalind[0][k]]
+
+            img_block = im[r - sze:r + sze + 1][:, c - sze:c + sze + 1]
+
+            newim[r][c] = np.sum(img_block * gabor_filter[int(orientindex[r][c]) - 1])
+
+        self._binim = newim < self.ridge_filter_thresh
+
+    def save_enhanced_image(self, path):
+        # saves the enhanced image at the specified path
+        cv2.imwrite(path, 255 - (255 * self._binim))
+
+        # image = (255 * self._binim)
+        # print(image)
+        # print(255 - image)
+
+    def enhance(self, img, resize=False):
+        # main function to enhance the image.
+        # calls all other subroutines
+
+        if(resize):
+            rows, cols = np.shape(img)
+            aspect_ratio = np.double(rows) / np.double(cols)
+
+            new_rows = 450                      # randomly selected number
+            new_cols = new_rows / aspect_ratio
+
+            img = cv2.resize(img, (int(new_cols), int(new_rows)))
+
+        self.__ridge_segment(img)   # normalise the image and find a ROI
+        self.__ridge_orient()       # compute orientation image
+        self.__ridge_freq()         # compute major frequency of ridges
+        self.__ridge_filter()       # filter the image using oriented gabor filter
+        return(self._binim)

README.md

@@ -1,10 +1,49 @@
 ---
-title: Contactless To Contactbased Fp Matching
-emoji: 🏃
+title: Fingerprint Matcher
+emoji: 🧬
 colorFrom: blue
-colorTo: yellow
+colorTo: green
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Fingerprint Comparison API
+
+This application provides a REST API to compare two fingerprint images (contactless vs. contact-based) using a Siamese Neural Network.
+
+## 🚀 How to use
+
+### API Endpoint
+**POST** `/compare`
+
+### Parameters
+| Key | Type | Description |
+|---|---|---|
+| `img_1` | File | First fingerprint image |
+| `img_2` | File | Second fingerprint image |
+| `type_1` | Text | `contactless` or `contactbased` (Default: contactless) |
+| `type_2` | Text | `contactless` or `contactbased` (Default: contactbased) |
+
+### Example Request (cURL)
+CMD local curl command
+```bash
+curl -X POST http://127.0.0.1:5000/compare -F "img_1=@C:\\SagarKV\\sol9x\\geekykant\\contactless_2d_fingerprint_images\\second_session\\p1\\p6.bmp" -F "type_1=contactless" -F "img_2=@C:\\SagarKV\\sol9x\\geekykant\\contact-based_fingerprints\\second_session\\1_6.jpg" -F "type_2=contactbased"
+```
+
+## 🛠 Project Structure
+
+* `app.py`: Main Flask application.
+* `enhancer.py`: Contains `basicEnhancing` and `advancedEnhancing` logic.
+* `model/12_120_fp160.h5`: The trained Keras model.
+
+```
+
+---
+
+### 💡 Final Tips for Success
+
+1.  **Gunicorn vs. App.run**: In my Dockerfile, I switched the execution to `gunicorn`. It handles multiple requests much better than the development server you have at the bottom of `app.py`.
+2.  **Model Path**: Ensure your model file is located at `./model/12_120_fp160.h5` in your repository.
+3.  **Port 7860**: Hugging Face defaults to `7860`. I've set the Dockerfile and the README to use this to ensure the "Open" button on your Space actually works.
+

app.py

@@ -0,0 +1,182 @@
+from flask import Flask, request, jsonify
+import cv2
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+import os
+from os.path import join, dirname
+
+# Import your custom enhancement functions
+from enhancer import basicEnhancing, advancedEnhancing
+
+app = Flask(__name__)
+
+# --- Configuration & Model Loading ---
+DIRNAME = dirname(__file__)
+MODEL_PATH = join(DIRNAME, 'model', '12_120_fp160.h5')
+
+# Load model once at startup
+try:
+    model = load_model(MODEL_PATH, compile=False)
+    print(f"Model loaded successfully from: {MODEL_PATH}")
+except Exception as e:
+    print(f"Critical Error: Could not load model: {e}")
+
+def preprocess_fingerprint(image_bytes, image_type):
+    """
+    image_type: 'contactless' or 'contactbased'
+    """
+    # Convert bytes to cv2 image
+    nparr = np.frombuffer(image_bytes, np.uint8)
+    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    
+    if img is None:
+        return None
+
+    # Apply conditional enhancement logic
+    if image_type == 'contactless':
+        # Contactless needs both basic and advanced
+        enhanced = advancedEnhancing(basicEnhancing(img))
+    else:
+        # Contact-based needs only advanced
+        enhanced = advancedEnhancing(img)
+    
+    # Standardize for the model
+    resized = cv2.resize(enhanced, (160, 160))
+    # Siamese models usually expect grayscale (1 channel) normalized to [0, 1]
+    normalized = resized.reshape((1, 160, 160, 1)).astype(np.float32) / 255.0
+    return normalized
+
+@app.route('/compare', methods=['POST'])
+def compare_fingerprints():
+    # Expecting: img_1 (file), img_2 (file), type_1 (text), type_2 (text)
+    if 'img_1' not in request.files or 'img_2' not in request.files:
+        return jsonify({"error": "Missing image files"}), 400
+
+    img_1_file = request.files['img_1'].read()
+    img_2_file = request.files['img_2'].read()
+    
+    # Defaults to 'contactless' if not specified
+    type_1 = request.form.get('type_1', 'contactless')
+    type_2 = request.form.get('type_2', 'contactbased')
+
+    # 1. Preprocess both images based on their types
+    processed_1 = preprocess_fingerprint(img_1_file, type_1)
+    processed_2 = preprocess_fingerprint(img_2_file, type_2)
+
+    if processed_1 is None or processed_2 is None:
+        return jsonify({"error": "Failed to process images"}), 400
+
+    # 2. Perform Inference
+    prediction = model.predict([processed_1, processed_2], verbose=0)
+    score = float(prediction[0][0])
+    accuracy = round(score * 100, 2)
+
+    # 3. Return JSON response
+    return jsonify({
+        "score": score,
+        "match_percentage": accuracy,
+        "is_match": score > 0.80,
+        "metadata": {
+            "img_1_type": type_1,
+            "img_2_type": type_2
+        }
+    })
+
+if __name__ == '__main__':
+    # Use threaded=False if your CV2/Tensorflow version has issues with local threads
+    app.run(host='0.0.0.0', port=5000, debug=True)
+
+
+
+# import os
+# import threading
+# import cv2
+# import numpy as np
+# from flask import Flask, request, jsonify
+# from tensorflow.keras.models import load_model
+
+# from enhancer import basicEnhancing, advancedEnhancing
+
+# app = Flask(__name__)
+
+# BASE_DIR = os.path.dirname(__file__)
+# MODEL_PATH = os.path.join(BASE_DIR, "model", "12_120_fp160.h5")
+
+# # Load once at startup
+# model = load_model(MODEL_PATH, compile=False)
+
+# # Guard predict if you run Flask threaded / multiple threads
+# predict_lock = threading.Lock()
+
+# def _read_image_from_filestorage(fs):
+#     data = fs.read()
+#     arr = np.frombuffer(data, dtype=np.uint8)
+#     img = cv2.imdecode(arr, cv2.IMREAD_COLOR)  # keep color for enhancers if needed
+#     return img
+
+# def preprocess(img_bgr, img_type: str):
+#     if img_bgr is None:
+#         raise ValueError("Invalid image (could not decode).")
+
+#     img_type = (img_type or "").strip().lower()
+#     if img_type not in ("contactless", "contactbased"):
+#         raise ValueError("type must be 'contactless' or 'contactbased'.")
+
+#     # Apply your rule:
+#     # contactless: basic + advanced
+#     # contactbased: advanced only
+#     if img_type == "contactless":
+#         en = advancedEnhancing(basicEnhancing(img_bgr))
+#     else:
+#         en = advancedEnhancing(img_bgr)
+
+#     # Ensure grayscale uint8
+#     if en is None:
+#         raise ValueError("Enhancer returned None.")
+#     if len(en.shape) > 2:
+#         en = cv2.cvtColor(en, cv2.COLOR_BGR2GRAY)
+#     en = np.array(en, dtype=np.uint8)
+
+#     # Resize to model input
+#     if en.shape != (160, 160):
+#         en = cv2.resize(en, (160, 160))
+
+#     # Normalize to float32, shape (1,160,160,1)
+#     x = en.reshape((1, 160, 160, 1)).astype(np.float32) / 255.0
+#     return x
+
+# def siamese_score(x1, x2):
+#     # model.predict may misbehave under multithreading in some setups,
+#     # so keep a lock unless you control workers/threads explicitly.
+#     with predict_lock:
+#         pred = model.predict([x1, x2], verbose=0)
+#     return float(pred[0][0])
+
+# @app.route("/api/match", methods=["POST"])
+# def match():
+#     if "img1" not in request.files or "img2" not in request.files:
+#         return jsonify({"error": "Both img1 and img2 are required."}), 400
+
+#     img1_type = request.form.get("type1", "")
+#     img2_type = request.form.get("type2", "")
+
+#     try:
+#         img1 = _read_image_from_filestorage(request.files["img1"])
+#         img2 = _read_image_from_filestorage(request.files["img2"])
+
+#         x1 = preprocess(img1, img1_type)
+#         x2 = preprocess(img2, img2_type)
+
+#         score = siamese_score(x1, x2)
+#         return jsonify({
+#             "score": score,
+#             "score_percent": round(score * 100.0, 5),
+#             "type1": img1_type,
+#             "type2": img2_type
+#         })
+#     except Exception as e:
+#         return jsonify({"error": str(e)}), 400
+
+# if __name__ == "__main__":
+#     app.run(host="0.0.0.0", port=5000, debug=True)

enhancer.py

@@ -0,0 +1,76 @@
+import cv2
+import numpy as np
+import os
+
+# # Fix for older libraries using deprecated numpy aliases
+# float = float
+# int = int
+
+from FingerprintImageEnhancer import FingerprintImageEnhancer
+
+def basicEnhancing(img):
+    if len(img.shape) == 3:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    ret, img = cv2.threshold(img, 140, 255, cv2.THRESH_TOZERO)
+    img = cv2.medianBlur(img, 5)
+    th3 = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                cv2.THRESH_BINARY, 43, 1)
+    im = cv2.normalize(th3, None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX)
+    res, im = cv2.threshold(im, 64, 255, cv2.THRESH_BINARY)
+    cv2.floodFill(im, None, (0,0), 0)
+    return im
+
+def advancedEnhancing(img):
+    if len(img.shape) == 3:
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+    image_enhancer = FingerprintImageEnhancer() 
+    out = image_enhancer.enhance(img)
+    # Convert normalized output back to 0-255 uint8 format
+    out_image = (255 - (255 * out)).astype(np.uint8)
+    return out_image
+
+
+if __name__ == '__main__':
+    # --- Execution Logic ---
+    image_path = r"C:\Users\SAGAR KESHAVE\Downloads\fore_tip.jpeg"
+    # image_path = r"C:\SagarKV\sol9x\geekykant\contactless_2d_fingerprint_images\first_session\p247\p1.bmp"
+    # image_path = r"C:\SagarKV\sol9x\geekykant\contact-based_fingerprints\second_session\13_3.jpg"
+    original = cv2.imread(image_path)
+
+    if original is None:
+        print(f"Error: Image not found at {image_path}")
+    else:
+        print("Processing... Please wait (Advanced enhancement takes time).")
+        
+        # Run Enhancements
+        basic_res = basicEnhancing(original)
+        advanced_res = advancedEnhancing(basic_res)
+
+        # 1. Save individual files
+        cv2.imwrite("result_basic.jpg", basic_res)
+        cv2.imwrite("result_advanced.jpg", advanced_res)
+        print("Individual results saved: result_basic.jpg and result_advanced.jpg")
+
+        # 2. Create and save a Comparison Strip
+        h, w = original.shape[:2]
+        # Resize for the comparison strip (making them uniform height)
+        target_h = 800
+        scale = target_h / h
+        target_w = int(w * scale)
+
+        res_orig = cv2.resize(original, (target_w, target_h))
+        res_basic = cv2.resize(cv2.cvtColor(basic_res, cv2.COLOR_GRAY2BGR), (target_w, target_h))
+        res_adv = cv2.resize(cv2.cvtColor(advanced_res, cv2.COLOR_GRAY2BGR), (target_w, target_h))
+
+        comparison = np.hstack([res_orig, res_basic, res_adv])
+        
+        output_path = "comparison_output.jpg"
+        cv2.imwrite(output_path, comparison)
+        
+        print(f"Comparison strip saved successfully as: {os.path.abspath(output_path)}")
+
+
+
+
+
+

main.py

@@ -0,0 +1,136 @@
+import os, sys
+import predictor
+import enhancer
+import utils
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+from flask import Flask, render_template, request, redirect, url_for, Response
+import cv2, jsonpickle, numpy as np
+
+# start flask
+app = Flask(__name__, template_folder='templates')
+app.config['MAX_CONTENT_LENGTH'] = 2 * 1024 * 1024 #16 MB
+
+# render default webpage
+@app.route('/')
+def home():
+    stored_fp = utils.getAllImagesFromDatabase()
+    return render_template('database.html', fps=stored_fp, detection_page=False, title="Fingerprint Prediction")
+
+# render default analyze page
+@app.route('/analyze')
+def analyze():
+    return render_template('analyze.html')
+
+# when the post method detect, then redirect to success function
+@app.route('/two_image_prediction', methods=['POST', 'GET'])
+def get_data():
+    if request.method == 'POST':
+        fp1 = request.files['fp1'].read()
+        fp2 = request.files['fp2'].read()
+
+        fp1img = np.frombuffer(fp1,np.uint8)
+        fp2img = np.frombuffer(fp2,np.uint8)
+
+        fp1img = cv2.imdecode(fp1img,cv2.IMREAD_GRAYSCALE)
+        fp2img = cv2.imdecode(fp2img,cv2.IMREAD_GRAYSCALE)
+
+        #resize image into 160 x 160 if not.
+        if fp1img.shape != (160, 160):
+            fp1img = cv2.resize(fp1img, (160, 160))
+        if fp2img.shape != (160, 160):
+            fp2img = cv2.resize(fp2img, (160, 160))
+
+        prediction_result = -1
+
+        try:
+            prediction = predictor.two_image_prediction(fp1img, fp2img) * 100
+            prediction_result = float("%.5f" %prediction)
+        except Exception as e:
+            print(e)
+            return Response(response={'status': 'Predction Error'}, status=503, mimetype="application/json")
+
+        response = {'accuracy': prediction_result, 'status': 'up & running'}
+        response_pickled = jsonpickle.encode(response)
+        return Response(response=response_pickled, status=200, mimetype="application/json")
+
+# render database webpage displaying all stored fingerprints
+@app.route('/database')
+def database_home():
+    stored_fp = utils.getAllImagesFromDatabase()
+    return render_template('database.html', fps=stored_fp, detection_page=True, title="Fingerprint Database")
+
+# when the post method detect, then redirect to success function
+@app.route('/upload_to_db', methods=['POST'])
+def store_fingerprint():
+    if request.method == 'POST':
+        default_label = 'not_labelled'
+        label = request.form.get('fp_label', default_label)
+        fp = request.files['fp1'].read()
+
+        fpimg = np.frombuffer(fp, np.uint8)
+        fpimg = cv2.imdecode(fpimg, cv2.IMREAD_GRAYSCALE)
+
+        enhanced_image = enhancer.basicEnhancing(fpimg)
+        enhanced_image = enhancer.advancedEnhancing(enhanced_image)
+        utils.saveImageToDatabase(label, enhanced_image)
+
+        response = {'status': 'Saved successfully!'}
+        response_pickled = jsonpickle.encode(response)
+        return Response(response=response_pickled, status=200, mimetype="application/json")
+
+@app.route('/predict_with_db', methods=['POST'])
+def predictWithDb():
+    if request.method == 'POST':
+        fp = request.files['fp1'].read()
+
+        fpimg = np.frombuffer(fp, np.uint8)
+        fpimg = cv2.imdecode(fpimg, cv2.IMREAD_GRAYSCALE)
+
+        out1 = enhancer.basicEnhancing(fpimg)
+        main_img = enhancer.advancedEnhancing(out1)
+        all_db_imgs = utils.getAllImagesFromDatabase()
+
+        pred_result = None
+        try:
+            pred_result = predictor.getPredictionDb(main_img, all_db_imgs)
+            pred_result['best_pred']['accuracy'] = float("%.5f" %(pred_result['best_pred']['accuracy']))
+        except Exception as e:
+            print(e)
+            return Response(response={'status': 'Predction Problem! Check image size, maybe.'}, status=503, mimetype="application/json")
+
+        response_pickled = jsonpickle.encode(pred_result)
+        return Response(response=response_pickled, status=200, mimetype="application/json")
+
+#get all stored fingerprints database -> json
+@app.route('/get_db')
+def getDb():
+    response = {'status': 'successful'}
+    response['data'] = utils.getAllImagesFromDatabase()
+    response_pickled = jsonpickle.encode(response)
+    return Response(response=response_pickled, status=200, mimetype="application/json")
+
+@app.route('/test')
+def test():
+    result = ""
+    for i in range(1, 5):
+        img1 = cv2.imread(f'{i}.png', cv2.IMREAD_GRAYSCALE)
+        for j in range(1,5):
+            img2 = cv2.imread(f'{j}.png', cv2.IMREAD_GRAYSCALE)
+            result +=  f"{i}-{j} --> {predictor.two_image_prediction(img1, img2) * 100} \n"
+        result += "\n"
+    print(result)
+    return Response(response=result, status=200, mimetype="text/plain")
+
+@app.errorhandler(413)
+def request_entity_too_large(error):
+    return 'File Too Large (Must be less than 2MB)', 413
+
+@app.errorhandler(503)
+def request_model_not_responding(error):
+    return 'Model is Not responding', 503
+
+
+if __name__ == "__main__":
+        
+        # app.run(debug=True, host= '0.0.0.0')
+        app.run(debug=True)

model/12_120_fp160.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34381b3058914524b704359627deea251d7b99f86ac5610ca741e388c4d8bd48
+size 53283376

model/12_120_fp160.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c4c89a125f38abe84a7bb4c5ef1c4623c98b8b77bca6a6d2259e17d4e9dae4b
+size 53293574

model/12_120_fp160_feature.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:512b61866a32e9f60acdc5018f0f12a7156432aa6b4168dddd2c5f07a4e304bb
+size 394056

model/12_120_fp160_feature.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:facab1bf3f4ff81925dab7c8df0ebb57fc2f5eaad178e05244222ccb19a72112
+size 399335

model/model_checkpoint.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd0e37a6ac1eb3890335895b9884b28c86d73d754fd89c98b4480fc4278e63a7
+size 53294023

predictor.py

@@ -0,0 +1,367 @@
+import cv2 
+import numpy as np
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from os.path import join, dirname, exists
+import os
+
+# Set up paths relative to this script
+dirname_val = dirname(__file__)
+# Points to your .h5 model
+model_path = join(dirname_val, 'model', '12_120_fp160.h5')
+
+# Load the Keras model
+try:
+    # compile=False is used because we only need the model for prediction (inference)
+    model = load_model(model_path, compile=False)
+    print(f"Model loaded successfully from: {model_path}")
+except Exception as e:
+    print(f"Error loading model: {e}")
+
+# Contactless images testing (The Siamese Comparison)
+def two_image_prediction(np_img1, np_img2):
+    
+    # Ensure images are 160x160 and float32 normalized
+    input1_img = np_img1.reshape((1, 160, 160, 1)).astype(np.float32) / 255.0
+    input2_img = np_img2.reshape((1, 160, 160, 1)).astype(np.float32) / 255.0
+    
+    # Keras prediction for Siamese (two inputs)
+    # verbose=0 keeps the console clean during the database loop
+    pred_right = model.predict([input1_img, input2_img], verbose=0)
+
+    # Optional: Save images for visual debugging
+    db_path = join(dirname_val, 'static', 'test_preds')
+    if not exists(db_path):
+        os.makedirs(db_path)
+    
+    cv2.imwrite(join(db_path, 'last_query.jpg'), np_img1)
+    cv2.imwrite(join(db_path, 'last_gallery.jpg'), np_img2)
+
+    # Return the similarity score (usually index [0][0])
+    return pred_right[0][0]
+
+# Testing with all other database images
+def getPredictionDb(main_img, all_db_imgs):
+    best_pred = 0.00
+    best_html_id = "db_null"
+    matched_person = "null"
+    all_preds = []
+
+    # Ensure query image is grayscale and correct type
+    if len(main_img.shape) > 2:
+        main_img = cv2.cvtColor(main_img, cv2.COLOR_BGR2GRAY)
+    
+    main_img = np.array(main_img, dtype='uint8')
+
+    # Resize to 160x160 if not already
+    if main_img.shape != (160, 160):
+        main_img = cv2.resize(main_img, (160, 160))
+
+    # Loop through the database provided by utils.getAllImagesFromDatabase()
+    for file in all_db_imgs:
+        # Construct path: remove leading '/' if present to join correctly
+        clean_url = file['url'].lstrip('/')
+        file_url = join(dirname_val, clean_url)
+        
+        db_img = cv2.imread(file_url, cv2.IMREAD_GRAYSCALE)
+        if db_img is None:
+            continue
+
+        if db_img.shape != (160, 160):
+            db_img = cv2.resize(db_img, (160, 160))
+
+        # Perform the 1-to-1 match
+        score = float(two_image_prediction(main_img, db_img))
+        
+        # Rounding for clean JSON response
+        pred_accuracy = float("%.5f" % (score * 100))
+        
+        all_preds.append({
+            "html_id": f"db_{file['label']}", 
+            "accuracy": pred_accuracy
+        })
+
+        # Update best match if this score is higher
+        if score > best_pred:
+            best_pred = score
+            matched_person = file['label']
+            best_html_id = f"db_{matched_person}"
+
+    # Structure the final result
+    result = {
+        "all_preds": all_preds, 
+        "best_pred": {
+            "html_id": best_html_id, 
+            "accuracy": float("%.5f" % (best_pred * 100)), 
+            "matched_person": matched_person
+        }
+    }
+    return result
+
+
+# if __name__ == "__main__":
+    # print("\n--- Starting Real Image Predictor Test ---")
+
+    # # 1. Update these paths to your real fingerprint images
+    # # Example: one of your extracted fingertips or an original image
+    # path_image_1 = r"C:\SagarKV\sol9x\geekykant\contactless_2d_fingerprint_images\second_session\p1\p4.bmp"
+    # path_image_2 = r"C:\SagarKV\sol9x\geekykant\contactless_2d_fingerprint_images\second_session\p240\p1.bmp"
+    # # Use same for 100%, different for comparison
+
+    # # Load and Preprocess
+    # img1 = cv2.imread(path_image_1, cv2.IMREAD_GRAYSCALE)
+    # img2 = cv2.imread(path_image_2, cv2.IMREAD_GRAYSCALE)
+
+    # if img1 is None or img2 is None:
+    #     print("Error: One of the images could not be loaded. Check your paths!")
+    # else:
+    #     # Resize to 160x160 as required by your model
+    #     img1_res = cv2.resize(img1, (160, 160))
+    #     img2_res = cv2.resize(img2, (160, 160))
+
+    #     # 2. Test 1-to-1 Prediction
+    #     print(f"Comparing: {os.path.basename(path_image_1)} vs {os.path.basename(path_image_2)}")
+    #     try:
+    #         score = two_image_prediction(img1_res, img2_res)
+    #         print(f"Match Score (Raw): {score:.6f}")
+    #         print(f"Match Confidence: {score * 100:.2f}%")
+            
+    #         if score > 0.85: # Typical threshold for Siamese networks
+    #             print("Result: MATCH FOUND!")
+    #         else:
+    #             print("Result: NO MATCH.")
+    #     except Exception as e:
+    #         print(f"Error during 1-to-1 test: {e}")
+
+    # # 3. Test Database Search using your actual DB folder
+    # print("\nTesting getPredictionDb with existing static database...")
+    # from utils import getAllImagesFromDatabase
+    
+    # try:
+    #     real_db = getAllImagesFromDatabase()
+    #     if not real_db:
+    #         print("Database is empty. Upload some images via the web app first.")
+    #     else:
+    #         db_results = getPredictionDb(img1_res, real_db)
+    #         print(f"Database Search Result:")
+    #         print(f"  Best Match Found: {db_results['best_pred']['matched_person']}")
+    #         print(f"  Accuracy: {db_results['best_pred']['accuracy']}%")
+    # except Exception as e:
+    #     print(f"Error during DB search test: {e}")
+
+    # print("\n--- Real Test Complete ---")
+    
+if __name__ == "__main__":
+    from enhancer import basicEnhancing, advancedEnhancing
+    
+    print("\n--- Starting Enhanced Image Predictor Test ---")
+
+    path_image_1 = r"C:\SagarKV\sol9x\geekykant\contact-based_fingerprints\second_session\1_1.jpg"
+    path_image_2 = r"C:\SagarKV\sol9x\geekykant\contact-based_fingerprints\second_session\1_4.jpg"
+
+	# # # Matched - 80%
+    # path_image_1 = r"C:\SagarKV\sol9x\geekykant\contactless_2d_fingerprint_images\second_session\p240\p6.bmp"
+    # path_image_2 = r"C:\SagarKV\sol9x\geekykant\contact-based_fingerprints\second_session\240_6.jpg"
+
+    # 1. Load images
+    img1 = cv2.imread(path_image_1)
+    img2 = cv2.imread(path_image_2)
+
+    if img1 is None or img2 is None:
+        print("Error loading images.")
+    else:
+        print("Enhancing images to remove background bias...")
+        # 2. Process images EXACTLY like your web app does
+        # Basic + Advanced (Gabor filters) makes ridges the only visible feature
+        en1 = advancedEnhancing(basicEnhancing(img1))
+        
+        en2 = advancedEnhancing(basicEnhancing(img2))
+        # en2 = advancedEnhancing(img2)  # # IndexError: index 0 is out of bounds for axis 0 with size 0
+        
+        # 3. Resize the CLEANED images
+        img1_res = cv2.resize(en1, (160, 160))
+        
+        img2_res = cv2.resize(en2, (160, 160))
+
+        # 4. Predict 
+        score = two_image_prediction(img1_res, img2_res)
+        
+        print(f"\nComparing: {os.path.basename(path_image_1)} vs {os.path.basename(path_image_2)}")
+        print(f"Match Score: {score * 100:.2f}%")
+        
+        if score > 0.80: # Higher threshold for enhanced images
+            print("Result: MATCH FOUND!")
+        else:
+            print("Result: NO MATCH")
+    
+
+    # # Both advance test
+    # from tqdm import tqdm
+    # import json
+    # from enhancer import basicEnhancing, advancedEnhancing
+    # import time 
+    # # --- CONFIGURATION ---
+    # CONTACTLESS_BASE = r"C:\SagarKV\sol9x\geekykant\contactless_2d_fingerprint_images\second_session"
+    # CONTACT_BASE = r"C:\SagarKV\sol9x\geekykant\contact-based_fingerprints\second_session"
+    # THRESHOLD = 0.70
+    
+    # matched_pairs = []
+    # total_tested = 0
+
+    # print(f"\n--- Starting Batch Test: Contactless vs Contact-Based ---")
+    # total_start = time.time()
+    # # Loop through the 240 subjects
+    # for p_id in tqdm(range(61, 121), desc="Processing IDs"):
+    #     for c_id in range(1, 7):
+    #         # Your pattern: contactless/p{id}/p6.bmp vs contact/{id}_6.jpg
+    #         path1 = join(CONTACTLESS_BASE, f"p{p_id}", f"p{c_id}.bmp")
+    #         path2 = join(CONTACT_BASE, f"{p_id}_{c_id}.jpg")
+
+    #         if not exists(path1) or not exists(path2):
+    #             # Some IDs might be missing in real datasets
+    #             continue
+
+            
+    #         # print(f"[{total_tested}/240] Processing ID: {p_id}...", end="\r")
+
+    #         try:
+    #             # 1. Load
+    #             img1 = cv2.imread(path1)
+    #             img2 = cv2.imread(path2)
+
+    #             # 2. Enhance (Wrapped in enhancer logic to avoid crashes)
+    #             en1 = advancedEnhancing(basicEnhancing(img1))
+    #             en2 = advancedEnhancing(img2)
+
+    #             # 3. Resize & Predict
+    #             img1_res = cv2.resize(en1, (160, 160))
+    #             img2_res = cv2.resize(en2, (160, 160))
+                
+    #             score = float(two_image_prediction(img1_res, img2_res))
+    #             accuracy = score * 100
+    #             total_tested += 1
+
+    #             if score > THRESHOLD:
+    #                 match_data = {
+    #                     "id": p_id,
+    #                     "c_id" : c_id,
+    #                     "contactless_path": path1,
+    #                     "contact_path": path2,
+    #                     "accuracy": f"{accuracy:.2f}%",
+    #                     "status": "MATCH FOUND"
+    #                 }
+    #                 matched_pairs.append(match_data)
+    #                 tqdm.write(f"P_ID {p_id} C_ID {c_id}: MATCH FOUND ({accuracy:.2f}%)")
+
+    #         except Exception as e:
+    #             # print(f"\nError processing ID {p_id}: {e}")
+    #             tqdm.write(f"Error processing p ID {p_id} c ID {c_id} : {e}")
+
+    # # Prepare the final data structure
+    # results_to_save = {
+    #     "summary": f"Found {len(matched_pairs)} out of {total_tested} pairs.",
+    #     "total_tested": total_tested,
+    #     "total_matched": len(matched_pairs),
+    #     "results": matched_pairs  # Your list of match dictionaries
+    # }
+
+    # # Save individual JSON
+    # output_file = "61_120_Both_vs_advance.json"
+    # with open(output_file, 'w') as f:
+    #     json.dump(results_to_save, f, indent=4)
+    
+    # print(f"\n--- Total Time: {time.time() - total_start:.2f}s ---")
+    # print(f"Finished. Found {len(matched_pairs)} out of {total_tested} matches.")
+
+    # print(f"\n--- Batch Test Complete ---")
+    # print(f"Total Tested: {total_tested}")
+    # print(f"Total Matches Found: {len(matched_pairs)}")
+    # print(f"Results saved to: {os.path.abspath(output_file)}")
+
+
+
+
+
+
+
+# "-----------------------------------------------------------------------------------"
+
+    # import os
+    # import cv2
+    # import json
+    # from os.path import join, exists
+    # from enhancer import basicEnhancing, advancedEnhancing
+
+    # # --- CONFIGURATION ---
+    # CONTACTLESS_BASE = r"C:\SagarKV\sol9x\geekykant\contactless_2d_fingerprint_images\second_session"
+    # CONTACT_BASE = r"C:\SagarKV\sol9x\geekykant\contact-based_fingerprints\second_session"
+    # THRESHOLD = 0.70
+
+    # # Define the enhancement "pipelines"
+    # strategies = {
+    #     "Basic": lambda x: basicEnhancing(x),
+    #     "Advanced": lambda x: advancedEnhancing(x),
+    #     "Both": lambda x: advancedEnhancing(basicEnhancing(x))
+    # }
+
+    # def run_test_combination(name1, func1, name2, func2):
+    #     matched_pairs = []
+    #     total_tested = 0
+    #     filename = f"results_{name1}_vs_{name2}.json"
+        
+    #     print(f"\n--- Testing: Img1({name1}) vs Img2({name2}) ---")
+
+    #     for p_id in range(1, 241):
+    #         for c_id in range(1,7):
+    #             print(f"\n--- Processing ID: ({p_id}) ({c_id})---")
+    #             path1 = join(CONTACTLESS_BASE, f"p{p_id}", f"p{c_id}.bmp")
+    #             path2 = join(CONTACT_BASE, f"{p_id}_{c_id}.jpg")
+
+    #             if not exists(path1) or not exists(path2):
+    #                 continue
+                
+    #             try:
+    #                 img1 = cv2.imread(path1)
+    #                 img2 = cv2.imread(path2)
+
+    #                 # Apply the selected strategy
+    #                 en1 = func1(img1)
+    #                 en2 = func2(img2)
+
+    #                 # Resize & Predict
+    #                 img1_res = cv2.resize(en1, (160, 160))
+    #                 img2_res = cv2.resize(en2, (160, 160))
+                    
+    #                 # Assuming two_image_prediction is defined globally
+    #                 score = float(two_image_prediction(img1_res, img2_res))
+    #                 accuracy = score * 100
+
+    #                 if score > THRESHOLD:
+    #                     matched_pairs.append({
+    #                         "id": p_id,
+    #                         "contactless_path" : path1,
+    #                         "contact_based_path" : path2,
+    #                         "accuracy": f"{accuracy:.2f}%",
+    #                         "status": "MATCH FOUND"
+    #                     })
+    #                 total_tested += 1
+
+    #             except Exception as e:
+    #                 print(f"\nError processing ID {p_id}: {e}")
+    #                 # pass # Silent fail for speed, or print(e) for debugging
+
+    #     # Save individual JSON
+    #     with open(filename, 'w') as f:
+    #         json.dump(matched_pairs, f, indent=4)
+        
+    #     print(f"Finished. Found {len(matched_pairs)} out of {len(total_tested)} matches. Saved to {filename}")
+
+    # # --- EXECUTION LOOP ---
+    # # This will run all 16 combinations automatically
+    # for name1, func1 in strategies.items():
+    #     for name2, func2 in strategies.items():
+    #         filename = f"results_{name1}_vs_{name2}.json"
+    #         if os.path.exists(filename):
+    #             print(f"Skipping {filename} bcz exists") 
+    #             continue
+    #         run_test_combination(name1, func1, name2, func2)

requirements.txt

@@ -0,0 +1,65 @@
+absl-py==2.3.1
+albucore==0.0.24
+albumentations==2.0.8
+annotated-types==0.7.0
+astunparse==1.6.3
+blinker==1.9.0
+certifi==2026.1.4
+charset-normalizer==3.4.4
+click==8.3.1
+colorama==0.4.6
+fingerprint-feature-extractor==0.0.10
+fingerprint_enhancer==0.0.14
+Flask==3.1.2
+flatbuffers==25.12.19
+gast==0.7.0
+glob2==0.7
+google-pasta==0.2.0
+grpcio==1.76.0
+gunicorn==24.0.0
+h5py==3.15.1
+idna==3.11
+ImageIO==2.37.2
+itsdangerous==2.2.0
+Jinja2==3.1.6
+jsonpickle==4.1.1
+keras==3.13.1
+lazy_loader==0.4
+libclang==18.1.1
+Markdown==3.10.1
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+ml_dtypes==0.5.4
+namex==0.1.0
+networkx==3.6.1
+numpy==2.4.1
+opencv-python==4.13.0.90
+opencv-python-headless==4.13.0.90
+opt_einsum==3.4.0
+optree==0.18.0
+packaging==26.0
+pillow==12.1.0
+protobuf==6.33.4
+pydantic==2.12.5
+pydantic_core==2.41.5
+Pygments==2.19.2
+PyYAML==6.0.3
+requests==2.32.5
+rich==14.2.0
+scikit-image==0.26.0
+scipy==1.17.0
+simsimd==6.5.12
+six==1.17.0
+stringzilla==4.6.0
+tensorboard==2.20.0
+tensorboard-data-server==0.7.2
+tensorflow==2.20.0
+termcolor==3.3.0
+tifffile==2026.1.14
+tqdm==4.67.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+urllib3==2.6.3
+Werkzeug==3.1.5
+wrapt==2.0.1

static/js/main.js

@@ -0,0 +1,250 @@
+$(function() {
+  $(document).ready(function() {
+    const crop_format = {
+      enableExif: true,
+      viewport: {
+        width: 300,
+        height: 300,
+        type: 'circle' //circle
+      },
+      boundary: {
+        width: 300,
+        height: 300
+      }
+    };
+
+    $image_crop1 = $('#f1').croppie(crop_format);
+    $image_crop2 = $('#f2').croppie(crop_format);
+
+    $('#fp1_upload').click(() => {
+      $('#fp1').click();
+    });
+    $('#fp2_upload').click(() => {
+      $('#fp2').click();
+    });
+
+    let sample_check1 = false,
+      sample_check2 = false
+
+    $('#fp1_sample').click(() => {
+      $image_crop1.croppie('bind', {
+        url: '/static/img/sample_fingerprint.jpg',
+        zoom: 0
+      }).then(function() {
+        console.log('sample finger 1 added');
+        sample_check1 = true
+      });
+    });
+
+    $('#fp2_sample').click(() => {
+      $image_crop2.croppie('bind', {
+        url: '/static/img/sample_fingerprint.jpg',
+        zoom: 0
+      }).then(function() {
+        console.log('sample finger 2 added');
+        sample_check2 = true
+      });
+    });
+
+    $('#fp1').on('change', function() {
+      var reader = new FileReader();
+      reader.onload = function(event) {
+        $image_crop1.croppie('bind', {
+          url: event.target.result,
+          zoom: 0
+        }).then(function() {
+          console.log('jQuery bind 1 complete');
+        });
+      }
+      reader.readAsDataURL(this.files[0]);
+    });
+
+    $('#fp2').on('change', function() {
+      var reader = new FileReader();
+      reader.onload = function(event) {
+        $image_crop2.croppie('bind', {
+          url: event.target.result,
+          zoom: 0
+        }).then(function() {
+          console.log('jQuery bind 2 complete');
+        });
+      }
+      reader.readAsDataURL(this.files[0]);
+    });
+
+    function makeblob(dataURL) {
+      const BASE64_MARKER = ';base64,';
+      const parts = dataURL.split(BASE64_MARKER);
+      const contentType = parts[0].split(':')[1];
+      const raw = window.atob(parts[1]);
+      const rawLength = raw.length;
+      const uInt8Array = new Uint8Array(rawLength);
+
+      for (let i = 0; i < rawLength; ++i) {
+        uInt8Array[i] = raw.charCodeAt(i);
+      }
+
+      return new Blob([uInt8Array], {type: contentType});
+    }
+
+    $("#predict_submit").click(e => {
+      e.preventDefault();
+      sendFileToPredictor();
+    });
+
+    const validateFiles = () => {
+      return $('#fp1').prop('files').length != 0 && $('#fp2').prop('files').length != 0
+    }
+
+    const validateSingleFile = () => {
+      return $('#fp1').prop('files').length != 0
+    }
+
+    const validateSampleFiles = () => {
+      return sample_check1 && sample_check2
+    }
+
+    function sendFileToPredictor() {
+      if (!validateFiles() && !validateSampleFiles()) {
+        alert("You haven't inputted 2 images!");
+        return;
+      }
+
+      var formData = new FormData();
+      // const fp1 = $('#fp1').prop('files')[0];
+      // const fp2 = $('#fp2').prop('files')[0];
+      // formData.append('fp1', fp1, fp1.name);
+      // formData.append('fp2', fp2, fp2.name);
+
+      var fp1_cropped,
+        fp2_cropped;
+
+      $image_crop1.croppie('result', {
+        type: 'canvas',
+        size: 'viewport'
+      }).then((crop_img1) => {
+        fp1_cropped = makeblob(crop_img1);
+        $image_crop2.croppie('result', {
+          type: 'canvas',
+          size: 'viewport'
+        }).then((crop_img2) => {
+          fp2_cropped = makeblob(crop_img2);
+        }).then(() => {
+          formData.append('fp1', fp1_cropped);
+          formData.append('fp2', fp2_cropped);
+
+          $.ajax({
+            type: "POST",
+            url: "/two_image_prediction",
+            data: formData,
+            processData: false,
+            contentType: false,
+            success: function(result) {
+              // console.log(result);
+              const accuracy = result['accuracy'];
+              if (accuracy > 80) {
+                $('#pred_emoji').attr('x-text', "`👍`");
+              } else {
+                $('#pred_emoji').attr('x-text', "`❌`");
+              }
+
+              $('#accuracy_text').text(`${accuracy}%`);
+              $("#accuracy_circle").attr("x-data", `{ circumference: 50 * 2 * Math.PI, percent: ${Math.round(accuracy)} }`);
+            },
+            error: function(err) {
+              alert(err);
+              console.log(err);
+            }
+          });
+        })
+      });
+    }
+
+    const hideProgresss = () => $('#progress').addClass("hidden");
+    const showProgresss = () => $('#progress').removeClass("hidden");
+
+    //sending new fingerprint to database
+    $("#upload_to_db").click(e => {
+      e.preventDefault();
+      sendFingerprintToDatabase();
+    });
+
+    function sendFingerprintToDatabase() {
+      if (!validateSingleFile()) {
+        alert(`Fingerprint image not uploaded!`);
+        return;
+      }
+
+      if (!$('#upload_label').val()) {
+        alert(`Fingerprint Label can't be empty!`);
+        return;
+      }
+
+      var formData = new FormData();
+      const fp1 = $('#fp1').prop('files')[0];
+      const label = $('#upload_label').val().trim();
+      formData.append('fp1', fp1, fp1.name);
+      formData.append('fp_label', label);
+
+      showProgresss();
+      $.ajax({
+        type: "POST",
+        url: "/upload_to_db",
+        data: formData,
+        processData: false,
+        contentType: false,
+        success: function(result) {
+          // console.log(result);
+          // window.location = '/database'
+          location.reload(true);
+        },
+        error: function(err) {
+          alert(err);
+          console.log(err);
+          hideProgresss();
+        }
+      });
+    }
+
+    //sending new fingerprint to database
+    $("#predict_with_db").click(e => {
+      e.preventDefault();
+      predictWithDb();
+    });
+
+    function predictWithDb() {
+      if (!validateSingleFile()) {
+        alert(`Fingerprint image not uploaded!`);
+        return;
+      }
+
+      var formData = new FormData();
+      const fp1 = $('#fp1').prop('files')[0];
+      formData.append('fp1', fp1, fp1.name);
+
+      showProgresss();
+      $.ajax({
+        type: "POST",
+        url: "/predict_with_db",
+        data: formData,
+        processData: false,
+        contentType: false,
+        success: function(result) {
+          console.log(result);
+          let {all_preds, best_pred} = result;
+          all_preds.forEach( (pred) => {
+            $(`#${pred['html_id']}_acc`).text('(' + pred['accuracy'].toFixed(3) + ')').removeClass('text-green-600').addClass('text-red-600');
+          });
+          $(`#${best_pred['html_id']}_acc`).removeClass('text-red-600').addClass('text-green-600');
+          hideProgresss();
+        },
+        error: function(err) {
+          alert(err);
+          console.log(err);
+          hideProgresss();
+        }
+      });
+    }
+
+  });
+});

templates/analyze.html

@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate" />
+  <meta http-equiv="Pragma" content="no-cache" />
+  <meta http-equiv="Expires" content="0" />
+  <title>Fingerprint DeepLearning</title>
+
+  <link rel="icon" type="image/png" href="{{ url_for('static', filename='logo.png')}}" />
+
+  <link rel="stylesheet" href="{{ url_for('static', filename='css/main.css')}}">
+  <link href="https://unpkg.com/tailwindcss@^2/dist/tailwind.min.css" rel="stylesheet">
+  <link href="https://cdnjs.cloudflare.com/ajax/libs/croppie/2.6.5/croppie.css" rel="stylesheet">
+</head>
+
+<body>
+
+  <!-- This example requires Tailwind CSS v2.0+ -->
+  <div class="bg-indigo-600">
+    <div class="max-w-7xl mx-auto py-3 px-3 sm:px-6 lg:px-8">
+      <div class="flex items-center justify-between flex-wrap">
+        <div class="w-0 flex-1 flex items-center">
+          <span class="flex p-2 rounded-lg bg-indigo-800">
+            <svg class="h-6 w-6 text-white" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" aria-hidden="true">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5.882V19.24a1.76 1.76 0 01-3.417.592l-2.147-6.15M18 13a3 3 0 100-6M5.436 13.683A4.001 4.001 0 017 6h1.832c4.1 0 7.625-1.234 9.168-3v14c-1.543-1.766-5.067-3-9.168-3H7a3.988 3.988 0 01-1.564-.317z" />
+            </svg>
+          </span>
+          <p class="ml-3 font-medium text-white truncate">
+            <span class="md:hidden">
+              This project is on beta version!
+            </span>
+            <span class="hidden md:inline">
+              This project is currectly under development. See more soon!
+            </span>
+          </p>
+        </div>
+      </div>
+    </div>
+  </div>
+
+
+  <!-- <div class="relative bg-white">
+    <div class="max-w-7xl mx-auto px-4 sm:px-6">
+      <div class="flex justify-between items-center border-b-2 border-gray-100 py-6 md:justify-start md:space-x-10">
+        <div class="flex justify-start lg:w-0 lg:flex-1">
+          <a href="/">
+            <span class="sr-only">Contactless FP</span>
+            <img class="h-12 w-auto sm:h-12" src="{{ url_for('static', filename='logo.png')}}" alt="">
+          </a>
+        </div>
+
+        <nav class="md:flex space-x-10 text-gray-500 ">
+          <span>Fingerprint Detection</span>
+        </nav>
+
+      </div>
+    </div> -->
+
+
+  <!-- <div class="absolute top-0 inset-x-0 p-2 transition transform origin-top-right md:hidden">
+    <div class="rounded-lg shadow-lg ring-1 ring-black ring-opacity-5 bg-white divide-y-2 divide-gray-50">
+      <div class="pt-5 pb-6 px-5">
+        <div class="flex items-center justify-between">
+          <div>
+            <img class="h-8 w-auto" src="https://tailwindui.com/img/logos/workflow-mark-indigo-600.svg" alt="Workflow">
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+  </div> -->
+
+
+  <div class="min-h-0 md:py-10 py-5 md:px-60 grid grid-cols-2">
+    <div x-data="{photoName: null, photoPreview: null}" class="">
+      <!-- Photo File Input -->
+      <input id="fp1" type="file" class="hidden">
+      <label class="font-mono block text-gray-700 text-base font-bold mb-2 text-center" for="photo">
+        Fingerprint 1 <span class="text-red-600"> </span>
+      </label>
+
+      <div class="text-center">
+        <!-- Current Profile Photo -->
+        <div class="mt-2 rounded-full ">
+          <img id="f1" src="https://images.unsplash.com/photo-1531316282956-d38457be0993?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=700&q=80" class="block w-40 h-40 rounded-full m-auto shadow">
+        </div>
+
+        <button id="fp1_upload" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-blue-700 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+          Select New Photo
+        </button>
+        <button id="fp1_sample" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-blue-700 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+          Use Sample
+        </button>
+      </div>
+    </div>
+
+    <div x-data="{photoName: null, photoPreview: null}" class="">
+      <input id="fp2" type="file" class="hidden">
+      <label class="font-mono block text-gray-700 text-base font-bold mb-2 text-center" for="photo">
+        Fingerprint 2 <span class="text-red-600"> </span>
+      </label>
+
+      <div class="text-center">
+        <!-- Current Profile Photo -->
+        <div class="mt-2 rounded-full ">
+          <img id="f2" src="https://images.unsplash.com/photo-1531316282956-d38457be0993?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=700&q=80" class="block w-40 h-40 rounded-full m-auto shadow">
+        </div>
+
+        <button id="fp2_upload" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-blue-700 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+          Select New Photo
+        </button>
+        <button id="fp2_sample" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-blue-700 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+          Use Sample
+        </button>
+      </div>
+    </div>
+  </div>
+
+  <div class="text-white font-mono flex flex-col">
+    <div class="flex flex-row-reverse flex-wrap m-auto">
+      <button id="predict_submit" class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white">
+        Predict
+      </button>
+    </div>
+  </div>
+
+
+  <div class="min-h-0 py-10 px-10">
+    <div id="accuracy_circle" class="flex items-center m-auto flex-wrap max-w-md px-10 bg-white shadow-xl rounded-2xl h-20" x-data="{ circumference: 50 * 2 * Math.PI, percent: 0 }">
+      <div class="flex items-center justify-center -m-6 overflow-hidden bg-white rounded-full">
+        <svg class="w-32 h-32 transform translate-x-1 translate-y-1" x-cloak aria-hidden="true">
+          <circle class="text-gray-300" stroke-width="10" stroke="currentColor" fill="transparent" r="50" cx="60" cy="60" />
+          <circle class="text-blue-700" stroke-width="10" :stroke-dasharray="circumference" :stroke-dashoffset="circumference - percent / 100 * circumference" stroke-linecap="round" stroke="currentColor" fill="transparent" r="50" cx="60" cy="60" />
+        </svg>
+        <span id="pred_emoji" class="absolute text-2xl text-blue-700" x-text="`🤔`"></span>
+      </div>
+      <p class="ml-10 font-medium text-gray-600 text-xs md:text-xl">Accuracy</p>
+
+      <span id="accuracy_text" class="ml-auto text-xs font-medium text-blue-600 md:text-xl">0.00%</span>
+    </div>
+  </div>
+
+</body>
+
+
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/croppie/2.6.5/croppie.js" defer></script>
+<script src="https://code.jquery.com/jquery-3.6.0.min.js" integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>
+<script src="{{ url_for('static', filename='js/main.js')}}" charset="utf-8"></script>
+
+<script src="https://cdn.jsdelivr.net/gh/alpinejs/alpine@v2.8.0/dist/alpine.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/gh/alpine-collective/alpine-magic-helpers@0.3.x/dist/index.js"></script>
+
+</html>

templates/database.html

@@ -0,0 +1,158 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta http-equiv="X-UA-Compatible" content="ie=edge">
+  <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate" />
+  <meta http-equiv="Pragma" content="no-cache" />
+  <meta http-equiv="Expires" content="0" />
+  <title>Fingerprint DeepLearning</title>
+
+  <link rel="icon" type="image/png" href="{{ url_for('static', filename='logo.png')}}" />
+
+  <link rel="stylesheet" href="{{ url_for('static', filename='css/main.css')}}">
+  <link href="https://unpkg.com/tailwindcss@^2/dist/tailwind.min.css" rel="stylesheet">
+  <link href="https://cdnjs.cloudflare.com/ajax/libs/croppie/2.6.5/croppie.css" rel="stylesheet">
+</head>
+
+<body>
+
+  <!-- This example requires Tailwind CSS v2.0+ -->
+  <div class="bg-indigo-600">
+    <div class="max-w-7xl mx-auto py-3 px-3 sm:px-6 lg:px-8">
+      <div class="flex items-center justify-between flex-wrap">
+        <div class="w-0 flex-1 flex items-center">
+          <span class="flex p-2 rounded-lg bg-indigo-800">
+            <svg class="h-6 w-6 text-white" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" aria-hidden="true">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5.882V19.24a1.76 1.76 0 01-3.417.592l-2.147-6.15M18 13a3 3 0 100-6M5.436 13.683A4.001 4.001 0 017 6h1.832c4.1 0 7.625-1.234 9.168-3v14c-1.543-1.766-5.067-3-9.168-3H7a3.988 3.988 0 01-1.564-.317z" />
+            </svg>
+          </span>
+          <p class="ml-3 font-medium text-white truncate">
+            <span class="md:hidden">
+              This project is on beta version!
+            </span>
+            <span class="hidden md:inline">
+              This project is currectly under development. See more soon!
+            </span>
+          </p>
+        </div>
+      </div>
+    </div>
+  </div>
+
+
+  <div class="relative bg-white">
+    <div class="max-w-7xl mx-auto px-4 sm:px-6">
+      <div class="flex justify-between items-center border-b-2 border-gray-100 py-6 md:justify-start md:space-x-10">
+        <div class="flex m-auto">
+          <a href="/">
+            <span class="sr-only">Contactless FP</span>
+            <img class="h-10 w-auto sm:h-10" src="{{ url_for('static', filename='logo.png')}}" alt="">
+          </a>
+          <h3 class="font-mono px-2 py-2 text-lg"> {{ title }}</h3>
+        </div>
+      </div>
+    </div>
+
+
+    <div class="min-h-0 md:py-8 py-8 md:px-20 grid grid-cols-2">
+      <div x-data="{photoName: null, photoPreview: null}" class="w-2/3">
+        <!-- Photo File Input -->
+        <input id="fp1" type="file" class="hidden">
+        <label class="font-mono block text-gray-700 text-base font-bold mb-2 text-center" for="photo">
+          Upload New Fingerprint
+        </label>
+
+        <div class="text-center">
+          <div class="mt-2 rounded-full ">
+            <img id="f1" src="https://images.unsplash.com/photo-1531316282956-d38457be0993?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=700&q=80" class="block w-40 h-40 rounded-full m-auto shadow">
+          </div>
+
+          {% if detection_page %}
+          <div class="mb-3 m-5 pt-0">
+            <input id="upload_label" type="text" placeholder="Fingerprint Label" class="px-3 py-3 placeholder-blueGray-300 text-blueGray-600 relative bg-white bg-white rounded text-sm border-2 shadow w-60" />
+          </div>
+          {% endif %}
+
+          {% if detection_page %}
+          <button id="fp1_upload" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-blue-700 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+            Select Photo
+          </button>
+          <button id="upload_to_db" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-blue-700 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+            Upload
+          </button>
+          {% else %}
+          <button id="fp1_upload" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-blue-700 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+            Upload Photo
+          </button>
+          <button id="predict_with_db" type="button" class="font-mono inline-flex items-center px-4 py-2 bg-white border border-blue-300 bg-red-500 rounded-md font-semibold text-xs text-white uppercase tracking-widest shadow-sm hover focus:outline-none focus:border-blue-400 focus:shadow-outline-blue active:text-gray-800 active:bg-gray-50 transition ease-in-out duration-150 mt-2 ml-3">
+            Predict
+          </button>
+          {% endif %}
+
+        </div>
+
+        <svg version="1.1" class="hidden" id="progress" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 100 100" enable-background="new 0 0 0 0" xml:space="preserve" style="height: 100px;width: 100px;margin: auto;">
+          <path fill="#000" d="M73,50c0-12.7-10.3-23-23-23S27,37.3,27,50 M30.9,50c0-10.5,8.5-19.1,19.1-19.1S69.1,39.5,69.1,50">
+            <animateTransform attributeName="transform" attributeType="XML" type="rotate" dur="1s" from="0 50 50" to="360 50 50" repeatCount="indefinite" />
+          </path>
+        </svg>
+
+      </div>
+
+      <!-- rest of right half-->
+      <div>
+        {% if fps %}
+        <div class="text-center">
+          <label class="font-mono text-gray-700 text-base font-bold">
+            All Database Fingerprints
+          </label>
+        </div>
+        {% endif %}
+
+        <div class="col-start-2 grid grid-cols-4 gap-4">
+          {% if fps %}
+          {% for fp in fps %}
+          <div class="text-center">
+            <div class="mt-2 rounded-full ">
+              <img id="db_{{ fp['label'] }}" src="{{ fp['url'] }}" class="block w-25 h-25 rounded-full shadow-md">
+            </div>
+            <label class="font-mono block font-bold text-gray-700 text-sm mb-2 text-center" for="photo">
+              {{ fp['label'] }}
+              {% if not detection_page %}
+              <span id="db_{{ fp['label'] }}_acc" class="text-red-600 block"></span>
+              {% endif %}
+            </label>
+          </div>
+          {% endfor %}
+          {% endif %}
+
+          <!-- <div class="text-center">
+          <div class="mt-2 rounded-full ">
+            <img id="f1" src="https://images.unsplash.com/photo-1531316282956-d38457be0993?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=700&q=80" class="block w-25 h-25 object-contain rounded-full shadow">
+          </div>
+          <label class="font-mono block text-gray-700 text-sm mb-2 text-center" for="photo">
+            Alice <span class="text-red-600"> </span>
+          </label>
+        </div> -->
+
+        </div>
+
+
+      </div>
+    </div>
+
+</body>
+
+
+
+<script src="https://cdnjs.cloudflare.com/ajax/libs/croppie/2.6.5/croppie.js" defer></script>
+<script src="https://code.jquery.com/jquery-3.6.0.min.js" integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>
+<script src="{{ url_for('static', filename='js/main.js')}}" charset="utf-8"></script>
+
+<script src="https://cdn.jsdelivr.net/gh/alpinejs/alpine@v2.8.0/dist/alpine.min.js" defer></script>
+<script src="https://cdn.jsdelivr.net/gh/alpine-collective/alpine-magic-helpers@0.3.x/dist/index.js"></script>
+
+</html>

test_len_of_combinations.py

@@ -0,0 +1,36 @@
+import json
+from pathlib import Path
+
+def analyze_json_lists():
+    # Get the current working directory
+    current_dir = Path.cwd()
+    
+    # Find all files ending with .json
+    json_files = list(current_dir.glob('*.json'))
+    
+    if not json_files:
+        print("No .json files found in the current directory.")
+        return
+
+    # Print header
+    print(f"{'File Name':<40} | {'List Length'}")
+    print("-" * 55)
+
+    for file_path in json_files:
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # Check if the root element is actually a list
+            if isinstance(data, list):
+                print(f"{file_path.name:<40} | {len(data)}")
+            else:
+                print(f"{file_path.name:<40} | Not a list (Type: {type(data).__name__})")
+                
+        except json.JSONDecodeError:
+            print(f"{file_path.name:<40} | Error: Invalid JSON format")
+        except Exception as e:
+            print(f"{file_path.name:<40} | Error: {e}")
+
+if __name__ == "__main__":
+    analyze_json_lists()

utils.py

@@ -0,0 +1,47 @@
+from os.path import join, dirname, basename, exists, normpath
+from os import makedirs
+from glob import glob
+import cv2
+import numpy as np
+
+# Use normpath to ensure Windows/Linux compatibility
+dirname_val = normpath(dirname(__file__))
+db_path = join(dirname_val, 'static', 'db_fingerprints')
+
+def getAllImagesFromDatabase():
+    fingerprint_db = []
+    # Search for all common image formats
+    for ext in ('*.png', '*.jpg', '*.jpeg', '*.bmp'):
+        fingerprint_db.extend(glob(join(db_path, ext)))
+
+    db_json = []
+    # Use enumerate for cleaner ID generation
+    for i, file_path in enumerate(fingerprint_db, 1):
+        # 1. Extract the label (filename without extension)
+        name = basename(file_path).rsplit('.', 1)[0]
+        
+        # 2. Fix the URL pathing
+        # We ensure it starts with a forward slash and uses forward slashes
+        # for Flask template compatibility
+        relative_url = file_path.replace(dirname_val, '').replace('\\', '/')
+        
+        db_json.append({
+            "id": i, 
+            "label": name, 
+            "url": relative_url
+        })
+
+    # Sort by label so the database view looks organized
+    return sorted(db_json, key=lambda k: k['label'])
+
+def saveImageToDatabase(label, img):
+    """Saves the enhanced fingerprint to the database folder."""
+    if not exists(db_path):
+        makedirs(db_path)
+    
+    # Ensure filename is safe (remove spaces/special chars if needed)
+    safe_label = "".join([c for c in label if c.isalnum() or c in (' ', '-', '_')]).strip()
+    save_path = join(db_path, f"{safe_label}.jpg")
+    
+    cv2.imwrite(save_path, img)
+    return save_path