I'm trying to have some text with two lines, aligned to the bottom of some bounds, and with a small line-height so that the two lines are closer together. However the text is not going where I would expect. It looks like it's going too downwards. When aligned to bottom it even goes outside the bounds. If I leave the line-height to default it also doesn't look right. Am I missing something?

Here's an example and it's output:

import pixie

image = pixie.Image(800, 800)
image.fill(pixie.Color(1, 1, 1, 1))

paint = pixie.Paint(pixie.PK_SOLID)
paint.color = pixie.Color(1, 0, 0, 1)
ctx = image.new_context()
ctx.line_width = 1
ctx.stroke_style = paint
ctx.stroke_rect(0, 266, 800, 318)

text = "AbCd\naBcD"

font = pixie.read_font("./Inter-Bold.otf")
font.size = 182
font.line_height = 140

font.paint.color = pixie.Color(1, 0, 0, 1)
image.fill_text(
    font,
    text,
    bounds = pixie.Vector2(800, 318),
    h_align = pixie.HA_CENTER,
    v_align = pixie.VA_TOP,
    transform = pixie.translate(0, 266)
)

font.paint.color = pixie.Color(0, 1, 0, 1)
image.fill_text(
    font,
    text,
    bounds = pixie.Vector2(800, 318),
    h_align = pixie.HA_CENTER,
    v_align = pixie.VA_MIDDLE,
    transform = pixie.translate(0, 266)
)

font.paint.color = pixie.Color(0, 0, 1, 1)
image.fill_text(
    font,
    text,
    bounds = pixie.Vector2(800, 318),
    h_align = pixie.HA_CENTER,
    v_align = pixie.VA_BOTTOM,
    transform = pixie.translate(0, 266)
)

image.write_file("out.png")

Installed pixie-python via pip, however when I try to load a JPG I get the following exception.

Exception has occurred: PixieError
Decoding JPG requires -d:pixieUseStb

I guess pixie is using std image library under the hood and the package did not get compiled with the correct options to support this?

Hi treeform, very nice lib (looking at the python output), I have recently discovered Flutter over dart language, they create a nice vibrant UI experience. BUT:

its ffi lib is just so ugly, shudders! it's ffi interop is very verbose and looks annoying to get done, at the same time, devs seem to flock to this (relatively) new platform but not many want to get hands dirty in C code, so Nim to the rescue right?

Can genny also support the dart programming language? it's just generating a lot of ugly boilerplate code.

I think it's a chance to get more people to use Nim, and thereby building more libs and contributing to it, which was one of your purposes with genny.

Aside from that, I personally want to leverage Nim libraries that i and others have written, and use dart and flutter mainly for the GUI story (though in terms of features, dart looks to be a decent language. unfortunately for dart, in terms of syntax - verbose like java and I think no templates, but this is just first impressions.)

I see there is an encodeImage proc in the nim library, would it be possible to support that as well as the already existing write_file() in the python layer?

https://nimdocs.com/treeform/pixie/pixie.html#encodeImage%2CImage%2CFileFormat

import pixie gives error:

---------------------------------------------------------------------------

OSError                                   Traceback (most recent call last)

<ipython-input-14-4833f4429f21> in <module>()
----> 1 import pixie
      2 
      3 

3 frames

/usr/lib/python3.7/ctypes/__init__.py in __init__(self, name, mode, handle, use_errno, use_last_error)
    362 
    363         if handle is None:
--> 364             self._handle = _dlopen(self._name, mode)
    365         else:
    366             self._handle = handle

