let applicableFilters = {};

let physics;

​

function isNodeApplicable(node)

{

  const found = Object.keys(applicableFilters).find((key) => {

    return applicableFilters[key].find((value) => value == node.value);

  })

  return !!found;

}

​

function drawNodes() {

  const nodes = FilterNode.nodes;

  push();

  background(0);

  translate(width/2, height/2);

  const linked = {};

  nodes.forEach((node) => {

    node.peripheral = node.selected ? false : isNodeApplicable(node);

  })

  nodes.forEach((node) => {

    node.draw();

  })

  nodes.filter((node) => (node.selected || node.peripheral || node.searched)).forEach((node) => {

    node.links.forEach((nodeId) => {

      const _node = FilterNode.nodes[nodeId];

      if ((node.peripheral || _node.peripheral) && (node.selected || _node.selected))

      {

        strokeWeight(1);

        stroke('rgba(0,255,0,0.5)');

        line(node.x+5, node.y+5, _node.x+5, _node.y+5);

      }

    })

  })

  nodes.filter((node) => (node.selected || node.peripheral || node.searched)).forEach((node) => {

    node.draw();

  });

  pop();

}

​

function remapNodes() {

  const nodes = FilterNode.nodes;

  const layers = {};

  nodes.forEach((node) => {

    if (!layers[node.key])

      layers[node.key] = []

    layers[node.key].push(node);

  })

  let radius = 5;

  let delta = 0.05;

  Object.keys(layers).sort((a, b) => (layers[a].length - layers[b].length)).map((layer, index) => {

    const nodes = layers[layer];

    let angle = index * 10 * Math.random();

    nodes.forEach((node) => {

      //node.x = radius * cos(angle);

      //node.y = radius * sin(angle);

      node.x = Math.random() * width * 1.0 - 0.5 * width;

      node.y = Math.random() * height * 1.0 - 0.5 * height;

      angle += (Math.PI * 2) / nodes.length;

    });

    radius += delta;

    delta += 0.000078 * index * index;

  })

}

​

function setup() {

  createCanvas(windowWidth, windowHeight);

  physics = new VerletPhysics2D();

  //drawNodes();

  //remapNodes();

}

​

function draw() {

  physics.update()

  background(200);

  if (cluster)

  {

    cluster.showConnections();

    cluster.show();

  }

}

​

function mousePressed() {

  let shortestDist = Infinity;

  let closestNode = null;

  const pressedNode = FilterNode.nodes.forEach((node) => {

    const dist = Math.sqrt(Math.pow(mouseX - node.x, 2) + Math.pow(mouseY - node.y, 2));

    if (dist < 10 && dist < shortestDist) {

      shortestDist = dist;

      closestNode = node;

    }

  });

  if (closestNode)

  {

    if (!selectedFilters[closestNode.key])

      selectedFilters[closestNode.key] = []

    const index = selectedFilters[closestNode.key].indexOf(closestNode.value);

    if (index >= 0)

    {

      selectedFilters[closestNode.key].splice(index, 1);

      closestNode.selected = false;

      if (selectedFilters[closestNode.key].length == 0)

      {

        delete selectedFilters[closestNode.key];

      }

    }

    else

    {

      selectedFilters[closestNode.key].push(closestNode.value);

      closestNode.selected = true;

    }

    applicableFilters = filters.getRelatedFilters(selectedFilters);

  }

  console.log("SELECTING", closestNode);

  //drawNodes();

}

​

function clearSelection() {

  FilterNode.nodes.forEach((node) => {node.selected = false;})

  selectedFilters = {};

  applicableFilters = {};

  //drawNodes();

}

​

function searchnode(event) {

  const value = event.target.value;

  console.log("SEARCHING FOR", value);

  FilterNode.nodes.forEach((node) => {

    if (value == "")

        node.searched = false;

    else if (node.value.toLowerCase().includes(value.toLowerCase()))

      node.searched = true;

    else

      node.searched = false;

  })

  //drawNodes();

}