Parallel-Programming_CUDA/loadSaveImage.h at main · Berserker312112/Parallel-Programming_CUDA · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/opencv.hpp>
#include <vector>
#include <stdio.h>
#include "cuda_runtime.h"

//The caller becomes responsible for the returned pointer. This
//is done in the interest of keeping this code as simple as possible.
//In production code this is a bad idea - we should use RAII
//to ensure the memory is freed.  DO NOT COPY THIS AND USE IN PRODUCTION
//CODE!!!
void loadImageHDR(const std::string &filename,
                  float **imagePtr,
                  size_t *numRows, size_t *numCols)
{
    cv::Mat originImg = cv::imread(filename.c_str(), CV_LOAD_IMAGE_COLOR | CV_LOAD_IMAGE_ANYDEPTH);

    cv::Mat image;

    if(originImg.type() != CV_32FC3){
      originImg.convertTo(image,CV_32FC3);
    } else{
      image = originImg;
    }

  if (image.empty()) {
    std::cerr << "Couldn't open file: " << filename << std::endl;
    exit(1);
  }

  if (image.channels() != 3) {
    std::cerr << "Image must be color!" << std::endl;
    exit(1);
  }

  if (!image.isContinuous()) {
    std::cerr << "Image isn't continuous!" << std::endl;
    exit(1);
  }

  *imagePtr = new float[image.rows * image.cols * image.channels()];

  float *cvPtr = image.ptr<float>(0);
  for (size_t i = 0; i < image.rows * image.cols * image.channels(); ++i)
    (*imagePtr)[i] = cvPtr[i];

  *numRows = image.rows;
  *numCols = image.cols;
}

void loadImageRGBA(const std::string &filename,
                   uchar4 **imagePtr,
                   size_t *numRows, size_t *numCols)
{
  cv::Mat image = cv::imread(filename.c_str(), CV_LOAD_IMAGE_COLOR);
  if (image.empty()) {
    std::cerr << "Couldn't open file: " << filename << std::endl;
    exit(1);
  }

  if (image.channels() != 3) {
    std::cerr << "Image must be color!" << std::endl;
    exit(1);
  }

  if (!image.isContinuous()) {
    std::cerr << "Image isn't continuous!" << std::endl;
    exit(1);
  }

  cv::Mat imageRGBA;
  cv::cvtColor(image, imageRGBA, CV_BGR2RGBA);

  *imagePtr = new uchar4[image.rows * image.cols];

  unsigned char *cvPtr = imageRGBA.ptr<unsigned char>(0);
  for (size_t i = 0; i < image.rows * image.cols; ++i) {
    (*imagePtr)[i].x = cvPtr[4 * i + 0];
    (*imagePtr)[i].y = cvPtr[4 * i + 1];
    (*imagePtr)[i].z = cvPtr[4 * i + 2];
    (*imagePtr)[i].w = cvPtr[4 * i + 3];
  }

  *numRows = image.rows;
  *numCols = image.cols;
}

void saveImageRGBA(const uchar4* const image,
                   const size_t numRows, const size_t numCols,
                   const std::string &output_file)
{
  int sizes[2];
  sizes[0] = numRows;
  sizes[1] = numCols;
  cv::Mat imageRGBA(2, sizes, CV_8UC4, (void *)image);
  cv::Mat imageOutputBGR;
  cv::cvtColor(imageRGBA, imageOutputBGR, CV_RGBA2BGR);
  //output the image
  cv::imwrite(output_file.c_str(), imageOutputBGR);
}

//output an exr file
//assumed to already be BGR
void saveImageHDR(const float* const image,
                  const size_t numRows, const size_t numCols,
                  const std::string &output_file)
{
  int sizes[2];
  sizes[0] = numRows;
  sizes[1] = numCols;

  cv::Mat imageHDR(2, sizes, CV_32FC3, (void *)image);

  imageHDR = imageHDR * 255;

  cv::imwrite(output_file.c_str(), imageHDR);
}