C++ ImageReader::getImageHeight方法代码示例

void Retexture::calculateTexture(std::vector<Vector3f> T, std::vector<Vector3f> background, std::vector<Vector3f> image, std::vector<float> deltaX, std::vector<float> deltaY, std::vector<Vector3f> &result, ImageReader mask)
{
    int width = mask.getImageWidth();
    std::cout << width << std::endl;
    float cmaxAverage = 0.0f;

    for (int i = 0; i < T.size(); i++) {
        int x = i % width;
        int y = i / width;

        if(QColor(mask.pixelAt(y,x)).red() < 150) {
            // Black part of the mask, don't do anything
            result.push_back(background[i]);
            continue;
        }

        int t_x = fmod(float(x) + m_s*deltaX[i], width);
        int t_y = fmod(float(y) + m_s*deltaY[i], mask.getImageHeight());
        Vector3f t_value = T[t_y*width + t_x];
        Vector3f resultValue = (1.f - m_f) * t_value + m_f * image[i];

        float resultAverage = (resultValue[0] + resultValue[1] + resultValue[2])/3.0f;
        if(cmaxAverage < resultAverage){
            cmaxAverage = resultAverage;
        }
        result.push_back(resultValue);
    }
}

std::vector<float> ShapeEstimation::computePixelLuminance(ImageReader imageIn, ImageReader mask, float &sigma){
    int rows = imageIn.getImageHeight();
    int cols = imageIn.getImageWidth();
    std::vector<float> pixelLuminances;

    int pixelsInObject = 0;
    float objectLuminanceSum = 0.0f;
    for(int row = 0; row < rows; row++){
        for(int col = 0; col < cols; col++){
            QColor imageColor = QColor(imageIn.pixelAt(row, col));
            QColor maskColor = QColor(mask.pixelAt(row, col));
            if((maskColor.red() > 150)){
                pixelsInObject += 1;
                float luminance =  0.213f * float(imageColor.red()) + 0.715f * float(imageColor.green()) + 0.072f * float(imageColor.blue());
                if(luminance == 0.0f){
                    luminance = 0.0001f;
                }
                pixelLuminances.push_back(luminance/ 255.0f);
                objectLuminanceSum += log(luminance / 255.0f);
            } else {
                if(DEPTHMAPBACKGROUND){
                     pixelLuminances.push_back(1.0f);
                } else {
                     pixelLuminances.push_back(0.0f);
                }
            }
        }
    }
    sigma = exp(objectLuminanceSum / float(pixelsInObject));
    return pixelLuminances;
}

void ShapeEstimation::cropMask(ImageReader mask, std::vector<float> &pixelLuminances){
    int rows = mask.getImageHeight();
    int cols = mask.getImageWidth();

    for(int row = 0; row < rows; row++){
        for(int col = 0; col < cols; col++){
           QColor maskColor = QColor(mask.pixelAt(row, col));
           int index = mask.indexAt(row, col);

           if(maskColor.red() > 150){

           } else {
               if(DEPTHMAPBACKGROUND){
                    pixelLuminances[index] = 1.0f;
               } else {
                    pixelLuminances[index] = 0.0f;
               }
           }
        }
    }
}

