started working on support for dynamic processing profiles

rtgui/dynamicprofile.cc

@@ -0,0 +1,180 @@
+/* -*- C++ -*-
+ *  This file is part of RawTherapee.
+ *
+ *  Copyright (c) 2017 Alberto Griggio
+ *
+ *  RawTherapee is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  RawTherapee is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with RawTherapee.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dynamicprofile.h"
+#include <stdlib.h>
+
+using namespace rtengine;
+using namespace rtengine::procparams;
+
+DynamicProfileEntry::DynamicProfileEntry():
+    serial_number(0),
+    has_iso(false), iso_min(0), iso_max(1000000),
+    has_fnumber(false), fnumber_min(0.0), fnumber_max(1000.0),
+    has_focallen(false), focallen_min(0.0), focallen_max(1000000.0),
+    has_shutterspeed(false), shutterspeed_min(1000.0), shutterspeed_max(1.0/1000000.0),
+    has_expcomp(false), expcomp_min(-100.0), expcomp_max(100.0),
+    has_make(false), make(""),
+    has_model(false), model(""),
+    has_lens(false), lens(""),
+    profilepath("")
+{
+}
+
+
+bool DynamicProfileEntry::operator<(const DynamicProfileEntry &other) const
+{
+    return serial_number < other.serial_number;
+}
+
+
+bool DynamicProfileEntry::matches(const rtengine::ImageMetaData *im)
+{
+    if (has_iso) {
+        int iso = im->getISOSpeed();
+        if (iso < iso_min || iso > iso_max) {
+            return false;
+        }
+    }
+    if (has_fnumber) {
+        double fnumber = im->getFNumber();
+        if (fnumber < fnumber_min || fnumber > fnumber_max) {
+            return false;
+        }
+    }
+    if (has_focallen) {
+        double focallen = im->getFocalLen();
+        if (focallen < focallen_min || focallen > focallen_max) {
+            return false;
+        }
+    }
+    if (has_shutterspeed) {
+        double shutterspeed = im->getShutterSpeed();
+        if (shutterspeed < shutterspeed_min || shutterspeed > shutterspeed_max){
+            return false;
+        }
+    }
+    if (has_expcomp) {
+        double expcomp = im->getExpComp();
+        if (expcomp < expcomp_min || expcomp > expcomp_max) {
+            return false;
+        }
+    }
+    if (has_make) {
+        if (im->getMake() != make) {
+            return false;
+        }
+    }
+    if (has_model) {
+        if (im->getModel() != model) {
+            return false;
+        }
+    }
+    if (has_lens) {
+        if (im->getLens() != lens) {
+            return false;
+        }
+    }
+    return true;
+}
+
+
+bool loadDynamicProfileEntries(std::vector<DynamicProfileEntry> &out)
+{
+    out.clear();
+    Glib::KeyFile kf;
+    if (!kf.load_from_file(
+            Glib::build_filename(Options::rtdir, "dynamicprofile.cfg"))) {
+        return false;
+    }
+    printf("loading dynamic profiles...\n");
+    auto groups = kf.get_groups();
+    for (auto group : groups) {
+        // groups are of the form "entry N", where N is a positive integer
+        if (group.find("entry ") != 0) {
+            return false;
+        }
+        std::istringstream buf(group.c_str() + 6);
+        int serial = 0;
+        if (!(buf >> serial) || !buf.eof()) {
+            return false;
+        }
+        printf(" loading entry %d\n", serial);
+        
+        out.emplace_back(DynamicProfileEntry());
+        DynamicProfileEntry &entry = out.back();
+        entry.serial_number = serial;
+        entry.has_iso = kf.get_boolean(group, "has_iso");
+        entry.iso_min = kf.get_integer(group, "iso_min");
+        entry.iso_max = kf.get_integer(group, "iso_max");
+
+        entry.has_fnumber = kf.get_boolean(group, "has_fnumber");
+        entry.fnumber_min = kf.get_double(group, "fnumber_min");
+        entry.fnumber_max = kf.get_double(group, "fnumber_max");
+
+        entry.has_focallen = kf.get_boolean(group, "has_focallen");
+        entry.focallen_min = kf.get_double(group, "focallen_min");
+        entry.focallen_max = kf.get_double(group, "focallen_max");
+
+        entry.has_shutterspeed = kf.get_boolean(group, "has_shutterspeed");
+        entry.shutterspeed_min = kf.get_double(group, "shutterspeed_min");
+        entry.shutterspeed_max = kf.get_double(group, "shutterspeed_max");
+
+        entry.has_expcomp = kf.get_boolean(group, "has_expcomp");
+        entry.expcomp_min = kf.get_double(group, "expcomp_min");
+        entry.expcomp_max = kf.get_double(group, "expcomp_max");
+
+        entry.has_make = kf.get_boolean(group, "has_make");
+        entry.make = kf.get_string(group, "make");
+
+        entry.has_model = kf.get_boolean(group, "has_model");
+        entry.model = kf.get_string(group, "model");
+
+        entry.has_lens = kf.get_boolean(group, "has_lens");
+        entry.lens = kf.get_string(group, "lens");
+
+        entry.profilepath = kf.get_string(group, "profilepath");
+    }
+    std::sort(out.begin(), out.end());
+    return true;
+}
+
+
+PartialProfile *loadDynamicProfile(const ImageMetaData *im)
+{
+    PartialProfile *ret = new PartialProfile(true, true);
+    std::vector<DynamicProfileEntry> entries;
+    if (loadDynamicProfileEntries(entries)) {
+        for (auto &entry : entries) {
+            if (entry.matches(im)) {
+                printf("found matching profile %s\n",
+                       entry.profilepath.c_str());
+                PartialProfile p(true, true);
+                if (!p.load(options.findProfilePath(entry.profilepath))) {
+                    p.applyTo(ret->pparams);
+                } else {
+                    printf("ERROR loading matching profile\n");
+                }
+                p.deleteInstance();
+            }
+        }
+    }
+    return ret;
+}
+