upload

CFA.py

@@ -0,0 +1,175 @@
+import gradio as gr
+import numpy as np
+from PIL import Image, ImageDraw
+import matplotlib.pyplot as plt
+from scipy.signal import convolve2d
+import time
+np.random.seed(123)
+
+# --- Configuration ---
+BOX_SIZE = 128
+
+# --- Helper Functions (GetMap, getFourier) ---
+# These computational functions remain the same as before.
+def GetMap(image_channel):
+    f = image_channel.astype(np.float64)
+    alpha = np.random.rand(4)
+    sigma = 0.005
+    delta = 10
+    count = 0
+    max_iter = 30
+    tolerance = 0.01
+    while True:
+        count += 1
+        kernel = np.array([[0, alpha[0], 0], [alpha[1], 0, alpha[2]], [0, alpha[3], 0]])
+        filtered = convolve2d(f, kernel, mode='same', boundary='symm')
+        r = np.abs(f - filtered) / 255.0
+        r = r[1:-1, 1:-1]
+        e = np.exp(-r**2 / sigma)
+        w = e / (e + 1 / delta)
+        if np.sum(w) < 1e-6:
+            print("Warning: Sum of weights is near zero. Exiting GetMap early.")
+            return e.ravel()
+        w_flat = w.ravel()
+        W = np.diag(w_flat)
+        value1 = f[:-2, 1:-1].ravel(); value2 = f[1:-1, :-2].ravel(); value3 = f[1:-1, 2:].ravel(); value4 = f[2:, 1:-1].ravel()
+        Y = f[1:-1, 1:-1].ravel()
+        X = np.column_stack((value1, value2, value3, value4))
+        try:
+            alpha_new = np.linalg.inv(X.T @ W @ X) @ (X.T @ W @ Y)
+        except np.linalg.LinAlgError:
+            print("Warning: Singular matrix encountered. Cannot compute inverse.")
+            return e.ravel()
+        if np.linalg.norm(alpha - alpha_new) < tolerance or count > max_iter: break
+        alpha = alpha_new
+        sigma = np.sum(w * (r**2)) / np.sum(w)
+    return e.ravel()
+
+def getFourier(prob):
+    imFft = np.fft.fftshift(np.fft.fft2(prob))
+    imFft = np.abs(imFft)
+    if np.max(imFft) > 0:
+        imFft = (imFft / np.max(imFft) * 255)
+    imFft = imFft.astype(np.uint8)
+    imFft = (imFft > (0.5 * 255)).astype(np.uint8)
+    return imFft
+
+# --- New Gradio Interaction Functions ---
+
+def draw_box_on_image(image: np.ndarray, box_coords: tuple, color="red", width=3) -> np.ndarray:
+    """Draws a bounding box on a NumPy image array."""
+    pil_image = Image.fromarray(image)
+    draw = ImageDraw.Draw(pil_image)
+    x, y = box_coords
+    rectangle = (x, y, x + BOX_SIZE, y + BOX_SIZE)
+    draw.rectangle(rectangle, outline=color, width=width)
+    return np.array(pil_image)
+
+def on_upload_image(image: np.ndarray) -> tuple:
+    """Called when an image is first uploaded. Stores the original image and draws the initial box."""
+    initial_coords = (0, 0)
+    image_with_box = draw_box_on_image(image, initial_coords)
+    # Returns: (image_with_box for display, original_image for state, initial_coords for state)
+    return image_with_box, image, initial_coords
+
+def move_selection_box(original_image: np.ndarray, evt: gr.SelectData) -> tuple:
+    """Called when the user clicks the image. It moves the box to the clicked location."""
+    # Center the box on the user's click
+    x = evt.index[0] - BOX_SIZE // 2
+    y = evt.index[1] - BOX_SIZE // 2
+    
+    # Clamp coordinates to ensure the box stays within the image boundaries
+    img_h, img_w, _ = original_image.shape
+    x = max(0, min(x, img_w - BOX_SIZE))
+    y = max(0, min(y, img_h - BOX_SIZE))
+    
+    new_coords = (int(x), int(y))
+    image_with_box = draw_box_on_image(original_image, new_coords)
+    # Returns: (image_with_box for display, new_coords for state)
+    return image_with_box, new_coords
+
+def analyze_region(original_image: np.ndarray, box_coords: tuple):
+    """The main analysis function, triggered by the 'Analyze' button."""
+    if original_image is None:
+        gr.Warning("Please upload an image first!")
+        return None
+        
+    print(f"\n--- Analysis Started for region at {box_coords} ---")
+    start_time = time.time()
+    
+    x, y = box_coords
+    patch = original_image[y:y + BOX_SIZE, x:x + BOX_SIZE]
+    print(f"1. Patch extracted with shape: {patch.shape}")
+
+    if len(patch.shape) == 3: analysis_channel = patch[:, :, 1] # Green channel
+    else: analysis_channel = patch # Grayscale
+    
+    print("2. Computing probability map...")
+    prob_flat = GetMap(analysis_channel)
+    prob_map_shape = (analysis_channel.shape[0] - 2, analysis_channel.shape[1] - 2)
+    prob_map = prob_flat.reshape(prob_map_shape)
+    
+    print("3. Computing Fourier transform...")
+    fft_result = getFourier(prob_map)
+
+    # Plotting
+    fig, axs = plt.subplots(1, 3, figsize=(12, 4))
+    axs[0].imshow(patch); axs[0].set_title("Selected 128x128 Patch"); axs[0].axis("off")
+    axs[1].imshow(prob_map, cmap='gray'); axs[1].set_title("Probability Map"); axs[1].axis("off")
+    axs[2].imshow(fft_result, cmap='gray'); axs[2].set_title("Fourier Transform"); axs[2].axis("off")
+    plt.tight_layout()
+    
+    print(f"4. Analysis complete in {time.time() - start_time:.2f} seconds.")
+    return fig
+
+# --- Build the Gradio Interface in a function ---
+def create_ui():
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        # State variables store data (like the original image) between user interactions
+        original_image_state = gr.State()
+        box_coords_state = gr.State(value=(0, 0))
+
+        gr.Markdown("# 🖼️ Image Patch Analyzer (CFA)")
+        gr.Markdown(
+            "**Instructions:**\n"
+            "1. **Upload** an image.\n"
+            "2. **Click** anywhere on the image to move the 128x128 selection box.\n"
+            "3. Press the **Analyze Region** button to start processing."
+        )
+
+        with gr.Row():
+            image_display = gr.Image(type="numpy", label="Selection Canvas")
+            output_plot = gr.Plot(label="Analysis Results")
+
+        analyze_button = gr.Button("Analyze Region", variant="primary")
+
+        # --- Wire up the event listeners ---
+
+        # 1. When a new image is uploaded, call on_upload_image
+        image_display.upload(
+            fn=on_upload_image,
+            inputs=[image_display],
+            outputs=[image_display, original_image_state, box_coords_state]
+        )
+
+        # 2. When the user clicks the image, call move_selection_box
+        image_display.select(
+            fn=move_selection_box,
+            inputs=[original_image_state],
+            outputs=[image_display, box_coords_state]
+        )
+        
+        # 3. When the user clicks the analyze button, call analyze_region
+        analyze_button.click(
+            fn=analyze_region,
+            inputs=[original_image_state, box_coords_state],
+            outputs=[output_plot],
+            # Show a progress bar during analysis
+            show_progress="full" 
+        )
+    return demo
+
+# --- Remove the launch() call ---
+# if __name__ == "__main__":
+#     demo = create_ui()
+#     demo.launch()

JPEG_Ghost.py