void Retexture::calculateMixedMaterial(std::vector<Vector3f> glass,std::vector<Vector3f> notGlass, std::vector<Vector3f> background, std::vector<Vector3f> image, std::vector<float> deltaX, std::vector<float> deltaY, std::vector<Vector3f> &result, ImageReader mask, ImageReader materialMask, ImageReader glassColors)
{
    int width = mask.getImageWidth();
    std::cout << width << std::endl;
    float cmaxAverage = 0.0f;
    std::vector<Vector3f> T = glass;
    for (int i = 0; i < T.size(); i++) {
        int x = i % width;
        int y = i / width;

        if(QColor(mask.pixelAt(y,x)).red() < 150) {
            // Black part of the mask, don't do anything

            // if image isn't 0, push back image.
                result.push_back(background[i]);

            continue;
        }

        if(QColor(materialMask.pixelAt(y,x)).red() < 50 && QColor(materialMask.pixelAt(y,x)).blue() < 50 && QColor(materialMask.pixelAt(y,x)).green() < 50){
           T = notGlass;
           m_s = 20.0f;
        } else {
            T = glass;
            m_s = 50.0f;
        }

        int t_x = fmod(float(x) + m_s*deltaX[i], width);
        int t_y = fmod(float(y) + m_s*deltaY[i], mask.getImageHeight());
        Vector3f t_value = T[t_y*width + t_x];
        Vector3f resultValue = (1.f - m_f) * t_value + m_f * image[i];

        float resultAverage = (resultValue[0] + resultValue[1] + resultValue[2])/3.0f;
        if(cmaxAverage < resultAverage){
            cmaxAverage = resultAverage;
        }
        result.push_back(resultValue);

    }
    std::cout << cmaxAverage << std::endl;

    T = glass;
    for (int i = 0; i < T.size(); i++) {
        int x = i % width;
        int y = i / width;

        if(QColor(mask.pixelAt(y,x)).red() < 150) {
            // Black part of the mask, don't do anything
            continue;
        }
        if(QColor(materialMask.pixelAt(y,x)).red() < 50 && QColor(materialMask.pixelAt(y,x)).blue() < 50 && QColor(materialMask.pixelAt(y,x)).green() < 50) {
            // Black part of the mask, don't do anything
            continue;
        }
        QColor stainedGlass = QColor(glassColors.pixelAt(y,x));

        Vector3f darkness = Vector3f(2.0f,2.0f,2.0f);
      //  Vector3f color = Vector3f(float(stainedGlass.red())/255.0f,float(stainedGlass.green())/255.0f,float(stainedGlass.blue())/255.0f);
        Vector3f color = Vector3f(1.0f,1.0f,1.0f);
        Vector3f resultValue = result[i];
        resultValue[0] = fmin(pow((resultValue[0] * color[0]/ cmaxAverage) , darkness[0]) * 255.0f,255.0f);
        resultValue[1] = fmin(pow((resultValue[1] * color[1]/ cmaxAverage) , darkness[1]) * 255.0f,255.0f);
        resultValue[2] = fmin(pow((resultValue[2] * color[2]/ cmaxAverage) , darkness[2]) * 255.0f, 255.0f);
        result[i] = resultValue;
    }

}

void ShapeEstimation::estimateShape(ImageReader imageIn, ImageReader mask, std::vector<float>& depthMap, std::vector<Vector3f>& normalMap, std::vector<float> &gradientX, std::vector<float> &gradientY){
    BilateralFilter bf;
    int rows = imageIn.getImageHeight();
    int cols = imageIn.getImageWidth();

    float sigma = 0.0f;

    std::vector<float> luminances = computePixelLuminance(imageIn, mask, sigma);
    m_luminances = luminances;

    sigmoidalCompression(luminances, sigma);
    std::cout << rows << " " << cols << std::endl;
    float bilateralSigmaSpatial = m_bilateralSmoothing * float(cols);
    float bilateralSigmaL = 255.0f;
    std::cout << "convolve" << std::endl;
    luminances = bf.convolve(imageIn, luminances, bilateralSigmaSpatial, bilateralSigmaL);
    std::cout << "inversion" << std::endl;
    sigmoidalInversion(luminances, sigma);
    //cropMask(mask, luminances);

    std::vector<Vector3f> normals = gradientField(mask, luminances, gradientX, gradientY);

    if(DEBUG){
        QImage output(cols, rows, QImage::Format_RGB32);
        QRgb *depthMap = reinterpret_cast<QRgb *>(output.bits());
        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                int index = imageIn.indexAt(i, j);
                float color = luminances[index] * 255.0f;
                QColor colorOut = QColor(floor(color), floor(color), floor(color));
                depthMap[imageIn.indexAt(i, j)] = colorOut.rgb();
            }
        }
        output.save("images/depthMap.png");
    }

    // write out normal map
    if(DEBUG){
        float maxRed = 0.0f;
        float maxGreen = 0.0f;
        float minRed = 10000.0f;
        float minGreen = 10000.0f;
        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                int index = imageIn.indexAt(i, j);
                float red = normals[index](0);
                if(red > maxRed){
                    maxRed = red;
                }
                if(red < minRed){
                    minRed = red;
                }
                float green = normals[index](1) ;
                if(green > maxGreen){
                    maxGreen = green;
                }
                if(green < minGreen){
                    minGreen = green;
                }
            }
        }
        QImage output(cols, rows, QImage::Format_RGB32);
        QRgb *normalMap = reinterpret_cast<QRgb *>(output.bits());

        for(int i = 0; i < rows; i++){
            for(int j = 0; j < cols; j++){
                int index = mask.indexAt(i, j);
                QColor colorOut = QColor(0,0,0);
                if(QColor(mask.pixelAt(i,j)).red() > 150){
                    float red = (255) * (normals[index](0)  - minRed)/(maxRed - minRed);
                    float green = (255) * (normals[index](1)  - minGreen)/(maxGreen - minGreen);
                    float blue = normals[index](2) * 255.0f;

                    colorOut = QColor(fabs(floor(red)), fabs(floor(green)), floor(blue));
                }
                normalMap[mask.indexAt(i, j)] = colorOut.rgb();
            }
        }
        output.save("images/normalmap.png");
    }
    depthMap = luminances;
    normalMap = normals;
}

