This is a bug, but it looks interesting! ;^)

https://i.ibb.co/8N5rmWJ/image.png

On 6/10/2023 5:37 PM, Chris M. Thomasson wrote:
> This is a bug, but it looks interesting! ;^)
>
> https://i.ibb.co/8N5rmWJ/image.png

Getting closer... ?

https://i.ibb.co/3svHVMp/image.png

;^)

On Saturday, June 10, 2023 at 8:37:57 PM UTC-4, Chris M. Thomasson wrote:
> This is a bug, but it looks interesting! ;^)
>
> https://i.ibb.co/8N5rmWJ/image.png
Yeah it is closing off the path.

On Saturday, June 10, 2023 at 9:31:08 PM UTC-4, Dan joyce wrote:
> On Saturday, June 10, 2023 at 8:37:57 PM UTC-4, Chris M. Thomasson wrote:
> > This is a bug, but it looks interesting! ;^)
> >
> > https://i.ibb.co/8N5rmWJ/image.png
> Yeah it is closing off the path.

Here is one you did as the going out sequence but the different colors are confusing especially the blue
It's hard to make out the arrows. Just draw it with no arrows and all white with a dark background for now.

https://i.ibb.co/JjXHnjB/image.png

It looks right but I would like to see it all in white with a dark background. if this is correct then the return is a piece of cake.
I also explain in this post how to get rid of the return square that sticks out at the top when the drawing is complete.

On 6/10/2023 5:37 PM, Chris M. Thomasson wrote:
> This is a bug, but it looks interesting! ;^)
>
> https://i.ibb.co/8N5rmWJ/image.png

The path in red is going out, the path in yellow is going back, the path
in purple is the connector. The circles in cyan are end points during
iteration:

https://i.ibb.co/QYckQzC/image.png

It ends up exactly where it started from.

Look okay?

On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> On 6/10/2023 5:37 PM, Chris M. Thomasson wrote:
>> This is a bug, but it looks interesting! ;^)
>>
>> https://i.ibb.co/8N5rmWJ/image.png
>
> The path in red is going out, the path in yellow is going back, the path
> in purple is the connector. The circles in cyan are end points during
> iteration:
>
> https://i.ibb.co/QYckQzC/image.png
>
> It ends up exactly where it started from.
>
> Look okay?

Looking better! ;^)

https://i.ibb.co/ts6k4gK/image.png

On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
>> On 6/10/2023 5:37 PM, Chris M. Thomasson wrote:
>>> This is a bug, but it looks interesting! ;^)
>>>
>>> https://i.ibb.co/8N5rmWJ/image.png
>>
>> The path in red is going out, the path in yellow is going back, the
>> path in purple is the connector. The circles in cyan are end points
>> during iteration:
>>
>> https://i.ibb.co/QYckQzC/image.png
>>
>> It ends up exactly where it started from.
>>
>> Look okay?
>
> Looking better! ;^)
>
> https://i.ibb.co/ts6k4gK/image.png

Here we go... I jest need to get rid of that damn connector! lol...

https://i.ibb.co/8xfnksh/image.png

;^D

On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
>>> On 6/10/2023 5:37 PM, Chris M. Thomasson wrote:
>>>> This is a bug, but it looks interesting! ;^)
>>>>
>>>> https://i.ibb.co/8N5rmWJ/image.png
>>>
>>> The path in red is going out, the path in yellow is going back, the
>>> path in purple is the connector. The circles in cyan are end points
>>> during iteration:
>>>
>>> https://i.ibb.co/QYckQzC/image.png
>>>
>>> It ends up exactly where it started from.
>>>
>>> Look okay?
>>
>> Looking better! ;^)
>>
>> https://i.ibb.co/ts6k4gK/image.png
>
> Here we go... I jest need to get rid of that damn connector! lol...
>
> https://i.ibb.co/8xfnksh/image.png
>
> ;^D

Tired now, going to bed. But, it looks like everything is going to work
out. I just need to polish up my algorithm sometime tomorrow. Good
night. ;^)

Here is a bigger grid:

https://i.ibb.co/MkpdTmg/image.png

It should work fine for any size.

On Sunday, June 11, 2023 at 4:54:31 AM UTC-4, Chris M. Thomasson wrote:
> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> > On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> >> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> >>> On 6/10/2023 5:37 PM, Chris M. Thomasson wrote:
> >>>> This is a bug, but it looks interesting! ;^)
> >>>>
> >>>> https://i.ibb.co/8N5rmWJ/image.png
> >>>
> >>> The path in red is going out, the path in yellow is going back, the
> >>> path in purple is the connector. The circles in cyan are end points
> >>> during iteration:
> >>>
> >>> https://i.ibb.co/QYckQzC/image.png
> >>>
> >>> It ends up exactly where it started from.
> >>>
> >>> Look okay?
> >>
> >> Looking better! ;^)
> >>
> >> https://i.ibb.co/ts6k4gK/image.png
> >
> > Here we go... I jest need to get rid of that damn connector! lol...
> >
> > https://i.ibb.co/8xfnksh/image.png
> >
> > ;^D
> Tired now, going to bed. But, it looks like everything is going to work
> out. I just need to polish up my algorithm sometime tomorrow. Good
> night. ;^)
>
> Here is a bigger grid:
>
> https://i.ibb.co/MkpdTmg/image.png
>
> It should work fine for any size.
I got screwed up looking at this because you are returning from the bottom, dosen't matter, and I returned at the
top, Then when I followed it back I get lost in the begining. What are the two blue lines?
Thanks
Other than that, it looks good.

Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
....
>>>> The path in red is going out, the path in yellow is going back, the
>>>> path in purple is the connector. The circles in cyan are end points
>>>> during iteration:
>>>>
>>>> https://i.ibb.co/QYckQzC/image.png
>>>> It ends up exactly where it started from.
....
>>> https://i.ibb.co/ts6k4gK/image.png
>>
>> Here we go... I jest need to get rid of that damn connector! lol...
>> https://i.ibb.co/8xfnksh/image.png
....
> Here is a bigger grid:
> https://i.ibb.co/MkpdTmg/image.png
>
> It should work fine for any size.

I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
<https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
where the green trace is going out and the blue trace coming in.
Program jLattice1.jl is in Julia, linked at short link above or at
<https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>

The excess connector in purple at the bottom of your MkpdTmg image
will go away if you leave off the last red down step in the outgoing
spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
haven't figured out what dmod.m_addend, dir.m_normal, and
dmod.m_normal are, so haven't gotten exactly how that earlier code
worked and don't know what you'd change to leave off half an angle.

