Laser Cut Radial Ridgeline Mountain Model

When I started making 3D ridgeline maps, I thought it would be really neat to make a "radial" model of an individual mountain to show its features extending in all directions from the summit. Going through this process, I was reminded of this really neat Mt. Fuji flip book that I saw in a gift shop in Japan a few summers ago that is sort of the same idea!

This project could be hung on a wall or placed on a table as a unique decoration. Scale it down and mix it up and it could be a fun puzzle. Scale it wayyy up and cut out the middle and it could be a backyard play structure :) One cool (and ambitious!) idea would be to do all of the significant peaks in a mountain range, like the Cascade volcanoes.

Mount Rainier

I grew up in the Seattle area and getting to see Mount Rainier while driving south toward the city on a clear day was always a treat! It's a beautiful mountain with such varied terrain, so I thought it would be a good one to start with to try out this new process.

Radial slotting pattern

This Instructable won't go over all the details of designing and creating the cuts in the individual ridgeline pieces to ensure that they'll slot together properly. I have a separate Instructable about that if you'd like to check it out! This one will just use the concepts of that Instructable to determine the sizing for the cuts!

My focus in this Instructable will be to go over the basics of creating the design and getting all of the radial features to translate to flat pieces of plywood so that they can be cut out.

If you want to skip ahead to download the cut files for Mt. Rainier, they're attached to Step 27! They're designed for 3.4mm thick plywood, so if you've got a different size, be sure to scale it to match before cutting or it might not fit! I think just a simple proportional scaling should work for different sizes/thicknesses.

Software

• QGIS - such a great, free, open source program for working with geospatial data! I feel like I learn new things all the time and there is so much awesome information and so many wonderful people willing to share their knowledge! This project assumes that you have at least some basic knowledge of QGIS and can navigate your way around the interface.
• Inkscape - another spectacular open source program. Not strictly necessary for this project, but it's really handy for getting final alignment and measurements set up.
• Lightburn or other laser cutter software - this is just the one that I'm used to and that my makerspace uses, but others should be just fine as well.
• Excel - I used Excel to store and merge the width of the cuts that I needed to make in the ridgeline pieces to slot them together. This is then merged with the QGIS file in order to create the proper sized cuts. Any sort of spreadsheet program should work, or if you're familiar with Python/Pandas, that would be a great option as well (I think the pandas melt method would be especially handy).

Tools and materials

• Laser cutter - not totally necessary, but makes things go quickly! I'd love to see something like this recreated at a much larger scale with a jigsaw and some thicker plywood.
• Plywood or other material - the plywood that I used was salvaged from an old birch door skin and is around 3.4mm thick instead of the 3mm Baltic birch or poplar that I use more frequently. The thickness is important for this project for everything to fit together properly, so be sure you have a good measurement!
• Data - you can't get very far without elevation data! I was able to use 10-meter resolution Digital Elevation Model (DEM) files from this site. Mount Rainier is specifically in the Yakima section, and spans 4 grid sections: Mowich Lake, Sunrise, Mount Rainier West, and Mount Rainier East. 10-meter resolution is perfectly fine for this area, but if you're doing something like Mount Wycheproof, you might need some higher resolution data :) I referenced some additional sources in my first ridgeline Instructable so you can check there for more information!
• You could potentially glue the pieces together, but I find that they hold together quite well once everything is assembled. If you end up hanging it on a wall or something though, it would probably be good to stick the pieces together!
• A little bit of paint could also be a nice touch. I find that the edges of this wood burn quite dark and lose some of their detail, so lightening them up could help add contrast. Alternatively, when I do projects with poplar plywood, the edges tend to be a bit lighter, so that could work as well.

This project is made up of three major parts/processes:

1. Steps 4-8: Creating a radial array and sampling elevation values for that array.
2. Steps 9-15: Creating individual features that will become the ridgeline pieces, matching elevation information to them, and making the ridgeline outlines.
3. Steps 16-22: Creating cuts in the ridgeline strips so that they all fit together nicely.

I don't know if the way that I did these things is the best way, but it seemed to work out well enough! Please let me know if you have ideas or suggestions for improving or simplifying things.

I won't go into as much detail on making the ridgelines themselves as I did in my earlier Instructable, so please take a look there if there are parts of that process that seem unclear in the following steps.

This image shows what I wanted my final radial ridgeline to look like from the top (plan view). My goal was to have enough pieces that it didn't look too empty between each one, but not so many that it was way too difficult to assemble! 16 strips seemed like a good amount. Though it's not shown in the photo, each strip does continue through the center, so there are 32 "rays" that extend out from the center from the 16 strips.

Note that this image shows a circle, but I wanted to make my model end at the same elevation for each strip rather than ending at a specific distance from the center point, so mine is definitely not circular! Overall, I wanted to make it about a foot (300mm) in diameter.

Labeling.

The labels on the strips in the photo are how I ended up laying things out for my project, so those numbers are the ones that I'll be using as a reference for the rest of the steps. The shade of each strip represents the angle of the strip relative to the strips it is between. So in order from darkest to lightest:

• Two strips (0 and 8) at 90 degrees - require a 3.4mm cut to slot together.
• Two strips (4 and 12) at 45 degrees - require an 8.2mm cut to slot together.
• Four strips (2, 6, 10, and 14) at 22.5 degrees - require a 17.1mm cut to slot together.
• Eight strips (1, 3, 5, 7, and 9) at 11.25 degrees - require a 34.5mm cut to slot together.

Planning the angles

The angles of the strips are important for determining how big the cuts in them need to be and in what order they're assembled. The best way to do things to end up with the overall structure shown in the photo is to pair up strips that are at 90 degrees to each other. The next "layer" of strips should then fit between a previous set of strips. This is explained in more detail in my previous Instructable for cutting lap joints for radially aligned pieces, so check that out for more details if needed!

I wanted my model to be about 300mm wide by 90mm tall. Knowing that there were 16 strips that would need to all slot together, this height allowed for each strip to have a 5mm connecting section that would hold the two halves together and a 5mm buffer on both the top and the bottom.

The top buffer provides a bit more room before the "bottom" cuts start in the individual strips. There is a chance that with very steep terrain or very thick strips, the cutouts for the part of the strip that's below the connecting section could end up intersecting with the ridgeline and therefore split the strip into multiple sections. Starting those cuts lower helps reduce the chance of that happening.

The bottom buffer is so that if there are any areas along a ridgeline that fall below the target endpoint elevation, they won't end up being cut off.

The image here shows a very simplified example of what a single strip looks like.

This is a brief overview of how I set things up in QGIS. If anything is unclear in this section, please check out my other ridgeline Instructable where things are laid out in greater detail.

For this map, I ensured that everything was projected to EPSG:3857, but any CRS with meters as a default should work fine.

Raster setup

After loading the individual DEM files into QGIS (left side of first image), I used the "Build Virtual Raster" tool. This tool creates a single-layer reference to each of the individual rasters so that they can be treated as a single layer. It saves computer storage space by simply referencing the files rather than merging them and creating an entirely new file.

I then went into the properties of the virtual raster layer and adjusted the minimum elevation value until I had an area that I thought would be good to work with. By adjusting the minimum elevation, QGIS turns everything else black so it's easy to see the area that you want to work with (right side of first image).

Changing the "Contrast enhancement" value in the layer properties dialog to "Stretch and Clip to MinMax" results in showing just the area that I wanted to work with (second image). Note that this doesn't delete the white areas, it just doesn't show them.

For my area, I chose a minimum elevation of 2220 meters, and the maximum is approximately 4380 meters.

Map units to physical units

Using the measurement tool in QGIS, I found that the area that I wanted to work with was about 24km across at its widest point. Given that I wanted my physical map to be approximately 300mm wide, my conversion ratio between QGIS map units and physical model units is:

24,000 meters / 300mm = 66.67 meters/mm

So now I know that every horizontal millimeter on my physical model represents 66.67 meters in QGIS. This conversion is very important for later!

Height exaggeration

Based on the elevations shown in the raster layer properties, the area that I'm working with has a height differential from highest to lowest elevation of 4380-2220 = 2160 meters.

If I were to use the conversion ratio noted above when creating ridgelines, my physical model would end up being 2160 / 66.67 = only 32.4mm tall!

But as mentioned in the previous step, my desired physical model height is 90mm.

Because of that difference, I need to include a vertical exaggeration factor that will allow the ridgelines to be created to the correct height.

In my case, the exaggeration factor is 85/32.4 = 2.62 (use 85 here since there's a 5mm buffer section at the bottom), so that means I will multiply all of the QGIS elevation values by 2.62 when I create the ridgelines and add the 5mm buffer section to the bottom so that I end up with the 90mm tall model that I want.

Check out this Wikipedia article for more information about how and why vertical exaggeration is used!

To create the set of radial points in QGIS (which will be used to sample the raster elevation values), we'll start by creating a central point at the summit of the mountain. From that central point, we'll create a single horizontal line equal to the diameter of the area that we're working with, centered on the center point. We'll add a set of evenly spaced points along that line, duplicate those points to make 16 sets of points, then rotate each of those sets of points to create a radial array of points. The following steps and attached images detail that process!

Central point

From the stretched and clipped to minmax raster shown in the previous step, I created a point layer of just a single point near the summit of the mountain (first image). I wasn't concerned with being too precise here, as long as it was close to the center!

Single Horizontal Line

To create the single horizontal line (second image), I created a new line layer and drew a horizontal line starting at the center point and extending 24,000m to the east (use the advanced digitizing toolbar to lock the length and angle to make this easy). Next, I moved the line 12,000m west so that it was centered on the center point. Enable snapping to "Middle of segments" to make this part easy!

Evenly spaced points

To create a set of evenly spaced points along the horizontal line, I used the "Points along geometry" tool for the single horizontal line layer with a distance parameter of 100m (third image).

Duplicated points

To create 16 (total) copies of the points, I ran the "Array of translated features" tool, even though the points aren't translated. Using a step distance of 0 for all values and 15 for the number of features to create, 16 total sets of points are generated. Since the points are all stacked on top of each other for now, this step looks exactly the same as the previous step.

Now, we have 16 sets of points. These points each have an associated distance value (which is the distance from the westernmost point) and instance value (which is the "copy" number).

The distance values range from 0 to 24,000 in increments of 100. The instance values range from 0 to 15 (for 16 total).

Rotating the sets of points

To rotate each set of points, I used the "Rotate" tool in QGIS. The sets of points are rotated about the center point, so it's easiest to hide the sets of points in the layers panel so that only the center point is visible for this step.

In the "Rotate" dialog, I selected the center point as the "Rotation anchor point". For the "Rotation (degrees clockwise)" parameter, I selected the dropdown option to the right of the input box, and clicked "Edit" (first image). In the dialog that came up there, the equation that I used was "instance"*-11.25 (second image). "instance" can be found in the "Fields and Values" dropdown. -11.25 degrees is used to match up with the order of layers that I showed in the layout view in Step 2. A positive value for the angle rotates clockwise, but I wanted to increment my layers in a counterclockwise direction.

The results of running the "Rotate" tool are shown in the third image. I've added annotations for a few of the sets of points to show the attributes associated with them at this point. The "distance" starts at the end with the "instance" label for all instances, so the distance increases from left to right for the first set (instance 0) of points but right to left for the 16th set (instance 15) of points.

To create individual "flat" ridgeline pieces later, each point in the rotated points layer will need to have a unique identifier that can be matched to the ridgeline pieces. To do this, we can use the instance and distance values for each point.

I used the field calculator on the layer for the rotated set of points to create a new "uniqueid" field that is a concatenation of the instance number, an underscore, and the distance. The field calculator expression is shown in the first image, and the resulting attribute table for the layer is shown in the second image.

Each point with its unique ID can be used to sample the elevation values of the raster layer. Remember that even though the area below 2200 meters shows up as white on my raster layer, the raster values are still there, they're just not shown!

Use the "Sample raster values" tool with the rotated points layer as the input layer and the elevation raster as the raster layer. I changed the output column prefix to "elevation", but it doesn't really matter what you use. A new layer is created with an added field for the elevation values. The points don't look any different at this point, so this image just shows the attribute table of the new layer.

At this point, we're done with the rotated points layer for now! We'll come back to it later though!

Now that all of the rotated sets of points have associated elevations and a unique ID value, we need to create horizontal sets of points that can then be translated to make ridgelines based on those elevations. To do this, each of those points must be matched to one of the rotated points, so the unique IDs need to be the same.

This process is done in a similar way to the rotated sets of points, but instead of rotating the sets of points, they'll be translated horizontally.

Single horizontal line

I again started with a single horizontal line 24,000m long, and just drew it off to the side of the raster and rotated points (doesn't really matter where - shown in first image).

Interpolated points

To create the points along the horizontal line, I again used the "Points along geometry" tool with a spacing of 100m (second (very boring) image).

Arrayed points

I used the "Array of translated features" tool to create 15 additional sets of ridgeline points. I added a horizontal (x-axis) step distance of 25,000m to ensure they wouldn't overlap one another. Recall that you use 15 for the number of features to create since the original one isn't counted, so you'll again end up with 16 total sets of points. These sets of points are shown in the second image. It's not very exciting.

Unique IDs

If you look at the attribute table for the layer that was just created, you'll notice that we again have a "distance" and "instance" field, so it's easy to create a "uniqueid" field that matches that of the rotated points. I used the field calculator in the same way as in Step 7 to create the field. The field calculator expression dialog is shown in the second image.

At this step, we have the sampled elevation values for the radially arrayed sets of points. The radially arrayed sets of points have a unique ID value that matches with the unique ID value of the horizontally arrayed ridgeline base points, so we can join the sampled elevation values to the ridgeline base points.

Creating the join

To join the points based on their attributes, I right-clicked on the arrayed ridgeline base points and clicked "Properties". In the left panel, I clicked "Joins", then the plus sign to create a new join.

For the join layer, I used the radially arrayed points with the sampled elevation field. For the join and target fields, I used the "uniqueid" field. The join and target fields are the ones that QGIS uses to match up the values from the two different layers.

Under "Joined fields", I only selected the elevation field since I didn't need the other fields to be available. The join dialog box is shown in the first image.

The second image shows the attribute table of the arrayed ridgeline base points layer showing the joined elevation field.

As indicated in Step 4, I want my minimum elevation to be 2200m, so I'll extract only points with a higher elevation than that to make the ridgelines. I used the "Extract by expression" tool to create a new layer with points from the ridgeline base points that have an elevation greater than or equal to 2200m. The equation used is shown in the first image and the resulting new layer is shown in the second image.

We need to add the 5mm buffer to the bottom of each piece. To create the baseline endpoints, I selected the first and last point from each set of points with an elevation of 2200m or greater and translated it down by the equivalent of 5mm. I then inverted the distance values so that I could create a continuous border line in a later step.

Selecting the first and last ridgeline points

To select the first and last ridgeline points, I used the "Select by expression" tool. In the expression dialog, I entered the following (shown in the first image):

"distance" = maximum("distance", "instance") OR "distance" = minimum("distance", "instance")

This expression uses the maximum and minimum functions. The first parameter in these functions is the field value to search through. The second parameter is a grouping parameter. So overall, this expression finds the points with the maximum and minimum distance value (i.e. farthest left and right) for each of the 16 instances of the arrayed ridgeline.

Translating the base points

The basepoints can then be translated down by the equivalent of 5mm. Using the "Translate" tool, I checked the box to use "Selected features only" and changed the y-axis offset distance to -5mm*66.67m/mm = -333.33m. Note that this calculation uses the default conversion value identified in Step 4 and not the exaggerated vertical value. An example of the result of this translation is shown in the second image.

Inverting baseline endpoint distance values

In a later step, we'll merge the baseline endpoints and ridgeline points and create a "dot-to-dot" line from them. To do this, QGIS needs to know what order to connect the points in. For the ridgeline points, the "distance" field increases from left to right. The "distance" field for the baseline endpoints can therefore be multiplied by -1 so the bottom right point has the lowest negative value, the bottom left point has a less negative value, and the ridgeline points all have positive values.

To perform this operation, I used the field calculator on the baseline endpoint layer and selected the "Update existing field" option for the "distance" field. The expression used is "distance"*-1, as shown in the third image.

The layer of points with an elevation of 2200m or greater created in step 12 can be translated to make the tops of the ridgeline shapes.

To do this, I used the "Translate" tool. For the y-axis offset distance, I clicked the dropdown to the right of the input box>Edit. Recall that there should be a vertical exaggeration of 2.62, so the equation that I used for the translation is:

2.62*(elevation - 2200)

The equation is shown in the first image and the resulting translated points are shown in the second image. Things are finally starting to look mountain-y!

The translated ridgeline and baseline endpoint layers (shown in the first image) can now be merged and converted to a line then to a polygon.

Merging layers

I used the "Merge vector layers" tool to merge the baseline endpoints and ridgeline points.

Points to path

Next, the "Points to path" tool is used to turn the merged points into a line. To do this, I checked the "Create closed paths" box, used "distance" as the "Order expression", and "instance" as the "Path group expression" to make a separate feature out of each instance. The "Points to path" dialog is shown in the second image and the resulting line is shown in the third image.

Lines to polygons

Since we'll need to cut the slot portions out of the ridgeline pieces, they need to be converted to polygons. This can be done with the "Lines to polygons" tool. The output from this is shown in the fourth image.

The "main" ridgeline polygons are done now, so the next step is to get the cuts set up so that the ridgeline pieces can slot together properly.

The example files from Step 10 of my earlier Instructable (shown in the first image here as well) show the general pattern of cuts that are needed to create an array of 16 interlocking pieces. The 8 cuts shown in the image are flipped vertically to create the second 8 set of cuts for a total of 16.

VERY IMORTANT INFORMATION!!

The cut order shown here does not match the instance number in QGIS. Because the layers stack at 90 degree angles to one another as shown in Step 2, they don't stack in numerical order 0, 1, 2, etc... Instead, they stack 0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15 (shown in the second image). So these need to match up properly with the QGIS model. This will be noted again in Step 19!

For the cuts, there are 4 possible widths of cuts that correspond to pieces of plywood intersecting at 90, 45, 22.5, or 11.25 degrees. Based on the 3.4mm thick plywood that I'm using, the widths for those angles are 3.4mm, 8.2mm, 17.1mm, and 34.5mm, respectively.

Note that for this Instructable, there are a total of 18 layers of cuts: 16 "regular" layers, plus the top and bottom buffer layer, so the cuts will need to be extended to the top and bottom of each piece.

Adding cuts to the ridgeline pieces

In the next few steps, we need to create points in QGIS that the cuts will be centered on, convert the cut widths in mm to meters, match them up to the appropriate ridgeline polygons, and then create the cuts.

Since there are 18 layers of cuts in each ridgeline polygon, we'll create 18 points for each polygon. Each point will become the center point for a rectangle that will be cut in the polygon. To create the 18 points, I selected the middle point from the original sets of arrayed base points for the ridgeline pieces. There are a total of 241 points in each set, with distance values from 0 to 24,000, the middle point of each set is the distance value of 12,000.

I used the "Select by expression" tool again to select the middle point (using the expression "distance" = 12000) from each of the arrayed sets of ridgeline base points, then used the "Array of translated features" tool (shown in the first image) to create an array of 17 points for each one of those points (be sure to check the box to only use the selected features!). The distance used for the y-axis step distance is 5mm = 333.33m. The results from this step are shown in the second image for two of the sets of points.

These arrayed points are currently lined up starting at the baseline of the ridgeline pieces, so they need to be moved down to be centered in each layer. This is done using the "Translate" tool and a y-axis distance of -166.67 m. The result of this translation are shown in the third image overlaid on the ridgeline polygons. The 18 layers of 5mm sections that make up each polygon are shown as well.

You may notice that the tip of the mountain extends above the top of the strips! Unfortunately, I didn't realize initially that by default, QGIS estimates the maximum elevation of a raster layer rather than precisely calculating it to speed up rendering. So the actual maximum elevation of the mountain is 4,393m instead of 4,380m! Thankfully it won't make too much of a difference for this project so I don't need to go back and redo all of the previous steps!

For this step, we will again create a unique ID for each point that will be turned into a cut. Each point now has an "instance" field for its horizontal translated array number and an "instance_2" field that was added in the previous step.

I concatenated these as shown in the attached image to create a "cut_id" field. It's important to note that the "instance_2" field starts with 0 at the bottom!

This step is a little tedious, but involves creating a set of cut widths for each cut point that will be used to create the cuts in the ridgeline polygons.

I found that the easiest way to do this was just to look at the cut pattern file and use a range of 0-4 as an index to indicate the width of each cut for each layer for each ridgeline polygon and put the value in a spreadsheet. An example of this process is shown in the attached image.

These values are then matched to the correct widths in mm and converted to m using the 66.67m/mm conversion noted in Step 4.

As noted in Step 16, the order needs to be as follows, to match the widths properly. The second image again shows the matchup between the cut pattern and the instance numbers.

0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15

To get the correct cut width for each cut in QGIS, I first saved the spreadsheet from Excel to a .csv file.

Adding the csv

The csv file can be added to QGIS by clicking on Layer>Add Layer>Add Delimited Text Layer. Make sure that the boxes for "First record has field names" and "Detect field types" are checked, and the Geometry Definition should be "No geometry (attribute table only)" as shown in the first attached image.

Joining the data

To join the cut data to the cut points, I right-clicked on the cut center point layer created in Steps 17-18 then Properties>Joins. I added a new join to the csv layer using the "cut_id" as the join and target field for each layer, then added only the "width_m" field since the other ones aren't needed. The attribute table of the cut points layer is shown in the second image. The width in meters is included in the farthest right field.

Now that the width of each cut is associated with the cut points, we can create rectangles that can be subtracted from the full ridgeline polygons. Each rectangle will have the proper associated width and will be 5mm = 333.33m tall.

Creating rectangles

To create rectangles, QGIS needs a non-zero height and width. A bunch of our cut points have 0m widths associated with them though, so I first ran "Select by expression" to select only points with a width of greater than zero.

Then, to actually create the rectangles, I used the "Rectangles, ovals, diamonds" tool on the cut points layer, made sure to check teh "Selected features only" box and selected Rectangle as the shape. For the width, I clicked the dropdown to the right of the input box>Field type...>width_m field (shown in the first image).

For the height, I entered 335m. This is slightly higher than needed, but I wanted to ensure that the rectangles would overlap one another for cutting later. The results from this step with the rectangles and cut points for the first two sets of cuts is shown in the second image.

Dissolving rectangles

Rather than having individual rectangles, I wanted have each polygon be a continuous shape, so I ran the "Dissolve" tool on the rectangle layer to merge all rectangles for each cut, as shown in the third image.

Simplifying cut shapes

Even though the cut polygons are all one continuous shape, they still have a lot of vertices along their edges from the locations of the original rectangles (shown in the fourth image). This isn't a huge deal, but I like to get rid of them by running the "Simplify" tool. This gets rid of most of the extra vertices (as shown in the fifth image), though it doesn't always catch all of them.

The result from all of this is shown in the sixth image, where the cut polygons are overlaid on the completed ridgeline polygons from earlier.

To cut the cut polygons out of the ridgeline polygons, I used the "Difference" tool with the ridgeline polygons as the input layer and the cut polygons as the overlay layer. The result of this operation is shown in the attached image.

Labeling

I added labels to each polygon using the Labels option in the layer properties dialog and the "instance" value for the label. This just makes it easier to keep the polygons straight when rearranging them for cutting later. In the menu highlighted in the first image, I select the "Always Render Labels as Text" option. This allows me to use the "Hershey text" extension in Inkscape later (this is shown in detail in Step 36 of this Instructable so I'm not going to go into detail here).

Export to PDF

I find that exporting to PDF works well from QGIS, so I do that by clicking on Project>Import/Export>Export Map to PDF. In the dialog box that pops up there, I select the ridgelines with cuts layer in the "Calculate from Layer" dropdown, keep the "Simplify geometries..." box checked, and change the Text export to "Always Export Text as Text Objects".

Scaling

From the QGIS export, the size might not be exactly what we want it to be in mm, so we need to edit that in Inkscape. To do this, I first change the view options in Inkscape to View>Display Mode>Outline as I find that easiest to work with. I then measure the height of an individual layer. It's a little messy as shown in the first image, but it shows that the height of an individual layer is only 2.08mm. We want it to be 5mm though, so I select everything in the Inksacpe file, then go to Object>Transform to open the transform menu, click on the "Scale" tab, check the box for "Scale proportionally", and enter 5/2.08*100 in either the width or the height box (the scale uses a percentage, so it needs to be multiplied by 100). This is shown in the second image.

After clicking Apply, the polygons are clearly bigger! Measuring again (as shown in the third image) indicates a layer height of 4.99mm, which is close enough!

I run the Hershey text extension (again, detailed in Step 36 of this Instructable) to convert the text to single lines. This isn't a necessary step, but it can be handy to speed up the laser cutting process.

Orientation

When assembling the final model, the pieces can fit together in two possible orientations, so it's easy to accidentally make a mirror image of the mountain you're working with! In fact, for the first version of this model, I did just that (you can see it in the picture in Step 1 of the model on my cutting mat that it's opposite of the later images). To avoid this, I later added a North and East arrow on layer 0 and layer 8 to indicate the direction that those should point. Once you have the direction for two of the pieces, you know whether the intermediate numbers increase going clockwise or counter-clockwise, so you can fill in the gaps as needed.

Based on the initial points array in the QGIS model, I know that the "distance" values increase from left to right, so the right side of instance 0 points to the east, and the right side of instance 8 points to the north. I add these as text (and run the Hershey text again) as shown in the attached image.

Rearranging

I also rearrange the pieces in Inkscape so that they're not so spread out, change the stroke color of the text so it's not the same as the outlines, and increase the text size so it's a bit easier to see. Once that's done, it's time to cut! If you just want the svg file, it's attached in the next step!

Attached is the SVG file used to make this model. As noted earlier, it's designed for wood that's 3.4mm thick, so scale as needed! Please let me know if you have any issues with the file! The text and outline colors are separate, so the text should be run with a lower power or faster speed to not cut through the wood.

This is always the best part of a project I think!

Cut out the individual pieces, put it together, and admire your work :) I used Lightburn to control the final layout and settings to make the cut, but whatever software you have access to should work!

When you're assembling the model, be sure to note the direction of the North and East arrows! Once you have those determined, you can slot the remaining pieces in their appropriate locations.

As always, please let me know if you have any questions or feedback and I'd be happy to chat!