#include "StreetMapFactory.h"
#include "EditorFramework/AssetImportData.h"
#include "OSMFile.h"
#include "StreetMap.h"

// Latitude/longitude scale factor
//			- https://en.wikipedia.org/wiki/Equator#Exact_length
static const double EarthCircumference = 40075036.0;
const double UStreetMapFactory::LatitudeLongitudeScale = EarthCircumference / 360.0; // meters per degree


UStreetMapFactory::UStreetMapFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UStreetMap::StaticClass();

	Formats.Add( TEXT( "osm;OpenStreetMap XML" ) );
	bCreateNew = false;
	bEditorImport = true;
	bEditAfterNew = false;
	bText = true;
}


UObject* UStreetMapFactory::FactoryCreateText( UClass* Class, UObject* Parent, FName Name, EObjectFlags Flags, UObject* Context, const TCHAR* Type, const TCHAR*& Buffer, const TCHAR* BufferEnd, FFeedbackContext* Warn )
{
	UStreetMap* StreetMap = NewObject<UStreetMap>( Parent, Name, Flags | RF_Transactional );

	StreetMap->AssetImportData->Update( this->GetCurrentFilename() );

	// @todo: Performance: This will copy the entire text buffer into an FString.  We need to do this
	//        because the FFastXml parser is expecting a buffer that it can mutate as it parses.
	const int32 CharacterCount = BufferEnd - Buffer;
	FString MutableTextBuffer( CharacterCount, Buffer );

	const bool bIsFilePathActuallyTextBuffer = true;
	const bool bLoadedOkay = LoadFromOpenStreetMapXMLFile( StreetMap, MutableTextBuffer, bIsFilePathActuallyTextBuffer, Warn );

	if( !bLoadedOkay )
	{
		StreetMap->MarkAsGarbage();
		StreetMap = nullptr;
	}

	return StreetMap;
}