@@ -0,0 +1,154 @@
+import gradio as gr
+import numpy as np
+import imageio.v2 as imageio
+import matplotlib.pyplot as plt
+import os
+import tempfile
+from PIL import Image, ImageDraw
+
+# --- Configuration ---
+BOX_SIZE = 256
+
+# --- Core Analysis & Helper Functions ---
+
+def draw_box_on_image(image: np.ndarray, box_coords: tuple, color="red", width=3) -> np.ndarray:
+    """Draws a bounding box on a NumPy image array."""
+    pil_image = Image.fromarray(image)
+    draw = ImageDraw.Draw(pil_image)
+    x, y = box_coords
+    rectangle = (x, y, x + BOX_SIZE, y + BOX_SIZE)
+    draw.rectangle(rectangle, outline=color, width=width)
+    return np.array(pil_image)
+
+def diff_maps(im: np.ndarray, qf_range: np.ndarray, temp_dir: str) -> np.ndarray:
+    if im.dtype != np.uint8:
+        im = im.astype(np.uint8)
+    num_qfs = len(qf_range)
+    diff_array = np.zeros((im.shape[0], im.shape[1], num_qfs), dtype=np.float32)
+    temp_path = os.path.join(temp_dir, 'temp_recompress.jpg')
+    for i, q in enumerate(qf_range):
+        imageio.imwrite(temp_path, im, format='JPEG', quality=int(q))
+        recompressed_im = imageio.imread(temp_path)
+        diff = (im.astype(np.float32) - recompressed_im.astype(np.float32))**2
+        if diff.ndim == 3:
+            diff = np.mean(diff, axis=2)
+        diff_array[:, :, i] = diff
+    return diff_array
+
+def on_upload_image(image: np.ndarray) -> tuple:
+    """Called when an image is first uploaded to draw the initial box."""
+    initial_coords = (0, 0)
+    image_with_box = draw_box_on_image(image, initial_coords)
+    return image_with_box, image, initial_coords
+
+def move_selection_box(original_image: np.ndarray, evt: gr.SelectData) -> tuple:
+    """Called when the user clicks the image to move the box."""
+    x = evt.index[0] - BOX_SIZE // 2
+    y = evt.index[1] - BOX_SIZE // 2
+    img_h, img_w, _ = original_image.shape
+    x = max(0, min(x, img_w - BOX_SIZE))
+    y = max(0, min(y, img_h - BOX_SIZE))
+    new_coords = (int(x), int(y))
+    image_with_box = draw_box_on_image(original_image, new_coords)
+    return image_with_box, new_coords
+
+def run_analysis(original_image: np.ndarray, box_coords: tuple, qf1: int, qf2: int, qf_start: int, qf_end: int):
+    if original_image is None:
+        raise gr.Error("Please upload an image first.")
+    if qf_start >= qf_end:
+        raise gr.Error("Analysis QF Start must be less than QF End.")
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        x, y = box_coords
+        patch_coords = (x, y, x + BOX_SIZE, y + BOX_SIZE)
+        
+        path_qf1 = os.path.join(temp_dir, 'temp1.jpg')
+        path_composite = os.path.join(temp_dir, 'composite.jpg')
+        imageio.imwrite(path_qf1, original_image, quality=int(qf1))
+        im_low_q = imageio.imread(path_qf1)
+        
+        xmin, ymin, xmax, ymax = patch_coords
+        im_low_q[ymin:ymax, xmin:xmax] = original_image[ymin:ymax, xmin:xmax]
+        
+        imageio.imwrite(path_composite, im_low_q, quality=int(qf2))
+        im_composite = imageio.imread(path_composite)
+
+        qf_values = np.arange(int(qf_start), int(qf_end) + 1, 5)
+        if len(qf_values) == 0:
+            raise gr.Error("The selected QF range is empty.")
+        
+        diffs = diff_maps(im_composite, qf_values, temp_dir)
+        diffs = np.clip(diffs, 0, 255)
+
+        num_plots = diffs.shape[2]
+        cols = 4
+        rows = int(np.ceil(num_plots / cols))
+        fig, axes = plt.subplots(rows, cols, figsize=(16, 4 * rows), squeeze=False)
+        fig.suptitle('Difference Images for Different Recompression Quality Factors', fontsize=16)
+        axes = axes.flatten()
+        for i in range(num_plots):
+            axes[i].imshow(diffs[:, :, i], cmap='gray', vmin=0, vmax=np.percentile(diffs, 99))
+            axes[i].set_title(f'QF = {qf_values[i]}')
+            axes[i].axis('off')
+        for i in range(num_plots, len(axes)):
+            axes[i].axis('off')
+        plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+
+    return im_composite, fig
+
+# --- Build the Gradio Interface in a function ---
+
+def create_ui():
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🕵️ JPEG Double Compression Analyzer")
+        gr.Markdown(
+            "**Instructions:**\n"
+            "1. **Upload** an image.\n"
+            "2. **Click** on the image to move the 256x256 selection box.\n"
+            "3. Press **Analyze Image** to process the selected region."
+        )
+
+        original_image_state = gr.State()
+        box_coords_state = gr.State()
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gr.Markdown("### 1. Inputs")
+                image_display = gr.Image(type="numpy", label="Upload Image & Click to Select")
+                qf1_slider = gr.Slider(minimum=1, maximum=100, value=70, step=1, label="QF1: Background Quality")
+                qf2_slider = gr.Slider(minimum=1, maximum=100, value=85, step=1, label="QF2: Final Composite Quality")
+                gr.Markdown("#### Analysis QF Range")
+                with gr.Row():
+                    qf_start_slider = gr.Slider(minimum=50, maximum=100, value=50, step=5, label="Start")
+                    qf_end_slider = gr.Slider(minimum=50, maximum=100, value=90, step=5, label="End")
+                analyze_button = gr.Button("Analyze Image", variant="primary")
+
+            with gr.Column(scale=2):
+                gr.Markdown("### 2. Results")
+                composite_image_display = gr.Image(type="numpy", label="Generated Composite Image")
+                difference_plot_display = gr.Plot(label="Difference Maps")
+        
+        # Event Listeners
+        image_display.upload(
+            fn=on_upload_image,
+            inputs=[image_display],
+            outputs=[image_display, original_image_state, box_coords_state]
+        )
+        
+        image_display.select(
+            fn=move_selection_box,
+            inputs=[original_image_state],
+            outputs=[image_display, box_coords_state]
+        )
+        
+        analyze_button.click(
+            fn=run_analysis,
+            inputs=[original_image_state, box_coords_state, qf1_slider, qf2_slider, qf_start_slider, qf_end_slider],
+            outputs=[composite_image_display, difference_plot_display]
+        )
+    return demo
+
+# --- Remove the launch() call ---
+# if __name__ == "__main__":
+#     demo = create_ui()
+#     demo.launch(debug=True)

PRNU.py

@@ -0,0 +1,153 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+import imageio.v2 as imageio
+import tempfile
+import os
+
+# --- Import your custom source files ---
+# This assumes a 'utils' directory is in the root of the HF Space
+try:
+    import utils.src.Functions as Fu
+    import utils.src.Filter as Ft
+    import utils.src.maindir as md
+except ImportError:
+    print("Warning: Could not import 'utils.src' modules.")
+    print("Please ensure the 'utils' directory is present in your repository.")
+    # Define dummy functions so the app can at least load
+    class DummyModule:
+        def __getattr__(self, name):
+            def dummy_func(*args, **kwargs):
+                raise ImportError(f"Module 'utils.src' not loaded. '{name}' is unavailable.")
+            return dummy_func
+    Fu = DummyModule()
+    Ft = DummyModule()
+    md = DummyModule()
+
+
+# --- App Description ---
+description = """
+# 📸 PRNU-Based Image Forgery Detector
+
+This tool analyzes an image to detect potential manipulations using Photo-Response Non-Uniformity (PRNU), a unique noise pattern that acts as a camera's fingerprint.
+
+## How it Works
+1.  **Camera Fingerprint**: Every digital camera sensor has a unique, systematic noise pattern called PRNU. We use a pre-extracted fingerprint file (`.dat`) for a specific camera.
+2.  **Image Analysis**: The tool extracts the noise residual from the uploaded image.
+3.  **Correlation**: It then compares the image's noise with the camera's fingerprint by calculating the Peak-to-Correlation Energy (PCE) across different blocks of the image.
+4.  **PCE Map**: The output PCE map visualizes this correlation. High PCE values (brighter areas) suggest that this part of the image was likely taken by the fingerprinted camera. Dark or inconsistent areas could indicate tampering or that the image was taken with a different device.
+
+![Diagram of the PRNU process](https://www.researchgate.net/profile/Feyisetan-Ojerinde/publication/323982885/figure/fig1/AS:607997380104192@1521971778119/Block-diagram-of-PRNU-based-source-camera-identification-process.png)
+
+## How to Use
+1.  Upload the camera's fingerprint file (`.dat` format).
+2.  Upload the JPG/PNG image you want to analyze.
+3.  Click **Submit** and view the resulting PCE map.
+"""
+
+# --- Main Analysis Function ---
+def analyze_image_forgery(fingerprint_file, input_image):
+    """
+    Processes an image against a camera fingerprint to generate a PCE map.
+    """
+    if fingerprint_file is None:
+        raise gr.Error("Please upload a camera fingerprint (.dat file).")
+    if input_image is None:
+        raise gr.Error("Please upload an image to analyze.")
+        
+    try:
+        # --- 1. Load Camera Fingerprint ---
+        print("Loading camera fingerprint...")
+        Fingerprint = np.genfromtxt(fingerprint_file.name)
+        print(f"Fingerprint loaded. Shape: {Fingerprint.shape}")
+
+        # --- 2. Save uploaded image to a temporary file ---
+        with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as temp_img_file:
+            temp_img_path = temp_img_file.name
+            imageio.imwrite(temp_img_path, input_image)
+
+        # --- 3. Extract and filter PRNU noise from the image ---
+        print("Extracting noise from image...")
+        Noisex = Ft.NoiseExtractFromImage(temp_img_path, sigma=2.)
+        Noisex = Fu.WienerInDFT(Noisex, np.std(Noisex))
+        print(f"Noise extracted. Shape: {Noisex.shape}")
+
+        # Clean up the temporary image file
+        os.remove(temp_img_path)
+
+        # --- 4. Align Fingerprint and PRNU sizes by padding if necessary ---
+        if Noisex.shape != Fingerprint.shape:
+            print("Shapes do not match. Padding PRNU noise to match fingerprint size.")
+            Noisex_padded = np.zeros_like(Fingerprint)
+            h = min(Noisex.shape[0], Fingerprint.shape[0])
+            w = min(Noisex.shape[1], Fingerprint.shape[1])
+            Noisex_padded[:h, :w] = Noisex[:h, :w]
+            Noisex = Noisex_padded
+        
+        # --- 5. Compute PCE Map in blocks ---
+        print("Computing PCE map...")
+        block_size = 64
+        blocks_x = np.arange(0, Noisex.shape[0], block_size)
+        blocks_y = np.arange(0, Noisex.shape[1], block_size)
+        PCE_map = np.zeros((len(blocks_x), len(blocks_y)))
+
+        for y_idx, y_start in enumerate(blocks_y):
+            for x_idx, x_start in enumerate(blocks_x):
+                block_Noisex = Noisex[x_start:x_start+block_size, y_start:y_start+block_size]
+                block_Fingerprint = Fingerprint[x_start:x_start+block_size, y_start:y_start+block_size]
+                
+                # Skip if blocks are not of the expected size (can happen at edges)
+                if block_Noisex.shape != (block_size, block_size):
+                    continue
+
+                C = Fu.crosscorr(block_Noisex, block_Fingerprint)
+                det, _ = md.PCE(C)
+                PCE_map[x_idx, y_idx] = det.get('PCE', 0) # Use .get for safety
+
+        print("PCE map computed successfully.")
+
+        # --- 6. Generate Output Plots ---
+        # Plot 1: PCE Map
+        fig1, ax1 = plt.subplots(figsize=(8, 6))
+        im = ax1.imshow(PCE_map, cmap='viridis')
+        ax1.set_title('Detection PCE-map')
+        fig1.colorbar(im, ax=ax1, label='PCE Value')
+        
+        # Plot 2: Original Image
+        fig2, ax2 = plt.subplots(figsize=(8, 6))
+        ax2.imshow(input_image)
+        ax2.set_title('Analyzed Image')
+        ax2.axis('off')
+
+        return fig1, fig2
+
+    except ImportError as e:
+        print(f"ImportError: {e}")
+        raise gr.Error("Missing 'utils' module. Please ensure the 'utils' directory is in the repository.")
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        raise gr.Error(f"An error occurred during analysis: {e}")
+
+
+# --- Create the Gradio Interface in a function ---
+def create_ui():
+    iface = gr.Interface(
+        fn=analyze_image_forgery,
+        inputs=[
+            gr.File(label="Upload Camera Fingerprint (.dat file)"),
+            gr.Image(type="numpy", label="Upload Image to Analyze")
+        ],
+        outputs=[
+            gr.Plot(label="PCE Map"),
+            gr.Plot(label="Analyzed Image")
+        ],
+        title="📸 PRNU-Based Image Forgery Detector",
+        description=description,
+        theme=gr.themes.Soft()
+    )
+    return iface
+
+# --- Remove the launch() call ---
+# if __name__ == "__main__":
+#     iface = create_ui()
+#     iface.launch()

README.md

@@ -1,13 +1,26 @@
+# Digital Image Forensics Toolkit 🕵️‍♂️
+
+This space provides a collection of fundamental digital forensic algorithms designed to detect "cheap fakes"—image manipulations created with standard editing software.
+
+These methods are effective for identifying traditional forgeries such as splicing, copy-move, and inconsistent lighting. Select a tool from the tabs above to get started.
+
 ---
