Command Line Applications in Go

Locked video

Please purchase the course to watch this video.

Powerful Command Line Applications

Working with images

The Go standard library offers extensive functionality for image manipulation, exemplified by the image package, which allows developers to encode, decode, and manipulate various image formats effortlessly. Through the creation of a simple CLI application, users can convert PNG images into JPEG format while handling transparency by setting a background color. The lesson guides the implementation process, starting from reading a PNG file to encoding it as JPEG, and explores options to adjust the image quality and background color using the draw package. Key takeaways include the powerful capabilities within Go's library for image processing and project extensions like supporting JPEG to PNG conversion and adding CLI options for background color and image padding, showcasing Go’s versatility in building applications without relying on external dependencies.

When it comes to building applications with Go, something that still takes me by surprise is how much functionality is provided by the Go standard library.

Real-World Example

Recently, when building out the CMS CLI for my Dreams of Code website in order to upload videos, I needed a feature where I was able to take the first frame of a video and convert it into a JPEG file.

Initially, I went about implementing this using ImageMagick, which is a CLI tool to convert between different image formats. However, as it turns out, I didn't need to do this, due to the fact that Go itself provides its own image package inside of the standard library.

The Go Image Package

The image package implements a basic 2D image library, allowing you to perform:

Basic image encoding and decoding
Image format conversion
Simple image manipulation
Drawing operations

Available Sub-packages

If we look at the image package documentation, it provides several sub-packages:

Package	Purpose
`image/color`	Basic color library and color models
`image/draw`	2D drawing operations and compositing
`image/gif`	GIF format encoding and decoding
`image/jpeg`	JPEG format encoding and decoding
`image/png`	PNG format encoding and decoding

Project Goal: PNG to JPEG Converter

In this lesson, we're going to create a simple CLI application to convert between PNG and JPEG formats, demonstrating the core concepts of Go image processing.

Project Setup

Project Structure:

image-converter/
├── main.go
├── gopher.png    # Sample image (download from lesson resources)
└── go.mod

Basic CLI Interface

Our CLI application will:

Take a filename as the first command-line argument
Check if the file is a PNG image
Convert it to JPEG format
Handle background color conversion (PNG transparency → JPEG solid color)

main.go (initial structure):

package main

import (
    "fmt"
    "log"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        log.Fatal("Usage: go run main.go <image.png>")
    }
    
    filename := os.Args[1]
    fmt.Printf("Converting %s...\n", filename)
    
    // TODO: Implement conversion logic
}

Testing the Basic Structure

bash

go run main.go gopher.png
# Output: Converting gopher.png...

Step 1: Loading and Decoding PNG Images

First, let's load a PNG image into memory using Go's image/png package.

Understanding Image Decoding

The image/png package provides functions for:

Decoding PNG data from an io.Reader
Encoding image data to PNG format
Compression options for PNG output

main.go (with PNG loading):

package main

import (
    "fmt"
    "image"
    "image/png"
    "log"
    "os"
)

func main() {
    if len(os.Args) < 2 {
        log.Fatal("Usage: go run main.go <image.png>")
    }
    
    filename := os.Args[1]
    fmt.Printf("Converting %s...\n", filename)
    
    // Open the PNG file
    file, err := os.Open(filename)
    if err != nil {
        log.Fatalf("Error opening file: %v", err)
    }
    defer file.Close()
    
    // Decode PNG image
    sourceImage, err := png.Decode(file)
    if err != nil {
        log.Fatalf("Error decoding PNG: %v", err)
    }
    
    fmt.Printf("Image loaded: %dx%d\n", 
        sourceImage.Bounds().Dx(), sourceImage.Bounds().Dy())
}

Key Concepts

Image Interface

type Image interface {
    ColorModel() color.Model
    Bounds() Rectangle
    At(x, y int) color.Color
}

The image.Image interface represents a finite rectangular grid of colors.

Automatic Format Detection

The PNG decoder automatically validates the file format:

bash

# This will work
go run main.go gopher.png

# This will fail with "invalid format: not a PNG file"
go run main.go invalid.jpg

Step 2: Converting to JPEG Format

Now let's add JPEG encoding using the image/jpeg package.

Understanding JPEG Encoding

JPEG encoding requires:

An io.Writer destination
An image.Image source
Optional quality settings

main.go (with JPEG encoding):

package main

import (
    "fmt"
    "image"
    "image/jpeg"
    "image/png"
    "log"
    "os"
    "path/filepath"
    "strings"
)