My code in jLattice1.jl is obscure in places unless you speak Julia,
but here are the main ideas: At start of main, fetch n, scale,
linewidth, and corner fraction parameters unless defaulted. (See
README.rst) The Drawing(...) call starts a Luxor plot page, probably
like your cairo scene. Functions drawString(s) does all the U,D,L,R
moves listed in string s. Points p1 and p2 are next and current
corners. drawTwo(ss) draws two side-runs of square as noted in its
comments, drawing only half of the last right angle in last CCW side.
Back in main, there's a loop that calls drawTwo to draw sides with 2,
3, 4 ... n right angles per side going CCW, then green-to-blue change,
then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
angles per side going CW. Finally, optional display of parameter
values at top right of picture, and finish() to close out the plot and
write a .png file. How to run program is described in README.rst,
as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.

On Sunday, June 11, 2023 at 10:39:39 AM UTC-4, James Waldby wrote:
> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> ...
> >>>> The path in red is going out, the path in yellow is going back, the
> >>>> path in purple is the connector. The circles in cyan are end points
> >>>> during iteration:
> >>>>
> >>>> https://i.ibb.co/QYckQzC/image.png
> >>>> It ends up exactly where it started from.
> ...
> >>> https://i.ibb.co/ts6k4gK/image.png
> >>
> >> Here we go... I jest need to get rid of that damn connector! lol...
> >> https://i.ibb.co/8xfnksh/image.png
> ...
> > Here is a bigger grid:
> > https://i.ibb.co/MkpdTmg/image.png
> >
> > It should work fine for any size.
> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> where the green trace is going out and the blue trace coming in.
> Program jLattice1.jl is in Julia, linked at short link above or at
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
>
> The excess connector in purple at the bottom of your MkpdTmg image
> will go away if you leave off the last red down step in the outgoing
> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
> haven't figured out what dmod.m_addend, dir.m_normal, and
> dmod.m_normal are, so haven't gotten exactly how that earlier code
> worked and don't know what you'd change to leave off half an angle.
>
> My code in jLattice1.jl is obscure in places unless you speak Julia,
> but here are the main ideas: At start of main, fetch n, scale,
> linewidth, and corner fraction parameters unless defaulted. (See
> README.rst) The Drawing(...) call starts a Luxor plot page, probably
> like your cairo scene. Functions drawString(s) does all the U,D,L,R
> moves listed in string s. Points p1 and p2 are next and current
> corners. drawTwo(ss) draws two side-runs of square as noted in its
> comments, drawing only half of the last right angle in last CCW side.
> Back in main, there's a loop that calls drawTwo to draw sides with 2,
> 3, 4 ... n right angles per side going CCW, then green-to-blue change,
> then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
> angles per side going CW. Finally, optional display of parameter
> values at top right of picture, and finish() to close out the plot and
> write a .png file. How to run program is described in README.rst,
> as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.

You are right about the extra square on the start of the return path.
I recently corrected that. It makes for a cleaner look with no protruding
cells.
Your coding is way beyond me so please excuse my ignorance of a
simple question.
Do you use any sort of 2 different sequences (out going)(incoming) of
integers along with the D,U,L,R ?. Both have a pattern so constructing
them is easy.
My rendereing is only a certain background color and just white drawing
for out and in. I makes it very obvious what is happening in slow-mo.
Otherwise it all happens in a flash, even a very large lattice with very small
cells.
The two color idea is nice though.
Thanks,

Dan

On Sunday, June 11, 2023 at 11:14:10 AM UTC-4, Dan joyce wrote:
> On Sunday, June 11, 2023 at 10:39:39 AM UTC-4, James Waldby wrote:
> > Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> > > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> > >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> > >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> > ...
> > >>>> The path in red is going out, the path in yellow is going back, the
> > >>>> path in purple is the connector. The circles in cyan are end points
> > >>>> during iteration:
> > >>>>
> > >>>> https://i.ibb.co/QYckQzC/image.png
> > >>>> It ends up exactly where it started from.
> > ...
> > >>> https://i.ibb.co/ts6k4gK/image.png
> > >>
> > >> Here we go... I jest need to get rid of that damn connector! lol...
> > >> https://i.ibb.co/8xfnksh/image.png
> > ...
> > > Here is a bigger grid:
> > > https://i.ibb.co/MkpdTmg/image.png
> > >
> > > It should work fine for any size.
> > I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> > <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> > where the green trace is going out and the blue trace coming in.
> > Program jLattice1.jl is in Julia, linked at short link above or at
> > <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
> >
> > The excess connector in purple at the bottom of your MkpdTmg image
> > will go away if you leave off the last red down step in the outgoing
> > spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
> > haven't figured out what dmod.m_addend, dir.m_normal, and
> > dmod.m_normal are, so haven't gotten exactly how that earlier code
> > worked and don't know what you'd change to leave off half an angle.
> >
> > My code in jLattice1.jl is obscure in places unless you speak Julia,
> > but here are the main ideas: At start of main, fetch n, scale,
> > linewidth, and corner fraction parameters unless defaulted. (See
> > README.rst) The Drawing(...) call starts a Luxor plot page, probably
> > like your cairo scene. Functions drawString(s) does all the U,D,L,R
> > moves listed in string s. Points p1 and p2 are next and current
> > corners. drawTwo(ss) draws two side-runs of square as noted in its
> > comments, drawing only half of the last right angle in last CCW side.
> > Back in main, there's a loop that calls drawTwo to draw sides with 2,
> > 3, 4 ... n right angles per side going CCW, then green-to-blue change,
> > then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
> > angles per side going CW. Finally, optional display of parameter
> > values at top right of picture, and finish() to close out the plot and
> > write a .png file. How to run program is described in README.rst,
> > as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.
> You are right about the extra square on the start of the return path.
> I recently corrected that. It makes for a cleaner look with no protruding
> cells.
> Your coding is way beyond me so please excuse my ignorance of a
> simple question.
> Do you use any sort of 2 different sequences (out going)(incoming) of
> integers along with the D,U,L,R ?. Both have a pattern so constructing
> them is easy.
> My rendereing is only a certain background color and just white drawing
> for out and in. I makes it very obvious what is happening in slow-mo.
> Otherwise it all happens in a flash, even a very large lattice with very small
> cells.
> The two color idea is nice though.
> Thanks,
>
> Dan
Yours looks better than mine. Mine has an ofset of the 4 corners but yours
keeps it square for a better look. So I guess there are a lot of ways to construct
these lattices from a square to different rectangular shapes ---->oo.
My lattice is the first rectangle off the square.

