Good day !

I faced with problem connected with Shadow Map slices.
I took algorithm from article

Code :
Matrix Light::CalculateCropMatrix(Frustum splitFrustum)  
{  
  Matrix lightViewProjMatrix = viewMatrix * projMatrix;  
  // Find boundaries in light's clip space  
  BoundingBox cropBB = CreateAABB(splitFrustum.AABB,  
                                  lightViewProjMatrix);  
  // Use default near-plane value  
  cropBB.min.z = 0.0f;  
  // Create the crop matrix  
  float scaleX, scaleY, scaleZ;  
  float offsetX, offsetY, offsetZ;  
  scaleX = 2.0f / (cropBB.max.x - cropBB.min.x);  
  scaleY = 2.0f / (cropBB.max.y - cropBB.min.y);  
  offsetX = -0.5f * (cropBB.max.x + cropBB.min.x) * scaleX;  
  offsetY = -0.5f * (cropBB.max.y + cropBB.min.y) * scaleY;  
  scaleZ = 1.0f / (cropBB.max.z - cropBB.min.z);  
  offsetZ = -cropBB.min.z * scaleZ;  
  return Matrix( scaleX,     0.0f,     0.0f,  0.0f,  
                   0.0f,   scaleY,     0.0f,  0.0f,  
                   0.0f,     0.0f,   scaleZ,  0.0f,  
                offsetX,  offsetY,  offsetZ,  1.0f);  
}

algorithm does next things:
1. calculate frustum points for each split
2. all 8 pointers multiply on lightViewProjMatrix to translate each point to light clip space
3. finding AABB
4. building crop matrix

i used this code in my program. but shadow maps for each slice are wrong (i will upload images with shadow maps soon).
my lightView matrix is lookat matrix with parameters:

Code :
scene.lightCamera.buildViewMatf(-600, 1000, -500, 0, 0, 0, 0, 1, 0);
 
   void buildViewMatf(float eye_x, float eye_y, float eye_z, 
	                  float earth_x, float earth_y, float earth_z,
					  float up_x, float up_y, float up_z)
   {
	   m_currEyePos[0] = eye_x; m_currEyePos[1] = eye_y; m_currEyePos[2] = eye_z;
	   m_earthPos[0] = earth_x; m_earthPos[1] = earth_y; m_earthPos[2] = earth_z;
	   m_up[0] = up_x; m_up[1] = up_y; m_up[2] = up_z;
 
	   NvBuildLookatMatf(m_view, m_currEyePos, m_earthPos, m_up);
   }


and i have light ortho projection matrix with parameters:
m_znear = 2.0f, m_zfar = 10000f;
Code :
NvBuildOrthoMatf(m_projection, -5000.0, 5000.0,
					-5000.0, 5000.0,
					m_znear, m_zfar);

finding frustum points:

Code :
   void updateFrustrumPoints(float z_near, float z_far)
   {
	   vec3f up(m_up[0], m_up[1], m_up[2]);
	   vec3f camera_position(m_currEyePos[0], m_currEyePos[1], m_currEyePos[2]);
	   vec3f view_direction(m_earthPos[0]-m_currEyePos[0], 
		                    m_earthPos[1]-m_currEyePos[1], 
							m_earthPos[2]-m_currEyePos[2]);
       view_direction = normalize(view_direction);
 
	   vec3f right = normalize(cross(view_direction, up));
       up = normalize(cross(right, view_direction));
 
	   float angle = (float) tan(45.0 * M_PI / 360.0);
	   float near_height = z_near * angle;
	   float far_height  = z_far * angle;
 
	   float near_width  = (1.0f / m_aspectRatio) * near_height;
	   float far_width   = (1.0f / m_aspectRatio) * far_height;
 
	   vec3f fc = camera_position + (view_direction * z_far); 
 
	   m_frustrumPoints.resize(8, vec3f(0.0, 0.0, 0.0));
 
	   // far-top-left
	   m_frustrumPoints[0] = fc + up*far_height - right*far_width;
 
	   // far-top-right
	   m_frustrumPoints[1] = fc + up*far_height + right*far_width;
 
	   // far-bottom-left
	   m_frustrumPoints[2] = fc - up*far_height - right*far_width;
 
	   // far-bottom-right
	   m_frustrumPoints[3] = fc - up*far_height + right*far_width;
 
	   vec3f nc =  camera_position + (view_direction * z_near);
 
	   // near-top-left
	   m_frustrumPoints[4] = nc + up*near_height - right*near_width;
 
	   // near-top-right
	   m_frustrumPoints[5] = nc + up*near_height + right*near_width;
 
	   // near-bottom-left
	   m_frustrumPoints[6] = nc - up*near_height - right*near_width;
 
	   //near-bottom-right
	   m_frustrumPoints[7] = nc - up*near_height + right*near_width;
   }

