Author: post
Date: 2012-04-26 20:46:22 +0200 (Thu, 26 Apr 2012)
New Revision: 4204

Modified:
   trunk/plugins/lensfun/lensfun.c
   trunk/src/application.c
   trunk/src/application.h
   trunk/src/rs-photo.c
   trunk/src/rs-preview-widget.c
   trunk/src/rs-toolbox.c
Log:
Separate vignetting/CA correction for A/B/C snapshots. Eliminates a lot of 
special cases and things that doesn't work.

Modified: trunk/plugins/lensfun/lensfun.c
===================================================================
--- trunk/plugins/lensfun/lensfun.c     2012-04-25 19:58:36 UTC (rev 4203)
+++ trunk/plugins/lensfun/lensfun.c     2012-04-26 18:46:22 UTC (rev 4204)
@@ -26,6 +26,7 @@
 #endif /* __SSE2__ */
 #include <rs-lens.h>
 #include "lensfun-version.h"
+#include <math.h>  /* fabsf */
 
 static guint rs_lf_version = 0;
 
@@ -57,6 +58,8 @@
 
        lfLens *selected_lens;
        const lfCamera *selected_camera;
+       gulong settings_signal_id;
+       RSSettings *settings;
 
        gboolean DIRTY;
 };
@@ -76,13 +79,12 @@
        PROP_LENS_MODEL,
        PROP_FOCAL,
        PROP_APERTURE,
-       PROP_TCA_KR,
-       PROP_TCA_KB,
-       PROP_VIGNETTING,
+       PROP_SETTINGS,
        PROP_DISTORTION_ENABLED,
        PROP_DEFISH,
 };
 
+static void settings_weak_notify(gpointer data, GObject *where_the_object_was);
 static void get_property (GObject *object, guint property_id, GValue *value, 
GParamSpec *pspec);
 static void set_property (GObject *object, guint property_id, const GValue 
*value, GParamSpec *pspec);
 static RSFilterResponse *get_image(RSFilter *filter, const RSFilterRequest 
*request);
@@ -103,6 +105,27 @@
 }
 
 static void
+finalize(GObject *object)
+{
+       RSLensfun *lensfun = RS_LENSFUN(object);
+       
+       if (lensfun->settings_signal_id && lensfun->settings)
+       {
+               g_signal_handler_disconnect(lensfun->settings, 
lensfun->settings_signal_id);
+               g_object_weak_unref(G_OBJECT(lensfun->settings), 
settings_weak_notify, lensfun);
+       }
+       lensfun->settings_signal_id = 0;
+       lensfun->settings = NULL;
+       if (lensfun->ldb)
+               lf_db_destroy(lensfun->ldb);
+       lensfun->ldb = NULL;
+       g_free(lensfun->model);
+       g_free(lensfun->make);
+       if (lensfun->lens)
+               g_object_unref(lensfun->lens);
+}
+
+static void
 rs_lensfun_class_init(RSLensfunClass *klass)
 {
        RSFilterClass *filter_class = RS_FILTER_CLASS (klass);
@@ -112,6 +135,7 @@
 
        object_class->get_property = get_property;
        object_class->set_property = set_property;
+       object_class->finalize = finalize;
 
        g_object_class_install_property(object_class,
                PROP_MAKE, g_param_spec_string(
@@ -149,21 +173,6 @@
                        1.0, G_MAXFLOAT, 5.6, G_PARAM_READWRITE)
        );
        g_object_class_install_property(object_class,
-               PROP_TCA_KR, g_param_spec_float(
-                       "tca_kr", "tca_kr", "tca_kr",
-                       -1, 1, 0.0, G_PARAM_READWRITE)
-       );
-       g_object_class_install_property(object_class,
-               PROP_TCA_KB, g_param_spec_float(
-                       "tca_kb", "tca_kb", "tca_kb",
-                       -1, 1, 0.0, G_PARAM_READWRITE)
-       );
-       g_object_class_install_property(object_class,
-               PROP_VIGNETTING, g_param_spec_float(
-                       "vignetting", "vignetting", "vignetting",
-                       -1.5, 1.5, 0.0, G_PARAM_READWRITE)
-       );
-       g_object_class_install_property(object_class,
                PROP_DISTORTION_ENABLED, g_param_spec_boolean(
                        "distortion-enabled", "distortion-enabled", 
"distortion-enabled",
                   FALSE, G_PARAM_READWRITE)
@@ -173,7 +182,11 @@
                        "defish", "defish", "defish",
                   FALSE, G_PARAM_READWRITE)
        );