func main() {
    if len(os.Args) < 2 {
        log.Fatal("Usage: go run main.go <image.png>")
    }
    
    filename := os.Args[1]
    fmt.Printf("Converting %s...\n", filename)
    
    // Open and decode PNG
    file, err := os.Open(filename)
    if err != nil {
        log.Fatalf("Error opening file: %v", err)
    }
    defer file.Close()
    
    sourceImage, err := png.Decode(file)
    if err != nil {
        log.Fatalf("Error decoding PNG: %v", err)
    }
    
    // Create output filename
    imageName := strings.TrimSuffix(filename, filepath.Ext(filename))
    outFilename := fmt.Sprintf("%s.jpeg", imageName)
    
    // Create output file
    outFile, err := os.OpenFile(outFilename, 
        os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
    if err != nil {
        log.Fatalf("Error creating output file: %v", err)
    }
    defer outFile.Close()
    
    // Encode as JPEG
    if err := jpeg.Encode(outFile, sourceImage, nil); err != nil {
        log.Fatalf("Error encoding JPEG: %v", err)
    }
    
    fmt.Println("Image converted successfully!")
}

Understanding File Creation Flags

os.O_WRONLY|os.O_CREATE|os.O_EXCL

os.O_WRONLY - Write-only mode
os.O_CREATE - Create file if it doesn't exist
os.O_EXCL - Fail if file already exists (prevents overwriting)

Testing the Conversion

bash

go run main.go gopher.png
# Output: Image converted successfully!

ls -lah *.png *.jpeg
# Compare file sizes - JPEG should be smaller

Step 3: JPEG Quality Control

JPEG encoding supports quality settings to balance file size vs image quality.

JPEG Options

main.go (with quality control):

// Replace the jpeg.Encode line with:
options := &jpeg.Options{
    Quality: 50, // Range: 0-100 (higher is better quality)
}

if err := jpeg.Encode(outFile, sourceImage, options); err != nil {
    log.Fatalf("Error encoding JPEG: %v", err)
}

Quality Comparison

Quality	File Size	Use Case
100	Largest	Professional photography
80-90	Large	High-quality images
50-70	Medium	Web images, general use
10-30	Small	Thumbnails, low bandwidth

Testing Different Qualities

bash

# Test different quality settings
go run main.go gopher.png  # Quality 50
ls -lah gopher.jpeg        # Check size

# Modify code to quality 10, then 90, and compare

Step 4: Handling Transparency (PNG → JPEG)

PNG supports transparency (alpha channel), but JPEG doesn't. When converting, transparent areas become black by default. Let's fix this by adding a custom background.

The Transparency Problem

PNG: Supports RGBA (Red, Green, Blue, Alpha)
JPEG: Only supports RGB (Red, Green, Blue)

When converting, transparent pixels need a background color.

Solution: Drawing with Background

We'll use the image/draw package to:

Create a new image with white background
Draw the PNG image on top of it
Encode the result as JPEG

main.go (with background handling):

package main

import (
    "fmt"
    "image"
    "image/color"
    "image/draw"
    "image/jpeg"
    "image/png"
    "log"
    "os"
    "path/filepath"
    "strings"
)

func main() {
    if len(os.Args) < 2 {
        log.Fatal("Usage: go run main.go <image.png>")
    }
    
    filename := os.Args[1]
    fmt.Printf("Converting %s...\n", filename)
    
    // Open and decode PNG
    file, err := os.Open(filename)
    if err != nil {
        log.Fatalf("Error opening file: %v", err)
    }
    defer file.Close()
    
    sourceImage, err := png.Decode(file)
    if err != nil {
        log.Fatalf("Error decoding PNG: %v", err)
    }
    
    // Create destination image with same bounds
    bounds := sourceImage.Bounds()
    destImage := image.NewRGBA(bounds)
    
    // Create white background
    background := image.NewUniform(color.White)
    
    // Draw white background
    draw.Draw(destImage, bounds, background, image.Point{}, draw.Src)
    
    // Draw source image on top
    draw.Draw(destImage, bounds, sourceImage, bounds.Min, draw.Over)
    
    // Create output file
    imageName := strings.TrimSuffix(filename, filepath.Ext(filename))
    outFilename := fmt.Sprintf("%s.jpeg", imageName)
    
    outFile, err := os.OpenFile(outFilename, 
        os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
    if err != nil {
        log.Fatalf("Error creating output file: %v", err)
    }
    defer outFile.Close()
    
    // Encode with quality settings
    options := &jpeg.Options{Quality: 50}
    if err := jpeg.Encode(outFile, destImage, options); err != nil {
        log.Fatalf("Error encoding JPEG: %v", err)
    }
    
    fmt.Println("Image converted with white background!")
}

Understanding the Drawing Process

Step 1: Create Destination Canvas

destImage := image.NewRGBA(bounds)

Creates a new RGBA image with the same dimensions as the source.

Step 2: Create Background

background := image.NewUniform(color.White)

Creates an infinite uniform color image (conceptually infinite size, single color).

Step 3: Draw Background Layer

draw.Draw(destImage, bounds, background, image.Point{}, draw.Src)

destImage - Where to draw
bounds - Area to draw to
background - What to draw
image.Point{} - Starting point (0,0)
draw.Src - Drawing operation (source/base layer)

Step 4: Draw Foreground Layer

draw.Draw(destImage, bounds, sourceImage, bounds.Min, draw.Over)

draw.Over - Compositing operation (overlay with alpha blending)

Drawing Operations

Operation	Description	Use Case
`draw.Src`	Source replaces destination	Background layers
`draw.Over`	Alpha blending/compositing	Overlaying images

Testing Different Background Colors

You can easily change the background color:

// Red background
background := image.NewUniform(color.RGBA{255, 0, 0, 255})

// Custom gray background  
background := image.NewUniform(color.RGBA{128, 128, 128, 255})

// Black background (default JPEG behavior)
background := image.NewUniform(color.Black)

Complete Working Example

bash

go run main.go gopher.png
# Creates gopher.jpeg with white background instead of black

# Compare the results
open gopher.png   # Original with transparency
open gopher.jpeg  # Converted with white background

Homework Assignments

Now let's extend our image converter with practical enhancements:

Assignment 1: Bidirectional Conversion (PNG ↔ JPEG)

Goal: Support both PNG→JPEG and JPEG→PNG conversion.

// TODO: Implement format detection and bidirectional conversion
func detectFormat(filename string) string {
    ext := strings.ToLower(filepath.Ext(filename))
    switch ext {
    case ".png":
        return "png"
    case ".jpg", ".jpeg":
        return "jpeg"
    default:
        return "unknown"
    }
}

func convertImage(inputFile, outputFile string) error {
    inputFormat := detectFormat(inputFile)
    outputFormat := detectFormat(outputFile)
    
    // TODO: Implement conversion logic based on formats
    switch {
    case inputFormat == "png" && outputFormat == "jpeg":
        return convertPNGToJPEG(inputFile, outputFile)
    case inputFormat == "jpeg" && outputFormat == "png":
        return convertJPEGToPNG(inputFile, outputFile)
    default:
        return fmt.Errorf("unsupported conversion: %s to %s", 
            inputFormat, outputFormat)
    }
}

// Usage: go run main.go input.png output.jpeg
//        go run main.go input.jpeg output.png

Assignment 2: Background Color CLI Flag

Goal: Allow users to specify background colors via command-line flags.

import "flag"

// TODO: Implement background color parsing
func parseBackgroundColor(colorStr string) (color.Color, error) {
    // Support named colors
    switch strings.ToLower(colorStr) {
    case "white":
        return color.White, nil
    case "black":
        return color.Black, nil
    case "red":
        return color.RGBA{255, 0, 0, 255}, nil
    case "green":
        return color.RGBA{0, 255, 0, 255}, nil
    case "blue":
        return color.RGBA{0, 0, 255, 255}, nil
    default:
        // TODO: Support hex colors like "FF0000" or "1E1E2E"
        return parseHexColor(colorStr)
    }
}

func parseHexColor(hexStr string) (color.Color, error) {
    // TODO: Parse hex strings like "FF0000" or "1E1E2E"
    // Hint: Use encoding/hex package
    // Remove leading # if present
    // Convert to RGB values
    // Return color.RGBA{r, g, b, 255}
}

// Usage: go run main.go -bg white input.png
//        go run main.go -bg FF0000 input.png  
//        go run main.go -bg 1E1E2E input.png

Assignment 3: Image Padding

Goal: Add padding around images during conversion.

// TODO: Implement padding functionality
type PaddingConfig struct {
    Top    int
    Right  int
    Bottom int
    Left   int
}

func parsePadding(paddingStr string) (PaddingConfig, error) {
    // Support different padding formats:
    // "20" - uniform padding
    // "20,30" - horizontal, vertical  
    // "10,20,30,40" - top, right, bottom, left (TRBL)
}

func addPadding(srcImage image.Image, padding PaddingConfig, 
                bgColor color.Color) image.Image {
    // TODO: Create larger destination image
    // Calculate new bounds with padding
    // Draw background with padding
    // Draw source image centered
}

// Usage: go run main.go -padding 20 input.png
//        go run main.go -padding 20,30 input.png
//        go run main.go -padding 10,20,30,40 input.png

Complete CLI Interface

Your final application should support:

bash

# Basic conversion
go run main.go input.png output.jpeg

# With background color
go run main.go -bg white input.png output.jpeg
go run main.go -bg FF0000 input.png output.jpeg

# With padding
go run main.go -padding 20 input.png output.jpeg
go run main.go -padding 10,20,30,40 input.png output.jpeg

# Combined options
go run main.go -bg 1E1E2E -padding 20 input.png output.jpeg

Advanced Topics

Image Manipulation Techniques

Resizing Images

import "image/draw"

func resizeImage(src image.Image, newWidth, newHeight int) image.Image {
    dst := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))
    
    // Simple nearest-neighbor scaling
    draw.BiLinear.Scale(dst, dst.Bounds(), src, src.Bounds(), 
        draw.Over, nil)
    
    return dst
}

