/modules/pChart/pSpring.class.php

https://gitlab.com/x33n/ampache · PHP · 868 lines · 703 code · 109 blank · 56 comment · 203 complexity · 6bdf41377d74c16d81522e948c1e66f3 MD5 · raw file 

    

  1. <?php
    2. 

  2.  /*
    3. 

  3.      pSpring - class to draw spring graphs
    4. 

    5. 

  5.      Version     : 2.1.4
    6. 

  6.      Made by     : Jean-Damien POGOLOTTI
    7. 

  7.      Last Update : 19/01/2014
    8. 

    9. 

  9.      This file can be distributed under the license you can find at :
    10. 

    11. 

  11.                        http://www.pchart.net/license
    12. 

    13. 

  13.      You can find the whole class documentation on the pChart web site.
    14. 

  14.  */
    15. 

  15. 

  16.  define("NODE_TYPE_FREE"	, 690001);
    17. 

  17.  define("NODE_TYPE_CENTRAL"	, 690002);
    18. 

  18. 

  19.  define("NODE_SHAPE_CIRCLE"	, 690011);
    20. 

  20.  define("NODE_SHAPE_TRIANGLE"	, 690012);
    21. 

  21.  define("NODE_SHAPE_SQUARE"	, 690013);
    22. 

  22. 

  23.  define("ALGORITHM_RANDOM"	, 690021);
    24. 

  24.  define("ALGORITHM_WEIGHTED"	, 690022);
    25. 

  25.  define("ALGORITHM_CIRCULAR"	, 690023);
    26. 

  26.  define("ALGORITHM_CENTRAL"	, 690024);
    27. 

  27. 

  28.  define("LABEL_CLASSIC"		, 690031);
    29. 

  29.  define("LABEL_LIGHT"		, 690032);
    30. 

  30. 

  31.  /* pSpring class definition */
    32. 

  32.  class pSpring
    33. 

  33.   {
    34. 

  34.    var $History;
    35. 

  35.    var $pChartObject;
    36. 

  36.    var $Data;
    37. 

  37.    var $Links;
    38. 

  38.    var $X1;
    39. 

  39.    var $Y1;
    40. 

  40.    var $X2;
    41. 

  41.    var $Y2;
    42. 

  42.    var $AutoComputeFreeZone;
    43. 

  43.    var $Labels;
    44. 

  44. 

  45.    /* Class creator */
    46. 

  46.    function pSpring()
    47. 

  47.     {
    48. 

  48.      /* Initialise data arrays */
    49. 

  49.      $this->Data = "";
    50. 

  50.      $this->Links = "";
    51. 

  51. 

  52.      /* Set nodes defaults */
    53. 

  53.      $this->Default["R"]		= 255;
    54. 

  54.      $this->Default["G"]		= 255;
    55. 

  55.      $this->Default["B"]		= 255;
    56. 

  56.      $this->Default["Alpha"]		= 100;
    57. 

  57.      $this->Default["BorderR"]		= 0;
    58. 

  58.      $this->Default["BorderG"]		= 0;
    59. 

  59.      $this->Default["BorderB"]		= 0;
    60. 

  60.      $this->Default["BorderAlpha"]	= 100;
    61. 

  61.      $this->Default["Surrounding"]	= NULL;
    62. 

  62.      $this->Default["BackgroundR"]	= 255;
    63. 

  63.      $this->Default["BackgroundG"]	= 255;
    64. 

  64.      $this->Default["BackgroundB"]	= 255;
    65. 

  65.      $this->Default["BackgroundAlpha"]	= 0;
    66. 

  66.      $this->Default["Force"]		= 1;
    67. 

  67.      $this->Default["NodeType"]		= NODE_TYPE_FREE;
    68. 

  68.      $this->Default["Size"]		= 5;
    69. 

  69.      $this->Default["Shape"]		= NODE_SHAPE_CIRCLE;
    70. 

  70.      $this->Default["FreeZone"]		= 40;
    71. 

  71.      $this->Default["LinkR"]		= 0;
    72. 

  72.      $this->Default["LinkG"]		= 0;
    73. 

  73.      $this->Default["LinkB"]		= 0;
    74. 

  74.      $this->Default["LinkAlpha"]	= 0;
    75. 

  75. 

  76.      $this->Labels["Type"]		= LABEL_CLASSIC;
    77. 

  77.      $this->Labels["R"]			= 0;
    78. 

  78.      $this->Labels["G"]			= 0;
    79. 

  79.      $this->Labels["B"]			= 0;
    80. 

  80.      $this->Labels["Alpha"]		= 100;
    81. 

  81. 

  82.      $this->AutoComputeFreeZone         = FALSE;
    83. 

  83.     }
    84. 

  84. 

  85.    /* Set default links options */
    86. 

  86.    function setLinkDefaults($Settings="")
    87. 

  87.     {
    88. 

  88.      if ( isset($Settings["R"]) )     { $this->Default["LinkR"] = $Settings["R"]; }
    89. 

  89.      if ( isset($Settings["G"]) )     { $this->Default["LinkG"] = $Settings["G"]; }
    90. 

  90.      if ( isset($Settings["B"]) )     { $this->Default["LinkB"] = $Settings["B"]; }
    91. 

  91.      if ( isset($Settings["Alpha"]) ) { $this->Default["LinkAlpha"] = $Settings["Alpha"]; }
    92. 

  92.     }
    93. 

  93. 

  94.    /* Set default links options */
    95. 

  95.    function setLabelsSettings($Settings="")
    96. 

  96.     {
    97. 

  97.      if ( isset($Settings["Type"]) )  { $this->Labels["Type"] = $Settings["Type"]; }
    98. 

  98.      if ( isset($Settings["R"]) )     { $this->Labels["R"] = $Settings["R"]; }
    99. 

  99.      if ( isset($Settings["G"]) )     { $this->Labels["G"] = $Settings["G"]; }
    100. 

  100.      if ( isset($Settings["B"]) )     { $this->Labels["B"] = $Settings["B"]; }
    101. 

  101.      if ( isset($Settings["Alpha"]) ) { $this->Labels["Alpha"] = $Settings["Alpha"]; }
    102. 

  102.     }
    103. 

  103. 

  104.    /* Auto compute the FreeZone size based on the number of connections */
    105. 

  105.    function autoFreeZone()
    106. 

  106.     {
    107. 

  107.      /* Check connections reciprocity */
    108. 

  108.      foreach($this->Data as $Key => $Settings)
    109. 

  109.       {
    110. 

  110.        if ( isset($Settings["Connections"]) )
    111. 

  111.         { $this->Data[$Key]["FreeZone"] = count($Settings["Connections"])*10 + 20; }
    112. 

  112.        else
    113. 

  113.         { $this->Data[$Key]["FreeZone"] = 20; }
    114. 

  114.       }
    115. 

  115. 

  116.     }
    117. 

  117. 

  118.    /* Set link properties */
    119. 

  119.    function linkProperties($FromNode,$ToNode,$Settings)
    120. 

  120.     {
    121. 

  121.      if ( !isset($this->Data[$FromNode]) ) { return(0); }
    122. 

  122.      if ( !isset($this->Data[$ToNode]) )   { return(0); }
    123. 

  123. 

  124.      $R			= isset($Settings["R"]) ? $Settings["R"] : 0;
    125. 

  125.      $G			= isset($Settings["G"]) ? $Settings["G"] : 0;
    126. 

  126.      $B			= isset($Settings["B"]) ? $Settings["B"] : 0;
    127. 

  127.      $Alpha		= isset($Settings["Alpha"]) ? $Settings["Alpha"] : 100;
    128. 

  128.      $Name		= isset($Settings["Name"]) ? $Settings["Name"] : NULL;
    129. 

  129.      $Ticks		= isset($Settings["Ticks"]) ? $Settings["Ticks"] : NULL;
    130. 

  130. 

  131.      $this->Links[$FromNode][$ToNode]["R"] = $R;         $this->Links[$ToNode][$FromNode]["R"] = $R;
    132. 

  132.      $this->Links[$FromNode][$ToNode]["G"] = $G;         $this->Links[$ToNode][$FromNode]["G"] = $G;
    133. 

  133.      $this->Links[$FromNode][$ToNode]["B"] = $B;         $this->Links[$ToNode][$FromNode]["B"] = $B;
    134. 

  134.      $this->Links[$FromNode][$ToNode]["Alpha"] = $Alpha; $this->Links[$ToNode][$FromNode]["Alpha"] = $Alpha;
    135. 

  135.      $this->Links[$FromNode][$ToNode]["Name"] = $Name;   $this->Links[$ToNode][$FromNode]["Name"] = $Name;
    136. 

  136.      $this->Links[$FromNode][$ToNode]["Ticks"] = $Ticks; $this->Links[$ToNode][$FromNode]["Ticks"] = $Ticks;
    137. 

  137.     }
    138. 

  138. 

  139.    function setNodeDefaults($Settings="")
    140. 

  140.     {
    141. 

  141.      if ( isset($Settings["R"]) ) { $this->Default["R"]					= $Settings["R"]; }
    142. 

  142.      if ( isset($Settings["G"]) ) { $this->Default["G"]					= $Settings["G"]; }
    143. 

  143.      if ( isset($Settings["B"]) ) { $this->Default["B"]					= $Settings["B"]; }
    144. 

  144.      if ( isset($Settings["Alpha"]) ) { $this->Default["Alpha"]				= $Settings["Alpha"]; }
    145. 

  145.      if ( isset($Settings["BorderR"]) ) { $this->Default["BorderR"]			= $Settings["BorderR"]; }
    146. 

  146.      if ( isset($Settings["BorderG"]) ) { $this->Default["BorderG"]			= $Settings["BorderG"]; }
    147. 

  147.      if ( isset($Settings["BorderB"]) ) { $this->Default["BorderB"]			= $Settings["BorderB"]; }
    148. 

  148.      if ( isset($Settings["BorderAlpha"]) ) { $this->Default["BorderAlpha"]		= $Settings["BorderAlpha"]; }
    149. 

  149.      if ( isset($Settings["Surrounding"]) ) { $this->Default["Surrounding"]		= $Settings["Surrounding"]; }
    150. 

  150.      if ( isset($Settings["BackgroundR"]) ) { $this->Default["BackgroundR"]		= $Settings["BackgroundR"]; }
    151. 

  151.      if ( isset($Settings["BackgroundG"]) ) { $this->Default["BackgroundG"]		= $Settings["BackgroundG"]; }
    152. 

  152.      if ( isset($Settings["BackgroundB"]) ) { $this->Default["BackgroundB"]		= $Settings["BackgroundB"]; }
    153. 

  153.      if ( isset($Settings["BackgroundAlpha"]) ) { $this->Default["BackgroundAlpha"]	= $Settings["BackgroundAlpha"]; }
    154. 

  154.      if ( isset($Settings["NodeType"]) ) { $this->Default["NodeType"]			= $Settings["NodeType"]; }
    155. 

  155.      if ( isset($Settings["Size"]) ) { $this->Default["Size"]				= $Settings["Size"]; }
    156. 

  156.      if ( isset($Settings["Shape"]) ) { $this->Default["Shape"]				= $Settings["Shape"]; }
    157. 

  157.      if ( isset($Settings["FreeZone"]) ) { $this->Default["FreeZone"]			= $Settings["FreeZone"]; }
    158. 

  158.     }
    159. 

  159. 

  160.    /* Add a node */
    161. 

  161.    function addNode($NodeID,$Settings="")
    162. 

  162.     {
    163. 

  163.      /* if the node already exists, ignore */
    164. 

  164.      if (isset($this->Data[$NodeID])) { return(0); }
    165. 

  165. 

  166.      $Name		= isset($Settings["Name"]) ? $Settings["Name"] : "Node ".$NodeID;
    167. 

  167.      $Connections	= isset($Settings["Connections"]) ? $Settings["Connections"] : NULL;
    168. 

  168. 

  169.      $R			= isset($Settings["R"]) ? $Settings["R"] : $this->Default["R"];
    170. 

  170.      $G			= isset($Settings["G"]) ? $Settings["G"] : $this->Default["G"];
    171. 

  171.      $B			= isset($Settings["B"]) ? $Settings["B"] : $this->Default["B"];
    172. 

  172.      $Alpha		= isset($Settings["Alpha"]) ? $Settings["Alpha"] : $this->Default["Alpha"];
    173. 

  173.      $BorderR		= isset($Settings["BorderR"]) ? $Settings["BorderR"] : $this->Default["BorderR"];
    174. 

  174.      $BorderG		= isset($Settings["BorderG"]) ? $Settings["BorderG"] : $this->Default["BorderG"];
    175. 

  175.      $BorderB		= isset($Settings["BorderB"]) ? $Settings["BorderB"] : $this->Default["BorderB"];
    176. 

  176.      $BorderAlpha	= isset($Settings["BorderAlpha"]) ? $Settings["BorderAlpha"] : $this->Default["BorderAlpha"];
    177. 

  177.      $Surrounding	= isset($Settings["Surrounding"]) ? $Settings["Surrounding"] : $this->Default["Surrounding"];
    178. 

  178.      $BackgroundR	= isset($Settings["BackgroundR"]) ? $Settings["BackgroundR"] : $this->Default["BackgroundR"];
    179. 

  179.      $BackgroundG	= isset($Settings["BackgroundG"]) ? $Settings["BackgroundG"] : $this->Default["BackgroundG"];
    180. 

  180.      $BackgroundB	= isset($Settings["BackgroundB"]) ? $Settings["BackgroundB"] : $this->Default["BackgroundB"];
    181. 

  181.      $BackgroundAlpha	= isset($Settings["BackgroundAlpha"]) ? $Settings["BackgroundAlpha"] : $this->Default["BackgroundAlpha"];
    182. 

  182.      $Force		= isset($Settings["Force"]) ? $Settings["Force"] :  $this->Default["Force"];
    183. 

  183.      $NodeType		= isset($Settings["NodeType"]) ? $Settings["NodeType"] : $this->Default["NodeType"];
    184. 

  184.      $Size		= isset($Settings["Size"]) ? $Settings["Size"] : $this->Default["Size"];
    185. 

  185.      $Shape		= isset($Settings["Shape"]) ? $Settings["Shape"] : $this->Default["Shape"];
    186. 

  186.      $FreeZone		= isset($Settings["FreeZone"]) ? $Settings["FreeZone"] : $this->Default["FreeZone"];
    187. 

  187. 

  188.      if ( $Surrounding != NULL ) { $BorderR = $R + $Surrounding; $BorderG = $G + $Surrounding; $BorderB = $B + $Surrounding; }
    189. 

  189. 

  190.      $this->Data[$NodeID]["R"] = $R; $this->Data[$NodeID]["G"] = $G; $this->Data[$NodeID]["B"] = $B; $this->Data[$NodeID]["Alpha"] = $Alpha;
    191. 

  191.      $this->Data[$NodeID]["BorderR"] = $BorderR; $this->Data[$NodeID]["BorderG"] = $BorderG; $this->Data[$NodeID]["BorderB"] = $BorderB; $this->Data[$NodeID]["BorderAlpha"] = $BorderAlpha;
    192. 

  192.      $this->Data[$NodeID]["BackgroundR"]	= $BackgroundR; $this->Data[$NodeID]["BackgroundG"] = $BackgroundG; $this->Data[$NodeID]["BackgroundB"] = $BackgroundB; $this->Data[$NodeID]["BackgroundAlpha"] = $BackgroundAlpha;
    193. 

  193.      $this->Data[$NodeID]["Name"]		= $Name;
    194. 

  194.      $this->Data[$NodeID]["Force"]		= $Force;
    195. 

  195.      $this->Data[$NodeID]["Type"]		= $NodeType;
    196. 

  196.      $this->Data[$NodeID]["Size"]		= $Size;
    197. 

  197.      $this->Data[$NodeID]["Shape"]		= $Shape;
    198. 

  198.      $this->Data[$NodeID]["FreeZone"]		= $FreeZone;
    199. 

  199.      if ( $Connections != NULL )
    200. 

  200.       {
    201. 

  201.        if ( is_array($Connections ) )
    202. 

  202.         {
    203. 

  203.          foreach($Connections as $Key => $Value)
    204. 

  204.           $this->Data[$NodeID]["Connections"][] = $Value;
    205. 

  205.         }
    206. 

  206.        else
    207. 

  207.         $this->Data[$NodeID]["Connections"][] = $Connections;
    208. 

  208.       }
    209. 

  209.     }
    210. 

  210. 

  211.    /* Set color attribute for a list of nodes */
    212. 

  212.    function setNodesColor($Nodes,$Settings="")
    213. 

  213.     {
    214. 

  214.      if ( is_array($Nodes) )
    215. 

  215.       {
    216. 

  216.        foreach ($Nodes as $Key => $NodeID)
    217. 

  217.         {
    218. 

  218.          if (isset($this->Data[$NodeID]) )
    219. 

  219.           {
    220. 

  220.            if ( isset($Settings["R"]) ) { $this->Data[$NodeID]["R"] = $Settings["R"]; }
    221. 

  221.            if ( isset($Settings["G"]) ) { $this->Data[$NodeID]["G"] = $Settings["G"]; }
    222. 

  222.            if ( isset($Settings["B"]) ) { $this->Data[$NodeID]["B"] = $Settings["B"]; }
    223. 

  223.            if ( isset($Settings["Alpha"]) ) { $this->Data[$NodeID]["Alpha"] = $Settings["Alpha"]; }
    224. 

  224.            if ( isset($Settings["BorderR"]) ) { $this->Data[$NodeID]["BorderR"] = $Settings["BorderR"]; }
    225. 

  225.            if ( isset($Settings["BorderG"]) ) { $this->Data[$NodeID]["BorderG"] = $Settings["BorderG"]; }
    226. 

  226.            if ( isset($Settings["BorderB"]) ) { $this->Data[$NodeID]["BorderB"] = $Settings["BorderB"]; }
    227. 

  227.            if ( isset($Settings["BorderAlpha"]) ) { $this->Data[$NodeID]["BorderAlpha"] = $Settings["BorderAlpha"]; }
    228. 

  228.            if ( isset($Settings["Surrounding"]) ) { $this->Data[$NodeID]["BorderR"] = $this->Data[$NodeID]["R"] + $Settings["Surrounding"]; $this->Data[$NodeID]["BorderG"] = $this->Data[$NodeID]["G"] + $Settings["Surrounding"]; $this->Data[$NodeID]["BorderB"] = $this->Data[$NodeID]["B"] + $Settings["Surrounding"]; }
    229. 

  229.           }
    230. 

  230.         }
    231. 

  231.       }
    232. 

  232.      else
    233. 

  233.       {
    234. 

  234.        if ( isset($Settings["R"]) ) { $this->Data[$Nodes]["R"] = $Settings["R"]; }
    235. 

  235.        if ( isset($Settings["G"]) ) { $this->Data[$Nodes]["G"] = $Settings["G"]; }
    236. 

  236.        if ( isset($Settings["B"]) ) { $this->Data[$Nodes]["B"] = $Settings["B"]; }
    237. 

  237.        if ( isset($Settings["Alpha"]) ) { $this->Data[$Nodes]["Alpha"] = $Settings["Alpha"]; }
    238. 

  238.        if ( isset($Settings["BorderR"]) ) { $this->Data[$Nodes]["BorderR"] = $Settings["BorderR"]; }
    239. 

  239.        if ( isset($Settings["BorderG"]) ) { $this->Data[$Nodes]["BorderG"] = $Settings["BorderG"]; }
    240. 

  240.        if ( isset($Settings["BorderB"]) ) { $this->Data[$Nodes]["BorderB"] = $Settings["BorderB"]; }
    241. 

  241.        if ( isset($Settings["BorderAlpha"]) ) { $this->Data[$Nodes]["BorderAlpha"] = $Settings["BorderAlpha"]; }
    242. 

  242.        if ( isset($Settings["Surrounding"]) ) { $this->Data[$Nodes]["BorderR"] = $this->Data[$NodeID]["R"] + $Settings["Surrounding"]; $this->Data[$NodeID]["BorderG"] = $this->Data[$NodeID]["G"] + $Settings["Surrounding"]; $this->Data[$NodeID]["BorderB"] = $this->Data[$NodeID]["B"] + $Settings["Surrounding"]; }
    243. 

  243.       }
    244. 

  244.     }
    245. 

  245. 

  246.    /* Returns all the nodes details */
    247. 

  247.    function dumpNodes()
    248. 

  248.     { return($this->Data); }
    249. 

  249. 

  250.    /* Check if a connection exists and create it if required */
    251. 

  251.    function checkConnection($SourceID, $TargetID)
    252. 

  252.     {
    253. 

  253.      if ( isset($this->Data[$SourceID]["Connections"]) )
    254. 

  254.       {
    255. 

  255.        foreach ($this->Data[$SourceID]["Connections"] as $Key => $ConnectionID)
    256. 

  256.         { if ( $TargetID == $ConnectionID ) { return(TRUE); } }
    257. 

  257.       }
    258. 

  258.      $this->Data[$SourceID]["Connections"][] = $TargetID;
    259. 

  259.     }
    260. 

  260.    /* Get the median linked nodes position */
    261. 

  261.    function getMedianOffset($Key,$X,$Y)
    262. 

  262.     {
    263. 

  263.      $Cpt = 1;
    264. 

  264.      if ( isset($this->Data[$Key]["Connections"]) )
    265. 

  265.       {
    266. 

  266.        foreach($this->Data[$Key]["Connections"] as $ID => $NodeID)
    267. 

  267.         {
    268. 

  268.          if ( isset($this->Data[$NodeID]["X"]) && isset($this->Data[$NodeID]["Y"]) )
    269. 

  269.           {
    270. 

  270.            $X = $X + $this->Data[$NodeID]["X"];
    271. 

  271.            $Y = $Y + $this->Data[$NodeID]["Y"];
    272. 

  272.            $Cpt++;
    273. 

  273.           }
    274. 

  274.         }
    275. 

  275.       }
    276. 

  276.      return(array("X"=>$X/$Cpt,"Y"=>$Y/$Cpt));
    277. 

  277.     }
    278. 

  278. 

  279.    /* Return the ID of the attached partner with the biggest weight */
    280. 

  280.    function getBiggestPartner($Key)
    281. 

  281.     {
    282. 

  282.      if ( !isset($this->Data[$Key]["Connections"]) ) { return(""); }
    283. 

  283. 

  284.      $MaxWeight = 0; $Result = "";
    285. 

  285.      foreach($this->Data[$Key]["Connections"] as $Key => $PeerID)
    286. 

  286.       {
    287. 

  287.        if ( $this->Data[$PeerID]["Weight"] > $MaxWeight )
    288. 

  288.         { $MaxWeight = $this->Data[$PeerID]["Weight"]; $Result = $PeerID; }
    289. 

  289.       }
    290. 

  290.      return($Result);
    291. 

  291.     }
    292. 

  292. 

  293.    /* Do the initial node positions computing pass */
    294. 

  294.    function firstPass($Algorithm)
    295. 

  295.     {
    296. 

  296.      $CenterX = ($this->X2 - $this->X1) / 2 + $this->X1;
    297. 

  297.      $CenterY = ($this->Y2 - $this->Y1) / 2 + $this->Y1;
    298. 

  298. 

  299.      /* Check connections reciprocity */
    300. 

  300.      foreach($this->Data as $Key => $Settings)
    301. 

  301.       {
    302. 

  302.        if ( isset($Settings["Connections"]) )
    303. 

  303.         {
    304. 

  304.          foreach($Settings["Connections"] as $ID => $ConnectionID)
    305. 

  305.           $this->checkConnection($ConnectionID,$Key);
    306. 

  306.         }
    307. 

  307.       }
    308. 

  308. 

  309.      if ( $this->AutoComputeFreeZone ) { $this->autoFreeZone(); }
    310. 

  310. 

  311.      /* Get the max number of connections */
    312. 

  312.      $MaxConnections = 0;
    313. 

  313.      foreach($this->Data as $Key => $Settings)
    314. 

  314.       { if ( isset($Settings["Connections"]) ) { if ( $MaxConnections < count($Settings["Connections"] ) ) { $MaxConnections = count($Settings["Connections"]); } } }
    315. 

  315. 

  316.      if ( $Algorithm == ALGORITHM_WEIGHTED )
    317. 

  317.       {
    318. 

  318.        foreach($this->Data as $Key => $Settings)
    319. 

  319.         {
    320. 

  320.          if ( $Settings["Type"] == NODE_TYPE_CENTRAL ) { $this->Data[$Key]["X"] = $CenterX; $this->Data[$Key]["Y"] = $CenterY; }
    321. 

  321.          if ( $Settings["Type"] == NODE_TYPE_FREE )
    322. 

  322.           {
    323. 

  323.            if ( isset($Settings["Connections"]) )
    324. 

  324.             { $Connections = count($Settings["Connections"]); }
    325. 

  325.            else
    326. 

  326.             { $Connections = 0; }
    327. 

  327. 

  328.            $Ring  = $MaxConnections - $Connections;
    329. 

  329.            $Angle = rand(0,360);
    330. 

  330.            
    331. 

  331.            $this->Data[$Key]["X"] = cos(deg2rad($Angle)) * ($Ring*$this->RingSize) + $CenterX;
    332. 

  332.            $this->Data[$Key]["Y"] = sin(deg2rad($Angle)) * ($Ring*$this->RingSize) + $CenterY;
    333. 

  333.           }
    334. 

  334.         }
    335. 

  335.       }
    336. 

  336.      elseif ( $Algorithm == ALGORITHM_CENTRAL )
    337. 

  337.       {
    338. 

  338.        /* Put a weight on each nodes */
    339. 

  339.        foreach($this->Data as $Key => $Settings)
    340. 

  340.         {
    341. 

  341.          if ( isset($Settings["Connections"]) )
    342. 

  342.           $this->Data[$Key]["Weight"] = count($Settings["Connections"]);
    343. 

  343.          else
    344. 

  344.           $this->Data[$Key]["Weight"] = 0;
    345. 

  345.         }
    346. 

  346. 

  347.        $MaxConnections = $MaxConnections + 1;
    348. 

  348.        for($i=$MaxConnections;$i>=0;$i--)
    349. 

  349.         {
    350. 

  350.          foreach($this->Data as $Key => $Settings)
    351. 

  351.           {
    352. 

  352.            if ( $Settings["Type"] == NODE_TYPE_CENTRAL ) { $this->Data[$Key]["X"] = $CenterX; $this->Data[$Key]["Y"] = $CenterY; }
    353. 

  353.            if ( $Settings["Type"] == NODE_TYPE_FREE )
    354. 

  354.             {
    355. 

  355.              if ( isset($Settings["Connections"]) )
    356. 

  356.               { $Connections = count($Settings["Connections"]); }
    357. 

  357.              else
    358. 

  358.               { $Connections = 0; }
    359. 

  359. 

  360.              if ( $Connections == $i )
    361. 

  361.               {
    362. 

  362.                $BiggestPartner = $this->getBiggestPartner($Key);
    363. 

  363.                if ( $BiggestPartner != "" )
    364. 

  364.                 {
    365. 

  365.                  $Ring          = $this->Data[$BiggestPartner]["FreeZone"];
    366. 

  366.                  $Weight        = $this->Data[$BiggestPartner]["Weight"];
    367. 

  367.                  $AngleDivision = 360 / $this->Data[$BiggestPartner]["Weight"];
    368. 

  368.                  $Done          = FALSE; $Tries = 0;
    369. 

  369.                  while (!$Done && $Tries <= $Weight*2)
    370. 

  370.                   {
    371. 

  371.                    $Tries++;
    372. 

  372.                    $Angle = floor(rand(0,$Weight)*$AngleDivision);
    373. 

  373.                    if ( !isset($this->Data[$BiggestPartner]["Angular"][$Angle]) || !isset($this->Data[$BiggestPartner]["Angular"]) )
    374. 

  374.                     {
    375. 

  375.                      $this->Data[$BiggestPartner]["Angular"][$Angle] = $Angle;
    376. 

  376.                      $Done = TRUE; 
    377. 

  377.                     }
    378. 

  378.                   }
    379. 

  379.                  if ( !$Done )
    380. 

  380.                   { $Angle = rand(0,360); $this->Data[$BiggestPartner]["Angular"][$Angle] = $Angle; }
    381. 

  381. 

  382.                  $X = cos(deg2rad($Angle)) * ($Ring) + $this->Data[$BiggestPartner]["X"];
    383. 

  383.                  $Y = sin(deg2rad($Angle)) * ($Ring) + $this->Data[$BiggestPartner]["Y"];
    384. 

  384. 

  385.                  $this->Data[$Key]["X"] = $X;
    386. 

  386.                  $this->Data[$Key]["Y"] = $Y;
    387. 

  387.                 }
    388. 

  388.               }
    389. 

  389.             }
    390. 

  390.           }
    391. 

  391.         }
    392. 

  392.       }
    393. 

  393.      elseif ( $Algorithm == ALGORITHM_CIRCULAR )
    394. 

  394.       {
    395. 

  395.        $MaxConnections = $MaxConnections + 1;
    396. 

  396.        for($i=$MaxConnections;$i>=0;$i--)
    397. 

  397.         {
    398. 

  398.          foreach($this->Data as $Key => $Settings)
    399. 

  399.           {
    400. 

  400.            if ( $Settings["Type"] == NODE_TYPE_CENTRAL ) { $this->Data[$Key]["X"] = $CenterX; $this->Data[$Key]["Y"] = $CenterY; }
    401. 

  401.            if ( $Settings["Type"] == NODE_TYPE_FREE )
    402. 

  402.             {
    403. 

  403.              if ( isset($Settings["Connections"]) )
    404. 

  404.               { $Connections = count($Settings["Connections"]); }
    405. 

  405.              else
    406. 

  406.               { $Connections = 0; }
    407. 

  407. 

  408.              if ( $Connections == $i )
    409. 

  409.               {
    410. 

  410.                $Ring  = $MaxConnections - $Connections;
    411. 

  411.                $Angle = rand(0,360);
    412. 

  412. 

  413.                $X = cos(deg2rad($Angle)) * ($Ring*$this->RingSize) + $CenterX;
    414. 

  414.                $Y = sin(deg2rad($Angle)) * ($Ring*$this->RingSize) + $CenterY;
    415. 

  415. 

  416.                $MedianOffset = $this->getMedianOffset($Key,$X,$Y);
    417. 

  417. 

  418.                $this->Data[$Key]["X"] = $MedianOffset["X"];
    419. 

  419.                $this->Data[$Key]["Y"] = $MedianOffset["Y"];
    420. 

  420.               }
    421. 

  421.             }
    422. 

  422.           }
    423. 

  423.         }
    424. 

  424.       }
    425. 

  425.      elseif ( $Algorithm == ALGORITHM_RANDOM )
    426. 

  426.       {
    427. 

  427.        foreach($this->Data as $Key => $Settings)
    428. 

  428.         {
    429. 

  429.          if ( $Settings["Type"] == NODE_TYPE_FREE )
    430. 

  430.           {
    431. 

  431.            $this->Data[$Key]["X"] = $CenterX + rand(-20,20);
    432. 

  432.            $this->Data[$Key]["Y"] = $CenterY + rand(-20,20);
    433. 

  433.           }
    434. 

  434.          if ( $Settings["Type"] == NODE_TYPE_CENTRAL ) { $this->Data[$Key]["X"] = $CenterX; $this->Data[$Key]["Y"] = $CenterY; }
    435. 

  435.         }
    436. 

  436.       }
    437. 

  437.     }
    438. 

  438. 

  439.    /* Compute one pass */
    440. 

  440.    function doPass()
    441. 

  441.     {
    442. 

  442.      /* Compute vectors */
    443. 

  443.      foreach($this->Data as $Key => $Settings)
    444. 

  444.       {
    445. 

  445.        if ( $Settings["Type"] != NODE_TYPE_CENTRAL )
    446. 

  446.         {
    447. 

  447.          unset($this->Data[$Key]["Vectors"]);
    448. 

  448. 

  449.          $X1 = $Settings["X"];
    450. 

  450.          $Y1 = $Settings["Y"];
    451. 

  451. 

  452.          /* Repulsion vectors */
    453. 

  453.          foreach($this->Data as $Key2 => $Settings2)
    454. 

  454.           {
    455. 

  455.            if ( $Key != $Key2 )
    456. 

  456.             {
    457. 

  457.              $X2 = $this->Data[$Key2]["X"];
    458. 

  458.              $Y2 = $this->Data[$Key2]["Y"];
    459. 

  459.              $FreeZone = $this->Data[$Key2]["FreeZone"];
    460. 

  460. 

  461.              $Distance = $this->getDistance($X1,$Y1,$X2,$Y2);
    462. 

  462.              $Angle    = $this->getAngle($X1,$Y1,$X2,$Y2) + 180;
    463. 

  463. 

  464.              /* Nodes too close, repulsion occurs */
    465. 

  465.              if ( $Distance < $FreeZone )
    466. 

  466.               {
    467. 

  467.                $Force = log(pow(2,$FreeZone-$Distance));
    468. 

  468.                if ( $Force > 1 )
    469. 

  469.                 { $this->Data[$Key]["Vectors"][] = array("Type"=>"R","Angle"=>$Angle % 360,"Force"=>$Force); }
    470. 

  470.               }
    471. 

  471.             }
    472. 

  472.           }
    473. 

  473. 

  474.          /* Attraction vectors */
    475. 

  475.          if ( isset($Settings["Connections"]) )
    476. 

  476.           {
    477. 

  477.            foreach($Settings["Connections"] as $ID => $NodeID)
    478. 

  478.             {
    479. 

  479.              if ( isset($this->Data[$NodeID]) )
    480. 

  480.               {
    481. 

  481.                $X2 = $this->Data[$NodeID]["X"];
    482. 

  482.                $Y2 = $this->Data[$NodeID]["Y"];
    483. 

  483.                $FreeZone = $this->Data[$Key2]["FreeZone"];
    484. 

  484. 

  485.                $Distance = $this->getDistance($X1,$Y1,$X2,$Y2);
    486. 

  486.                $Angle    = $this->getAngle($X1,$Y1,$X2,$Y2);
    487. 

  487. 

  488.                if ( $Distance > $FreeZone )
    489. 

  489.                 $Force = log(($Distance-$FreeZone)+1);
    490. 

  490.                else
    491. 

  491.                 { $Force = log(($FreeZone-$Distance)+1); ($Angle = $Angle + 180); }
    492. 

  492. 

  493.                if ( $Force > 1 )
    494. 

  494.                 $this->Data[$Key]["Vectors"][] = array("Type"=>"A","Angle"=>$Angle % 360,"Force"=>$Force);
    495. 

  495.               }
    496. 

  496.             }
    497. 

  497.           }
    498. 

  498.         }
    499. 

  499.       }
    500. 

  500. 

  501.      /* Move the nodes accoding to the vectors */
    502. 

  502.      foreach($this->Data as $Key => $Settings)
    503. 

  503.       {
    504. 

  504.        $X = $Settings["X"];
    505. 

  505.        $Y = $Settings["Y"];
    506. 

  506. 

  507.        if ( isset($Settings["Vectors"]) && $Settings["Type"] != NODE_TYPE_CENTRAL )
    508. 

  508.         {
    509. 

  509.          foreach($Settings["Vectors"] as $ID => $Vector)
    510. 

  510.           {
    511. 

  511.            $Type  = $Vector["Type"];
    512. 

  512.            $Force = $Vector["Force"];
    513. 

  513.            $Angle = $Vector["Angle"];
    514. 

  514.            $Factor = $Type == "A" ? $this->MagneticForceA : $this->MagneticForceR;
    515. 

  515. 

  516.            $X = cos(deg2rad($Angle)) * $Force * $Factor + $X;
    517. 

  517.            $Y = sin(deg2rad($Angle)) * $Force * $Factor + $Y;
    518. 

  518.           }
    519. 

  519.         }
    520. 

  520. 

  521.        $this->Data[$Key]["X"] = $X;
    522. 

  522.        $this->Data[$Key]["Y"] = $Y;
    523. 

  523.       }
    524. 

  524.     }
    525. 

  525. 

  526.    function lastPass()
    527. 

  527.     {
    528. 

  528.      /* Put everything inside the graph area */
    529. 

  529.      foreach($this->Data as $Key => $Settings)
    530. 

  530.       {
    531. 

  531.        $X = $Settings["X"];
    532. 

  532.        $Y = $Settings["Y"];
    533. 

  533. 

  534.        if ( $X < $this->X1 ) { $X = $this->X1; }
    535. 

  535.        if ( $X > $this->X2 ) { $X = $this->X2; }
    536. 

  536.        if ( $Y < $this->Y1 ) { $Y = $this->Y1; }
    537. 

  537.        if ( $Y > $this->Y2 ) { $Y = $this->Y2; }
    538. 

  538. 

  539.        $this->Data[$Key]["X"] = $X;
    540. 

  540.        $this->Data[$Key]["Y"] = $Y;
    541. 

  541.       }
    542. 

  542. 

  543.      /* Dump all links */
    544. 

  544.      $Links = "";
    545. 

  545.      foreach($this->Data as $Key => $Settings)
    546. 

  546.       {
    547. 

  547.        $X1 = $Settings["X"];
    548. 

  548.        $Y1 = $Settings["Y"];
    549. 

  549. 

  550.        if ( isset($Settings["Connections"]) )
    551. 

  551.         {
    552. 

  552.          foreach ($Settings["Connections"] as $ID => $NodeID)
    553. 

  553.           {
    554. 

  554.            if ( isset($this->Data[$NodeID]) )
    555. 

  555.             {
    556. 

  556.              $X2 = $this->Data[$NodeID]["X"];
    557. 

  557.              $Y2 = $this->Data[$NodeID]["Y"];
    558. 

  558. 

  559.              $Links[] = array("X1"=>$X1,"Y1"=>$Y1,"X2"=>$X2,"Y2"=>$Y2,"Source"=>$Settings["Name"],"Destination"=>$this->Data[$NodeID]["Name"]);
    560. 

  560.             }
    561. 

  561.           }
    562. 

  562.         }
    563. 

  563.       }
    564. 

  564. 

  565.      /* Check collisions */
    566. 

  566.      $Conflicts = 0;
    567. 

  567.      foreach($this->Data as $Key => $Settings)
    568. 

  568.       {
    569. 

  569.        $X1 = $Settings["X"];
    570. 

  570.        $Y1 = $Settings["Y"];
    571. 

  571. 

  572.        if ( isset($Settings["Connections"]) )
    573. 

  573.         {
    574. 

  574.          foreach ($Settings["Connections"] as $ID => $NodeID)
    575. 

  575.           {
    576. 

  576.            if ( isset($this->Data[$NodeID]) )
    577. 

  577.             {
    578. 

  578.              $X2 = $this->Data[$NodeID]["X"];
    579. 

  579.              $Y2 = $this->Data[$NodeID]["Y"];
    580. 

  580. 

  581.              foreach($Links as $IDLinks => $Link)
    582. 

  582.               {
    583. 

  583.                $X3 = $Link["X1"]; $Y3 = $Link["Y1"]; $X4 = $Link["X2"]; $Y4 = $Link["Y2"];
    584. 

  584. 

  585.                if ( !($X1 == $X3 && $X2 == $X4 && $Y1 == $Y3 && $Y2 == $Y4 ) )
    586. 

  586.                 {
    587. 

  587.                  if ( $this->intersect($X1,$Y1,$X2,$Y2,$X3,$Y3,$X4,$Y4) )
    588. 

  588.                   {
    589. 

  589.                    if ( $Link["Source"] != $Settings["Name"] && $Link["Source"] != $this->Data[$NodeID]["Name"] && $Link["Destination"] != $Settings["Name"] && $Link["Destination"] != $this->Data[$NodeID]["Name"] )
    590. 

  590.                     { $Conflicts++; }
    591. 

  591.                   }
    592. 

  592.                 }
    593. 

  593.               }
    594. 

  594.             }
    595. 

  595.           }
    596. 

  596.         }
    597. 

  597.       }
    598. 

  598.      return($Conflicts/2);
    599. 

  599.     }
    600. 

  600. 

  601.    /* Center the graph */
    602. 

  602.    function center()
    603. 

  603.     {
    604. 

  604.      /* Determine the real center */
    605. 

  605.      $TargetCenterX = ($this->X2 - $this->X1) / 2 + $this->X1;
    606. 

  606.      $TargetCenterY = ($this->Y2 - $this->Y1) / 2 + $this->Y1;
    607. 

  607. 

  608.      /* Get current boundaries */
    609. 

  609.      $XMin = $this->X2; $XMax = $this->X1;
    610. 

  610.      $YMin = $this->Y2; $YMax = $this->Y1;
    611. 

  611.      foreach($this->Data as $Key => $Settings)
    612. 

  612.       {
    613. 

  613.        $X = $Settings["X"];
    614. 

  614.        $Y = $Settings["Y"];
    615. 

  615. 

  616.        if ( $X < $XMin) { $XMin = $X; }
    617. 

  617.        if ( $X > $XMax) { $XMax = $X; }
    618. 

  618.        if ( $Y < $YMin) { $YMin = $Y; }
    619. 

  619.        if ( $Y > $YMax) { $YMax = $Y; }
    620. 

  620.       }
    621. 

  621.      $CurrentCenterX = ($XMax - $XMin) / 2 + $XMin;
    622. 

  622.      $CurrentCenterY = ($YMax - $YMin) / 2 + $YMin;
    623. 

  623. 

  624.      /* Compute the offset to apply */
    625. 

  625.      $XOffset = $TargetCenterX - $CurrentCenterX;
    626. 

  626.      $YOffset = $TargetCenterY - $CurrentCenterY;
    627. 

  627. 

  628.      /* Correct the points position */
    629. 

  629.      foreach($this->Data as $Key => $Settings)
    630. 

  630.       {
    631. 

  631.        $this->Data[$Key]["X"] = $Settings["X"] + $XOffset;
    632. 

  632.        $this->Data[$Key]["Y"] = $Settings["Y"] + $YOffset;
    633. 

  633.       }
    634. 

  634.     }
    635. 

  635. 

  636.    /* Create the encoded string */
    637. 

  637.    function drawSpring($Object,$Settings="")
    638. 

  638.     {
    639. 

  639.      $this->pChartObject = $Object;
    640. 

  640. 

  641.      $Pass			= isset($Settings["Pass"]) ? $Settings["Pass"] : 50;
    642. 

  642.      $Retries			= isset($Settings["Retry"]) ? $Settings["Retry"] : 10;
    643. 

  643.      $this->MagneticForceA	= isset($Settings["MagneticForceA"]) ? $Settings["MagneticForceA"] : 1.5;
    644. 

  644.      $this->MagneticForceR	= isset($Settings["MagneticForceR"]) ? $Settings["MagneticForceR"] : 2;
    645. 

  645.      $this->RingSize		= isset($Settings["RingSize"]) ? $Settings["RingSize"] : 40;
    646. 

  646.      $DrawVectors		= isset($Settings["DrawVectors"]) ? $Settings["DrawVectors"] : FALSE;
    647. 

  647.      $DrawQuietZone		= isset($Settings["DrawQuietZone"]) ? $Settings["DrawQuietZone"] : FALSE;
    648. 

  648.      $CenterGraph		= isset($Settings["CenterGraph"]) ? $Settings["CenterGraph"] : TRUE;
    649. 

  649.      $TextPadding		= isset($Settings["TextPadding"]) ? $Settings["TextPadding"] : 4;
    650. 

  650.      $Algorithm			= isset($Settings["Algorithm"]) ? $Settings["Algorithm"] : ALGORITHM_WEIGHTED;
    651. 

  651. 

  652.      $FontSize		= $Object->FontSize;
    653. 

  653.      $this->X1		= $Object->GraphAreaX1;
    654. 

  654.      $this->Y1		= $Object->GraphAreaY1;
    655. 

  655.      $this->X2		= $Object->GraphAreaX2;
    656. 

  656.      $this->Y2		= $Object->GraphAreaY2;
    657. 

  657. 

  658.      $Conflicts = 1; $Jobs = 0; $this->History["MinimumConflicts"] = -1;
    659. 

  659.      while ($Conflicts != 0 && $Jobs < $Retries )
    660. 

  660.       {
    661. 

  661.        $Jobs++;
    662. 

  662. 

  663.        /* Compute the initial settings */
    664. 

  664.        $this->firstPass($Algorithm);
    665. 

  665. 

  666.        /* Apply the vectors */
    667. 

  667.        if ( $Pass > 0 ) 
    668. 

  668.         {
    669. 

  669.          for ($i=0; $i<=$Pass; $i++) { $this->doPass(); }
    670. 

  670.         }
    671. 

  671. 

  672.        $Conflicts = $this->lastPass();
    673. 

  673.        if ( $this->History["MinimumConflicts"] == -1 || $Conflicts < $this->History["MinimumConflicts"] )
    674. 

  674.         { $this->History["MinimumConflicts"] = $Conflicts; $this->History["Result"] = $this->Data; }
    675. 

  675.       }
    676. 

  676. 

  677.      $Conflicts  = $this->History["MinimumConflicts"];
    678. 

  678.      $this->Data = $this->History["Result"];
    679. 

  679. 

  680.      if ( $CenterGraph ) { $this->center(); }
    681. 

  681. 

  682.      /* Draw the connections */
    683. 

  683.      $Drawn = "";
    684. 

  684.      foreach($this->Data as $Key => $Settings)
    685. 

  685.       {
    686. 

  686.        $X	= $Settings["X"];
    687. 

  687.        $Y	= $Settings["Y"];
    688. 

  688. 

  689.        if ( isset($Settings["Connections"]) )
    690. 

  690.         {
    691. 

  691.          foreach ($Settings["Connections"] as $ID => $NodeID)
    692. 

  692.           {
    693. 

  693.            if ( !isset($Drawn[$Key]) )    { $Drawn[$Key] = ""; }
    694. 

  694.            if ( !isset($Drawn[$NodeID]) ) { $Drawn[$NodeID] = ""; }
    695. 

  695. 

  696.            if ( isset($this->Data[$NodeID]) && !isset($Drawn[$Key][$NodeID]) && !isset($Drawn[$NodeID][$Key]) )
    697. 

  697.             {
    698. 

  698.              $Color = array("R"=>$this->Default["LinkR"],"G"=>$this->Default["LinkG"],"B"=>$this->Default["LinkB"],"Alpha"=>$this->Default["Alpha"]);
    699. 

  699. 

  700.              if ( $this->Links != "" )
    701. 

  701.               {
    702. 

  702.                if ( isset($this->Links[$Key][$NodeID]["R"]) )
    703. 

  703.                 { $Color = array("R"=>$this->Links[$Key][$NodeID]["R"],"G"=>$this->Links[$Key][$NodeID]["G"],"B"=>$this->Links[$Key][$NodeID]["B"],"Alpha"=>$this->Links[$Key][$NodeID]["Alpha"]); }
    704. 

  704. 

  705.                if ( isset($this->Links[$Key][$NodeID]["Ticks"]) )
    706. 

  706.                  { $Color["Ticks"] = $this->Links[$Key][$NodeID]["Ticks"]; }
    707. 

  707.               }
    708. 

  708. 

  709.              $X2 = $this->Data[$NodeID]["X"];
    710. 

  710.              $Y2 = $this->Data[$NodeID]["Y"];
    711. 

  711.              $this->pChartObject->drawLine($X,$Y,$X2,$Y2,$Color);
    712. 

  712.              $Drawn[$Key][$NodeID] = TRUE;
    713. 

  713. 

  714.              if ( isset($this->Links) && $this->Links != "" )
    715. 

  715.               {
    716. 

  716.                if ( isset($this->Links[$Key][$NodeID]["Name"]) || isset($this->Links[$NodeID][$Key]["Name"]) )
    717. 

  717.                 {
    718. 

  718.                  $Name  = isset($this->Links[$Key][$NodeID]["Name"]) ? $this->Links[$Key][$NodeID]["Name"] : $this->Links[$NodeID][$Key]["Name"];
    719. 

  719.                  $TxtX  = ($X2 - $X)/2 + $X;
    720. 

  720.                  $TxtY  = ($Y2 - $Y)/2 + $Y;
    721. 

  721. 

  722.                  if ( $X <= $X2 )
    723. 

  723.                   $Angle = (360-$this->getAngle($X,$Y,$X2,$Y2)) % 360;
    724. 

  724.                  else
    725. 

  725.                   $Angle = (360-$this->getAngle($X2,$Y2,$X,$Y)) % 360;
    726. 

  726. 

  727.                  $Settings          = $Color;
    728. 

  728.                  $Settings["Angle"] = $Angle;
    729. 

  729.                  $Settings["Align"] = TEXT_ALIGN_BOTTOMMIDDLE;
    730. 

  730.                  $this->pChartObject->drawText($TxtX,$TxtY,$Name,$Settings);
    731. 

  731.                 }
    732. 

  732.               }
    733. 

  733.             }
    734. 

  734.           }
    735. 

  735.         }
    736. 

  736.       }
    737. 

  737. 

  738.      /* Draw the quiet zones */
    739. 

  739.      if ( $DrawQuietZone )
    740. 

  740.       {
    741. 

  741.        foreach($this->Data as $Key => $Settings)
    742. 

  742.         {
    743. 

  743.          $X	 = $Settings["X"];
    744. 

  744.          $Y	 = $Settings["Y"];
    745. 

  745.          $FreeZone = $Settings["FreeZone"];
    746. 

  746. 

  747.          $this->pChartObject->drawFilledCircle($X,$Y,$FreeZone,array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>2));
    748. 

  748.         }
    749. 

  749.       }
    750. 

  750. 

  751. 

  752.      /* Draw the nodes */
    753. 

  753.      foreach($this->Data as $Key => $Settings)
    754. 

  754.       {
    755. 

  755.        $X	 = $Settings["X"];
    756. 

  756.        $Y	 = $Settings["Y"];
    757. 

  757.        $Name	 = $Settings["Name"];
    758. 

  758.        $FreeZone = $Settings["FreeZone"];
    759. 

  759.        $Shape    = $Settings["Shape"];
    760. 

  760.        $Size     = $Settings["Size"];
    761. 

  761. 

  762.        $Color	 = array("R"=>$Settings["R"],"G"=>$Settings["G"],"B"=>$Settings["B"],"Alpha"=>$Settings["Alpha"],"BorderR"=>$Settings["BorderR"],"BorderG"=>$Settings["BorderG"],"BorderB"=>$Settings["BorderB"],"BorderApha"=>$Settings["BorderAlpha"]);
    763. 

  763. 

  764.        if ( $Shape == NODE_SHAPE_CIRCLE )
    765. 

  765.         {
    766. 

  766.          $this->pChartObject->drawFilledCircle($X,$Y,$Size,$Color);
    767. 

  767.         }
    768. 

  768.        elseif ( $Shape == NODE_SHAPE_TRIANGLE )
    769. 

  769.         {
    770. 

  770.          $Points = "";
    771. 

  771.          $Points[] = cos(deg2rad(270)) * $Size + $X; $Points[] = sin(deg2rad(270)) * $Size + $Y;
    772. 

  772.          $Points[] = cos(deg2rad(45)) * $Size + $X;  $Points[] = sin(deg2rad(45)) * $Size + $Y;
    773. 

  773.          $Points[] = cos(deg2rad(135)) * $Size + $X; $Points[] = sin(deg2rad(135)) * $Size + $Y;
    774. 

  774.          $this->pChartObject->drawPolygon($Points,$Color);
    775. 

  775.         }
    776. 

  776.        elseif ( $Shape == NODE_SHAPE_SQUARE )
    777. 

  777.         {
    778. 

  778.          $Offset = $Size/2; $Size = $Size / 2;
    779. 

  779.          $this->pChartObject->drawFilledRectangle($X-$Offset,$Y-$Offset,$X+$Offset,$Y+$Offset,$Color);
    780. 

  780.         }
    781. 

  781. 

  782.        if ( $Name != "" )
    783. 

  783.         {
    784. 

  784.          $LabelOptions = array("R"=>$this->Labels["R"],"G"=>$this->Labels["G"],"B"=>$this->Labels["B"],"Alpha"=>$this->Labels["Alpha"]);
    785. 

  785. 

  786.          if ( $this->Labels["Type"] == LABEL_LIGHT )
    787. 

  787.           {
    788. 

  788.            $LabelOptions["Align"] = TEXT_ALIGN_BOTTOMLEFT;
    789. 

  789.            $this->pChartObject->drawText($X,$Y,$Name,$LabelOptions);
    790. 

  790.           }
    791. 

  791.          elseif ( $this->Labels["Type"] == LABEL_CLASSIC )
    792. 

  792.           {
    793. 

  793.            $LabelOptions["Align"]         = TEXT_ALIGN_TOPMIDDLE;
    794. 

  794.            $LabelOptions["DrawBox"]       = TRUE;
    795. 

  795.            $LabelOptions["BoxAlpha"]      = 50;
    796. 

  796.            $LabelOptions["BorderOffset"]  = 4;
    797. 

  797.            $LabelOptions["RoundedRadius"] = 3;
    798. 

  798.            $LabelOptions["BoxRounded"]    = TRUE;
    799. 

  799.            $LabelOptions["NoShadow"]      = TRUE;
    800. 

  800. 

  801.            $this->pChartObject->drawText($X,$Y+$Size+$TextPadding,$Name,$LabelOptions);
    802. 

  802.           }
    803. 

  803.         }
    804. 

  804.       }
    805. 

  805. 

  806.      /* Draw the vectors */
    807. 

  807.      if ( $DrawVectors )
    808. 

  808.       {
    809. 

  809.        foreach($this->Data as $Key => $Settings)
    810. 

  810.         {
    811. 

  811.          $X1 = $Settings["X"];
    812. 

  812.          $Y1 = $Settings["Y"];
    813. 

  813. 

  814.          if ( isset($Settings["Vectors"]) && $Settings["Type"] != NODE_TYPE_CENTRAL )
    815. 

  815.           {
    816. 

  816.            foreach($Settings["Vectors"] as $ID => $Vector)
    817. 

  817.             {
    818. 

  818.              $Type  = $Vector["Type"];
    819. 

  819.              $Force = $Vector["Force"];
    820. 

  820.              $Angle = $Vector["Angle"];
    821. 

  821.              $Factor = $Type == "A" ? $this->MagneticForceA : $this->MagneticForceR;
    822. 

  822.              $Color  = $Type == "A" ? array("FillR"=>255,"FillG"=>0,"FillB"=>0) : array("FillR"=>0,"FillG"=>255,"FillB"=>0);
    823. 

  823. 

  824.              $X2 = cos(deg2rad($Angle)) * $Force * $Factor + $X1;
    825. 

  825.              $Y2 = sin(deg2rad($Angle)) * $Force * $Factor + $Y1;
    826. 

  826. 

  827.              $this->pChartObject->drawArrow($X1,$Y1,$X2,$Y2,$Color);
    828. 

  828.             }
    829. 

  829.           }
    830. 

  830.         }
    831. 

  831.       }
    832. 

  832. 

  833.      return(array("Pass"=>$Jobs,"Conflicts"=>$Conflicts));
    834. 

  834.     }
    835. 

  835. 

  836.    /* Return the distance between two points */
    837. 

  837.    function getDistance($X1,$Y1,$X2,$Y2)
    838. 

  838.     { return (sqrt(($X2-$X1)*($X2-$X1)+($Y2-$Y1)*($Y2-$Y1))); }
    839. 

  839. 

  840.    /* Return the angle made by a line and the X axis */
    841. 

  841.    function getAngle($X1,$Y1,$X2,$Y2)
    842. 

  842.     {
    843. 

  843.      $Opposite = $Y2 - $Y1; $Adjacent = $X2 - $X1;$Angle = rad2deg(atan2($Opposite,$Adjacent));
    844. 

  844.      if ($Angle > 0) { return($Angle); } else { return(360-abs($Angle)); }
    845. 

  845.     }
    846. 

  846. 

  847.    function intersect($X1,$Y1,$X2,$Y2,$X3,$Y3,$X4,$Y4)
    848. 

  848.     {
    849. 

  849.      $A = (($X3 * $Y4 - $X4 * $Y3) * ($X1 - $X2) - ($X1 * $Y2 - $X2 * $Y1) * ($X3 - $X4));
    850. 

  850.      $B = (($Y1 - $Y2) * ($X3 - $X4) - ($Y3 - $Y4) * ($X1 - $X2));
    851. 

  851. 

  852.      if ( $B == 0 ) { return(FALSE); }
    853. 

  853.      $Xi = $A / $B;
    854. 

  854. 

  855.      $C = ($X1 - $X2);
    856. 

  856.      if ( $C == 0 ) { return(FALSE); }
    857. 

  857.      $Yi = $Xi * (($Y1 - $Y2)/$C) + (($X1 * $Y2 - $X2 * $Y1)/$C);
    858. 

  858. 

  859.      if ( $Xi >= min($X1,$X2) && $Xi >= min($X3,$X4) && $Xi <= max($X1,$X2) && $Xi <= max($X3,$X4))
    860. 

  860.       {
    861. 

  861.        if ( $Yi >= min($Y1,$Y2) && $Yi >= min($Y3,$Y4) && $Yi <= max($Y1,$Y2) && $Yi <= max($Y3,$Y4))
    862. 

  862.         { return(TRUE); }
    863. 

  863.       }
    864. 

  864. 

  865.       return(FALSE);   
    866. 

  866.     }
    867. 

  867.   }
    868. 

  868. ?>
    869.