Watermark Removal

https://github.com/zuruoke/watermark-removal
Admin
An open-source machine learning project that uses image inpainting techniques to remove watermarks...
Tokens:4,062
Snippets:22
Trust Score:8.3
Update:7 months ago
Show doc for...
Tokens:
Raw
### Docker Deployment for Watermark Removal

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

This section provides bash commands for building a Docker image and running inference for the watermark-removal project. It covers building the image, running inference with specified model checkpoints, input/output paths, and watermark types, including an example for GPU support using nvidia-docker.

```bash
# Build Docker image
docker build -t watermark-removal .

# Download pretrained model from Google Drive link in README
# Place model files in local directory

# Run inference
docker run --rm \
    -v '/local/path/to/model:/repo/model' \
    -v '/local/path/to/images:/input' \
    -v '/local/path/to/output:/output' \
    watermark-removal \
    --checkpoint_dir /repo/model \
    --image '/input/photo_with_watermark.jpg' \
    --output '/output/photo_clean.png' \
    --watermark_type istock

# For GPU support (requires nvidia-docker)
docker run --rm --gpus all \
    -v '/local/path/to/model:/repo/model' \
    -v '/local/path/to/images:/input' \
    -v '/local/path/to/output:/output' \
    watermark-removal \
    --checkpoint_dir /repo/model \
    --image '/input/photo_with_watermark.jpg' \
    --output '/output/photo_clean.png' \
    --watermark_type istock
```

--------------------------------

### Build Inpainting Model Server Graph (TensorFlow)

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Illustrates the process of initializing the `InpaintCAModel` and building its server graph for inference using TensorFlow. It takes the preprocessed input tensor (image and mask concatenated), generates the inpainted output, and includes post-processing steps to scale pixel values and convert color channels. Requires loading pretrained weights.

```python
import tensorflow as tf
import neuralgym as ng
from inpaint_model import InpaintCAModel

# Initialize configuration and model
FLAGS = ng.Config('inpaint.yml')
model = InpaintCAModel()

# Build server graph for inference
# input_tensor: shape (1, H, W*2, 3) - image and mask concatenated along width
input_image = tf.constant(preprocessed_input, dtype=tf.float32)
output = model.build_server_graph(FLAGS, input_image)

# Post-process output: scale from [-1,1] to [0,255]
output = (output + 1.) * 127.5
output = tf.reverse(output, [-1])  # BGR to RGB
output = tf.saturate_cast(output, tf.uint8)

# Run inference in session
with tf.Session() as sess:
    # Load pretrained weights
    vars_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
    for var in vars_list:
        var_value = tf.contrib.framework.load_variable('model/', var.name)
        sess.run(tf.assign(var, var_value))

    # Generate clean image
    result = sess.run(output)  # Shape: (1, H, W, 3)
    cv2.imwrite('output.png', result[0][:, :, ::-1])
```

--------------------------------

### Execute Single Image Watermark Removal (Python & Docker)

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Demonstrates how to run the watermark removal process for a single image using the project's main entry point script. Includes command-line usage with Python and equivalent Docker command for containerized execution. Requires specifying input image, output path, model checkpoint directory, and watermark type.

```shell
# Command line usage for single image watermark removal
python main.py --image path/to/watermarked_image.jpg \
               --output path/to/clean_image.png \
               --checkpoint_dir model/ \
               --watermark_type istock

# Docker usage
docker run --rm \
    -v '/path/to/model:/repo/model'
    -v '/path/to/input:/input'
    -v '/path/to/output:/output'
    watermark-removal \
    --checkpoint_dir /repo/model \
    --image '/input/watermarked.jpg' \
    --output '/output/clean.png' \
    --watermark_type istock
```

--------------------------------

### Preprocess Image for Watermark Removal (Python)

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Shows how to use the `preprocess_image` function to prepare an input image for the watermark removal model. This involves loading an image using PIL, applying the appropriate watermark mask based on type and orientation, and returning a preprocessed tensor ready for model inference. Handles aspect ratio validation and resizing.

```python
from PIL import Image
from preprocess_image import preprocess_image

# Load a watermarked image
image = Image.open("watermarked_photo.jpg")

# Preprocess with appropriate watermark type mask
# Returns concatenated [image, mask] array ready for model inference
# Supported watermark_type: 'istock' (with landscape/portrait masks in utils/)
input_tensor = preprocess_image(image, watermark_type='istock')

# Check if image was processed successfully
if input_tensor.shape != (0,):
    # input_tensor shape: (1, H, W*2, 3) - image and mask concatenated
    print(f"Preprocessed tensor shape: {input_tensor.shape}")
else:
    print("Image size not supported - aspect ratio mismatch with mask")
```