-       
+       g_object_class_install_property(object_class,
+               PROP_SETTINGS, g_param_spec_object(
+                       "settings", "Settings", "Settings to render from",
+                       RS_TYPE_SETTINGS, G_PARAM_READWRITE)
+       );
        filter_class->name = "Lensfun filter";
        filter_class->get_image = get_image;
 
@@ -195,6 +208,8 @@
        lensfun->vignetting = 0.0;
        lensfun->distortion_enabled = FALSE;
        lensfun->defish = FALSE;
+       lensfun->settings_signal_id = 0;
+       lensfun->settings = NULL;
 
        /* Initialize Lensfun database */
        lensfun->ldb = lf_db_new ();
@@ -208,6 +223,9 @@
 
        switch (property_id)
        {
+               case PROP_SETTINGS:
+                       g_value_set_object(value, lensfun->settings);
+                       break;
                case PROP_MAKE:
                        g_value_set_string(value, lensfun->make);
                        break;
@@ -229,15 +247,6 @@
                case PROP_APERTURE:
                        g_value_set_float(value, lensfun->aperture);
                        break;
-               case PROP_TCA_KR:
-                       g_value_set_float(value, lensfun->tca_kr);
-                       break;
-               case PROP_TCA_KB:
-                       g_value_set_float(value, lensfun->tca_kb);
-                       break;
-               case PROP_VIGNETTING:
-                       g_value_set_float(value, lensfun->vignetting);
-                       break;
                case PROP_DISTORTION_ENABLED:
                        g_value_set_boolean(value, lensfun->distortion_enabled);
                        break;
@@ -249,13 +258,60 @@
        }
 }
 
+static gboolean
+float_closeto(gfloat a, gfloat b, gfloat maxdiff)
+{
+       return (fabsf(a-b) < maxdiff);
+}
+
 static void
+settings_weak_notify(gpointer data, GObject *where_the_object_was)
+{
+       RSLensfun *lensfun = RS_LENSFUN(data);
+       lensfun->settings = NULL;
+}
+
+static void
+settings_changed(RSSettings *settings, RSSettingsMask mask, RSLensfun *lensfun)
+{
+       if (NULL == settings || NULL == lensfun)
+               return;
+
+       gboolean changed = ! (float_closeto(settings->tca_kb, 
lensfun->tca_kb,0.001f) && 
+       float_closeto(settings->tca_kr, lensfun->tca_kr,0.001f) && 
+       float_closeto(settings->vignetting, lensfun->vignetting,0.001f));
+       if (changed)
+       {
+               lensfun->tca_kb = settings->tca_kb;
+               lensfun->tca_kr = settings->tca_kr;
+               lensfun->vignetting = settings->vignetting;
+               rs_filter_changed(RS_FILTER(lensfun), 
RS_FILTER_CHANGED_PIXELDATA);
+       }
+}
+
+static void
 set_property(GObject *object, guint property_id, const GValue *value, 
GParamSpec *pspec)
 {
        RSLensfun *lensfun = RS_LENSFUN(object);
 
        switch (property_id)
        {
+               case PROP_SETTINGS:
+                       if (lensfun->settings && lensfun->settings_signal_id)
+                       {
+                               if (lensfun->settings == 
g_value_get_object(value))
+                               {
+                                       settings_changed(lensfun->settings, 
MASK_VIGNETTING|MASK_TCA, lensfun);
+                                       break;
+                               }
+                               g_signal_handler_disconnect(lensfun->settings, 
lensfun->settings_signal_id);
+                               
g_object_weak_unref(G_OBJECT(lensfun->settings), settings_weak_notify, lensfun);
+                       }
+                       lensfun->settings = g_value_get_object(value);
+                       lensfun->settings_signal_id = 
g_signal_connect(lensfun->settings, "settings-changed", 
G_CALLBACK(settings_changed), lensfun);
+                       settings_changed(lensfun->settings, 
MASK_VIGNETTING|MASK_TCA, lensfun);
+                       g_object_weak_ref(G_OBJECT(lensfun->settings), 
settings_weak_notify, lensfun);
+                       break;
                case PROP_MAKE:
                        g_free(lensfun->make);
                        lensfun->make = g_value_dup_string(value);
@@ -278,18 +334,6 @@
                case PROP_APERTURE:
                        lensfun->aperture = g_value_get_float(value);
                        break;
-               case PROP_TCA_KR:
-                       lensfun->tca_kr = g_value_get_float(value);
-                       rs_filter_changed(RS_FILTER(lensfun), 
RS_FILTER_CHANGED_PIXELDATA);
-                       break;
-               case PROP_TCA_KB:
-                       lensfun->tca_kb = g_value_get_float(value);
-                       rs_filter_changed(RS_FILTER(lensfun), 
RS_FILTER_CHANGED_PIXELDATA);
-                       break;
-               case PROP_VIGNETTING:
-                       lensfun->vignetting = g_value_get_float(value);
-                       rs_filter_changed(RS_FILTER(lensfun), 
RS_FILTER_CHANGED_PIXELDATA);
-                       break;
                case PROP_DISTORTION_ENABLED:
                        lensfun->DIRTY = TRUE;
                        lensfun->distortion_enabled = 
g_value_get_boolean(value);

Modified: trunk/src/application.c
===================================================================
--- trunk/src/application.c     2012-04-25 19:58:36 UTC (rev 4203)
+++ trunk/src/application.c     2012-04-26 18:46:22 UTC (rev 4204)
@@ -57,7 +57,6 @@
 #include "rs-profile-factory-model.h"
 #include "rs-profile-camera.h"
 
-static void photo_spatial_changed(RS_PHOTO *photo, RS_BLOB *rs);
 static void photo_profile_changed(RS_PHOTO *photo, gpointer profile, RS_BLOB 
*rs);
 
 void
@@ -88,27 +87,11 @@
                        "image", rs->photo->input_response,
                        "filename", rs->photo->filename,
                        NULL);
-
-               g_signal_connect(G_OBJECT(rs->photo), "spatial-changed", 
G_CALLBACK(photo_spatial_changed), rs);
-               g_signal_connect(G_OBJECT(rs->photo), "profile-changed", 
G_CALLBACK(photo_profile_changed), rs);
        }