On Sunday, June 11, 2023 at 10:39:39 AM UTC-4, James Waldby wrote:
> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> ...
> >>>> The path in red is going out, the path in yellow is going back, the
> >>>> path in purple is the connector. The circles in cyan are end points
> >>>> during iteration:
> >>>>
> >>>> https://i.ibb.co/QYckQzC/image.png
> >>>> It ends up exactly where it started from.
> ...
> >>> https://i.ibb.co/ts6k4gK/image.png
> >>
> >> Here we go... I jest need to get rid of that damn connector! lol...
> >> https://i.ibb.co/8xfnksh/image.png
> ...
> > Here is a bigger grid:
> > https://i.ibb.co/MkpdTmg/image.png
> >
> > It should work fine for any size.
> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> where the green trace is going out and the blue trace coming in.
> Program jLattice1.jl is in Julia, linked at short link above or at
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
>
> The excess connector in purple at the bottom of your MkpdTmg image
> will go away if you leave off the last red down step in the outgoing
> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
> haven't figured out what dmod.m_addend, dir.m_normal, and
> dmod.m_normal are, so haven't gotten exactly how that earlier code
> worked and don't know what you'd change to leave off half an angle.
>
> My code in jLattice1.jl is obscure in places unless you speak Julia,
> but here are the main ideas: At start of main, fetch n, scale,
> linewidth, and corner fraction parameters unless defaulted. (See
> README.rst) The Drawing(...) call starts a Luxor plot page, probably
> like your cairo scene. Functions drawString(s) does all the U,D,L,R
> moves listed in string s. Points p1 and p2 are next and current
> corners. drawTwo(ss) draws two side-runs of square as noted in its
> comments, drawing only half of the last right angle in last CCW side.
> Back in main, there's a loop that calls drawTwo to draw sides with 2,
> 3, 4 ... n right angles per side going CCW, then green-to-blue change,
> then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
> angles per side going CW. Finally, optional display of parameter
> values at top right of picture, and finish() to close out the plot and
> write a .png file. How to run program is described in README.rst,
> as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.

I will try your square lattice with my program done in pixels.

Dan joyce <danj4084@gmail.com> wrote:
> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>> > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
>> >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>> >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
>> ...
>> >>>> The path in red is going out, the path in yellow is going back, the
>> >>>> path in purple is the connector. The circles in cyan are end points
>> >>>> during iteration:
>> >>>>
>> >>>> https://i.ibb.co/QYckQzC/image.png
>> >>>> It ends up exactly where it started from.
>> ...
>> >>> https://i.ibb.co/ts6k4gK/image.png
>> >>
>> >> Here we go... I jest need to get rid of that damn connector! lol...
>> >> https://i.ibb.co/8xfnksh/image.png
>> ...
>> > Here is a bigger grid:
>> > https://i.ibb.co/MkpdTmg/image.png
>> >
>> > It should work fine for any size.
>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
>> where the green trace is going out and the blue trace coming in.
>> Program jLattice1.jl is in Julia, linked at short link above or at
>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
>>
>> The excess connector in purple at the bottom of your MkpdTmg image
>> will go away if you leave off the last red down step in the outgoing
>> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
>> haven't figured out what dmod.m_addend, dir.m_normal, and
>> dmod.m_normal are, so haven't gotten exactly how that earlier code
>> worked and don't know what you'd change to leave off half an angle.
>>
>> My code in jLattice1.jl is obscure in places unless you speak Julia,
>> but here are the main ideas: At start of main, fetch n, scale,
>> linewidth, and corner fraction parameters unless defaulted. (See
>> README.rst) The Drawing(...) call starts a Luxor plot page, probably
>> like your cairo scene. Function drawString(s) does all the U,D,L,R
>> moves listed in string s. Points p1 and p2 are next and current
>> corners. drawTwo(ss) draws two side-runs of square as noted in its
>> comments, drawing only half of the last right angle in last CCW side.
>> Back in main, there's a loop that calls drawTwo to draw sides with 2,
>> 3, 4 ... n right angles per side going CCW, then green-to-blue change,
>> then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
>> angles per side going CW. Finally, optional display of parameter
>> values at top right of picture, and finish() to close out the plot and
>> write a .png file. How to run program is described in README.rst,
>> as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.

> You are right about the extra square on the start of the return
> path. I recently corrected that. It makes for a cleaner look with
> no protruding cells.

> Your coding is way beyond me so please excuse my ignorance of a
> simple question. Do you use any sort of 2 different sequences (out
> going)(incoming) of integers along with the D,U,L,R ?. Both have a
> pattern so constructing them is easy.

Going out CCW (counterclockwise) my program uses 2 RU, 2 LU, 3 DL, 3
DR for first round, 4 RU, 4 LU, 5 DL, 5 DR for second round, etc up to
n and n-1/2 steps for the last two sides. The trace turns around at
the left-hand corner if n is even, or at the right-hand corner if n is
odd, then starts going CW for n-1, n-1, n-2, n-2, ... 1, 1 steps, with
k RU, k RD for even k, and k LD, k LU for odd k number of steps.

> My rendering is only a certain background color and just white
> drawing for out and in. I makes it very obvious what is happening in
> slow-mo. Otherwise it all happens in a flash, even a very large
> lattice with very small cells. The two color idea is nice though.

I think the corner cuts (where segment lines don't go clear out to the
lattice points) make the direction more clear also, with less visual
clutter than arrows produce. However, the corner cut fraction
produces curious results if it's outside [0, 0.5); see images #8 and
#9, which are annotated in top right corners with parameter values.

On Sunday, June 11, 2023 at 10:39:39 AM UTC-4, James Waldby wrote:
> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> ...
> >>>> The path in red is going out, the path in yellow is going back, the
> >>>> path in purple is the connector. The circles in cyan are end points
> >>>> during iteration:
> >>>>
> >>>> https://i.ibb.co/QYckQzC/image.png
> >>>> It ends up exactly where it started from.
> ...
> >>> https://i.ibb.co/ts6k4gK/image.png
> >>
> >> Here we go... I jest need to get rid of that damn connector! lol...
> >> https://i.ibb.co/8xfnksh/image.png
> ...
> > Here is a bigger grid:
> > https://i.ibb.co/MkpdTmg/image.png
> >
> > It should work fine for any size.
> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> where the green trace is going out and the blue trace coming in.
> Program jLattice1.jl is in Julia, linked at short link above or at
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
>
> The excess connector in purple at the bottom of your MkpdTmg image
> will go away if you leave off the last red down step in the outgoing
> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
> haven't figured out what dmod.m_addend, dir.m_normal, and
> dmod.m_normal are, so haven't gotten exactly how that earlier code
> worked and don't know what you'd change to leave off half an angle.
>
> My code in jLattice1.jl is obscure in places unless you speak Julia,
> but here are the main ideas: At start of main, fetch n, scale,
> linewidth, and corner fraction parameters unless defaulted. (See
> README.rst) The Drawing(...) call starts a Luxor plot page, probably
> like your cairo scene. Functions drawString(s) does all the U,D,L,R
> moves listed in string s. Points p1 and p2 are next and current
> corners. drawTwo(ss) draws two side-runs of square as noted in its
> comments, drawing only half of the last right angle in last CCW side.
> Back in main, there's a loop that calls drawTwo to draw sides with 2,
> 3, 4 ... n right angles per side going CCW, then green-to-blue change,
> then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
> angles per side going CW. Finally, optional display of parameter
> values at top right of picture, and finish() to close out the plot and
> write a .png file. How to run program is described in README.rst,
> as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.