-title: Cfa Forensics Tool
-emoji: 📈
-colorFrom: blue
-colorTo: red
-sdk: gradio
-sdk_version: 5.49.1
-app_file: app.py
-pinned: false
-license: other
----
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Forensic Tools
+
+This toolkit includes the following analysis methods:
+
+### 🎨 Color Filter Array Analysis (`CFA.py`)
+Analyzes artifacts introduced during the camera's raw image processing. Inconsistencies in the **Color Filter Array (CFA)** interpolation pattern can reveal areas that have been spliced from another image or copy-pasted within the same image (copy-move).
+
+### 👻 JPEG Ghost Detection (`JPEG_Ghost.py`)
+Detects forgeries by identifying regions within an image that were compressed with different **JPEG Quality Factors (QF)**. When an area from a different JPEG image is spliced in, it often carries the "ghost" of its original compression level, which this tool can reveal.
+
+### 📸 PRNU Analysis (`PRNU.py`)
+Uses the **Photo Response Non-Uniformity (PRNU)** pattern, a unique noise fingerprint inherent to every digital camera sensor. By comparing the PRNU of an image against a camera's known fingerprint, this tool can identify tampered regions (splicing, copy-move) that do not share the same origin. While typically used for source camera identification, local correlation analysis makes it a powerful forgery detector.
+
+### ☀️ Shadow Consistency Analysis (`shadows.py`)
+A utility for verifying geometric consistency of shadows in an image. By projecting vanishing points, it helps determine if all shadows correspond to a single, coherent light source. This method is based on principles of perspective and can be useful for analyzing both traditional manipulations and AI-generated images.
+
+
+    

app.py

@@ -0,0 +1,28 @@
+import gradio as gr
+
+# Import the UI-creation functions from your tool scripts
+import CFA as CFA_tool
+import JPEG_Ghost as JPEG_Ghost_tool
+import PRNU as PRNU_tool
+import shadow as shadows_tool
+
+# Create the tabbed interface
+demo = gr.TabbedInterface(
+    interface_list=[
+        CFA_tool.create_ui(),
+        JPEG_Ghost_tool.create_ui(),
+        PRNU_tool.create_ui(),
+        shadows_tool.build_gradio_interface()
+    ],
+    tab_names=[
+        "🎨 CFA Analysis",
+        "👻 JPEG Ghost",
+        "📸 PRNU Analysis",
+        "☀️ Shadow Analysis"
+    ],
+    title="Digital Image Forensics Toolkit 🕵️‍♂️"
+)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,45 @@
+asttokens==2.4.1
+backcall==0.2.0
+colorama==0.4.6
+comm==0.2.2
+contourpy==1.1.1
+cycler==0.12.1
+debugpy==1.8.8
+decorator==5.1.1
+executing==2.1.0
+fonttools==4.55.0
+imagecodecs==2023.3.16
+imageio==2.35.1
+importlib-metadata==8.5.0
+importlib-resources==6.4.5
+ipykernel==6.29.5
+ipython==8.12.3
+jedi==0.19.2
+jupyter-client==8.6.3
+jupyter-core==5.7.2
+kiwisolver==1.4.7
+lazy-loader==0.4
+matplotlib==3.7.5
+matplotlib-inline==0.1.7
+nest-asyncio==1.6.0
+networkx==3.1
+numpy==1.24.4
+opencv-python==4.10.0.84
+packaging==24.2
+parso==0.8.4
+pickleshare==0.7.5
+pillow==10.4.0
+platformdirs==4.3.6
+prompt-toolkit==3.0.48
+psutil==6.1.0
+pure-eval==0.2.3
+pygments==2.18.0
+pyparsing==3.1.4
+python-dateutil==2.9.0.post0
+PyWavelets==1.4.1
+scikit-image==0.21.0
+scipy==1.10.1
+six==1.16.0
+tornado==6.4.1
+gradio
+imageio.v2

shadow.py

