Gist 6380d89d2f26c575b4325e85d39274a6

100%

Gist 6380d89d2f26c575b4325e85d39274a6

✓ Published0🌍 Public

Last edited Aug 22, 2021

Created on Aug 21, 2021

This visualization ranks soccer defenders by a calculated "weight" score, blending their difficulty of upcoming fixtures, recent form, and selection confidence. It shows a bar chart where each player’s bar length encodes their total weight, sorted from highest to lowest. The chart uses D3.js with `d3.scaleLinear` for the x-axis and `d3.axisBottom` for ticks, while bars are drawn as SVG `rect` elements. Data comes from a static CSV file (`in_weights.csv`) listing player names, fixture difficulty, form, and chance of playing. Tooltips appear on hover via `d3.tip`, revealing the underlying stats for each player.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 2186477931c9166d8a5f26d5ebcd0e55

This visualization shows a simulated ranking of soccer players based on their fantasy-league value, where each player’s node weight reflects a blend of difficulty, form, and chance of playing. A force-directed layout using d3.forceSimulation positions the labeled nodes, while their size and color encode the computed weight. The chart draws directly from the CSV data in out_weights.csv, with player names as text labels. The code relies on D3’s selection and data-binding methods to bind the tabular rows to circle and text elements, and it uses the simulation’s tick event to update positions dynamically, though no explicit interaction or animation beyond the layout is implemented.

CConorAspell

85% match

Loading thumbnail…

Gist 0ff68c82fce6408905fe7964eaf25be3

The visualization ranks ten Premier League midfielders by their current fantasy football weight, mapping each player’s name to a horizontal bar chart. It shows relative player value through bar length, with heavier weights (e.g., Harrison at 27.5) extending farther than lighter ones (e.g., Walcott at 21.5). The code uses D3.js’s `scaleBand` and `scaleLinear` to position and size the bars, while `d3.select` and `attr` methods bind the CSV data from `player_in_weights.csv` to SVG rectangles. Player names and weights are appended as text labels using `text` and `attr` calls, with the chart’s axes and gridlines drawn via `d3.axisBottom` and `d3.axisLeft`.

CConorAspell

84% match

Loading thumbnail…

Gist 08396e82bf7fe86a88d9a131f1a2654d

This visualization shows a force-directed network of football (soccer) players, with each node representing a player and edges likely indicating team or shared-match connections. The code uses `d3.forceSimulation` to calculate node positions and applies a custom weighting scheme to influence node size or opacity, though the rendering itself is not shown in the snippet. The weighting logic, defined in `out_weights.py`, modifies each player’s outgoing influence by subtracting fixture difficulty and form (scaled by 10), adding a small penalty for low play chance, and reducing weight for goalkeepers (element type 1). The data source is a pandas DataFrame of player statistics, and the visualization is part of an interactive dashboard built with JavaScript.

CConorAspell

80% match

Loading thumbnail…

Gist b541552eb18726aea9a989003304b013

This visualization shows a network of Premier League players as connected nodes, with each player’s node size and position determined by a custom weight calculation. The code, written in Python, uses a pandas DataFrame to compute an `in_weight` for each player by combining fixture difficulty, current form, and the chance of playing this round, with negative weights clamped to zero. The rendering approach is not shown in the code, but the visible structure suggests a force-directed or scatter-plot layout, likely built with a library like D3.js or Plotly. The data source is a player statistics table, with the weight influencing node prominence.

CConorAspell

80% match

Loading thumbnail…

Gist 6583ab0c6c2fb592d0c980d0fa48bbbd

This visualization uses a force-directed simulation to lay out a network of fantasy football players, with each node’s size mapped to a player’s weight attribute from the starters.csv file. The chart reveals the relative heft of players like Wan-Bissaka and Son, contrasting them with lighter picks such as Maupay. Built with D3’s `d3.forceSimulation`, it applies collision and charge forces to space nodes, while `d3.drag` enables interactive repositioning. Node size is encoded via `d3.scaleSqrt`, and the canvas is redrawn each tick, making the weight distribution immediately apparent.

CConorAspell

78% match

Loading thumbnail…

Gist 10ad2f6c126f2280c720ff15922f5a5a

This visualization is a force-directed network diagram of a fantasy football team, mapping player connections through shared club or selection data. It shows each player as a node with a label, while weighted links between them are computed and rendered in real time. The code uses `d3.forceSimulation` with `forceLink`, `forceManyBody`, and `forceCenter` to arrange nodes, and `d3.geoPath` is not used—instead, links are drawn as SVG lines and nodes as circles. Player weights from the CSV file (e.g., 14.6 for Lacazette) are encoded via node radius, and the visualization updates smoothly with `transition.attrTween` on position changes. Data comes directly from the embedded `player_weights.csv` array, parsed into JavaScript objects for the simulation.

CConorAspell

77% match

Loading thumbnail…

Gist 1da59c7531b92d80b1087f8b51ac9d17

This visualization tracks fantasy Premier League player transfer momentum by calculating weighted "in" and "out" scores from fixture difficulty, player form, and selection chance. It uses a Python AWS Lambda function to fetch live data from the Fantasy Premier League API, merge it with bookmaker odds stored in an S3 bucket, and output a CSV of player weights per gameweek. The code relies on `pandas` for data manipulation, `boto3` for cloud storage access, and `requests` for API calls, with team strengths and fixture probabilities driving the transfer recommendations.

CConorAspell

76% match

Loading thumbnail…

Gist 9a395dc704cccccadb07f5963767f02a

This visualization maps the projected difficulty of upcoming fixtures for each team in a sports league, using a force-directed network layout. It shows the relationship between teams based on their opponents’ home and away difficulty ratings, with nodes positioned by a simulated physics model. The implementation relies on `d3.forceSimulation` to compute node positions and link forces, while `d3.geoPath` is not used here—instead, SVG elements are drawn for nodes and edges. The data comes from the `next_fixtures.csv` file, which lists team IDs and their assigned difficulty values. The code reads this CSV and renders a static snapshot, without interactive transitions or canvas-based pixel manipulation.

CConorAspell

76% match