se/SE/dev/php-cli/edge_paths_with_PE_controll.xsl

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
    xmlns:xs="http://www.w3.org/2001/XMLSchema"
    xmlns:bp="https://procesy5.pl/biale_plamy-schema.xsd"
    
    
    exclude-result-prefixes="xs"
    version="2.0">
    
    <xsl:import href="PE_wariant_bit_table.xsl"/>
    
    <xsl:output indent="yes"/>
    <xsl:strip-space elements="*"/>
    
    <xsl:param name="PE_Price" select="2500"/>
    <xsl:param name="Cable_Price" select="3"/>
    <xsl:param name="max_combinate_groups_elements" select="10"/> <!-- po ile wezlow mamy grupowac do wyliczania kombinacji kosztow -->
    <xsl:param name="logic" select="'grouped'"/> <!-- tutaj robi grupy po $max_combinate_groups_elements -->
    <!--<xsl:param name="logic" select="'sorted'"/>--> <!-- tutaj robi grupy ale analizyje w grupie tylko wazniejsze/bardziej oblozone wezly -->
    
    <xsl:param name="debug"/>
    
    
    <xsl:param name="edge_paths_with_PE.xml"/>
    <xsl:param name="edge_paths_with_PE_controll_temp" select="'edge_paths_with_PE_controll_temp'"/> <!-- cache do przekazywani danych z petli-->
    <xsl:param name="edge_paths_with_PE_controll_temp.alias" select="'edge_paths_with_PE_controll_temp.alias'" />
    
    <!-- bedziemy od najdluzszej drogi starac sie rozmiescic PE w oparciu o rozmieszczenie klientow oraz odleglosci  -->
    
    
    
    <xsl:template match="edge_joins_filled_paths">
        <xsl:message>Running script for params:
            PE_Price=<xsl:value-of select="$PE_Price"/>
            Cable_Price=<xsl:value-of select="$Cable_Price"/>
            max_combinate_groups_elements=<xsl:value-of select="$max_combinate_groups_elements"/>
            logic=<xsl:value-of select="$logic"/> .EOF
        </xsl:message>
        <xsl:variable name="edge_joins_filled_paths_len">
            <xsl:for-each select="item">
                <xsl:sort select="number(asText/@len)" order="descending"/>
                <Path>
                    <xsl:attribute name="id" select="@id"/>
                    <xsl:attribute name="len" select="asText/@len"/>
                    <xsl:attribute name="Points_cnt" select="asText/@Points_cnt"/>
                </Path>
            </xsl:for-each>
        </xsl:variable>
       
            <edge_paths_with_PE_controll>
                <xsl:attribute name="logic" select="$logic"/>
               <xsl:apply-templates select="$edge_joins_filled_paths_len" mode="PointMatrixGroup"/>
            </edge_paths_with_PE_controll>
        
        <!--<xsl:result-document href="edge_paths_with_PE.xml">
             <xsl:apply-templates select="$edge_paths_with_PE_controll" mode="edge_paths_with_PE.xml"/>
        </xsl:result-document>-->
    </xsl:template>
    
    
    
       <xsl:template match="Path" mode="PointMatrixGroup">
        <Path>
            <xsl:variable name="edge_joins_filled_path" select=" doc(concat('edge_joins_filled_paths/edge_joins_filled_paths.',@id,'.xml'))"/>
            <xsl:attribute name="id" select="@id"/>
            <xsl:variable name="ID_Way" select="@id"/>
            <xsl:attribute name="Points_cnt" select="@Points_cnt"/>
            <xsl:variable name="Points_cnt" select="@Points_cnt"/>
            <xsl:attribute name="len" select="@len"/>
            <xsl:attribute name="Count" select="count($edge_joins_filled_path/edge_joins_filled_paths_xml/asText_XMl/LineString)"/>
            <xsl:variable name="len" select="@len"/>
            <xsl:message> Path dla ID_Way=<xsl:value-of select="$ID_Way"/>; len=<xsl:value-of select="@len"/>; Count=<xsl:value-of select="count($edge_joins_filled_path/edge_joins_filled_paths_xml/asText_XMl/LineString)"/>
                Points_cnt=<xsl:value-of select="@Points_cnt"/>
            </xsl:message>
        <!--<xsl:variable name="edge_joins_filled_paths" select="collection( 'edge_joins_filled_paths?select=*.xml;recurse=yes')"/>-->
        
        <!--<EdgeWayJoinsPair>
            <xsl:copy-of select="$edge_joins_filled_path"></xsl:copy-of>
        </EdgeWayJoinsPair>-->
        
        <!-- liczmy najwieksza roznice odleglosci miedzy punktami -->
        
        
        <!-- rozmieszczamy prawidlowo PE na danej trasie -->
        <xsl:variable name="EconomicDistanceCut">
            <EconomicDistanceCut>
                <xsl:for-each select="$edge_joins_filled_path/edge_joins_filled_paths_xml/asText_XMl/LineString">
                        <distance>
                            <xsl:attribute name="pos" select="position()"/>
                            <xsl:attribute name="not_id" select="@not_id"/>
                            <xsl:attribute name="len" select="@len"/>
                            <xsl:attribute name="id_path" select="@id_path"/>
                            <xsl:variable name="Points" select="count(Points)"/>
                            <xsl:attribute name="Points" select="$Points"/>
                            <xsl:variable name="Ways" select="count(Ways)"/>
                            <xsl:attribute name="Ways_count" select="$Ways"/> 
                            <xsl:choose>
                            <xsl:when test="$Ways or $Points">
                                <xsl:attribute name="point_count" select="$Points + $Ways"/>
                                <!--<xsl:attribute name="NotPoints" select="0"/>--><!-- do Grupowanai potrzebne aby nie liczyc tych w count -->
                            </xsl:when>
                            <xsl:otherwise><xsl:attribute name="NotPoints" select="1"/>
                                <xsl:attribute name="point_count" select="0"/>
                            </xsl:otherwise><!-- do Grupowanai potrzebne aby nie liczyc tych w count -->
                        </xsl:choose>
                        </distance>
                    </xsl:for-each>
            </EconomicDistanceCut>
        </xsl:variable>
        <!--<xsl:copy-of select="$EconomicDistanceCut"/>-->
            
            <xsl:variable name="EconomicDistanceCut2">
                <EconomicDistanceCut2>
                    <xsl:for-each select="$EconomicDistanceCut/EconomicDistanceCut/distance">
                        <distance2>
                            <xsl:attribute name="distance" select="sum( $EconomicDistanceCut/EconomicDistanceCut/distance[number(@pos )&lt;  number(current()/@pos )]/@len)"/>
                            <!-- suma do poprzedniego pkt tylko dla tych co maja pkt-->
                            <xsl:choose>
                                <xsl:when test="number(@point_count)&gt;0">
                                    <xsl:variable name="max_pos_z_pkt" select="max($EconomicDistanceCut/EconomicDistanceCut/distance[
                                        number(@pos )&lt;  number(current()/@pos ) and number(@point_count)&gt;0
                                        ]/@pos)"/>
                                    <xsl:attribute name="max_pos_z_pkt" select="$max_pos_z_pkt"/>
                                    <xsl:variable name="disttopkt" select="sum( $EconomicDistanceCut/EconomicDistanceCut/distance[
                                        number(@pos )&lt;  number(current()/@pos )
                                        and number(@pos) &gt;= number($max_pos_z_pkt) 
                                        ]/@len)"/>
                                    <xsl:attribute name="disttopkt" select="$disttopkt" />
                                    <xsl:variable name="cost_dist" select="$Cable_Price * $disttopkt * number(@point_count)"/>
                                    <xsl:attribute name="cost_dist" select="$cost_dist"/>
                                    <xsl:attribute name="point_count" select="@point_count"/>
                                    <xsl:attribute name="Ways_count" select="@Ways_count"/>
                                    <xsl:choose> <!-- to powinno przeciac grupe ale moze nie? -->
                                        <xsl:when test="$cost_dist &gt; $PE_Price">
                                            <xsl:attribute name="cut_by_pe" select="1"/>
                                        </xsl:when>
                                        <xsl:otherwise><xsl:attribute name="cut_by_pe" select="0"/></xsl:otherwise>
                                    </xsl:choose>
                                    <xsl:attribute name="not_id" select="@not_id"/> <!-- to jest z ID way - way ma 2 pointsy! -->
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:choose>
                                        <xsl:when test="number(@Ways_count)&gt;0">
                                            <xsl:attribute name="point_count" select="@Ways_count"/>
                                        </xsl:when>
                                        <xsl:otherwise><xsl:attribute name="point_count" select="0"/></xsl:otherwise>
                                    </xsl:choose>
                                </xsl:otherwise>
                            </xsl:choose>
                            <xsl:attribute name="id_path" select="@id_path"/>
                            <xsl:copy-of select="@point_count"/>
                            <xsl:copy-of select="@pos"/><!-- position() -->
                            <xsl:copy-of select="@len"/>
                            <xsl:copy-of select="@ForceCutByPrice"/>
                            <!--<xsl:copy-of select="@NotPoints"/>--><!--debug -->
                        </distance2>
                    </xsl:for-each>
                </EconomicDistanceCut2>
            </xsl:variable>
            
            <xsl:copy-of select="$EconomicDistanceCut"/>
            
            
            <xsl:variable name="EconomicDistanceCut2">
                <EconomicDistanceCut2><xsl:attribute name="debug" select="'bez pustych punktow tylko grupowanie'"/>
                    <xsl:for-each select="$EconomicDistanceCut2/EconomicDistanceCut2/distance2[number(@point_count) &gt; 0 ]">
                        <distance2>
                            <xsl:copy-of select="@*"/>
                            <xsl:choose>
                                <xsl:when test=" position()  mod $max_combinate_groups_elements = 0">  <!--- minus puste sum($EconomicDistanceCut/EconomicDistanceCut/distance[ number(@pos) &lt; number(current()/@pos) ]/number(@NotPoints)) ) --><!-- nabija grupe do przeliczenia-->
                                    <xsl:attribute name="PosCut3Flag" select="1"/>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:attribute name="PosCut3Flag" select="0"/>
                                </xsl:otherwise>
                            </xsl:choose>
                        </distance2>
                    </xsl:for-each>
                </EconomicDistanceCut2>
            </xsl:variable>
            
            
            <xsl:variable name="EconomicDistanceCut2"> <!-- dla potrzeb przegrupowania po iles do wyliczen grup i posortowania -->
                <EconomicDistanceCut2><xsl:attribute name="debug" select="'add mod gr'"/>
                    <xsl:for-each select="$EconomicDistanceCut2/EconomicDistanceCut2/distance2"> <!-- [@point_count &gt; 0] -->
                        <distance2>
                            <xsl:attribute name="PosCut3GrId" select="sum($EconomicDistanceCut2/EconomicDistanceCut2/distance2[ number(@pos) &lt; number(current()/@pos) ]/number(@PosCut3Flag))"/>
                            <xsl:copy-of select="@*"/>
                        </distance2>
                    </xsl:for-each>
                </EconomicDistanceCut2>
            </xsl:variable>
            
            <!-- debug -->
            <!--<EconomicDistanceCut2><xsl:attribute name="debug" select="'#183 just show PosCut3GrId data'"/>
                <xsl:for-each select="$EconomicDistanceCut2/EconomicDistanceCut2/distance2">
                    <distance2>
                        <xsl:attribute name="fl" select="@PosCut3Flag"/>
                        <xsl:copy-of select="@PosCut3GrId"/>
                        <xsl:copy-of select="@CurSumNotPoints"/>
                        <xsl:copy-of select="@NotPoints"/>
                        <!-\-<xsl:copy-of select="@pos"/>-\->
                    </distance2>
                </xsl:for-each>
            </EconomicDistanceCut2>-->
            <!--<xsl:copy-of select="$EconomicDistanceCut2"/>-->
            
            
            <xsl:variable name="elements_cnt" select="count($EconomicDistanceCut2/EconomicDistanceCut2/distance2[@point_count &gt; 0])"/><!-- liczba wezlow potencjalnych licbza PE-->
            <!--<xsl:variable name="bit_max" select="round($len  div  ( $PE_Price div $Cable_Price ) + count($EconomicDistanceCut2/EconomicDistanceCut2/distance2[@cost_dist &gt; $PE_Price])  )"/>--><!-- max licbza PE-->
            
            
            
            <!-- pogrupujemy elementy co 50 metrow lub grupy ilosciowe -->
            <xsl:variable name="PointMatrixGroup">
                <PointMatrixGroup>
                    <xsl:for-each-group select="$EconomicDistanceCut2/EconomicDistanceCut2/distance2" group-by="@PosCut3GrId "> <!-- stare : round( @distance div ( $PE_Price div $Cable_Price + 50 ))-->
                        <PointMatrixGroupPos>
                            <xsl:variable name="elements_cnt_Pos" select="count(current-group()[@point_count &gt; 0])"/> 
                            <xsl:variable name="countGr" select="count(current-group())"/>
                            <xsl:variable name="bit_max_Pos" select="round(sum( current-group()/@disttopkt )  div  ( $PE_Price div 20 ) )"/>
                            <xsl:message>Nowa grupa Ways:<xsl:value-of select="@PosCut3GrId"/>; distanceGr=<xsl:value-of select="@PosCut3GrId"/>;elements_cnt_Pos=<xsl:value-of select="$elements_cnt_Pos"/>;  @bit_max_Pos=<xsl:value-of select="$bit_max_Pos"/>; @id_path=<xsl:value-of select="@id_path"/>; countGr=<xsl:value-of select="$countGr"/>; point_count_Pos=<xsl:value-of select="sum(current-group()/@point_count)"/>; len_sum=<xsl:value-of select="sum(current-group()/@len)"/> ; distanceBeg/distanceEnd= <xsl:value-of select="min(current-group()/number(@distance))"/>/<xsl:value-of select="max(current-group()/number(@distance))"/>
                            </xsl:message>
                            <xsl:attribute name="distanceGr" select="@PosCut3GrId "/> <!-- bylo current-grouping-key() -->
                            <xsl:attribute name="elements_cnt_Pos" select="$elements_cnt_Pos"/>
                            <xsl:attribute name="bit_max_Pos" select="$bit_max_Pos"/>
                            <xsl:attribute name="id_path" select="@id_path"/>
                            <xsl:attribute name="point_count_Pos" select="sum(current-group()/@point_count)"/><!-- po przesortowaniu z usunieciem wezlow bez skojarzen przylaczy - jest to nieprawdziwe - rzebaa dodac te dane z poprzednich sciezek itp -->
                            <xsl:attribute name="LineStringCount" select="count( current-group())"/>
                            <xsl:attribute name="len_sum" select="sum(current-group()/@len)"/>
                            <xsl:attribute name="distanceBeg" select="min(current-group()/number(@distance))"/>
                            <xsl:attribute name="distanceEnd" select="max(current-group()/number(@distance))"/>
                            <xsl:attribute name="countGr" select="$countGr"/>
                            <!--<xsl:attribute name="GroupPos" select="position()"/>-->
                                <xsl:for-each select="current-group()">
                                    <distance2>
                                        <xsl:attribute name="PosMatrGroup" select="position()"/>
                                        <xsl:copy-of select="@*"></xsl:copy-of>
                                    </distance2>
                                </xsl:for-each>
                        </PointMatrixGroupPos>
                     </xsl:for-each-group>
                </PointMatrixGroup>
            </xsl:variable>
            <!-- wsadzamy PE w grupach i moze w kilku wariantach - najlepiej tam gdzie jest najwiecej klientow najpierw 
                gdzie najwiecej klientow walimy wezly - grupujemy ilosciami klientow dzielac sume drogi na ilosc przewidzianych wezlow
            -->
            <!-- debug -->
           
            <!--<xsl:copy-of select="$PointMatrixGroup"/>-->
            <PointMatrixGroupPE>
            <xsl:for-each select="$PointMatrixGroup/PointMatrixGroup">
                <xsl:for-each select="PointMatrixGroupPos">
                <xsl:variable name="bit_max_Pos" select="@bit_max_Pos"/>
                <xsl:variable name="point_count_Pos" select="@point_count_Pos"/>
                <xsl:variable name="distanceGr" select="@distanceGr"/>
                    <PointMatrixGroup>
                        <xsl:attribute name="bit_max_Pos" select="$bit_max_Pos"/>
                        <xsl:attribute name="point_count_Pos" select="$point_count_Pos"/>
                        <xsl:attribute name="distanceGr" select="$distanceGr"/>
                        <xsl:attribute name="LineStringCount" select="@LineStringCount"/>
                        <xsl:attribute name="len_sum" select="@len_sum"/>
                        <xsl:attribute name="point_count_Pos" select="@point_count_Pos"/>
                        <xsl:attribute name="distanceBeg" select="@distanceBeg"/>
                        <xsl:attribute name="distanceEnd" select="@distanceEnd"/>
                        <xsl:message>#239: calc @distanceGr=<xsl:value-of select="$distanceGr"/>; @point_count_Pos=<xsl:value-of select="@point_count_Pos"/>;@LineStringCount ; @len_sum=<xsl:value-of select="@len_sum"/>; @distanceBeg=<xsl:value-of select="@distanceBeg"/>; @distanceEnd=<xsl:value-of select="@distanceEnd"/>;
                        </xsl:message>
                <!-- ida kandydaci -->
                        <xsl:variable name="candidates">
                            <xsl:for-each select="distance2[ (  $logic='sorted' and ( ( position() &lt;= $bit_max_Pos and @point_count &gt;0 ) or (  position()=1 and $point_count_Pos &gt; 0 )  ) or position()= last()  )   or ( @point_count &gt;0 and $logic='grouped'  )  ]">  <!--@point_count &gt;0-->  <!--( position() &lt;= $bit_max_Pos and @point_count &gt;0 ) or (  position()=1 and $point_count_Pos &gt; 0 )  or position()= last() --> <!-- jak jest maly wspolczynnik to chociaz jeden punkt jak sa punkty jakies w tej grupie -->
                                    <xsl:sort select="@cost_dist" order="descending"/>
                                    <bp:Path_Point>
                                        <xsl:attribute name="DebugPosPoint" select="position()"/>
                                        <xsl:attribute name="PosMatrGroup" select="@PosMatrGroup"/>
                                        <xsl:attribute name="distanceGr" select="$distanceGr"/>
                                        <xsl:attribute name="pos" select="@pos"/>
                                        <xsl:attribute name="len" select="@len"/>
                                        <xsl:attribute name="distance" select="@distance"/>
                                        <xsl:attribute name="cost_dist" select="@cost_dist"/>
                                        <xsl:attribute name="id_path" select="@id_path"/>
                                        <xsl:attribute name="point_count" select="@point_count"/>
                                        <xsl:attribute name="X" select="$edge_joins_filled_path/edge_joins_filled_paths_xml/asText_XMl/LineString[@id_path = current()/@id_path]/@X"/>
                                        <xsl:attribute name="Y" select="$edge_joins_filled_path/edge_joins_filled_paths_xml/asText_XMl/LineString[@id_path = current()/@id_path]/@Y"/>
                                    </bp:Path_Point>
                                </xsl:for-each>
                        </xsl:variable>
                    
                    
                    <!-- potrzebuje wywolac petle raz, aby sie do niej odniesc drugi raz z poprzednim wynikiem
                       $last = A
                        - najprosciej przez pliki oszukujac silnik xsl
                        - tozsamowsci $ID_Way $distanceGr
                        - do edge_paths_with_PE_controll_temp, read z edge_paths_with_PE_controll_temp.alias
                    -->
                        <xsl:variable name="cache_file_name" select="concat($edge_paths_with_PE_controll_temp,'/odpalam_liczenie_or_nie_',$ID_Way,'_',$distanceGr,'.xml')"/>
                        <xsl:variable name="PrevdistanceGr" select="number($distanceGr) - 1"/>
                        <xsl:variable name="cache_file_name_previous" select="concat( $edge_paths_with_PE_controll_temp.alias,'/odpalam_liczenie_or_nie_',$ID_Way,'_',$PrevdistanceGr,'.xml')"/>
                        <xsl:variable name="poprzednie_odpalam_liczenie_or_nie">
                            <xsl:if test="$PrevdistanceGr &gt; 0 ">
                                <xsl:copy-of select="doc($cache_file_name_previous)"/>
                            </xsl:if>
                        </xsl:variable>
                        <!--<poprzednie_odpalam_liczenie_or_nie>
                            <xsl:attribute name="cache_file_name_previous" select="$cache_file_name_previous"/>
                            <xsl:copy-of select="$poprzednie_odpalam_liczenie_or_nie/poprzednie_odpalam_liczenie_or_nie"/>
                        </poprzednie_odpalam_liczenie_or_nie>-->
                        <xsl:variable name="odpalam_liczenie_or_nie">
                            <xsl:choose>
                                <xsl:when test="count($candidates/bp:Path_Point) &lt;= $max_combinate_groups_elements  and count($candidates/bp:Path_Point)&gt;1">
                                    <xsl:variable name="max_bit">
                                        <xsl:for-each select="1 to count($candidates/bp:Path_Point)"><xsl:value-of select="1"/></xsl:for-each>
                                    </xsl:variable>
                                    <odpalam_liczenie>
                                        <!-- todo dolozyc poprzedni wezel dodany aby mogl od niego zawsze liczyc -->
                                        <xsl:call-template name="calculate_optimum">
                                            <xsl:with-param name="candidates" select="$candidates"/>
                                            <xsl:with-param name="elements_cnt" select="count($candidates/bp:Path_Point)"/>
                                            <xsl:with-param name="max_bit" select="$max_bit"/>
                                            <xsl:with-param name="poprzednie_odpalam_liczenie_or_nie" select="$poprzednie_odpalam_liczenie_or_nie/poprzednie_odpalam_liczenie_or_nie"/>
                                        </xsl:call-template>
                                    </odpalam_liczenie>
                                </xsl:when>
                                <xsl:otherwise>
                                    <xsl:for-each select="$candidates/bp:Path_Point">
                                        <bp:Path_Point>
                                            <xsl:copy-of select="@*"/>
                                            <xsl:attribute name="bin_pos" select="1"/>
                                        </bp:Path_Point>
                                    </xsl:for-each>
                                    <!--<xsl:copy-of select="$candidates"></xsl:copy-of>-->
                                </xsl:otherwise>
                            </xsl:choose>
                        </xsl:variable>
                        <xsl:copy-of select="$odpalam_liczenie_or_nie"/>
                        <xsl:result-document href="{$cache_file_name}"> <!-- zapisanie do cache, aby odczytac w kolejnej petli-->
                            <poprzednie_odpalam_liczenie_or_nie>
                                <xsl:for-each select="$odpalam_liczenie_or_nie/odpalam_liczenie/koniec_wariantow/bp:Path_Point">
                                    <xsl:if test="position() = last()">
                                        <xsl:copy-of select="."/>
                                    </xsl:if>
                                </xsl:for-each>
                                <nizej_zwykly></nizej_zwykly>
                                <xsl:for-each select="$odpalam_liczenie_or_nie/bp:Path_Point">
                                    <xsl:if test="position() = last()">
                                        <xsl:copy-of select="."/>
                                    </xsl:if>
                                </xsl:for-each>
                                <!--<xsl:copy-of select="$odpalam_liczenie_or_nie/odpalam_liczenie/koniec_wariantow/bp:Path_Point"/>
                                <xsl:copy-of select="$odpalam_liczenie_or_nie/bp:Path_Point"/>-->
                            </poprzednie_odpalam_liczenie_or_nie>
                        </xsl:result-document>
                    </PointMatrixGroup>
                </xsl:for-each>
            </xsl:for-each>
            </PointMatrixGroupPE>
            
            <!--<PointMatrix>
                   <xsl:attribute name="bit_max" select="$bit_max"/>
                <xsl:attribute name="elements_cnt" select="$elements_cnt"/>
                
                <xsl:attribute name="num_extr" select="count($EconomicDistanceCut2/EconomicDistanceCut2/distance2[@cost_dist &gt; $PE_Price])"/>
                <!-\-<xsl:call-template name="PE_wariant">
                    <xsl:with-param name="elements_cnt" select="$elements_cnt"/>
                    <xsl:with-param name="bit_max" select="$bit_max"/>
                </xsl:call-template>-\->
                
            </PointMatrix>-->
        </Path>
    </xsl:template>
    
    
    
    
    
    
    <xsl:template name="calculate_optimum">
        <xsl:param name="candidates" required="yes"/>
        <xsl:param name="elements_cnt" required="yes"/>
        <xsl:param name="variant"  select="1"/>
        <xsl:param name="max_bit" required="yes"/>
        <xsl:param name="best_cost"/><xsl:param name="best_variant"/>
        <xsl:param name="poprzednie_odpalam_liczenie_or_nie"/>
        <xsl:variable name="bit" select=" string-join(bp:decimalToBitFill($variant,$elements_cnt),'')"/>
        <xsl:variable name="cand_to_calc">
            <xsl:for-each select="$candidates/bp:Path_Point">
                <xsl:sort select="@distance"/>
                <bp:Path_Point>
                    <!--<xsl:attribute name="bit" select="$bit"/>-->
                    <xsl:attribute name="bin_pos"  select="substring($bit, position(),1)"/>
                    <xsl:copy-of select="@*"/>
                    <xsl:copy-of select="bp:Path_Point"></xsl:copy-of>
                </bp:Path_Point>
            </xsl:for-each>
        </xsl:variable>
        <!-- debug -->
        <xsl:if test="$debug">
            <variant><xsl:attribute name="variant" select="$variant"/>
                <xsl:attribute name="cur_bit" select="$bit"/>
                <xsl:attribute name="best_cost" select="$best_cost"/>
                <xsl:attribute name="best_variant" select="$best_variant"/>
                <xsl:copy-of select="$cand_to_calc"/>
            </variant>
        </xsl:if>
        <xsl:variable name="calc_cost_way">
            <xsl:call-template name="calc_cost_way">
                <xsl:with-param name="cand_to_calc" select="$cand_to_calc"/>
                <xsl:with-param name="poprzednie_odpalam_liczenie_or_nie" select="$poprzednie_odpalam_liczenie_or_nie"/>
            </xsl:call-template>
        </xsl:variable>
        <xsl:variable name="cost_sum">
            <costs>
                <xsl:attribute name="Cable_Price" select="sum($calc_cost_way/cost/@Cable_Price)" />
                <xsl:attribute name="PE_Price" select="sum($calc_cost_way/cost/@PE_Price)"/>
                <xsl:attribute name="Price" select="sum($calc_cost_way/cost/@Price)"/>
                <xsl:copy-of select="$calc_cost_way"/>    
            </costs>
        </xsl:variable>
        <xsl:if test="$debug"><xsl:copy-of select="$cost_sum"/></xsl:if>
        <xsl:variable name="best">
            <xsl:variable name="cur_Price" select="$cost_sum/costs/@Price"/>
            <xsl:choose>
                <xsl:when test="number($cur_Price) &lt; number($best_cost) or not($best_cost) ">
                    <best>
                        <xsl:attribute name="best_cost" select="$cur_Price"/>
                        <xsl:attribute name="best_variant" select="$bit"/>
                    </best>
                </xsl:when>
                <xsl:otherwise>
                    <best>
                        <xsl:attribute name="best_cost" select="$best_cost"/>
                        <xsl:attribute name="best_variant" select="$best_variant"/>
                    </best>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:variable>
        <xsl:if test="$debug"><xsl:copy-of select="$best"/></xsl:if>
        <xsl:choose>
            <xsl:when test="$bit = $max_bit">
                <koniec_wariantow>
                    <xsl:message>#410 OK - przeliczony wariant bit=<xsl:value-of select="$best_variant"/> ( nr <xsl:value-of select="$variant"/>;) </xsl:message>
                    <xsl:attribute name="best_variant" select="$best_variant"/>
                    <xsl:for-each select="$candidates/bp:Path_Point">
                    <xsl:sort select="@distance"/>
                    <xsl:if test="substring($best_variant, position(),1)='1'"><!-- jak wystawiony w wariancie-->
                        <bp:Path_Point>
                            <xsl:attribute name="bit" select="$best_variant"/>
                            <xsl:attribute name="bin_pos"  select="substring($best_variant, position(),1)"/>
                            <xsl:copy-of select="@*"/>
                            <xsl:attribute name="Price" select="$best_cost"/>
                            <xsl:copy-of select="bp:Path_Point"/>
                        </bp:Path_Point>
                    </xsl:if>
                    </xsl:for-each>
                 </koniec_wariantow>
            </xsl:when>
            <xsl:otherwise>
                <xsl:call-template name="calculate_optimum">
                    <xsl:with-param name="candidates" select="$candidates"/>
                    <xsl:with-param name="max_bit" select="$max_bit"/>
                    <xsl:with-param name="variant" select="$variant + 1"/>
                    <xsl:with-param name="elements_cnt" select="$elements_cnt"/>
                    <xsl:with-param name="best_cost" select="$best/best/@best_cost"/>
                    <xsl:with-param name="best_variant" select="$best/best/@best_variant"/>
                    <xsl:with-param name="poprzednie_odpalam_liczenie_or_nie" select="$poprzednie_odpalam_liczenie_or_nie"/>
                </xsl:call-template>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:template>
    
    <xsl:template name="calc_cost_way"><!-- do wyliczenia ile wyjda kable w takiej konfiguracji -->
        <xsl:param name="cand_to_calc" required="yes"/>
        <xsl:param name="poprzednie_odpalam_liczenie_or_nie"/>
        
        <xsl:variable name="candidates_merged_with_poprzednie">
            <xsl:for-each select="$poprzednie_odpalam_liczenie_or_nie/*">
                <bp:Path_Point>
                    <xsl:attribute name="poprzednia_grupa" select="true()"/>
                    <xsl:copy-of select="@*"/>
                </bp:Path_Point>
            </xsl:for-each>
            <xsl:for-each select="$cand_to_calc/bp:Path_Point">
                <bp:Path_Point>
                    <xsl:copy-of select="@*"/>
                </bp:Path_Point>
            </xsl:for-each>
            <!--<xsl:copy-of select="$cand_to_calc/bp:Path_Point"/>-->
        </xsl:variable>
        <xsl:if test="$debug">
                <candidates_merged_with_poprzednie>
                    <cand_to_calc><xsl:copy-of select="$cand_to_calc"/></cand_to_calc>
                    <poprzedniee><xsl:copy-of select="$poprzednie_odpalam_liczenie_or_nie/poprzednie_odpalam_liczenie_or_nie"/></poprzedniee>
                    <merged><xsl:copy-of select="$candidates_merged_with_poprzednie"/></merged>
                </candidates_merged_with_poprzednie>
        </xsl:if>
        <xsl:for-each select="$candidates_merged_with_poprzednie/bp:Path_Point"> <!-- bylo cand_to_calc  -->
            <xsl:choose>
                <xsl:when test="@poprzednia_grupa">
                    <cost>
                        <xsl:attribute name="Cable_Price" select="0"/>
                        <xsl:attribute name="PE_Price" select="0"/>
                        <xsl:attribute name="Price" select="0"/>
                        <xsl:attribute name="debug" select="'ignore by last DistGroup @poprzednia_grupa'"/>
                    </cost>
                </xsl:when>
                <xsl:when test="@bin_pos=0"><!-- szukamy gdzie ma najblizej i za ile -->
                    <xsl:variable name="way_up_id" select="max($candidates_merged_with_poprzednie/bp:Path_Point[@bin_pos=1 and @id_path &lt;  current()/@id_path ]/number(@id_path))"/>
                    <xsl:variable name="way_up_len" >
                            <xsl:choose>
                                <xsl:when test="$way_up_id">
                                    <xsl:value-of select="number( current()/@distance) - number($candidates_merged_with_poprzednie/bp:Path_Point[@id_path=$way_up_id]/@distance)"/></xsl:when>
                                <xsl:otherwise><xsl:value-of select="-1"/></xsl:otherwise>
                            </xsl:choose>
                    </xsl:variable>
                    <xsl:variable name="way_dn_id" select="max($candidates_merged_with_poprzednie/bp:Path_Point[@bin_pos=1 and @id_path &gt;  current()/@id_path ]/number(@id_path)) " />
                    <xsl:variable name="way_dn_len">
                        <xsl:choose>
                            <xsl:when test="$way_dn_id">
                                <xsl:value-of select="  number($candidates_merged_with_poprzednie/bp:Path_Point[@id_path=$way_dn_id]/@distance ) -  current()/@distance"/>
                            </xsl:when>
                            <xsl:otherwise><xsl:value-of select="-1"/></xsl:otherwise>
                        </xsl:choose>
                    </xsl:variable>
                    <xsl:choose><!-- czy w gore czy w dol -->
                        <xsl:when test=" number($way_up_len)  &gt;= number($way_dn_len) and  number($way_dn_len) &gt; 0 or $way_up_len=-1"> <!--and not($way_dn_len='NaN') -->
                            <cost>
                                <xsl:variable name="Cable_Price_sum">
                                    <xsl:choose>
                                        <xsl:when test="number(@point_count) &gt; 0 ">
                                            <xsl:value-of select="$Cable_Price * $way_dn_len * number(@point_count) "/>
                                        </xsl:when>
                                        <xsl:otherwise>
                                            <xsl:value-of select="$Cable_Price * $way_dn_len "/> <!-- todo @point_count -->
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:variable>
                                 <!-- todo @point_count -->
                                <xsl:attribute name="PE_Price" select="0"/>
                                <xsl:attribute name="Cable_Price" select="$Cable_Price_sum"/>
                                <xsl:attribute name="Price" select="$Cable_Price_sum"/>
                                <xsl:attribute name="choosed" select="'down'"/>
                                <xsl:attribute name="way_up_id" select="$way_up_id"/><xsl:attribute name="way_up_len" select="$way_up_len"/>
                                <xsl:attribute name="way_dn_id" select="$way_dn_id"/><xsl:attribute name="way_dn_len" select="$way_dn_len"/>
                            </cost>
                        </xsl:when>
                        <xsl:otherwise>
                            <cost>
                                <xsl:variable name="Cable_Price_sum">
                                    <xsl:choose>
                                        <xsl:when test="number(@point_count) &gt; 0 ">
                                            <xsl:value-of select="$Cable_Price * $way_up_len * number(@point_count) "/>
                                        </xsl:when>
                                        <xsl:otherwise>
                                            <xsl:value-of select="$Cable_Price * $way_up_len "/> <!-- todo @point_count -->
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:variable>
                                <xsl:attribute name="Cable_Price" select="$Cable_Price_sum"/> <!-- todo @point_count -->
                                <xsl:attribute name="PE_Price" select="0"/>
                                <xsl:attribute name="Price" select="$Cable_Price_sum"/>
                                <xsl:attribute name="choosed" select="'up'"/>
                                <xsl:attribute name="way_up_id" select="$way_up_id"/><xsl:attribute name="way_up_len" select="$way_up_len"/>
                                <xsl:attribute name="way_dn_id" select="$way_dn_id"/><xsl:attribute name="way_dn_len" select="$way_dn_len"/>
                            </cost>
                        </xsl:otherwise>
                    </xsl:choose>
                </xsl:when>
                <xsl:otherwise>
                    <cost>
                        <xsl:attribute name="Cable_Price" select="0"/>
                        <xsl:attribute name="PE_Price" select="$PE_Price"/>
                        <xsl:attribute name="Price" select="$PE_Price"/>
                        <xsl:attribute name="mial_bin_pos" select="@bin_pos"/>
                    </cost>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:for-each>
    </xsl:template>
    
    
    
    
    
    
    
    
    
    
    
    
</xsl:stylesheet>