moritz/ptprnt
1
0
Fork 0
Code Issues Pull Requests Actions Projects Releases 1 Wiki Activity

Generate labels with pangocairo (#8)
All checks were successful
Build ptprnt / build (push) Successful in 3m41s
Details

Browse Source 
Goal of this PR is to have some basic labels generated with pangocairo
- size of the canvas should be matching the input text and grow/shrink accordingly
- basic formatting options like fontsize and align should be working

Reviewed-on: moritz/ptouch-prnt#8
This commit was merged in pull request #8.
This commit is contained in:
Moritz Martinius
2025-10-12 20:07:18 +00:00
parent fec8ee231b
commit 05cd9d244c
43 changed files with 2087 additions and 622 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/graphics/Bitmap.cpp
View File

@@ -1,6 +1,6 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023 Moritz Martinius
Copyright (C) 2023-2025 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -19,32 +19,30 @@
#include "Bitmap.hpp"
#include <algorithm>
#include <spdlog/spdlog.h>
#include <iterator>
#include <optional>
#include <ranges>
#include <stdexcept>
#include <vector>
namespace ptprnt::graphics {
template <class T>
Bitmap<T>::Bitmap(uint16_t width, uint16_t height)
: mWidth{width}, mHeight{height}, mPixels(width * height) {}
Bitmap<T>::Bitmap(uint16_t width, uint16_t height) : mWidth{width}, mHeight{height}, mPixels(width * height) {}
template <class T>
uint16_t Bitmap<T>::getWidth() {
[[nodiscard]] uint16_t Bitmap<T>::getWidth() const {
return mWidth;
}
template <class T>
uint16_t Bitmap<T>::getHeight() {
[[nodiscard]] uint16_t Bitmap<T>::getHeight() const {
return mHeight;
}
template <class T>
bool Bitmap<T>::setPixels(const std::vector<T>& pixels) {
if (pixels.size() != mPixels.size()) {
spdlog::error("Invalid pixel buffer size.");
spdlog::error("Invalid pixel buffer size (got {} vs. {} bitmap size).", pixels.size(), mPixels.size());
return false;
}
@@ -53,39 +51,34 @@ bool Bitmap<T>::setPixels(const std::vector<T>& pixels) {
}
template <class T>
std::vector<T> Bitmap<T>::getPixelsCpy() {
[[nodiscard]] std::vector<T> Bitmap<T>::getPixelsCpy() const {
return mPixels;
}
template <class T>
std::optional<std::vector<T>> Bitmap<T>::getLine(uint16_t line) {
if (line >= mHeight) {
// out of bound
return std::nullopt;
[[nodiscard]] std::vector<T> Bitmap<T>::getLine(const uint16_t lineNo) const {
if (lineNo >= mHeight) {
throw(std::out_of_range("Line is out of range!"));
}
auto lineStart = mPixels.begin() + (line * mWidth);
auto lineEnd = mPixels.begin() + ((line + 1) * mWidth);
auto lineStart = mPixels.begin() + (lineNo * mWidth);
auto lineEnd = mPixels.begin() + ((lineNo + 1) * mWidth);
return std::vector<T>(lineStart, lineEnd);
}
// TODO: I guess this is borked
template <class T>
std::optional<std::vector<T>> Bitmap<T>::getCol(uint16_t col) {
if (col >= mWidth) {
// out of bound
return std::nullopt;
[[nodiscard]] std::vector<T> Bitmap<T>::getCol(const uint16_t colNo) const {
if (colNo >= mWidth) {
throw(std::out_of_range("Col is out of range!"));
}
// first pixel is always beginning of the col
std::vector<T> colPixels(mHeight);
auto it = std::next(mPixels.begin(), col);
for (auto& colElement : colPixels) {
colElement = *it;
std::advance(it, mWidth);
std::vector<T> col{};
col.reserve(mHeight);
for (size_t i{0}; i <= mPixels.size(); i++) {
if (i % mWidth == colNo) {
col.push_back(mPixels[i]);
}
}
return colPixels;
return col;
}
} // namespace ptprnt::graphics

30
src/graphics/Bitmap.hpp
View File

@@ -1,6 +1,6 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023 Moritz Martinius
Copyright (C) 2023-2025 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -19,19 +19,17 @@
#pragma once
#include <stdint.h>
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <vector>
namespace ptprnt::graphics {
typedef uint8_t ALPHA8; // Alpha only, 8 bit per pixel
typedef uint32_t RGBX8; // RGB, least significant byte unused, 8 bit per channel
typedef uint32_t RGBA8; // RGB, least significant byte alpha, 8 bit per channel
typedef uint32_t ARGB8; // RGB, most significant byte alpha, 8 bit per channel
using ALPHA8 = std::uint8_t; // Alpha only, 8 bit per pixel
using RGBX8 = std::uint32_t; // RGB, least significant byte unused, 8 bit per channel
using RGBA8 = std::uint32_t; // RGB, least significant byte alpha, 8 bit per channel
using ARGB8 = std::uint32_t; // RGB, most significant byte alpha, 8 bit per channel
template <class T>
class Bitmap {
@@ -39,12 +37,18 @@ class Bitmap {
Bitmap(uint16_t width, uint16_t height);
~Bitmap() = default;
uint16_t getWidth();
uint16_t getHeight();
Bitmap(const Bitmap&) = default;
Bitmap& operator=(const Bitmap&) = default;
Bitmap(Bitmap&&) = default;
Bitmap& operator=(Bitmap&&) = default;
[[nodiscard]] uint16_t getWidth() const;
[[nodiscard]] uint16_t getHeight() const;
bool setPixels(const std::vector<T>& pixels);
std::vector<T> getPixelsCpy();
std::optional<std::vector<T>> getLine(uint16_t line);
std::optional<std::vector<T>> getCol(uint16_t col);
[[nodiscard]] std::vector<T> getPixelsCpy() const;
[[nodiscard]] std::vector<T> getLine(uint16_t line) const;
[[nodiscard]] std::vector<T> getCol(uint16_t col) const;
void visualize() const;
private:
uint16_t mWidth;

57
src/graphics/Image.cpp
View File

@@ -1,57 +0,0 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "Image.hpp"
#include <string>
#include "pango/pango-font.h"
namespace ptprnt::graphics {
Image::Image() {
mSurface = cairo_image_surface_create(CAIRO_FORMAT_A8, 512, 128);
cairo_t* cr = cairo_create(mSurface);
mFontDescription = pango_font_description_new();
pango_font_description_set_family(mFontDescription, "sans");
pango_font_description_set_weight(mFontDescription, PANGO_WEIGHT_SEMIBOLD);
pango_font_description_set_size(mFontDescription, 60 * PANGO_SCALE);
std::string printThis("Mist 💩");
mLayout = pango_cairo_create_layout(cr);
pango_layout_set_font_description(mLayout, mFontDescription);
pango_layout_set_text(mLayout, printThis.c_str(), -1);
cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
cairo_move_to(cr, 0.0, 94.0);
pango_cairo_show_layout_line(cr, pango_layout_get_line(mLayout, 0));
cairo_surface_write_to_png(mSurface, "hello.png");
}
uint8_t* Image::getRaw() {
cairo_surface_flush(mSurface);
return cairo_image_surface_get_data(mSurface);
}
Image::~Image() {
g_object_unref(mLayout);
pango_font_description_free(mFontDescription);
}
} // namespace ptprnt::graphics

38
src/graphics/Image.hpp
View File

@@ -1,38 +0,0 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <pango/pangocairo.h>
#include <cstdint>
namespace ptprnt::graphics {
class Image {
public:
Image();
~Image();
uint8_t* getRaw();
private:
PangoLayout* mLayout;
PangoFontDescription* mFontDescription;
cairo_surface_t* mSurface;
};
} // namespace ptprnt::graphics

229
src/graphics/Label.cpp Normal file
View File

@@ -0,0 +1,229 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023-2025 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include "graphics/Label.hpp"
#include <algorithm>
#include <spdlog/spdlog.h>
#include <cassert>
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
#include "cairo.h"
#include "graphics/interface/ILabel.hpp"
#include "pango/pango-font.h"
#include "pango/pango-layout.h"
#include "pango/pango-types.h"
#include "pango/pangocairo.h"
namespace ptprnt::graphics {
Label::Label(const uint16_t heightPixel)
: mPrinterHeight(heightPixel) {
// Initialize resources in correct order with RAII
mFontMap.reset(pango_cairo_font_map_new());
}
std::vector<uint8_t> Label::getRaw() {
assert(mSurface != nullptr);
auto* surface = mSurface.get();
cairo_surface_flush(surface);
assert(cairo_image_surface_get_format(surface) == CAIRO_FORMAT_A8);
int width = cairo_image_surface_get_width(surface);
int height = cairo_image_surface_get_height(surface);
int stride = cairo_image_surface_get_stride(surface);
spdlog::debug("Cairo Surface data: W: {}; H: {}; S:{}", width, height, stride);
auto data = cairo_image_surface_get_data(surface);
// If stride equals width, we can return data directly
if (stride == width) {
size_t len = height * stride;
return {data, data + len};
}
// Otherwise, we need to copy row by row, removing stride padding
std::vector<uint8_t> result;
result.reserve(width * height);
for (int y = 0; y < height; ++y) {
uint8_t* row_start = data + (y * stride);
result.insert(result.end(), row_start, row_start + width);
}
spdlog::debug("getRaw: Removed stride padding, returning {} bytes ({}x{})", result.size(), width, height);
return result;
}
uint8_t Label::getNumLines(std::string_view strv) {
return std::count(strv.begin(), strv.end(), '\n');
}
int Label::getWidth() {
// Return the actual Cairo surface width (which is the layout width)
return mLayoutWidth;
}
int Label::getHeight() {
// Return the actual Cairo surface height (which is the printer height)
return mPrinterHeight;
}
void Label::configureLayout(PangoLayout* layout, const std::string& text, PangoFontDescription* fontDesc) {
pango_layout_set_font_description(layout, fontDesc);
pango_layout_set_text(layout, text.c_str(), static_cast<int>(text.length()));
pango_layout_set_height(layout, getNumLines(text) * -1);
}
void Label::applyHorizontalAlignment(PangoLayout* layout) {
switch (mHAlign) {
case HAlignPosition::LEFT:
pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
break;
case HAlignPosition::RIGHT:
pango_layout_set_alignment(layout, PANGO_ALIGN_RIGHT);
break;
case HAlignPosition::JUSTIFY:
pango_layout_set_alignment(layout, PANGO_ALIGN_LEFT);
pango_layout_set_justify(layout, true);
#if PANGO_VERSION_MAJOR >= 1 && PANGO_VERSION_MINOR >= 50
pango_layout_set_justify_last_line(layout, true);
#endif
break;
case HAlignPosition::CENTER:
[[fallthrough]];
default:
pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
break;
}
}
bool Label::create(PrintableText printableText) {
setFontFamily(printableText.fontFamily);
setFontSize(printableText.fontSize);
return create(printableText.text);
}
bool Label::create(const std::string& labelText) {
// TODO: we need to create a custom font config here so that Noto Emoji does not load the systems default
// font config here. For this, we need to create a PangoFcFontMap and a custom FcConfig
// see: https://docs.gtk.org/PangoFc/method.FontMap.set_config.html
// see: https://gist.github.com/CallumDev/7c66b3f9cf7a876ef75f
// Create a temporary surface for layout size calculations
auto* tempSurface = cairo_image_surface_create(CAIRO_FORMAT_A8, 1, 1);
auto* tempCr = cairo_create(tempSurface);
auto* tempPangoCtx = pango_cairo_create_context(tempCr);
auto* tempPangoLyt = pango_layout_new(tempPangoCtx);
PangoFontDescription* regularFont = pango_font_description_new();
pango_font_description_set_size(regularFont, static_cast<int>(mFontSize * PANGO_SCALE));
pango_font_description_set_family(regularFont, mFontFamily.c_str());
// Configure temporary layout for size calculation
configureLayout(tempPangoLyt, labelText, regularFont);
applyHorizontalAlignment(tempPangoLyt);
// Calculate label size from temporary layout
pango_layout_get_size(tempPangoLyt, &mLayoutWidth, &mLayoutHeight);
mLayoutWidth /= PANGO_SCALE;
mLayoutHeight /= PANGO_SCALE;
spdlog::debug("Layout width: {}, height: {}", mLayoutWidth, mLayoutHeight);
//auto alignedWidth = mLayoutWidth + (8 - (mLayoutWidth % 8));
//spdlog::debug("Aligned Layout width: {}, height: {}", alignedWidth, mLayoutHeight);
// Clean up temporary resources
g_object_unref(tempPangoLyt);
g_object_unref(tempPangoCtx);
cairo_destroy(tempCr);
cairo_surface_destroy(tempSurface);
// Now create the final surface and Pango context for actual rendering
mSurface.reset(cairo_image_surface_create(CAIRO_FORMAT_A8, mLayoutWidth, mPrinterHeight));
cairo_t* cr = cairo_create(mSurface.get());
mCairoCtx.reset(cr);
mPangoCtx.reset(pango_cairo_create_context(cr));
mPangoLyt.reset(pango_layout_new(mPangoCtx.get()));
// Configure final layout with same settings
configureLayout(mPangoLyt.get(), labelText, regularFont);
applyHorizontalAlignment(mPangoLyt.get());
// Adjust Cairo cursor position to respect the vertical alignment
switch (mVAlign) {
case VAlignPosition::TOP:
break;
case VAlignPosition::BOTTOM:
cairo_move_to(mCairoCtx.get(), 0.0, mPrinterHeight - mLayoutHeight);
break;
case VAlignPosition::MIDDLE:
cairo_move_to(mCairoCtx.get(), 0.0, (mPrinterHeight - mLayoutHeight) / 2);
break;
default:
break;
}
// Finally show the layout on the Cairo surface
pango_cairo_show_layout(mCairoCtx.get(), mPangoLyt.get());
cairo_set_source_rgb(mCairoCtx.get(), 0.0, 0.0, 0.0);
cairo_surface_flush(mSurface.get());
// mCairoCtx smart pointer will handle cleanup
return true;
}
void Label::writeToPng(const std::string& file) {
if (mSurface) {
cairo_surface_flush(mSurface.get());
cairo_surface_write_to_png(mSurface.get(), file.c_str());
}
}
void Label::setFontSize(const double fontSize) {
mFontSize = fontSize;
}
void Label::setFontFamily(const std::string& fontFamily) {
mFontFamily = fontFamily;
}
void Label::setHAlign(HAlignPosition hAlign) {
mHAlign = hAlign;
}
void Label::setVAlign(VAlignPosition vAlign) {
mVAlign = vAlign;
}
void Label::setText(const std::string& text) {
mText = text;
}
Label::~Label() {
spdlog::debug("Image dtor...");
// RAII smart pointers handle cleanup automatically
}
} // namespace ptprnt::graphics

100
src/graphics/Label.hpp Normal file
View File

@@ -0,0 +1,100 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023-2025 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <pango/pangocairo.h>
#include <cstdint>
#include <memory>
#include <string>
#include <vector>
#include "cairo.h"
#include "graphics/interface/ILabel.hpp"
#include "pango/pango-types.h"
namespace ptprnt::graphics {
// Custom deleters for Cairo/Pango resources
struct CairoSurfaceDeleter {
void operator()(cairo_surface_t* surface) const {
if (surface)
cairo_surface_destroy(surface);
}
};
struct CairoDeleter {
void operator()(cairo_t* cr) const {
if (cr)
cairo_destroy(cr);
}
};
struct GObjectDeleter {
void operator()(gpointer obj) const {
if (obj)
g_object_unref(obj);
}
};
class Label : public ILabel {
public:
Label(const uint16_t heightPixel);
~Label() override;
Label(const Label&) = delete;
Label& operator=(const Label&) = delete;
Label(Label&&) = delete;
Label& operator=(Label&&) = delete;
bool create(PrintableText printableText) override;
bool create(const std::string& labelText) override;
void writeToPng(const std::string& file);
[[nodiscard]] int getWidth() override;
[[nodiscard]] int getHeight() override;
[[nodiscard]] std::vector<uint8_t> getRaw() override;
void setFontSize(const double fontSize) override;
void setFontFamily(const std::string& fontFamily) override;
void setText(const std::string& text) override;
void setHAlign(HAlignPosition hpos) override;
void setVAlign(VAlignPosition vpos) override;
private:
// methods
[[nodiscard]] uint8_t getNumLines(std::string_view str);
[[nodiscard]] PangoFontMap* createCustomFontMap();
void configureLayout(PangoLayout* layout, const std::string& text, PangoFontDescription* fontDesc);
void applyHorizontalAlignment(PangoLayout* layout);
std::unique_ptr<cairo_surface_t, CairoSurfaceDeleter> mSurface{nullptr};
std::unique_ptr<cairo_t, CairoDeleter> mCairoCtx{nullptr};
std::unique_ptr<PangoContext, GObjectDeleter> mPangoCtx{nullptr};
std::unique_ptr<PangoLayout, GObjectDeleter> mPangoLyt{nullptr};
std::unique_ptr<PangoFontMap, GObjectDeleter> mFontMap{nullptr};
double mFontSize{DEFAULT_FONT_SIZE};
std::string mFontFamily{DEFAULT_FONT_FAMILY};
HAlignPosition mHAlign = HAlignPosition::LEFT;
VAlignPosition mVAlign = VAlignPosition::MIDDLE;
std::string mText{""};
int mLayoutWidth = 0, mLayoutHeight = 0;
int mPrinterHeight = 0;
};
} // namespace ptprnt::graphics

242
src/graphics/Monochrome.cpp
View File

@@ -1,6 +1,6 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023 Moritz Martinius
Copyright (C) 2023-2025 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -21,39 +21,239 @@
#include <cmath>
#include <cstdint>
#include <iostream>
#include <vector>
namespace ptprnt::graphics {
Monochrome::Monochrome(const std::vector<uint8_t>& grayscale) : mPixels(std::move(grayscale)) {}
// Constructor from grayscale data
MonochromeData::MonochromeData(const std::vector<uint8_t>& grayscale, uint32_t width, uint32_t height,
Orientation orient)
: stride(0),
orientation(orient),
width(width),
height(height),
mPixels(grayscale),
mIsProcessed(false) {}
void Monochrome::setThreshold(uint8_t threshhold) {
mThreshhold = threshhold;
MonochromeData::MonochromeData(const std::span<uint8_t> grayscale, uint32_t width, uint32_t height,
Orientation orient)
: stride(0),
orientation(orient),
width(width),
height(height),
mPixels(grayscale.begin(), grayscale.end()),
mIsProcessed(false) {}
void MonochromeData::setThreshold(uint8_t threshold) {
mThreshold = threshold;
mIsProcessed = false; // Mark as needing reprocessing
}
void Monochrome::invert(bool shouldInvert) {
void MonochromeData::invert(bool shouldInvert) {
mShouldInvert = shouldInvert;
mIsProcessed = false; // Mark as needing reprocessing
}
std::vector<uint8_t> Monochrome::get() {
std::vector<uint8_t> outPixels(
(static_cast<unsigned int>((mPixels.size() / 8)) + (std::floor(mPixels.size() % 8 + 0.9))));
MonochromeData MonochromeData::get() {
if (!mIsProcessed) {
processGrayscaleToMonochrome();
mIsProcessed = true;
}
unsigned int outIndex = 0;
// Return a copy of the processed data
MonochromeData result;
result.bytes = bytes;
result.stride = stride;
result.orientation = orientation;
result.width = width;
result.height = height;
result.mIsProcessed = true;
return result;
}
for (unsigned int byteNum = 0; byteNum < mPixels.size(); byteNum += 8) {
for (unsigned int bitNo = 0; bitNo < 8; bitNo++) {
if (mPixels[byteNum + bitNo] > mThreshhold) {
outPixels[outIndex] |= (1 << (7 - bitNo));
} else {
outPixels[outIndex] &= ~(1 << (7 - bitNo));
void MonochromeData::processGrayscaleToMonochrome() {
// Calculate stride based on packed monochrome data (1 bit per pixel, 8 pixels per byte)
stride = static_cast<uint32_t>((width + 7) / 8);
// Create the monochrome byte array
bytes.clear();
bytes.resize(stride * height, 0);
// Convert grayscale to monochrome
for (uint32_t y = 0; y < height; ++y) {
for (uint32_t x = 0; x < width; ++x) {
uint32_t pixelIndex = y * width + x;
if (pixelIndex < mPixels.size()) {
uint8_t pixelValue = mPixels[pixelIndex];
// Apply threshold
bool isSet = pixelValue >= mThreshold;
// Apply inversion if needed
if (mShouldInvert) {
isSet = !isSet;
}
// Set the bit in the monochrome data
if (isSet) {
setBit(x, y, true);
}
}
}
if (mShouldInvert) {
outPixels[outIndex] = ~outPixels[outIndex];
}
outIndex++;
}
return outPixels;
}
// Transformation methods implementation
void MonochromeData::transformTo(Orientation targetOrientation) {
if (orientation == targetOrientation) {
return; // No transformation needed
}
auto rotatedData = createRotatedData(targetOrientation);
bytes = std::move(rotatedData);
// Update dimensions and stride based on rotation
switch (targetOrientation) {
case Orientation::PORTRAIT:
case Orientation::PORTRAIT_FLIPPED:
// Swap width and height for portrait orientations
std::swap(width, height);
stride = (width + 7) / 8; // Recalculate stride for new width
break;
case Orientation::LANDSCAPE:
case Orientation::LANDSCAPE_FLIPPED:
// Keep original stride calculation
stride = (width + 7) / 8;
break;
}
orientation = targetOrientation;
}
bool MonochromeData::getBit(uint32_t x, uint32_t y) const {
if (x >= width || y >= height) {
return false;
}
uint32_t byteIndex = y * stride + x / 8;
uint32_t bitIndex = 7 - (x % 8); // MSB first
if (byteIndex >= bytes.size()) {
return false;
}
return (bytes[byteIndex] >> bitIndex) & 1;
}
void MonochromeData::setBit(uint32_t x, uint32_t y, bool value) {
if (x >= width || y >= height) {
return;
}
uint32_t byteIndex = y * stride + x / 8;
uint32_t bitIndex = 7 - (x % 8); // MSB first
if (byteIndex >= bytes.size()) {
return;
}
if (value) {
bytes[byteIndex] |= (1 << bitIndex);
} else {
bytes[byteIndex] &= ~(1 << bitIndex);
}
}
std::vector<uint8_t> MonochromeData::createRotatedData(Orientation targetOrientation) const {
uint32_t newWidth = 0, newHeight = 0;
// Determine new dimensions
switch (targetOrientation) {
case Orientation::PORTRAIT:
case Orientation::PORTRAIT_FLIPPED:
newWidth = height;
newHeight = width;
break;
case Orientation::LANDSCAPE:
case Orientation::LANDSCAPE_FLIPPED:
default:
newWidth = width;
newHeight = height;
break;
}
uint32_t newStride = (newWidth + 7) / 8;
std::vector<uint8_t> newBytes(newStride * newHeight, 0);
// Create a temporary MonochromeData for the new image
MonochromeData tempData;
tempData.bytes = std::move(newBytes);
tempData.stride = newStride;
tempData.width = newWidth;
tempData.height = newHeight;
tempData.orientation = targetOrientation;
// Copy pixels with appropriate transformation
for (uint32_t y = 0; y < height; ++y) {
for (uint32_t x = 0; x < width; ++x) {
bool pixel = getBit(x, y);
uint32_t newX = 0, newY = 0;
switch (targetOrientation) {
case Orientation::LANDSCAPE:
newX = x;
newY = y;
break;
case Orientation::PORTRAIT: // 90 degrees clockwise
newX = height - 1 - y;
newY = x;
break;
case Orientation::LANDSCAPE_FLIPPED: // 180 degrees
newX = width - 1 - x;
newY = height - 1 - y;
break;
case Orientation::PORTRAIT_FLIPPED: // 270 degrees clockwise
newX = y;
newY = width - 1 - x;
break;
}
tempData.setBit(newX, newY, pixel);
}
}
return std::move(tempData.bytes);
}
void MonochromeData::visualize() const {
std::cout << "MonochromeData visualization (" << width << "x" << height << ", orientation: ";
switch (orientation) {
case Orientation::LANDSCAPE:
std::cout << "LANDSCAPE";
break;
case Orientation::PORTRAIT:
std::cout << "PORTRAIT";
break;
case Orientation::LANDSCAPE_FLIPPED:
std::cout << "LANDSCAPE_FLIPPED";
break;
case Orientation::PORTRAIT_FLIPPED:
std::cout << "PORTRAIT_FLIPPED";
break;
}
std::cout << "):" << std::endl;
// Print the image row by row
for (uint32_t y = 0; y < height; ++y) {
for (uint32_t x = 0; x < width; ++x) {
bool pixel = getBit(x, y);
std::cout << (pixel ? "█" : ".");
}
std::cout << std::endl;
}
std::cout << std::endl;
}
} // namespace ptprnt::graphics

79
src/graphics/Monochrome.hpp
View File

@@ -1,6 +1,6 @@
/*
ptrnt - print labels on linux
Copyright (C) 2023 Moritz Martinius
Copyright (C) 2023-2025 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@@ -20,22 +20,81 @@
#pragma once
#include <cstdint>
#include <span>
#include <vector>
#include "graphics/Bitmap.hpp"
namespace ptprnt::graphics {
class Monochrome {
public:
Monochrome(const std::vector<uint8_t>& grayscale);
~Monochrome() = default;
void setThreshold(uint8_t);
enum class Orientation {
LANDSCAPE = 0, // 0 degrees
PORTRAIT = 1, // 90 degrees clockwise
LANDSCAPE_FLIPPED = 2, // 180 degrees
PORTRAIT_FLIPPED = 3 // 270 degrees clockwise (90 counter-clockwise)
};
class MonochromeData {
public:
// Constructors
MonochromeData() : stride(0), orientation(Orientation::LANDSCAPE), width(0), height(0) {}
MonochromeData(std::vector<uint8_t> data, uint32_t stride_bytes, Orientation orient = Orientation::LANDSCAPE,
uint32_t w = 0, uint32_t h = 0)
: bytes(std::move(data)), stride(stride_bytes), orientation(orient), width(w), height(h) {}
// Constructor from grayscale data (replaces old Monochrome class)
MonochromeData(const std::vector<uint8_t>& grayscale, uint32_t width, uint32_t height,
Orientation orient = Orientation::LANDSCAPE);
MonochromeData(const std::span<uint8_t> grayscale, uint32_t width, uint32_t height,
Orientation orient = Orientation::LANDSCAPE);
~MonochromeData() = default;
// Copy constructor and assignment
MonochromeData(const MonochromeData&) = default;
MonochromeData& operator=(const MonochromeData&) = default;
// Move constructor and assignment
MonochromeData(MonochromeData&&) = default;
MonochromeData& operator=(MonochromeData&&) = default;
// Configuration methods
void setThreshold(uint8_t threshold);
void invert(bool shouldInvert);
std::vector<uint8_t> get();
// Get processed monochrome data
MonochromeData get();
// Transform the image data to the target orientation
void transformTo(Orientation targetOrientation);
// Visualize the monochrome data on stdout
void visualize() const;
// Helper methods for orientation transformations
[[nodiscard]] bool getBit(uint32_t x, uint32_t y) const;
void setBit(uint32_t x, uint32_t y, bool value);
[[nodiscard]] std::vector<uint8_t> createRotatedData(Orientation targetOrientation) const;
// Public member access for backward compatibility
std::vector<uint8_t> bytes;
uint32_t stride;
Orientation orientation;
uint32_t width; // Width in pixels
uint32_t height; // Height in pixels
private:
const std::vector<uint8_t>& mPixels;
uint8_t mThreshhold = 127;
bool mShouldInvert = false;
// Processing parameters (for old Monochrome class compatibility)
std::vector<uint8_t> mPixels; // Original grayscale pixels
uint8_t mThreshold = UINT8_MAX / 2;
bool mShouldInvert = false;
bool mIsProcessed = false; // Flag to indicate if conversion has been done
// Helper method to convert grayscale to monochrome
void processGrayscaleToMonochrome();
};
// For backward compatibility, create a type alias
using Monochrome = MonochromeData;
} // namespace ptprnt::graphics

80
src/graphics/interface/ILabel.hpp Normal file
View File

@@ -0,0 +1,80 @@
/*
ptrnt - print labels on linux
Copyright (C) 2024-2025 Moritz Martinius
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#pragma once
#include <cstdint>
#include <map>
#include <string>
#include <vector>
constexpr const char* DEFAULT_FONT_FAMILY = "sans";
constexpr const double DEFAULT_FONT_SIZE = 32.0;
enum class HAlignPosition {
UNKNOWN = 0,
LEFT = 1,
CENTER = 2,
RIGHT = 3,
JUSTIFY = 4,
};
const std::map<std::string, HAlignPosition> HALignPositionMap{{"", HAlignPosition::UNKNOWN},
{"left", HAlignPosition::LEFT},
{"center", HAlignPosition::CENTER},
{"right", HAlignPosition::RIGHT},
{"justify", HAlignPosition::JUSTIFY}};
enum class VAlignPosition {
UNKNOWN = 0,
TOP = 1,
MIDDLE = 2,
BOTTOM = 3,
};
const std::map<std::string, VAlignPosition> VALignPositionMap{{"", VAlignPosition::UNKNOWN},
{"top", VAlignPosition::TOP},
{"middle", VAlignPosition::MIDDLE},
{"bottom", VAlignPosition::BOTTOM}};
struct PrintableText {
std::string text{""};
std::string fontFamily{DEFAULT_FONT_FAMILY};
double fontSize{DEFAULT_FONT_SIZE};
HAlignPosition hAlign{HAlignPosition::LEFT};
VAlignPosition vAlign{VAlignPosition::MIDDLE};
};
namespace ptprnt::graphics {
class ILabel {
public:
virtual ~ILabel() = default;
virtual bool create(PrintableText printableText) = 0;
virtual bool create(const std::string& labelText) = 0;
virtual std::vector<uint8_t> getRaw() = 0;
virtual int getWidth() = 0;
virtual int getHeight() = 0;
virtual void setText(const std::string& text) = 0;
virtual void setFontSize(const double fontSize) = 0;
virtual void setFontFamily(const std::string& fontFamily) = 0;
virtual void setHAlign(HAlignPosition hpos) = 0;
virtual void setVAlign(VAlignPosition vpos) = 0;
};
} // namespace ptprnt::graphics