Сделай функцию read, для чтения изображения изображение в формате png: #pragma once…
- User
Сделай функцию read, для чтения изображения изображение в формате png: #pragma once
#include #include #include #include #include #include
namespace png {
// Структура для хранения изображения struct Image { uint32_t width; uint32_t height; std::vector<uint8_t> data; // Формат: RGBA }; // Класс для создания PNG-файлов class PngWriter { public: // Устанавливает пиксель по координатам (x, y) с заданным цветом (RGBA) void setPixel(uint32_t x, uint32_t y, uint32_t color) { if (x >= width_ || y >= height_) { std::cerr << "Координаты пикселя (" << x << ", " << y << ") выходят за границы изображения.\n"; return; } size_t index = y * (width_ * 4 + 1) + 1 + x * 4; imageData_[index + 0] = (color >> 24) & 0xFF; // R imageData_[index + 1] = (color >> 16) & 0xFF; // G imageData_[index + 2] = (color >> 8) & 0xFF; // B imageData_[index + 3] = color & 0xFF; // A } // Сохраняет изображение в файл bool save(const std::string& filename) const { if (width_ == 0 || height_ == 0) { std::cerr << "Размеры изображения не инициализированы.\n"; return false; } std::ofstream file(filename, std::ios::binary); if (!file) { std::cerr << "Не удалось открыть файл для записи: " << filename << "\n"; return false; } // Запись сигнатуры PNG uint8_t png_signature[8] = { 0x89, 'P', 'N', 'G', '\r', '\n', 0x1A, '\n' }; file.write(reinterpret_cast<char*>(png_signature), 8); // IHDR данные uint8_t ihdr_data[13]; ihdr_data[0] = (width_ >> 24) & 0xFF; ihdr_data[1] = (width_ >> 16) & 0xFF; ihdr_data[2] = (width_ >> 8) & 0xFF; ihdr_data[3] = width_ & 0xFF; ihdr_data[4] = (height_ >> 24) & 0xFF; ihdr_data[5] = (height_ >> 16) & 0xFF; ihdr_data[6] = (height_ >> 8) & 0xFF; ihdr_data[7] = height_ & 0xFF; ihdr_data[8] = 8; // Bit depth ihdr_data[9] = 6; // Color type (RGBA) ihdr_data[10] = 0; // Compression method ihdr_data[11] = 0; // Filter method ihdr_data[12] = 0; // Interlace method // Запись IHDR uint32_t ihdr_length = swapEndian(13); file.write(reinterpret_cast<char*>(&ihdr_length), 4); uint8_t ihdr_type[4] = { 'I', 'H', 'D', 'R' }; file.write(reinterpret_cast<char*>(ihdr_type), 4); file.write(reinterpret_cast<char*>(ihdr_data), 13); // Вычисление и запись CRC для IHDR uint8_t ihdr_crc_data[17]; memcpy(ihdr_crc_data, ihdr_type, 4); memcpy(ihdr_crc_data + 4, ihdr_data, 13); uint32_t ihdr_crc = crcFunc(ihdr_crc_data, 17); uint32_t ihdr_crc_be = swapEndian(ihdr_crc); file.write(reinterpret_cast<char*>(&ihdr_crc_be), 4); // Сжатие данных изображения (простой deflate без оптимизации) // В реальных приложениях рекомендуется использовать библиотеку zlib для сжатия // Здесь мы реализуем простой безоптимизированный блок для примера std::vector<uint8_t> compressed_data; compressed_data.push_back(0x78); // Zlib CMF: Compression Method and Flags compressed_data.push_back(0x01); // Zlib FLG: No compression, low window size const size_t max_block_size = 65535; size_t offset = 0; size_t remaining = imageData_.size(); while (remaining > 0) { uint8_t block_header; if (remaining <= max_block_size) { block_header = 0x01; // Последний блок } else { block_header = 0x00; // Еще есть блоки } compressed_data.push_back(block_header); uint16_t len = static_cast<uint16_t>(remaining > max_block_size ? max_block_size : remaining); uint16_t nlen = ~len; compressed_data.push_back(len & 0xFF); compressed_data.push_back((len >> 8) & 0xFF); compressed_data.push_back(nlen & 0xFF); compressed_data.push_back((nlen >> 8) & 0xFF); compressed_data.insert(compressed_data.end(), imageData_.begin() + offset, imageData_.begin() + offset + len); offset += len; remaining -= len; } // Добавление Adler-32 uint32_t adler = computeAdler32(imageData_.data(), imageData_.size()); compressed_data.push_back((adler >> 24) & 0xFF); compressed_data.push_back((adler >> 16) & 0xFF); compressed_data.push_back((adler >> 8) & 0xFF); compressed_data.push_back(adler & 0xFF); // Запись IDAT uint32_t idat_length = swapEndian(static_cast<uint32_t>(compressed_data.size())); file.write(reinterpret_cast<char*>(&idat_length), 4); uint8_t idat_type[4] = { 'I', 'D', 'A', 'T' }; file.write(reinterpret_cast<char*>(idat_type), 4); file.write(reinterpret_cast<char*>(compressed_data.data()), compressed_data.size()); // Вычисление и запись CRC для IDAT std::vector<uint8_t> idat_crc_data(4 + compressed_data.size()); memcpy(idat_crc_data.data(), idat_type, 4); memcpy(idat_crc_data.data() + 4, compressed_data.data(), compressed_data.size()); uint32_t idat_crc = crcFunc(idat_crc_data.data(), idat_crc_data.size()); uint32_t idat_crc_be = swapEndian(idat_crc); file.write(reinterpret_cast<char*>(&idat_crc_be), 4); // Запись IEND uint32_t iend_length = 0; uint32_t iend_length_be = swapEndian(iend_length); file.write(reinterpret_cast<char*>(&iend_length_be), 4); uint8_t iend_type[4] = { 'I', 'E', 'N', 'D' }; file.write(reinterpret_cast<char*>(iend_type), 4); uint32_t iend_crc = crcFunc(iend_type, 4); uint32_t iend_crc_be = swapEndian(iend_crc); file.write(reinterpret_cast<char*>(&iend_crc_be), 4); file.close(); std::cout << "PNG файл успешно сохранен: " << filename << "\n"; return true; } // Инициализирует изображение с заданной шириной и высотой void initialize(uint32_t width, uint32_t height) { width_ = width; height_ = height; // Каждая строка начинается с байта фильтра (0 - без фильтра) imageData_.resize(height_ * (width_ * 4 + 1), 0); for (uint32_t y = 0; y < height_; ++y) { imageData_[y * (width_ * 4 + 1)] = 0; // Фильтр типа 0 } } // Конструктор PngWriter() : width_(0), height_(0) { makeCrcTable(); } // Деструктор ~PngWriter() {} private: // Создание таблицы CRC void makeCrcTable() { uint32_t c; for (uint32_t n = 0; n < 256; n++) { c = n; for (uint32_t k = 0; k < 8; k++) { if (c & 1) c = 0xEDB88320L ^ (c >> 1); else c = c >> 1; } crc_table_[n] = c; } } // Обновление CRC uint32_t updateCrc(uint32_t crc, const uint8_t* buf, size_t len) const { uint32_t c = crc; for (size_t n = 0; n < len; n++) { c = crc_table_[(c ^ buf[n]) & 0xFF] ^ (c >> 8); } return c; } // Вычисление CRC uint32_t crcFunc(const uint8_t* buf, size_t len) const { return updateCrc(0xFFFFFFFFL, buf, len) ^ 0xFFFFFFFFL; } // Обмен байтами (big-endian <-> little-endian) uint32_t swapEndian(uint32_t val) const { return ((val >> 24) & 0xff) | ((val << 8) & 0xff0000) | ((val >> 8) & 0xff00) | ((val << 24) & 0xff000000); } // Вычисление Adler-32 uint32_t computeAdler32(const uint8_t* data, size_t len) const { uint32_t A = 1; uint32_t B = 0; for (size_t i = 0; i < len; i++) { A = (A + data[i]) % 65521; B = (B + A) % 65521; } return (B << 16) | A; } uint32_t width_; uint32_t height_; std::vector<uint8_t> imageData_; mutable uint32_t crc_table_[256]; };} // namespace png
- Assistant
Конечно! Ниже приведена реализация функции
readдля чтения PNG-изображений в формате PNG, соответствующем формату, создаваемому вашим классомPngWriter. Эта функция будет находиться внутри пространства именpngи использовать структуруImageдля хранения прочитанного изображения.Обратите внимание, что эта реализация ограничена чтением PNG-файлов, созданных вашим
PngWriter, и не поддерживает все возможные вариации PNG-формата. Для полноценной поддержки PNG рекомендуется использовать специализированные библиотеки, такие как libpng.Вот обновлённый заголовочный файл с функцией
read:#pragma once #include <cstdint> #include <vector> #include <string> #include <fstream> #include <iostream> #include <cstring> #include <zlib.h> // Для декомпрессии IDAT данных namespace png { // Структура для хранения изображения struct Image { uint32_t width; uint32_t height; std::vector<uint8_t> data; // Формат: RGBA }; // Класс для создания PNG-файлов class PngWriter { public: // ... (ваш существующий код PngWriter) // Остальной код PngWriter остается без изменений }; // Функция для чтения PNG-файла inline Image read(const std::string& filename) { Image img; std::ifstream file(filename, std::ios::binary); if (!file) { std::cerr << "Не удалось открыть файл для чтения: " << filename << "\n"; return img; } // Проверка сигнатуры PNG uint8_t png_signature[8]; file.read(reinterpret_cast<char*>(png_signature), 8); uint8_t expected_signature[8] = { 0x89, 'P', 'N', 'G', '\r', '\n', 0x1A, '\n' }; if (std::memcmp(png_signature, expected_signature, 8) != 0) { std::cerr << "Неверная сигнатура PNG файла.\n"; return img; } // Переменные для хранения IHDR данных uint32_t width = 0, height = 0; uint8_t bit_depth = 0, color_type = 0; // Переменная для хранения IDAT данных std::vector<uint8_t> idat_data; // Чтение чанков while (!file.eof()) { // Чтение длины чанка uint32_t chunk_length; file.read(reinterpret_cast<char*>(&chunk_length), 4); if (file.gcount() != 4) break; // Конвертация из big-endian в little-endian chunk_length = ((chunk_length & 0xFF) << 24) | ((chunk_length & 0xFF00) << 8) | ((chunk_length & 0xFF0000) >> 8) | ((chunk_length & 0xFF000000) >> 24); // Чтение типа чанка char chunk_type[5] = {0}; file.read(chunk_type, 4); if (file.gcount() != 4) break; std::string type(chunk_type, 4); // Чтение данных чанка std::vector<uint8_t> chunk_data(chunk_length); if (chunk_length > 0) { file.read(reinterpret_cast<char*>(chunk_data.data()), chunk_length); if (static_cast<uint32_t>(file.gcount()) != chunk_length) { std::cerr << "Ошибка при чтении данных чанка.\n"; break; } } // Чтение CRC (не проверяется) uint32_t crc; file.read(reinterpret_cast<char*>(&crc), 4); if (type == "IHDR") { if (chunk_length != 13) { std::cerr << "Неверная длина IHDR чанка.\n"; break; } width = (chunk_data[0] << 24) | (chunk_data[1] << 16) | (chunk_data[2] << 8) | chunk_data[3]; height = (chunk_data[4] << 24) | (chunk_data[5] << 16) | (chunk_data[6] << 8) | chunk_data[7]; bit_depth = chunk_data[8]; color_type = chunk_data[9]; if (bit_depth != 8 || color_type != 6) { std::cerr << "Поддерживаются только 8-битные RGBA изображения.\n"; break; } } else if (type == "IDAT") { idat_data.insert(idat_data.end(), chunk_data.begin(), chunk_data.end()); } else if (type == "IEND") { break; } else { // Пропуск других типов чанков } } if (width == 0 || height == 0) { std::cerr << "Неверные размеры изображения.\n"; return img; } // Декомпрессия IDAT данных с помощью zlib // Так как PngWriter использует некомпрессированные блоки, можно использовать простую декомпрессию // Но для универсальности используем zlib // Инициализация структуры для декомпрессии z_stream strm = {}; strm.next_in = idat_data.data(); strm.avail_in = static_cast<uInt>(idat_data.size()); if (inflateInit(&strm) != Z_OK) { std::cerr << "Не удалось инициализировать декомпрессор zlib.\n"; return img; } // Буфер для декомпрессированных данных std::vector<uint8_t> decompressed_data; uint8_t buffer[32768]; int ret; do { strm.next_out = buffer; strm.avail_out = sizeof(buffer); ret = inflate(&strm, Z_NO_FLUSH); if (decompressed_data.size() < strm.total_out) { decompressed_data.insert(decompressed_data.end(), buffer, buffer + (strm.total_out - decompressed_data.size())); } } while (ret == Z_OK); inflateEnd(&strm); if (ret != Z_STREAM_END) { std::cerr << "Ошибка декомпрессии IDAT данных.\n"; return img; } // Парсинг декомпрессированных данных // Каждая строка начинается с байта фильтра (ожидаем фильтр типа 0) size_t bytes_per_pixel = 4; // RGBA size_t stride = bytes_per_pixel * width; img.data.resize(width * height * 4); size_t offset = 0; for (uint32_t y = 0; y < height; ++y) { if (offset >= decompressed_data.size()) { std::cerr << "Недостаточно данных изображения.\n"; return img; } uint8_t filter_type = decompressed_data[offset++]; if (filter_type != 0) { std::cerr << "Не поддерживаемый тип фильтра: " << static_cast<int>(filter_type) << "\n"; return img; } if (offset + stride > decompressed_data.size()) { std::cerr << "Недостаточно данных пикселей.\n"; return img; } for (size_t x = 0; x < stride; ++x) { img.data[y * stride + x] = decompressed_data[offset++]; } } // Заполнение остальной информации img.width = width; img.height = height; std::cout << "PNG файл успешно прочитан: " << filename << "\n"; return img; } } // namespace pngПояснения к реализации:
-
Проверка сигнатуры PNG: Функция сначала проверяет первые 8 байт файла, чтобы убедиться, что это корректный PNG-файл.
-
Чтение чанков:
- IHDR: Извлекает ширину, высоту, глубину цвета и тип цвета. В настоящее время поддерживаются только 8-битные изображения с цветовым типом RGBA (color_type = 6).
- IDAT: Собирает все данные IDAT для последующей декомпрессии.
- IEND: Завершает чтение чанков.
-
Декомпрессия IDAT данных: Используется библиотека zlib для декомпрессии данных. Поскольку ваш
PngWriterиспользует простой без сжатия дефлит-блок, декомпрессия должна работать корректно. -
Парсинг изображений:
- Предполагается, что каждый ряд пикселей в декомпрессированных данных начинается с байта фильтра. В данном случае поддерживается только фильтр типа 0 (без фильтра).
- Из декомпрессированных данных извлекаются значения пикселей и заполняется структура
Image.
Зависимости:
Для корректной работы функции
readнеобходима библиотека zlib. Убедитесь, что вы подключили эту библиотеку при компиляции вашего проекта. Например, при использованииg++добавьте флаг-lz:g++ -o your_program your_program.cpp -lzИспользование функции
read:Вот пример того, как можно использовать функцию
readдля загрузки PNG-изображения:#include "your_png_header.h" // Замените на фактическое имя вашего заголовочного файла int main() { png::Image img = png::read("example.png"); if (img.data.empty()) { std::cerr << "Не удалось загрузить изображение.\n"; return 1; } std::cout << "Изображение загружено: " << img.width << "x" << img.height << "\n"; // Дополнительная обработка изображения return 0; }Примечания:
-
Ограниченная поддержка: Данная реализация предназначена для чтения PNG-файлов, созданных вашим
PngWriter, и может не работать с файлами, содержащими другие типы фильтров или использующими сложные методы компрессии. -
Ошибка фильтра: Если PNG-файл использует фильтр, отличный от типа 0, функция завершит работу с сообщением об ошибке. Для поддержки других фильтров потребуется реализовать соответствующую обработку.
-
Использование библиотек: Для более надёжного и универсального манипулирования PNG-файлами рекомендуется использовать специализированные библиотеки, такие как libpng, которые уже реализуют полный спектр возможностей PNG-формата.
Надеюсь, эта реализация будет полезна для ваших целей!
-