+       g_signal_connect(G_OBJECT(rs->photo), "profile-changed", 
G_CALLBACK(photo_profile_changed), rs);
 }
 
-static void
-photo_spatial_changed(RS_PHOTO *photo, RS_BLOB *rs)
-{
-       if (photo == rs->photo)
-       {
-               /* Update crop and rotate filters */
-               rs_filter_set_recursive(rs->filter_end,
-                       "rectangle", rs_photo_get_crop(photo),
-                       "angle", rs_photo_get_angle(photo),
-                       "orientation", rs->photo->orientation,
-                       NULL);
-       }
 
-}
-
 static void
 photo_profile_changed(RS_PHOTO *photo, gpointer profile, RS_BLOB *rs)
 {
@@ -222,8 +205,6 @@
 RS_BLOB *
 rs_new(void)
 {
-       RSFilter *cache;
-
        RS_BLOB *rs;
        rs = g_malloc(sizeof(RS_BLOB));
        rs->settings_buffer = NULL;
@@ -241,13 +222,8 @@
        /* We need this for 100% zoom */
        g_object_set(rs->filter_demosaic_cache, "ignore-roi", TRUE, NULL);
 
-       rs->filter_lensfun = rs_filter_new("RSLensfun", 
rs->filter_demosaic_cache);
-       rs->filter_rotate = rs_filter_new("RSRotate", rs->filter_lensfun);
-       rs->filter_crop = rs_filter_new("RSCrop", rs->filter_rotate);
-       cache = rs_filter_new("RSCache", rs->filter_crop);
-
        rs_filter_set_recursive(rs->filter_input, "color-space", 
rs_color_space_new_singleton("RSProphoto"), NULL);
-       rs->filter_end = cache;
+       rs->filter_end = rs->filter_demosaic_cache;
 
        return(rs);
 }

Modified: trunk/src/application.h
===================================================================
--- trunk/src/application.h     2012-04-25 19:58:36 UTC (rev 4203)
+++ trunk/src/application.h     2012-04-26 18:46:22 UTC (rev 4204)
@@ -93,9 +93,6 @@
        RSFilter *filter_demosaic;
        RSFilter *filter_fuji_rotate;
        RSFilter *filter_demosaic_cache;
-       RSFilter *filter_lensfun;
-       RSFilter *filter_rotate;
-       RSFilter *filter_crop;
        RSFilter *filter_end;
 } RS_BLOB;
 