@@ -0,0 +1,339 @@
+"""
+Gradio app module for interactive vanishing-point selection.
+This file is intended to be imported by app.py.
+"""
+
+import io
+import math
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+import gradio as gr
+from scipy.optimize import minimize
+
+# ------------------------ Helper math functions ---------------------------
+
+def build_line_from_points(p1, p2):
+    """Return line coefficients (A, B, C) for Ax + By + C = 0 given two points."""
+    x1, y1 = p1
+    x2, y2 = p2
+    a = y1 - y2
+    b = x2 - x1
+    c = x1 * y2 - y1 * x2
+    return np.array([a, b, c], dtype=float)
+
+
+def distance_point_to_line(pt, line):
+    x, y = pt
+    a, b, c = line
+    return abs(a * x + b * y + c) / math.hypot(a, b)
+
+
+def total_distances(x, lines, noise_lines):
+    """Sum of distances from candidate point x to all lines and noise lines."""
+    pt = x
+    s = 0.0
+    for L in lines:
+        s += distance_point_to_line(pt, L)
+    for Ln in noise_lines:
+        s += distance_point_to_line(pt, Ln)
+    return s
+
+
+def add_noise_lines_for_line(p1, p2, n=4, sigma=1.0):
+    """Create a list of "noise" lines by jittering the endpoints slightly."""
+    noise_lines = []
+    for _ in range(n):
+        p1n = (p1[0] + np.random.normal(0, sigma), p1[1] + np.random.normal(0, sigma))
+        p2n = (p2[0] + np.random.normal(0, sigma), p2[1] + np.random.normal(0, sigma))
+        noise_lines.append(build_line_from_points(p1n, p2n))
+    return noise_lines
+
+# ------------------------- Drawing utilities ------------------------------
+
+def draw_overlay(base_pil, yellow_lines, red_lines, yellow_points, red_points, vps=None):
+    """Return a new PIL image with overlays drawn: lines, points and vanishing points.
+
+    - yellow_lines, red_lines: lists of line coefficients
+    - yellow_points, red_points: lists of tuples (p1, p2) for each line
+    - vps: dict with keys 'yellow' and 'red' for vanishing points (x,y)
+    """
+    if isinstance(base_pil, np.ndarray):
+        img = Image.fromarray(base_pil).convert("RGBA")
+    else:
+        img = base_pil.copy().convert("RGBA")
+        
+    draw = ImageDraw.Draw(img)
+
+    # helpers
+    def draw_point(pt, color, r=4):
+        x, y = pt
+        draw.ellipse((x - r, y - r, x + r, y + r), fill=color, outline=color)
+
+    def draw_line_by_points(p1, p2, color, width=2, dash=False):
+        # we just draw a straight segment connecting endpoints
+        if dash:
+            # dashed line: draw small segments
+            x1, y1 = p1
+            x2, y2 = p2
+            segs = 40
+            for i in range(segs):
+                t0 = i / segs
+                t1 = (i + 0.5) / segs
+                xa = x1 * (1 - t0) + x2 * t0
+                ya = y1 * (1 - t0) + y2 * t0
+                xb = x1 * (1 - t1) + x2 * t1
+                yb = y1 * (1 - t1) + y2 * t1
+                draw.line((xa, ya, xb, yb), fill=color, width=width)
+        else:
+            draw.line((p1[0], p1[1], p2[0], p2[1]), fill=color, width=width)
+
+    # Draw yellow lines
+    for idx, ((p1, p2), L) in enumerate(zip(yellow_points, yellow_lines)):
+        # draw long extents of line by projecting to image bounds
+        draw_line_segment_from_line(L, img.size, color=(255, 215, 0, 200), draw=draw)
+        draw_point(p1, (255, 215, 0, 255))
+        draw_point(p2, (255, 215, 0, 255))
+
+    # Draw red lines
+    for idx, ((p1, p2), L) in enumerate(zip(red_points, red_lines)):
+        draw_line_segment_from_line(L, img.size, color=(255, 64, 64, 200), draw=draw)
+        draw_point(p1, (255, 64, 64, 255))
+        draw_point(p2, (255, 64, 64, 255))
+
+    # Draw vanishing points if present
+    if vps is not None:
+        if "yellow" in vps and vps["yellow"] is not None:
+            draw_point(vps["yellow"], (255, 215, 0, 255), r=6)
+        if "red" in vps and vps["red"] is not None:
+            draw_point(vps["red"], (255, 64, 64, 255), r=6)
+
+    return img.convert("RGB")
+
+
+def draw_line_segment_from_line(line, image_size, draw=None, color=(255, 255, 0, 255)):
+    """Given line coefficients and image size, draw a segment across the image bounds.
+    This draws directly using ImageDraw if 'draw' is provided.
+    """
+    W, H = image_size
+    a, b, c = line
+    points = []
+    # intersection with left edge x=0
+    if abs(b) > 1e-9:
+        y = -(a * 0 + c) / b
+        points.append((0, y))
+    # right edge x=W
+    if abs(b) > 1e-9:
+        y = -(a * W + c) / b
+        points.append((W, y))
+    # top edge y=0 --> a x + c = 0
+    if abs(a) > 1e-9:
+        x = -(b * 0 + c) / a
+        points.append((x, 0))
+    # bottom edge y=H
+    if abs(a) > 1e-9:
+        x = -(b * H + c) / a
+        points.append((x, H))
+
+    # keep only points within the image bounds
+    pts_in = [(x, y) for (x, y) in points if -W * 0.1 <= x <= W * 1.1 and -H * 0.1 <= y <= H * 1.1]
+    if len(pts_in) >= 2 and draw is not None:
+        # pick two extreme points
+        # sort by x coordinate
+        pts_in = sorted(pts_in, key=lambda p: (p[0], p[1]))
+        pA = pts_in[0]
+        pB = pts_in[-1]
+        draw.line((pA[0], pA[1], pB[0], pB[1]), fill=color, width=2)
+
+# ------------------------- Gradio app callbacks ---------------------------
+
+def init_states():
+    return None, [], [], [], [], []
+
+
+def on_mode_change(mode, image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
+    """Switch drawing mode between 'yellow', 'red' or None.
+    Returns image (unchanged) and updated states.
+    """
+    # Just update the mode state. Clear any pending single point.
+    return (image, mode, [], y_lines, r_lines, y_pairs, r_pairs)
+
+
+def on_image_select(sel: gr.SelectData, image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
+    """Called when user clicks on the image. sel.index gives (x, y) in pixels.
+    """
+    if image is None:
+        gr.Warning("Please upload an image first.")
+        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
+        
+    if sel is None:
+        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
+
+    idx = getattr(sel, "index", None)
+    if idx is None:
+        idx = getattr(sel, "data", None) or getattr(sel, "value", None)
+    if not idx:
+        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
+
+    x, y = int(idx[0]), int(idx[1])
+
+    # append to current_points
+    current_points = list(current_points) if current_points is not None else []
+    current_points.append((x, y))
+
+    # if we have two points, create a line
+    if len(current_points) >= 2 and current_mode in ("yellow", "red"):
+        p1 = current_points[-2]
+        p2 = current_points[-1]
+        L = build_line_from_points(p1, p2)
+        if current_mode == "yellow":
+            y_lines = list(y_lines) if y_lines is not None else []
+            y_pairs = list(y_pairs) if y_pairs is not None else []
+            y_lines.append(L)
+            y_pairs.append((p1, p2))
+        else:
+            r_lines = list(r_lines) if r_lines is not None else []
+            r_pairs = list(r_pairs) if r_pairs is not None else []
+            r_lines.append(L)
+            r_pairs.append((p1, p2))
+        
+        # Clear current points after forming a line
+        current_points = []
+
+
+    # redraw overlay image
+    base_pil = Image.fromarray(image) if isinstance(image, np.ndarray) else image
+    out = draw_overlay(base_pil, y_lines or [], r_lines or [], y_pairs or [], r_pairs or [], vps=None)
+
+    return out, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
+
+
+def compute_vanishing_points(image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs):
+    """Compute vanishing points for both color groups, draw them and return annotated image.
+    """
+    if image is None:
+        gr.Warning("Please upload an image and draw lines first.")
+        return image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs
+
+    img_pil = Image.fromarray(image) if isinstance(image, np.ndarray) else image
+
+    vps = {"yellow": None, "red": None}
+
+    # process yellow group
+    if y_lines and len(y_lines) > 1:
+        lines_arr = np.array(y_lines)
+        inters = []
+        for i in range(len(lines_arr) - 1):
+            for j in range(i + 1, len(lines_arr)):
+                try:
+                    ip = np.linalg.solve(np.array([[lines_arr[i][0], lines_arr[i][1]],[lines_arr[j][0], lines_arr[j][1]]]),
+                                         -np.array([lines_arr[i][2], lines_arr[j][2]]))
+                    inters.append(ip)
+                except Exception:
+                    pass
+        if inters:
+            p0 = np.mean(inters, axis=0)
+        else:
+            p0 = np.array([img_pil.width / 2, img_pil.height / 2])
+
+        noise = []
+        for (p1, p2) in y_pairs:
+            noise += add_noise_lines_for_line(p1, p2, n=4, sigma=2.0)
+
+        res = minimize(lambda x: total_distances(x, lines_arr, noise), p0, method='Powell')
+        vps['yellow'] = (float(res.x[0]), float(res.x[1]))
+
+    # process red group
+    if r_lines and len(r_lines) > 1:
+        lines_arr = np.array(r_lines)
+        inters = []
+        for i in range(len(lines_arr) - 1):
+            for j in range(i + 1, len(lines_arr)):
+                try:
+                    ip = np.linalg.solve(np.array([[lines_arr[i][0], lines_arr[i][1]],[lines_arr[j][0], lines_arr[j][1]]]),
+                                         -np.array([lines_arr[i][2], lines_arr[j][2]]))
+                    inters.append(ip)
+                except Exception:
+                    pass
+        if inters:
+            p0 = np.mean(inters, axis=0)
+        else:
+            p0 = np.array([img_pil.width / 2, img_pil.height / 2])
+
+        noise = []
+        for (p1, p2) in r_pairs:
+            noise += add_noise_lines_for_line(p1, p2, n=4, sigma=2.0)
+
+        res = minimize(lambda x: total_distances(x, lines_arr, noise), p0, method='Powell')
+        vps['red'] = (float(res.x[0]), float(res.x[1]))
+
+    out = draw_overlay(img_pil, y_lines or [], r_lines or [], y_pairs or [], r_pairs or [], vps=vps)
+    # Return state, clearing current_points
+    return out, current_mode, [], y_lines, r_lines, y_pairs, r_pairs
+
+
+def on_upload(image):
+    # When a new image is uploaded, reset all states
+    return image, None, [], [], [], [], []
+
+# ------------------------------ Build Blocks ------------------------------
+
+def build_gradio_interface():
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# ☀️ Shadow Vanishing-Point Picker")
+        with gr.Row():
+            img_in = gr.Image(label="Upload image and then click to add points", type="numpy", interactive=True, height=600)
+            with gr.Column(scale=1):
+                start_y = gr.Button("Start Yellow Line")
+                start_r = gr.Button("Start Red Line")
+                none_btn = gr.Button("Stop Drawing")
+                compute_btn = gr.Button("Compute Vanishing Points", variant="primary")
+                reset_btn = gr.Button("Reset All")
+                gr.Markdown("Click the image to add points. Two points make one line. Add at least 2 lines per color group to compute a vanishing point.")
+
+        # states
+        current_mode = gr.State(None)
+        current_points = gr.State([])
+        y_lines = gr.State([])
+        r_lines = gr.State([])
+        y_pairs = gr.State([])
+        r_pairs = gr.State([])
+        
+        # Original image state to allow reseting
+        original_image = gr.State()
+
+        # link buttons to mode change
+        start_y.click(on_mode_change, inputs=[gr.State("yellow"), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
+        start_r.click(on_mode_change, inputs=[gr.State("red"), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
+        none_btn.click(on_mode_change, inputs=[gr.State(None), img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
+
+        # image select event
+        img_in.select(on_image_select, inputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+                      outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
+
+        compute_btn.click(compute_vanishing_points, inputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs],
+                          outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs])
+
+        # Store original image on upload
+        img_in.upload(
+            lambda img: (img, img, None, [], [], [], [], []),  # Reset all states on new upload
+            inputs=[img_in],
+            outputs=[img_in, original_image, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
+        )
+        
+        # Reset button restores the original image and clears states
+        reset_btn.click(
+            lambda img: (img, None, [], [], [], [], []), # Reset all states
+            inputs=[original_image],
+            outputs=[img_in, current_mode, current_points, y_lines, r_lines, y_pairs, r_pairs]
+        )
+
+    return demo
+
+# --- Remove the launch() call ---
+# if __name__ == '__main__':
+#     demo = build_gradio_interface()
+#     demo.queue()
+#     demo.launch()

utils/src/Filter.py

@@ -0,0 +1,422 @@
+"""
+Please read the copyright notice located on the readme file (README.md).  
+"""
+import cv2 as cv
+import numpy as np
+from scipy import signal
+import utils.src.Functions as Fu
+
+
+def Threshold(y, t):
+    """
+    Applies max(0,y-t).
+
+    Parameters
+    ----------
+    y : numpy.ndarray('float')
+        Array of Wavelet coefficients 
+    t : float
+        Variance of PRNU
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        The thresholded Wavelet coefficients for a later filtering
+
+    """
+    res = y - t
+    x = np.maximum(res, 0.)
+    return x
+
+
+def WaveNoise(coef, NoiseVar):
+    """
+    Applies Wiener-like filter in Wavelet Domain (residual filtering).
+    
+    Models each detail wavelet coefficient as conditional Gaussian random 
+    variable and use four square NxN moving windows, N in [3,5,7,9], to 
+    estimate the variance of noise-free image for each wavelet coefficient. 
+    Then it applies a Wiener-type denoising filter to the coefficients.
+
+    Parameters
+    ----------
+    coef : numpy.ndarray('float')
+        Wavelet detailed coefficient at certain level 
+    NoiseVar : float
+        Variance of the additive noise (PRNU)
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        Attenuated (filtered) Wavelet coefficient
+    numpy.ndarray('float')
+        Finall estimated variances for each Wavelet coefficient
+    """
+
+    tc = np.power(coef, 2)
+    coefVar = Threshold(
+        signal.fftconvolve(tc, np.ones([3, 3], dtype=float) / (3 * 3), mode='same'),
+        NoiseVar)
+
+    for w in range(5, 9 + 1, 2):
+        EstVar = Threshold(
+            signal.fftconvolve(tc, np.ones([w, w], dtype=float) / (w * w), mode='same'),
+            NoiseVar)
+        coefVar = np.minimum(coefVar, EstVar)
+
+    # Wiener filter like attenuation
+    tc = np.multiply(coef, np.divide(NoiseVar, coefVar + NoiseVar))
+
+    return tc, coefVar
+
+'''
+def WaveFilter(coef, NoiseVar):
+    """
+    Applies Wiener-like filter in Wavelet Domain (image filtering).
+    
+    Models each detail wavelet coefficient as conditional Gaussian random 
+    variable and use four square NxN moving windows, N in [3,5,7,9], to 
+    estimate the variance of noise-free image for each wavelet coefficient. 
+    Then it applies a Wiener-type denoising filter to the coefficients.
+
+    Parameters
+    ----------
+    coef : numpy.ndarray('float')
+        Wavelet detailed coefficient at certain level 
+    NoiseVar : float
+        Variance of the additive noise
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        Attenuated (filtered) Wavelet coefficient
+    numpy.ndarray('float')
+        Finall estimated variances for each Wavelet coefficient
+    """
+
+    tc = np.power(coef, 2)
+    coefVar = Threshold(
+        signal.fftconvolve(np.ones([3, 3]) / (3. * 3.), tc, mode='valid'),
+        NoiseVar);
+
+    for w in range(5, 9 + 1, 2):
+        EstVar = Threshold(
+            signal.fftconvolve(np.ones([w, w]) / (w * w), tc, mode='valid'),
+            NoiseVar)
+        coefVar = min(coefVar, EstVar)
+
+    # Wiener filter like attenuation
+    tc = np.multiply(coef, np.divide(coefVar, coefVar + NoiseVar))
+
+    return tc, coefVar
+'''
+
+def NoiseExtractFromImage(image, sigma=3.0, color=False, noZM=False):
+    """
+    Estimates PRNU from one image
+
+    Parameters
+    ----------
+    image : str or numpy.ndarray('uint8')
+        either test image filename or numpy matrix of image
+    sigma : float
+        std of noise to be used for identicication
+        (recomended value between 2 and 3)
+    color : bool
+        for an RGB image, whether to extract noise for the three channels 
+        separately (default: False)
+    noZM
+        whether to apply zero-mean to the extracted (filtered) noise
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        extracted noise from the input image, a rough estimate of PRNU fingerprint
+        
+    Example
+    -------
+    noise = NoiseExtractFromImage('DSC00123.JPG',2);
+    
+    Reference
+    ---------
+    [1] M. Goljan, T. Filler, and J. Fridrich. Large Scale Test of Sensor
+    Fingerprint Camera Identification. In N.D. Memon and E.J. Delp and P.W. Wong and
+    J. Dittmann, editors, Proc. of SPIE, Electronic Imaging, Media Forensics and
+    Security XI, volume 7254, pages # 0I–01–0I–12, January 2009.
+
+    """
+    
+    # ----- Parameters ----- #
+    L = 4  # number of wavelet decomposition levels (between 2-5 as well)
+    if isinstance(image, str):
+        X = cv.imread(image)
+        if np.ndim(X)==3: X = X[:,:,::-1] # BGR2RGB
+    else:
+        X = image
+        del image
+
+    M0, N0, three = X.shape
+    if X.dtype == 'uint8':
+        # convert to [0,255]
+        X = X.astype(float)
+    elif X.dtype == 'uint16':
+        X = X.astype(float) / 65535 * 255
+
+    qmf = [ 	.230377813309,	.714846570553, .630880767930, -.027983769417,
+           -.187034811719,	.030841381836, .032883011667, -.010597401785]
+    qmf /= np.linalg.norm(qmf)
+    
+    if three != 3:
+        Noise = Fu.NoiseExtract(X, qmf, sigma, L)
+    else:
+        Noise = np.zeros(X.shape)
+        for j in range(3):
+            Noise[:, :, j] = Fu.NoiseExtract(X[:, :, j], qmf, sigma, L)
+        if not color:
+            Noise = Fu.rgb2gray1(Noise)
+    if noZM:
+        print('not removing the linear pattern')
+    else:
+        Noise, _ = Fu.ZeroMeanTotal(Noise)
+
+    #Noise = Noise.astype(float)
+
+    return Noise
+
+#%% ----- 'mdwt' mex code ported to python -----#
+def mdwt(x, h, L):
+    """
+    multi-level Discrete Wavelet Transform, implemented similar to 
+    Rice Wavelet Toolbox (https://www.ece.rice.edu/dsp/software/rwt.shtml)
+    
+    Parameters
+    ----------
+    X : numpy.ndarray('float')
+        2D input image
+    h : list
+        db4 (D8) decomposition lowpass filter
+    L : Int
+        Number of levels for DWT decomposition
+    
+    Returns
+    -------
+    numpy.ndarray('float')
+        input image in DWT domain      
+    
+    """
+    
+    isint = lambda x: x % 1 == 0
+
+    m, n = x.shape[0], x.shape[1]  
+    if m > 1:
+        mtest = m / (2.**L)
+        if not isint(mtest):
+            raise(ValueError("Number of rows in input image must be of size m*2^(L)"))
+    if n > 1:
+        ntest = n / (2.**L)
+        if not isint(ntest):
+            raise(ValueError("Number of columns in input image must be of size n*2^(L)"))
+    
+    
+    # -- internal --
+    
+    def _fpsconv(x_in, lx, h0, h1, lhm1, x_outl, x_outh):
+        # circular-like padding
+        x_in[lx:lx+lhm1] = x_in[:lhm1]
+        #
+        tmp = np.convolve(x_in[:lx+lhm1],h0)
+        x_outl[:lx//2]= tmp[lhm1:-lhm1-1:2]
+        tmp = np.convolve(x_in[:lx+lhm1],h1)
+        x_outh[:lx//2]= tmp[lhm1:-lhm1-1:2]
+        '''
+        # or (as in the C++ implementation):
+        ind = 0
+        for i in range(0,lx,2):
+            x_outl[ind] = np.dot( x_in[i:i+lhm1+1], np.flip(h0) )
+            x_outh[ind] = np.dot( x_in[i:i+lhm1+1], np.flip(h1) )
+            ind += 1
+        '''
+        return x_in, x_outl, x_outh
+    
+    def _MDWT(x, h, L):
+        lh = len(h)
+        _m, _n = x.shape[0], x.shape[1]  
+        y = np.zeros([_m,_n], dtype=float)
+        
+        xdummy  = np.zeros([max(_m,_n) + lh-1], dtype=float)
+        ydummyl = np.zeros([max(_m,_n)], dtype=float)
+        ydummyh = np.zeros([max(_m,_n)], dtype=float)
+        
+        # analysis lowpass and highpass
+        if _n == 1:
+            _n = _m
+            _m = 1
+        
+        h0 = np.flip(h)
+        h1 = [h[i]*(-1)**(i+1) for i in range(lh)] 
+        lhm1 = lh - 1
+        actual_m = 2 * _m
+        actual_n = 2 * _n
+        
+        # main loop
+        for actual_L in range(1, L+1):
+            if _m == 1:
+                actual_m = 1
+            else:
+                actual_m = actual_m // 2
+                r_o_a = actual_m // 2
+            actual_n = actual_n // 2
+            c_o_a = actual_n // 2
+            
+            # go by rows
+            for ir in range(actual_m):# loop over rows
+                # store in dummy variable
+                if actual_L == 1:
+                    xdummy[:actual_n] = x[ir, :actual_n]# from input
+                else:
+                    xdummy[:actual_n] = y[ir, :actual_n]# from LL of previous level
+                # perform filtering lowpass and highpass
+                xdummy, ydummyl, ydummyh = _fpsconv(xdummy, actual_n, h0, h1, lhm1, ydummyl, ydummyh)
+                # restore dummy variables in matrices
+                y[ir, :c_o_a     ] = ydummyl[:c_o_a]
+                y[ir, c_o_a:2*c_o_a] = ydummyh[:c_o_a]
+            
+            
+            if _m > 1: # in case of a 2D signal
+                # go by columns
+                for ic in range(actual_n):# loop over column
+                    # store in dummy variables 
+                    xdummy[:actual_m] = y[:actual_m, ic]
+                    # perform filtering lowpass and highpass
+                    xdummy, ydummyl, ydummyh = _fpsconv(xdummy, actual_m, h0, h1, lhm1, ydummyl, ydummyh)
+                    # restore dummy variables in matrix
+                    y[:r_o_a,      ic] = ydummyl[:r_o_a]
+                    y[r_o_a:2*r_o_a, ic] = ydummyh[:r_o_a]
+                    
+        return y
+
+    # --------------
+    
+    y = _MDWT(x, h, L)
+    
+    return y
+
+#%% ----- 'midwt' mex code ported to python -----#
+def midwt(y, h, L):
+    """
+    multi-level inverse Discrete Wavelet Transform, implemented similar to 
+    Rice Wavelet Toolbox (https://www.ece.rice.edu/dsp/software/rwt.shtml)
+    
+    Parameters
+    ----------
+    y : numpy.ndarray('float')
+        2D matrix of image in multi-level DWT domain
+    h : list
+        db4 (D8) decomposition lowpass filter
+    L : Int
+        Number of levels for DWT decomposition
+    
+    Returns
+    -------
+    numpy.ndarray('float')
+        input image in DWT domain      
+    
+    """
+    
+    isint = lambda x: x % 1 == 0
+    
+    m, n = y.shape[0], y.shape[1]  
+    if m > 1:
+        mtest = m / (2.**L)
+        if not isint(mtest):
+            raise(ValueError("Number of rows in input image must be of size m*2^(L)"))
+    if n > 1:
+        ntest = n / (2.**L)
+        if not isint(ntest):
+            raise(ValueError("Number of columns in input image must be of size n*2^(L)"))
+    
+    # -- internal --
+    def _bpsconv(x_out, lx, g0, g1, lhhm1, x_inl, x_inh):
+        x_inl[:lhhm1] = x_inl[lx:lx+lhhm1]
+        x_inh[:lhhm1] = x_inh[lx:lx+lhhm1]
+        
+        tmp = np.convolve(x_inl[:lx+lhhm1+1], g0[::2]) + \
+                np.convolve(x_inh[:lx+lhhm1+1], g1[::2]);
+        x_out[:2*lx:2] = tmp[lhhm1:-lhhm1-1]
+        
+        tmp = np.convolve(x_inl[:lx+lhhm1+1], g0[1::2]) + \
+                np.convolve(x_inh[:lx+lhhm1+1], g1[1::2])
+        x_out[1:2*lx:2] = tmp[lhhm1:-lhhm1-1]
+        '''
+        # or (as in the C++ implementation):
+        ind = 0
+        for i in range(lx):
+            x_out[ind]   = np.dot(x_inl[i:i+lhhm1+1], np.flip(g0[::2])) + \
+                            np.dot(x_inh[i:i+lhhm1+1], np.flip(g1[::2]))
+            x_out[ind+1] = np.dot(x_inl[i:i+lhhm1+1], np.flip(g0[1::2])) + \
+                                  np.dot(x_inh[i:i+lhhm1+1], np.flip(g1[1::2]))
+            ind += 2
+        '''
+        return x_out
+    
+    def _MIDWT(y, h, L):
+        lh = len(h)
+        _m, _n = y.shape[0], y.shape[1]
+        xdummy  = np.zeros([max(_m, _n)], dtype=float)
+        ydummyl = np.zeros([max(_m, _n)+lh//2-1], dtype=float)
+        ydummyh = np.zeros([max(_m, _n)+lh//2-1], dtype=float)
+        
+        # synthesis lowpass and highpass
+        if _n == 1:
+            _n = _m
+            _m = 1
+        
+        g0 = h
+        g1 = [h[lh-i-1]*((-1)**i) for i in range(lh)] 
+        #lhm1 = lh - 1
+        lhhm1 = lh // 2 - 1
+        
+        # 2^L
+        sample_f = 2**(L-1)
+        
+        actual_m = _m // sample_f if _m > 1 else 1
+        actual_n = _n // sample_f
+        
+        x = y
+        
+        # main loop
+        for actual_L in range(L,0,-1):
+            r_o_a = actual_m // 2
+            c_o_a = actual_n // 2
+            
+            # in case of a 2D signal
+            if _m > 1:
+                # go by columns
+                for ic in range(actual_n):# loop over column
+                    # store in dummy variables
+                    ydummyl[lhhm1:lhhm1+r_o_a] = x[:r_o_a, ic]
+                    ydummyh[lhhm1:lhhm1+r_o_a] = x[r_o_a:2*r_o_a, ic]
+                    # perform filtering lowpass and highpass 
+                    xdummy = _bpsconv(xdummy, r_o_a, g0, g1, lhhm1, ydummyl, ydummyh)
+                    # restore dummy variables in matrix
+                    x[:actual_m, ic] = xdummy[:actual_m]
+            # go by rows
+            for ir in range(actual_m):# loop over rows
+                # store in dummy variable
+                ydummyl[lhhm1:lhhm1+c_o_a] = x[ir, :c_o_a]
+                ydummyh[lhhm1:lhhm1+c_o_a] = x[ir, c_o_a:2*c_o_a]
+                # perform filtering lowpass and highpass
+                xdummy = _bpsconv(xdummy, c_o_a, g0, g1, lhhm1, ydummyl, ydummyh);
+                # restore dummy variables in matrices
+                x[ir, :actual_n] = xdummy[:actual_n]
+            
+            actual_m = 1 if _m == 1 else actual_m * 2
+            actual_n = actual_n * 2
+        
+        return x
+    # --------------
+    
+    x = _MIDWT(y, h, L)
+    
+    return x
+

utils/src/Functions.py

@@ -0,0 +1,565 @@
+"""
+Please read the copyright notice located on the readme file (README.md).    
+"""
+import numpy as np
+from scipy import special
+import utils.src.Filter as Ft
+
+
+def crosscorr(array1, array2):
+    """
+    Computes 2D cross-correlation of two 2D arrays.
+    
+    Parameters
+    ----------
+    array1 : numpy.ndarray
+        first 2D matrix
+    array2: numpy.ndarray
+        second 2D matrix
+    
+    Returns
+    ------
+    numpy.ndarray('float64')
+        2D cross-correlation matrix
+
+    """ 
+
+    array1 = array1.astype(np.double)
+    array2 = array2.astype(np.double)
+    array1 = array1 - array1.mean()
+    array2 = array2 - array2.mean()
+
+    ############### End of filtering
+    normalizator = np.sqrt(np.sum(np.power(array1,2))*np.sum(np.power(array2,2)))
+    tilted_array2 = np.fliplr(array2);     del array2
+    tilted_array2 = np.flipud(tilted_array2)
+    TA = np.fft.fft2(tilted_array2);           del tilted_array2
+    FA = np.fft.fft2(array1);                  del array1
+    AC = np.multiply(FA, TA);                  del FA, TA
+
+    if normalizator==0:
+        ret = None
+    else:
+        ret = np.real(np.fft.ifft2(AC))/normalizator
+    return ret
+
+'''
+def crosscorr(array1, array2):
+    # function ret = crosscor2(array1, array2)
+    # Computes 2D crosscorrelation of 2D arrays
+    # Function returns DOUBLE type 2D array
+    # No normalization applied
+
+    array1 = array1.astype(np.double)
+    array2 = array2.astype(np.double)
+    array1 = array1 - array1.mean()
+    array2 = array2 - array2.mean()
+
+    ############### End of filtering
+    tilted_array2 = np.fliplr(array2);     del array2
+    tilted_array2 = np.flipud(tilted_array2)
+    TA = np.fft.fft2(tilted_array2);           del tilted_array2
+    FA = np.fft.fft2(array1);                  del array1
+    FF = np.multiply(FA, TA);                  del FA, TA
+
+    ret = np.real(np.fft.ifft2(FF))
+    return ret
+'''
+
+def imcropmiddle(X, sizeout, preference='SE'):
+    """
+    Crops the middle portion of a given size.
+    
+    Parameters
+    ----------
+    x : numpy.ndarray
+        2D or 3D image matrix
+    sizeout: list
+        size of the output image
+    
+    Returns
+    ------
+    numpy.ndarray
+        cropped image
+
+    """ 
+
+    if sizeout.__len__() >2:
+        sizeout = sizeout[:2]
+    if np.ndim(X)==2: X = X[...,np.newaxis]
+    M, N, three = X.shape
+    sizeout = [min(M,sizeout[0]), min(N,sizeout[1])]
+    # the cropped region is off center by 1/2 pixel
+    if preference == 'NW':
+        M0 = np.floor((M-sizeout[0])/2)
+        M1 = M0+sizeout[0]
+        N0 = np.floor((N-sizeout[1])/2)
+        N1 = N0+sizeout[1]
+    elif preference == 'SW':
+        M0 = np.ceil((M-sizeout[0])/2)
+        M1 = M0+sizeout[0]
+        N0 = np.floor((N-sizeout[1])/2)
+        N1 = N0+sizeout[1]
+    elif preference == 'NE':
+        M0 = np.floor((M-sizeout[0])/2)
+        M1 = M0+sizeout[0]
+        N0 = np.ceil((N-sizeout[1])/2)
+        N1 = N0+sizeout[1]
+    elif preference == 'SE':
+        M0 = np.ceil((M-sizeout[0])/2)
+        M1 = M0+sizeout[0]
+        N0 = np.ceil((N-sizeout[1])/2)
+        N1 = N0+sizeout[1]
+    X = X[M0:M1+1,N0:N1+1,:]
+    return X
+
+
+def IntenScale(inp):
+    """
+    Scales input pixels to be used as a multiplicative model for PRNU detector.
+    
+    Parameters
+    ----------
+    x : numpy.ndarray('uint8')
+        2D or 3D image matrix
+    
+    Returns
+    ------
+    numpy.ndarray('float')
+        Matrix of pixel intensities in to be used in a multiplicative model
+        for PRNU.
+
+    """
+
+    T = 252.
+    v = 6.
+    out = np.exp(-1*np.power(inp-T,2)/v)
+
+    out[inp < T] = inp[inp < T]/T
+    
+    return out
+
+
+def LinearPattern(X):
+    """
+    Output column and row means from all 4 subsignals, subsampling by 2.
+    
+    Parameters
+    ----------
+    x : numpy.ndarray('float')
+        2D noise matrix
+    
+    Returns
+    -------
+    dict
+        A dictionary with the following items:
+            row means as LP.r11, LP.r12, LP.r21, LP.r22 (column vectors) 
+            column means as LP.c11, LP.c12, LP.c21, LP.c22 (row vectors)
+            
+    numpy.ndarray('float')
+        The difference between input X and ZeroMean(X); i.e. X-output would be
+        the zero-meaned version of X
+
+    """
+
+    M, N = X.shape
+    me = X.mean()
+    X = X-me
+
+    #LP = {"r11":[],"c11":[],"r12":[],"c12":[],"r21":[],"c21":[],"r22":[],"c22":[],"me":[],"cm":[]}
+    LP = dict(r11=[], c11=[], r12=[], c12=[], r21=[], c21=[], r22=[], c22=[], me=[], cm=[])
+    LP['r11'] = np.mean(X[::2,::2],axis=1)
+    LP['c11'] = np.mean(X[::2,::2],axis=0)
+    cm11 = np.mean(X[::2,::2])
+    LP['r12'] = np.mean(X[::2,1::2],axis=1)
+    LP['c12'] = np.mean(X[::2,1::2],axis=0)
+    cm12 = np.mean(X[::2,1::2]) # = -cm  Assuming mean2(X)==0
+    LP['r21'] = np.mean(X[1::2,::2],axis=1)
+    LP['c21'] = np.mean(X[1::2,::2],axis=0)
+    cm21 = np.mean(X[1::2,::2]) # = -cm  Assuming mean2(X)==0
+    LP['r22'] = np.mean(X[1::2,1::2],axis=1)
+    LP['c22'] = np.mean(X[1::2,1::2],axis=0)
+    cm22 = np.mean(X[1::2,1::2]) # = cm   Assuming mean2(X)==0
+    LP['me'] = me
+    LP['cm'] = [cm11,cm12,cm21,cm22]
+
+    del X
+    D = np.zeros([M,N],dtype=np.double)
+    [aa,bb] = np.meshgrid(LP["c11"],LP["r11"],indexing='ij')
+    D[::2,::2] = aa+bb+me-cm11
+    [aa,bb] = np.meshgrid(LP["c12"],LP["r12"],indexing='ij')
+    D[::2,1::2] = aa+bb+me-cm12
+    [aa,bb] = np.meshgrid(LP["c21"],LP["r21"],indexing='ij')
+    D[1::2,::2] = aa+bb+me-cm21
+    [aa,bb] = np.meshgrid(LP["c22"],LP["r22"],indexing='ij')
+    D[1::2,1::2] = aa+bb+me-cm22
+
+    return LP, D
+
+
+def NoiseExtract(Im,qmf,sigma,L):
+    """
+    Extracts noise signal that is locally Gaussian N(0,sigma^2)
+
+    Parameters
+    ----------
+    Im : numpy.ndarray
+        2D noisy image matrix
+    qmf : list
+        Scaling coefficients of an orthogonal wavelet filter
+    sigma : float
+        std of noise to be used for identicication
+        (recomended value between 2 and 3)
+    L : int
+        The number of wavelet decomposition levels. 
+        Must match the number of levels of WavePRNU. 
+        (Generally, L = 3 or 4 will give pretty good results because the
+        majority of the noise is present only in the first two detail levels.)
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        extracted noise converted back to spatial domain
+        
+    Example
+    -------
+    Im = np.double(cv.imread('Lena_g.bmp')[...,::-1])        % read gray scale test image
+    qmf = MakeONFilter('Daubechies',8)
+    Image_noise = NoiseExtract(Im, qmf, 3., 4)
+    
+    Reference
+    ---------
+    [1] M. Goljan, T. Filler, and J. Fridrich. Large Scale Test of Sensor
+    Fingerprint Camera Identification. In N.D. Memon and E.J. Delp and P.W. Wong and
+    J. Dittmann, editors, Proc. of SPIE, Electronic Imaging, Media Forensics and
+    Security XI, volume 7254, pages # 0I–01–0I–12, January 2009.
+
+    """
+
+    Im = Im.astype(float)
+
+    M, N = Im.shape
+    m = 2**L
+    # use padding with mirrored image content
+    minpad=2    # minimum number of padded rows and columns as well
+    nr = (np.ceil((M+minpad)/m)*m).astype(int);  nc = (np.ceil((N+minpad)/m)*m).astype(int)  # dimensions of the padded image (always pad 8 pixels or more)
+    pr = np.ceil((nr-M)/2).astype(int)      # number of padded rows on the top
+    prd= np.floor((nr-M)/2).astype(int)    # number of padded rows at the bottom
+    pc = np.ceil((nc-N)/2).astype(int)      # number of padded columns on the left
+    pcr= np.floor((nc-N)/2).astype(int)     # number of padded columns on the right
+    Im = np.block([
+        [ Im[pr-1::-1,pc-1::-1],       Im[pr-1::-1,:],       Im[pr-1::-1,N-1:N-pcr-1:-1]],
+        [ Im[:,pc-1::-1],              Im,                   Im[:,N-1:N-pcr-1:-1] ],
+        [ Im[M-1:M-prd-1:-1,pc-1::-1], Im[M-1:M-prd-1:-1,:], Im[M-1:M-prd-1:-1,N-1:N-pcr-1:-1] ]
+                   ])
+
+    # Precompute noise variance and initialize the output
+    NoiseVar = sigma**2
+    # Wavelet decomposition, without redudance
+    wave_trans = Ft.mdwt(Im,qmf,L)
+    # Extract the noise from the wavelet coefficients
+
+    for i in range(1,L+1):
+
+        # Horizontal noise extraction
+        wave_trans[0:nr//2, nc//2:nc], _ = \
+            Ft.WaveNoise(wave_trans[0:nr//2, nc//2:nc], NoiseVar)
+
+        # Vertical noise extraction
+        wave_trans[nr//2:nr, 0:nc//2], _ = \
+            Ft.WaveNoise(wave_trans[nr//2:nr, 0:nc//2],NoiseVar)
+
+        # Diagonal noise extraction
+        wave_trans[nr//2:nr, nc//2:nc], _ = \
+            Ft.WaveNoise(wave_trans[nr//2:nr, nc//2:nc], NoiseVar)
+
+        nc = nc//2
+        nr = nr//2
+        
+    # Last, coarest level noise extraction
+    wave_trans[0:nr,0:nc] = 0
+
+    # Inverse wavelet transform
+    image_noise = Ft.midwt(wave_trans,qmf,L)
+
+    # Crop to the original size
+    image_noise = image_noise[pr:pr+M,pc:pc+N]
+    return image_noise
+
+
+def Qfunction(x):
+    """
+    Calculates probability that Gaussian variable N(0,1) takes value larger
+    than x
+    
+    Parameters
+    ----------
+    x : float
+        value to evalueate Q-function for
+
+    Returns
+    -------
+    float
+        probability that a variable from N(0,1) is larger than x
+    float
+        logQ
+
+    """
+
+    if x<37.5:
+        Q = 1/2*special.erfc(x/np.sqrt(2))
+        logQ = np.log(Q)
+    else:
+        Q = (1/(np.sqrt(2*np.pi)*x))*np.exp(-np.power(x,2)/2)
+        logQ = -np.power(x,2)/2 - np.log(x)-1/2*np.log(2*np.pi)
+
+    return Q, logQ
+
+
+def rgb2gray1(X):
+    """
+    Converts RGB-like real data to gray-like output.
+    
+    Parameters
+    ----------
+    X : numpy.ndarray('float')
+        3D noise matrix from RGB image(s)
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        2D noise matrix in grayscale
+
+    """
+    
+    datatype = X.dtype
+    
+    if X.shape[2]==1: G=X; return G
+    M,N,three = X.shape
+    X = X.reshape([M * N, three])
+
+    # Calculate transformation matrix
+    T = np.linalg.inv(np.array([[1.0, 0.956, 0.621],
+                                [1.0, -0.272, -0.647],
+                                [1.0, -1.106, 1.703]]))
+    coef = T[0,:]
+    G = np.reshape(np.matmul(X.astype(datatype), coef), [M, N])
+    
+    return G
+
+
+def Saturation(X, gray=False):
+    """
+    Determines saturated pixels as those having a peak value (must be over 250)
+    and a neighboring pixel of equal value
+    
+    Parameters
+    ----------
+    X : numpy.ndarray('float')
+        2D or 3D matrix of image with pixels in [0, 255]
+    gray : bool
+        Only for RGB input. If gray=true, then saturated pixels in output 
+        (denoted as zeros) result from at least 2 saturated color channels 
+
+    Returns
+    -------
+    numpy.ndarray('bool')
+        binary matrix, 0 - saturated pixels
+    
+    """
+
+    M = X.shape[0];  N = X.shape[1]
+    if X.max()<=250:
+        if not gray:
+            SaturMap = np.ones(X.shape,dtype=np.bool)
+        else:
+            SaturMap = np.ones([M,N],dtype=np.bool)
+        return SaturMap
+    
+    SaturMap = np.ones([M,N],dtype=np.int8)
+    
+    Xh = X - np.roll(X, 1, axis=1)
+    Xv = X - np.roll(X, 1, axis=0)
+    Satur = np.logical_and(np.logical_and(Xh, Xv), 
+                np.logical_and(np.roll(Xh, -1, axis=1),np.roll(Xv, -1, axis=0)))
+
+    if np.ndim(np.squeeze(X))==3:
+        maxX = []
+        for j in range(3):
+            maxX.append(X[:,:,j].max())
+            if maxX[j]>250:
+                SaturMap[:,:,j] = np.logical_not(np.logical_and(X[:,:,j]==maxX[j],
+                                                                np.logical_not(Satur[:,:,j])))
+    elif np.ndim(np.squeeze(X))==2:
+        maxX = X.max()
+        SaturMap = np.logical_not(np.logical_and(X==maxX, np.logical_not(SaturMap)))
+    else: raise ValueError('Invalid matrix dimensions')
+
+    if gray and np.ndim(np.squeeze(X))==3:
+        SaturMap = SaturMap[:,:,1]+SaturMap[:,:,3]+SaturMap[:,:,3]
+        SaturMap[SaturMap>1] = 1
+
+    return SaturMap
+
+
+def SeeProgress(i):
+    """
+    SeeProgress(i) outputs i without performing carriage return
+    This function is designed to be used in slow for-loops to show how the 
+    calculations progress. If the first call in the loop is not with i=1, it's
+    convenient to call SeeProgress(1) before the loop.
+    """
+    if i==1 | i==0 : print('\n               ')
+    print('*   %(i)d   *' % {"i": i}, end="\r")
+
+
+def WienerInDFT(ImNoise,sigma):
+    """
+    Removes periodical patterns (like the blockness) from input noise in 
+    frequency domain
+    
+    Parameters
+    ----------
+    ImNoise : numpy.ndarray('float')
+        2D noise matrix extracted from one images or a camera reference pattern
+    sigma : float
+        Standard deviation of the noise that we want not to exceed even locally
+        in DFT domain
+        
+    Returns
+    -------
+    numpy.ndarray('float')
+        filtered image noise (or camera reference pattern) ... estimate of PRNU
+
+    """
+    M,N = ImNoise.shape
+
+    F = np.fft.fft2(ImNoise);   del ImNoise
+    Fmag = np.abs(np.real(F / np.sqrt(M*N)))       #  normalized magnitude
+
+    NoiseVar = np.power(sigma, 2)
+    Fmag1, _ = Ft.WaveNoise(Fmag, NoiseVar)
+
+    fzero = np.where(Fmag==0); Fmag[fzero]=1; Fmag1[fzero]=0;    del fzero
+    F = np.divide(np.multiply(F, Fmag1), Fmag)
+
+    # inverse FFT transform
+    NoiseClean = np.real(np.fft.ifft2(F))
+
+    return NoiseClean
+
+
+def ZeroMean(X, zType='CFA'):
+    """
+    Subtracts mean from all subsignals of the given type
+    
+    Parameters
+    ----------
+    X : numpy.ndarray('float')
+        2-D or 3-D noise matrix
+    zType : str
+        Zero-meaning type. One of the following 4 options: {'col', 'row', 'both', 'CFA'}
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        noise matrix after applying zero-mean
+    dict
+        dictionary including mean vectors in rows, columns, total mean, and 
+        checkerboard mean
+    
+    Example
+    -------
+    Y,_ = ZeroMean(X,'col') ... Y will have all columns with mean 0.
+    Y,_ = ZeroMean(X,'CFA') ... Y will have all columns, rows, and 4 types of
+    odd/even pixels zero mean.
+    
+    """
+    
+    M, N, K = X.shape
+    # initialize the output matrix and vectors
+    Y = np.zeros(X.shape, dtype=X.dtype)
+    row = np.zeros([M,K], dtype=X.dtype)
+    col = np.zeros([K,N], dtype=X.dtype)
+    cm=0
+    
+    # subtract mean from each color channel
+    mu = []
+    for j in range(K):
+        mu.append(np.mean(X[:,:,j], axis=(0,1)))
+        X[:,:,j] -= mu[j]
+    
+    for j in range(K): 
+        row[:,j] = np.mean(X[:,:,j],axis=1)
+        col[j,:] = np.mean(X[:,:,j],axis=0)
+
+    if zType=='col':
+        for j in range(K): Y[:,:,j] = X[:,:,j] - np.tile(col[j,:],(M,1))
+    elif zType=='row':
+        for j in range(K): Y[:,:,j] = X[:,:,j] - np.tile(row[:,j],(N,1)).transpose()
+    elif zType=='both':
+        for j in range(K): Y[:,:,j] = X[:,:,j] - np.tile(col[j,:],(M,1))
+        for j in range(K): Y[:,:,j] = X[:,:,j] - np.tile(row[:,j],(N,1)).transpose()# equal to Y = ZeroMean(X,'row'); Y = ZeroMean(Y,'col');
+    elif zType=='CFA':
+        for j in range(K): Y[:,:,j] = X[:,:,j] - np.tile(col[j,:],(M,1))
+        for j in range(K): Y[:,:,j] = X[:,:,j] - np.tile(row[:,j],(N,1)).transpose()    # equal to Y = ZeroMean(X,'both');
+        for j in range(K):
+            cm = np.mean(Y[::2, ::2, j], axis=(1,2))
+            Y[::2, ::2, j]   -= cm
+            Y[1::2, 1::2, j] -= cm
+            Y[::2, 1::2, j]  += cm
+            Y[1::2, ::2, j]  += cm
+    else:
+        raise(ValueError('Unknown type for zero-meaning.'))
+        
+    # Linear pattern data:
+    LP = {}# dict(row=[], col=[], mu=[], checkerboard_mean=[])
+    LP['row'] = row
+    LP['col'] = col
+    LP['mu'] = mu
+    LP['checkerboard_mean'] = cm
+    return Y, LP
+
+
+def ZeroMeanTotal(X):
+    """
+    Subtracts mean from all black and all white subsets of columns and rows
+    in a checkerboard pattern
+    
+    Parameters
+    ----------
+    X : numpy.ndarray('float')
+        2-D or 3-D noise matrix
+
+    Returns
+    -------
+    numpy.ndarray('float')
+        noise matrix after applying ZeroMeanTotal
+    dict
+        dictionary of four dictionaries for the four subplanes, each includes
+        mean vectors in rows, columns, total mean, and checkerboard mean.
+    
+    """
+    dimExpanded = False
+    if np.ndim(X)==2: X = X[...,np.newaxis];  dimExpanded = True      
+    Y = np.zeros(X.shape, dtype=X.dtype)
+    
+    Z, LP11 = ZeroMean(X[::2, ::2, :],'both')
+    Y[::2, ::2, :] = Z
+    Z, LP12 = ZeroMean(X[::2, 1::2, :],'both')
+    Y[::2, 1::2,:] = Z
+    Z, LP21 = ZeroMean(X[1::2, ::2, :],'both')
+    Y[1::2, ::2,:] = Z
+    Z, LP22 = ZeroMean(X[1::2, 1::2, :],'both')
+    Y[1::2, 1::2,:] = Z
+    
+    if dimExpanded: Y = np.squeeze(Y)
+    
+    LP = {}# dict(d11=[], d12=[], d21=[], d22=[])
+    LP['d11'] = LP11
+    LP['d12'] = LP12
+    LP['d21'] = LP21
+    LP['d22'] = LP22 
+    
+    return Y, LP
+

utils/src/extraUtils.py

@@ -0,0 +1,72 @@
+import os
+import matplotlib.pyplot as plt
+from matplotlib import cm
+from matplotlib.ticker import LinearLocator, FormatStrFormatter
+import numpy as np
+
+def getImagesFrom(folder_addr, extension='.png'):
+    """
+    Returns a list of images from a path, with the desired extension.
+    
+    Parameters
+    ----------
+    folder_addr : str
+        Path to a target directory
+    extension : str
+        Extension of target image files, such as '.png', '.jpg', etc.
+
+    Returns
+    -------
+    list
+        The list of addresses of the images
+    """
+    
+    files = sorted(os.listdir(folder_addr))
+    if not folder_addr[-1]==os.sep: folder_addr += os.sep
+    list_probeFiles = [i for i in files if i.endswith(extension)]
+    for i in range(list_probeFiles.__len__()):
+        list_probeFiles[i] = folder_addr + list_probeFiles[i]
+    return list_probeFiles
+
+
+'''
+The following lines of code are mainly from:
+    [https://matplotlib.org/examples/mplot3d/surface3d_demo.html]
+'''
+def mesh(Z):
+    """
+    Similar to MATLAB 'mesh' function, can show peak of cross-correlation plane.
+    
+    Parameters
+    ----------
+    Z : numpy.ndarray('float32')
+        2D matrix of cross-correlation
+
+    Returns
+    -------
+    <nothing>
+    
+    """
+    Z = np.squeeze(Z)
+    
+    fig = plt.figure()
+    ax = fig.gca(projection='3d')
+
+    M, N = Z.shape
+    X = np.arange(0, N, 1)
+    Y = np.arange(0, M, 1)
+    X, Y = np.meshgrid(X, Y)
+
+    # Plot the surface.
+    surf = ax.plot_surface(X, Y, Z, cmap=cm.coolwarm,
+                           linewidth=0, antialiased=False)
+
+    # Customize the z axis.
+    ax.set_zlim(Z.min()*.99, Z.max()*1.01)
+    ax.zaxis.set_major_locator(LinearLocator(10))
+    ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
+
+    # Add a color bar which maps values to colors.
+    fig.colorbar(surf, shrink=0.5, aspect=5)
+
+    plt.show()

utils/src/getFingerprint.py

@@ -0,0 +1,92 @@
+"""
+Please read the copyright notice located on the readme file (README.md).    
+"""
+import utils.src.Functions as Fu 
+import cv2 as cv
+import numpy as np
+
+def getFingerprint(Images, sigma=3., fromHowMany=-1):
+    """
+     Extracts and averages noise from all images and outputs a camera 
+     fingerprint
+
+    Parameters
+    ----------
+    Images : list
+        List of color images to process. They have to be from the same camera
+        and the same size and orientation.
+    sigma : float32
+        Standard deviation of the expected noise (PRNU)
+
+    Returns
+    -------
+    numpy.ndarray('float32')
+        3D matrix of reference pattern - estimate of PRNU (in the output file)
+    dict
+         Dictionary of Linear Pattern data
+         
+    -------------------------------------------------------------------------
+    [1] M. Goljan, T. Filler, and J. Fridrich. Large Scale Test of Sensor
+    Fingerprint Camera Identification. In N.D. Memon and E.J. Delp and P.W. 
+    Wong and J. Dittmann, editors, Proc. of SPIE, Electronic Imaging, Media 
+    Forensics and Security XI, volume 7254, pages % 0I–01–0I–12, January 2009.
+    -------------------------------------------------------------------------
+    """
+
+    database_size = Images.__len__() if fromHowMany==-1 else fromHowMany; del fromHowMany    # Number of the images
+    if database_size==0: raise ValueError('No images of specified type in the directory.')
+    ###  Parameters used in denoising filter
+    L = 4 #  number of decomposition levels
+    qmf = [ 	.230377813309,	.714846570553, .630880767930, -.027983769417,
+           -.187034811719,	.030841381836, .032883011667, -.010597401785]
+    qmf /= np.linalg.norm(qmf)
+    
+    t = 0
+    ImagesinRP = []
+    for i in range(database_size):
+        Fu.SeeProgress(i),
+        im = Images[i]
+        X = cv.imread(im);
+        if np.ndim(X)==3: X = X[:,:,::-1] # BGR to RGB
+        X = _double255(X)
+        if t == 0:
+            M,N,three=X.shape
+            if three == 1:
+                continue # only color images will be processed
+            ###  Initialize sums
+            RPsum = np.zeros([M,N,3],dtype='single')
+            NN = np.zeros([M,N,3],dtype='single') # number of additions to each pixel for RPsum
+        else:
+            s = X.shape
+            if X.ndim != 3:
+                print('Not a color image - skipped.\n')
+                continue # only color images will be used
+            if set([M,N,three]) != set(X.shape):
+                print('\n Skipping image %(im)s of size %(s1)d x %(s2)d x %(s3)d \n' %{'im':im,'s1':s(1-1),'s2':s(2-1),'s3':s(3-1)})
+                continue # only same size images will be used
+
+        # The image will be the t-th image used for the reference pattern RP
+        t=t+1  # counter of used images
+        ImagesinRP.append(im)
+
+        for j in range(3):
+            ImNoise = np.single(Fu.NoiseExtract(X[:,:,j],qmf,sigma,L))
+            Inten = np.multiply(Fu.IntenScale(X[:,:,j]),\
+                                Fu.Saturation(X[:,:,j]))    # zeros for saturated pixels
+            RPsum[:,:,j] = RPsum[:,:,j] + np.multiply(ImNoise,Inten)   	# weighted average of ImNoise (weighted by Inten)
+            NN[:,:,j] = NN[:,:,j] + np.power(Inten,2)
+
+
+    del ImNoise, Inten, X
+    if t==0: raise ValueError('None of the images was color image in landscape orientation.')
+    RP = np.divide(RPsum, NN + 1)
+    # Remove linear pattern and keep its parameters
+    RP, LP = Fu.ZeroMeanTotal(RP)
+    return RP, LP, ImagesinRP
+
+### FUNCTIONS ##
+def _double255(X):
+    # In MATLAB: convert to 'double' ranging from 0 to 255
+    # Here in this Python implementation we convert it to 'single' (np.float32)
+    X = X.astype(np.single)
+    return X

utils/src/maindir.py

@@ -0,0 +1,114 @@
+"""
+Please read the copyright notice located on the readme file (README.md).    
+"""
+import utils.src.Functions as Fu
+import numpy as np
+from scipy import special
+
+
+def PCE(C, shift_range=[0,0], squaresize=11):
+    """
+    Computes Peak-to-Correlation Energy (PCE) obtained from correlation surface 
+    restricted to possible shifts due to cropping. In this implementation of 
+    PCE, it carries the sign of the peak (i.e. PCE can be negative)
+
+    Parameters
+    ----------
+    C : numpy.ndarray('float32')
+        cross-correlation surface calculated by function 'crosscorr'
+    shift_range : list
+        maximum shift is from [0,0] to [shift_range]
+    squaresize : int
+        removes the peak neighborhood of size (squaresize x squaresize)
+        
+    Returns
+    -------
+    dict
+        A dictionary with the following items:
+            PCE : peak-to-correlation energy
+            PeakLocation : location of the primary peak, [0 0] when correlated
+                    signals are not shifted to each other
+            pvalue : probability of obtaining peakheight or higher (under
+                    Gaussian assumption)
+            P_FA : probability of false alarm (increases with increasing range
+                    of admissible shifts (shift_range)
+    dict
+        A dictionary similar to the first output but for test under assumption
+        of no cropping (i.e. equal to 'Out0,_ = PCE(C)')
+        
+    Example
+    -------
+    Out, Out0 = PCE(crosscorr(Noise1, Noise2), size(Noise)-1);
+    C = crosscorr(Noise1,Noise2); Out0,_ = PCE(C)
+    
+    Note: 'Out0.PCE == Out.PCE' and 'Out.P_FA == Out.pvalue' when no shifts are considered
+    
+    """
+
+    if any(np.greater_equal(shift_range,C.shape)):
+        shift_range = min(shift_range,C.shape-1)   # all possible shift in at least one dimension
+
+    shift_range = np.array(shift_range)
+    Out = dict(PCE=[], pvalue=[], PeakLocation=[], peakheight=[], P_FA=[], log10P_FA=[])
+
+    if not C.any():            # the case when cross-correlation C has zero energy (see crosscor2)
+        Out['PCE'] = 0
+        Out['pvalue'] = 1
+        Out['PeakLocation'] = [0,0]
+        return
+
+    Cinrange = C[-1-shift_range[0]:,-1-shift_range[1]:]  	# C[-1,-1] location corresponds to no shift of the first matrix argument of 'crosscor2'
+    [max_cc, imax] = np.max(Cinrange.flatten()), np.argmax(Cinrange.flatten())
+    [ypeak, xpeak] = np.unravel_index(imax,Cinrange.shape)[0], np.unravel_index(imax,Cinrange.shape)[1]
+    Out['peakheight'] = Cinrange[ypeak,xpeak]
+    del Cinrange
+    Out['PeakLocation'] = [shift_range[0]-ypeak, shift_range[1]-xpeak]
+
+    C_without_peak = _RemoveNeighborhood(C,
+                                         np.array(C.shape)-Out['PeakLocation'],
+                                         squaresize)
+    correl = C[-1,-1];        del C
+
+    # signed PCE, peak-to-correlation energy
+    PCE_energy = np.mean(C_without_peak*C_without_peak)
+    Out['PCE'] = (Out['peakheight']**2)/PCE_energy * np.sign(Out['peakheight'])
+
+    # p-value
+    Out['pvalue'] = 1/2*special.erfc(Out['peakheight']/np.sqrt(PCE_energy)/np.sqrt(2))     # under simplifying assumption that C are samples from Gaussian pdf
+    [Out['P_FA'], Out['log10P_FA']] = _FAfromPCE(Out['PCE'], np.prod(shift_range+1))
+
+    Out0 = dict(PCE=[], P_FA=[], log10P_FA=[])
+    Out0['PCE'] = (correl**2)/PCE_energy
+    Out0['P_FA'], Out0['log10P_FA'] = _FAfromPCE(Out0['PCE'],1)
+    return Out, Out0
+# ----------------------------------------
+
+def _RemoveNeighborhood(X,x,ssize):
+    # Remove a 2-D neighborhood around x=[x1,x2] from matrix X and output a 1-D vector Y
+    # ssize     square neighborhood has size (ssize x ssize) square
+    [M,N] = X.shape
+    radius = (ssize-1)/2
+    X = np.roll(X,[int(radius-x[0]),int(radius-x[1])], axis=[0,1]) 
+    Y = X[ssize:,:ssize];   Y = Y.flatten()
+    Y = np.concatenate([Y, X.flatten()[int(M*ssize):]], axis=0)
+    return Y
+
+def _FAfromPCE(pce,search_space):
+    # Calculates false alarm probability from having peak-to-cross-correlation (PCE) measure of the peak
+    # pce           PCE measure obtained from PCE.m
+    # seach_space   number of correlation samples from which the maximum is taken
+    #  USAGE:   FA = FAfromPCE(31.5,32*32);
+
+    [p,logp] = Fu.Qfunction(np.sign(pce)*np.sqrt(np.abs(pce)))
+    if pce<50:
+        FA = np.power(1-(1-p),search_space)
+    else:
+        FA = search_space*p                # an approximation
+
+    if FA==0:
+        FA = search_space*p
+        log10FA = np.log10(search_space)+logp*np.log10(np.exp(1))
+    else:
+        log10FA = np.log10(FA)
+
+    return FA, log10FA