I have created a procedurally generated sphere; but it has a strange crease, a 'pinch point' at the poles, and the lighting is off at the seam.

How can I correct this so the lighting is uniform? And if possible remove the 'point' at the poles? (although this is not so detrimental as it is masked when the deform is applied).

Here's the full script :

 #pragma strict
 
 @script RequireComponent(MeshFilter)
 @script RequireComponent(MeshRenderer)
 
 public var radius : float = 1.0;
 public var segments : int = 5;
 public var perlinRange : float = 0.25;
 
 private var calcAngle : float;
 private var posX : float[];
 private var posY : float[];
 private var posX2 : float[];
 private var posY2 : float[];
 
 private var myMesh : Mesh;
 private var verts : Vector3[];
 private var uv : Vector2[];
 private var tris : int[];
 
 
 function Start() 
 {
     CreateSphere();
 }
 
 function Update() 
 {
     if (Input.GetMouseButtonUp(1))
     {
         CreateSphere();
     }
 }
 
 
 function CreateSphere() 
 {
     var i : int = 0;
     // ----
     
     calcAngle = 0;
     posX = new float[segments + 1];
     posY = new float[segments + 1];
     
     // Calculate Circle on X-Y
     for (i = 0; i < segments + 1; i ++)
     {
         posX[i] = Mathf.Sin( calcAngle * Mathf.Deg2Rad );
         posY[i] = Mathf.Cos( calcAngle * Mathf.Deg2Rad );
         
         calcAngle += 180.0 / parseFloat(segments);
     }
     
     // ----
     
     calcAngle = 0;
     posX2 = new float[ (segments * 2) + 1 ];
     posY2 = new float[ (segments * 2) + 1 ];
     
     // Calculate Circle on X-Z
     for (i = 0; i < (segments * 2) + 1; i ++)
     {
         posX2[i] = Mathf.Sin( calcAngle * Mathf.Deg2Rad );
         posY2[i] = Mathf.Cos( calcAngle * Mathf.Deg2Rad );
         
         calcAngle += 180.0 / parseFloat(segments);
     }
     
     // ----
     
     // Vertices - Add Perlin Noise
     verts = new Vector3[ ( segments + 1 ) * ( (segments * 2) + 1 )];
     
     var p : int = 0;
     for (i = 0; i < (segments + 1); i ++)
     {
         for (p = 0; p < (segments * 2) + 1; p ++)
         {
             if ( i == 0 || i == segments ) // align top and bottom verts to same vert
             {
                 verts[ p + (i * ( (segments * 2) + 1 )) ] = new Vector3( posX2[p] * posX[i], posY[i], posY2[p] * posX[i] ) * radius * ( Random.Range(1.0 - perlinRange, 1.0) );
                 
                 if (p != 0) // leave first in row randomly generated (no need to make equal to self)
                 {
                     verts[ p + (i * ( (segments * 2) + 1 )) ] = verts[ 0 + (i * ( (segments * 2) + 1 )) ];
                 }
             }
             else if ( p == (segments * 2) ) // at end of row
             {
                 verts[ p + (i * ( (segments * 2) + 1 )) ] = verts[ 0 + (i * ( (segments * 2) + 1 )) ];
             }
             else 
             {
                 verts[ p + (i * ( (segments * 2) + 1 )) ] = new Vector3( posX2[p] * posX[i], posY[i], posY2[p] * posX[i] ) * radius * ( Random.Range(1.0 - perlinRange, 1.0) );
             }
         }
     }
     
     // ----
     
     // UVs
     
     uv = new Vector2[verts.length];
     
     //var calcUVchunk : Vector2 = Vector2( 1.0 / ( (segments * 2) + 1 ), 1.0 / (segments + 1) );
     var calcUVchunk : Vector2 = Vector2( 1.0 / (segments * 2), 1.0 / (segments) );
     
     for (i = 0; i < (segments + 1); i ++)
     {
         for (p = 0; p < (segments * 2) + 1; p ++)
         {
             uv[ p + (i * ( (segments * 2) + 1 )) ] = new Vector2( 1.0 - (calcUVchunk.x * p), 1.0 - (calcUVchunk.y * i) );
             
             //Debug.Log( " " + uv[ p + (i * ( (segments * 2) + 1 )) ] + " : " + Vector2( calcUVchunk.x * p, 1.0 - (calcUVchunk.y * i) ) );
         }
     }
     
     // ----
     
     // Triangles
     
     tris = new int[ ( segments * segments * 4 * 3 ) ];
     
     var t : int = 0;
     
     for (i = 0; i < segments; i ++)
     {
         for (p = 0; p < (segments * 2); p ++)
         {
             tris[ t + 0 ] = ( (i + 0) * ( (segments * 2) + 1 ) ) + p + 0;
             tris[ t + 1 ] = ( (i + 1) * ( (segments * 2) + 1 ) ) + p + 0;
             tris[ t + 2 ] = ( (i + 1) * ( (segments * 2) + 1 ) ) + p + 1;
             
             tris[ t + 3 ] = ( (i + 0) * ( (segments * 2) + 1 ) ) + p + 1;
             tris[ t + 4 ] = ( (i + 0) * ( (segments * 2) + 1 ) ) + p + 0;
             tris[ t + 5 ] = ( (i + 1) * ( (segments * 2) + 1 ) ) + p + 1;
             
             t += 6;
         }
     }
     
     // ----
     
     // Show Mesh
     
     var theMeshFilter : MeshFilter = this.gameObject.GetComponent(MeshFilter) as MeshFilter;
     
     theMeshFilter.mesh.vertices = new Vector3[verts.length];
     theMeshFilter.mesh.uv = new Vector2[uv.length];
     theMeshFilter.mesh.triangles = new int[tris.length];
     
     theMeshFilter.mesh.vertices = verts;
     theMeshFilter.mesh.uv = uv;
     theMeshFilter.mesh.triangles = tris;
     
     theMeshFilter.mesh.RecalculateBounds();
     theMeshFilter.mesh.RecalculateNormals();
     
     
     // Calculate Tangents
     TangentSolver(theMeshFilter.mesh);
     
     
     // assign default material if there is none    
     if (!theMeshFilter.renderer.material)
     {
         theMeshFilter.renderer.material.color = Color.white;
     }
 }

note : yes, I do reference Perlin Noise but don't use it. The original line was

 verts[ p + (i * ( (segments * 2) + 1 )) ] = new Vector3( posX2[p] * posX[i], posY[i], posY2[p] * posX[i] ) * radius * ( Mathf.PerlinNoise(1.0 - perlinRange, 1.0) );

but all this did was scale the whole object. I have alot to learn yet ....