OSError: /lib/x86_64-linux-gnu/libm.so.6: version `GLIBC_2.29' not found (required by /usr/local/lib/python3.7/dist-packages/pixie/libpixie.so)

https://i.imgur.com/N1ue3Ce.png

This is the source code：

import pixie

image = pixie.Image(200, 200)
image.fill(pixie.Color(1, 1, 1, 1))

paint = pixie.Paint(pixie.PK_SOLID)
paint.color = pixie.Color(1, 0, 0, 1)

ctx = image.new_context()
ctx.fill_style = paint

ctx.fill_rect(50, 50, 100, 100)

image.write_file("examples/square.png")

I got the following results： Traceback (most recent call last): File "F:\Python\Python Project\Test\test.py", line 6, in paint = pixie.Paint(pixie.PK_SOLID) AttributeError: module 'pixie' has no attribute 'PK_SOLID'

Would be nice if add this alignment style, also give access to Arrangement attributes(selectionRects, lines, positions).

I've made this little library for making this feature for me, it behaves like the Microsoft Word Office.

import
    nimpy,
    pixie,
    unicode

pyExportModule("pixie_utils")

const
    LF = Rune(10)
    NR = Rune(0)

proc justifyArrangement*(arrangement: Arrangement, maxWidth: float32) {.raises: [].} =
    proc right(rect: Rect): float32 =
        rect.x + rect.w

    let
        runes: ptr = arrangement.runes.addr
        positions: ptr = arrangement.positions.addr
        rects: ptr = arrangement.selectionRects.addr
        last_lineId: int = arrangement.lines.len-1
    var
        rune, last_rune: Rune
        last_wordRuneId: int
        spaces_idx: seq[int]
        inc_width, space_width, line_width, x_offset: float32
    
    for lineId, (start, stop) in arrangement.lines:
        last_rune = runes[stop]

        # This line must not be justified, if it is the last or if the last rune is a breakline char.
        if lineId == last_lineId or last_rune.uint32 == LF.uint32:
            continue

        echo runes[start..stop]
        # Get the spaces indexes of this line to increase their width, and get the line width.
        spaces_idx = @[]
        last_rune = NR
        for r_id in start..stop:
            rune = runes[r_id]
            if not rune.isWhiteSpace():
                if last_rune.isWhiteSpace():
                    spaces_idx.add(r_id-1)
                last_wordRuneId = r_id
            last_rune = runes[r_id]

        line_width = rects[last_wordRuneId].right

        echo "Line spaces: ", spaces_idx.len
        if spaces_idx.len > 0:
            # Get the amount of pixels/units to increase each space width in the middle of the line.
            inc_width = (maxWidth - line_width) / spaces_idx.len.float32

            if inc_width > 0:
                space_width = rects[spaces_idx[0]].w + inc_width

                # Adjust the runes X position
                x_offset = 0
                for r_id in spaces_idx[0]..stop:
                    positions[r_id].x += x_offset

                    if r_id in spaces_idx:
                        rects[r_id].x += x_offset
                        rects[r_id].w = space_width
                        x_offset += inc_width
                    else:
                        rects[r_id].x += x_offset

proc justifyArrangement(arrangement_ref: int, maxWidth: float32) {.exportpy: "justifyArrangement".} =
    justifyArrangement(cast[Arrangement](arrangement_ref), maxWidth)

I need the bytes of the images, for example, use them in pillow or pygame.

I've made this little library for making this feature for me, it gets the image data bytes as well the png file bytes.

import
    nimpy,
    pixie

pyExportModule("pixie_utils")

proc getImageBytes*(image: Image, format: string = "png"): string {.raises: [PixieError].} =
  # Gets the bytes from image.
  let encodeFormat = case format:
    of "png": PngFormat
    of "bmp": BmpFormat
    of "jpg", "jpeg": JpegFormat
    of "qoi": QoiFormat
    of "ppm": PpmFormat
    else:
      raise newException(PixieError, "Unsupported image format")

  result = image.encodeImage(encodeFormat)

proc getImageData*(image: Image): string {.raises: [].} =
  # Gets the image data as bytes.
  result = newString(image.width * image.height * 4)
  var
    i = 0
    rgba: ColorRGBA
  
  for color in image.data:
    rgba = color.rgba()
    result[i] = rgba.r.char
    result[i+1] = rgba.g.char
    result[i+2] = rgba.b.char
    result[i+3] = rgba.a.char
    i += 4

proc getImageBytes(image_ref: int, format: string = "png"): string {.exportpy: "getImageBytes".} =
    result = getImageBytes(cast[Image](image_ref), format)

proc getImageData(image_ref: int): string {.exportpy: "getImageData".} =
    result = getImageData(cast[Image](image_ref))

Hi,

If I have known the related offset of translation and angle in pixels between centers of 2 images, can I use this library to generate a mosaic without explicitly considering allocating a big matrix matching to final image size, compensating for non-integer offset values, and converting the offset between image centers to left-up image origin?

Now, I'm doing these trivial things. It's fragile and troublesome.