Source for file PolarAutoLap.class.php

Documentation is available at PolarAutoLap.class.php

  1. <?php
  2. /**
  3.  * Class to automatize laps generation for distance steps and interval training
  4.  *
  5.  * @author    Jean-Philippe Brunon <jp75018@free.fr>
  6.  * @copyright    2007-2009 Jean-Philippe Brunon
  7.  * @license    http://www.opensource.org/licenses/gpl-license.php GPL
  8.  * @package    php-endurance
  9.  * @version    $Id: PolarAutoLap.class.php 64 2009-03-25 13:42:20Z jp75018 $
  10.  */
  11.  
  12. /**
  13.  * General configuration file
  14.  */
  15. require_once ('conf/config.php');
  16. /**
  17.  * Output is language dependant
  18.  */
  19. require_once ('lang/strings_' . $GLOBALS['lang'] . '.inc.php');
  20. /**
  21.  * HTML output (formatting)
  22.  */
  23. require_once ('include/html.php');
  24.  
  25. /**
  26.  * Class to automatize laps generation for distance steps and interval training
  27.  */
  28. class PolarAutoLap
  29. {
  30. /**
  31.  * Sport standard alias (use to compute mechanical energy)
  32.  * @var string 
  33.  */
  34.   var    $sport_alias;
  35.  
  36. /**
  37.  * Class constructor
  38.  *
  39.  * @param    string  $sport_alias Standard sport alias
  40.  * @return      void 
  41.  */
  42.   function PolarAutoLap ($sport_alias)
  43.   {
  44.     $this->sport_alias = $sport_alias;
  45.   }
  46.  
  47. /**
  48.  * Generate laps array from detailed HR data for every time or distance step, or
  49.  * for each slope change
  50.  *
  51.  * @param    string    $lap_type Lap type in ('time','distance','altitude')
  52.  * @param    array    $data Heart rate data
  53.  * @param    integer    $interval Recording interval (seconds)
  54.  * @param    integer    $distance Real distance (meters, if speed measure)
  55.  * @param    integer    $rest_hr Rest heart rate of runner
  56.  * @param    integer    $weight Weight of runner (Kg), to compute energy if > 0
  57.  * @param    integer    $step_or_delta_h Lap step (sec*10 or meters) or delta H
  58.  * @param    integer    $vma VMA in km/h to compute physio energy
  59.  * @return    array    Array of laps with same structure as 'plw_lap' SQL table
  60.  */
  61.   function generate_auto_laps($lap_type, $data, $interval, $distance,
  62.     $rest_hr, $weight, $step_or_delta_h, $vma)
  63.   {
  64.     $data_nb = count($data);
  65.     $laps = array();
  66.  
  67.     switch ($lap_type)
  68.     {
  69.     case 'time' :
  70.       $step = $step_or_delta_h;
  71.     // Compute subtotal groups from time step
  72.       switch ($step)
  73.       {
  74.       case 300 :
  75.       case 18000 :
  76.     $step_nb = 2;
  77.     break;
  78.       case 600 :
  79.     $step_nb = 5;
  80.     break;
  81.       case 3000 :
  82.     $step_nb = 6;
  83.     break;
  84.       default :    // 150, 9000, 36000
  85.     $step_nb = 4;
  86.       }
  87.       break;
  88.     case 'distance' :
  89.       $step = $step_or_delta_h;
  90.     // Compute subtotal groups from distance step
  91.       switch ($step)
  92.       {
  93.       case 50 :
  94.     $step_nb = 20;
  95.     break;
  96.       case 100 :
  97.     $step_nb = 10;
  98.     break;
  99.       case 1000 :
  100.       case 2000 :
  101.     $step_nb = 5;
  102.     break;
  103.       default :    // 500, 5000
  104.     $step_nb = 2;
  105.       }
  106.       break;
  107.     default :    // altitude
  108.       $delta_h = $step_or_delta_h;
  109.     }
  110.  
  111.     $is_hr = isset($data[0]['hr']);
  112.     $is_speed = isset($data[0]['speed']);
  113.     $is_cad = isset($data[0]['cadence']);
  114.     $is_alti = isset($data[0]['altitude']);
  115.  
  116.     if ($is_speed)
  117.     {
  118.     // Compute ratio to adjust distance
  119.       $d = 0;
  120.       for ($i = 0; $i < $data_nb; $i++)
  121.       { $d += $data[$i]['speed']; }
  122.       if ($d > 0)
  123.       { $d_ratio = $distance / ($d * ($interval / 36)); }
  124.       else
  125.       { $d_ratio = 0; }
  126.       if ($lap_type == 'altitude')
  127.       {
  128.       // Store cumulated distance to check lap distance not too short
  129.     for ($i = 0; $i < $data_nb; $i++)
  130.     {
  131.       $data_dist[$i] = $data_dist[$i - 1] +
  132.         $d_ratio * $data[$i]['speed'] * $interval / 36;
  133.     }
  134.       }
  135.     }
  136.  
  137.   // If 'altitude' laps, 1st pass to set pointers to data for slope change
  138.     if ($lap_type == 'altitude')
  139.     {
  140.     // Minimum altitude change : 2 * MIN_DELTA_ALTITUDE or 2% of exe delta H
  141.       $min_delta_h = 2 * MIN_DELTA_ALTITUDE;
  142.       if (($delta_h / 50) > $min_delta_h)
  143.       { $min_delta_h = $delta_h / 50; }
  144.  
  145.       if ($is_speed)
  146.       {
  147.       // Minimum lap distance : 100m or 0.25% of total distance
  148.     $min_lap_dist = 100;
  149.     if (($distance / 400) > $min_lap_dist)
  150.     { $min_lap_dist = $distance / 400; }
  151.       }
  152.       else
  153.       {
  154.       // Minimum lap duration : 20" or 0.25% of total duration
  155.     $exe_elapsed = $interval * $data_nb;
  156.     $min_lap_time = 20;
  157.     if (($exe_elapsed / 400) > $min_lap_time)
  158.     { $min_lap_time = $exe_elapsed / 400; }
  159.       }
  160.  
  161.       $slope_tab = array();
  162.       $zero_slope = array();
  163.     // Detect slope change
  164.       $slopes = array(
  165.     -0.20, -0.15, -0.10, -0.08, -0.06, -0.04, -0.02, -0.01, -0.005,
  166.     0, 0.005, 0.01, 0.02, 0.04, 0.06, 0.08, 0.10, 0.15, 0.20
  167.       );
  168.       while (list($sl_ind, $sl) = each($slopes))
  169.       {
  170.     $local_min = $data[0]['altitude'];
  171.     $local_min_ind = 0;
  172.     $local_max = $data[0]['altitude'];
  173.     $local_max_ind = 0;
  174.     $p_local = null;
  175.     $d = $d_ratio * $interval * $data[0]['speed'] / 36;
  176.     for ($i = 1; $i < $data_nb; $i++)
  177.     {
  178.     // Pseudo-rotation => Homothety by distance from depart
  179.       if (! $is_speed)
  180.       {
  181.       // If no speed : If distance => Constant speed, if not => 10.8 km/h
  182.         if ($distance)
  183.         { $d = $i * $distance / $data_nb; }
  184.         else
  185.         { $d = $i * $interval * 3; }    // 3 m/s = 10.8 km/h
  186.       }
  187.       $altitude = $data[$i]['altitude'] + $sl * $d;
  188.       if (($altitude >= ($local_min + $min_delta_h)) && ($p_local != 'min'))
  189.       {
  190.         if ($local_min_ind > 0)
  191.         {
  192.           array_push($slope_tab, $local_min_ind);
  193.           if ($sl == 0)    // If slope = 0 => Store for priority
  194.           { array_push($zero_slope, $local_min_ind); }
  195.         }
  196.         $p_local = 'min';
  197.         $local_max = $local_min;
  198.         $local_max_ind = $local_min_ind;
  199.       }
  200.       if ($altitude > $local_max)
  201.       {
  202.         $local_max = $altitude;
  203.         $local_max_ind = $i;
  204.       }
  205.       if (($altitude <= ($local_max - $min_delta_h)) &&
  206.         ($p_local != 'max'))
  207.       {
  208.         if ($local_max_ind > 0)
  209.         {
  210.           array_push($slope_tab, $local_max_ind);
  211.           if ($sl == 0)    // If slope = 0 => Store for priority
  212.           { array_push($zero_slope, $local_max_ind); }
  213.         }
  214.         $p_local = 'max';
  215.         $local_min = $local_max;
  216.         $local_min_ind = $local_max_ind;
  217.       }
  218.       if ($altitude < $local_min)
  219.       {
  220.         $local_min = $altitude;
  221.         $local_min_ind = $i;
  222.       }
  223.       if ($altitude < $alti_local_min)
  224.       { $alti_local_min = $altitude; }
  225.       if ($is_speed)
  226.       { $d += $d_ratio * $interval * $data[$i]['speed'] / 36; }
  227.     }
  228.       }
  229.     // Add last data
  230.       array_push($slope_tab, $data_nb - 1);
  231.       array_push($zero_slope, $data_nb - 1);
  232.     // Remove some pointers if too close (loop till nb of points change)
  233.       $slope_nb = count($slope_tab);
  234.       $prev_slope_nb = $slope_nb + 1;
  235.       while ($slope_nb < $prev_slope_nb)
  236.       {
  237.     $prev_slope_nb = $slope_nb;
  238.     $prev_data_ind = 0;
  239.     for ($i = 0; $i < $slope_nb; $i++)
  240.     {
  241.       if ($is_speed)
  242.       {
  243.         $lap_too_short = (($data_dist[$slope_tab[$i]] -
  244.           $data_dist[$prev_data_ind]) < $min_lap_dist) ? true : false;
  245.       }
  246.       else
  247.       {
  248.         $lap_too_short = ((($slope_tab[$i] - $prev_data_ind) *
  249.           $interval) < $min_lap_time) ? true : false;
  250.       }
  251.       if ($lap_too_short)
  252.       {
  253.         if ($i == ($slope_nb - 1))
  254.         { unset($slope_tab[$i - 1]); }
  255.         else
  256.         {
  257.           if ((! in_array($slope_tab[$i], $zero_slope)) ||
  258.               in_array($prev_data_ind, $zero_slope) || ($i == 0))
  259.           { unset($slope_tab[$i]); }
  260.           if (in_array($slope_tab[$i], $zero_slope) &&
  261.               (! in_array($prev_data_ind, $zero_slope)))
  262.           { unset($slope_tab[$i - 1]); }
  263.         }
  264.       }
  265.       $prev_data_ind = $slope_tab[$i];
  266.     }
  267.     sort($slope_tab);
  268.     $slope_nb = count($slope_tab);
  269.       }
  270.     }
  271.  
  272.     if ($is_hr)
  273.     {
  274.       $beat_nb = 0;
  275.       $hr_ini = $data[0]['hr'];
  276.       $hr_min = $data[0]['hr'];
  277.       $hr_max = $data[0]['hr'];
  278.     }
  279.     if ($is_speed)
  280.     {
  281.       $d = 0;
  282.       $d_lap = 0;
  283.       $speed_ini = $data[0]['speed'];
  284.       $speed_min = $data[0]['speed'];
  285.       $speed_max = $data[0]['speed'];
  286.       $p_speed = 0;
  287.     }
  288.     if ($is_cad)
  289.     {
  290.       $stride_nb = 0;
  291.       $cadence_ini = $data[0]['cadence'];
  292.       $cadence_min = $data[0]['cadence'];
  293.       $cadence_max = $data[0]['cadence'];
  294.       $stride_max = 0;
  295.     }
  296.     if ($is_alti)
  297.     {
  298.       $alti_ini = $data[0]['altitude'];
  299.       $alti_min = $data[0]['altitude'];
  300.       $alti_max = $data[0]['altitude'];
  301.       $ascend = 0;
  302.       $sum_alti = 0;
  303.       $alti_local_min = $data[0]['altitude'];
  304.     }
  305.     if ($weight)
  306.     {
  307.       $air_en = 0;
  308.       $cin_en = 0;
  309.     }
  310.  
  311.     $t_lap = 0;
  312.     $lap_nb = 1;
  313.     for ($i = 0; $i < $data_nb; $i++)
  314.     {
  315.       if ($is_speed)
  316.       {
  317.     $speed = $data[$i]['speed'];
  318.     $dd = $d_ratio * $interval * $speed / 36;
  319.       }
  320.       switch ($lap_type)
  321.       {
  322.       case 'time' :
  323.     $end_lap = (($t_lap + $interval * 10) >= $step) ? true : false;
  324.     break;
  325.       case 'distance' :
  326.     $end_lap = (($d_lap + $dd) >= $step) ? true : false;
  327.     break;
  328.       default :        // altitude
  329.     $end_lap = in_array($i, $slope_tab);
  330.       }
  331.       if ($i == ($data_nb - 1))
  332.       { $end_lap = true; }
  333.       if ($end_lap)
  334.       {
  335.     switch ($lap_type)
  336.     {
  337.     case 'distance' :
  338.       if ($i == ($data_nb - 1))
  339.       {
  340.         $dt = $interval * 10;
  341.         $lap_d = $d_lap + $dd;
  342.         $d += $dd;
  343.       }
  344.       else
  345.       {
  346.         $dt = (($step - $d_lap) / $dd) * $interval * 10;
  347.         $lap_d = $step;
  348.         $d += $step - $d_lap;
  349.       }
  350.       break;
  351.     default :    // time, altitude
  352.       $dt = $interval * 10;
  353.       if ($is_speed)
  354.       {
  355.         $lap_d = $d_lap + $dd;
  356.         $d += $dd;
  357.       }
  358.     }
  359.     $t_lap += $dt;
  360.     if ($is_hr)
  361.     {
  362.       if ($data[$i]['hr'] < $hr_min)
  363.       { $hr_min = $data[$i]['hr']; }
  364.       if ($data[$i]['hr'] > $hr_max)
  365.       { $hr_max = $data[$i]['hr']; }
  366.     }
  367.     if ($is_speed)
  368.     {
  369.       if ($speed < $speed_min)
  370.       { $speed_min = $speed; }
  371.       if ($speed > $speed_max)
  372.       { $speed_max = $speed; }
  373.     }
  374.     if ($is_cad)
  375.     {
  376.       if ($data[$i]['cadence'] < $cadence_min)
  377.       { $cadence_min = $data[$i]['cadence']; }
  378.       if ($data[$i]['cadence'] > $cadence_max)
  379.       { $cadence_max = $data[$i]['cadence']; }
  380.       if ($data[$i]['cadence'] > 0)
  381.       {
  382.         $stride = 250 * $speed / (3 * $data[$i]['cadence']);
  383.         if (($stride > $stride_max) && ($stride <= STRIDE_MAX))
  384.         { $stride_max = $stride; }
  385.       }
  386.     }
  387.     if ($is_alti)
  388.     {
  389.       $sum_alti += $data[$i]['altitude'] * $dt / 10;
  390.       if ($data[$i]['altitude'] < $alti_min)
  391.       { $alti_min = $data[$i]['altitude']; }
  392.       if ($data[$i]['altitude'] > $alti_max)
  393.       { $alti_max = $data[$i]['altitude']; }
  394.       if ($data[$i]['altitude'] >= ($alti_local_min + MIN_DELTA_ALTITUDE))
  395.       {
  396.         $ascend += $data[$i]['altitude'] - $alti_local_min;
  397.         $alti_local_min = $data[$i]['altitude'];
  398.       }
  399.       if ($data[$i]['altitude'] < $alti_local_min)
  400.       { $alti_local_min = $data[$i]['altitude']; }
  401.     }
  402.     if ($weight && $is_speed)
  403.     {
  404.       if ($speed > $p_speed)
  405.       {
  406.         switch ($this->sport_alias)
  407.         {
  408.         case 'running' :
  409.         case 'walking' :
  410.           $cin_en += $speed * $speed - $p_speed * $p_speed;
  411.           break;
  412.         }
  413.       }
  414.       if ($speed > 0)
  415.       {
  416.         switch ($this->sport_alias)
  417.         {
  418.         case 'running' :
  419.         case 'walking' :
  420.           $air_en += ($dt / 10) * $speed * AIR_CST_ENERGY *
  421.         $speed * $speed / 46656;    // delta_dist * C * V * V
  422.           break;
  423.         }
  424.       }
  425.     }
  426.       // Subtotal every 'step_nb' lap if time or distance,
  427.       // local min / max if 'altitude'
  428.     switch ($lap_type)
  429.     {
  430.     case 'time' :
  431.     case 'distance' :
  432.       $laps[$lap_nb]['subtotal'] = ($lap_nb % $step_nb) ? 'no':'yes';
  433.       break;
  434.     default :    // altitude
  435.       $laps[$lap_nb]['subtotal'] = in_array($i, $zero_slope) ? 'yes':'no';
  436.     }
  437.     $laps[$lap_nb]['elapsed'] = round($i * $interval * 10 + $dt);
  438.     $laps[$lap_nb]['lap_elapsed'] = round($t_lap);
  439.     if ($is_speed)
  440.     { $laps[$lap_nb]['distance'] = round($lap_d); }
  441.     if ($is_hr)
  442.     {
  443.       $beat_nb += $data[$i]['hr'] * $dt / 600;
  444.       $laps[$lap_nb]['ini_hr'] = $hr_ini;
  445.       $laps[$lap_nb]['min_hr'] = $hr_min;
  446.       $laps[$lap_nb]['avg_hr'] = round($beat_nb / ($t_lap / 600), 2);
  447.       $laps[$lap_nb]['max_hr'] = $hr_max;
  448.       $laps[$lap_nb]['end_hr'] = $data[$i]['hr'];
  449.       $laps[$lap_nb]['beat_sum'] = $beat_nb;
  450.     }
  451.     if ($is_speed)
  452.     {
  453.       $laps[$lap_nb]['ini_speed'] = $speed_ini;
  454.       $laps[$lap_nb]['min_speed'] = $speed_min;
  455.       $laps[$lap_nb]['avg_speed'] = round(360 * $lap_d / $t_lap, 2);
  456.       $laps[$lap_nb]['max_speed'] = $speed_max;
  457.       $laps[$lap_nb]['end_speed'] = $speed;
  458.     }
  459.     if ($is_cad)
  460.     {
  461.       $stride_nb += $data[$i]['cadence'] * $dt / 300;
  462.       $laps[$lap_nb]['ini_cadence'] = $cadence_ini;
  463.       $laps[$lap_nb]['min_cadence'] = $cadence_min;
  464.       $laps[$lap_nb]['avg_cadence'] = round($stride_nb / ($t_lap / 300), 2);
  465.       $laps[$lap_nb]['max_cadence'] = $cadence_max;
  466.       $laps[$lap_nb]['end_cadence'] = $data[$i]['cadence'];
  467.       if ($stride_nb > 0)
  468.       { $laps[$lap_nb]['avg_stride'] = round(($lap_d*100) / $stride_nb,2); }
  469.       $laps[$lap_nb]['max_stride'] = round($stride_max, 2);
  470.     }
  471.     if ($is_alti)
  472.     {
  473.       $laps[$lap_nb]['ini_altitude'] = $alti_ini;
  474.       $laps[$lap_nb]['min_altitude'] = $alti_min;
  475.       $laps[$lap_nb]['avg_altitude'] = round(10 * $sum_alti / $t_lap);
  476.       $laps[$lap_nb]['max_altitude'] = $alti_max;
  477.       $laps[$lap_nb]['end_altitude'] = $data[$i]['altitude'];
  478.       $laps[$lap_nb]['ascend'] = $ascend;
  479.     }
  480.     if ($weight)
  481.     {
  482.       if ($is_hr)
  483.       {
  484.         $laps[$lap_nb]['physio_energy'] =
  485.           round(1000 * $weight * $vma * PHYSIO_CST_POWER *
  486.         ($beat_nb - PHYSIO_CST_REST * $rest_hr * ($t_lap/600)));
  487.       }
  488.       if ($is_speed)
  489.       {
  490.         switch ($this->sport_alias)
  491.         {
  492.         case 'running' :
  493.         case 'walking' :
  494.           $cin_en *= $weight / 2592;    // 2592 = 2 * (10 * 3.6)^2
  495.           $cin_en = round($cin_en / CALORY_2_JOULE);    // In cal
  496.           $mov_en = round($weight * $lap_d * MOVE_CST_ENERGY);
  497.           $grn_en = round($weight * $t_lap * GROUND_CST_ENERGY / 10);
  498.           $air_en = round($air_en * $weight);
  499.           break;
  500.         }
  501.       }
  502.       if ($is_alti)
  503.       {
  504.         switch ($this->sport_alias)
  505.         {
  506.         case 'running' :
  507.         case 'walking' :
  508.           $pot_en_up= round($weight * $ascend * GRAVI_CST / CALORY_2_JOULE);
  509.           break;
  510.         }
  511.         $descend = $ascend + $alti_ini - $data[$i]['altitude'];
  512.         if ($descend < 0)
  513.         { $descend = 0; }
  514.         switch ($this->sport_alias)
  515.         {
  516.         case 'running' :
  517.         case 'walking' :
  518.           $pot_en_down = round(POT_DOWN_USED_CST_ENERGY *
  519.         $weight * $descend * GRAVI_CST / CALORY_2_JOULE);
  520.           break;
  521.         }
  522.       }
  523.       switch ($this->sport_alias)
  524.       {
  525.       case 'running' :
  526.       case 'walking' :
  527.         $laps[$lap_nb]['meca_energy'] = round($cin_en +
  528.           $pot_en_up - $pot_en_down + $mov_en + $grn_en + $air_en);
  529.         break;
  530.       }
  531.     }
  532.     $lap_nb++;
  533.     switch ($lap_type)
  534.     {
  535.     case 'distance' :
  536.       $d_lap = $d_lap + $dd - $step;
  537.       break;
  538.     default :    // time, altitude
  539.       if ($is_speed)
  540.       { $d_lap = 0; }
  541.     }
  542.     $t_lap = 10 * $interval - $dt;
  543.     if ($is_hr)
  544.     {
  545.       $beat_nb = $data[$i]['hr'] * (10 * $interval - $dt) / 600;
  546.       $hr_ini = $data[$i]['hr'];
  547.       $hr_min = $data[$i]['hr'];
  548.       $hr_max = $data[$i]['hr'];
  549.     }
  550.     if ($is_speed)
  551.     {
  552.       $speed_ini = $speed;
  553.       $speed_min = $speed;
  554.       $speed_max = $speed;
  555.     }
  556.     if ($is_cad)
  557.     {
  558.       $stride_nb = $data[$i]['cadence'] * (10 * $interval - $dt) / 300;
  559.       $cadence_ini = $data[$i]['cadence'];
  560.       $cadence_min = $data[$i]['cadence'];
  561.       $cadence_max = $data[$i]['cadence'];
  562.       $stride_max = 0;
  563.     }
  564.     if ($is_alti)
  565.     {
  566.       $sum_alti = $data[$i]['altitude'] * (10 * $interval - $dt) / 10;
  567.       $alti_ini = $data[$i]['altitude'];
  568.       $alti_min = $data[$i]['altitude'];
  569.       $alti_max = $data[$i]['altitude'];
  570.       $ascend = 0;
  571.     }
  572.     if ($weight)
  573.     {
  574.       $air_en = 0;
  575.       $cin_en = 0;
  576.     }
  577.     if ($is_speed && ($lap_type == 'distance'))
  578.     {
  579.       $d += $d_lap;
  580.       if ($d >= $distance)    // End of data = end of lap
  581.       { break; }
  582.     }
  583.       }
  584.       else
  585.       {
  586.     $t_lap += 10 * $interval;
  587.     if ($is_speed)
  588.     {
  589.       $d_lap += $dd;
  590.       $d += $dd;
  591.     }
  592.     if ($is_hr)
  593.     {
  594.       $beat_nb += $data[$i]['hr'] * $interval / 60;
  595.       if ($data[$i]['hr'] < $hr_min)
  596.       { $hr_min = $data[$i]['hr']; }
  597.       if ($data[$i]['hr'] > $hr_max)
  598.       { $hr_max = $data[$i]['hr']; }
  599.     }
  600.     if ($is_speed)
  601.     {
  602.       if ($speed < $speed_min)
  603.       { $speed_min = $speed; }
  604.       if ($speed > $speed_max)
  605.       { $speed_max = $speed; }
  606.     }
  607.     if ($is_cad)
  608.     {
  609.       if ($data[$i]['cadence'] < $cadence_min)
  610.       { $cadence_min = $data[$i]['cadence']; }
  611.       if ($data[$i]['cadence'] > $cadence_max)
  612.       { $cadence_max = $data[$i]['cadence']; }
  613.       $stride_nb += $data[$i]['cadence'] * $interval / 30;
  614.       if ($data[$i]['cadence'] > 0)
  615.       {
  616.         $stride = 250 * $speed / (3 * $data[$i]['cadence']);
  617.         if (($stride > $stride_max) && ($stride <= STRIDE_MAX))
  618.         { $stride_max = $stride; }
  619.       }
  620.     }
  621.     if ($is_alti)
  622.     {
  623.       $sum_alti += $data[$i]['altitude'] * $interval;
  624.       if ($data[$i]['altitude'] < $alti_min)
  625.       { $alti_min = $data[$i]['altitude']; }
  626.       if ($data[$i]['altitude'] > $alti_max)
  627.       { $alti_max = $data[$i]['altitude']; }
  628.       if ($data[$i]['altitude'] >= ($alti_local_min + MIN_DELTA_ALTITUDE))
  629.       {
  630.         $ascend += $data[$i]['altitude'] - $alti_local_min;
  631.         $alti_local_min = $data[$i]['altitude'];
  632.       }
  633.       if ($data[$i]['altitude'] < $alti_local_min)
  634.       { $alti_local_min = $data[$i]['altitude']; }
  635.     }
  636.     if ($weight && $is_speed)
  637.     {
  638.       if ($speed > $p_speed)
  639.       {
  640.         switch ($this->sport_alias)
  641.         {
  642.         case 'running' :
  643.         case 'walking' :
  644.           $cin_en += $speed * $speed - $p_speed * $p_speed;
  645.           break;
  646.         }
  647.       }
  648.       if ($speed > 0)
  649.       {
  650.         switch ($this->sport_alias)
  651.         {
  652.         case 'running' :
  653.         case 'walking' :
  654.           $air_en += $interval * $speed * AIR_CST_ENERGY *
  655.         $speed * $speed / 46656;    // delta_dist * C * V * V
  656.           break;
  657.         }
  658.       }
  659.     }
  660.       }
  661.       if ($is_speed)
  662.       { $p_speed = $speed; }
  663.     }
  664.  
  665.   // Last lap is always a subtotal
  666.     $laps[count($laps)]['subtotal'] = 'yes';
  667.  
  668.     return $laps;
  669.   }
  670.  
  671. /**
  672.  * Generate laps array from Polar laps and interval training expression
  673.  *
  674.  * Two elements can be separated or not by an implicit recovery.
  675.  * Example : 3000m + 3000m
  676.  *
  677.  * One work or recovery element can consist in several Polar laps. There are 2
  678.  * cases :
  679.  * - Work element : Polar laps are not merged to keep intermediate times.
  680.  * Example : 5000m whith a Polar lap every 1000m
  681.  * - Recovery element : Polar laps are merged.
  682.  *
  683.  * @param    array    $polar_laps Polar laps from database
  684.  * @param    array    $intervals Array of work / recovery elements
  685.  * @param    integer    $vma VMA in km/h (from database or computed),
  686.  *             used to predict minimum speeds for work and
  687.  *             maximum speeds for recovery
  688.  * @return    array    Array of laps with same structure as 'plw_lap' SQL table
  689.  *             or null if Polar laps and interval training expression
  690.  *             do not match
  691.  */
  692.   function generate_interval_training($polar_laps, $intervals, $vma)
  693.   {
  694. $trace = false;
  695. // TODO : Try to "guess" if no speed measure...
  696.   /*
  697.     Use 100% VMA = 6' / 85% VMA = 1H as upper limit with V = V0 - C*Log(D)
  698.     (linear speed decrease with log(distance), V (km/h), distance (km)
  699.     => C = 0.15*VMA / (Log(0.85*VMA) - Log(0.1*VMA))
  700.     => V0 = VMA + C * Log(0.1*VMA)
  701.     Min for work element / Max for recovery element = 2/3 upper limit
  702.   */
  703.     $c = 0.15 * $vma / (log(0.85 * $vma) - log(0.1 * $vma));
  704.     $v0 = $vma + $c * log(0.1 * $vma);
  705.  
  706.   // Compute speed and duration for standard distances for linear interpolation
  707.     $std_dist = array (
  708.          50,   100,   150,   200,   250,   300,   400,   500,
  709.         600,   800,  1000,  1500,  2000,  2500,  3000,  4000,
  710.        5000,  6000,  8000, 10000, 15000, 20000, 21098, 42195
  711.     );
  712.     for ($i = 0; $i < count($std_dist); $i++)
  713.     {
  714.       $distance = $std_dist[$i];
  715.       $max_speed = $v0 - $c * log($std_dist[$i] / 1000);
  716.       $min_time = 3.6 * $std_dist[$i] / $max_speed;
  717.       $std_int[$i]['distance'] = $std_dist[$i];
  718.       $std_int[$i]['speed'] = $max_speed;
  719.       $std_int[$i]['duration'] = $min_time;
  720.     }
  721. //print_r($std_int);
  722.  
  723.   // Loop on intervals to compute min work / max recovery speeds
  724.     for ($i = 0; $i < count($intervals); $i++)
  725.     {
  726.     // Work / recovery limit speed = 2/3 of max speed for distance / duration
  727.       if ($intervals[$i]['work_distance'])
  728.       {
  729.           $intervals[$i]['work_min_speed'] = 0.667 * $this->_get_max_speed(
  730.       $intervals[$i]['work_distance'], 'distance', $std_int);
  731.       }
  732.       else
  733.       {
  734.     if ($intervals[$i]['work_duration'])
  735.     {
  736.       $intervals[$i]['work_min_speed'] = 0.667 * $this->_get_max_speed(
  737.         $intervals[$i]['work_duration'], 'duration', $std_int);
  738.     }
  739.       }
  740.       if ($intervals[$i]['reco_distance'])
  741.       {
  742.           $intervals[$i]['reco_max_speed'] = 0.667 * $this->_get_max_speed(
  743.       $intervals[$i]['reco_distance'], 'distance', $std_int);
  744.       }
  745.       else
  746.       {
  747.     if ($intervals[$i]['reco_duration'])
  748.     {
  749.       $intervals[$i]['reco_max_speed'] = 0.667 * $this->_get_max_speed(
  750.         $intervals[$i]['reco_duration'], 'duration', $std_int);
  751.     }
  752.       }
  753.     }
  754.  
  755.   /*
  756.     Build cumulated laps (pyramid of N * (N + 1) values) with distance,
  757.     duration, average speed, and delta with limit speed from duration
  758.     (> 0 => work, < 0 => recovery)
  759.   */
  760.     $laps_copy = $polar_laps;
  761.     reset($polar_laps);
  762.     $prev_rank = -1;
  763.     $lap_cum = array();
  764.     while (list($rank, $lap) = each($polar_laps))
  765.     {
  766.       reset($laps_copy);
  767.       $prev_rank_2 = -1;
  768.       while (list($rank_2, $lap_2) = each($laps_copy))
  769.       {
  770.     if ($rank_2 > $rank)
  771.     { break; }
  772.     $lap_cum[$rank][$rank_2]['distance'] = $lap['distance'];
  773.     $lap_cum[$rank][$rank_2]['duration'] = $lap['lap_elapsed'];
  774.     if (($prev_rank > 0) && ($prev_rank_2 > 0))
  775.     {
  776.       $lap_cum[$rank][$rank_2]['distance'] +=
  777.         $lap_cum[$prev_rank][$prev_rank_2]['distance'];
  778.       $lap_cum[$rank][$rank_2]['duration'] +=
  779.         $lap_cum[$prev_rank][$prev_rank_2]['duration'];
  780.     }
  781.     $lap_cum[$rank][$rank_2]['avg_speed'] =
  782.       36 * $lap_cum[$rank][$rank_2]['distance'] /
  783.         $lap_cum[$rank][$rank_2]['duration'];
  784.     $lap_cum[$rank][$rank_2]['delta'] =
  785.       $lap_cum[$rank][$rank_2]['avg_speed'] - 0.667 * $this->_get_max_speed(
  786.         $lap_cum[$rank][$rank_2]['duration'] / 10, 'duration', $std_int);
  787.     $prev_rank_2 = $rank_2;
  788.       }
  789.       $prev_rank = $rank;
  790.     }
  791.     unset($laps_copy);
  792.  
  793.   // Create a list of cumulated laps sorted by 'delta' [N * (N + 1) values]
  794.     $sorted_cum = array();
  795.     reset($lap_cum);
  796.     $i = 0;
  797.     while (list($rank, $lap_sum) = each($lap_cum))
  798.     {
  799. if ($trace)
  800. {
  801. printf("%3d.|", $rank);
  802. }
  803.       reset($lap_sum);
  804.       while (list($rank_2, $lap) = each($lap_sum))
  805.       {
  806.         $sorted_cum[$i++] = array($rank, $rank_2, $lap['delta']);
  807. if ($trace)
  808. {
  809. printf(" %5d[%+.2f]", $lap['distance'], $lap['delta']);
  810. }
  811.       }
  812. if ($trace)
  813. {
  814. echo "\n    |";
  815. reset($lap_sum);
  816. while (list($rank_2, $lap) = each($lap_sum))
  817. { printf(" %5d       ", round($lap['duration'] / 10)); }
  818. echo "\n";
  819. }
  820.     }
  821.  
  822. if ($trace)
  823. {
  824. reset($lap_cum);
  825. echo '-----';
  826. while (list($rank, $lap_sum) = each($lap_cum))
  827. { echo '-------------'; }
  828. echo "\n";
  829. reset($lap_cum);
  830. echo '     ';
  831. while (list($rank, $lap_sum) = each($lap_cum))
  832. { printf("   %3d.      ", $rank); }
  833. echo "\n";
  834.     usort(&$sorted_cum, array($this, '_sort_cum_cmp'));
  835. reset($sorted_cum);
  836. for ($i = 0; $i < count($sorted_cum); $i++)
  837. {
  838.   if ($sorted_cum[$i][1] > 1)
  839.   { $str_end = sprintf("-> %2d", $sorted_cum[$i][0]); }
  840.   else
  841.   { $str_end = '     '; }
  842.   printf("%4d : %2d %s / %+5.2f / ", $i,
  843.     $sorted_cum[$i][0] - $sorted_cum[$i][1] + 1, $str_end, $sorted_cum[$i][2]);
  844.   $duration = $lap_cum[$sorted_cum[$i][0]][$sorted_cum[$i][1]]['duration'] / 10;
  845.   $distance = $lap_cum[$sorted_cum[$i][0]][$sorted_cum[$i][1]]['distance'];
  846.   $avg_speed = $lap_cum[$sorted_cum[$i][0]][$sorted_cum[$i][1]]['avg_speed'];
  847.   printf("%7.1f s / %5d m / %5.2f %s\n",
  848.     $duration, $distance, $avg_speed, $GLOBALS['str_abbr_speed_km_h']);
  849. }
  850. echo "\n";
  851. for ($i = 0; $i < count($intervals); $i++)
  852. {
  853.   $str_work = '                           ';
  854.   if ($intervals[$i]['work_distance'])
  855.   {
  856.     $str_work = sprintf("W =%5d m [min:%5.2f %s]",
  857.       $intervals[$i]['work_distance'], $intervals[$i]['work_min_speed'],
  858.       $GLOBALS['str_abbr_speed_km_h']);
  859.   }
  860.   if ($intervals[$i]['work_duration'])
  861.   {
  862.     $str_work = sprintf("W =%5d s [min:%5.2f %s]",
  863.       $intervals[$i]['work_duration'], $intervals[$i]['work_min_speed'],
  864.       $GLOBALS['str_abbr_speed_km_h']);
  865.   }
  866.   $str_reco = '                           ';
  867.   if ($intervals[$i]['reco_distance'])
  868.   {
  869.     $str_reco = sprintf("R =%5d m [max:%5.2f %s]",
  870.       $intervals[$i]['reco_distance'], $intervals[$i]['reco_max_speed'],
  871.       $GLOBALS['str_abbr_speed_km_h']);
  872.   }
  873.   if ($intervals[$i]['reco_duration'])
  874.   {
  875.     $str_reco = sprintf("R =%5d s [max:%5.2f %s]",
  876.       $intervals[$i]['reco_duration'], $intervals[$i]['reco_max_speed'],
  877.       $GLOBALS['str_abbr_speed_km_h']);
  878.   }
  879.   printf("%2d : %2d x { %s / %s }\n", $i, $intervals[$i]['repeat_nb'],
  880.     $str_work, $str_reco);
  881. }
  882. echo "\n";
  883. reset($polar_laps);
  884. while (list($rank, $lap) = each($polar_laps))
  885. {
  886.   printf("%3d : %7.1f s / %5d m / %4.1f %s\n", $rank,
  887.     $lap['lap_elapsed'] / 10, $lap['distance'], $lap['avg_speed'] / 10,
  888.     $GLOBALS['str_abbr_speed_km_h']);
  889. }
  890. //print_r($intervals);
  891. //print_r($polar_laps);
  892. //print_r($sorted_cum);
  893. }
  894.  
  895.     reset($polar_laps);
  896.   /*
  897.     Loop on intervals to find candidate lap groups in cumulated laps
  898.     Good candidates :
  899.     1. closely match interval distance or duration within a tolerance
  900.        (tolerance is larger if distance / duration is small),
  901.     2. speed >= min work speed if work, speed <= max recovery speed if recovery
  902.     3. Sort candidates having max 'delta' if work, min delta if recovery.
  903.     Notes :
  904.     - Unknown recovery possible (work with > 1 repeat, null recovery).
  905.     - Polar laps not in intervals are merged
  906.     - Keep laps if more than 1 Polar lap in interval =>
  907.       . Guess exact lap distance if interval distance with proportion / rounding
  908.       . If not possible => Merge Polar laps
  909.     Success only if all intervals are matched in right order
  910.   */
  911.     for ($i = 0; $i < count($intervals); $i++)
  912.     {
  913. //print_r($intervals[$i]);
  914.       $sum_elapsed = 0;
  915.       $sum_distance = 0;
  916.       $lap_set = array();
  917.       for ($rep = 0; $rep < $intervals[$i]['repeat_nb']; $rep++)
  918.       {
  919. //echo "$rep.\n";
  920.     $state = 'work';
  921.     if ($intervals[$i]['work_distance'])
  922.     { $value = $intervals[$i]['work_distance']; $unit = 'distance'; }
  923.     else
  924.     {
  925.       if ($intervals[$i]['work_duration'])
  926.       { $value = $intervals[$i]['work_duration']; $unit = 'duration'; }
  927.       else
  928.       {
  929.         $state = 'reco';
  930.         if ($intervals[$i]['reco_distance'])
  931.         { $value = $intervals[$i]['reco_distance']; $unit = 'distance'; }
  932.         else
  933.         { $value = $intervals[$i]['reco_duration']; $unit = 'duration'; }
  934.       }
  935.     }
  936.     if (! (list($rank, $lap) = each($polar_laps)))
  937.     { return null; }
  938.     $lap_set[$rank] = $lap;
  939.     $sum_duration += $lap['lap_elapsed'];
  940.     $sum_distance += $lap['distance'];
  941.     if ($state == 'work')
  942.     {
  943.     }
  944.  
  945.       // Caution : Recovery of last repetition is optional !
  946.       }
  947.     }
  948. if ($trace)
  949. {
  950. reset($polar_laps);
  951. print_r($polar_laps);
  952. //print_r($this->_merge_laps($polar_laps));
  953. }
  954. return $polar_laps;    // Do nothing !
  955.   }
  956.  
  957. /**
  958.  * Merge several laps to one lap
  959.  *
  960.  * @param    array    $laps Array of laps to merge (>=1 elements)
  961.  * @return    One lap array
  962.  */
  963.   function _merge_laps($laps)
  964.   {
  965.     $merged = array();
  966.  
  967.   // Initial values + init min and max
  968.     if (isset($laps[1]['ini_hr']))
  969.     { $merged['ini_hr'] = $laps[1]['ini_hr']; }
  970.     if (isset($laps[1]['min_hr']))
  971.     { $merged['min_hr'] = $laps[1]['min_hr']; }
  972.     if (isset($laps[1]['max_hr']))
  973.     { $merged['max_hr'] = $laps[1]['max_hr']; }
  974.     if (isset($laps[1]['ini_speed']))
  975.     { $merged['ini_speed'] = $laps[1]['ini_speed']; }
  976.     if (isset($laps[1]['min_speed']))
  977.     { $merged['min_speed'] = $laps[1]['min_speed']; }
  978.     if (isset($laps[1]['max_speed']))
  979.     { $merged['max_speed'] = $laps[1]['max_speed']; }
  980.     if (isset($laps[1]['ini_cadence']))
  981.     { $merged['ini_cadence'] = $laps[1]['ini_cadence']; }
  982.     if (isset($laps[1]['min_cadence']))
  983.     { $merged['min_cadence'] = $laps[1]['min_cadence']; }
  984.     if (isset($laps[1]['max_cadence']))
  985.     { $merged['max_cadence'] = $laps[1]['max_cadence']; }
  986.     if (isset($laps[1]['max_stride']))
  987.     { $merged['max_stride'] = $laps[1]['max_stride']; }
  988.     if (isset($laps[1]['ini_altitude']))
  989.     { $merged['ini_altitude'] = $laps[1]['ini_altitude']; }
  990.     if (isset($laps[1]['min_altitude']))
  991.     { $merged['min_altitude'] = $laps[1]['min_altitude']; }
  992.     if (isset($laps[1]['max_altitude']))
  993.     { $merged['max_altitude'] = $laps[1]['max_altitude']; }
  994.  
  995.     $pond_cadence = 0;
  996.     $pond_altitude = 0;
  997.  
  998.   // Loop on laps to cumulate values + min / max
  999.     for ($i = 1; $i <= count($laps); $i++)
  1000.     {
  1001.       $merged['lap_elapsed'] += $laps[$i]['lap_elapsed'];
  1002.       if (isset($laps[$i]['distance']))
  1003.       $merged['distance'] += $laps[$i]['distance'];
  1004.       if (isset($merged['min_hr']))
  1005.       {
  1006.           if ($laps[$i]['min_hr'] < $merged['min_hr'])
  1007.     { $merged['min_hr'] = $laps[$i]['min_hr']; }
  1008.       }
  1009.       if (isset($merged['max_hr']))
  1010.       {
  1011.           if ($laps[$i]['max_hr'] > $merged['max_hr'])
  1012.     { $merged['max_hr'] = $laps[$i]['max_hr']; }
  1013.       }
  1014.       if (isset($merged['min_speed']))
  1015.       {
  1016.           if ($laps[$i]['min_speed'] < $merged['min_speed'])
  1017.     { $merged['min_speed'] = $laps[$i]['min_speed']; }
  1018.       }
  1019.       if (isset($merged['max_speed']))
  1020.       {
  1021.           if ($laps[$i]['max_speed'] > $merged['max_speed'])
  1022.     { $merged['max_speed'] = $laps[$i]['max_speed']; }
  1023.       }
  1024.       if (isset($merged['min_cadence']))
  1025.       {
  1026.           if ($laps[$i]['min_cadence'] < $merged['min_cadence'])
  1027.     { $merged['min_cadence'] = $laps[$i]['min_cadence']; }
  1028.       }
  1029.       if (isset($merged['max_cadence']))
  1030.       {
  1031.           if ($laps[$i]['max_cadence'] > $merged['max_cadence'])
  1032.     { $merged['max_cadence'] = $laps[$i]['max_cadence']; }
  1033.       }
  1034.       if (isset($merged['max_stride']))
  1035.       {
  1036.           if ($laps[$i]['max_stride'] > $merged['max_stride'])
  1037.     { $merged['max_stride'] = $laps[$i]['max_stride']; }
  1038.       }
  1039.       if (isset($merged['min_altitude']))
  1040.       {
  1041.           if ($laps[$i]['min_altitude'] < $merged['min_altitude'])
  1042.     { $merged['min_altitude'] = $laps[$i]['min_altitude']; }
  1043.       }
  1044.       if (isset($merged['max_altitude']))
  1045.       {
  1046.           if ($laps[$i]['max_altitude'] > $merged['max_altitude'])
  1047.     { $merged['max_altitude'] = $laps[$i]['max_altitude']; }
  1048.       }
  1049.       if (isset($laps[$i]['ascend']))
  1050.       { $merged['ascend'] += $laps[$i]['ascend']; }
  1051.       if (isset($laps[$i]['physio_energy']))
  1052.       { $merged['physio_energy'] += $laps[$i]['physio_energy']; }
  1053.       if (isset($laps[$i]['meca_energy']))
  1054.       { $merged['meca_energy'] += $laps[$i]['meca_energy']; }
  1055.       if (isset($laps[$i]['beat_sum']))
  1056.       { $merged['beat_sum'] += $laps[$i]['beat_sum']; }
  1057.       if (isset($laps[$i]['avg_cadence']))
  1058.       { $pond_cadence += $laps[$i]['avg_cadence'] * $laps[$i]['lap_elapsed']; }
  1059.       if (isset($laps[$i]['avg_altitude']))
  1060.       { $pond_altitude += $laps[$i]['avg_altitude'] * $laps[$i]['lap_elapsed'];}
  1061.     }
  1062.  
  1063.   // End values + compute average values
  1064.     $merged['elapsed'] = $laps[$i - 1]['elapsed'];
  1065.     if (isset($laps[1]['avg_hr']))
  1066.     {
  1067.       $merged['avg_hr'] =
  1068.     round(600 * $merged['beat_sum'] / $merged['lap_elapsed'], 2);
  1069.     }
  1070.     if (isset($laps[$i - 1]['end_hr']))
  1071.     { $merged['end_hr'] = $laps[$i - 1]['end_hr']; }
  1072.     if (isset($laps[1]['avg_speed']))
  1073.     {
  1074.       $merged['avg_speed'] =
  1075.     round(360 * $merged['distance'] / $merged['lap_elapsed'], 2);
  1076.     }
  1077.     if (isset($laps[$i - 1]['end_speed']))
  1078.     { $merged['end_speed'] = $laps[$i - 1]['end_speed']; }
  1079.     if ($pond_cadence)
  1080.     {
  1081.       $merged['avg_cadence'] = round($pond_cadence / $merged['lap_elapsed'], 2);
  1082.       if (isset($merged['distance']))
  1083.       {
  1084.           $merged['avg_stride'] =
  1085.       round(30000 * $merged['distance'] / $pond_cadence, 2);
  1086.       }
  1087.     }
  1088.     if (isset($laps[$i - 1]['end_cadence']))
  1089.     { $merged['end_cadence'] = $laps[$i - 1]['end_cadence']; }
  1090.     if ($pond_altitude)
  1091.     {
  1092.       $merged['avg_altitude'] =
  1093.     round($pond_altitude / $merged['lap_elapsed'], 2);
  1094.     }
  1095.     if (isset($laps[$i - 1]['end_altitude']))
  1096.     { $merged['end_altitude'] = $laps[$i - 1]['end_altitude']; }
  1097.     if (isset($laps[$i - 1]['description']))
  1098.     { $merged['description'] = $laps[$i - 1]['description']; }
  1099.  
  1100.     return $merged;
  1101.   }
  1102.  
  1103. /**
  1104.  * Callback comparison function to sort cumulated laps by 'delta' value
  1105.  *
  1106.  * @param    array    $v1 1st value where [2] is delta value
  1107.  * @param    array    $v2 2nd value where [2] is delta value
  1108.  * @return    integer    -1 if v1 < v2, +1 if V2 > v1, 0 if v1 = v2
  1109.  */
  1110.   function _sort_cum_cmp($v1, $v2)
  1111.   {
  1112.     if ($v1[2] == $v2[2])
  1113.     { return 0; }
  1114.  
  1115.     return ($v1[2] < $v2[2]) ? -1 : 1;
  1116.   }
  1117.  
  1118. /**
  1119.  * Get maximum average speed for a given distance or duration
  1120.  *
  1121.  * Use dichotomy algorithm, to find closest lower and upper pre-computed speeds,
  1122.  * then linear approximation.
  1123.  *
  1124.  * @param    integer    $value 
  1125.  * @param    string    $unit Unit for value in ('distance','duration').
  1126.  *             Distance in meters, duration in seconds.
  1127.  * @param    array    $std_int Pre-computed data for standard distances, each
  1128.  *             element is array('distance' => <meters>,
  1129.  *             'duration' => seconds, 'speed' => km/h)
  1130.  * @return    float    Maximum average speed in km/h
  1131.  */
  1132.   function _get_max_speed($value, $unit, $std_int)
  1133.   {
  1134.     $min = 0;
  1135.     $max = count($std_int) - 1;
  1136.     while ($max > $min + 1)
  1137.     {
  1138.       $i = floor(($min + $max) / 2);
  1139.       if ($std_int[$i][$unit] > $value)
  1140.       { $max = $i; }
  1141.       else
  1142.       { $min = $i; }
  1143.     }
  1144.     $max_speed = $std_int[$min]['speed'] +
  1145.       ($std_int[$max]['speed'] - $std_int[$min]['speed']) *
  1146.     ($value - $std_int[$min][$unit]) /
  1147.     ($std_int[$max][$unit] - $std_int[$min][$unit]);
  1148.  
  1149.     return $max_speed;
  1150.   }
  1151. }
  1152. ?>

Documentation generated on Sat, 28 Mar 2009 23:15:43 +0000 by phpDocumentor 1.4.1