Drawing helical wires via two different approaches

[zenineasa]

Dear Leap 71 team,

I have been trying out PicoGK for the last couple of days, and, I think I am starting to love it. Thank you for making it available for all.

I attempted to draw helical wires via two different approaches; first by using multiple 'AddBeam' method in a loop, and, second by using the shape kernel. I observed that the former appears to be giving a visually accurate result, while the latter appears to have some tapered regions that is not quite right. Could you help me understand why that is and what I could do to ameliorate?

Also, could you please let me know which of the two approaches you would approve of, and the reason for it?

Looking forward to hearing from you.

Regards,
Zenin Easa Panthakkalakath

--

The code and results are shown below:

try
{
    PicoGK.Library.Go(.01f, OurClass.Run1);
    //PicoGK.Library.Go(.01f, OurClass.Run2);
}

catch (Exception e)
{
    Console.WriteLine(e.ToString());
}

class OurClass
{
    public static void Run1()
    {
        // Helical wire with circular cross section - version 1

        float pipeRadius = 0.25f;
        float helixRadius = 5f;
        float helixHeight = 10f;
        float helixPitch = 0.5f; // number of turns per unit length

        int numSegmentsPerPitch = 100;
        int numPitches = (int)(helixHeight / helixPitch);

        List<System.Numerics.Vector3> helicalPath = [];
        for (int i = 0; i < numPitches; ++i)
        {
            for (int j = 0; j < numSegmentsPerPitch; ++j)
            {
                double theta = j * (2 * Math.PI) / numSegmentsPerPitch;
                helicalPath.Add(new(
                    helixRadius * (float)Math.Sin(theta),
                    helixRadius * (float)Math.Cos(theta),
                    i * helixPitch + (float)(theta / (2 * Math.PI) * helixPitch)
                ));
            }
        }

        PicoGK.Lattice lat = new();

        for (int i = 1; i < helicalPath.Count; ++i)
        {
            bool rounded = !(i == 1 || i == helicalPath.Count - 1);
            lat.AddBeam(
                helicalPath[i], helicalPath[i - 1],
                pipeRadius, pipeRadius,
                rounded
            );
        }

        // Create the voxels        
        PicoGK.Voxels voxLat = new(lat);

        // Visualize in the viewer
        PicoGK.Library.oViewer().Add(voxLat);
    }
    public static void Run2()
    {
        // Helical wire with circular cross section - version 2

        float pipeRadius = 0.25f;
        float helixRadius = 5f;
        float helixHeight = 10f;
        float helixPitch = 0.5f; // number of turns per unit length

        int numSegmentsPerPitch = 100;
        int numPitches = (int)(helixHeight / helixPitch);

        List<System.Numerics.Vector3> helicalPath = [];
        for (int i = 0; i < numPitches; ++i)
        {
            for (int j = 0; j < numSegmentsPerPitch; ++j)
            {
                double theta = j * (2 * Math.PI) / numSegmentsPerPitch;
                helicalPath.Add(new(
                    helixRadius * (float)Math.Sin(theta),
                    helixRadius * (float)Math.Cos(theta),
                    i * helixPitch + (float)(theta / (2 * Math.PI) * helixPitch)
                ));
            }
        }

        float fInnerRadius(float iPhi, float iLengthRatio)
        {
            return 0f;
        }
        float fOuterRadius(float iPhi, float iLengthRatio)
        {
            return pipeRadius;
        }

        Leap71.ShapeKernel.Frames aFrames = new Leap71.ShapeKernel.Frames(
            helicalPath, System.Numerics.Vector3.UnitY
        );
        Leap71.ShapeKernel.BasePipe oShape = new Leap71.ShapeKernel.BasePipe(aFrames);
        oShape.SetRadius(
            new Leap71.ShapeKernel.SurfaceModulation(fInnerRadius),
            new Leap71.ShapeKernel.SurfaceModulation(fOuterRadius)
        );
        PicoGK.Voxels oVoxels = oShape.voxConstruct();

        // Visualize in the viewer
        PicoGK.Library.oViewer().Add(oVoxels);
    }
}

Run 1 results in:

Run 2 results in:

[zenineasa]

Update:

It is now observed that when I change the frame to use UnitZ direction instead, the tapering goes away. That is,

changing the following:

        Leap71.ShapeKernel.Frames aFrames = new Leap71.ShapeKernel.Frames(
            helicalPath, System.Numerics.Vector3.UnitY
        );

to the following:

        Leap71.ShapeKernel.Frames aFrames = new Leap71.ShapeKernel.Frames(
            helicalPath, System.Numerics.Vector3.UnitZ
        );

results in:

which is what is desired.

Could you help me understand why this fixes the issue? Is this expected?

Regards,
Zenin