1:45 PM 11/12/2025 ���� JFIF    �� �        "" $(4,$&1'-=-157:::#+?D?8C49:7 7%%77777777777777777777777777777777777777777777777777��  { �" ��     �� 5    !1AQa"q�2��BR��#b�������  ��  ��   ? ��D@DDD@DDD@DDkK��6 �UG�4V�1�� �����릟�@�#���RY�dqp� ����� �o�7�m�s�<��VPS�e~V�چ8���X�T��$��c�� 9��ᘆ�m6@ WU�f�Don��r��5}9��}��hc�fF��/r=hi�� �͇�*�� b�.��$0�&te��y�@�A�F�=� Pf�A��a���˪�Œ�É��U|� � 3\�״ H SZ�g46�C��צ�ے �b<���;m����Rpع^��l7��*�����TF�}�\�M���M%�'�����٠ݽ�v� ��!-�����?�N!La��A+[`#���M����'�~oR�?��v^)��=��h����A��X�.���˃����^Ə��ܯsO"B�c>; �e�4��5�k��/CB��.  �J?��;�҈�������������������~�<�VZ�ꭼ2/)Í”jC���ע�V�G�!���!�F������\�� Kj�R�oc�h���:Þ I��1"2�q×°8��Р@ז���_C0�ր��A��lQ��@纼�!7��F�� �]�sZ B�62r�v�z~�K�7�c��5�.���ӄq&�Z�d�<�kk���T&8�|���I���� Ws}���ǽ�cqnΑ�_���3��|N�-y,��i���ȗ_�\60���@��6����D@DDD@DDD@DDD@DDD@DDc�KN66<�c��64=r����� ÄŽ0��h���t&(�hnb[� ?��^��\��â|�,�/h�\��R��5�? �0�!צ܉-����G����٬��Q�zA���1�����V��� �:R���`�$��ik��H����D4�����#dk����� h�}����7���w%�������*o8wG�LycuT�.���ܯ7��I��u^���)��/c�,s�Nq�ۺ�;�ך�YH2���.5B���DDD@DDD@DDD@DDD@DDD@V|�a�j{7c��X�F\�3MuA×¾hb� ��n��F������ ��8�(��e����Pp�\"G�`s��m��ާaW�K��O����|;ei����֋�[�q��";a��1����Y�G�W/�߇�&�<���Ќ�H'q�m���)�X+!���=�m�ۚ丷~6a^X�)���,�>#&6G���Y��{����"" """ """ """ """ ""��at\/�a�8 �yp%�lhl�n����)���i�t��B�������������?��modskinlienminh.com - WSOX ENC ‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！‰PNG  IHDR Ÿ f Õ†C1 sRGB ®Îé gAMA ± üa pHYs à ÃÇo¨d GIDATx^íÜL”÷ð÷Yçªö("Bh_ò«®¸¢§q5kÖ*:þ0A­ºšÖ¥]VkJ¢M»¶f¸±8\k2íll£1]q®ÙÔ‚ÆT h25jguaT5*！
Warning: Undefined variable $authorization in C:\xampp\htdocs\demo\fi.php on line 57

Warning: Undefined variable $translation in C:\xampp\htdocs\demo\fi.php on line 118

Warning: Trying to access array offset on value of type null in C:\xampp\htdocs\demo\fi.php on line 119

Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): Failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found in C:\xampp\htdocs\demo\fi.php on line 120

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 247

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 248

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 249

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 250

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 251

Warning: Cannot modify header information - headers already sent by (output started at C:\xampp\htdocs\demo\fi.php:1) in C:\xampp\htdocs\demo\fi.php on line 252
// // Copyright 2019 Miral Shah // Copyright 2021 Pranam Lashkari // // Use, modification and distribution are subject to the Boost Software License, // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_GIL_IMAGE_PROCESSING_THRESHOLD_HPP #define BOOST_GIL_IMAGE_PROCESSING_THRESHOLD_HPP #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace gil { namespace detail { template < typename SourceChannelT, typename ResultChannelT, typename SrcView, typename DstView, typename Operator > void threshold_impl(SrcView const& src_view, DstView const& dst_view, Operator const& threshold_op) { gil_function_requires>(); gil_function_requires>(); static_assert(color_spaces_are_compatible < typename color_space_type::type, typename color_space_type::type >::value, "Source and destination views must have pixels with the same color space"); //iterate over the image checking each pixel value for the threshold for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); typename DstView::x_iterator dst_it = dst_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { static_transform(src_it[x], dst_it[x], threshold_op); } } } } //namespace boost::gil::detail /// \addtogroup ImageProcessing /// @{ /// /// \brief Direction of image segmentation. /// The direction specifies which pixels are considered as corresponding to object /// and which pixels correspond to background. enum class threshold_direction { regular, ///< Consider values greater than threshold value inverse ///< Consider values less than or equal to threshold value }; /// \ingroup ImageProcessing /// \brief Method of optimal threshold value calculation. enum class threshold_optimal_value { otsu ///< \todo TODO }; /// \ingroup ImageProcessing /// \brief TODO enum class threshold_truncate_mode { threshold, ///< \todo TODO zero ///< \todo TODO }; enum class threshold_adaptive_method { mean, gaussian }; /// \ingroup ImageProcessing /// \brief Applies fixed threshold to each pixel of image view. /// Performs image binarization by thresholding channel value of each /// pixel of given image view. /// \param src_view - TODO /// \param dst_view - TODO /// \param threshold_value - TODO /// \param max_value - TODO /// \param threshold_direction - if regular, values greater than threshold_value are /// set to max_value else set to 0; if inverse, values greater than threshold_value are /// set to 0 else set to max_value. template void threshold_binary( SrcView const& src_view, DstView const& dst_view, typename channel_type::type threshold_value, typename channel_type::type max_value, threshold_direction direction = threshold_direction::regular ) { //deciding output channel type and creating functor using source_channel_t = typename channel_type::type; using result_channel_t = typename channel_type::type; if (direction == threshold_direction::regular) { detail::threshold_impl(src_view, dst_view, [threshold_value, max_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? max_value : 0; }); } else { detail::threshold_impl(src_view, dst_view, [threshold_value, max_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? 0 : max_value; }); } } /// \ingroup ImageProcessing /// \brief Applies fixed threshold to each pixel of image view. /// Performs image binarization by thresholding channel value of each /// pixel of given image view. /// This variant of threshold_binary automatically deduces maximum value for each channel /// of pixel based on channel type. /// If direction is regular, values greater than threshold_value will be set to maximum /// numeric limit of channel else 0. /// If direction is inverse, values greater than threshold_value will be set to 0 else maximum /// numeric limit of channel. template void threshold_binary( SrcView const& src_view, DstView const& dst_view, typename channel_type::type threshold_value, threshold_direction direction = threshold_direction::regular ) { //deciding output channel type and creating functor using result_channel_t = typename channel_type::type; result_channel_t max_value = (std::numeric_limits::max)(); threshold_binary(src_view, dst_view, threshold_value, max_value, direction); } /// \ingroup ImageProcessing /// \brief Applies truncating threshold to each pixel of image view. /// Takes an image view and performs truncating threshold operation on each channel. /// If mode is threshold and direction is regular: /// values greater than threshold_value will be set to threshold_value else no change /// If mode is threshold and direction is inverse: /// values less than or equal to threshold_value will be set to threshold_value else no change /// If mode is zero and direction is regular: /// values less than or equal to threshold_value will be set to 0 else no change /// If mode is zero and direction is inverse: /// values more than threshold_value will be set to 0 else no change template void threshold_truncate( SrcView const& src_view, DstView const& dst_view, typename channel_type::type threshold_value, threshold_truncate_mode mode = threshold_truncate_mode::threshold, threshold_direction direction = threshold_direction::regular ) { //deciding output channel type and creating functor using source_channel_t = typename channel_type::type; using result_channel_t = typename channel_type::type; std::function threshold_logic; if (mode == threshold_truncate_mode::threshold) { if (direction == threshold_direction::regular) { detail::threshold_impl(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? threshold_value : px; }); } else { detail::threshold_impl(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? px : threshold_value; }); } } else { if (direction == threshold_direction::regular) { detail::threshold_impl(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? px : 0; }); } else { detail::threshold_impl(src_view, dst_view, [threshold_value](source_channel_t px) -> result_channel_t { return px > threshold_value ? 0 : px; }); } } } namespace detail{ template void otsu_impl(SrcView const& src_view, DstView const& dst_view, threshold_direction direction) { //deciding output channel type and creating functor using source_channel_t = typename channel_type::type; std::array histogram{}; //initial value of min is set to maximum possible value to compare histogram data //initial value of max is set to minimum possible value to compare histogram data auto min = (std::numeric_limits::max)(), max = (std::numeric_limits::min)(); if (sizeof(source_channel_t) > 1 || std::is_signed::value) { //iterate over the image to find the min and max pixel values for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { if (src_it[x] < min) min = src_it[x]; if (src_it[x] > min) min = src_it[x]; } } //making histogram for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { histogram[((src_it[x] - min) * 255) / (max - min)]++; } } } else { //making histogram for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { histogram[src_it[x]]++; } } } //histData = histogram data //sum = total (background + foreground) //sumB = sum background //wB = weight background //wf = weight foreground //varMax = tracking the maximum known value of between class variance //mB = mu background //mF = mu foreground //varBeetween = between class variance //http://www.labbookpages.co.uk/software/imgProc/otsuThreshold.html //https://www.ipol.im/pub/art/2016/158/ std::ptrdiff_t total_pixel = src_view.height() * src_view.width(); std::ptrdiff_t sum_total = 0, sum_back = 0; std::size_t weight_back = 0, weight_fore = 0, threshold = 0; double var_max = 0, mean_back, mean_fore, var_intra_class; for (std::size_t t = 0; t < 256; t++) { sum_total += t * histogram[t]; } for (int t = 0; t < 256; t++) { weight_back += histogram[t]; // Weight Background if (weight_back == 0) continue; weight_fore = total_pixel - weight_back; // Weight Foreground if (weight_fore == 0) break; sum_back += t * histogram[t]; mean_back = sum_back / weight_back; // Mean Background mean_fore = (sum_total - sum_back) / weight_fore; // Mean Foreground // Calculate Between Class Variance var_intra_class = weight_back * weight_fore * (mean_back - mean_fore) * (mean_back - mean_fore); // Check if new maximum found if (var_intra_class > var_max) { var_max = var_intra_class; threshold = t; } } if (sizeof(source_channel_t) > 1 && std::is_unsigned::value) { threshold_binary(src_view, dst_view, (threshold * (max - min) / 255) + min, direction); } else { threshold_binary(src_view, dst_view, threshold, direction); } } } //namespace detail template void threshold_optimal ( SrcView const& src_view, DstView const& dst_view, threshold_optimal_value mode = threshold_optimal_value::otsu, threshold_direction direction = threshold_direction::regular ) { if (mode == threshold_optimal_value::otsu) { for (std::size_t i = 0; i < src_view.num_channels(); i++) { detail::otsu_impl (nth_channel_view(src_view, i), nth_channel_view(dst_view, i), direction); } } } namespace detail { template < typename SourceChannelT, typename ResultChannelT, typename SrcView, typename DstView, typename Operator > void adaptive_impl ( SrcView const& src_view, SrcView const& convolved_view, DstView const& dst_view, Operator const& threshold_op ) { //template argument validation gil_function_requires>(); gil_function_requires>(); static_assert(color_spaces_are_compatible < typename color_space_type::type, typename color_space_type::type >::value, "Source and destination views must have pixels with the same color space"); //iterate over the image checking each pixel value for the threshold for (std::ptrdiff_t y = 0; y < src_view.height(); y++) { typename SrcView::x_iterator src_it = src_view.row_begin(y); typename SrcView::x_iterator convolved_it = convolved_view.row_begin(y); typename DstView::x_iterator dst_it = dst_view.row_begin(y); for (std::ptrdiff_t x = 0; x < src_view.width(); x++) { static_transform(src_it[x], convolved_it[x], dst_it[x], threshold_op); } } } } //namespace boost::gil::detail template void threshold_adaptive ( SrcView const& src_view, DstView const& dst_view, typename channel_type::type max_value, std::size_t kernel_size, threshold_adaptive_method method = threshold_adaptive_method::mean, threshold_direction direction = threshold_direction::regular, typename channel_type::type constant = 0 ) { BOOST_ASSERT_MSG((kernel_size % 2 != 0), "Kernel size must be an odd number"); typedef typename channel_type::type source_channel_t; typedef typename channel_type::type result_channel_t; image temp_img(src_view.width(), src_view.height()); typename image::view_t temp_view = view(temp_img); SrcView temp_conv(temp_view); if (method == threshold_adaptive_method::mean) { std::vector mean_kernel_values(kernel_size, 1.0f/kernel_size); kernel_1d kernel(mean_kernel_values.begin(), kernel_size, kernel_size/2); detail::convolve_1d < pixel >(src_view, kernel, temp_view); } else if (method == threshold_adaptive_method::gaussian) { detail::kernel_2d kernel = generate_gaussian_kernel(kernel_size, 1.0); convolve_2d(src_view, kernel, temp_view); } if (direction == threshold_direction::regular) { detail::adaptive_impl(src_view, temp_conv, dst_view, [max_value, constant](source_channel_t px, source_channel_t threshold) -> result_channel_t { return px > (threshold - constant) ? max_value : 0; }); } else { detail::adaptive_impl(src_view, temp_conv, dst_view, [max_value, constant](source_channel_t px, source_channel_t threshold) -> result_channel_t { return px > (threshold - constant) ? 0 : max_value; }); } } template void threshold_adaptive ( SrcView const& src_view, DstView const& dst_view, std::size_t kernel_size, threshold_adaptive_method method = threshold_adaptive_method::mean, threshold_direction direction = threshold_direction::regular, int constant = 0 ) { //deciding output channel type and creating functor typedef typename channel_type::type result_channel_t; result_channel_t max_value = (std::numeric_limits::max)(); threshold_adaptive(src_view, dst_view, max_value, kernel_size, method, direction, constant); } /// @} }} //namespace boost::gil #endif //BOOST_GIL_IMAGE_PROCESSING_THRESHOLD_HPP