Image Filters

func applyGrayscale(src image.Image) image.Image {
    bounds := src.Bounds()
    dst := image.NewGray(bounds)
    
    for y := bounds.Min.Y; y < bounds.Max.Y; y++ {
        for x := bounds.Min.X; x < bounds.Max.X; x++ {
            originalColor := src.At(x, y)
            grayColor := color.GrayModel.Convert(originalColor)
            dst.Set(x, y, grayColor)
        }
    }
    
    return dst
}

Performance Considerations

Memory Management

// For large images, consider processing in chunks
func processLargeImage(src image.Image) image.Image {
    bounds := src.Bounds()
    
    // Process image in 1000x1000 tiles to manage memory
    tileSize := 1000
    
    // Implementation depends on specific processing needs
    return nil
}

Concurrent Processing

import "sync"

func parallelImageProcessing(src image.Image) image.Image {
    bounds := src.Bounds()
    height := bounds.Dy()
    workers := runtime.NumCPU()
    rowsPerWorker := height / workers
    
    var wg sync.WaitGroup
    dst := image.NewRGBA(bounds)
    
    for i := 0; i < workers; i++ {
        wg.Add(1)
        go func(startRow, endRow int) {
            defer wg.Done()
            // Process rows startRow to endRow
        }(i*rowsPerWorker, (i+1)*rowsPerWorker)
    }
    
    wg.Wait()
    return dst
}

