GeorgH93/OpenVulkano
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moved header structs and some methods to cpp files, reading pnm images upside-down

Browse Source
This commit is contained in:
Vladyslav Baranovskyi
2025-01-04 14:27:28 +02:00
parent 7ea6edf5d0
commit 295468358f
5 changed files with 179 additions and 149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
openVulkanoCpp/Image/ImageLoaderPfm.cpp
View File

@@ -14,6 +14,33 @@
#include <sstream> #include <sstream>
#include <stdexcept> #include <stdexcept>
namespace
{
struct PfmImageHeader
{
int width;
int height;
bool isColor;
bool isLittleEndian;
};
PfmImageHeader ParseHeader(std::istringstream& stream)
{
PfmImageHeader header;
std::string magic;
stream >> magic;
header.isColor = (magic == "PF");
float endianess;
stream >> header.width >> header.height >> endianess;
stream.ignore();
header.isLittleEndian = endianess < 0;
return header;
}
}
namespace OpenVulkano::Image namespace OpenVulkano::Image
{ {
std::unique_ptr<Image> ImageLoaderPfm::loadFromFile(const std::string& filePath) std::unique_ptr<Image> ImageLoaderPfm::loadFromFile(const std::string& filePath)
@@ -31,12 +58,21 @@ namespace OpenVulkano::Image
std::unique_ptr<Image> ImageLoaderPfm::loadFromMemory(const std::vector<uint8_t>& buffer) std::unique_ptr<Image> ImageLoaderPfm::loadFromMemory(const std::vector<uint8_t>& buffer)
{ {
std::istringstream stream(std::string(buffer.begin(), buffer.end()), std::ios::binary); std::istringstream stream(std::string(buffer.begin(), buffer.end()), std::ios::binary);
PfmImageHeader header = parseHeader(stream); PfmImageHeader header = ParseHeader(stream);
size_t numChannels = header.isColor ? 3 : 1; size_t numChannels = header.isColor ? 3 : 1;
size_t dataSize = header.width * header.height * numChannels * sizeof(float); size_t dataSize = header.width * header.height * numChannels * sizeof(float);
std::vector<float> data(header.width * header.height * numChannels); Array<float> data(header.width * header.height * numChannels);
stream.read(reinterpret_cast<char*>(data.data()), dataSize); size_t rowSize = header.width * numChannels * sizeof(float);
for (int y = header.height - 1; y >= 0; --y)
{
stream.read(reinterpret_cast<char*>(&data[y * header.width * numChannels]), rowSize);
if (!stream)
{
throw std::runtime_error("Error reading PFM image data");
}
}
if (!header.isLittleEndian) if (!header.isLittleEndian)
{ {
@@ -47,20 +83,10 @@ namespace OpenVulkano::Image
} }
} }
for (int y = 0; y < header.height / 2; ++y)
{
for (int x = 0; x < header.width * numChannels; ++x)
{
std::swap(data[y * header.width * numChannels + x],
data[(header.height - 1 - y) * header.width * numChannels + x]);
}
}
auto image = std::make_unique<Image>(); auto image = std::make_unique<Image>();
image->resolution = { static_cast<uint32_t>(header.width), static_cast<uint32_t>(header.height), 1 }; image->resolution = { static_cast<uint32_t>(header.width), static_cast<uint32_t>(header.height), 1 };
image->dataFormat = header.isColor ? DataFormat::Format::R32G32B32_SFLOAT : DataFormat::Format::R32_SFLOAT; image->dataFormat = header.isColor ? DataFormat::Format::R32G32B32_SFLOAT : DataFormat::Format::R32_SFLOAT;
image->data = Array<uint8_t>(dataSize); image->data = std::move(*reinterpret_cast<Array<uint8_t>*>(&data));
memcpy(image->data.Data(), data.data(), dataSize);
return image; return image;
} }
@@ -74,23 +100,7 @@ namespace OpenVulkano::Image
std::vector<uint8_t> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>()); std::vector<uint8_t> buffer((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
std::istringstream stream(std::string(buffer.begin(), buffer.end()), std::ios::binary); std::istringstream stream(std::string(buffer.begin(), buffer.end()), std::ios::binary);
PfmImageHeader header = parseHeader(stream); PfmImageHeader header = ParseHeader(stream);
return { header.width, header.height }; return { header.width, header.height };
} }
ImageLoaderPfm::PfmImageHeader ImageLoaderPfm::parseHeader(std::istringstream& stream)
{
ImageLoaderPfm::PfmImageHeader header;
std::string magic;
stream >> magic;
header.isColor = (magic == "PF");
float endianess;
stream >> header.width >> header.height >> endianess;
stream.ignore();
header.isLittleEndian = endianess < 0;
return header;
}
} }