std::vector<Vector3f> ShapeEstimation::gradientField(ImageReader mask, std::vector<float> &pixelLuminances, std::vector<float> &gradientX, std::vector<float> &gradientY){
    int rows = mask.getImageHeight();
    int cols = mask.getImageWidth();

    float gxNormalize = 0.0f;
    float gyNormalize = 0.0f;

    for(int row = 0; row < rows; row++){
        for(int col = 0; col < cols; col++){
           int index = mask.indexAt(row, col);
           if(row + 1 < rows){
               int indexUp = mask.indexAt(row + 1, col);
               float dY = pixelLuminances[indexUp] - pixelLuminances[index];
               gradientY.push_back(dY);
               if(fabs(dY) > gyNormalize){
                   gyNormalize = fabs(dY);
               }

           } else {
               gradientY.push_back(0.0f);
           }

           if(col + 1 < cols){
               int indexRight = mask.indexAt(row, col+1);
               float dX = pixelLuminances[indexRight] - pixelLuminances[index];
               gradientX.push_back(dX);
               if(fabs(dX) > gxNormalize){
                   gxNormalize = fabs(dX);
               }
           } else {
               gradientX.push_back(0.0f);
           }

        }
    }
    assert(gradientX.size() == gradientY.size());

    for(int i = 0; i < gradientX.size(); i++){
        gradientX[i] = gradientReshapeRecursive(gradientX[i]/gxNormalize, m_curvature) * gxNormalize;

    }
    for(int i = 0; i < gradientY.size(); i++){
        gradientY[i] = gradientReshapeRecursive(gradientY[i]/gyNormalize, m_curvature) * gyNormalize;
    }

    std::vector<Vector3f> normals;
    for(int i = 0; i < rows; i++){
        for(int j = 0; j < cols; j++){
            QColor maskColor = QColor(mask.pixelAt(i,j));
            if(maskColor.red() > 150){
                Eigen::Vector3f gx = Vector3f(1.0f, 0.0f, gradientX[mask.indexAt(i,j)]);
                Eigen::Vector3f gy = Vector3f(0.0f, 1.0f, gradientY[mask.indexAt(i,j)]);


                Eigen::Vector3f normal = (gx.cross(gy));

                normal = normal.normalized();
                normals.push_back(normal);
            } else {
                normals.push_back(Vector3f(0.0,0.0,0.0));
            }
        }
    }
    //pixelLuminances = gradientX;
    return normals;
}