Real-World Applications

Thumbnail Generation

func generateThumbnail(srcPath, dstPath string, maxSize int) error {
    // Load source image
    // Calculate aspect-preserving dimensions
    // Resize image
    // Save as JPEG with appropriate quality
}

Image Format Conversion Pipeline

func batchConvert(inputDir, outputDir string, format string) error {
    // Walk directory tree
    // Process each image file
    // Convert to target format
    // Maintain directory structure
}

Image Metadata Preservation

import "image/jpeg"

func preserveMetadata(src, dst string) error {
    // Extract EXIF data from source
    // Apply image transformations  
    // Embed EXIF data in destination
}

Testing Your Implementation

Unit Tests

// image_test.go
package main

import (
    "image"
    "image/color"
    "testing"
)

func TestBackgroundColor(t *testing.T) {
    // Create test image with transparency
    // Convert with different backgrounds
    // Verify background colors in result
}

func TestFormatDetection(t *testing.T) {
    tests := []struct {
        filename string
        expected string
    }{
        {"test.png", "png"},
        {"test.jpg", "jpeg"},
        {"test.JPEG", "jpeg"},
    }
    
    for _, test := range tests {
        result := detectFormat(test.filename)
        if result != test.expected {
            t.Errorf("detectFormat(%s) = %s, want %s", 
                test.filename, result, test.expected)
        }
    }
}

Integration Tests

func TestEndToEndConversion(t *testing.T) {
    // Create temporary test images
    // Run conversion
    // Verify output files exist and are valid
    // Clean up temporary files
}