James,
Aha!, I get it you had to create a full cell first then no more on its outward
path. My offset lattice does not create any cells at all until the return path
starts to fill back in to the origin.

Not significant but Interesting.

James Waldby <no@no.no> wrote:
> Dan joyce <danj4084@gmail.com> wrote:
>> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>> > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
>>> >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>>> >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
>>> ...
>>> >>>> The path in red is going out, the path in yellow is going back, the
>>> >>>> path in purple is the connector. The circles in cyan are end points
>>> >>>> during iteration:
>>> >>>>
>>> >>>> https://i.ibb.co/QYckQzC/image.png
>>> >>>> It ends up exactly where it started from.
>>> ...
>>> >>> https://i.ibb.co/ts6k4gK/image.png
>>> >>
>>> >> Here we go... I jest need to get rid of that damn connector! lol...
>>> >> https://i.ibb.co/8xfnksh/image.png
>>> ...
>>> > Here is a bigger grid:
>>> > https://i.ibb.co/MkpdTmg/image.png
>>> >
>>> > It should work fine for any size.
>>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
>>> where the green trace is going out and the blue trace coming in.
>>> Program jLattice1.jl is in Julia, linked at short link above or at
>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
>>>
>>> The excess connector in purple at the bottom of your MkpdTmg image
>>> will go away if you leave off the last red down step in the outgoing
>>> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
>>> haven't figured out what dmod.m_addend, dir.m_normal, and
>>> dmod.m_normal are, so haven't gotten exactly how that earlier code
>>> worked and don't know what you'd change to leave off half an angle.
>>>
>>> My code in jLattice1.jl is obscure in places unless you speak Julia,
>>> but here are the main ideas: At start of main, fetch n, scale,
>>> linewidth, and corner fraction parameters unless defaulted. (See
>>> README.rst) The Drawing(...) call starts a Luxor plot page, probably
>>> like your cairo scene. Function drawString(s) does all the U,D,L,R
>>> moves listed in string s. Points p1 and p2 are next and current
>>> corners. drawTwo(ss) draws two side-runs of square as noted in its
>>> comments, drawing only half of the last right angle in last CCW side.
>>> Back in main, there's a loop that calls drawTwo to draw sides with 2,
>>> 3, 4 ... n right angles per side going CCW, then green-to-blue change,
>>> then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
>>> angles per side going CW. Finally, optional display of parameter
>>> values at top right of picture, and finish() to close out the plot and
>>> write a .png file. How to run program is described in README.rst,
>>> as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.
>
>> You are right about the extra square on the start of the return
>> path. I recently corrected that. It makes for a cleaner look with
>> no protruding cells.
>
>> Your coding is way beyond me so please excuse my ignorance of a
>> simple question. Do you use any sort of 2 different sequences (out
>> going)(incoming) of integers along with the D,U,L,R ?. Both have a
>> pattern so constructing them is easy.
>
> Going out CCW (counterclockwise) my program uses 2 RU, 2 LU, 3 DL, 3
> DR for first round, 4 RU, 4 LU, 5 DL, 5 DR for second round, etc up to
> n and n-1/2 steps for the last two sides. The trace turns around at
> the left-hand corner if n is even, or at the right-hand corner if n is
> odd, then starts going CW for n-1, n-1, n-2, n-2, ... 1, 1 steps, with
> k RU, k RD for even k, and k LD, k LU for odd k number of steps.

Sorry, the first half of that paragraph is wrong. It should have said:

Going out CCW (counterclockwise) my program uses 2 DR, 2 UR, 3 UL, 3
DL for first round, 4 DR, 4 UR, 5 UL, 5 DL for second round, etc up to
n and n-1/2 steps for the last two sides. The trace turns around at
the left-hand corner if n is even, or at the right-hand corner if n is
odd, then starts going CW for n-1, n-1, n-2, n-2, ... 1, 1 steps, with
k RU, k RD for even k, and k LD, k LU for odd k number of steps.

>> My rendering is only a certain background color and just white
>> drawing for out and in. I makes it very obvious what is happening in
>> slow-mo. Otherwise it all happens in a flash, even a very large
>> lattice with very small cells. The two color idea is nice though.
>
> I think the corner cuts (where segment lines don't go clear out to the
> lattice points) make the direction more clear also, with less visual
> clutter than arrows produce. However, the corner cut fraction
> produces curious results if it's outside [0, 0.5); see images #8 and
> #9, which are annotated in top right corners with parameter values.

On Sunday, June 11, 2023 at 2:16:32 PM UTC-4, James Waldby wrote:
> James Waldby <n...@no.no> wrote:
> > Dan joyce <danj...@gmail.com> wrote:
> >> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
> >>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> >>> > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> >>> >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> >>> >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> >>> ...
> >>> >>>> The path in red is going out, the path in yellow is going back, the
> >>> >>>> path in purple is the connector. The circles in cyan are end points
> >>> >>>> during iteration:
> >>> >>>>
> >>> >>>> https://i.ibb.co/QYckQzC/image.png
> >>> >>>> It ends up exactly where it started from.
> >>> ...
> >>> >>> https://i.ibb.co/ts6k4gK/image.png
> >>> >>
> >>> >> Here we go... I jest need to get rid of that damn connector! lol....
> >>> >> https://i.ibb.co/8xfnksh/image.png
> >>> ...
> >>> > Here is a bigger grid:
> >>> > https://i.ibb.co/MkpdTmg/image.png
> >>> >
> >>> > It should work fine for any size.
> >>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> >>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> >>> where the green trace is going out and the blue trace coming in.
> >>> Program jLattice1.jl is in Julia, linked at short link above or at
> >>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
> >>>
> >>> The excess connector in purple at the bottom of your MkpdTmg image
> >>> will go away if you leave off the last red down step in the outgoing
> >>> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
> >>> haven't figured out what dmod.m_addend, dir.m_normal, and
> >>> dmod.m_normal are, so haven't gotten exactly how that earlier code
> >>> worked and don't know what you'd change to leave off half an angle.
> >>>
> >>> My code in jLattice1.jl is obscure in places unless you speak Julia,
> >>> but here are the main ideas: At start of main, fetch n, scale,
> >>> linewidth, and corner fraction parameters unless defaulted. (See
> >>> README.rst) The Drawing(...) call starts a Luxor plot page, probably
> >>> like your cairo scene. Function drawString(s) does all the U,D,L,R
> >>> moves listed in string s. Points p1 and p2 are next and current
> >>> corners. drawTwo(ss) draws two side-runs of square as noted in its
> >>> comments, drawing only half of the last right angle in last CCW side.
> >>> Back in main, there's a loop that calls drawTwo to draw sides with 2,
> >>> 3, 4 ... n right angles per side going CCW, then green-to-blue change,
> >>> then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
> >>> angles per side going CW. Finally, optional display of parameter
> >>> values at top right of picture, and finish() to close out the plot and
> >>> write a .png file. How to run program is described in README.rst,
> >>> as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.
> >
> >> You are right about the extra square on the start of the return
> >> path. I recently corrected that. It makes for a cleaner look with
> >> no protruding cells.
> >
> >> Your coding is way beyond me so please excuse my ignorance of a
> >> simple question. Do you use any sort of 2 different sequences (out
> >> going)(incoming) of integers along with the D,U,L,R ?. Both have a
> >> pattern so constructing them is easy.
> >
> > Going out CCW (counterclockwise) my program uses 2 RU, 2 LU, 3 DL, 3
> > DR for first round, 4 RU, 4 LU, 5 DL, 5 DR for second round, etc up to
> > n and n-1/2 steps for the last two sides. The trace turns around at
> > the left-hand corner if n is even, or at the right-hand corner if n is
> > odd, then starts going CW for n-1, n-1, n-2, n-2, ... 1, 1 steps, with
> > k RU, k RD for even k, and k LD, k LU for odd k number of steps.
> Sorry, the first half of that paragraph is wrong. It should have said:
>
> Going out CCW (counterclockwise) my program uses 2 DR, 2 UR, 3 UL, 3
> DL for first round, 4 DR, 4 UR, 5 UL, 5 DL for second round, etc up to
> n and n-1/2 steps for the last two sides. The trace turns around at
> the left-hand corner if n is even, or at the right-hand corner if n is
> odd, then starts going CW for n-1, n-1, n-2, n-2, ... 1, 1 steps, with
> k RU, k RD for even k, and k LD, k LU for odd k number of steps.
>
> >> My rendering is only a certain background color and just white
> >> drawing for out and in. I makes it very obvious what is happening in
> >> slow-mo. Otherwise it all happens in a flash, even a very large
> >> lattice with very small cells. The two color idea is nice though.
> >
> > I think the corner cuts (where segment lines don't go clear out to the
> > lattice points) make the direction more clear also, with less visual
> > clutter than arrows produce. However, the corner cut fraction
> > produces curious results if it's outside [0, 0.5); see images #8 and
> > #9, which are annotated in top right corners with parameter values.

