Mirroring and surface extraction

[eflehder1]

Hi Josefine,

What is the best way to mirror a set of voxel geometries about a defined plane? This is the assembly for reference:

Moreover, I want to create some attachment hooks that blend into the curved surfaces of these wedges, my approach would be to first extract the surface of the wedge, create a lattice pipe with the shapekernel, make the local frame perpendicular to the surface and then find a way to blend the lattice pipe into the wedge surface, is there a way to achive this or would you recommend a different workflow?

Many thanks,
Eric

[josefinelissner]

Hi, @eflehder1 !

To answer your first question on how you can essentially apply a transformation to an existing voxel geometry - I would suggest the following steps:

• convert voxels to a mesh
• apply a vertex-wise transformation function to obtain a transformed mesh
• convert transformed mesh back into voxels

I uploaded Examples/Ex_MeshTrafoShowCase.cs to the ShapeKernel library which gives you a minimum example of how to do it. There is one transformation for mirroring and one for rotating. You can use the same workflow to come up with more elaborate transformations.

Use this function to apply your transformation to each vertex of the input mesh:
Mesh mshTrafoBox = MeshUtility.mshApplyTransformation(mshBox, fnMirror);

And here is an example of how the transformation function can look like. It needs to following the format Vector3 func(Vector3).

[eflehder1]

Thank you very much @josefinelissner!

[eflehder1]

Hi @josefinelissner I made a small addition to this logic in order to mirror a voxel part about a particular axis and thought I would share it here. To define the input I am using a member variable, it is not possible to add more input variables to the TrafoFunc function itself right?

        public Voxels MirrorPart(Voxels Part1)
        {
            Mesh meshPart1            = new(Part1);
            Mesh meshPart2            = MeshUtility.mshApplyTransformation(meshPart1, FnMirror2);
            Voxels voxPart2          = new(meshPart2);
            return voxPart2;
        }
        public Vector3 FnMirror2(Vector3 vecPt)
        {
            float fX            = vecPt.X;
            float fY            = vecPt.Y;
            float fZ            = vecPt.Z;
            float fMirrorPlane = 0;
            int intAxX = mMirrorAx.CompareTo("x");
            int intAxY = mMirrorAx.CompareTo("y");
            int intAxZ = mMirrorAx.CompareTo("z");

            float fNew;
            Vector3 vecNewPt;
            if (intAxX == 1)
            {
                fNew         = fMirrorPlane - (fY - fMirrorPlane);
                vecNewPt    = new Vector3(fX, fNew, fZ);
            }
            else if (intAxY == 1)
            {
                fNew         = fMirrorPlane - (fX - fMirrorPlane);
                vecNewPt    = new Vector3(fNew, fY, fZ);
            }
            else
            {
                fNew         = fMirrorPlane - (fZ - fMirrorPlane);
                vecNewPt    = new Vector3(fX, fZ, fNew);
            }
            return vecNewPt;
        }

I then also used the rotate function you provided in order to mirror my part as desired. However, I noticed that the mesh seems to have changed a little with the transformations, would this be expected due to one having to the converstions from voxels to mesh and back to voxels?

Many thanks,
Eric

[josefinelissner]

Hi @eflehder1!
Yes, if you convert between voxels and mesh very often I would expect slight deviations in the shape to creep in. If you want to apply multiple transformations in sequence I suggest to all do it on the mesh-basis and only voxelize at the end agin.

The transformation in our case is a delegate function which needs to follow the syntax of Vector3 fnTrafo(Vector3) and no other inputs are allowed. There are two ways to communicate additional information. For basic cases, a (static) member variable can be used intermittently (as you are already doing). When it get's more complex, you would use a dedicated helper class that handles the transformation and additional data internally (same way as above), but exposes a static function with all the inputs you want to specify directly. It's kind of a two-step approach and more elegant. You find an example of this in the ShapeKernel library in LineModulation with the function that adds to LineModulations together.

[LinKayser]

BTW, Eric, I added mirroring to PicoGK base, because it's a really important function. If you pull the latest version, you can check it out here:

https://github.com/leap71/PicoGK/blob/main/Examples/Ex_MirrorObject.cs

You can either use the new transformation function for a Mesh:

Plane plane     = new(Vector3.UnitZ, 30f); // plane 30mm away in Z
Matrix4x4 mat   = Matrix4x4.CreateReflection(plane);
Mesh mshNew3    = mshOrg.mshCreateTransformed(mat);

Or you can use the new mshCreateMirrored method of Mesh

Mesh mshNew2 = mshOrg.mshCreateMirrored(Vector3.Zero, -Vector3.UnitX);

Cheers,
Lin

[eflehder1]

Thank you very much @josefinelissner @LinKayser! For the particular situation I was dealing with here it was easy enough to create the mirrored part from the original logic instead so I've done that to avoid conversion into mesh, however this mirroring function Im sure will be very handy for more complex parts!