Error Handling Best Practices

Robust File Operations

func safeImageConversion(input, output string) error {
    // Validate input file exists and is readable
    if _, err := os.Stat(input); err != nil {
        return fmt.Errorf("input file error: %w", err)
    }
    
    // Check if output file already exists
    if _, err := os.Stat(output); err == nil {
        return fmt.Errorf("output file already exists: %s", output)
    }
    
    // Validate file extensions
    if !isValidImageFile(input) {
        return fmt.Errorf("unsupported input format: %s", input)
    }
    
    // Perform conversion with proper cleanup
    return convertImageSafe(input, output)
}

Memory Safety

func convertWithMemoryLimit(input, output string, maxMemoryMB int) error {
    // Check image dimensions before loading
    config, err := getImageConfig(input)
    if err != nil {
        return err
    }
    
    estimatedMemory := config.Width * config.Height * 4 // RGBA
    maxMemory := maxMemoryMB * 1024 * 1024
    
    if estimatedMemory > maxMemory {
        return fmt.Errorf("image too large: %dMB > %dMB limit", 
            estimatedMemory/1024/1024, maxMemoryMB)
    }
    
    return convertImage(input, output)
}

Summary

We've successfully created an image conversion tool using Go's standard library:

Key Concepts Learned:

Image Package Architecture - Understanding Go's image interfaces and sub-packages
Format Conversion - PNG ↔ JPEG with proper handling of transparency
Image Drawing - Using the draw package for compositing operations
Quality Control - JPEG compression settings and trade-offs
Color Models - Working with RGBA, RGB, and uniform colors

Benefits:

No External Dependencies - Uses only Go standard library
Cross-Platform - Works on all platforms Go supports
Memory Efficient - Streaming operations where possible
Format Flexible - Easy to extend to other image formats

Real-World Applications:

Thumbnail Generation - Resize and convert images for web
Batch Processing - Convert multiple images in pipelines
Background Removal - Replace transparency with solid colors
Image Optimization - Reduce file sizes for web delivery

Next Steps:

Complete the homework assignments to create a full-featured image converter with CLI flags, multiple format support, and advanced features like padding and custom backgrounds.

Once complete, you'll have built your own CLI application for image conversion without needing to rely on third-party dependencies like ImageMagick!

In the next lesson, we'll start looking at how we can distribute our applications to other users.

Additional Resources

Go Image Package Documentation - Complete reference for image operations
JPEG Quality Guidelines - Best practices for compression settings
PNG vs JPEG - When to use each format
Color Theory - Understanding color models and conversions
Image Processing Algorithms - Advanced manipulation techniques

Remember: The Go standard library is incredibly powerful for image processing - explore the other sub-packages for additional functionality! 📷

Bidirectional Conversion (PNG ↔ JPEG)

Completed

Pending

Support both PNG→JPEG and JPEG→PNG conversion with automatic format detection.

Requirements:

Format Detection:

// TODO: Implement format detection and bidirectional conversion
func detectFormat(filename string) string {
    ext := strings.ToLower(filepath.Ext(filename))
    switch ext {
    case ".png":
        return "png"
    case ".jpg", ".jpeg":
        return "jpeg"
    default:
        return "unknown"
    }
}

Conversion Logic:

func convertImage(inputFile, outputFile string) error {
    inputFormat := detectFormat(inputFile)
    outputFormat := detectFormat(outputFile)

    // TODO: Implement conversion logic based on formats
    switch {
    case inputFormat == "png" && outputFormat == "jpeg":
        return convertPNGToJPEG(inputFile, outputFile)
    case inputFormat == "jpeg" && outputFormat == "png":
        return convertJPEGToPNG(inputFile, outputFile)
    default:
        return fmt.Errorf("unsupported conversion: %s to %s",
            inputFormat, outputFormat)
    }
}

Usage Examples:

bash

go run main.go input.png output.jpeg
go run main.go input.jpeg output.png

Implementation Notes:

Handle both .jpg and .jpeg extensions
Implement separate functions for each conversion direction
Provide clear error messages for unsupported formats

Background Color CLI Flag

Completed

Pending

Allow users to specify background colors via command-line flags for transparency handling.

Requirements:

Color Parsing:

import "flag"

