C# Procedural Tilemap Generation - Each instance of tilemap rendering the same

I am working with script from a tutorial I followed to randomly generate terrain on a tilemap. The trouble I am having is when I add individual instances of the tilemap each one is a copy of the other. I thought it would be as simple as making the 2d array static so each instance of the tilemap would generate off a seperate array however this was not the case. Can I get some pointers here?

TileData.cs
using UnityEngine;
using System.Collections;

public class TileData : MonoBehaviour{
	public static int[,] tile;
	int x, y;

	// Use this for initialization
	void Awake ()
	{
		int mapHeight = TileMap.SIZE_Z;
		int mapWidth = TileMap.SIZE_X;;
		float tileSize = TileMap.TILESIZE;

		tile = new int[mapWidth, mapHeight];

		for (int x = 0; x < mapWidth; x++) 
		{
			for (int y = 0; y < mapHeight; y++)
			{
				tile[x, y] = Random.Range (0, 4);
			}
		}
	}

	public int GetTileAt(int x, int y) {
		return tile[x,y];
	}
}

TileMap.cs

using UnityEngine;
using System.Collections;
[RequireComponent(typeof(MeshRenderer))]
[RequireComponent(typeof(MeshCollider))]
public class TileMap : MonoBehaviour {
	
	public int size_x;
	public int size_z;
	public float tileSize;

	public static int SIZE_X;
	public static int SIZE_Z;
	public static float TILESIZE;
	
		
	public Texture2D terrainTiles;
	public int tileResolution;
		
	// Use this for initialization
	void Start () 
	{
		SIZE_X = size_x;
		SIZE_Z = size_z;
		TILESIZE = tileSize;
		BuildMesh();
	}
		
	Color[][] ChopUpTiles() 
	{
		int numTilesPerRow = terrainTiles.width / tileResolution;
		int numRows = terrainTiles.height / tileResolution;

		Color[][] tiles = new Color[numTilesPerRow*numRows][];

		for(int y=0; y<numRows; y++) 
		{
			for(int x=0; x<numTilesPerRow; x++) 
			{
				tiles[y*numTilesPerRow + x] = terrainTiles.GetPixels( x*tileResolution , y*tileResolution, tileResolution, tileResolution );
			}
		}

		return tiles;
	}
		
	void BuildTexture() 
	{
		//TileData map = new TileData();
		TileData map = gameObject.AddComponent<TileData>() as TileData;

		int texWidth = size_x * tileResolution;
		int texHeight = size_z * tileResolution;
		Texture2D texture = new Texture2D(texWidth, texHeight);
			
		Color[][] tiles = ChopUpTiles();

		for(int y=0; y < size_z; y++) 
		{
			for(int x=0; x < size_x; x++) 
			{
				Color[] p = tiles[map.GetTileAt(x,y)];
				texture.SetPixels(x*tileResolution, y*tileResolution, tileResolution, tileResolution, p);
			}
		}
			
		texture.filterMode = FilterMode.Point;
		texture.wrapMode = TextureWrapMode.Clamp;
		texture.Apply();
			
		MeshRenderer mesh_renderer = GetComponent<MeshRenderer>();
		mesh_renderer.sharedMaterials[0].mainTexture = texture;
			
	}
		
	public void BuildMesh() 
	{
		int numTiles = size_x * size_z;
		int numTris = numTiles * 2;
			
		int vsize_x = size_x + 1;
		int vsize_z = size_z + 1;
		int numVerts = vsize_x * vsize_z;
			
		// Generate the mesh data
		Vector3[] vertices = new Vector3[ numVerts ];
		Vector3[] normals = new Vector3[numVerts];
		Vector2[] uv = new Vector2[numVerts];
			
		int[] triangles = new int[ numTris * 3 ];
			
		int x, z;
		for(z=0; z < vsize_z; z++) 
		{
			for(x=0; x < vsize_x; x++) 
			{
				vertices[ z * vsize_x + x ] = new Vector3( x*tileSize, 0, -z*tileSize );
				normals[ z * vsize_x + x ] = Vector3.up;
				uv[ z * vsize_x + x ] = new Vector2( (float)x / size_x, 1f - (float)z / size_z );
			}
		}
			
		for(z=0; z < size_z; z++) 
		{
			for(x=0; x < size_x; x++) 
			{
				int squareIndex = z * size_x + x;
				int triOffset = squareIndex * 6;
				triangles[triOffset + 0] = z * vsize_x + x + 		   0;
				triangles[triOffset + 2] = z * vsize_x + x + vsize_x + 0;
				triangles[triOffset + 1] = z * vsize_x + x + vsize_x + 1;
			
				triangles[triOffset + 3] = z * vsize_x + x + 		   0;
				triangles[triOffset + 5] = z * vsize_x + x + vsize_x + 1;
				triangles[triOffset + 4] = z * vsize_x + x + 		   1;
			}
		}
			
			
		// Create a new Mesh and populate with the data
		Mesh mesh = new Mesh();
		mesh.vertices = vertices;
		mesh.triangles = triangles;
		mesh.normals = normals;
		mesh.uv = uv;
			
		// Assign our mesh to our filter/renderer/collider
		MeshFilter mesh_filter = GetComponent<MeshFilter>();
		MeshCollider mesh_collider = GetComponent<MeshCollider>();

		mesh_filter.mesh = mesh;
		mesh_collider.sharedMesh = mesh;
		Debug.Log ("Done Mesh!");
			
		BuildTexture();
	}
}

Found it, it was the mesh_renderer.sharedMaterials[0].mainTexture = texture; changing all instances of the material I was using.