Modified: trunk/src/rs-photo.c
===================================================================
--- trunk/src/rs-photo.c        2012-04-25 19:58:36 UTC (rev 4203)
+++ trunk/src/rs-photo.c        2012-04-26 18:46:22 UTC (rev 4204)
@@ -432,9 +432,6 @@
                                "lens", lens,
                                "focal", (gfloat) meta->focallength,
                                "aperture", meta->aperture,
-                               "tca_kr", photo->settings[0]->tca_kr,
-                               "tca_kb", photo->settings[0]->tca_kb,
-                               "vignetting", photo->settings[0]->vignetting,
                                NULL);
                        g_object_unref(lens);
                }

Modified: trunk/src/rs-preview-widget.c
===================================================================
--- trunk/src/rs-preview-widget.c       2012-04-25 19:58:36 UTC (rev 4203)
+++ trunk/src/rs-preview-widget.c       2012-04-26 18:46:22 UTC (rev 4204)
@@ -166,6 +166,10 @@
        gfloat straighten_angle;
        RSFilter *filter_input;
 
+       RSFilter *filter_lensfun[MAX_VIEWS];
+       RSFilter *filter_rotate[MAX_VIEWS];
+       RSFilter *filter_crop[MAX_VIEWS];
+       RSFilter *filter_cache0[MAX_VIEWS];
        RSFilter *filter_resample[MAX_VIEWS];
        RSFilter *filter_cache1[MAX_VIEWS];
        RSFilter *filter_denoise[MAX_VIEWS];
@@ -176,7 +180,6 @@
        RSFilter *filter_mask[MAX_VIEWS];
        RSFilter *filter_cache3[MAX_VIEWS];
        RSFilter *filter_end[MAX_VIEWS]; /* For convenience */
-       RSFilter *filter_lensfun[MAX_VIEWS];
 
        RSFilterRequest *request[MAX_VIEWS];
        GdkRectangle *last_roi[MAX_VIEWS];
@@ -268,6 +271,7 @@
 static gpointer render_thread_func(gpointer _thread_info);
 static void rs_preview_do_render(RSPreviewWidget *preview, GdkRectangle 
*dirty_area);
 static void rs_preview_wait_for_render(RSPreviewWidget *preview);
+static void photo_spatial_changed(RS_PHOTO *photo, RSPreviewWidget *preview);
 /**
  * Class initializer
  */
@@ -401,7 +405,11 @@
        preview->filter_input = NULL;
        for(i=0;i<MAX_VIEWS;i++)
        {
-               preview->filter_resample[i] = rs_filter_new("RSResample", NULL);
+               preview->filter_lensfun[i] = rs_filter_new("RSLensfun", NULL);
+               preview->filter_rotate[i] = rs_filter_new("RSRotate", 
preview->filter_lensfun[i]);
+               preview->filter_crop[i] = rs_filter_new("RSCrop", 
preview->filter_rotate[i]);
+               preview->filter_cache0[i] = rs_filter_new("RSCache", 
preview->filter_crop[i]);
+               preview->filter_resample[i] = rs_filter_new("RSResample", 
preview->filter_cache0[i]);
                /* Careful - "make_cbdata" grabs data from "filter_cache1" */
                preview->filter_cache1[i] = rs_filter_new("RSCache", 
preview->filter_resample[i]);
                preview->filter_transform_input[i] = 
rs_filter_new("RSColorspaceTransform", preview->filter_cache1[i]);
@@ -493,6 +501,24 @@
        return widget;
 }
 
+static void
+photo_spatial_changed(RS_PHOTO *photo, RSPreviewWidget *preview)
+{
+       if (photo == preview->photo)
+       {
+               int i;
+               /* Update crop and rotate filters */
+               for(i=0;i<MAX_VIEWS;i++)
+               {
+                       rs_filter_set_recursive(preview->filter_end[i],
+                               "rectangle", rs_photo_get_crop(photo),
+                               "angle", rs_photo_get_angle(photo),
+                               "orientation", photo->orientation,
+                               NULL);
+               }
+       }
+}
+
 extern void
 rs_preview_widget_lock_renderer(RSPreviewWidget *preview)
 {
@@ -732,6 +758,7 @@
                photo->thumbnail_filter = preview->navigator_filter_end;
                g_signal_connect(G_OBJECT(preview->photo), "lens-changed", 
G_CALLBACK(lens_changed), preview);
                g_signal_connect(G_OBJECT(preview->photo), "profile-changed", 
G_CALLBACK(profile_changed), preview);
+               g_signal_connect(G_OBJECT(preview->photo), "spatial-changed", 
G_CALLBACK(photo_spatial_changed), preview);
        }
 }
 
