How is possible draw with Image Brush out of the Image bounds? To have shifted effect in result Image.

[LLIAMAH]

I've picture 1000x1000 pixels and I need to have texture, from the image brush resized to 100x100 where each even row from the top must start by X: from zero to width, but each odd row (by Y) must be shifted by -50 pixels: -(image_size / 2) and end shifted +50 pixels after row end.
I've drawing algorithm, which took image pattern, create brush resized to 100x100:

private static void DrawFull(IImageProcessingContext ctx, Size size, Brush brush, int width, int height)
{
    var j = 0;
    while (j < height)
    {
        var limitWidth = width;
        var i = 0;
        if ((j / size.Height) % 2 != 0)
        {
            i = - (size.Width / 2);
            limitWidth = width + size.Width;
        }

        while (i < limitWidth)
        {
            ctx.Fill(brush, new RectangleF(new PointF(i, j), size));
            i += size.Width;
        }

        j += size.Height;
    }
}

But first odd item is drawn wrong way - it seems it starts with the x: -50 coordinate, but drawn only half and brush draw it from zero coordinate:

I'm not sure but it seems it is some Image brush behavior bug.

[LLIAMAH]

It seems it is bug

1. If I writing code to draw one line from the width - brush pattern size: result always same - there is no left shift.

ctx.DrawLine(brush, 100, new PointF[]
{
    new PointF(-50, (float)size.Height / 2),
    new PointF(width, (float)size.Height / 2)
});

///OR full line with shift from both sides:
ctx.DrawLine(brush, 100, new PointF[]
{
    new PointF(width + 50, (float)size.Height / 2),
    new PointF(-50, (float)size.Height / 2)
});

Left corder looks like unshifted.

2. Here I'm trying to do work around - do the shift in 50 pixels and draw one line to the left, but second one to the right.

// Here we have some shift and zero X point 50 pixels right to width
ctx.DrawLine(brush, 100, new PointF[]
{
    new PointF(50, (float)size.Height / 2),
    new PointF(width, (float)size.Height / 2)
});

// here we try to draw line inverse from +50 by X till 0:
ctx.DrawLine(brush, 100, new PointF[]
{
    new PointF(50, (float)size.Height / 2),
    new PointF(0, (float)size.Height / 2)
});

And in result I've same picture:

So there is question - how is possible to draw ImageBrush line, starting with some shift from the left border of the image? From minus some X to Width.

[JimBobSquarePants]

I'm struggling to follow your intention vs the implementation here as you're offsetting the position of the path you are drawing not the brush itself. You're also exceeding the bounds of the image.

[LLIAMAH]

I'm struggling to follow your intention vs the implementation here as you're offsetting the position of the path you are drawing not the brush itself. You're also exceeding the bounds of the image.

I've a template 256x256 pixels template, which I convert to the 100x100 pixels result (and changing color):

I must draw full texture in which:

• even lines started in normal way and drawing full template figure until end
• odd lines must be shifted and first figure shows only half of the templated figure (and with ending figure - must be 1/2 of template too).
  Here is required view created by work around - in which I'm adding additional portion of the half of the figure at start:
  
  This means I need 2 brushes to draw:

1. First - to draw half of the pattern for first "half item"
   and
2. Second - to draw full pattern for all next line.

How I planned to do - set start coordinate at -50 pixel left it is minus half of the template size. And in result I'm receiving this:

And this half figure drawn first - is abnormal, cause END figure of the line drawn in valid way - only Half figure is visible.

Yes in this case I've to break bounds, cause I NEED only PART of the Image to drawn at some level.
Does it mean that is possible to go out bound in the end, but impossible from the start?

[JimBobSquarePants]

I see what you are doing now.

You cannot draw in any direction out of bounds. The image will be clipped.

Your negative x-position leads to clamping which then reduces the size of the reglangular path.

I don't know what you are trying to achieve in this DrawLine example. What is it?

///OR full line with shift from both sides:
ctx.DrawLine(brush, 100, new PointF[]
{
    new PointF(width + 50, (float)size.Height / 2),
    new PointF(-50, (float)size.Height / 2)
});

What I can do is expose an internal constructor to the image brush which allows you to select a region of interest within the overlay image to draw.

Given that change here's a unit test that demostrates a change to your algorithm wich would yield the expected result.

[Theory]
[WithSolidFilledImages(1000, 1000, "White", PixelTypes.Rgba32)]
public void CanDrawOffsetImage<TPixel>(TestImageProvider<TPixel> provider)
    where TPixel : unmanaged, IPixel<TPixel>
{
    byte[] data = TestFile.Create(TestImages.Png.Ducky).Bytes;
    using Image<TPixel> background = provider.GetImage();
    using Image overlay = Image.Load<Rgba32>(data);

    overlay.Mutate(c => c.Resize(100, 100));

    ImageBrush half = new(overlay, new RectangleF(50, 0, 50, 100));
    ImageBrush full = new(overlay);
    background.Mutate(c => DrawFull(c, new Size(100, 100), full, half, 1000, 1000));

    background.DebugSave(provider, appendSourceFileOrDescription: false);
    background.CompareToReferenceOutput(provider, appendSourceFileOrDescription: false);
}

private static void DrawFull(IImageProcessingContext ctx, Size size, ImageBrush brush, ImageBrush halfBrush, int width, int height)
{
    int j = 0;
    while (j < height)
    {
        bool half = false;
        int limitWidth = width;
        int i = 0;
        if ((j / size.Height) % 2 != 0)
        {
            half = true;
        }

        while (i < limitWidth)
        {
            if (half)
            {
                ctx.Fill(halfBrush, new RectangleF(i, j, size.Width / 2f, size.Height));
                i += (int)(size.Width / 2f);
                half = false;
            }
            else
            {
                ctx.Fill(brush, new RectangleF(new PointF(i, j), size));
                i += size.Width;
            }
        }

        j += size.Height;
    }
}

[tocsoft]

I don't think either of these ways are the best for creating this effect, you really should just be creating a single new texture pre computed to be 2 rows tall so that it ends up something like this.

the code to make that is;

public Image BuildMultiRowTexture(Image sourceTexture)
{
    int halfWidth = sourceTexture.Width / 2;

    Image final = sourceTexture.Clone(x => x.Resize(new ResizeOptions
    {
        Size = new Size(templateImage.Width, templateImage.Height * 2),
        Position = AnchorPositionMode.TopLeft,
        Mode = ResizeMode.Pad,
    })
    .DrawImage(templateImage, new Point(halfWidth, sourceTexture.Height), new Rectangle(0, 0, halfWidth, sourceTexture.Height), 1)
    .DrawImage(templateImage, new Point(0, templateImage.Height), new Rectangle(halfWidth, 0, halfWidth, sourceTexture.Height), 1));
    return final;
}

then you would just apply it as a simple fill directly

using Image templateImage = Image.Load<Rgba32>(data);
// manipulate the source image here

using Image finalTexture = BuildMultiRowTexture(templateImage); 
ImageBrush brush = new(finalTexture );
background.Mutate(c => c.Fill(brush));

returning the same