[Custom CLI] For adjusting exposure (C++)

edcoreweb · July 4, 2019, 8:12pm

Hi all,

I have a custom workflow where I need to automate 2 tasks:

apply white balance from a spot (x, y coords)
tweak the exposure compensation until I get to a specific L value (Lab)

So far I managed to apply the white balance from a spot, and retrieve the L value from the same spot, but I get really big values for L (I am expecting 2 digit number and I get 4 digit numbers, Eg: expecting 64, and get 6300)

What am I doing wrong ?

Here I apply the white balance:

github.com

edcoreweb/rawtherapee-cli/blob/a04a6ff2700a9c31d4558decd9d1080a6d74763f/cli.cc#L189

    
      
          {
              std::cout << p << std::endl;
          }
          
          
void setProgressState(bool inProcessing)
          {
              std::cout << inProcessing << std::endl;
              // get the white balance from one spot
              if (inProcessing == false)
              {
                  double temp, green;
                  ipc->getSpotWB(2370, 1740, 8, temp, green);
          
          
        std::cout << "temp:" << temp << "|green:" << green<< std::endl;
                  
                  saveImage(temp, green);
              }
          }
          
          
void error(const Glib::ustring& descr)
          {

Here I get the L value from the processed image (from RGB)

github.com

edcoreweb/rawtherapee-cli/blob/a04a6ff2700a9c31d4558decd9d1080a6d74763f/cli.cc#L158

    
      
              // rtengine::Imagefloat* src = new rtengine::Imagefloat(res->getWidth(), res->getHeight());
              // res->copyData(src);
          
          
    // rtengine::ImProcFunctions* ipf = new rtengine::ImProcFunctions(&params);
              // ipf->rgb2lab(*src, *lab, params.icm.workingProfile);
          
          
    // float L, a, b;
              // lab->getPipetteData(L, a, b, 2370, 1740, 8);
              // std::cout << L << ", " << a << ", " << b << std::endl;
          
          
    float LAB_a, LAB_b;
              rtengine::Color::rgb2lab01(params.icm.outputProfile, params.icm.workingProfile, r / 255.f, g / 255.f, bl / 255.f, LAB_l, LAB_a, LAB_b, options.rtSettings.HistogramWorking);
              std::cout << LAB_l << ", " << LAB_a << ", " << LAB_b << std::endl;
              
              float increment = LAB_l < minL ? .1f : -(.1f);
              params.toneCurve.expcomp += increment;
              // delete job;
              // delete res;
          
          
} while (LAB_l < minL || LAB_l > maxL);

Any suggestions are welcome, I did not write C++ since college so if you spot some things which can be done better please let me know

The repo is public

I tested and built on linux in a docker container.

There’s an example photo in the input folder, which is mounted in the docker container.

I overwrote the main-cli.cc file, as I am not confident enough to mess with the CMake files

The cli.cc file is mounted over the original main-cli.cc

To build it you need docker and docker compose:

clone the repo,
run docker-compose build
run docker-compose run app
run ./programs/rawtherapee/rawtherapee-cli ./input/IMG_0416.CR2 ./input/out.jpg

Thanatomanic · July 5, 2019, 5:06pm

Ping @heckflosse or @floessie

heckflosse · July 5, 2019, 5:30pm

@edcoreweb Can you post the console output please?

edcoreweb · July 5, 2019, 5:45pm

@heckflosse, sure please find the output below!

heckflosse · July 5, 2019, 6:52pm

divide by 65535 instead of 255

edcoreweb · July 5, 2019, 7:14pm

@heckflosse works like a charm, thanks a lot!

Everytime I change the exposure, I create a processing job and process the image. I have a hunch that this is not that efficient and very slow

github.com

edcoreweb/rawtherapee-cli/blob/a04a6ff2700a9c31d4558decd9d1080a6d74763f/cli.cc#L136

    
      
          
          
rtengine::IImagefloat* res = nullptr;
          rtengine::ProcessingJob* job = nullptr;
          float LAB_l;
          int minL = 7500;
          int maxL = 7600;
          
          

          
do {
              // create a processing job with the loaded image and the current processing parameters
              job = rtengine::ProcessingJob::create (image, params);
          
          
    // process image. The error is given back in errorcode.
              int errorCode;
              res = rtengine::processImage (job, errorCode, nullptr);
          
          

          
    float r, g, bl;
              res->getPipetteData(r, g, bl, 2370, 1740, 8, 0);
              std::cout << r / 255.f << ", " << g / 255.f << ", " << bl / 255.f << std::endl;

Is there a way to optimize this somehow, only to apply the exposure and not run all the processing pipeline again and again ?

heckflosse · July 5, 2019, 7:30pm

@edcoreweb Please explain in clear words what you want to do. I currently didn’t get it (maybe because my brain isn’t working fully at the current high temperature here in germany…)
So please, try to explain it more simple. I’m sure there’s a better way, once I understood what you want to do.

edcoreweb · July 5, 2019, 7:40pm

@heckflosse sorry I was not clear enough, basically I need to adjust the exposure compensation until a ‘hard-coded’ point on the image reaches LAB (L = 79).

heckflosse · July 5, 2019, 8:09pm

So, you have a reference point in our image which needs to be Lab L value 79?

edcoreweb · July 5, 2019, 8:26pm

Exactly.

edcoreweb · July 8, 2019, 10:47am

@heckflosse

My biggest problem is that, to get the RGB data of a point I need do have a processed image.

github.com

edcoreweb/rawtherapee-cli/blob/f4b94b8e3c7de68877d6cb61a41841531dd32d03/cli.cc#L121

    
      
              return rawParams;
          }
          
          
rtengine::IImagefloat* adjustExposure(const rtengine::procparams::ProcParams &params, float &LAB_l)
          {
              // create a processing job with the loaded image and the current processing parameters
              rtengine::ProcessingJob* job = rtengine::ProcessingJob::create (image, params);
          
          
    // process image. The error is given back in errorcode.
              int errorCode;
              rtengine::IImagefloat* res = rtengine::processImage (job, errorCode, nullptr);
          
          
    float r, g, bl;
              res->getPipetteData(r, g, bl, 2370, 1740, 8, 0);
          
          
    float LAB_a, LAB_b;
              rtengine::Color::rgb2lab01(params.icm.outputProfile, params.icm.workingProfile, r / 65535.f, g / 65535.f, bl / 65535.f, LAB_l, LAB_a, LAB_b, options.rtSettings.HistogramWorking);
              std::cout << LAB_l << ", " << LAB_a << ", " << LAB_b << std::endl;
          
          
    return res;
          }

From my testing this is takes the longest.
An optimization I found is to crop the image 100 X 100 around the point I need to test.

But, there needs to be a better way to do this, without calling processImage every time.

My question:
Is there any way to get RGB from a point without calling processImage ?
Maybe only using the rtengine::StagedImageProcessor class ?

edcoreweb · July 12, 2019, 8:32am

@heckflosse

Found a solution, not sure it’s the best, but basically I attach a Crop to the StagedImageProcessor and only apply the RGBCURVE bit mask when I change the exposure.

Thanks for your help, I owe you a beer.