@@ -803,8 +830,8 @@
 
        preview->filter_input = filter;
        rs_filter_set_recursive(RS_FILTER(preview->filter_input), 
"demosaic-allow-downscale",  preview->zoom_to_fit, NULL);
-       rs_filter_set_previous(preview->filter_resample[0], 
preview->filter_input);
-       rs_filter_set_previous(preview->filter_resample[1], 
preview->filter_input);
+       rs_filter_set_previous(preview->filter_lensfun[0], 
preview->filter_input);
+       rs_filter_set_previous(preview->filter_lensfun[1], 
preview->filter_input);
        if (fast_filter)
        {
                g_assert(RS_IS_FILTER(fast_filter));
@@ -2163,21 +2190,6 @@
                if (preview->snapshot[view] == snapshot)
                {
                        DIRTY(preview->dirty[view], SCREEN);
-                       if (mask & MASK_TCA || mask & MASK_VIGNETTING)
-                       {
-                               gfloat tca_kr = 0.0;
-                               gfloat tca_kb = 0.0;
-                               gfloat vignetting = 0.0;
-                               
g_object_get(preview->photo->settings[preview->snapshot[view]], "tca_kr", 
&tca_kr, NULL);
-                               
g_object_get(preview->photo->settings[preview->snapshot[view]], "tca_kb", 
&tca_kb, NULL);
-                               
g_object_get(preview->photo->settings[preview->snapshot[view]], "vignetting", 
&vignetting, NULL);
-
-                               
rs_filter_set_recursive(preview->filter_end[view],
-                                                       "tca_kr", tca_kr,
-                                                       "tca_kb", tca_kb,
-                                                       "vignetting", 
vignetting,
-                                                       NULL);
-                       }
                }
        }
 }

Modified: trunk/src/rs-toolbox.c
===================================================================
--- trunk/src/rs-toolbox.c      2012-04-25 19:58:36 UTC (rev 4203)
+++ trunk/src/rs-toolbox.c      2012-04-26 18:46:22 UTC (rev 4204)
@@ -305,10 +305,7 @@
                gint snapshot = 
GPOINTER_TO_INT(g_object_get_data(G_OBJECT(range), "rs-snapshot"));
                gfloat value = gtk_range_get_value(range);
                BasicSettings *basic = g_object_get_data(G_OBJECT(range), 
"rs-basic");
-               if (snapshot != 0  && (basic->mask & (MASK_TCA_KR | MASK_TCA_KB 
| MASK_VIGNETTING)) != 0)
-                       return;
-               else
-                       g_object_set(toolbox->photo->settings[snapshot], 
basic->property_name, value, NULL);
+               g_object_set(toolbox->photo->settings[snapshot], 
basic->property_name, value, NULL);
        }
 
        if (toolbox->photo)
@@ -353,9 +350,6 @@
                }
                else
                        
rs_object_class_property_reset(G_OBJECT(toolbox->photo->settings[snapshot]), 
basic->property_name);
-
-               if (snapshot != 0 && (mask & (MASK_TCA_KR | MASK_TCA_KB 
|MASK_VIGNETTING)) != 0)
-                       rs_settings_copy(s[snapshot], mask, 
toolbox->photo->settings[0]);
        }
 
 
@@ -1014,9 +1008,6 @@
                                gfloat value;
                                
g_object_get(toolbox->photo->settings[snapshot], lens[i].property_name, &value, 
NULL);
                                gtk_range_set_value(toolbox->lens[snapshot][i], 
value);
-                               /* NOTICE: This disables sliders on B+C pages */
-                               if (snapshot != 0)
-                                       
gtk_widget_set_sensitive(GTK_WIDGET(toolbox->lens[snapshot][i]), FALSE);
                        }
 
                /* Update curve */


_______________________________________________
Rawstudio-commit mailing list
[email protected]
http://rawstudio.org/cgi-bin/mailman/listinfo/rawstudio-commit

Reply via email to