Exemplo n.º 1
0
void GUI::mirror(Controller &controller, char sens) {

  if ( ! controller.image_file_loaded   ) { return ; }

  switch (sens) {

    case 'l' :
      mirror_vertical_left(controller.current_image_to_process, controller.current_image_to_process) ;
      break ;

    case 'r' :
      mirror_vertical_right(controller.current_image_to_process, controller.current_image_to_process) ;
      break ;

    case 't' :
      mirror_horizontal_top(controller.current_image_to_process, controller.current_image_to_process) ;
      break ;

    case 'b' :
      mirror_horizontal_bottom(controller.current_image_to_process, controller.current_image_to_process) ;
      break ;

  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying() ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 2
0
void GUI::rotating(Controller &controller, bool sens) {

  if ( ! controller.image_file_loaded   ) { return ; }

  if (! sens)  {
    rotate_90_left(controller.current_image_to_process, controller.current_image_to_process) ;
  }
  else {
    rotate_90_right(controller.current_image_to_process, controller.current_image_to_process) ;
  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying() ;

  controller.get_current_image_position() ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  set_label_size_value(controller.source_image_size.first, controller.source_image_size.second) ;

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 3
0
void GUI::kernel_mean_callback(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  string kernel_type ;

  switch (controller.kernel_mean_kernel_type) {

    case 0 :

      kernel_type = "rect" ;
      break ;

    case 1 :

      kernel_type = "diamond" ;
      break ;

    case 2 :

      kernel_type = "cross" ;
      break ;

    case 3 :

      kernel_type = "X" ;
      break ;


    #ifdef DEBUG
    default :
      // This cannot append due of the GUI interfacing.
      fprintf(stderr,"Cannot identify kernel type !!!\n") ;
      return ;
    #endif

  }

  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  Mean kernel(controller.kernel_mean_kernel_size, kernel_type) ;

  kernel.kernel_print() ;

  kernel.apply(tmp, frame) ;

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 4
0
void GUI::apply_grayscale(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  // Transform image into a grayscale image according choosen settings:

  switch (combo_current_grayscaling) {

    case 0 :

      grayscale(controller.current_image_to_process, controller.current_image_to_process, "average") ;
      break ;

    case 1 :

      grayscale(controller.current_image_to_process, controller.current_image_to_process, "max")     ;
      break ;

    case 2 :

      grayscale(controller.current_image_to_process, controller.current_image_to_process, "min")     ;
      break ;

    case 3 :

      grayscale(controller.current_image_to_process, controller.current_image_to_process, "red")     ;
      break ;

    case 4 :

      grayscale(controller.current_image_to_process, controller.current_image_to_process, "green")    ;
      break ;

    case 5 :

      grayscale(controller.current_image_to_process, controller.current_image_to_process, "blue")     ;
      break ;


    #ifdef DEBUG
    default :
      // Cannot append due of the GUI interfacing.
      fprintf(stdout,"Error applying grayscale filter !!!\n") ;
      return ;
   #endif

  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying() ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 5
0
void GUI::flip(Controller &controller, char sens) {

  if ( ! controller.image_file_loaded   ) { return ; }

  static char flip_x_pos = ' ' ;
  static char flip_y_pos = ' ' ;

  switch (sens) {

    case 'l' :

      if (flip_x_pos != 'l') {
        flipping(controller.current_image_to_process, controller.current_image_to_process, -1) ;
        flip_x_pos = 'l' ;
      }

      break ;

    case 'r' :

      if ( flip_x_pos != ' ' && flip_x_pos != 'r' ) {
        flipping(controller.current_image_to_process, controller.current_image_to_process, -1) ;
        flip_x_pos = 'r' ;
      }

      break ;

    case 'u' :


      if (flip_y_pos != 'u') {
        flipping(controller.current_image_to_process, controller.current_image_to_process, 1) ;
        flip_y_pos = 'u' ;
      }

      break ;

    case 'd' :

      if ( flip_y_pos != ' ' && flip_y_pos != 'd') {
        flipping(controller.current_image_to_process, controller.current_image_to_process, 1) ;
        flip_y_pos='d' ;
      }

      break ;
  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying() ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 6
0
int		main(int ac, char **av)
{
	t_rt		*rt;
	char		*scene;

	rt = NULL;
	scene = NULL;
	if (ac > 1)
		scene = read_file(av[1]);
	init_rt(&rt, scene);
	set_img(&(rt->img), rt->env->img, &(rt->lay));
	mlx_expose_hook(rt->env->win, expose_hook, (void*)rt);
	mlx_loop_hook(rt->env->mlx, loop_hook, (void*)rt);
	mlx_key_hook(rt->env->win, key_hook, (void*)rt);
	mlx_loop(rt->env->mlx);
	return (0);
}
Exemplo n.º 7
0
 inline const typename boost::enable_if<is_expression<Expression>,
   typename boost::enable_if_c<Expression::dimCount == dimCount,
     expression_t
   >::type
 >::type&
 operator=(const Expression& expr) const {
   const dim_t& size = expr.size();
   for (unsigned i = 0; i < dimCount; ++i) {
     tbblas_assert(size[i] == this->size()[i]);
   }
   tbblas::detail::for_each(
       typename tbblas::detail::select_system<cuda_enabled && Expression::cuda_enabled>::system(),
       thrust::make_zip_iterator(thrust::make_tuple(this->expr.begin(), expr.begin())),
       thrust::make_zip_iterator(thrust::make_tuple(this->expr.end(), expr.end())),
       set_img());
   return *this;
 }
Exemplo n.º 8
0
void GUI::get_display_area_size(Gtk::Allocation &scr, Controller &controller) {

  auto container_size = controller.get_layout_size() ;

  display_area_width=scr.get_width() ;
  display_area_height=scr.get_height() ;

  if (container_size.first == display_area_width && container_size.second == display_area_height) {
    // If nothing changed we return.
    display_area_size_changed = false ;
    return ;
  }

  display_area_size_changed = true ;

  controller.set_layout_size(scr.get_width(), scr.get_height()) ;

  int width, height ;

  get_size(width, height) ;

  controller.set_window_size(width, height) ;

  have_layout_size = true ;


  if ( widget_current_image_to_display != NULL ) {


    // Updating current image sizes and positions values.
    controller.get_current_image_position() ;

    if ( controller.get_image_size_gt_layout() || controller.get_image_lt_layout() ) {
      set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).
      return ;
    }


    // Set image at right position.
    display_area.move(*widget_current_image_to_display, controller.current_image_position.first, controller.current_image_position.second) ;

  }

}
Exemplo n.º 9
0
void GUI::zoom_plus(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  cv::Mat frame ;

  zoom(controller.current_image_to_process, frame, cv::Point2f(controller.mouse_zoom_center_x, controller.mouse_zoom_center_y ), controller.zoom_factor_plus) ;

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  controller.zoom_idx = controller.image_to_display_vector_idx ;

  controller.zoom_counter++ ;

}
Exemplo n.º 10
0
void GUI::redo_callback(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  if (controller.image_to_display_vector_idx < controller.image_to_display_vector.size()-1 ) {

    controller.image_to_display_vector_idx++ ;

    controller.current_image_to_process = controller.image_to_display_vector.at(controller.image_to_display_vector_idx) ;

    controller.get_current_image_position() ;

    // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
    set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ; // It auto process conversion to RGB(A).

    if (controller.image_to_display_vector_idx == controller.image_to_display_vector.size()-1 ) {
      controller.has_undo = false ;
    }

  }

}
Exemplo n.º 11
0
void GUI::set_image_in_color_tone_callback(Controller &controller, const uint8_t red, const uint8_t green, const uint8_t blue) {

  if ( ! controller.image_file_loaded   ) { return ; }



  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  set_image_in_color_tone(tmp, frame, red, green, blue) ;

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 12
0
void GUI::mult_global_intensity_callback(Controller &controller, const float factor) {

  if ( ! controller.image_file_loaded   ) { return ; }



  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  multiply_global_intensity(tmp, frame, factor) ;

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 13
0
void GUI::mult_colors_callback(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }



  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  mult_colors(tmp, frame, static_cast<float>(controller.mult_red), static_cast<float>(controller.mult_green), static_cast<float>(controller.mult_blue), static_cast<float>(controller.mult_alpha) ) ;

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 14
0
void GUI::kernel_emboss_callback(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  Emboss kernel(controller.kernel_emboss_kernel_size, controller.kernel_emboss_kernel_values_factor, '+', controller.kernel_emboss_kernel_center_factor) ;

  kernel.apply(tmp, frame) ;

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 15
0
void GUI::zoom_minus(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  if (controller.zoom_counter > 0) {

    controller.zoom_idx--     ;
    controller.zoom_counter-- ;

    cv::Mat frame = controller.image_to_display_vector.at(controller.zoom_idx) ;

    // We register current frame in vector<cv::Mat> for undo-redo.
    controller.process_after_applying(frame) ;

    // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
    set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  }





}
Exemplo n.º 16
0
void GUI::kernel_kirsch_callback(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  string kernel_direction ;

  switch (controller.kernel_kirsch_kernel_direction) {

    case 0 :

      kernel_direction = "E" ;
      break ;

    case 1 :

      kernel_direction = "W" ;
      break ;

    case 2 :

      kernel_direction = "N" ;
      break ;

    case 3 :

      kernel_direction = "S" ;
      break ;


    #ifdef DEBUG
    default :
      // This cannot append due of the GUI interfacing.
      fprintf(stderr,"Cannot identify kernel type !!!\n") ;
      return ;
    #endif

  }

  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  if (tmp.channels() == 4) {

    cv::Mat frame_rgb ;
    cv::Mat tmp_1     ;

    cvtColor(tmp, frame_rgb, cv::COLOR_BGRA2BGR) ;

    Kirsch kernel(controller.kernel_kirsch_kernel_size, kernel_direction, controller.kernel_kirsch_kernel_values_factor) ;

    kernel.apply(frame_rgb, tmp_1) ;

    vector<cv::Mat> tmp_2 ;
    vector<cv::Mat> tmp_3 ;

    cv::split(tmp,   tmp_2) ;
    cv::split(tmp_1, tmp_3) ;

    // Assign BGR channels.
    tmp_2[0] = tmp_3[0] ;
    tmp_2[1] = tmp_3[1] ;
    tmp_2[2] = tmp_3[2] ;

    // Final channels merging into result with alpha channel unchanged.
    cv::merge(tmp_2, frame) ;

  }
  else {

    Kirsch kernel(controller.kernel_kirsch_kernel_size, kernel_direction, controller.kernel_kirsch_kernel_values_factor) ;

    kernel.apply(tmp, frame) ;

  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 17
0
void GUI::process_change_intensity(Controller &controller, uint8_t selected_scale) {

  if ( ! controller.image_file_loaded   ) { return ; }

  int64_t value = static_cast<int64_t>(get_scale(selected_scale).get_value()) ;

  bool add = true ;

  if (value == 0) { return ; }


  if (value < 0) {

    value  = -value ;
    add    =  false ;

  }

  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  switch (selected_scale) {

    case 1 :

      // Red intensity change ;
      change_intensity(tmp, frame, add, static_cast<int>(value), 0, 0 ) ;
      break ;

    case 2 :

      // Green intensity change ;
      change_intensity(tmp, frame, add, 0, static_cast<int>(value), 0 ) ;
      break ;

    case 3 :

      // Blue intensity change ;
      change_intensity(tmp, frame, add, 0, 0, static_cast<int>(value) ) ;
      break ;

    case 4 :

      // Global intensity change
      change_intensity(tmp, frame, add, static_cast<int>(value), static_cast<int>(value), static_cast<int>(value) ) ;
      break ;

    #ifdef DEBUG
    default :
      // This cannot append due of the GUI interfacing.
      fprintf(stderr,"Error intensity changing\n") ;
      return ;
    #endif
 
  }

   // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 18
0
void GUI::apply_filter_from_menu(Controller &controller, Gtk::ImageMenuItem &imagemenuitem) {

  if ( ! controller.image_file_loaded   ) { return ; }


  bool is_alpha = controller.current_image_to_process.channels() == 4 ;

  Sharpen sharpen_filter(3, "diamond")      ;

  Sharpen sharpen_filter_more(3, "diamond") ;


  Find_Edges find_edges_filter(3) ;


  Mean mean_filter(3)      ;

  Mean mean_filter_more(5) ;


  cv::Mat kernel = make_kernel("rect", 3)  ;


  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  switch ( stoi(imagemenuitem.get_name()) ) {

    case 0 :
      
      // Pencil Sketch filter.
      pencil_sketch_filter(tmp, frame) ;
      break ;

    case 1 :
    
      // Stylisation filter.
      stylisation_filter(tmp, frame) ;
      break ;

    case 2 :
    
      // Detail Enhance filter.
      detail_enhance_filter(tmp, frame) ;
      break ;

    case 3 :
     
      // Edge Preserving filter.
      edge_preserving_filter(tmp, frame) ;
      break ;

    case 4 :

      // Stroke edges filter:
      stroke_edges(tmp, frame) ;
      break ;

    case 5 :

      // Invert Intensity filter:
      invert_intensity(tmp, frame) ;
      break ;

    case 6 :

      // Light Intensity filter:
      effect_light(tmp, frame) ;
      break ;

    case 7 :

      // Recolor-RC (Red-Cyan) filter:
      recolorRC(tmp, frame) ;
      break ;

    case 8 :

      // Recolor-RC (Red-Green-Value) filter:
      recolorRGV(tmp, frame) ;
      break ;

    case 9 :

      // Recolor-RC (Cyan-Magenta-Value) filter:
      recolorCMV(tmp, frame) ;
      break ;

    case 10 :

      // Extrema Maximal Filter:
      extrema(tmp, frame, "max") ;
      break ;

    case 11 :

      // Extrema Minimal Filter:
      extrema(tmp, frame, "min") ;
      break ;



    case 12 :

      // Sharpen filter:
      sharpen_filter.apply(tmp, frame)   ;
      break ;

    case 13 :

      // Sharpen More filter:
      sharpen_filter_more.apply(tmp, frame)   ;
      break ;

    case 14 :

      // Find Edges filter:

      if (is_alpha) {

        cv::Mat frame_rgb ;
        cv::Mat tmp_1     ;

        cvtColor(tmp, frame_rgb, cv::COLOR_BGRA2BGR) ;

        find_edges_filter.apply(frame_rgb, tmp_1)   ;

        vector<cv::Mat> tmp_2 ;
        vector<cv::Mat> tmp_3 ;

        cv::split(tmp,   tmp_2) ;
        cv::split(tmp_1, tmp_3) ;

        // Assign BGR channels.
        tmp_2[0] = tmp_3[0] ;
        tmp_2[1] = tmp_3[1] ;
        tmp_2[2] = tmp_3[2] ;

        // Final channels merging into result with alpha channel unchanged.
        cv::merge(tmp_2, frame) ;

        break ;


      }

      find_edges_filter.apply(tmp, frame)   ;
      break ;

    case 15 :

      // Mean Blur filter:
      mean_filter.apply(tmp, frame)   ;
      break ;

    case 16 :

      // Mean Blur More filter:
      mean_filter_more.apply(tmp, frame)   ;
      break ;


    case 17 :

      // Blur filter:
      blur_filter(tmp, frame) ;
      break ;

    case 18 :

      // Median Blur filter:
      median_blur_filter(tmp, frame) ;
      break ;

    case 19 :

      // Gaussian Blur filter:
      gaussian_blur_filter(tmp, frame) ;
      break ;

    case 20 :

      denoising_filter(tmp, frame) ;
      break ;

    case 21 :

      // Erode filter:
      erode_filter(tmp, frame, kernel, 1)   ;
      break ;

    case 22 :

      // Dilate filter:
      dilate_filter(tmp, frame, kernel, 1)   ;
      break ;

    case 23 :

      // Wave Horizontally filter:
      wave(tmp, frame, -1) ;
      break ;

    case 24 :

      // Wave Vertically filter:
      wave(tmp, frame,  1) ;
      break ;

    case 25 :

      // Wave Twice (Horizontally and Vertically) filter:
      wave(tmp, frame,  0) ;
      break ;

    case 26 :

      // Contours Sobel White filter.
      sobel_drawning(tmp, frame, 3, false, 1) ;
      break ;

    case 27 :

      // Contours Sobel Black filter.
      sobel_drawning(tmp, frame, 3, false, -1) ;
      break ;

    case 28 :

      // Contours Sobel Emboss filter.
      sobel_drawning(tmp, frame, 3, false, 0) ;
      break ;

    case 29 :

      // Emboss Sobel filter:
      sobel_emboss(tmp, frame, 3) ;
      break ;

    case 30 :

      // Emboss Laplacian filter:
      laplacian_emboss(tmp, frame, 3) ;
      break ;


    case 31 :

      // Binary White OTSU filter:
      // Build a binary image (a black and white only image) with white background (@arg value true)
      // based on the OTSU threshold computing algorithm (@arg value -1).
      build_binary_image(tmp, frame, -1, true) ;
      break ;

    case 32 :

      // Binary White TRIANGLE filter:
      // Build a binary image (a black and white only image) with white background (@arg value true)
      // based on the TRIANGLE threshold computing algorithm (@arg value 1).
      build_binary_image(tmp, frame,  1, true) ;
      break ;

    case 33 :

      // Binary White AVERAGE filter:
      // Build a binary image (a black and white only image) with white background (@arg value true)
      // based on the AVERAGE threshold from OTSU and TRIANGLE (@arg value 0).
      build_binary_image(tmp, frame,  0, true) ;
      break ;

    case 34 :

      // Binary Black OTSU filter:
      // Build a binary image (a black and white only image) with black background (@arg value true)
      // based on the OTSU threshold computing algorithm (@arg value -1).
      build_binary_image(tmp, frame, -1, false) ;
      break ;

    case 35 :

      // Binary Black TRIANGLE filter:
      // Build a binary image (a black and white only image) with black background (@arg value true)
      // based on the TRIANGLE threshold computing algorithm (@arg value 1).
      build_binary_image(tmp, frame,  1, false) ;
      break ;

    case 36 :

      // Binary Black AVERAGE filter:
      // Build a binary image (a black and white only image) with black background (@arg value true)
      // based on the AVERAGE threshold from OTSU and TRIANGLE (@arg value 0).
      build_binary_image(tmp, frame,  0, false) ;
      break ;

    case 37 :

      // Binary Contours White filter:
      // Build a binary image (a black and white only image) with contours detction on white background (@arg value false).
      laplacian_zero_crossing(tmp, frame, 19, false)  ;
      break ;

    case 38 :

      // Binary Contours Black filter:
      // Build a binary image (a black and white only image) with contours detction on black background (@arg value true).
      laplacian_zero_crossing(tmp, frame, 19, true)  ;
      break ;







    #ifdef DEBUG
    default :
      // Cannot append due of the GUI interfacing.
      fprintf(stdout,"Error applying filter !!!\n") ;
      return ;
    #endif

  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 19
0
void GUI::process_change_colorspace(Controller &controller, uint8_t selected_scale) {

  if ( ! controller.image_file_loaded   ) { return ; }

  long int value = static_cast<long int>(get_scale(selected_scale).get_value()) ;

  if (value == 0) {
    return ;
  }

  const float div = (selected_scale == 9) ? 2.0f : (selected_scale == 7) ? 1.0 : 16.0f ;

  const float factor = (1.0f / (255.0f / div )) * static_cast<double>(value) ;

  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  switch (selected_scale) {

    case 6 :

      // Lightness change ;
      change_lightness(tmp, frame, factor) ;
      break ;

    case 7 :

      // Hue change ;
      change_hue(tmp, frame, factor) ;
      break ;

    case 8 :

      // Saturation change ;
      change_saturation(tmp, frame, factor) ;
      break ;

    case 9 :

      // Brightness change ;
      change_brightness(tmp, frame, factor) ;
      break ;

    #ifdef DEBUG
    default :
      // This cannot append due of the GUI interfacing.
      fprintf(stderr,"Error Change HSBL settings\n") ;
      return ;
    #endif

  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).



  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 20
0
void GUI::morphological_callback(Controller &controller) {

  if ( ! controller.image_file_loaded   ) { return ; }

  string kernel_type ;

  switch (controller.morphological_kernel_type) {

    case 0 :

      kernel_type = "rect" ;
      break ;

    case 1 :

      kernel_type = "diamond" ;
      break ;

    case 2 :

      kernel_type = "cross" ;
      break ;

    case 3 :

      kernel_type = "X" ;
      break ;


    #ifdef DEBUG
    default :
      // This cannot append due of the GUI interfacing.
      fprintf(stderr,"Cannot identify kernel type !!!\n") ;
      return ;
    #endif

  }

  char center_value ;

  switch (controller.morphological_center_value) {

    case 0 :

      center_value = '1' ;
      break ;

   case 1 :

     center_value = '0' ;
     break ;

   case 2 :

     center_value = '+' ;
     break ;

   case 3 :

     center_value = '-' ;
     break ;

    #ifdef DEBUG
    default :
      // This cannot append due of the GUI interfacing.
      fprintf(stderr,"Cannot identify center value !!!\n") ;
      return ;
    #endif

  }

  int operator_type ;

  switch (controller.morphological_operator_type) {

    case 0 :

      operator_type = cv::MORPH_ERODE ;
      break ;

    case 1 :

      operator_type = cv::MORPH_DILATE ;
      break ;

    case 2 :

      operator_type = cv::MORPH_OPEN ;
      break ;

    case 3 :

      operator_type = cv::MORPH_CLOSE ;
      break ;

    case 4 :

      operator_type = cv::MORPH_TOPHAT ;
      break ;

    case 5 :

      operator_type = cv::MORPH_BLACKHAT ;
      break ;

    #ifdef DEBUG
    default :
      // This cannot append due of the GUI interfacing.
      fprintf(stderr,"Cannot identify operator !!!\n") ;
      return ;
    #endif

  }

  cv::Mat kernel = make_kernel(kernel_type, static_cast<int>(controller.morphological_kernel_size), center_value) ;

  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;

  morphological_filter(tmp, frame, operator_type, kernel, static_cast<int>(controller.morphological_iterations) ) ;

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 21
0
void GUI::apply_colorscale_from_menu(Controller &controller, Gtk::ImageMenuItem &imagemenuitem) {

  if ( ! controller.image_file_loaded   ) { return ; }

  cv::Mat tmp = controller.current_image_to_process.clone() ;

  cv::Mat frame ;


  // Apply a colorscale on the image according choosen settings:

  switch ( stoi(imagemenuitem.get_name()) ) {

    case 0 :

      colorscale(tmp, frame, "red", "average") ;
      break ;

    case 1 :

      colorscale(tmp, frame, "red", "max") ;
      break ;

    case 2 :

      colorscale(tmp, frame, "red", "min") ;
      break ;

    case 3 :

      colorscale(tmp, frame, "red", "red") ;
      break ;

    case 4 :

      colorscale(tmp, frame, "red", "green") ;
      break ;


    case 5 :

      colorscale(tmp, frame, "green", "average") ;
      break ;

    case 6 :

      colorscale(tmp, frame, "green", "max") ;
      break ;

    case 7 :

      colorscale(tmp, frame, "green", "min") ;
      break ;

    case 8 :

      colorscale(tmp, frame, "green", "red") ;
      break ;


    case 9 :

      colorscale(tmp, frame, "green", "blue") ;
      break ;


    case 10 :

      colorscale(tmp, frame, "blue", "average") ;
      break ;

    case 11 :

      colorscale(tmp, frame, "blue", "max") ;
      break ;

    case 12 :

      colorscale(tmp, frame, "blue", "min") ;
      break ;

    case 13 :

      colorscale(tmp, frame, "blue", "red") ;
      break ;

    case 14 :

      colorscale(tmp, frame, "blue", "green") ;
      break ;



    case 15 :

      colorscale(tmp, frame, "yellow", "average") ;
      break ;

    case 16 :

      colorscale(tmp, frame, "yellow", "max") ;
      break ;

    case 17 :

      colorscale(tmp, frame, "yellow", "min") ;
      break ;

    case 18 :

      colorscale(tmp, frame, "yellow", "red") ;
      break ;

    case 19 :

      colorscale(tmp, frame, "yellow", "green") ;
      break ;

    case 20 :

      colorscale(tmp, frame, "yellow", "blue") ;
      break ;


    case 21 :

      colorscale(tmp, frame, "pink", "average") ;
      break ;

    case 22 :

      colorscale(tmp, frame, "pink", "max") ;
      break ;

    case 23 :

      colorscale(tmp, frame, "pink", "min") ;
      break ;

    case 24 :

      colorscale(tmp, frame, "pink", "red") ;
      break ;

    case 25 :

      colorscale(tmp, frame, "pink", "green") ;
      break ;

    case 26 :

      colorscale(tmp, frame, "pink", "blue") ;
      break ;


    case 27 :

      colorscale(tmp, frame, "turquoise", "average") ;
      break ;

    case 28 :

      colorscale(tmp, frame, "turquoise", "max") ;
      break ;

    case 29 :

      colorscale(tmp, frame, "turquoise", "min") ;
      break ;

    case 30 :

      colorscale(tmp, frame, "turquoise", "red") ;
      break ;

    case 31 :

      colorscale(tmp, frame, "turquoise", "green") ;
      break ;

    case 32 :

      colorscale(tmp, frame, "turquoise", "blue") ;
      break ;


    #ifdef DEBUG
    default :
      // Cannot append due of the GUI interfacing.
      fprintf(stdout,"Error applying colorscale filter !!!\n") ;
      return ;
    #endif

  }

  // We register current frame in vector<cv::Mat> for undo-redo.
  controller.process_after_applying(frame) ;

  // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
  set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

  // Reset some variables.
  after_applying_reset_settings(controller) ;

}
Exemplo n.º 22
0
bool GUI::on_display_area_button_press_handler(GdkEventButton *event_button, Controller &controller) {

  if (button_zoom_pointer.get_active() ) { // This is in relationship with the button setting for mouse selection of zoom center.

    if ( controller.mouse_into_image && controller.mouse_curser_changed == 1 && event_button->button == 1 ) {

      // Settings the zoom center coordinates by mutiplying the coordinates from inside the image per factors:
      controller.mouse_zoom_center_x =  static_cast<float>(controller.mouse_inside_image_x) *  controller.factor_width   ;
      controller.mouse_zoom_center_y =  static_cast<float>(controller.mouse_inside_image_y) *  controller.factor_height   ;

      controller.process_after_applying() ;  // We register current frame in vector<cv::Mat> for undo-redo.

      // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
      set_img(controller.current_image_to_process, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).
    

      // Reset cursor.
      main_window_gdk_window->set_cursor() ;

      // Reset control variables:
      controller.mouse_curser_changed = -1 ;
  
      controller.draw_offset = 0.0 ;

      if ( button_zoom_pointer.get_active() ) {
        // If button pressed, raise it.
        button_zoom_pointer.set_active(false) ;
      }

    }
    else if (event_button->button != 1) {

      // Reset cursor.
      main_window_gdk_window->set_cursor() ;

      controller.reset_zoom_center(controller.current_image_to_process) ;

      controller.mouse_curser_changed = -1 ;

      if ( button_zoom_pointer.get_active() ) {
        // If button pressed, raise it.
        button_zoom_pointer.set_active(false) ;
      }

    }

  }
  else if ( button_draw_rect.get_active() || button_draw_line.get_active() || button_draw_circle.get_active() || button_draw_ellipse.get_active() || button_draw_polygon.get_active() || button_draw_star.get_active() || button_draw_text.get_active() ) {

    if ( controller.mouse_into_image && controller.mouse_curser_changed == 1 && event_button->button == 1 ) {

      if ( (controller.drawning_status == -1) || (controller.drawning_status == 1) ) {

        // Getting the drawning coordinates onto the real (not resized) image by multiplying per factors:
        controller.mouse_draw_x1 =  static_cast<float>(controller.mouse_inside_image_x) *  controller.factor_width   ;
        controller.mouse_draw_y1 =  static_cast<float>(controller.mouse_inside_image_y) *  controller.factor_height   ;

        controller.drawning_status = 0 ;

        controller.saved_frame = controller.current_image_to_process.clone() ;



        if ( button_draw_line.get_active() ) {
          goto fake_mouse_1_button_press  ;
        }
        if ( button_draw_text.get_active() ) {
          goto fake_mouse_1_button_press ;
        }

        return false ;




      }
      else if (controller.drawning_status == 0) {



        fake_mouse_1_button_press :

        // Getting the drawning coordinates onto the real (not resized) image by multiplying per factors:
        controller.mouse_draw_x2 =  static_cast<float>(controller.mouse_inside_image_x) *  controller.factor_width   ;
        controller.mouse_draw_y2 =  static_cast<float>(controller.mouse_inside_image_y) *  controller.factor_height   ;

        controller.drawning_status = 1 ;

        cv::Scalar color(draw_color.get_blue_u() >> 8, draw_color.get_green_u() >> 8, draw_color.get_red_u() >> 8, draw_color.get_alpha_u() >> 8) ;

        cv::Mat frame = controller.current_image_to_process.clone() ;



        if (button_draw_line.get_active() ) {

           if ( controller.polylines_points_nb == 0) {

             controller.polylines_start_rect = cv::Rect( cv::Point(controller.mouse_draw_x1-7, controller.mouse_draw_y1-7), cv::Size(15, 15) ) ;

           }



           controller.polylines.push_back( cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1)) ;

           controller.polylines_points_nb++ ;

           if ( controller.polylines_points_nb > 1) {



             if ( controller.polylines_start_rect.contains(cv::Point(controller.mouse_draw_x1,   controller.mouse_draw_y1)) ) {

              draw_polylines(frame , controller.polylines, true, (draw_thickness < 0),  color, (draw_thickness < 0) ? 0 : draw_thickness , draw_line_type) ;
              controller.polylines_points_nb = 0 ;

              controller.polylines.clear() ;
              controller.polylines.shrink_to_fit() ;
            }
            else {
              draw_polylines(frame , controller.polylines, false, false,  color, (draw_thickness < 0) ? 0 : draw_thickness, draw_line_type) ;
            }

           }


        }
        else if (button_draw_rect.get_active()) {


          cv::Rect rect( cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1), cv::Point(controller.mouse_draw_x2, controller.mouse_draw_y2) ) ;

          draw_rect(frame, rect, color, draw_thickness, draw_line_type) ;

        }
        else if (button_draw_circle.get_active() ) {

          const int radius = static_cast<int>(roundf( sqrtf(powf(static_cast<float>(controller.mouse_draw_x2)-static_cast<float>(controller.mouse_draw_x1), 2) + powf(static_cast<float>(controller.mouse_draw_y2)-static_cast<float>(controller.mouse_draw_y1), 2))) ) ;

          draw_circle(frame, cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1), radius, color, draw_thickness, draw_line_type) ;

        }
        else if (button_draw_ellipse.get_active() ) {

          const int distance_x = abs(controller.mouse_draw_x1-controller.mouse_draw_x2) ;
          const int distance_y = abs(controller.mouse_draw_y1-controller.mouse_draw_y2) ;

          const cv::RotatedRect rot_rect(cv::Point2f( static_cast<float>(controller.mouse_draw_x1), static_cast<float>(controller.mouse_draw_y1) ), cv::Size(abs( distance_x * 2 ), abs( distance_y * 2 ) ), 0.0  ) ;

          draw_ellipse(frame, rot_rect, color, draw_thickness, draw_line_type) ;

        }
        else if (button_draw_polygon.get_active() && controller.config_draw_success == Gtk::RESPONSE_OK ) {

            const double radius = round( sqrt (pow(static_cast<double>(controller.mouse_draw_x2)-static_cast<double>(controller.mouse_draw_x1), 2) + pow(static_cast<double>(controller.mouse_draw_y2)-static_cast<double>(controller.mouse_draw_y1), 2)) ) ;

            vector<cv::Point> polygon ;

            double offset_correct = 0.0 ;

            if ((controller.polygon_edges > 4) && (controller.polygon_edges % 2 == 1)) {
              offset_correct = 360.0 / controller.polygon_edges / 2.0 / 2.0  ;
            }

            bool fill = false ;

            if ( ! controller.polygon_strikethrough && draw_thickness < 0 ) { fill = true ; }

            generate_polygon(controller.polygon_edges, radius, cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1),  polygon, controller.polygon_strikethrough, false,  controller.polygon_offset + controller.draw_offset + offset_correct) ;

            draw_polylines(frame, polygon, true, fill, color, ((draw_thickness < 0) ? 0 : draw_thickness) , draw_line_type) ;


         }
         else if (button_draw_text.get_active() && controller.config_draw_success == Gtk::RESPONSE_OK ) {

            int italic_flags = (controller.put_text_is_italic) ? cv::FONT_ITALIC : 0 ;

            draw_text(frame, controller.put_text_string, cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1), controller.put_text_font_face | italic_flags, controller.put_text_font_scale, color, ((draw_thickness < 0) ? 0 : draw_thickness), draw_line_type) ;

            controller.drawning_status = 1 ;

         }
         else if (button_draw_star.get_active() && controller.config_draw_success == Gtk::RESPONSE_OK ) {

            const double radius = round( sqrt (pow(static_cast<double>(controller.mouse_draw_x2)-static_cast<double>(controller.mouse_draw_x1), 2) + pow(static_cast<double>(controller.mouse_draw_y2)-static_cast<double>(controller.mouse_draw_y1), 2)) ) ;

            vector<cv::Point> star ;

            bool join_stroke = true ;

            bool fill = false ;

            if ( controller.star_correcting && (! controller.star_strokes) && (controller.star_pikes == 5 ||  controller.star_pikes == 6) ) {

              if ( ! controller.star_flower && ! controller.star_strikethrough && draw_thickness < 0 ) { fill = true ; }

              switch (controller.star_pikes) {

                case 5 :

                  generate_pentagram(radius, cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1), star, controller.star_strikethrough, controller.star_flower, (360.0 / 5.0 / 2.0 / 2.0) + controller.star_offset + controller.draw_offset ) ;
                  break ;

                case 6 :

                  generate_hexagram(radius, cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1), star, controller.star_strikethrough, controller.star_flower, controller.star_offset + controller.draw_offset ) ;
                  break ;
 
              }
            }
            else if ( ! controller.star_strokes)  {

              if ( ! controller.star_flower && ! controller.star_strikethrough &&  ! controller.star_strokes && draw_thickness < 0 ) { fill = true ; }

              generate_star(controller.star_pikes , radius , cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1), star, controller.star_strikethrough, controller.star_flower, controller.star_offset + controller.draw_offset  + ((controller.star_pikes == 5) ? (360.0 / 5.0 / 2.0 / 2.0) : 0) ) ;

            }
            else {
        
              generate_polygon(controller.star_pikes, radius, cv::Point(controller.mouse_draw_x1, controller.mouse_draw_y1), star, false, true, controller.star_offset + controller.draw_offset ) ;

              join_stroke = false ;

            }
       
        
            draw_polylines(frame, star, join_stroke, fill, color, ((draw_thickness < 0) ? 0 : draw_thickness), draw_line_type) ;


         }



        // We register current frame in vector<cv::Mat> for undo-redo.
        controller.process_after_applying(frame) ;

        // It convert current_image_to_process as src to RGB(A) in dst current_image_to_display.
        set_img(frame, controller.current_image_to_display, controller) ;  // It auto process conversion to RGB(A).

        frame.release() ;

        controller.saved_frame.release() ;

        controller.mouse_curser_changed = -1 ;

        return false ;

      }

    }
    else if (event_button->button == 3) {
Exemplo n.º 23
0
void set_img_chinese(enemy *e, char *img, int dx){
  set_img(e, C_PREFIX, img, dx);
}