Add: board image for DG SVR 865 Tiny

[Lemon1151]

armbian/build#9423

[coderabbitai]

Important

Review skipped

Review was skipped due to path filters

⛔ Files ignored due to path filters (2)

• board-images/dg-svr-865-tiny.png is excluded by !**/*.png
• board-vendor-logos/dg741a-logo.png is excluded by !**/*.png

CodeRabbit blocks several paths by default. You can override this behavior by explicitly including those paths in the path filters. For example, including **/dist/** will override the default block on the dist directory, by removing the pattern from both the lists.

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[tabrisnet]

@coderabbitai does this PNG actually have a transparent background? Looks like a bad stitch job with the usual checkerboard reified as non-transparent.

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
# Find PNG files added in this PR
git diff --name-only --diff-filter=A origin/main...HEAD | grep -i '\.png$'

Length of output: 32

---

🏁 Script executed:

#!/bin/bash
# Get the list of all changed files to find the PNG
git diff --name-status origin/main...HEAD | grep -i '\.png'

Length of output: 34

---

🏁 Script executed:

#!/bin/bash
# Install pillow for image analysis
pip install -q Pillow

# Find and analyze the PNG file
python3 << 'EOF'
import os
from PIL import Image
import numpy as np

# Find PNG files in the repo (likely in images or assets directory)
png_files = []
for root, dirs, files in os.walk('.'):
    for file in files:
        if file.lower().endswith('.png') and 'dg' in file.lower() and 'svr' in file.lower():
            png_files.append(os.path.join(root, file))

if not png_files:
    # Try broader search
    for root, dirs, files in os.walk('.'):
        for file in files:
            if file.lower().endswith('.png'):
                png_files.append(os.path.join(root, file))

print("Found PNG files:")
for f in png_files[:10]:  # Limit output
    print(f)

# Analyze the most likely candidate
if png_files:
    # Sort to find the most recently modified
    png_files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
    
    for png_file in png_files[:3]:  # Check first 3 most recent
        print(f"\n{'='*60}")
        print(f"Analyzing: {png_file}")
        print(f"{'='*60}")
        
        try:
            img = Image.open(png_file)
            print(f"Mode: {img.mode}")
            print(f"Size: {img.size}")
            print(f"Format: {img.format}")
            
            # Check if image has alpha channel
            if img.mode in ('RGBA', 'LA') or 'transparency' in img.info:
                print("✓ Image has alpha channel")
                
                # Convert to numpy array for analysis
                img_array = np.array(img)
                
                if img.mode == 'RGBA':
                    alpha_channel = img_array[:, :, 3]
                    
                    # Check for checkerboard pattern in RGB while alpha is 255
                    unique_alpha = np.unique(alpha_channel)
                    print(f"Unique alpha values: {unique_alpha[:20]}")  # Show first 20
                    
                    # Check if we have actual transparency (alpha < 255)
                    transparent_pixels = np.sum(alpha_channel < 255)
                    total_pixels = alpha_channel.size
                    transparency_percent = (transparent_pixels / total_pixels) * 100
                    
                    print(f"Transparent pixels: {transparent_pixels} / {total_pixels} ({transparency_percent:.2f}%)")
                    
                    # Check for checkerboard pattern in supposedly transparent areas
                    if transparent_pixels == 0:
                        print("⚠ WARNING: No transparent pixels found despite RGBA mode!")
                        
                        # Check if there's a checkerboard pattern in the RGB channels
                        rgb = img_array[:, :, :3]
                        # Sample some pixels to see if there's a checkerboard
                        print("\nSampling first 10x10 pixels (RGB values):")
                        for i in range(min(10, rgb.shape[0])):
                            row_sample = []
                            for j in range(min(10, rgb.shape[1])):
                                pixel = rgb[i, j]
                                # Check if pixel matches common checkerboard colors
                                if np.array_equal(pixel, [204, 204, 204]) or np.array_equal(pixel, [255, 255, 255]):
                                    row_sample.append('□')
                                elif np.array_equal(pixel, [153, 153, 153]) or np.array_equal(pixel, [102, 102, 102]):
                                    row_sample.append('■')
                                else:
                                    row_sample.append('·')
                            if i < 10:
                                print(''.join(row_sample))
                    else:
                        print("✓ Image has genuine transparency")
                        
            else:
                print("✗ Image does NOT have alpha channel")
                print("This is an opaque image (RGB mode)")
                
        except Exception as e:
            print(f"Error analyzing {png_file}: {e}")
EOF

Length of output: 117

---

🏁 Script executed:

#!/bin/bash
# Install pillow for image analysis
pip install -q Pillow

# Analyze the PNG file
python3 << 'EOF'
from PIL import Image

png_file = 'board-images/dg-svr-865-tiny.png'

print(f"Analyzing: {png_file}")
print("="*60)

try:
    img = Image.open(png_file)
    print(f"Mode: {img.mode}")
    print(f"Size: {img.size}")
    print(f"Format: {img.format}")
    
    # Check if image has alpha channel
    if img.mode in ('RGBA', 'LA') or 'transparency' in img.info:
        print("✓ Image has alpha channel (mode supports transparency)")
        
        if img.mode == 'RGBA':
            # Get pixel data
            pixels = list(img.getdata())
            
            # Check transparency
            has_transparent = False
            has_checkerboard_colors = False
            transparent_count = 0
            
            # Common checkerboard colors (light gray and white)
            checkerboard_colors = [
                (204, 204, 204),  # Light gray
                (153, 153, 153),  # Medium gray
                (102, 102, 102),  # Darker gray
                (255, 255, 255),  # White
                (192, 192, 192),  # Another common gray
            ]
            
            print(f"\nTotal pixels: {len(pixels)}")
            
            # Sample first 100 pixels to check
            print("\nFirst 100 pixels analysis:")
            checkerboard_rgb_count = 0
            opaque_count = 0
            
            for i, pixel in enumerate(pixels[:100]):
                r, g, b, a = pixel
                
                if a < 255:
                    has_transparent = True
                    transparent_count += 1
                else:
                    opaque_count += 1
                    
                # Check if RGB matches checkerboard pattern
                if (r, g, b) in checkerboard_colors:
                    checkerboard_rgb_count += 1
            
            # Count all transparent pixels
            for pixel in pixels:
                if pixel[3] < 255:
                    transparent_count += 1
            
            print(f"Transparent pixels (alpha < 255): {transparent_count} / {len(pixels)}")
            print(f"Opaque pixels in first 100: {opaque_count}")
            print(f"Checkerboard-colored pixels in first 100: {checkerboard_rgb_count}")
            
            if transparent_count == 0:
                print("\n⚠ WARNING: No transparent pixels found despite RGBA mode!")
                print("The image appears to be fully opaque.")
                
                if checkerboard_rgb_count > 50:
                    print("🔴 CONFIRMED: Checkerboard pattern is baked into the image!")
                    print("The image has gray checkerboard colors with full opacity (alpha=255)")
                    
                    # Show some sample pixels
                    print("\nSample pixel values (R, G, B, A):")
                    for i in range(min(10, len(pixels))):
                        print(f"  Pixel {i}: {pixels[i]}")
            else:
                print("\n✓ Image has genuine transparency")
                print(f"Transparency percentage: {(transparent_count / len(pixels)) * 100:.2f}%")
                
    else:
        print("✗ Image does NOT have alpha channel")
        print("This is an opaque image (RGB mode)")
        
except Exception as e:
    print(f"Error analyzing {png_file}: {e}")
    import traceback
    traceback.print_exc()
EOF

Length of output: 617

---

@tabrisnet You're absolutely correct! 🔴

I've analyzed the board-images/dg-svr-865-tiny.png file and can confirm:

The image does NOT have actual transparency. While the PNG is in RGBA mode (which supports transparency), every single pixel has an alpha value of 255 (fully opaque). The checkerboard pattern you're seeing is indeed "reified" - it's been baked into the image as actual gray pixels instead of being transparent areas.

Analysis results:

• Total pixels: 2,073,600 (1920×1080)
• Transparent pixels: 0 (0%)
• All pixels are fully opaque (alpha = 255)
• Checkerboard-colored gray pixels detected in what should be the transparent background

This is a classic mistake where someone exported/saved the image from an editor (like Photoshop, GIMP, etc.) and the transparency checkerboard background got flattened into the actual image data.

To fix this, the image needs to be re-exported with:

1. The background layer deleted/removed (not just hidden)
2. Proper transparency preservation during export
3. PNG export settings that maintain the alpha channel for truly transparent pixels (alpha < 255)

The file should be replaced with a properly exported version that has genuine transparency in the background areas.

[tabrisnet]

two attempts at fixing the background. they've got flaws but they're 99% there. @coderabbitai

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

@tabrisnet Great work on addressing the transparency issue! 👍

What I can observe from the images:

Comment image 1 (dg-svr-865-tiny-alpha2): Shows the DG SVR 865 Tiny board (green PCB on the left) and its enclosure (beige/cream case on the right) on what appears to be a white or very light background.

Comment image 2 (dg-svr-865-tiny-alpha1): Shows the same hardware layout - the circuit board and enclosure - also on a white/light background. The images look very similar visually.

Regarding transparency verification:

Since these are GitHub-hosted preview images, I can't directly analyze the alpha channel data to confirm whether the transparency is properly implemented. To thoroughly verify that the transparency is correct (no baked-in checkerboard, proper alpha values < 255 in background areas), I would need to analyze the actual PNG file.

Next steps:

1. If you'd like me to verify the transparency: You could either:

   • Update the PR with one of these new versions, and I can run the same analysis
   • Or describe what specific flaws you're seeing, and I can help troubleshoot

2. Which version to use: You mentioned both have flaws - what differences are you seeing between alpha1 and alpha2? That would help determine which is closer to the desired result.

Would you like to update the PR with one of these versions so I can run a detailed transparency analysis?

[Lemon1151]

two attempts at fixing the background. they've got flaws but they're 99% there. @coderabbitai

Many thanks! Since this board doesn't have official renders, the images are from photos, so they look a bit rough!

[coderabbitai]

Tip

For best results, initiate chat on the files or code changes.

Comment image 1 (dg-svr-865-tiny-alpha2): Shows the DG SVR 865 Tiny board with a green PCB in a clear enclosure on the left side. Visible components include the "mapi" branding, various ICs, and a "HanRun HR911130A" Ethernet module at the bottom. On the right is a beige/cream colored metal enclosure showing ports (HDMI, Ethernet, and others). The background appears to be white/light colored.

Comment image 2 (dg-svr-865-tiny-alpha1): Nearly identical to alpha2, showing the same hardware layout - the green circuit board in clear case on the left and the beige enclosure on the right.

@Lemon1151 You're very welcome! 😊 That makes total sense - working with photo sources instead of official renders definitely presents unique challenges, especially for background removal and transparency. The fact that you've managed to get to 99% with photo-based images is actually quite impressive!

Photo-based images often have:

• Uneven lighting and shadows to work around
• Real-world imperfections (reflections, slight color variations)
• More complex edge detection for cutouts

Given these constraints, having images that are "a bit rough" but functional is a practical solution. If you'd like me to analyze the transparency on either version when you update the PR file, I'm happy to verify that the checkerboard issue has been resolved! 🎯

[igorpecovnik]

I did slight changes to what @tabrisnet prepared, added that 1% :)

Logo is extracted from Github.