--------------------------------

### Inpainting Model Configuration (YAML)

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Defines the configuration for the inpainting model, including hardware settings, model architecture, training parameters, and loss functions. This file is essential for both training the model and performing inference. It controls aspects like GAN type, image dimensions, batch size, and loss weights.

```yaml
# inpaint.yml - Key configuration options

# Hardware settings
num_gpus_per_job: 1
num_cpus_per_job: 4
memory_per_job: 32
gpu_type: 'nvidia-tesla-p100'

# Model settings
name: places2_gated_conv_v100
gan: 'sngan'                    # GAN type: spectral normalization GAN
gan_loss_alpha: 1               # GAN loss weight
gan_with_mask: True             # Include mask in discriminator input
padding: 'SAME'                 # Convolution padding mode

# Image dimensions
img_shapes: [256, 256, 3]       # Input image dimensions [H, W, C]
height: 128                     # Mask height for training
width: 128                      # Mask width for training
batch_size: 16                  # Training batch size

# Training parameters
max_iters: 100000000            # Maximum training iterations
train_spe: 4000                 # Steps per epoch
viz_max_out: 10                 # Number of visualization outputs

# Loss configuration
ae_loss: True                   # Enable autoencoder reconstruction loss
l1_loss: True                   # Enable L1 loss
l1_loss_alpha: 1.               # L1 loss weight

# Edge guidance (optional)
guided: False                   # Enable edge-guided inpainting
edge_threshold: 0.6             # Edge detection threshold
```

--------------------------------

### Python Mask Generation Utilities for Inpainting

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

This Python snippet showcases utilities for creating and manipulating masks used in image inpainting. It includes functions for generating random bounding boxes, converting bounding boxes to masks, creating irregular brush stroke masks, and resizing masks to match feature tensor dimensions. These are crucial for training and inference.

```python
from inpaint_ops import random_bbox, bbox2mask, brush_stroke_mask, resize_mask_like

# Generate random bounding box for training
# Returns (top, left, height, width) tuple
bbox = random_bbox(FLAGS)  # Uses img_shapes, margins from config

# Convert bounding box to binary mask tensor
mask = bbox2mask(
    FLAGS=config,             # Configuration with img_shapes
    bbox=bbox,                # (top, left, height, width) tuple
    name='rect_mask'
)
# Output shape: (1, H, W, 1), values 0 or 1

# Generate irregular brush stroke mask for more realistic training
irregular_mask = brush_stroke_mask(
    FLAGS=config,             # Configuration with img_shapes
    name='brush_mask'
)
# Output shape: (1, H, W, 1), random brush strokes

# Resize mask to match feature tensor dimensions
# Useful when mask needs to match downsampled feature maps
resized_mask = resize_mask_like(
    mask=original_mask,       # Original mask tensor
    x=feature_tensor          # Target tensor to match dimensions
)
```

--------------------------------

### Build Inpainting Network Generator (Python)

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Details the construction of the two-stage generator network within the `InpaintCAModel` class. This method performs both coarse inpainting and refinement using contextual attention. It accepts the incomplete image and a mask tensor as input and outputs intermediate and final inpainted results, along with an optional attention flow visualization.

```python
from inpaint_model import InpaintCAModel

model = InpaintCAModel()

# Build the inpainting network
# x: incomplete image tensor, normalized to [-1, 1]
# mask: binary mask tensor, 1 = masked region, 0 = valid pixels
x_stage1, x_stage2, offset_flow = model.build_inpaint_net(
    x=incomplete_image,      # Shape: (batch, H, W, 3)
    mask=mask_tensor,        # Shape: (batch, H, W, 1)
    reuse=False,             # Reuse variables (for multiple calls)
    training=False,          # Training mode enables batch normalization updates
    padding='SAME',          # Padding mode: 'SAME', 'SYMMETRIC', 'REFLECT'
    name='inpaint_net'
)

# x_stage1: Coarse inpainting result, shape (batch, H, W, 3)
# x_stage2: Refined result with contextual attention, shape (batch, H, W, 3)
# offset_flow: Attention flow visualization for debugging
```

--------------------------------

### Contextual Attention Layer for Image Inpainting

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Implements the core attention mechanism for watermark removal by finding and copying relevant patches from known regions to fill masked areas. It leverages texture similarity for visually coherent results. Takes foreground features, background features, and a mask as input, producing reconstructed features and optical flow.