Replying to the top of this feed I get from your rerndering ----
1 RU
2 LD---- that creates the first center cell on the first pass and no more until the return path starts to fill.
1 RD
3 RU
3 LU
Right?

On Sunday, June 11, 2023 at 2:32:48 PM UTC-4, Dan joyce wrote:
> On Sunday, June 11, 2023 at 2:16:32 PM UTC-4, James Waldby wrote:
> > James Waldby <n...@no.no> wrote:
> > > Dan joyce <danj...@gmail.com> wrote:
> > >> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
> > >>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> > >>> > On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> > >>> >> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> > >>> >>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> > >>> ...
> > >>> >>>> The path in red is going out, the path in yellow is going back, the
> > >>> >>>> path in purple is the connector. The circles in cyan are end points
> > >>> >>>> during iteration:
> > >>> >>>>
> > >>> >>>> https://i.ibb.co/QYckQzC/image.png
> > >>> >>>> It ends up exactly where it started from.
> > >>> ...
> > >>> >>> https://i.ibb.co/ts6k4gK/image.png
> > >>> >>
> > >>> >> Here we go... I jest need to get rid of that damn connector! lol....
> > >>> >> https://i.ibb.co/8xfnksh/image.png
> > >>> ...
> > >>> > Here is a bigger grid:
> > >>> > https://i.ibb.co/MkpdTmg/image.png
> > >>> >
> > >>> > It should work fine for any size.
> > >>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> > >>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> > >>> where the green trace is going out and the blue trace coming in.
> > >>> Program jLattice1.jl is in Julia, linked at short link above or at
> > >>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
> > >>>
> > >>> The excess connector in purple at the bottom of your MkpdTmg image
> > >>> will go away if you leave off the last red down step in the outgoing
> > >>> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
> > >>> haven't figured out what dmod.m_addend, dir.m_normal, and
> > >>> dmod.m_normal are, so haven't gotten exactly how that earlier code
> > >>> worked and don't know what you'd change to leave off half an angle.
> > >>>
> > >>> My code in jLattice1.jl is obscure in places unless you speak Julia,
> > >>> but here are the main ideas: At start of main, fetch n, scale,
> > >>> linewidth, and corner fraction parameters unless defaulted. (See
> > >>> README.rst) The Drawing(...) call starts a Luxor plot page, probably
> > >>> like your cairo scene. Function drawString(s) does all the U,D,L,R
> > >>> moves listed in string s. Points p1 and p2 are next and current
> > >>> corners. drawTwo(ss) draws two side-runs of square as noted in its
> > >>> comments, drawing only half of the last right angle in last CCW side.
> > >>> Back in main, there's a loop that calls drawTwo to draw sides with 2,
> > >>> 3, 4 ... n right angles per side going CCW, then green-to-blue change,
> > >>> then a loop to call drawTwo for sides with n-1, n-2, ... 1 right
> > >>> angles per side going CW. Finally, optional display of parameter
> > >>> values at top right of picture, and finish() to close out the plot and
> > >>> write a .png file. How to run program is described in README.rst,
> > >>> as seen by scroll-down at <https://gitlab.com/ghjwp7/mxnSquares>.
> > >
> > >> You are right about the extra square on the start of the return
> > >> path. I recently corrected that. It makes for a cleaner look with
> > >> no protruding cells.
> > >
> > >> Your coding is way beyond me so please excuse my ignorance of a
> > >> simple question. Do you use any sort of 2 different sequences (out
> > >> going)(incoming) of integers along with the D,U,L,R ?. Both have a
> > >> pattern so constructing them is easy.
> > >
> > > Going out CCW (counterclockwise) my program uses 2 RU, 2 LU, 3 DL, 3
> > > DR for first round, 4 RU, 4 LU, 5 DL, 5 DR for second round, etc up to
> > > n and n-1/2 steps for the last two sides. The trace turns around at
> > > the left-hand corner if n is even, or at the right-hand corner if n is
> > > odd, then starts going CW for n-1, n-1, n-2, n-2, ... 1, 1 steps, with
> > > k RU, k RD for even k, and k LD, k LU for odd k number of steps.
> > Sorry, the first half of that paragraph is wrong. It should have said:
> >
> > Going out CCW (counterclockwise) my program uses 2 DR, 2 UR, 3 UL, 3
> > DL for first round, 4 DR, 4 UR, 5 UL, 5 DL for second round, etc up to
> > n and n-1/2 steps for the last two sides. The trace turns around at
> > the left-hand corner if n is even, or at the right-hand corner if n is
> > odd, then starts going CW for n-1, n-1, n-2, n-2, ... 1, 1 steps, with
> > k RU, k RD for even k, and k LD, k LU for odd k number of steps.
> >
> > >> My rendering is only a certain background color and just white
> > >> drawing for out and in. I makes it very obvious what is happening in
> > >> slow-mo. Otherwise it all happens in a flash, even a very large
> > >> lattice with very small cells. The two color idea is nice though.
> > >
> > > I think the corner cuts (where segment lines don't go clear out to the
> > > lattice points) make the direction more clear also, with less visual
> > > clutter than arrows produce. However, the corner cut fraction
> > > produces curious results if it's outside [0, 0.5); see images #8 and
> > > #9, which are annotated in top right corners with parameter values.
> Replying to the top of this feed I get from your rerndering ----
> 1 RU
> 2 LD---- that creates the first center cell on the first pass and no more until the return path starts to fill.
> 1 RD
> 3 RU
> 3 LU
> Right?
So that is kind of neat. You have to create a completed center cell before you can complete
the cells in the return path. Unlike mine the final result is a square lattice and not a rectangular
lattice like mine. I see the pattern in both of your sequences. Also, naturally different than mine.

