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 (c) 1997 // Utrecht University (The Netherlands), // ETH Zurich (Switzerland), // INRIA Sophia-Antipolis (France), // Max-Planck-Institute Saarbruecken (Germany), // and Tel-Aviv University (Israel). All rights reserved. // // This file is part of CGAL (www.cgal.org) // // $URL: https://github.com/CGAL/cgal/blob/v6.1/Polygon/include/CGAL/Polygon_2/Polygon_2_algorithms_impl.h $ // $Id: include/CGAL/Polygon_2/Polygon_2_algorithms_impl.h b26b07a1242 $ // SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial // // // Author(s) : Wieger Wesselink #include #include #include #include #include #include #include #include #include #include #include /// \cond SKIP_IN_MANUAL namespace CGAL { namespace internal { namespace Polygon_2 { // Filter a range of points to simplify sequences of collinear (or almost) points. // A point is removed if the two segments, formed using its previous and next points // in the range are collinear segments, up to a given tolerance. // // \tparam K must be a model of `Kernel` // \tparam InputForwardIterator must be a model of `ForwardIterator` // with value type `K::Point_2` // \tparam OutputForwardIterator must be a model of `OutputIterator` // with value type `K::Point_2` // // \param first, beyond the range // \param out points that are not removed are output in `out` // \param tolerance a tolerance on the collinearity of the two segments formed // by three consecutive points of the range (more specifically, // on the value of the determinant). // // \pre The range `(first, beyond)` is composed of at least three points. // \pre Not all points in the range `(first, beyond)` are (almost) collinear. template OutputForwardIterator filter_collinear_points(InputForwardIterator first, InputForwardIterator beyond, OutputForwardIterator out, const typename K::FT tolerance = std::numeric_limits::epsilon()) { CGAL_precondition(std::distance(first, beyond) >= 3); typedef typename K::FT FT; typedef typename K::Point_2 Point; InputForwardIterator last = std::prev(beyond); InputForwardIterator vit = first, vit_next = vit, vit_next_2 = vit, vend = vit; ++vit_next; ++(++vit_next_2); bool stop = false; do { CGAL_assertion(vit != vit_next); CGAL_assertion(vit_next != vit_next_2); CGAL_assertion(vit != vit_next_2); const Point& o = *vit; const Point& p = *vit_next; const Point& q = *vit_next_2; // Stop when 'p' is the starting point. It does not matter whether we are // in a collinear case or not. stop = (vit_next == vend); const FT det = CGAL::determinant(o.x() - q.x(), o.y() - q.y(), p.x() - q.x(), p.y() - q.y()); if(CGAL::abs(det) <= tolerance) { // Only move 'p' and 'q' to ignore consecutive collinear points vit_next = (vit_next == last) ? first : ++vit_next; vit_next_2 = (vit_next_2 == last) ? first : ++vit_next_2; } else { // 'vit = vit_next' and not '++vit' because we don't necessarily have *(next(vit) == p) // and collinear points between 'o' and 'p' are ignored vit = vit_next; vit_next = (vit_next == last) ? first : ++vit_next; vit_next_2 = (vit_next_2 == last) ? first : ++vit_next_2; *out++ = p; } } while(!stop); return out; } } // namespace Polygon_2 } // namespace internal //-----------------------------------------------------------------------// // is_simple_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_xy_2 // PolygonTraits::less_xy_2 // PolygonTraits::Orientation_2 // PolygonTraits::orientation_2 // PolygonTraits::Point_2 template bool is_simple_2(ForwardIterator first, ForwardIterator last, const PolygonTraits& traits) { if (first == last) return true; return is_simple_polygon(first, last, traits); } namespace internal { namespace Polygon_2 { template class Compare_vertices { typedef typename Traits::Less_xy_2 Less_xy_2; typedef typename Traits::Point_2 Point_2; Less_xy_2 less; public: Compare_vertices(Less_xy_2 less) : less(less) {} // `Point_like` derives from `Point_2` template bool operator()(const Point_like& p1, const Point_like& p2) { return less(Point_2(p1), Point_2(p2)); } }; // end Compare_vertices } // end namespace Polygon_2 } // end namespace internal //-----------------------------------------------------------------------// // left_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_xy_2 and less_xy_2_object() template ForwardIterator left_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits&traits) { CGAL_precondition(first != last); internal::Polygon_2::Compare_vertices less(traits.less_xy_2_object()); return std::min_element(first, last, less); } //-----------------------------------------------------------------------// // right_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_xy_2 and less_xy_2_object() template ForwardIterator right_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits &traits) { CGAL_precondition(first != last); internal::Polygon_2::Compare_vertices less(traits.less_xy_2_object()); return std::max_element(first, last, less); } //-----------------------------------------------------------------------// // top_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_yx_2 and less_yx_2_object() template ForwardIterator top_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits&traits) { CGAL_precondition(first != last); return std::max_element(first, last, traits.less_yx_2_object()); } //-----------------------------------------------------------------------// // bottom_vertex_2 //-----------------------------------------------------------------------// // uses PolygonTraits::Less_yx_2 and less_yx_2_object() template ForwardIterator bottom_vertex_2(ForwardIterator first, ForwardIterator last, const PolygonTraits&traits) { CGAL_precondition(first != last); return std::min_element(first, last, traits.less_yx_2_object()); } //-----------------------------------------------------------------------// // area_2 //-----------------------------------------------------------------------// // uses Traits:: // implemented in header file //-----------------------------------------------------------------------// // is_convex_2 //-----------------------------------------------------------------------// // uses Traits::Less_xy_2 and less_xy_2_object() // Traits::Orientation_2 and orientation_2_object() // Traits::Equal_2 for filtering repeated points template bool is_convex_2(ForwardIterator first, ForwardIterator last, const Traits& traits) { ForwardIterator previous = first; if (previous == last) return true; ForwardIterator current = previous; ++current; if (current == last) return true; ForwardIterator next = current; ++next; if (next == last) return true; typename Traits::Equal_2 equal = traits.equal_2_object(); while(equal(*previous, *current)) { current = next; ++next; if (next == last) return true; } typename Traits::Less_xy_2 less_xy_2 = traits.less_xy_2_object(); typename Traits::Orientation_2 orientation = traits.orientation_2_object(); // initialization bool HasClockwiseTriples = false; bool HasCounterClockwiseTriples = false; bool Order = less_xy_2(*previous, *current); int NumOrderChanges = 0; do { switch_orient: switch (orientation(*previous, *current, *next)) { case CLOCKWISE: HasClockwiseTriples = true; break; case COUNTERCLOCKWISE: HasCounterClockwiseTriples = true; break; case ZERO: if(equal(*current, *next)) { if(next == first) { first = current; } ++next; if (next == last) next = first; goto switch_orient; } break; } bool NewOrder = less_xy_2(*current, *next); if (Order != NewOrder) NumOrderChanges++; if (NumOrderChanges > 2) { #ifdef CGAL_POLYGON_DEBUG std::cout << "too many order changes: not convex!" << std::endl; #endif return false; } if (HasClockwiseTriples && HasCounterClockwiseTriples) { #ifdef CGAL_POLYGON_DEBUG std::cout << "polygon not locally convex!" << std::endl; #endif return false; } previous = current; current = next; ++next; if (next == last) next = first; Order = NewOrder; } while (previous != first); return true; } //-----------------------------------------------------------------------// // oriented_side_2 //-----------------------------------------------------------------------// // uses Traits::Less_xy_2 // Traits::Compare_x_2 compare_x_2_object() // Traits::Compare_y_2 compare_y_2_object() // Traits::Orientation_2 and orientation_2_object() template Oriented_side oriented_side_2(ForwardIterator first, ForwardIterator last, const Point& point, const Traits& traits) { Orientation o = orientation_2(first, last, traits); CGAL_assertion(o != COLLINEAR); Bounded_side b = bounded_side_2(first, last, point, traits); switch (b) { case ON_BOUNDARY: return ON_ORIENTED_BOUNDARY; case ON_BOUNDED_SIDE: return (o == CLOCKWISE) ? ON_NEGATIVE_SIDE : ON_POSITIVE_SIDE; default: //case ON_UNBOUNDED_SIDE: return (o == CLOCKWISE) ? ON_POSITIVE_SIDE : ON_NEGATIVE_SIDE; } } //-----------------------------------------------------------------------// // bounded_side_2 //-----------------------------------------------------------------------// // uses Traits::Compare_x_2 compare_x_2_object() // Traits::Compare_y_2 compare_y_2_object() // Traits::Orientation_2 and orientation_2_object() // // returns ON_BOUNDED_SIDE, ON_BOUNDARY or ON_UNBOUNDED_SIDE /* Implementation: we shoot a horizontal ray from the point to the right and count the number of intersections with polygon segments. If the number of intersections is odd, the point is inside. We don't count intersections with horizontal segments. With non-horizontal segments, the top vertex is considered to be part of the segment, but the bottom vertex is not. (Segments are half-closed). */ namespace i_polygon { template int which_side_in_slab(Point const &point, Point const &low, Point const &high, Orientation_2 &orientation_2, CompareX_2 &compare_x_2) // returns -1 if point is left of segment , 0 if its on the segment // and 1 if it is to the right // precondition: low.y < point.y < high.y { // first we try to decide on x coordinate values alone // This is an optimization (whether this is really faster for // a homogeneous kernel is not clear, as comparisons can be expensive. Comparison_result low_x_comp_res = compare_x_2(point, low); Comparison_result high_x_comp_res = compare_x_2(point, high); if (low_x_comp_res == SMALLER) { if (high_x_comp_res == SMALLER) return -1; } else { switch (high_x_comp_res) { case LARGER: return 1; case SMALLER: break; case EQUAL: return (low_x_comp_res == EQUAL) ? 0 : 1; } } switch (orientation_2(low, point, high)) { case LEFT_TURN: return 1; case RIGHT_TURN: return -1; default: return 0; } } } // end namespace i_polygon template Bounded_side bounded_side_2(ForwardIterator first, ForwardIterator last, const Point& point, const PolygonTraits& traits) { ForwardIterator current = first; if (current == last) return ON_UNBOUNDED_SIDE; ForwardIterator next = current; ++next; if (next == last) return ON_UNBOUNDED_SIDE; typename PolygonTraits::Compare_x_2 compare_x_2 = traits.compare_x_2_object(); typename PolygonTraits::Compare_y_2 compare_y_2 = traits.compare_y_2_object(); typename PolygonTraits::Orientation_2 orientation_2 = traits.orientation_2_object(); bool IsInside = false; Comparison_result cur_y_comp_res = compare_y_2(*current, point); do // check if the segment (current,next) intersects // the ray { (t,point.y()) | t >= point.x() } { Comparison_result next_y_comp_res = compare_y_2(*next, point); switch (cur_y_comp_res) { case SMALLER: switch (next_y_comp_res) { case SMALLER: break; case EQUAL: switch (compare_x_2(point, *next)) { case SMALLER: IsInside = !IsInside; break; case EQUAL: return ON_BOUNDARY; case LARGER: break; } break; case LARGER: switch (i_polygon::which_side_in_slab(point, *current, *next, orientation_2, compare_x_2)) { case -1: IsInside = !IsInside; break; case 0: return ON_BOUNDARY; } break; } break; case EQUAL: switch (next_y_comp_res) { case SMALLER: switch (compare_x_2(point, *current)) { case SMALLER: IsInside = !IsInside; break; case EQUAL: return ON_BOUNDARY; case LARGER: break; } break; case EQUAL: switch (compare_x_2(point, *current)) { case SMALLER: if (compare_x_2(point, *next) != SMALLER) return ON_BOUNDARY; break; case EQUAL: return ON_BOUNDARY; case LARGER: if (compare_x_2(point, *next) != LARGER) return ON_BOUNDARY; break; } break; case LARGER: if (compare_x_2(point, *current) == EQUAL) { return ON_BOUNDARY; } break; } break; case LARGER: switch (next_y_comp_res) { case SMALLER: switch (i_polygon::which_side_in_slab(point, *next, *current, orientation_2, compare_x_2)) { case -1: IsInside = !IsInside; break; case 0: return ON_BOUNDARY; } break; case EQUAL: if (compare_x_2(point, *next) == EQUAL) { return ON_BOUNDARY; } break; case LARGER: break; } break; } current = next; cur_y_comp_res = next_y_comp_res; ++next; if (next == last) next = first; } while (current != first); return IsInside ? ON_BOUNDED_SIDE : ON_UNBOUNDED_SIDE; } //-----------------------------------------------------------------------// // orientation_2 //-----------------------------------------------------------------------// // uses Traits::Less_xy_2 (used by left_vertex_2) // Traits::orientation_2_object() namespace Polygon { namespace internal { // This exists because the "is_simple_2" precondition in the orientation_2() function is in fact // stronger than necessary: it also works for strictly simple polygons, which matters for // Straight line skeletons, as the offset polygons might have non-manifoldness. template Orientation orientation_2_no_precondition(ForwardIterator first, ForwardIterator last, const Traits& traits) { ForwardIterator i = left_vertex_2(first, last, traits); ForwardIterator prev = (i == first) ? last : i; --prev; ForwardIterator next = i; ++next; if (next == last) next = first; // if the range [first,last) contains fewer than three points, then some // of the points (prev,i,next) will coincide // return the orientation of the triple (prev,i,next) typedef typename Traits::Point_2 Point; return traits.orientation_2_object()(Point(*prev), Point(*i), Point(*next)); } } // namespace internal } // namespace Polygon template Orientation orientation_2(ForwardIterator first, ForwardIterator last, const Traits& traits) { CGAL_precondition(is_simple_2(first, last, traits)); return Polygon::internal::orientation_2_no_precondition(first, last, traits); } } //namespace CGAL /// \endcond // Local Variables: // c-basic-offset: 4 // End: