No. And if you scaled the data in unreal chances are the geo data is not going to match the real data from the railroad tracks.
Unfortunately, Unless you are able to get 1m lidar DTMs you will always have that particular issue.
What you should do is produce a DTM from the data, with the railroad tracks and everything else.
Also, scaling up in a GIS program helps reduce the bad stretching that occur when you take a data sample that’s 20 or 30m to be 1m.
Since it’s mostly the purpose of the program, the scaling is done differently with a special effort to preserve slope values - which is not true for adjusting things either at the PNG level or within unreal.
(Not to mention you should never change the X and Y scale of a landscape unless you know what you are doing. So you saying the size was adjusted within unreal is an immediate red flag).
Once you have the map and the roads to scale, in gis, you just export the streets/railroad as CSV.
You then create a bluetility importer in unreal, load the CSV and generate the spline.
This is done one street at a time.
Unless you know c++ and can modify the existing code, the ability of blueprint to loop or update the csv data you read in is inexistent.
At the same time, you definitely want each street to be a separate spline, so your actors can follow the splines as you code them to.
Depending on the type of game you may even need each road to be a conglomerate of splines.
If that’s the case I would highly suggest spending a couple of days on the spline generation tool, so you can give yourself some configurable options and generate a package of some sort which you can just configure and get to auto run.
The best approach to that is to use OOP in C++. Create a Road class, generate instances of Road by reading data in on construction.
Create a “Road generator” that parses the content of a directory of .csv to generate the Road system the game will use.
Once you are there you can actually make something similar for the buildings exterior.
For most US cities you are usually able to find somewhat detailed building shapes.
Generating non instanced meshes will likely kill performance - you have to be really careful as to what and how you do (because unreal is ■■■■ at performance, if you were using a different engine you may not have to over think this apsect).
There’s no fast track to any of this.
Keep this in mind too:
The splines can be used to deform the tiles.
The splines have to be inside persistent with no mesh. If you need to add meshes they need be to cut up to fit inside specific tiles.
For performance you shouldn’t be using splines to make roads with meshes. Since splines don’t use instancing.
Houston is not a bad entry point to learn all of this.
However I would suggest you practice on something much smaller so that you can get stuff to work right.
Pick a desolate lonely place that offers 1m lidar terrain scans to start so you don’t have to waste time figuring out how to get GIS to stretch terrain maps and how to get street map data onto it accurately.
I didn’t mention it, but obviously you will need to convert from GIS data x/y/z to unreal data.
PPS: you better make sure you are using the correct format for geospacial distortion.
Remember: unreal is always a flat earth while the actual earth is round.
This causes measurements to be vastly different exponentially unless you correctly deform the heightmaps generating the somewhat correct falloff that the earth radius provides.
This leads to another issue too: All your coordinate systems Z will always be wrong, since the terrain is adjusted for accurate representation based on a specific geographical location.
To get the real altitude in engine you would have to develop or adopt an approximate formula based on the value of the geographical representation used by the heigtmaps (you can probably search what formulae to use. The map adjustments make use of the same formula.)
As with everything, it all depends on what your end goal is. Maybe none of this stuff actually matters to you and you can just create the spline system based on flat/equispacial representations.