11
openVulkanoCpp/Image/ImageLoaderPfm.hpp
View File

@@ -12,20 +12,9 @@ namespace OpenVulkano::Image
{ {
class ImageLoaderPfm : public IImageLoader class ImageLoaderPfm : public IImageLoader
{ {
struct PfmImageHeader
{
int width;
int height;
bool isColor;
bool isLittleEndian;
};
public: public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override; std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override; std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override; Math::Vector2i GetImageDimensions(const std::string& filename) override;
private:
PfmImageHeader parseHeader(std::istringstream& stream);
}; };
} }

212
openVulkanoCpp/Image/ImageLoaderPnm.cpp
View File

@@ -9,6 +9,128 @@
#include <sstream> #include <sstream>
#include <fstream> #include <fstream>
namespace
{
struct PnmHeader
{
char magic = 0; // 1 for P1, 2 for P2 etc
int width = 0;
int height = 0;
int maxVal = 255; // Only used for formats P2, P3, P5, P6
};
void MaybeSkipComments(std::istream& stream)
{
std::string line;
while (std::getline(stream, line))
{
line.erase(0, line.find_first_not_of(" \t"));
if (line.empty() || line[0] != '#')
{
stream.seekg(-static_cast<std::streamoff>(line.length()) - 1, std::ios::cur);
break;
}
}
}
PnmHeader ParseHeader(std::istream& stream)
{
PnmHeader header;
MaybeSkipComments(stream);
char pMagic;
stream >> pMagic;
if (pMagic != 'P')
{
throw std::runtime_error("Unsupported magic");
}
stream >> header.magic;
header.magic -= '0';
if (header.magic < 1 || header.magic > 6)
{
throw std::runtime_error("Unsupported magic number: P" + (header.magic + '0'));
}
MaybeSkipComments(stream);
stream >> header.width >> header.height;
if (header.magic != 1 && header.magic != 4)
{
MaybeSkipComments(stream);
stream >> header.maxVal;
}
stream.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
return header;
}
OpenVulkano::Array<uint8_t> ReadBinaryData(std::istream& stream, const PnmHeader& header)
{
size_t dataSize = header.width * header.height * ((header.magic == 6) ? 3 : 1);
OpenVulkano::Array<uint8_t> data(dataSize);
if (header.magic == 4)
{
size_t rowBytes = (header.width + 7) / 8;
OpenVulkano::Array<uint8_t> rowBuffer(rowBytes);
for (int y = header.height - 1; y >= 0; --y)
{
stream.read(reinterpret_cast<char*>(rowBuffer.Data()), rowBytes);
size_t rowStart = y * header.width;
for (int x = 0; x < header.width; ++x)
{
size_t byteIndex = x / 8;
size_t bitIndex = 7 - (x % 8);
data[rowStart + x] = (rowBuffer[byteIndex] >> bitIndex) & 1 ? 255 : 0;
}
}
}
else
{
size_t bytesPerRow = header.width * ((header.magic == 6) ? 3 : 1);
OpenVulkano::Array<uint8_t> rowBuffer(bytesPerRow);
for (int y = header.height - 1; y >= 0; --y)
{
stream.read(reinterpret_cast<char*>(rowBuffer.Data()), bytesPerRow);
size_t rowStart = y * bytesPerRow;
std::memcpy(data.Data() + rowStart, rowBuffer.Data(), bytesPerRow);
}
}
return data;
}
OpenVulkano::Array<uint8_t> ReadTextData(std::istream& stream, const PnmHeader& header)
{
const size_t numChannels = (header.magic == 3) ? 3 : 1;
OpenVulkano::Array<uint8_t> data(header.width * header.height * numChannels);
const int PRECOMPUTED_RATIO = 255 / header.maxVal;
for (int y = header.height - 1; y >= 0; --y)
{
for (size_t x = 0; x < header.width * numChannels; ++x)
{
int value;
stream >> value;
if (header.magic == 1)
{
data[y * header.width * numChannels + x] = static_cast<uint8_t>(value * 255);
}
else
{
data[y * header.width * numChannels + x] = static_cast<uint8_t>(value * PRECOMPUTED_RATIO);
}
}
}
return data;
}
}
namespace OpenVulkano::Image namespace OpenVulkano::Image
{ {
std::unique_ptr<Image> ImageLoaderPnm::loadFromFile(const std::string& filePath) std::unique_ptr<Image> ImageLoaderPnm::loadFromFile(const std::string& filePath)
@@ -26,20 +148,20 @@ namespace OpenVulkano::Image
std::unique_ptr<Image> ImageLoaderPnm::loadFromMemory(const std::vector<uint8_t>& buffer) std::unique_ptr<Image> ImageLoaderPnm::loadFromMemory(const std::vector<uint8_t>& buffer)
{ {
std::istringstream stream(std::string(buffer.begin(), buffer.end())); std::istringstream stream(std::string(buffer.begin(), buffer.end()));
PnmHeader header = parseHeader(stream); PnmHeader header = ParseHeader(stream);
std::unique_ptr<Image> result = std::make_unique<Image>(); std::unique_ptr<Image> result = std::make_unique<Image>();
result->resolution.x = header.width; result->resolution.x = header.width;
result->resolution.y = header.height; result->resolution.y = header.height;
result->resolution.z = 1; result->resolution.z = 1;
if (header.magic == 1 || header.magic == 2 || header.magic == 3) if (header.magic <= 3)
{ {
result->data = readTextData(stream, header); result->data = ReadTextData(stream, header);
} }
else if (header.magic == 4 || header.magic == 5 || header.magic == 6) else if (header.magic <= 6)
{ {
result->data = readBinaryData(stream, header); result->data = ReadBinaryData(stream, header);
} }
else else
{ {
@@ -66,85 +188,7 @@ namespace OpenVulkano::Image
throw std::runtime_error("Failed to open file: " + filename); throw std::runtime_error("Failed to open file: " + filename);
} }
PnmHeader header = parseHeader(file); PnmHeader header = ParseHeader(file);
return Math::Vector2i(header.width, header.height); return Math::Vector2i(header.width, header.height);
} }
PnmHeader ImageLoaderPnm::parseHeader(std::istream& stream)
{
PnmHeader header;
char pMagic;
stream >> pMagic;
if (pMagic != 'P')
{
throw std::runtime_error("Unsupported magic");
}
stream >> header.magic;
header.magic -= '0';
if (header.magic != 1 && header.magic != 2 && header.magic != 3 && header.magic != 4 && header.magic != 5
&& header.magic != 6)
{
throw std::runtime_error("Unsupported magic number: P" + (header.magic + '0'));
}
stream >> header.width >> header.height;
if (header.magic != 1 && header.magic != 4)
{
stream >> header.maxVal;
}
stream.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
return header;
}
Array<uint8_t> ImageLoaderPnm::readBinaryData(std::istream& stream, const PnmHeader& header)
{
size_t dataSize = header.width * header.height * ((header.magic == 6) ? 3 : 1);
Array<uint8_t> data(dataSize);
if (header.magic == 4)
{
size_t rowBytes = (header.width + 7) / 8;
Array<uint8_t> rowBuffer(rowBytes);
size_t index = 0;
for (int y = 0; y < header.height; ++y)
{
stream.read(reinterpret_cast<char*>(rowBuffer.Data()), rowBytes);
for (int x = 0; x < header.width; ++x)
{
size_t byteIndex = x / 8;
size_t bitIndex = 7 - (x % 8);
data[index++] = (rowBuffer[byteIndex] >> bitIndex) & 1 ? 255 : 0;
}
}
}
else
{
stream.read(reinterpret_cast<char*>(data.Data()), dataSize);
}
return data;
}
Array<uint8_t> ImageLoaderPnm::readTextData(std::istream& stream, const PnmHeader& header)
{
Array<uint8_t> data(header.width * header.height * ((header.magic == 3) ? 3 : 1));
for (size_t i = 0; i < data.Size(); ++i)
{
int value;
stream >> value;
if (header.magic == 1 || header.magic == 4)
{
data[i] = static_cast<uint8_t>(value * 255);
}
else
{
data[i] = static_cast<uint8_t>((value * 255) / header.maxVal);
}
}
return data;
}
}; };

