Calculating the diffuse r,g,bvalue of pixel on raytracer using Blinn-Phong

Question

I am trying to calculate the RGB value of a pixel using the Blinn-Phong formula. For that I use this function:

Material getPixelColor(Ray ray, double min, int index, std::vector<Object*> Objects, std::vector<Object*> lightSources) {

    Vector intersectionPoint = ray.getOrigin() + ray.getDirection() * min;
    Vector n = Objects.at(index)->getNormalAt(intersectionPoint);
    Vector reflectiondirection = ray.getDirection() - n * Vector::dot(ray.getDirection(), n) * 2;
    Ray reflectionRay(intersectionPoint, reflectiondirection);

    // check if ray intersects any other object;
    double minimum = INFINITY;
    int count = 0, indx = -1;
    for (auto const& obj : Objects) {
        double distance = obj->Intersect(reflectionRay);
        if (minimum > distance) {
            minimum = distance;
            indx = count;
        }
        count++;
    }

    Material result(0,0,0);
    if (recurseDepth >= 5 || indx == -1) {
        recurseDepth = 0;
        // Check if object is lit for each light source
        for (auto const& light : lightSources) {
            // Blinn-Phong
            Vector lightDirection = (light->getPosition() - intersectionPoint).normalize();
            double nl = Vector::dot(n, lightDirection);
            nl = nl > 0 ? nl : 0.0;
            result = result + (Objects.at(index)->getMaterial() * light->getMaterial() * nl);
        }
    }
    else{
        recurseDepth++;
        result = result + getPixelColor(reflectionRay, minimum, indx, Objects, lightSources);
    }
    return result;
}

The result that I get is this:

This is how it was without shading:

I have been trying to find a solution for hours and can't. Am I using the wrong formula?

Answer 1

After a lot of research, I removed the part where it is getting color from other objects:

Material getPixelColor(Ray ray, double min, int index, std::vector<Object*> Objects, std::vector<Object*> lightSources) {
    Vector intersectionPoint = ray.getOrigin() + ray.getDirection() * min;
    Vector n = Objects.at(index)->getNormalAt(intersectionPoint);

    Material result(0,0,0);
    // Check if object is lit for each light source
    for (auto const& light : lightSources) {
        //create a ray to the light and check if there is an object between the two
        Vector lightDirection = (light->getPosition() - intersectionPoint).normalize();
        Ray lightRay(intersectionPoint, lightDirection);

        bool hit = false;
        for (auto const& obj : Objects) {
            double distance = obj->Intersect(lightRay);
            if (INFINITY > distance && distance > 0.0001) {
                hit = true;
                break;
            }
        }

        if (!hit) {
            // Blinn-Phong
            double nl = Vector::dot(n, lightDirection);

            // clamp nl between 0 and 1
            if (nl > 1.0) {
                nl = 1.0;
            }
            else if (nl < 0.0) {
                nl = 0.0;
            }

            result = result + (Objects.at(index)->getMaterial() * nl);
        }
    }
    return result;
}

And so I got the desired result: