public PieChart fillChartPiePopBovinos() {

    HashMap<String, Integer> data = dataForChartEdadesySexo();
    int total = 0;
    Set<String> keySet = data.keySet();
    for (String key : keySet) {
      total = total + data.get(key);
    }
    ObservableList<PieChart.Data> pieChartData = FXCollections.observableArrayList();

    System.out.println("total=" + total);
    int percent;
    double di;
    for (String key : keySet) {
      di = (double) data.get(key) / (double) total;
      percent = (int) (di * 100);
      pieChartData.add(new PieChart.Data(key, percent));
    }

    final PieChart chart = new PieChart(pieChartData);
    chart.setTitle("Población de Bovinos");

    // set it to pane
    return (chart);
  }
 public void load3(Event event) {
   f.clear();
   String extra;
   String[] extra1;
   HashMap<String, Integer> h = new HashMap<String, Integer>();
   try {
     BufferedReader x = new BufferedReader(new FileReader("./src/Expenses.txt"));
     extra = x.readLine();
     extra = x.readLine();
     extra = x.readLine();
     while ((extra = x.readLine()) != null) {
       extra1 = extra.split(" ");
       if (h.containsKey(extra1[0])) {
         h.put(extra1[0], h.get(extra1[0]) + Integer.parseInt(extra1[1]));
       }
       h.put(extra1[0], Integer.parseInt(extra1[1]));
     }
     Set<String> keys = h.keySet();
     for (String key : keys) {
       f.add(new PieChart.Data(key, h.get(key)));
     }
     x.close();
     chr.setData(f);
   } catch (IOException ex) {
     ex.printStackTrace();
   }
 }
  @Override
  public void start(Stage primaryStage) {
    PieChart pieChart = new PieChart();
    pieChart.setData(getPieData());

    final CategoryAxis xAxis = new CategoryAxis();
    final NumberAxis yAxis = new NumberAxis();
    final StackedBarChart<String, Number> sbc = new StackedBarChart<>(xAxis, yAxis);
    ObservableList<Series<String, Number>> barData = createBarData(getPieData());
    // simulate client code that re-orders/filters the data
    FXCollections.shuffle(barData);
    sbc.setData(barData);

    primaryStage.setTitle("Correlated Charts");
    Scene scene = new Scene(new HBox(pieChart, sbc));
    primaryStage.setScene(scene);
    primaryStage.show();
  }
  @Override
  public void initialize(URL url, ResourceBundle rb) {

    Sql.loadSql();

    total.setText("$" + expenseTotal);

    name.setCellValueFactory(new PropertyValueFactory<Expense, String>("name"));
    name.setCellFactory(TextFieldTableCell.<String>forTableColumn());
    vendor.setCellValueFactory(new PropertyValueFactory<Expense, String>("vendor"));
    vendor.setCellFactory(TextFieldTableCell.<String>forTableColumn());
    date.setCellValueFactory(new PropertyValueFactory<Expense, String>("date"));
    date.setCellFactory(TextFieldTableCell.<String>forTableColumn());
    cost.setCellValueFactory(new PropertyValueFactory<Expense, Double>("cost"));
    cost.setCellFactory(
        TextFieldTableCell.forTableColumn(
            new StringConverter<Double>() {

              @Override
              public String toString(Double object) {
                return object.toString();
              }

              @Override
              public Double fromString(String string) {
                return Double.parseDouble(string);
              }
            }));

    add.setOnAction(e -> Action.addExpense());
    delete.setOnAction(e -> Action.deleteExpense());

    if (tableList.size() > 0) emptyLabel.setText("");

    table.setItems(tableList);
    pieChart.setData(pieChartList);
  }
 /** initializes the PieChart */
 private void initializePieChart() {
   ObservableList<PieChart.Data> pieChartData =
       FXCollections.observableArrayList(
           new PieChart.Data("To Keep", 100), new PieChart.Data("To Remove", 0));
   pieChartSubsToRemove.setData(pieChartData);
 }
 @Override
 public void initialize(URL location, ResourceBundle resources) {
   // Set measurement result into scene
   domainName.setText(StaticVars.currentDomainName);
   domainNameLabel.setText(StaticVars.currentLabel);
   domainNameResponseTime.setText(StaticVars.currentResponseTime + " second(s)");
   domainNameDateMeasured.setText(String.valueOf(StaticVars.currentDate));
   if (StaticVars.methodType == 1) {
     labelSiteComposition.setVisible(false);
     chartCompositionDangerousity.setVisible(false);
   } else {
     if (StaticVars.currentLabel.equals("normal")) {
       labelSiteComposition.setVisible(false);
       chartCompositionDangerousity.setVisible(false);
     } else {
       if (!StaticVars.currentLabel.equals("malicious (unknown type)")
           && !StaticVars.currentLabel.equals("unknown")) {
         Triplet<Double, Double, Double> compositionDangerousity = StaticVars.currentComposition;
         ObservableList<PieChart.Data> pieChartElements = FXCollections.observableArrayList();
         pieChartElements.addAll(
             new PieChart.Data("Malware", compositionDangerousity.getValue0()),
             new PieChart.Data("Phishing", compositionDangerousity.getValue1()),
             new PieChart.Data("Spamming", compositionDangerousity.getValue2()));
         chartCompositionDangerousity.setData(pieChartElements);
         chartCompositionDangerousity.setLegendSide(Side.RIGHT);
         chartCompositionDangerousity.setLabelLineLength(10);
       } else {
         labelSiteComposition.setVisible(false);
         chartCompositionDangerousity.setVisible(false);
       }
     }
   }
   // Save this reputation result into eksternal file
   historySitesReputation thisResultReputation = new historySitesReputation();
   thisResultReputation.setCompositionDangerousity(StaticVars.currentComposition);
   thisResultReputation.setLabelNormality(StaticVars.currentLabel);
   thisResultReputation.setResponseTime(Long.parseLong(StaticVars.currentResponseTime));
   thisResultReputation.setMeasureDate(StaticVars.currentDate);
   switch (StaticVars.reputationType) {
     case 1:
       thisResultReputation.setReputationType("DNS");
       break;
     case 2:
       thisResultReputation.setReputationType("Spesific");
       break;
     case 3:
       thisResultReputation.setReputationType("Trust");
       break;
     case 4:
       thisResultReputation.setReputationType("DNS+Spesific");
       break;
     case 5:
       thisResultReputation.setReputationType("DNS+Trust");
       break;
     case 6:
       thisResultReputation.setReputationType("Spesific+Trust");
       break;
     case 7:
       thisResultReputation.setReputationType("DNS+Spesific+Trust");
       break;
   }
   switch (StaticVars.methodType) {
     case 1:
       thisResultReputation.setMethodType("supervised");
       break;
     case 2:
       thisResultReputation.setMethodType("unsupervised");
       break;
     case 3:
       thisResultReputation.setMethodType("hybrid");
       break;
   }
   List<Pair<String, historySitesReputation>> oldHistoryReputation =
       reputationResultController.loadHistoryReputation();
   Pair<String, historySitesReputation> addedHistoryReputation =
       new Pair<String, historySitesReputation>(
           StaticVars.currentDomainName, thisResultReputation);
   oldHistoryReputation.add(addedHistoryReputation);
   reputationResultController.saveHistoryReputation(oldHistoryReputation);
 }
 public WeightCoverageChart() {
   weightA.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(
               0,
               new PieChart.Data("A " + weightA.doubleValue() + "kgs", (weightA.doubleValue())));
         }
       });
   weightB.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(1, new PieChart.Data("B", (weightB.doubleValue())));
         }
       });
   weightC.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(2, new PieChart.Data("C", (weightC.doubleValue())));
         }
       });
   weightD.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(3, new PieChart.Data("D", (weightD.doubleValue())));
         }
       });
   weightE.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(4, new PieChart.Data("E", (weightE.doubleValue())));
         }
       });
   weightF.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(5, new PieChart.Data("F", (weightF.doubleValue())));
         }
       });
   weightG.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(6, new PieChart.Data("G", (weightG.doubleValue())));
         }
       });
   weightH.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(7, new PieChart.Data("H", (weightH.doubleValue())));
         }
       });
   weightI.addListener(
       new ChangeListener<Number>() {
         @Override
         public void changed(
             ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
           pieData.set(8, new PieChart.Data("I", (weightI.doubleValue())));
         }
       });
   this.setCache(true);
   pie.setData(pieData);
   Rectangle pieBG =
       RectangleBuilder.create()
           .cache(true)
           .x(pie.getTranslateX() + 127)
           .y(pie.getTranslateY() + 84)
           .fill(Color.rgb(50, 50, 50))
           .id("envelopeBG")
           .width(265)
           .height(245)
           .arcWidth(5)
           .arcHeight(5)
           .build();
   Group group = new Group();
   group.getChildren().addAll(pieBG, pie);
   getChildren().add(group);
 }
  public void assignSampleData(FXOMObject startObject) {
    assert startObject != null;

    final Object sceneGraphObject = startObject.getSceneGraphObject();
    final AbstractSampleData currentData = sampleDataMap.get(startObject);
    final AbstractSampleData newData;

    if (sceneGraphObject == null) {
      // startObject is unresolved
      newData = null;
    } else {
      final Class<?> sceneGraphClass = sceneGraphObject.getClass();
      if (sceneGraphClass == ChoiceBox.class) {
        final ChoiceBox<?> choiceBox = (ChoiceBox) sceneGraphObject;
        if (choiceBox.getItems().isEmpty()) {
          if (currentData instanceof ChoiceBoxSampleData) {
            newData = currentData;
          } else {
            newData = new ChoiceBoxSampleData();
          }
        } else {
          newData = null;
        }
      } else if (sceneGraphClass == ComboBox.class) {
        final ComboBox<?> comboBox = (ComboBox) sceneGraphObject;
        if (comboBox.getItems().isEmpty()) {
          if (currentData instanceof ComboBoxSampleData) {
            newData = currentData;
          } else {
            newData = new ComboBoxSampleData();
          }
        } else {
          newData = null;
        }
      } else if (sceneGraphClass == ListView.class) {
        final ListView<?> listView = (ListView) sceneGraphObject;
        if (listView.getItems().isEmpty()) {
          if (currentData instanceof ListViewSampleData) {
            newData = currentData;
          } else {
            newData = new ListViewSampleData();
          }
        } else {
          newData = null;
        }
      } else if (sceneGraphClass == TreeView.class) {
        final TreeView<?> treeView = (TreeView) sceneGraphObject;
        if (treeView.getRoot() == null) {
          if (currentData instanceof TreeViewSampleData) {
            newData = currentData;
          } else {
            newData = new TreeViewSampleData();
          }
        } else {
          newData = null;
        }
      } else if (sceneGraphClass == TableView.class) {
        final TableView<?> treeView = (TableView) sceneGraphObject;
        if (TableViewSampleData.canApplyTo(treeView)) {
          if (currentData instanceof TableViewSampleData) {
            newData = currentData;
          } else {
            newData = new TableViewSampleData();
          }
        } else {
          newData = null;
        }
      } else if (sceneGraphClass == TreeTableView.class) {
        final TreeTableView<?> treeTableView = (TreeTableView) sceneGraphObject;
        if (treeTableView.getRoot() == null) {
          if (currentData instanceof TreeTableViewSampleData) {
            newData = currentData;
          } else {
            newData = new TreeTableViewSampleData();
          }
        } else {
          newData = null;
        }
      } else if (sceneGraphClass == PieChart.class) {
        final PieChart pieChart = (PieChart) sceneGraphObject;
        if (pieChart.getData().isEmpty()) {
          if (currentData instanceof PieChartSampleData) {
            newData = currentData;
          } else {
            newData = new PieChartSampleData();
          }
        } else {
          newData = null;
        }
      } else if (XYChartSampleData.isKnownXYChart(sceneGraphObject)) {
        final XYChart<?, ?> xyChart = (XYChart) sceneGraphObject;
        if (xyChart.getData().isEmpty()) {
          if (currentData instanceof XYChartSampleData) {
            newData = currentData;
          } else {
            newData = new XYChartSampleData();
          }
        } else {
          newData = null;
        }
      } else {
        newData = null;
      }
    }

    if (newData == null) {
      if (currentData != null) {
        sampleDataMap.remove(startObject);
      }
    } else {
      newData.applyTo(sceneGraphObject);
      sampleDataMap.put(startObject, newData);
    }

    if (startObject instanceof FXOMInstance) {
      final FXOMInstance fxomInstance = (FXOMInstance) startObject;
      for (FXOMProperty p : fxomInstance.getProperties().values()) {
        if (p instanceof FXOMPropertyC) {
          final FXOMPropertyC pc = (FXOMPropertyC) p;
          for (FXOMObject v : pc.getValues()) {
            assignSampleData(v);
          }
        }
      }
    } else if (startObject instanceof FXOMCollection) {
      final FXOMCollection fxomCollection = (FXOMCollection) startObject;
      for (FXOMObject i : fxomCollection.getItems()) {
        assignSampleData(i);
      }
    }
  }