On 6/11/2023 11:16 AM, James Waldby wrote:
> James Waldby <no@no.no> wrote:
>> Dan joyce <danj4084@gmail.com> wrote:
>>> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
>>>>>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>>>>>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
>>>> ...
>>>>>>>> The path in red is going out, the path in yellow is going back, the
>>>>>>>> path in purple is the connector. The circles in cyan are end points
>>>>>>>> during iteration:
>>>>>>>>
>>>>>>>> https://i.ibb.co/QYckQzC/image.png
>>>>>>>> It ends up exactly where it started from.
>>>> ...
>>>>>>> https://i.ibb.co/ts6k4gK/image.png
>>>>>>
>>>>>> Here we go... I jest need to get rid of that damn connector! lol...
>>>>>> https://i.ibb.co/8xfnksh/image.png
>>>> ...
>>>>> Here is a bigger grid:
>>>>> https://i.ibb.co/MkpdTmg/image.png
>>>>>
>>>>> It should work fine for any size.
>>>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
>>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
>>>> where the green trace is going out and the blue trace coming in.
>>>> Program jLattice1.jl is in Julia, linked at short link above or at
>>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
[...]

Nice work James! :^)

Your code is clean an easy to read.

On 6/11/2023 7:12 AM, Dan joyce wrote:
> On Sunday, June 11, 2023 at 4:54:31 AM UTC-4, Chris M. Thomasson wrote:
>> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
>>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
>>>>> On 6/10/2023 5:37 PM, Chris M. Thomasson wrote:
>>>>>> This is a bug, but it looks interesting! ;^)
>>>>>>
>>>>>> https://i.ibb.co/8N5rmWJ/image.png
>>>>>
>>>>> The path in red is going out, the path in yellow is going back, the
>>>>> path in purple is the connector. The circles in cyan are end points
>>>>> during iteration:
>>>>>
>>>>> https://i.ibb.co/QYckQzC/image.png
>>>>>
>>>>> It ends up exactly where it started from.
>>>>>
>>>>> Look okay?
>>>>
>>>> Looking better! ;^)
>>>>
>>>> https://i.ibb.co/ts6k4gK/image.png
>>>
>>> Here we go... I jest need to get rid of that damn connector! lol...
>>>
>>> https://i.ibb.co/8xfnksh/image.png
>>>
>>> ;^D
>> Tired now, going to bed. But, it looks like everything is going to work
>> out. I just need to polish up my algorithm sometime tomorrow. Good
>> night. ;^)
>>
>> Here is a bigger grid:
>>
>> https://i.ibb.co/MkpdTmg/image.png
>>
>> It should work fine for any size.
> I got screwed up looking at this because you are returning from the bottom, dosen't matter, and I returned at the
> top, Then when I followed it back I get lost in the begining. What are the two blue lines?
> Thanks
> Other than that, it looks good.

Does this look a little less noisy?

https://www.facebook.com/photo/?fbid=982318362927162

Sorry for the FB post, but can you see the resulting image?

Fwiw, here is what I wrote about it:
_____________________________________________
For a friend of mine. Fwiw, it is his original idea. The path in red
goes out, the path in yellow goes back in. It ends up exactly where it
started. The red circle is the origin point emitting red lines. The
yellow circle is the origin point for its way back "home" that emits
yellow lines. I plotted some arrows on said lines to give a sense of
direction... Does it clutter it up too much? The smaller purple circle
is where the way back home, the yellow lines, ends up. It ends up
exactly where it started wrt the red circle. Nice! :^)

The point is that the pen never leaves the paper without revisiting and
overdrawing any existing line...
_____________________________________________

Is that okay? Any thoughts?

On Sunday, June 11, 2023 at 3:34:12 PM UTC-4, Chris M. Thomasson wrote:
> On 6/11/2023 11:16 AM, James Waldby wrote:
> > James Waldby <n...@no.no> wrote:
> >> Dan joyce <danj...@gmail.com> wrote:
> >>> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
> >>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> >>>>> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> >>>>>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> >>>>>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> >>>> ...
> >>>>>>>> The path in red is going out, the path in yellow is going back, the
> >>>>>>>> path in purple is the connector. The circles in cyan are end points
> >>>>>>>> during iteration:
> >>>>>>>>
> >>>>>>>> https://i.ibb.co/QYckQzC/image.png
> >>>>>>>> It ends up exactly where it started from.
> >>>> ...
> >>>>>>> https://i.ibb.co/ts6k4gK/image.png
> >>>>>>
> >>>>>> Here we go... I jest need to get rid of that damn connector! lol....
> >>>>>> https://i.ibb.co/8xfnksh/image.png
> >>>> ...
> >>>>> Here is a bigger grid:
> >>>>> https://i.ibb.co/MkpdTmg/image.png
> >>>>>
> >>>>> It should work fine for any size.
> >>>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> >>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> >>>> where the green trace is going out and the blue trace coming in.
> >>>> Program jLattice1.jl is in Julia, linked at short link above or at
> >>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
> [...]
>
> Nice work James! :^)
>
> Your code is clean an easy to read.
Not like mine.;=)

He gets the true square lattice by first making the first completed cell (center cell) and then goes out
to the limit of his lattice filling in the return path with cells. Different from mine where I don't
make any completed cells until I start down the return path. This will be true for all different rectangular
lattice.