// TODO: Implement background color parsing
func parseBackgroundColor(colorStr string) (color.Color, error) {
    // Support named colors
    switch strings.ToLower(colorStr) {
    case "white":
        return color.White, nil
    case "black":
        return color.Black, nil
    case "red":
        return color.RGBA{255, 0, 0, 255}, nil
    case "green":
        return color.RGBA{0, 255, 0, 255}, nil
    case "blue":
        return color.RGBA{0, 0, 255, 255}, nil
    default:
        // TODO: Support hex colors like "FF0000" or "1E1E2E"
        return parseHexColor(colorStr)
    }
}

func parseHexColor(hexStr string) (color.Color, error) {
    // TODO: Parse hex strings like "FF0000" or "1E1E2E"
    // Hint: Use encoding/hex package
    // Remove leading # if present
    // Convert to RGB values
    // Return color.RGBA{r, g, b, 255}
}

Usage Examples:

bash

go run main.go -bg white input.png
go run main.go -bg FF0000 input.png
go run main.go -bg 1E1E2E input.png

Supported Formats:

Named colors: white, black, red, green, blue
Hex colors: FF0000, 1E1E2E (with or without # prefix)
Default to white if no background specified

Image Padding

Completed

Pending

Add padding around images during conversion with flexible padding specification.

Requirements:

Padding Configuration:

// TODO: Implement padding functionality
type PaddingConfig struct {
    Top    int
    Right  int
    Bottom int
    Left   int
}

func parsePadding(paddingStr string) (PaddingConfig, error) {
    // Support different padding formats:
    // "20" - uniform padding
    // "20,30" - horizontal, vertical
    // "10,20,30,40" - top, right, bottom, left (TRBL)
}

func addPadding(srcImage image.Image, padding PaddingConfig,
                bgColor color.Color) image.Image {
    // TODO: Create larger destination image
    // Calculate new bounds with padding
    // Draw background with padding
    // Draw source image centered
}

Usage Examples:

bash

go run main.go -padding 20 input.png
go run main.go -padding 20,30 input.png
go run main.go -padding 10,20,30,40 input.png

Padding Formats:

"20" - 20px padding on all sides
"20,30" - 20px horizontal, 30px vertical
"10,20,30,40" - top, right, bottom, left (CSS-style)

Complete CLI Interface:

Your final application should support all combinations:

bash

# Basic conversion
go run main.go input.png output.jpeg

# With background color
go run main.go -bg white input.png output.jpeg
go run main.go -bg FF0000 input.png output.jpeg

# With padding
go run main.go -padding 20 input.png output.jpeg
go run main.go -padding 10,20,30,40 input.png output.jpeg

# Combined options
go run main.go -bg 1E1E2E -padding 20 input.png output.jpeg

How would you rate this lesson?

Full Course

Real-World Example

The Go Image Package

Available Sub-packages

Project Goal: PNG to JPEG Converter

Project Setup

Project Structure:

Basic CLI Interface

main.go (initial structure):

Testing the Basic Structure

Step 1: Loading and Decoding PNG Images

Understanding Image Decoding

main.go (with PNG loading):

Key Concepts

Image Interface

Automatic Format Detection

Step 2: Converting to JPEG Format

Understanding JPEG Encoding

main.go (with JPEG encoding):

Understanding File Creation Flags

Testing the Conversion

Step 3: JPEG Quality Control

JPEG Options

main.go (with quality control):

Quality Comparison

Testing Different Qualities

Step 4: Handling Transparency (PNG → JPEG)

The Transparency Problem

Solution: Drawing with Background

main.go (with background handling):

Understanding the Drawing Process

Step 1: Create Destination Canvas

Step 2: Create Background

Step 3: Draw Background Layer

Step 4: Draw Foreground Layer

Drawing Operations

Testing Different Background Colors

Complete Working Example

Homework Assignments

Assignment 1: Bidirectional Conversion (PNG ↔ JPEG)

Assignment 2: Background Color CLI Flag

Assignment 3: Image Padding

Complete CLI Interface

Advanced Topics

Image Manipulation Techniques

Resizing Images

Image Filters

Performance Considerations

Memory Management

Concurrent Processing

Real-World Applications

Thumbnail Generation

Image Format Conversion Pipeline

Image Metadata Preservation

Testing Your Implementation

Unit Tests

Integration Tests

Error Handling Best Practices

Robust File Operations

Memory Safety

Summary

Key Concepts Learned:

Benefits:

Real-World Applications:

Next Steps:

Additional Resources

Bidirectional Conversion (PNG ↔ JPEG)

Background Color CLI Flag

Image Padding

Get Support