QR Code Generator and Reader (cpp, written by Claude Code)

Claude Code wrote this cpp project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: QR Code Generator and Reader

Write a program that generates QR codes from text or URLs and reads/decodes QR codes from image files, supporting multiple output formats and error correction levels.

FUNCTIONAL REQUIREMENTS:
- Support two subcommands: generate and read
- generate: Accept text or URL content via command-line argument and produce a QR code image
- Support configurable error correction levels via --error-correction flag: L (7%), M (15%), Q (25%), H (30%); default: M
- Support configurable QR code size via --size flag (pixels for the output image, default: 300x300)
- Support configurable module (pixel block) size via --scale flag (default: 10 pixels per module)
- Support custom colors via --foreground and --background flags (hex color codes, default: black on white)
- Support multiple output formats via --format flag: PNG (default), SVG, and ASCII art (for terminal display)
- Support adding a logo/image overlay in the center of the QR code via --logo flag (relies on higher error correction to remain scannable)
- read: Accept an image file path and decode the QR code content from it
- read: Support decoding from various image formats (PNG, JPEG, BMP)
- read: Report decoded content, QR version, error correction level, and encoding mode
- Support batch generation from a file containing one content string per line via --batch flag
- Print results to console: for generation show the content encoded and output path, for reading show the decoded content
- Save decoded results as JSON with --output flag
- If no arguments are given, generate QR codes for several sample inputs (a URL, a plain text message, a vCard contact, and a Wi-Fi network config), save them as images, then read each one back and verify the decoded content matches the original
- Handle errors: content too long for QR capacity, unreadable QR codes, low-quality images, and invalid color values

Create a complete C++ project for a clean Ubuntu 22.04 machine with only G++ 12+ and CMake 3.22+ installed. Include:
- Source code
- CMakeLists.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

cmake_minimum_required(VERSION 3.14)
project(qr_code_tool VERSION 1.0.0 LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)

# Fetch Nayuki QR Code generator library
FetchContent_Declare(
    nayuki_qrcodegen
    GIT_REPOSITORY https://github.com/nayuki/QR-Code-generator.git
    GIT_TAG master
)
FetchContent_MakeAvailable(nayuki_qrcodegen)

# Add Nayuki QR Code generator as a library
add_library(qrcodegen
    ${nayuki_qrcodegen_SOURCE_DIR}/cpp/qrcodegen.cpp
)
target_include_directories(qrcodegen PUBLIC
    ${nayuki_qrcodegen_SOURCE_DIR}/cpp
)

# Find ZXing-C++ for QR code decoding
find_package(ZXing REQUIRED)

add_executable(qr_tool main.cpp)

target_link_libraries(qr_tool PRIVATE
    qrcodegen
    ZXing::ZXing
)

/**
 * QR Code Generator and Reader (C++ - Trial 2)
 *
 * Generates QR codes as PNG images and SVG files using the Nayuki QR Code
 * generator library, and decodes QR codes from images using ZXing-C++.
 *
 * Dependencies: nayuki-qr-code-generator (generation), zxing-cpp (decoding)
 */

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <cstdint>
#include <cmath>
#include <stdexcept>

#include "qrcodegen.hpp"

#include <ZXing/ReadBarcode.h>
#include <ZXing/BarcodeFormat.h>
#include <ZXing/DecodeHints.h>
#include <ZXing/Result.h>
#include <ZXing/TextUtfEncoding.h>

using qrcodegen::QrCode;
using qrcodegen::QrSegment;

/**
 * Error correction level mapping.
 */
QrCode::Ecc parseEcLevel(const std::string& level) {
    if (level == "L" || level == "low")      return QrCode::Ecc::LOW;
    if (level == "M" || level == "medium")   return QrCode::Ecc::MEDIUM;
    if (level == "Q" || level == "quartile") return QrCode::Ecc::QUARTILE;
    if (level == "H" || level == "high")     return QrCode::Ecc::HIGH;
    return QrCode::Ecc::MEDIUM;
}

/**
 * Writes a minimal BMP file from grayscale pixel data.
 * Used as a simpler alternative to PNG for demonstration.
 */
bool writeBMP(const std::string& path, const std::vector<uint8_t>& pixels,
              int width, int height) {
    int rowSize = ((width * 3 + 3) / 4) * 4;
    int imageSize = rowSize * height;
    int fileSize = 54 + imageSize;

    std::ofstream file(path, std::ios::binary);
    if (!file.is_open()) return false;

    // BMP header
    uint8_t header[54] = {};
    header[0] = 'B'; header[1] = 'M';
    *reinterpret_cast<int32_t*>(&header[2]) = fileSize;
    *reinterpret_cast<int32_t*>(&header[10]) = 54;
    *reinterpret_cast<int32_t*>(&header[14]) = 40;
    *reinterpret_cast<int32_t*>(&header[18]) = width;
    *reinterpret_cast<int32_t*>(&header[22]) = height;
    *reinterpret_cast<int16_t*>(&header[26]) = 1;
    *reinterpret_cast<int16_t*>(&header[28]) = 24;
    *reinterpret_cast<int32_t*>(&header[34]) = imageSize;

    file.write(reinterpret_cast<char*>(header), 54);

    std::vector<uint8_t> row(rowSize, 0);
    for (int y = height - 1; y >= 0; --y) {
        for (int x = 0; x < width; ++x) {
            uint8_t val = pixels[y * width + x];
            row[x * 3 + 0] = val;  // B
            row[x * 3 + 1] = val;  // G
            row[x * 3 + 2] = val;  // R
        }
        file.write(reinterpret_cast<char*>(row.data()), rowSize);
    }

    file.close();
    std::cout << "BMP QR code saved to: " << path << std::endl;
    return true;
}

/**
 * Generates a QR code and saves it as a BMP image using the Nayuki library.
 */
bool generateImage(const std::string& data, const std::string& outputPath,
                   int pixelSize = 8, int margin = 2,
                   const std::string& ecLevel = "medium") {
    try {
        QrCode qr = QrCode::encodeText(data.c_str(), parseEcLevel(ecLevel));
        int qrSize = qr.getSize();
        int imgSize = (qrSize + margin * 2) * pixelSize;

        std::vector<uint8_t> pixels(imgSize * imgSize, 255);

        for (int y = 0; y < qrSize; ++y) {
            for (int x = 0; x < qrSize; ++x) {
                if (qr.getModule(x, y)) {
                    for (int py = 0; py < pixelSize; ++py) {
                        for (int px = 0; px < pixelSize; ++px) {
                            int ix = (x + margin) * pixelSize + px;
                            int iy = (y + margin) * pixelSize + py;
                            pixels[iy * imgSize + ix] = 0;
                        }
                    }
                }
            }
        }

        return writeBMP(outputPath, pixels, imgSize, imgSize);
    } catch (const std::exception& e) {
        std::cerr << "Error generating QR: " << e.what() << std::endl;
        return false;
    }
}

/**
 * Generates an SVG representation of a QR code using the Nayuki library.
 */
std::string generateSVG(const std::string& data, const std::string& outputPath = "",
                         int border = 2, const std::string& ecLevel = "medium") {
    QrCode qr = QrCode::encodeText(data.c_str(), parseEcLevel(ecLevel));
    std::string svg = qr.toSvgString(border);

    if (!outputPath.empty()) {
        std::ofstream file(outputPath);
        if (file.is_open()) {
            file << svg;
            file.close();
            std::cout << "SVG QR code saved to: " << outputPath << std::endl;
        }
    }

    return svg;
}

/**
 * Generates an ASCII art representation of a QR code.
 */
std::string generateASCII(const std::string& data,
                           const std::string& ecLevel = "medium") {
    QrCode qr = QrCode::encodeText(data.c_str(), parseEcLevel(ecLevel));
    int size = qr.getSize();
    std::ostringstream oss;

    for (int y = 0; y < size; y += 2) {
        for (int x = 0; x < size; ++x) {
            bool top = qr.getModule(x, y);
            bool bottom = (y + 1 < size) ? qr.getModule(x, y + 1) : false;

            if (top && bottom)       oss << "\u2588";
            else if (top)            oss << "\u2580";
            else if (bottom)         oss << "\u2584";
            else                     oss << " ";
        }
        oss << "\n";
    }

    return oss.str();
}

/**
 * Reads a BMP file into a raw pixel buffer for decoding.
 */
bool readBMP(const std::string& path, std::vector<uint8_t>& pixels,
             int& width, int& height) {
    std::ifstream file(path, std::ios::binary);
    if (!file.is_open()) return false;

    uint8_t header[54];
    file.read(reinterpret_cast<char*>(header), 54);

    if (header[0] != 'B' || header[1] != 'M') return false;

    width = *reinterpret_cast<int32_t*>(&header[18]);
    height = *reinterpret_cast<int32_t*>(&header[22]);
    int bitsPerPixel = *reinterpret_cast<int16_t*>(&header[28]);
    int rowSize = ((width * (bitsPerPixel / 8) + 3) / 4) * 4;

    pixels.resize(width * height);
    std::vector<uint8_t> row(rowSize);

    for (int y = height - 1; y >= 0; --y) {
        file.read(reinterpret_cast<char*>(row.data()), rowSize);
        for (int x = 0; x < width; ++x) {
            int offset = x * (bitsPerPixel / 8);
            // Convert BGR to grayscale
            uint8_t b = row[offset];
            uint8_t g = row[offset + 1];
            uint8_t r = row[offset + 2];
            pixels[y * width + x] = static_cast<uint8_t>(0.299 * r + 0.587 * g + 0.114 * b);
        }
    }

    return true;
}

