void fft_apply(PluginData *pd)
{
int w = pd->image_width, h = pd->image_height,
pw = w/2+1; // physical width
fftwf_complex *multiplied = (fftwf_complex*) fftwf_malloc(sizeof(fftwf_complex) * pw * h);
float diagonal = sqrt(h*h + w*w)/2.0;
// save current state of the curve
curve_copy(&pd->curve_user, &pd->curve_fft);
for(int channel=0; channel < pd->channel_count; channel++)
{
//skip DC value
multiplied[0][0] = pd->image_freq[channel][0][0];
multiplied[0][1] = pd->image_freq[channel][0][1];
// apply convolution
for (int i=1; i < pw*h; i++){
float dist = index_to_dist(i, pw, h);
float coef = curve_get_value(dist_to_graph(dist), &pd->curve_fft);
multiplied[i][0] = pd->image_freq[channel][i][0] * coef;
multiplied[i][1] = pd->image_freq[channel][i][1] * coef;
}
// apply inverse FFT
fftwf_execute_dft_c2r(pd->plan, multiplied, pd->image[channel]);
// pack results for GIMP
for(int x=0; x < w; x ++)
{
for(int y=0; y < h; y ++)
{
float v = pd->image[channel][y*w + x];
pd->img_pixels[(y*w + x)*pd->channel_count + channel] = CLAMPED(v,0,255);
}
}
}
fftwf_free(multiplied);
}
//===========================================================================
vector<shared_ptr<SplineCurve> >
LoftSurfaceCreator::unifiedCurvesCopy(vector<shared_ptr<SplineCurve> >::iterator
first_curve,
int nmb_crvs)
//===========================================================================
{
bool rational = false;
for (int i = 0; i < nmb_crvs; ++i)
if (first_curve[i]->rational())
rational = true;
// Create the copies
vector<shared_ptr<SplineCurve> > unified_curves;
for (int i = 0; i < nmb_crvs; ++i)
{
shared_ptr<SplineCurve> curve_copy(first_curve[i]->clone());
if (rational)
curve_copy->representAsRational();
unified_curves.push_back(curve_copy);
}
// Reparametrize, to have the B-spline spaces living on the same intervals
double
avg_start = 0.0,
avg_end = 0.0;
for (int i = 0; i < nmb_crvs; ++i)
{
avg_start += unified_curves[i]->startparam();
avg_end += unified_curves[i]->endparam();
}
avg_start /= double(nmb_crvs);
avg_end /= double(nmb_crvs);
for (int i = 0; i < nmb_crvs; ++i)
unified_curves[i]->setParameterInterval(avg_start, avg_end);
// Put the curves into common basis.
double tolerance = 1e-05;
GeometryTools::unifyCurveSplineSpace(unified_curves, tolerance);
return unified_curves;
}
/****************
* To verify correct skey it use a random information.
* First, encrypt and decrypt this dummy value,
* test if the information is recuperated.
* Second, test with the sign and verify functions.
*/
static void
test_keys (ECC_secret_key *sk, unsigned int nbits)
{
ECC_public_key pk;
gcry_mpi_t test = mpi_new (nbits);
mpi_point_t R_;
gcry_mpi_t c = mpi_new (nbits);
gcry_mpi_t out = mpi_new (nbits);
gcry_mpi_t r = mpi_new (nbits);
gcry_mpi_t s = mpi_new (nbits);
if (DBG_CIPHER)
log_debug ("Testing key.\n");
point_init (&R_);
pk.E = curve_copy (sk->E);
point_init (&pk.Q);
point_set (&pk.Q, &sk->Q);
gcry_mpi_randomize (test, nbits, GCRY_WEAK_RANDOM);
if (sign (test, sk, r, s) )
log_fatal ("ECDSA operation: sign failed\n");
if (verify (test, &pk, r, s))
{
log_fatal ("ECDSA operation: sign, verify failed\n");
}
if (DBG_CIPHER)
log_debug ("ECDSA operation: sign, verify ok.\n");
point_free (&pk.Q);
curve_free (&pk.E);
point_free (&R_);
mpi_free (s);
mpi_free (r);
mpi_free (out);
mpi_free (c);
mpi_free (test);
}
// Create and handle the plugin's dialog
gboolean dialog(PluginData *pd)
{
gimp_ui_init (PLUG_IN_BINARY, FALSE);
GtkWidget *dialog, *main_hbox, *hbox_buttons, *preview, *graph, *vbox, *preview_button, *preview_hd_checkbox;
dialog = gimp_dialog_new ("Frequency Curves", PLUG_IN_BINARY,
NULL, (GtkDialogFlags)0,
gimp_standard_help_func, PLUG_IN_NAME,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
main_hbox = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (main_hbox), 12);
gtk_container_add (GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), main_hbox);
curve_init(&pd->curve_user);
curve_copy(&pd->curve_user, &pd->curve_fft);
pd->preview = gimp_drawable_preview_new (pd->drawable, 0);
gtk_box_pack_start (GTK_BOX (main_hbox), pd->preview, TRUE, TRUE, 0);
gtk_widget_show (pd->preview);
g_signal_connect_swapped (pd->preview, "invalidated", G_CALLBACK (preview_invalidated), pd);
vbox = gtk_vbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
gtk_container_add (GTK_CONTAINER(main_hbox), vbox);
gtk_widget_show(vbox);
graph = pd->graph = gtk_drawing_area_new();
pd->graph_pixmap = NULL;
gtk_widget_set_size_request (graph, GRAPH_WIDTH, GRAPH_HEIGHT);
gtk_widget_set_events (graph, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK | GDK_ENTER_NOTIFY_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON1_MOTION_MASK);
gtk_container_add (GTK_CONTAINER (vbox), graph);
gtk_widget_show (graph);
g_signal_connect (graph, "event", G_CALLBACK (graph_events), pd);
hbox_buttons = gtk_hbox_new (FALSE, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox_buttons), 12);
gtk_container_add (GTK_CONTAINER(vbox), hbox_buttons);
gtk_widget_show(hbox_buttons);
preview_button = gtk_button_new_with_mnemonic ("HD _Preview");
gtk_box_pack_start (GTK_BOX (hbox_buttons), preview_button, FALSE, FALSE, 0);
gtk_widget_show (preview_button);
g_signal_connect (preview_button, "clicked", G_CALLBACK (preview_hd), pd);
preview_hd_checkbox = gtk_check_button_new_with_label("Always preview HD");
gtk_box_pack_start (GTK_BOX (hbox_buttons), preview_hd_checkbox, FALSE, FALSE, 0);
gtk_widget_show (preview_hd_checkbox);
pd->do_preview_hd = FALSE;
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(preview_hd_checkbox), FALSE);
g_signal_connect (preview_hd_checkbox, "toggled", G_CALLBACK (preview_hd_toggled), pd);
gtk_widget_show(main_hbox);
gtk_widget_show(dialog);
fft_prepare(pd);
histogram_generate(pd);
wavelet_prepare(pd);
gboolean run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
if (run)
{
// set the region mode to actual writing
gimp_pixel_rgn_init(&pd->region, pd->drawable, 0, 0, pd->image_width, pd->image_height, TRUE, TRUE);
fft_apply(pd);
gimp_pixel_rgn_set_rect(&pd->region, pd->img_pixels, 0, 0, pd->image_width, pd->image_height);
// show the result
gimp_drawable_flush(pd->drawable);
gimp_drawable_merge_shadow(pd->drawable->drawable_id, TRUE);
gimp_drawable_update(pd->drawable->drawable_id, pd->selection_offset_x, pd->selection_offset_y, pd->selection_width, pd->selection_height);
gimp_displays_flush();
}
fft_destroy(pd);
wavelet_destroy(pd);
gtk_widget_destroy (dialog);
return run;
}