On Sunday, June 11, 2023 at 4:37:07 PM UTC-4, Dan joyce wrote:
> On Sunday, June 11, 2023 at 3:34:12 PM UTC-4, Chris M. Thomasson wrote:
> > On 6/11/2023 11:16 AM, James Waldby wrote:
> > > James Waldby <n...@no.no> wrote:
> > >> Dan joyce <danj...@gmail.com> wrote:
> > >>> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
> > >>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> > >>>>> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> > >>>>>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> > >>>>>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> > >>>> ...
> > >>>>>>>> The path in red is going out, the path in yellow is going back, the
> > >>>>>>>> path in purple is the connector. The circles in cyan are end points
> > >>>>>>>> during iteration:
> > >>>>>>>>
> > >>>>>>>> https://i.ibb.co/QYckQzC/image.png
> > >>>>>>>> It ends up exactly where it started from.
> > >>>> ...
> > >>>>>>> https://i.ibb.co/ts6k4gK/image.png
> > >>>>>>
> > >>>>>> Here we go... I jest need to get rid of that damn connector! lol....
> > >>>>>> https://i.ibb.co/8xfnksh/image.png
> > >>>> ...
> > >>>>> Here is a bigger grid:
> > >>>>> https://i.ibb.co/MkpdTmg/image.png
> > >>>>>
> > >>>>> It should work fine for any size.
> > >>>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> > >>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> > >>>> where the green trace is going out and the blue trace coming in.
> > >>>> Program jLattice1.jl is in Julia, linked at short link above or at
> > >>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
> > [...]
> >
> > Nice work James! :^)
> >
> > Your code is clean an easy to read.
> Not like mine.;=)
>
> He gets the true square lattice by first making the first completed cell (center cell) and then goes out
> to the limit of his lattice filling in the return path with cells. Different from mine where I don't
> make any completed cells until I start down the return path. This will be true for all different rectangular
> lattice.

Can we get a little movement in slow-mo guys. It really adds to the presentation..
It's easy to do with pixels, I don' t know about your methods but I am sure it can be done.
This will enhance the two different colors going out and then going back in..
You or James will come up with something.
I'm talking about really slowing it down. I ran one without slowing it down and in 30 rotations
going out and then about 29 1/2 rotations coming back in it just flashed a finished lattice.
From nothing to a finished lattice in a split second..
So the full visual effect of this is in slow-mo.
Besides, who could draw that fast. ;=)

Thanks Guys for all your input.
Its been a blast.

I'm just and old fart having fun trying to keep my brain exercised.
Dan
And now they want to kill all the cows in Ireland to save the environment. WHAT!
You have got to be kidding me.

On Sunday, June 11, 2023 at 5:11:24 PM UTC-4, Dan joyce wrote:
> On Sunday, June 11, 2023 at 4:37:07 PM UTC-4, Dan joyce wrote:
> > On Sunday, June 11, 2023 at 3:34:12 PM UTC-4, Chris M. Thomasson wrote:
> > > On 6/11/2023 11:16 AM, James Waldby wrote:
> > > > James Waldby <n...@no.no> wrote:
> > > >> Dan joyce <danj...@gmail.com> wrote:
> > > >>> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
> > > >>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
> > > >>>>> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
> > > >>>>>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
> > > >>>>>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> > > >>>> ...
> > > >>>>>>>> The path in red is going out, the path in yellow is going back, the
> > > >>>>>>>> path in purple is the connector. The circles in cyan are end points
> > > >>>>>>>> during iteration:
> > > >>>>>>>>
> > > >>>>>>>> https://i.ibb.co/QYckQzC/image.png
> > > >>>>>>>> It ends up exactly where it started from.
> > > >>>> ...
> > > >>>>>>> https://i.ibb.co/ts6k4gK/image.png
> > > >>>>>>
> > > >>>>>> Here we go... I jest need to get rid of that damn connector! lol...
> > > >>>>>> https://i.ibb.co/8xfnksh/image.png
> > > >>>> ...
> > > >>>>> Here is a bigger grid:
> > > >>>>> https://i.ibb.co/MkpdTmg/image.png
> > > >>>>>
> > > >>>>> It should work fine for any size.
> > > >>>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> > > >>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> > > >>>> where the green trace is going out and the blue trace coming in.
> > > >>>> Program jLattice1.jl is in Julia, linked at short link above or at
> > > >>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
> > > [...]
> > >
> > > Nice work James! :^)
> > >
> > > Your code is clean an easy to read.
> > Not like mine.;=)
> >
> > He gets the true square lattice by first making the first completed cell (center cell) and then goes out
> > to the limit of his lattice filling in the return path with cells. Different from mine where I don't
> > make any completed cells until I start down the return path. This will be true for all different rectangular
> > lattice.
> Can we get a little movement in slow-mo guys. It really adds to the presentation..
> It's easy to do with pixels, I don' t know about your methods but I am sure it can be done.
> This will enhance the two different colors going out and then going back in.
> You or James will come up with something.
> I'm talking about really slowing it down. I ran one without slowing it down and in 30 rotations
> going out and then about 29 1/2 rotations coming back in it just flashed a finished lattice.
> From nothing to a finished lattice in a split second..
> So the full visual effect of this is in slow-mo.
> Besides, who could draw that fast. ;=)
>
> Thanks Guys for all your input.
> Its been a blast.
>
> I'm just and old fart having fun trying to keep my brain exercised.
> Dan
> And now they want to kill all the cows in Ireland to save the environment.. WHAT!
> You have got to be kidding me.
I should say, to save the planet.

On 6/11/2023 2:11 PM, Dan joyce wrote:
> On Sunday, June 11, 2023 at 4:37:07 PM UTC-4, Dan joyce wrote:
>> On Sunday, June 11, 2023 at 3:34:12 PM UTC-4, Chris M. Thomasson wrote:
>>> On 6/11/2023 11:16 AM, James Waldby wrote:
>>>> James Waldby <n...@no.no> wrote:
>>>>> Dan joyce <danj...@gmail.com> wrote:
>>>>>> On Sunday, June 11, 2023 at 10:39:39???AM UTC-4, James Waldby wrote:
>>>>>>> Chris M. Thomasson <chris.m.t...@gmail.com> wrote:
>>>>>>>> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
>>>>>>>>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>>>>>>>>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
>>>>>>> ...
>>>>>>>>>>> The path in red is going out, the path in yellow is going back, the
>>>>>>>>>>> path in purple is the connector. The circles in cyan are end points
>>>>>>>>>>> during iteration:
>>>>>>>>>>>
>>>>>>>>>>> https://i.ibb.co/QYckQzC/image.png
>>>>>>>>>>> It ends up exactly where it started from.
>>>>>>> ...
>>>>>>>>>> https://i.ibb.co/ts6k4gK/image.png
>>>>>>>>>
>>>>>>>>> Here we go... I jest need to get rid of that damn connector! lol...
>>>>>>>>> https://i.ibb.co/8xfnksh/image.png
>>>>>>> ...
>>>>>>>> Here is a bigger grid:
>>>>>>>> https://i.ibb.co/MkpdTmg/image.png
>>>>>>>>
>>>>>>>> It should work fine for any size.
>>>>>>> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
>>>>>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
>>>>>>> where the green trace is going out and the blue trace coming in.
>>>>>>> Program jLattice1.jl is in Julia, linked at short link above or at
>>>>>>> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
>>> [...]
>>>
>>> Nice work James! :^)
>>>
>>> Your code is clean an easy to read.
>> Not like mine.;=)
>>
>> He gets the true square lattice by first making the first completed cell (center cell) and then goes out
>> to the limit of his lattice filling in the return path with cells. Different from mine where I don't
>> make any completed cells until I start down the return path. This will be true for all different rectangular
>> lattice.
>
> Can we get a little movement in slow-mo guys. It really adds to the presentation..
> It's easy to do with pixels, I don' t know about your methods but I am sure it can be done.
> This will enhance the two different colors going out and then going back in.
> You or James will come up with something.
> I'm talking about really slowing it down. I ran one without slowing it down and in 30 rotations
> going out and then about 29 1/2 rotations coming back in it just flashed a finished lattice.
> From nothing to a finished lattice in a split second..
> So the full visual effect of this is in slow-mo.
> Besides, who could draw that fast. ;=)
>
> Thanks Guys for all your input.
> Its been a blast.
>
> I'm just and old fart having fun trying to keep my brain exercised.
> Dan
> And now they want to kill all the cows in Ireland to save the environment. WHAT!
> You have got to be kidding me.