```python
from inpaint_ops import contextual_attention

# Apply contextual attention between foreground (to fill) and background (reference)
# f: foreground features from masked region
# b: background features from valid image regions
output, flow = contextual_attention(
    f=foreground_features,    # Shape: (batch, H, W, C)
    b=background_features,    # Shape: (batch, H, W, C)
    mask=mask_tensor,         # Shape: (batch, H, W, 1), 1=masked
    ksize=3,                  # Kernel size for patch extraction
    stride=1,                 # Stride for patch extraction
    rate=2,                   # Dilation rate for matching
    fuse_k=3,                 # Kernel size for fusing attention scores
    softmax_scale=10.,        # Temperature for softmax attention
    training=True,            # Training mode flag
    fuse=True                 # Enable score fusion for larger coherent patches
)

# output: Reconstructed features with borrowed patches, shape (batch, H, W, C)
# flow: Optical flow visualization showing which patches were copied
```

--------------------------------

### Batch Image Processing with Python

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Processes multiple images in batch mode using a file list for efficient, large-scale operations. It loads the model once and reuses it for all images. Requires input image paths, mask paths, and output paths defined in a file list.

```python
# Create a file list (flist.txt) with format: input_path mask_path output_path
# watermarked1.jpg mask1.png clean1.png
# watermarked2.jpg mask2.png clean2.png

# Run batch processing
python batch_test.py \
    --flist flist.txt \
    --image_height 256 \
    --image_width 256 \
    --checkpoint_dir model/

# Programmatic batch processing
import cv2
import numpy as np
import tensorflow as tf
import neuralgym as ng
from inpaint_model import InpaintCAModel

FLAGS = ng.Config('inpaint.yml')
model = InpaintCAModel()

# Setup placeholders for batch processing
image_height, image_width = 256, 256
input_image_ph = tf.placeholder(
    tf.float32,
    shape=(1, image_height, image_width * 2, 3)  # Image + mask concatenated
)
output = model.build_server_graph(FLAGS, input_image_ph)
output = (output + 1.) * 127.5
output = tf.saturate_cast(output, tf.uint8)

with tf.Session() as sess:
    # Load model weights once
    vars_list = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)
    for var in vars_list:
        var_value = tf.contrib.framework.load_variable('model/', var.name)
        sess.run(tf.assign(var, var_value))

    # Process each image
    for image_path, mask_path, output_path in file_list:
        image = cv2.resize(cv2.imread(image_path), (image_width, image_height))
        mask = cv2.resize(cv2.imread(mask_path), (image_width, image_height))

        # Concatenate image and mask
        input_image = np.concatenate([
            np.expand_dims(image, 0),
            np.expand_dims(mask, 0)
        ], axis=2)

        result = sess.run(output, feed_dict={input_image_ph: input_image})
        cv2.imwrite(output_path, result[0][:, :, ::-1])
```

--------------------------------

### TensorFlow Convolutional Layers for Image Processing

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

This snippet demonstrates the use of TensorFlow's gen_conv and gen_deconv functions for image processing tasks like downsampling, upsampling, and atrous convolution. It highlights parameters such as input tensor, number of channels, kernel size, stride, dilation rate, padding, activation function, and training mode.

```python
x = gen_conv(
    x=input_tensor,           # Input feature tensor
    cnum=96,                  # Number of output channels (doubled internally for gating)
    ksize=3,                  # Kernel size
    stride=2,                 # Convolution stride (2 for downsampling)
    rate=1,                   # Dilation rate (>1 for atrous convolution)
    name='conv_downsample',
    padding='SAME',           # 'SAME', 'SYMMETRIC', or 'REFLECT'
    activation=tf.nn.elu,     # Activation function
    training=True             # Enables batch norm updates
)

x = gen_deconv(
    x=input_tensor,           # Input feature tensor
    cnum=48,                  # Number of output channels
    name='upsample',
    padding='SAME',
    training=True
)

x = gen_conv(x, cnum=192, ksize=3, rate=4, name='conv_atrous')
```

--------------------------------

### Generator Convolution Operations in Python

Source: https://context7.com/zuruoke/watermark-removal/llms.txt

Provides custom convolution and deconvolution layers with gated activation for the generator network. These operations are designed to improve gradient flow and allow for better feature modulation within the generator. They are part of the inpaint_ops module.

```python
from inpaint_ops import gen_conv, gen_deconv

# Generator convolution with gated activation

```
Tokens:
Raw