bool UStreetMapFactory::LoadFromOpenStreetMapXMLFile( UStreetMap* StreetMap, FString& OSMFilePath, const bool bIsFilePathActuallyTextBuffer, FFeedbackContext* FeedbackContext )
{
	// OSM data is stored in meters.  This is the scale factor to convert those units into UE4's native units (cm)
	// Keep in mind that if this is changed, UStreetMapComponent sizes for roads may need to be updated too!
	// @todo: We should make this scale factor customizable as an import option
	const double OSMToCentimetersScaleFactor = 100.0;


	// Converts latitude to meters
	auto ConvertLatitudeToMeters = []( const double Latitude ) -> double
	{
		return -Latitude * LatitudeLongitudeScale;
	};

	// Converts longitude to meters
	auto ConvertLongitudeToMeters = []( const double Longitude, const double Latitude ) -> double
	{
		return Longitude * LatitudeLongitudeScale * FMath::Cos( FMath::DegreesToRadians( Latitude ) );
	};

	// Converts latitude and longitude to X/Y coordinates, relative to some other latitude/longitude
	auto ConvertLatLongToMetersRelative = [ConvertLatitudeToMeters, ConvertLongitudeToMeters]( 
		const double Latitude, 
		const double Longitude, 
		const double RelativeToLatitude, 
		const double RelativeToLongitude ) -> FVector2D
	{
		// Applies Sanson-Flamsteed (sinusoidal) Projection (see http://www.progonos.com/furuti/MapProj/Normal/CartHow/HowSanson/howSanson.html)
		return FVector2d(
			ConvertLongitudeToMeters( Longitude, Latitude ) - ConvertLongitudeToMeters( RelativeToLongitude, Latitude ),
			ConvertLatitudeToMeters( Latitude ) - ConvertLatitudeToMeters( RelativeToLatitude ) );
	};
    
    // Adds a Park to the street map using the OpenStreetMap data, flattening the road's coordinates into our map's space
	auto AddParkForWay = [ConvertLatLongToMetersRelative, OSMToCentimetersScaleFactor]( 
		const FOSMFile& OSMFile, 
		UStreetMap& StreetMapRef, 
		const FOSMFile::FOSMWayInfo& OSMWay ) -> bool
	{
		if( OSMWay.WayType == FOSMFile::EOSMWayType::Park )
		{
			// Require at least three points so that we don't have degenerate polygon!
			if( OSMWay.Nodes.Num() > 2 )
			{
				// Create a Park for this way
				FStreetMapPark& NewPark = *new( StreetMapRef.Parks )FStreetMapPark();

				FVector2D BoundsMin( TNumericLimits<float>::Max(), TNumericLimits<float>::Max() );
				FVector2D BoundsMax( TNumericLimits<float>::Lowest(), TNumericLimits<float>::Lowest() );

				NewPark.ParkPoints.AddUninitialized( OSMWay.Nodes.Num() );
				int32 CurParkPoint = 0;

				for( const FOSMFile::FOSMNodeInfo* OSMNodePtr : OSMWay.Nodes )
				{
					const FOSMFile::FOSMNodeInfo& OSMNode = *OSMNodePtr;

					// Transform all points relative to the center of the latitude/longitude bounds, so that
					// we get as much precision as possible.
					const double RelativeToLatitude = OSMFile.AverageLatitude;
					const double RelativeToLongitude = OSMFile.AverageLongitude;
					const FVector2D NodePos = ConvertLatLongToMetersRelative(
						OSMNode.Latitude,
						OSMNode.Longitude,
						RelativeToLatitude,
						RelativeToLongitude ) * OSMToCentimetersScaleFactor;

					// Update bounding box
					{
						if( NodePos.X < BoundsMin.X )
						{
							BoundsMin.X = NodePos.X;
						}
						if( NodePos.Y < BoundsMin.Y )
						{
							BoundsMin.Y = NodePos.Y;
						}
						if( NodePos.X > BoundsMax.X )
						{
							BoundsMax.X = NodePos.X;
						}
						if( NodePos.Y > BoundsMax.Y )
						{
							BoundsMax.Y = NodePos.Y;
						}
					}

					// Fill in the points
					NewPark.ParkPoints[ CurParkPoint++ ] = NodePos;
				}

				// Make sure the Park ended up with a closed polygon, then remove the final (redundant) point
				const bool bIsClosed = NewPark.ParkPoints[ 0 ].Equals( NewPark.ParkPoints[ NewPark.ParkPoints.Num() - 1 ], KINDA_SMALL_NUMBER );
				if( bIsClosed )
				{
					// Remove the final redundant point
					NewPark.ParkPoints.Pop();
				}
				else
				{
					// Wasn't expecting to have an unclosed shape.  Our tolerances might be off, or the data was malformed.
					// Either way, it shouldn't be a problem as we'll close the shape ourselves below.
					// @todo: Log this for the user as an import warning
				}

				NewPark.ParkName = OSMWay.Name;
				if( NewPark.ParkName.IsEmpty() )
				{
					NewPark.ParkName = OSMWay.Ref;
				}

				NewPark.BoundsMin = BoundsMin;
				NewPark.BoundsMax = BoundsMax;

				StreetMapRef.BoundsMin.X = FMath::Min( StreetMapRef.BoundsMin.X, BoundsMin.X );
				StreetMapRef.BoundsMin.Y = FMath::Min( StreetMapRef.BoundsMin.Y, BoundsMin.Y );
				StreetMapRef.BoundsMax.X = FMath::Max( StreetMapRef.BoundsMax.X, BoundsMax.X );
				StreetMapRef.BoundsMax.Y = FMath::Max( StreetMapRef.BoundsMax.Y, BoundsMax.Y );

				return true;
			}
			else
			{
				// NOTE: Skipped adding Park for way because it has less than 3 points
				// @todo: Log this for the user as an import warning
			}
		}

		return false;
	};

	// Adds a road to the street map using the OpenStreetMap data, flattening the road's coordinates into our map's space
	auto AddRoadForWay = [ConvertLatLongToMetersRelative, OSMToCentimetersScaleFactor]( 
		const FOSMFile& OSMFile, 
		UStreetMap& StreetMapRef, 
		const FOSMFile::FOSMWayInfo& OSMWay, 
		int32& OutRoadIndex ) -> bool
	{
		EStreetMapRoadType RoadType = EStreetMapRoadType::Other;
		switch( OSMWay.WayType )
		{
			case FOSMFile::EOSMWayType::Motorway:
			case FOSMFile::EOSMWayType::Motorway_Link:
			case FOSMFile::EOSMWayType::Trunk:
			case FOSMFile::EOSMWayType::Trunk_Link:
			case FOSMFile::EOSMWayType::Primary:
			case FOSMFile::EOSMWayType::Primary_Link:
				RoadType = EStreetMapRoadType::Highway;
				break;

			case FOSMFile::EOSMWayType::Secondary:
			case FOSMFile::EOSMWayType::Secondary_Link:
			case FOSMFile::EOSMWayType::Tertiary:
			case FOSMFile::EOSMWayType::Tertiary_Link:
				RoadType = EStreetMapRoadType::MajorRoad;
				break;

			case FOSMFile::EOSMWayType::Residential:
			case FOSMFile::EOSMWayType::Service:
			case FOSMFile::EOSMWayType::Unclassified:
			case FOSMFile::EOSMWayType::Road:	// @todo: Consider excluding "Road" from our data set, as it could be a highway that wasn't properly tagged in OSM yet
				RoadType = EStreetMapRoadType::Street;
				break;

			default:
				RoadType = EStreetMapRoadType::Other;
		}

		if( RoadType != EStreetMapRoadType::Other )
		{
			// Require at least two points!
			if( OSMWay.Nodes.Num() > 1 )
			{
				// Create a road for this way
				OutRoadIndex = StreetMapRef.Roads.Num();
				FStreetMapRoad& NewRoad = *new( StreetMapRef.Roads )FStreetMapRoad();

				FVector2D BoundsMin( TNumericLimits<float>::Max(), TNumericLimits<float>::Max() );
				FVector2D BoundsMax( TNumericLimits<float>::Lowest(), TNumericLimits<float>::Lowest() );

				NewRoad.RoadPoints.AddUninitialized( OSMWay.Nodes.Num() );
				int32 CurRoadPoint = 0;

				// Set defaults for each node index on this road.  INDEX_NONE means the node is not valid, which may be the case
				// for nodes that we filter out entirely.  This will be filled in by valid indices to nodes later on.
				NewRoad.NodeIndices.AddUninitialized( OSMWay.Nodes.Num() );
				for( int32& NodeIndex : NewRoad.NodeIndices )
				{
					NodeIndex = INDEX_NONE;
				}


				for( const FOSMFile::FOSMNodeInfo* OSMNodePtr : OSMWay.Nodes )
				{
					const FOSMFile::FOSMNodeInfo& OSMNode = *OSMNodePtr;

					// Transform all points relative to the center of the latitude/longitude bounds, so that
					// we get as much precision as possible.
					const double RelativeToLatitude = OSMFile.AverageLatitude;
					const double RelativeToLongitude = OSMFile.AverageLongitude;
					const FVector2D NodePos = ConvertLatLongToMetersRelative(
						OSMNode.Latitude,
						OSMNode.Longitude,
						RelativeToLatitude,
						RelativeToLongitude ) * OSMToCentimetersScaleFactor;

					// Update bounding box
					{
						if( NodePos.X < BoundsMin.X )
						{
							BoundsMin.X = NodePos.X;
						}
						if( NodePos.Y < BoundsMin.Y )
						{
							BoundsMin.Y = NodePos.Y;
						}
						if( NodePos.X > BoundsMax.X )
						{
							BoundsMax.X = NodePos.X;
						}
						if( NodePos.Y > BoundsMax.Y )
						{
							BoundsMax.Y = NodePos.Y;
						}
					}

					// Fill in the points
					NewRoad.RoadPoints[ CurRoadPoint++ ] = NodePos;
				}


				NewRoad.RoadName = OSMWay.Name;
				if( NewRoad.RoadName.IsEmpty() )
				{
					NewRoad.RoadName = OSMWay.Ref;
				}
				NewRoad.RoadType = RoadType;
				NewRoad.BoundsMin = BoundsMin;
				NewRoad.BoundsMax = BoundsMax;

				NewRoad.bIsOneWay = OSMWay.bIsOneWay;

				StreetMapRef.BoundsMin.X = FMath::Min( StreetMapRef.BoundsMin.X, BoundsMin.X );
				StreetMapRef.BoundsMin.Y = FMath::Min( StreetMapRef.BoundsMin.Y, BoundsMin.Y );
				StreetMapRef.BoundsMax.X = FMath::Max( StreetMapRef.BoundsMax.X, BoundsMax.X );
				StreetMapRef.BoundsMax.Y = FMath::Max( StreetMapRef.BoundsMax.Y, BoundsMax.Y );

				return true;
			}
			else
			{
				// NOTE: Skipped adding road for way because it has less than 2 points
				// @todo: Log this for the user as an import warning
			}
		}

		return false;
	};


	// Adds a building to the street map using the OpenStreetMap data, flattening the road's coordinates into our map's space
	auto AddBuildingForWay = [ConvertLatLongToMetersRelative, OSMToCentimetersScaleFactor]( 
		const FOSMFile& OSMFile, 
		UStreetMap& StreetMapRef, 
		const FOSMFile::FOSMWayInfo& OSMWay ) -> bool
	{
		if( OSMWay.WayType == FOSMFile::EOSMWayType::Building )
		{
			// Require at least three points so that we don't have degenerate polygon!
			if( OSMWay.Nodes.Num() > 2 )
			{
				// Create a building for this way
				FStreetMapBuilding& NewBuilding = *new( StreetMapRef.Buildings )FStreetMapBuilding();

				FVector2D BoundsMin( TNumericLimits<float>::Max(), TNumericLimits<float>::Max() );
				FVector2D BoundsMax( TNumericLimits<float>::Lowest(), TNumericLimits<float>::Lowest() );

				NewBuilding.BuildingPoints.AddUninitialized( OSMWay.Nodes.Num() );
				int32 CurBuildingPoint = 0;

				for( const FOSMFile::FOSMNodeInfo* OSMNodePtr : OSMWay.Nodes )
				{
					const FOSMFile::FOSMNodeInfo& OSMNode = *OSMNodePtr;

					// Transform all points relative to the center of the latitude/longitude bounds, so that
					// we get as much precision as possible.
					const double RelativeToLatitude = OSMFile.AverageLatitude;
					const double RelativeToLongitude = OSMFile.AverageLongitude;
					const FVector2d NodePos = ConvertLatLongToMetersRelative(
						OSMNode.Latitude,
						OSMNode.Longitude,
						RelativeToLatitude,
						RelativeToLongitude ) * OSMToCentimetersScaleFactor;

					// Update bounding box
					{
						if( NodePos.X < BoundsMin.X )
						{
							BoundsMin.X = NodePos.X;
						}
						if( NodePos.Y < BoundsMin.Y )
						{
							BoundsMin.Y = NodePos.Y;
						}
						if( NodePos.X > BoundsMax.X )
						{
							BoundsMax.X = NodePos.X;
						}
						if( NodePos.Y > BoundsMax.Y )
						{
							BoundsMax.Y = NodePos.Y;
						}
					}

					// Fill in the points
					NewBuilding.BuildingPoints[ CurBuildingPoint++ ] = NodePos;
				}

				// Make sure the building ended up with a closed polygon, then remove the final (redundant) point
				const bool bIsClosed = NewBuilding.BuildingPoints[ 0 ].Equals( NewBuilding.BuildingPoints[ NewBuilding.BuildingPoints.Num() - 1 ], KINDA_SMALL_NUMBER );
				if( bIsClosed )
				{
					// Remove the final redundant point
					NewBuilding.BuildingPoints.Pop();
				}
				else
				{
					// Wasn't expecting to have an unclosed shape.  Our tolerances might be off, or the data was malformed.
					// Either way, it shouldn't be a problem as we'll close the shape ourselves below.
					// @todo: Log this for the user as an import warning
				}

				NewBuilding.BuildingName = OSMWay.Name;
				if( NewBuilding.BuildingName.IsEmpty() )
				{
					NewBuilding.BuildingName = OSMWay.Ref;
				}

				NewBuilding.Height = OSMWay.Height * OSMToCentimetersScaleFactor;
				NewBuilding.BuildingLevels = OSMWay.BuildingLevels;
                
                // Vinfamy added
                if ( NewBuilding.BuildingLevels == 0 )
                {
                    NewBuilding.BuildingLevels = rand() % 10 + 3;
                }
                NewBuilding.Amenity = OSMWay.Amenity;
                NewBuilding.Building = OSMWay.Building;

				NewBuilding.BoundsMin = BoundsMin;
				NewBuilding.BoundsMax = BoundsMax;

				StreetMapRef.BoundsMin.X = FMath::Min( StreetMapRef.BoundsMin.X, BoundsMin.X );
				StreetMapRef.BoundsMin.Y = FMath::Min( StreetMapRef.BoundsMin.Y, BoundsMin.Y );
				StreetMapRef.BoundsMax.X = FMath::Max( StreetMapRef.BoundsMax.X, BoundsMax.X );
				StreetMapRef.BoundsMax.Y = FMath::Max( StreetMapRef.BoundsMax.Y, BoundsMax.Y );

				return true;
			}
			else
			{
				// NOTE: Skipped adding building for way because it has less than 3 points
				// @todo: Log this for the user as an import warning
			}
		}

		return false;
	};
    
    
    /**
    // Adds a water to the street map using the OpenStreetMap data, flattening the road's coordinates into our map's space
	auto AddWaterForWay = [ConvertLatLongToMetersRelative, OSMToCentimetersScaleFactor]( 
		const FOSMFile& OSMFile, 
		UStreetMap& StreetMapRef, 
		const FOSMFile::FOSMWayInfo& OSMWay ) -> bool
	{
		if( OSMWay.WayType == FOSMFile::EOSMWayType::Water )
		{
			// Require at least three points so that we don't have degenerate polygon!
			if( OSMWay.Nodes.Num() > 2 )
			{
				// Create a Water for this way
				FStreetMapWater& NewWater = *new( StreetMapRef.Waters )FStreetMapWater();

				FVector2D BoundsMin( TNumericLimits<float>::Max(), TNumericLimits<float>::Max() );
				FVector2D BoundsMax( TNumericLimits<float>::Lowest(), TNumericLimits<float>::Lowest() );

				NewWater.WaterPoints.AddUninitialized( OSMWay.Nodes.Num() );
				int32 CurWaterPoint = 0;

				for( const FOSMFile::FOSMNodeInfo* OSMNodePtr : OSMWay.Nodes )
				{
					const FOSMFile::FOSMNodeInfo& OSMNode = *OSMNodePtr;

					// Transform all points relative to the center of the latitude/longitude bounds, so that
					// we get as much precision as possible.
					const double RelativeToLatitude = OSMFile.AverageLatitude;
					const double RelativeToLongitude = OSMFile.AverageLongitude;
					const FVector2D NodePos = ConvertLatLongToMetersRelative(
						OSMNode.Latitude,
						OSMNode.Longitude,
						RelativeToLatitude,
						RelativeToLongitude ) * OSMToCentimetersScaleFactor;

					// Update bounding box
					{
						if( NodePos.X < BoundsMin.X )
						{
							BoundsMin.X = NodePos.X;
						}
						if( NodePos.Y < BoundsMin.Y )
						{
							BoundsMin.Y = NodePos.Y;
						}
						if( NodePos.X > BoundsMax.X )
						{
							BoundsMax.X = NodePos.X;
						}
						if( NodePos.Y > BoundsMax.Y )
						{
							BoundsMax.Y = NodePos.Y;
						}
					}

					// Fill in the points
					NewWater.WaterPoints[ CurWaterPoint++ ] = NodePos;
				}

				// Make sure the Water ended up with a closed polygon, then remove the final (redundant) point
				const bool bIsClosed = NewWater.WaterPoints[ 0 ].Equals( NewWater.WaterPoints[ NewWater.WaterPoints.Num() - 1 ], KINDA_SMALL_NUMBER );
				if( bIsClosed )
				{
					// Remove the final redundant point
					NewWater.WaterPoints.Pop();
				}
				else
				{
					// Wasn't expecting to have an unclosed shape.  Our tolerances might be off, or the data was malformed.
					// Either way, it shouldn't be a problem as we'll close the shape ourselves below.
					// @todo: Log this for the user as an import warning
				}

				NewWater.WaterName = OSMWay.Name;
				if( NewWater.WaterName.IsEmpty() )
				{
					NewWater.WaterName = OSMWay.Ref;
				}

				NewWater.BoundsMin = BoundsMin;
				NewWater.BoundsMax = BoundsMax;

				StreetMapRef.BoundsMin.X = FMath::Min( StreetMapRef.BoundsMin.X, BoundsMin.X );
				StreetMapRef.BoundsMin.Y = FMath::Min( StreetMapRef.BoundsMin.Y, BoundsMin.Y );
				StreetMapRef.BoundsMax.X = FMath::Max( StreetMapRef.BoundsMax.X, BoundsMax.X );
				StreetMapRef.BoundsMax.Y = FMath::Max( StreetMapRef.BoundsMax.Y, BoundsMax.Y );

				return true;
			}
			else
			{
				// NOTE: Skipped adding Water for way because it has less than 3 points
				// @todo: Log this for the user as an import warning
			}
		}

		return false;
	};
    
    */
    
    
    




	// Load up the OSM file.  It's in XML format.
	FOSMFile OSMFile;
	if( !OSMFile.LoadOpenStreetMapFile( OSMFilePath, bIsFilePathActuallyTextBuffer, FeedbackContext ) )
	{
		// Loading failed.  The actual error message will be sent to the FeedbackContext's log.
		return false;
	}

	// @todo: The loaded OSMFile stores data in double precision, but our runtime representation (UStreetMap)
	//        truncates everything to single precision, after transposing coordinates to be relative to the
	//        center of the map's 2D bounds.  Large maps will suffer from floating point precision issues.
	//        To solve this we'd need to either store everything in double precision, or store map elements
	//        in integral grid cells with coordinates relative to their cell.  Of course, there will be many
	//        other considerations for handling huge maps (loading, rendering, collision, etc.)

	// Maps OSMWayInfos to the RoadIndex we created for that way
	TMap< const FOSMFile::FOSMWayInfo*, int32 > OSMWayToRoadIndexMap;

	StreetMap->BoundsMin = FVector2D( TNumericLimits<float>::Max(), TNumericLimits<float>::Max() );
	StreetMap->BoundsMax = FVector2D( TNumericLimits<float>::Lowest(), TNumericLimits<float>::Lowest() );

	for( const FOSMFile::FOSMWayInfo* OSMWay : OSMFile.Ways )
	{
		// Handle buildings differently than roads
		if (OSMWay->WayType == FOSMFile::EOSMWayType::Park)
		{
			if (AddParkForWay(OSMFile, *StreetMap, *OSMWay))
			{
				// ...
			}
		}

		else if( OSMWay->WayType == FOSMFile::EOSMWayType::Building )
		{
			if( AddBuildingForWay( OSMFile, *StreetMap, *OSMWay ) )
			{
				// ...
			}
		}
        
        
        /**
        else if( OSMWay->WayType == FOSMFile::EOSMWayType::Water )
		{
			if( AddWaterForWay( OSMFile, *StreetMap, *OSMWay ) )
			{
				// ...
			}
		}
        */
        
        
		else
		{
			int32 RoadIndex = INDEX_NONE;
			if( AddRoadForWay( OSMFile, *StreetMap, *OSMWay, RoadIndex ) )
			{
				OSMWayToRoadIndexMap.Add( OSMWay, RoadIndex );
			}
		}
	}

	for( const auto& NodeMapHashPair : OSMFile.NodeMap )
	{
		const FOSMFile::FOSMNodeInfo& OSMNode = *NodeMapHashPair.Value;

		// Any ways touching this node?
		if( OSMNode.WayRefs.Num() > 0 )
		{
			FStreetMapNode NewNode;

			for( const FOSMFile::FOSMWayRef& OSMWayRef : OSMNode.WayRefs )
			{
				const int32* FoundRoundIndexPtr = OSMWayToRoadIndexMap.Find( OSMWayRef.Way );
				if( FoundRoundIndexPtr != nullptr )
				{
					const int32 FoundRoadIndex = *FoundRoundIndexPtr;

					FStreetMapRoadRef RoadRef;
					RoadRef.RoadIndex = FoundRoadIndex;

					const int32 RoadPointIndex = OSMWayRef.NodeIndex;
					RoadRef.RoadPointIndex = RoadPointIndex;
					NewNode.RoadRefs.Add( RoadRef );
				}
				else
				{
					// Skipped ref because we didn't keep this road in our data set							
				}
			}

			// Only store nodes that are attached to at least one road.  We must have at least a connection to a single
			// road, otherwise we've filtered this node's road out and there's no point in wasting memory on the node itself.
			if( NewNode.RoadRefs.Num() > 0 )
			{
				// Most nodes from OpenStreetMap will only be touching a single road.  These nodes usually make up the points
				// along the length of the road, even for roads with no intersections except at the beginning and end.  We
				// don't need to store these points unless they are at the ends of the road.  Keeping the points at the
				// beginning and end of the road is useful when calculating navigation data, but the other nodes can go!
				// In the road's NodeIndices array, any nodes we filter out here will simply have an INDEX_NONE value in that
				// array, and we'll only store the positions of the road at these points in the road's RoadPoints array.

				const FStreetMapRoadRef& FirstRoadRef = NewNode.RoadRefs[ 0 ];
				const FStreetMapRoad& FirstRoad = StreetMap->Roads[ FirstRoadRef.RoadIndex ];

				if( NewNode.RoadRefs.Num() > 1 ||					// Does the node connect to more than one road?
					FirstRoadRef.RoadPointIndex == 0 ||				// Does the node connect to the beginning of the road?
					FirstRoadRef.RoadPointIndex == ( FirstRoad.NodeIndices.Num() - 1 ) )	// Does the node connect to the end of the road?
				{
					const int32 NewNodeIndex = StreetMap->Nodes.Num();
					StreetMap->Nodes.Add( NewNode );

					// Update the roads that are overlapping this node
					for( const FStreetMapRoadRef& RoadRef : NewNode.RoadRefs )
					{
						FStreetMapRoad& Road = StreetMap->Roads[ RoadRef.RoadIndex ];
						check( Road.NodeIndices[ RoadRef.RoadPointIndex ] == INDEX_NONE );
						Road.NodeIndices[ RoadRef.RoadPointIndex ] = NewNodeIndex;
					}
				}
				else
				{
					// Node has only one road that is references, and it wasn't the beginning or end of the road, so filter it out!
				}
			}
			else
			{
				// Node doesn't reference any roads that we kept, or the data was malformed.  Filter it out.
			}
		}
	}

	// Validation test: Make sure that all roads have at least two nodes referencing them, one at the beginning and
	// one at the end.
	for( const FStreetMapRoad& Road : StreetMap->Roads )
	{
		const bool bHasNodeAtBeginning = Road.NodeIndices[ 0 ] != INDEX_NONE;
		const bool bHasNodeAtEnd = Road.NodeIndices[ Road.NodeIndices.Num() - 1 ] != INDEX_NONE;

		// All roads should have at least two nodes referencing them, one at the beginning and one at the end
		ensure( bHasNodeAtBeginning && bHasNodeAtEnd );
	}

	return true;
}