I can create an animation where the arrow lines grow within a time
frame. Say 24 frames is one second and it takes 24 frames for a line to
grow from origin to destination. In my system red lines, the way out,
would build one second per line growth, then the way back in the yellow
lines, would fill itself in one second per line growth?

Sound okay?

On 6/11/2023 7:39 AM, James Waldby wrote:
> Chris M. Thomasson <chris.m.thomasson.1@gmail.com> wrote:
>> On 6/11/2023 1:40 AM, Chris M. Thomasson wrote:
>>> On 6/11/2023 1:11 AM, Chris M. Thomasson wrote:
>>>> On 6/11/2023 1:04 AM, Chris M. Thomasson wrote:
> ...
>>>>> The path in red is going out, the path in yellow is going back, the
>>>>> path in purple is the connector. The circles in cyan are end points
>>>>> during iteration:
>>>>>
>>>>> https://i.ibb.co/QYckQzC/image.png
>>>>> It ends up exactly where it started from.
> ...
>>>> https://i.ibb.co/ts6k4gK/image.png
>>>
>>> Here we go... I jest need to get rid of that damn connector! lol...
>>> https://i.ibb.co/8xfnksh/image.png
> ...
>> Here is a bigger grid:
>> https://i.ibb.co/MkpdTmg/image.png
>>
>> It should work fine for any size.
>
> I have examples and code at <https://gitlab.com/ghjwp7/mxnSquares> eg
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/image-07.png>
> where the green trace is going out and the blue trace coming in.
> Program jLattice1.jl is in Julia, linked at short link above or at
> <https://gitlab.com/ghjwp7/mxnSquares/-/blob/master/jLattice1.jl>
>
> The excess connector in purple at the bottom of your MkpdTmg image
> will go away if you leave off the last red down step in the outgoing
> spiral. In the code you posted Wed, 7 Jun 2023 23:12:31 -0700, I
> haven't figured out what dmod.m_addend, dir.m_normal, and
> dmod.m_normal are, so haven't gotten exactly how that earlier code
> worked and don't know what you'd change to leave off half an angle.
[...]

Nice. Fwiw, here is a render of my test version with a damn connector at
the end of the way out in red. The way back is in yellow, the red circle
casts the red lines, the yellow circle casts the yellow lines. The small
purple circle is where the yellow path ends up. Right back where the red
path started from. My code is crude, but seems to work. I have not had a
lot of time to work on it, ;^o.

https://i.ibb.co/2MLPFRZ/image.png

___________________________________
glm::vec2
ct_ladder(
ct::plot::cairo::plot_2d& scene,
glm::vec2 current,
float unit,
glm::vec2 normal_0,
glm::vec2 normal_1,
unsigned long n,
ct::plot::cairo::pixel const& color
) {
glm::vec2 next = { 0, 0 };

for (unsigned long i = 0; i < n; ++i)
{
next = current + normal_0 * unit;
plot_arrow_line(scene, current, next, color, 3);
current = next;

next = current + normal_1 * unit;
plot_arrow_line(scene, current, next, color, 3);
current = next;
}

return next;
}

float
ct_test_algo_for_dj_v1(
ct::plot::cairo::plot_2d& scene,
float unit,
bool plot,
unsigned long yn
) {
float max_dis = 0;

glm::vec2 origin = { 0, 0 };
glm::vec2 current = origin;

unsigned long n = 2;
unsigned long origin_n = n;

scene.circle(current, unit, CT_RGBF(1, 0, 0), 2);

// going out...
{
for (unsigned long i = 0; i < yn; ++i)
{
current = ct_ladder(scene, current, unit, { 1, 0 }, { 0, 1
}, n, CT_RGBF(1, 0, 0));
current = ct_ladder(scene, current, unit, { -1, 0 }, { 0, 1
}, n - 1, CT_RGBF(1, 0, 0));
current = ct_ladder(scene, current, unit, { -1, 0 }, { 0,
-1 }, n + 1, CT_RGBF(1, 0, 0));
current = ct_ladder(scene, current, unit, { 1, 0 }, { 0, -1
}, n, CT_RGBF(1, 0, 0));
n = origin_n + ((i + 1) * 2);
}

scene.circle(current, unit, CT_RGBF(1, 1, 0), 2);
}

// way home connector... ;^)
{
glm::vec2 next = current + glm::vec2(1, 0) * unit;
plot_arrow_line(scene, current, next, CT_RGBF(1, 1, 0), 3);
current = next;
next = current + glm::vec2(0, 1) * unit;
plot_arrow_line(scene, current, next, CT_RGBF(1, 1, 0), 3);
current = next;
}

// going in...
{
for (unsigned long i = 0; i < yn - 1; ++i)
{
current = ct_ladder(scene, current, unit, { -1, 0 }, { 0, 1
}, n - origin_n, CT_RGBF(1, 1, 0));
current = ct_ladder(scene, current, unit, { 1, 0 }, { 0, 1
}, n - origin_n - 1, CT_RGBF(1, 1, 0));
current = ct_ladder(scene, current, unit, { 1, 0 }, { 0, -1
}, n - origin_n - 1, CT_RGBF(1, 1, 0));
current = ct_ladder(scene, current, unit, { -1, 0 }, { 0,
-1 }, n - origin_n - 2, CT_RGBF(1, 1, 0));
n = n - 2;
}

// final connector...
current = ct_ladder(scene, current, unit, { -1, 0 }, { 0, 1 },
n - origin_n, CT_RGBF(1, 1, 0));
current = ct_ladder(scene, current, unit, { 1, 0 }, { 0, 1 }, n
- origin_n - 1, CT_RGBF(1, 1, 0));
current = ct_ladder(scene, current, unit, { 1, 0 }, { 0, -1 },
n - origin_n - 1, CT_RGBF(1, 1, 0));
current = ct_ladder(scene, current, unit, { -1, 0 }, { 0, -1 },
n - origin_n - 1, CT_RGBF(1, 1, 0));

scene.circle(current, unit / 2, CT_RGBF(1, 0, 1), 2);
}

return max_dis;
} ___________________________________

;^)