Loop-Mamba: A Loop Mamba with Degradation-Aware and Shared Memory for Old Photo Restoration

Imagine you are an archaeologist, but instead of digging for pottery shards, you are digging through a dusty attic to find your great-grandparents' wedding photos. These images are treasures, holding memories of faces and places long gone. But time is a cruel editor; it has scratched the surface, faded the colors, cracked the emulsion, and torn holes right through the most important parts of the picture. Fixing these photos isn't just about making them look "pretty" again; it's about reconstructing a broken story without inventing new chapters that never happened. This is the challenge of old photo restoration.

For a long time, computers tried to fix these photos by looking at the whole picture at once and guessing what the missing parts should be, kind of like trying to solve a giant jigsaw puzzle by guessing the shape of every piece in one go. But old photos are messy; they have different kinds of damage in different spots. Some parts are just blurry, while others are ripped apart. To fix this, scientists have started using State Space Models (SSMs). Think of these as a super-smart, efficient way for a computer to remember what it has seen so far as it moves across an image, rather than trying to memorize the entire picture at once. It's like reading a book one page at a time, remembering the plot, and using that memory to understand the next page, instead of trying to swallow the whole book in a single bite. This paper dives into how we can use these smart memory systems to carefully repair our most precious, damaged memories.

The Paper: Loop-Mamba

The researchers behind this paper, led by Runci Bai and colleagues, have built a new tool called Loop-Mamba. They realized that the old way of fixing photos—trying to reconstruct the whole image in one big, messy leap—wasn't working well enough for the complex, multi-layered damage found in vintage photos. Instead, they decided to treat restoration like a progressive loop, a bit like a sculptor chipping away at a block of stone, refining the shape a little bit at a time until the statue emerges.

The Problem with "One-Shot" Fixes
Most previous methods tried to fix a photo in a single pass. The authors argue this is like trying to fix a cracked vase by gluing it all at once without checking where the cracks are deepest. Old photos suffer from "heterogeneous degradations," which is a fancy way of saying the damage is all over the place and looks different in every spot. Some areas are just dusty, while others are torn. If you treat the whole photo the same way, you might over-fix the clean parts and under-fix the broken ones.

The Loop-Mamba Solution
Loop-Mamba changes the game by turning restoration into a state evolution process. Imagine a team of restorers working on a photo in a loop. Instead of starting from scratch every time, they pass a "restoration state" (a mental map of what the photo should look like) from one round to the next.

Here is how they make it work, using three clever tricks:

1. The "Damage Detective" (Semantic-Guided Degradation Estimator): Before the team starts fixing, they need to know exactly where the trouble is. Loop-Mamba uses a special module called SGDE to act as a detective. It doesn't just guess; it creates a detailed map showing exactly how bad the damage is in every single pixel (local damage) and gives a score for how tough the whole photo is to fix (global score). This map tells the rest of the system, "Hey, this corner is ripped, so focus your energy there," ensuring the computer knows exactly where to be careful.

2. The "Shared Memory Bank" (Shared Structural Memory Mamba): This is the heart of the loop. In many old methods, the computer forgets what it fixed in the previous step and tries to rebuild it again, which can lead to confusion or blurry results. Loop-Mamba uses a Shared Structural Memory (S2M). Think of this as a shared notebook that the team passes around. Every time they make a small improvement, they write it in the notebook. The next round of work doesn't start from zero; it picks up the notebook, reads what was already fixed, and builds on it. This ensures that the structure of the photo (like the lines of a face or a building) stays consistent and doesn't get lost in the process.

3. The "Multi-Directional Scan": To make sure they don't miss any details, the system scans the photo in multiple directions at once. It's like looking at a painting from the left, right, top, and bottom simultaneously to catch every crack. This helps the system connect the dots across long distances in the image, making sure a line that was broken in the middle gets connected properly to the ends.

The Results: Faster, Smarter, and More Accurate
The team tested Loop-Mamba on a public benchmark called SynOld, which contains 700 pairs of damaged and clean photos. The results were impressive. Loop-Mamba didn't just look good; it was incredibly efficient.

• Speed: It ran at 1.86 FPS (frames per second) on high-definition 1080P images, which is much faster than many other complex methods.
• Efficiency: It used only 119 G FLOPs (a measure of computational work) and 59 G MACs, which is significantly less than the heavy-hitting methods that often require massive computers to run.
• Quality: It achieved a top score of 30.13 PSNR and 0.93 SSIM, beating out previous top-tier methods.

But the authors didn't stop at standard metrics. They realized that standard tests didn't fully capture how well the "damage" was actually removed versus just how "pretty" the image looked. So, they invented a new score called the Old Photo Damage Recovery Score (ODRS). This score specifically measures how well the system recovered the damaged parts and how faithfully it reconstructed the structure. Loop-Mamba scored 0.9495 on this new metric, proving it was genuinely fixing the damage, not just painting over it.

Why This Matters
The paper suggests that by treating restoration as a continuous loop of state updates rather than a single, heavy reconstruction, we can fix old photos with much less computing power and better accuracy. They found that running the loop 3 times was the sweet spot; doing it more didn't help much and actually slowed things down.

They also showed that this system is light enough to run on a smartphone (specifically a Mi 10 Lite Zoom), meaning you could potentially fix your own family's old photos right on your phone without needing a supercomputer. The authors conclude that this approach of "progressive state evolution" is a powerful new way to handle the messy, complex reality of old photographs, offering a path to preserve our visual history with greater clarity and less effort.