13
openVulkanoCpp/Image/ImageLoaderPnm.hpp
View File

@@ -9,24 +9,11 @@
namespace OpenVulkano::Image namespace OpenVulkano::Image
{ {
struct PnmHeader
{
char magic = 0; // 1 for P1, 2 for P2 etc
int width = 0;
int height = 0;
int maxVal = 255; // Only used for formats P2, P3, P5, P6
};
class ImageLoaderPnm : public IImageLoader class ImageLoaderPnm : public IImageLoader
{ {
public: public:
std::unique_ptr<Image> loadFromFile(const std::string& filePath) override; std::unique_ptr<Image> loadFromFile(const std::string& filePath) override;
std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override; std::unique_ptr<Image> loadFromMemory(const std::vector<uint8_t>& buffer) override;
Math::Vector2i GetImageDimensions(const std::string& filename) override; Math::Vector2i GetImageDimensions(const std::string& filename) override;
private:
PnmHeader parseHeader(std::istream& stream);
Array<uint8_t> readBinaryData(std::istream& stream, const PnmHeader& header);
Array<uint8_t> readTextData(std::istream& stream, const PnmHeader& header);
}; };
} }

20
tests/Image/ImageLoaderPnmTest.cpp
View File

@@ -24,7 +24,7 @@ TEST_CASE("ImageLoaderPnm - Load P1 (ASCII Black & White)")
REQUIRE(image->resolution.x == 4); REQUIRE(image->resolution.x == 4);
REQUIRE(image->resolution.y == 2); REQUIRE(image->resolution.y == 2);
REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT); REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT);
REQUIRE(image->data == Array<uint8_t> { 255, 0, 255, 0, 0, 255, 0, 255 }); REQUIRE(image->data == Array<uint8_t> { 0, 255, 0, 255, 255, 0, 255, 0 });
} }
TEST_CASE("ImageLoaderPnm - Load P2 (ASCII Grayscale)") TEST_CASE("ImageLoaderPnm - Load P2 (ASCII Grayscale)")
@@ -38,21 +38,21 @@ TEST_CASE("ImageLoaderPnm - Load P2 (ASCII Grayscale)")
REQUIRE(image->resolution.x == 4); REQUIRE(image->resolution.x == 4);
REQUIRE(image->resolution.y == 2); REQUIRE(image->resolution.y == 2);
REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT); REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT);
REQUIRE(image->data == Array<uint8_t> { 0, 64, 128, 255, 255, 128, 64, 0 }); REQUIRE(image->data == Array<uint8_t> { 255, 128, 64, 0, 0, 64, 128, 255 });
} }
TEST_CASE("ImageLoaderPnm - Load P3 (ASCII RGB)") TEST_CASE("ImageLoaderPnm - Load P3 (ASCII RGB)")
{ {
std::vector<uint8_t> p3Buffer = { 'P', '3', '\n', '2', ' ', '2', '\n', '2', '5', '5', '\n', '2', '5', '5', ' ', '0', std::vector<uint8_t> p3Buffer = { 'P', '3', '\n', '2', ' ', '2', '\n', '2', '5', '5', '\n',
' ', '0', ' ', '0', ' ', '2', '5', '5', ' ', '0', '\n', '0', ' ', '0', ' ', '2', '2', '5', '5', ' ', '0', ' ', '0', ' ', '0', ' ', '2', '5', '5', ' ', '0', '\n',
'5', '5', ' ', '2', '5', '5', ' ', '2', '5', '5', ' ', '2', '5', '5', '\n' }; '0', ' ', '0', ' ', '2', '5', '5', ' ', '2', '5', '5', ' ', '2', '5', '5', ' ', '2', '5', '5', '\n' };
ImageLoaderPnm loader; ImageLoaderPnm loader;
auto image = loader.loadFromMemory(p3Buffer); auto image = loader.loadFromMemory(p3Buffer);
REQUIRE(image->resolution.x == 2); REQUIRE(image->resolution.x == 2);
REQUIRE(image->resolution.y == 2); REQUIRE(image->resolution.y == 2);
REQUIRE(image->dataFormat == DataFormat::Format::R8G8B8_UINT); REQUIRE(image->dataFormat == DataFormat::Format::R8G8B8_UINT);
REQUIRE(image->data == Array<uint8_t> { 255, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 255 }); REQUIRE(image->data == Array<uint8_t> { 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 255, 0 });
} }
TEST_CASE("ImageLoaderPnm - Load P4 (Binary Black & White)") TEST_CASE("ImageLoaderPnm - Load P4 (Binary Black & White)")
@@ -66,8 +66,8 @@ TEST_CASE("ImageLoaderPnm - Load P4 (Binary Black & White)")
REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT); REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT);
REQUIRE(image->data REQUIRE(image->data
== Array<uint8_t> { == Array<uint8_t> {
255, 0, 255, 0, 255, 0, 255, 0, // Row 1 0, 255, 0, 255, 0, 255, 0, 255, // Row 1
0, 255, 0, 255, 0, 255, 0, 255 // Row 2 255, 0, 255, 0, 255, 0, 255, 0 // Row 2
}); });
} }
@@ -81,7 +81,7 @@ TEST_CASE("ImageLoaderPnm - Load P5 (Binary Grayscale)")
REQUIRE(image->resolution.x == 4); REQUIRE(image->resolution.x == 4);
REQUIRE(image->resolution.y == 2); REQUIRE(image->resolution.y == 2);
REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT); REQUIRE(image->dataFormat == DataFormat::Format::R8_UINT);
REQUIRE(image->data == Array<uint8_t> { 0, 64, 128, 255, 255, 128, 64, 0 }); REQUIRE(image->data == Array<uint8_t> { 255, 128, 64, 0, 0, 64, 128, 255 });
} }
TEST_CASE("ImageLoaderPnm - Load P6 (Binary RGB)") TEST_CASE("ImageLoaderPnm - Load P6 (Binary RGB)")
@@ -94,7 +94,7 @@ TEST_CASE("ImageLoaderPnm - Load P6 (Binary RGB)")
REQUIRE(image->resolution.x == 2); REQUIRE(image->resolution.x == 2);
REQUIRE(image->resolution.y == 2); REQUIRE(image->resolution.y == 2);
REQUIRE(image->dataFormat == DataFormat::Format::R8G8B8_UINT); REQUIRE(image->dataFormat == DataFormat::Format::R8G8B8_UINT);
REQUIRE(image->data == Array<uint8_t> { 255, 0, 0, 0, 255, 0, 0, 0, 255, 255, 255, 255 }); REQUIRE(image->data == Array<uint8_t> { 0, 0, 255, 255, 255, 255, 255, 0, 0, 0, 255, 0 });
} }
TEST_CASE("ImageLoaderPnm - Get Dimensions") TEST_CASE("ImageLoaderPnm - Get Dimensions")