calculate crop matrix:
Code :
   void buildCropMatrix(vector<vec3f>& _frustumPoints, int number_of_split){
 
       vector<vec3f> frustumPoints(8, vec3f(0.0, 0.0, 0.0));
 
       for(int i = 0; i < 8; i++) {	      
	       NvTransformPointf((GLfloat*) &frustumPoints[i], m_model_view_projection, (GLfloat*) &_frustumPoints[i]);
	   }
 
	   /* Find minX, maxX, minY, maxY, minZ, maxZ */
	   float minX = frustumPoints[0].x, maxX = frustumPoints[0].x;
	   float minY = frustumPoints[0].y, maxY = frustumPoints[0].y;
       float minZ = frustumPoints[0].z, maxZ = frustumPoints[0].z;
 
       for(int i = 1; i < 8; i++){
 
			if(frustumPoints[i].x < minX) minX = frustumPoints[i].x;
	        if(frustumPoints[i].x > maxX) maxX = frustumPoints[i].x;
 
	        if(frustumPoints[i].y < minY) minY = frustumPoints[i].y;
	        if(frustumPoints[i].y > maxY) maxY = frustumPoints[i].y;
 
            if(frustumPoints[i].z < minZ) minZ = frustumPoints[i].z;
            if(frustumPoints[i].z > maxZ) maxZ = frustumPoints[i].z;
       }
 
       float scaleX = 2.0f / (maxX - minX);
       m_CropMatrix[number_of_split][0][0] = scaleX;
       m_CropMatrix[number_of_split][0][1] = 0.0f;
       m_CropMatrix[number_of_split][0][2] = 0.0f;
       m_CropMatrix[number_of_split][0][3] = 0.0f; 
 
       float scaleY = 2.0f / (maxY - minY);
	   float scaleZ = 1.0f / (maxZ - minZ);
 
       m_CropMatrix[number_of_split][1][0] = 0.0f;
       m_CropMatrix[number_of_split][1][1] = scaleY;
       m_CropMatrix[number_of_split][1][2] = 0.0f;
       m_CropMatrix[number_of_split][1][3] = 0.0f; 
 
       m_CropMatrix[number_of_split][2][0] = 0.0f;
       m_CropMatrix[number_of_split][2][1] = 0.0f;
       m_CropMatrix[number_of_split][2][2] = scaleZ; 
       m_CropMatrix[number_of_split][2][3] = 0.0f; 
 
       m_CropMatrix[number_of_split][3][0]  = -0.5f * (maxX + minX) * scaleX;
       m_CropMatrix[number_of_split][3][1]  = -0.5f * (maxY + minY) * scaleY;
       m_CropMatrix[number_of_split][3][2]  = -minZ * scaleZ; 
       m_CropMatrix[number_of_split][3][3]  = 1.0f; 
   }

Also i found algorithm

with code
Code :
Mat4 CreateDirLightVPMatrix(const CameraFrustrum& cameraFrustrum, const Vec3& lightDir)
    {
        const Vec3 lightDirx = glm::normalize(lightDir);
        const Vec3 perpVec1  = glm::normalize(glm::cross(lightDirx, Vec3(0.0f, 0.0f, 1.0f)));
        const Vec3 perpVec2  = glm::normalize(glm::cross(lightDirx, perpVec1));
        Mat4 lightViewMatrix(Vec4(perpVec1, 0.0f), Vec4(perpVec2, 0.0f), Vec4(lightDirx, 0.0f), Vec4(0.0f, 0.0f, 0.0f, 1.0f));
 
        Vec4 transf = lightViewMatrix * cameraFrustrum[0]; // cameraFrustrum is a std::array<Vec4, 8> and 0-3 is near-points and 4-7 are far points of the frustrum
        float maxZ = cameraFrustrum[0].z, minZ = cameraFrustrum[0].z;
        for (uint32_t i = 1; i < 8; i++)
        {
            transf = lightViewMatrix * cameraFrustrum[i];
            if (cameraFrustrum[i].z > maxZ)
                maxZ = cameraFrustrum[i].z;
            if (cameraFrustrum[i].z < minZ)
                minZ = cameraFrustrum[i].z;
        }
 
        const Mat4 mvp = glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, maxZ, minZ) * lightViewMatrix;
 
        float maxX = -1000.0f, minX = 1000.0f;
        float maxY = -1000.0f, minY = 1000.0f;
        for (uint32_t i = 0; i < 8; i++)
        {
            transf = mvp * cameraFrustrum[i];
 
            if (cameraFrustrum[i].x > maxX)
                maxX = cameraFrustrum[i].x;
            if (cameraFrustrum[i].x < minX)
                minX = cameraFrustrum[i].x;
            if (cameraFrustrum[i].y > maxY)
                maxY = cameraFrustrum[i].y;
            if (cameraFrustrum[i].y < minY)
                minY = cameraFrustrum[i].y;
        }
 
        float scaleX = 2.0f / (maxX - minX);
        float scaleY = 2.0f / (maxY - minY);
        float offsetX = -0.5f * (maxX + minX) * scaleX;
        float offsetY = -0.5f * (maxY + minY) * scaleY;
 
        Mat4 cropMatrix(1.0f);
        cropMatrix[0][0] = scaleX;
        cropMatrix[1][1] = scaleY;
        cropMatrix[3][0] = offsetX;
        cropMatrix[3][1] = offsetY;
 
        return cropMatrix * glm::ortho(-1.0f, 1.0f, -1.0f, 1.0f, maxZ, minZ) * lightViewMatrix;
    }

1. Does the first method correct ?
2. And what the difference (mathematical) between those two methods?