/**
 * Decodes a QR code from an image file using ZXing-C++.
 */
std::string decodeFromImage(const std::string& imagePath) {
    std::vector<uint8_t> pixels;
    int width, height;

    if (!readBMP(imagePath, pixels, width, height)) {
        std::cerr << "Error: Cannot read image: " << imagePath << std::endl;
        return "";
    }

    ZXing::DecodeHints hints;
    hints.setFormats(ZXing::BarcodeFormat::QRCode);
    hints.setTryHarder(true);
    hints.setTryRotate(true);

    ZXing::ImageView imageView(pixels.data(), width, height,
                                ZXing::ImageFormat::Lum);

    auto result = ZXing::ReadBarcode(imageView, hints);

    if (result.isValid()) {
        std::string text = result.text();
        std::cout << "Decoded QR code: " << text << std::endl;
        return text;
    }

    std::cout << "No QR code found in image." << std::endl;
    return "";
}

/**
 * Displays QR code metadata (version, size, error correction).
 */
void displayMetadata(const std::string& data, const std::string& ecLevel) {
    QrCode qr = QrCode::encodeText(data.c_str(), parseEcLevel(ecLevel));
    std::cout << "QR Code Metadata:" << std::endl;
    std::cout << "  Version: " << qr.getVersion() << std::endl;
    std::cout << "  Size: " << qr.getSize() << "x" << qr.getSize() << " modules" << std::endl;
    std::cout << "  Error correction: " << ecLevel << std::endl;
    std::cout << "  Data length: " << data.size() << " characters" << std::endl;
}

/**
 * Main demonstration function.
 */
int main(int argc, char* argv[]) {
    std::cout << "=== QR Code Generator and Reader (Trial 2) ===" << std::endl;

    std::string testData = "https://example.com/qr-demo?id=12345";
    std::string outputFile = "output_qr.bmp";

    if (argc >= 2) testData = argv[1];
    if (argc >= 3) outputFile = argv[2];

    // Display metadata
    std::cout << "\n1. QR Code metadata:" << std::endl;
    displayMetadata(testData, "high");

    // Generate BMP image
    std::cout << "\n2. Generating BMP QR code..." << std::endl;
    if (!generateImage(testData, outputFile, 8, 2, "high")) {
        std::cerr << "Failed to generate image." << std::endl;
        return 1;
    }

    // Generate SVG
    std::cout << "\n3. Generating SVG QR code..." << std::endl;
    generateSVG(testData, "output_qr.svg", 2, "medium");

    // Generate ASCII
    std::cout << "\n4. ASCII QR code:" << std::endl;
    std::string ascii = generateASCII(testData, "medium");
    std::cout << ascii << std::endl;

    // Decode
    std::cout << "5. Decoding QR code from " << outputFile << "..." << std::endl;
    std::string decoded = decodeFromImage(outputFile);
    if (!decoded.empty()) {
        std::cout << "Match: " << (decoded == testData ? "SUCCESS" : "MISMATCH") << std::endl;
    }

    std::cout << "\n=== All operations completed ===" << std::endl;
    return 0;
}

# QR Code Generator and Reader (C++ - Trial 2)

## Description

A C++ application that generates QR codes using the Nayuki QR Code generator library for encoding and ZXing-C++ for decoding. Outputs QR codes as BMP images, SVG files, and ASCII art.

## Dependencies

- **nayuki-qr-code-generator** - A compact, well-documented QR code generation library by Project Nayuki. Provides a clean C++ API for encoding text into QR code matrices with full control over version selection and error correction levels. Fetched automatically via CMake FetchContent.
- **zxing-cpp** - C++ port of the ZXing barcode scanning library. Used for decoding QR codes from raster image data with support for rotation detection and multi-format scanning.

## Features

- Generate QR codes as BMP images with configurable pixel scaling and margins
- Generate QR codes as SVG files using Nayuki's built-in SVG export
- Generate QR codes as Unicode ASCII art for terminal display
- Decode QR codes from BMP image files using ZXing-C++
- Display QR code metadata (version, module size, error correction)
- Round-trip verification (generate then decode)
- Configurable error correction levels (Low, Medium, Quartile, High)

## Building

```bash
mkdir build && cd build
cmake ..
make
```

## Usage

```bash
./qr_tool                                      # Uses default demo data
./qr_tool "https://example.com" output.bmp     # Custom data and output path
```

## System Requirements

- CMake 3.14+ (for FetchContent)
- C++17 compatible compiler
- ZXing-C++ installed on the system
- Internet access for CMake FetchContent to download Nayuki library