List of usage examples for org.jfree.chart.plot Marker setPaint
public void setPaint(Paint paint)
From source file:com.jtstand.swing.StatsPanel.java
public void placeLimitMarkers(XYPlot plot, boolean range) { if (testStepInstances.getReferenceStep() != null && testStepInstances.getReferenceStep().getTestLimit() != null) { if (testStepInstances.getReferenceStep().getTestLimit().getLowerSpecifiedLimit() != null) { final Marker lsl = new ValueMarker( testStepInstances.getReferenceStep().getTestLimit().getLowerSpecifiedLimit()); lsl.setPaint(limitcolor); lsl.setLabel("LSL"); if (range) { lsl.setLabelAnchor(RectangleAnchor.BOTTOM_RIGHT); lsl.setLabelTextAnchor(TextAnchor.TOP_RIGHT); plot.addRangeMarker(lsl); } else { lsl.setLabelAnchor(RectangleAnchor.TOP_LEFT); lsl.setLabelTextAnchor(TextAnchor.TOP_RIGHT); plot.addDomainMarker(lsl); }//from w ww.j av a 2 s.c o m } if (testStepInstances.getReferenceStep().getTestLimit().getUpperSpeficiedLimit() != null) { final Marker usl = new ValueMarker( testStepInstances.getReferenceStep().getTestLimit().getUpperSpeficiedLimit()); usl.setPaint(limitcolor); usl.setLabel("USL"); if (range) { usl.setLabelAnchor(RectangleAnchor.TOP_RIGHT); usl.setLabelTextAnchor(TextAnchor.BOTTOM_RIGHT); plot.addRangeMarker(usl); } else { usl.setLabelAnchor(RectangleAnchor.TOP_RIGHT); usl.setLabelTextAnchor(TextAnchor.TOP_LEFT); plot.addDomainMarker(usl); } } } }
From source file:desmoj.extensions.visualization2d.engine.modelGrafic.StatisticGrafic.java
/** * Update of animation type StatisticGrafic.ANIMATION_Histogram * @throws ModelException/*w ww .ja va 2 s. com*/ */ private void updateHistogram() throws ModelException { Marker meanMarker, minMarker, maxMarker; double mean, min0, max0; XYPlot plot = this.chart.getXYPlot(); String domainAxisLabel = "Observations "; switch (this.statistic.getTypeIndex()) { case Statistic.INDEX_None: break; case Statistic.INDEX_Min_Max: plot.clearDomainMarkers(); min0 = statistic.getMin(); max0 = statistic.getMax(); if (!Double.isNaN(min0)) { minMarker = new ValueMarker(min0); minMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_MIN_MAX); minMarker.setStroke(new BasicStroke(2.0f)); plot.addDomainMarker(minMarker, Layer.FOREGROUND); } if (!Double.isNaN(max0)) { maxMarker = new ValueMarker(max0); maxMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_MIN_MAX); maxMarker.setStroke(new BasicStroke(2.0f)); plot.addDomainMarker(maxMarker, Layer.FOREGROUND); } domainAxisLabel += "(min - max)"; break; case Statistic.INDEX_Mean_StdDev: plot.clearDomainMarkers(); min0 = statistic.getMean() - statistic.getStdDev(); max0 = statistic.getMean() + statistic.getStdDev(); mean = statistic.getMean(); if (!Double.isNaN(mean)) { meanMarker = new ValueMarker(mean); meanMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_MEAN); meanMarker.setStroke(new BasicStroke(2.0f)); plot.addDomainMarker(meanMarker, Layer.FOREGROUND); } if (!Double.isNaN(min0)) { minMarker = new ValueMarker(min0); minMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_STD_DEV); minMarker.setStroke(new BasicStroke(2.0f)); plot.addDomainMarker(minMarker, Layer.FOREGROUND); } if (!Double.isNaN(max0)) { maxMarker = new ValueMarker(max0); maxMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_STD_DEV); maxMarker.setStroke(new BasicStroke(2.0f)); plot.addDomainMarker(maxMarker, Layer.FOREGROUND); } domainAxisLabel += "(\u03BC-\u03C3 - mean - \u03BC+\u03C3)"; break; } this.buildHistogramAxisFormat(plot, domainAxisLabel); }
From source file:desmoj.extensions.visualization2d.engine.modelGrafic.StatisticGrafic.java
/** * Update of animation type StatisticGrafic.ANIMATION_TimeValueDiagram * @throws ModelException// w w w . j a va2 s.co m */ private void updateTimeValueDiagram() throws ModelException { Marker meanMarker, minMarker, maxMarker; double mean, min0, max0; XYPlot plot = this.chart.getXYPlot(); String rangeAxisLabel = ""; switch (this.statistic.getTypeIndex()) { case Statistic.INDEX_None: break; case Statistic.INDEX_Min_Max: plot.clearRangeMarkers(); min0 = statistic.getMin(); max0 = statistic.getMax(); if (!Double.isNaN(min0)) { minMarker = new ValueMarker(min0); minMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_MIN_MAX); minMarker.setStroke(new BasicStroke(2.0f)); plot.addRangeMarker(minMarker, Layer.BACKGROUND); } if (!Double.isNaN(max0)) { maxMarker = new ValueMarker(max0); maxMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_MIN_MAX); maxMarker.setStroke(new BasicStroke(2.0f)); plot.addRangeMarker(maxMarker, Layer.BACKGROUND); } rangeAxisLabel = "min - max"; break; case Statistic.INDEX_Mean_StdDev: plot.clearRangeMarkers(); if (statistic.hasValue()) { min0 = statistic.getMean() - statistic.getStdDev(); max0 = statistic.getMean() + statistic.getStdDev(); mean = statistic.getMean(); if (!Double.isNaN(mean)) { meanMarker = new ValueMarker(mean); meanMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_MEAN); meanMarker.setStroke(new BasicStroke(2.0f)); plot.addRangeMarker(meanMarker, Layer.BACKGROUND); } if (!Double.isNaN(min0)) { minMarker = new ValueMarker(min0); minMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_STD_DEV); minMarker.setStroke(new BasicStroke(2.0f)); plot.addRangeMarker(minMarker, Layer.BACKGROUND); } if (!Double.isNaN(max0)) { maxMarker = new ValueMarker(max0); maxMarker.setPaint(StatisticGrafic.DIAGRAM_MARKER_STD_DEV); maxMarker.setStroke(new BasicStroke(2.0f)); plot.addRangeMarker(maxMarker, Layer.BACKGROUND); } } rangeAxisLabel = "\u03BC-\u03C3 - mean - \u03BC+\u03C3"; break; } //this.buildTimeValueDiagramAxisFormat(plot, rangeAxisLabel); }
From source file:app.RunApp.java
/** * Set label IR/*w ww.j a v a 2s .c om*/ * * @param jtable Table * @param stat Statistics * @param cp CategoryPlot * @return Generated TableModel * @throws Exception */ private TableModel irLabelsetsTableModel(JTable jtable, Statistics stat, CategoryPlot cp) throws Exception { DefaultTableModel tableModel = new DefaultTableModel() { @Override public boolean isCellEditable(int row, int column) { //This causes all cells to be not editable return false; } }; DefaultCategoryDataset myData = new DefaultCategoryDataset(); tableModel.addColumn("Labelset id"); tableModel.addColumn("IR values"); //Labelsets frequency HashMap<LabelSet, Integer> labelsetsFrequency = stat.labelCombCount(); labelsetStringByIR = new ArrayList<>(labelsetsFrequency.size()); Set<LabelSet> keysets = labelsetsFrequency.keySet(); Object[] row = new Object[2]; int count = 1; double IR_labelset; int max = getMax(keysets, labelsetsFrequency); ArrayList<ImbalancedFeature> listImbalanced = new ArrayList(); ImbalancedFeature temp; int value; for (LabelSet current : keysets) { value = labelsetsFrequency.get(current); IR_labelset = max / (value * 1.0); String temp1 = MetricUtils.truncateValue(IR_labelset, 4); IR_labelset = Double.parseDouble(temp1); temp = new ImbalancedFeature(current.toString(), value, IR_labelset); listImbalanced.add(temp); } labelsetsIRSorted = new ImbalancedFeature[listImbalanced.size()]; labelsetsByIR = new double[listImbalanced.size()]; //stores IR per labelset String truncate; while (!listImbalanced.isEmpty()) { temp = Utils.getMin(listImbalanced); labelsetsIRSorted[count - 1] = temp; labelsetsByIR[count - 1] = temp.getIRIntraClass(); row[0] = count; truncate = Double.toString(temp.getIRIntraClass()); row[1] = MetricUtils.getValueFormatted(truncate, 3); tableModel.addRow(row); myData.setValue(temp.getIRIntraClass(), Integer.toString(count), ""); labelsetStringByIR.add(temp.getName()); count++; listImbalanced.remove(temp); } jtable.setModel(tableModel); jtable.setBounds(jtable.getBounds()); //Resize columns TableColumnModel tcm = jtable.getColumnModel(); tcm.getColumn(0).setPreferredWidth(50); tcm.getColumn(1).setPreferredWidth(50); //graph cp.setDataset(myData); //get mean double sum = 0; for (int i = 0; i < labelsetsIRSorted.length; i++) { sum += labelsetsIRSorted[i].getIRIntraClass(); } sum = sum / labelsetsIRSorted.length; Marker start = new ValueMarker(sum); start.setPaint(Color.blue); start.setLabelFont(new Font("SansSerif", Font.BOLD, 12)); start.setLabel(" Mean: " + MetricUtils.truncateValue(sum, 4)); cp.addRangeMarker(start); return jtable.getModel(); }
From source file:app.RunApp.java
/** * Set frequency of labelsets/* w w w .j a va 2s . c om*/ * * @param jtable Table * @param dataset Dataset * @param stat Statistics * @param cp Plot * @return Generated TableModel * @throws Exception */ private TableModel labelsetsFrequencyTableModel(JTable jtable, MultiLabelInstances dataset, Statistics stat, CategoryPlot cp) throws Exception { DefaultTableModel tableModel = new DefaultTableModel() { @Override public boolean isCellEditable(int row, int column) { //This causes all cells to be not editable return false; } }; DefaultCategoryDataset myData = new DefaultCategoryDataset(); tableModel.addColumn("Labelset Id"); tableModel.addColumn("# Examples"); tableModel.addColumn("Frequency"); double freq; //Labelsets frequency HashMap<LabelSet, Integer> result = stat.labelCombCount(); labelsetStringsByFreq = new ArrayList<>(result.size()); double sum = 0.0; Set<LabelSet> keysets = result.keySet(); Object[] row = new Object[3]; int count = 1; ArrayList<ImbalancedFeature> listImbalanced = new ArrayList(); ImbalancedFeature temp; int value; for (LabelSet current : keysets) { value = result.get(current); temp = new ImbalancedFeature(current.toString(), value); listImbalanced.add(temp); } labelsetsSorted = new ImbalancedFeature[listImbalanced.size()]; labelsetsFrequency = new double[listImbalanced.size()]; while (!listImbalanced.isEmpty()) { temp = Utils.getMax(listImbalanced); labelsetsSorted[count - 1] = temp; value = temp.getAppearances(); labelsetsFrequency[count - 1] = value; row[0] = count; freq = value * 1.0 / dataset.getNumInstances(); sum += freq; String valueFreq = Double.toString(freq); row[1] = value; row[2] = MetricUtils.getValueFormatted(valueFreq, 4); tableModel.addRow(row); String id = "ID: " + Integer.toString(count); myData.setValue(freq, id, ""); labelsetStringsByFreq.add(temp.getName()); count++; listImbalanced.remove(temp); } jtable.setModel(tableModel); jtable.setBounds(jtable.getBounds()); TableColumnModel tcm = jtable.getColumnModel(); tcm.getColumn(0).setPreferredWidth(50); tcm.getColumn(1).setPreferredWidth(50); tcm.getColumn(2).setPreferredWidth(60); //graph cp.setDataset(myData); sum = sum / keysets.size(); Marker start = new ValueMarker(sum); start.setLabelFont(new Font("SansSerif", Font.BOLD, 12)); start.setLabel(" Mean: " + MetricUtils.truncateValue(sum, 4)); start.setPaint(Color.red); cp.addRangeMarker(start); return jtable.getModel(); }
From source file:com.lp.server.fertigung.ejbfac.FertigungFacBean.java
@TransactionAttribute(TransactionAttributeType.NEVER) public KapazitaetsvorschauDto getKapazitaetsvorschau(TheClientDto theClientDto) throws EJBExceptionLP { KapazitaetsvorschauDto kapDto = null; Session session = null;//from w w w .j a v a2 s. c om try { // ------------------------------------------------------------------ // ----- // Benoetigte Parameter holen // ------------------------------------------------------------------ // ----- // Default Sicht nach Wochen // final int iSicht = FertigungFac.KAPAZITAETSVORSCHAU_NACH_WOCHEN; // Anzahl der angezeigten Vatergruppen. Alles andere wird nach // "Sonstige" verdichtet final ParametermandantDto parameterAnzahlGruppen = getParameterFac().getMandantparameter( theClientDto.getMandant(), ParameterFac.KATEGORIE_FERTIGUNG, ParameterFac.PARAMETER_FERTIGUNG_KAPAZITAETSVORSCHAU_ANZAHL_GRUPPEN); final int iParamAnzahlGruppen = (Integer) parameterAnzahlGruppen.getCWertAsObject(); // Angezeigter Zeitraum = Anzahl der Spalten final ParametermandantDto parameterZeitraum = getParameterFac().getMandantparameter( theClientDto.getMandant(), ParameterFac.KATEGORIE_FERTIGUNG, ParameterFac.PARAMETER_FERTIGUNG_KAPAZITAETSVORSCHAU_ZEITRAUM); final int iParamZeitraum = (Integer) parameterZeitraum.getCWertAsObject(); // ------------------------------------------------------------------ // ----- // Hibernate-Session erstellen // ------------------------------------------------------------------ // ----- SessionFactory factory = FLRSessionFactory.getFactory(); session = factory.openSession(); // ------------------------------------------------------------------ // ----- // Artikel- / Maschinen-Vatergruppen holen // ------------------------------------------------------------------ // ----- // Alle Artikel-Vatergruppen Criteria cArtikelVatergruppen = session.createCriteria(FLRArtikelgruppe.class); cArtikelVatergruppen.add(Restrictions.isNull(ArtikelFac.FLR_ARTIKELGRUPPE_FLRARTIKELGRUPPE)); List<?> listArtikelgruppen = cArtikelVatergruppen.list(); // Alle Maschinen-Vatergruppen Criteria cMaschinengruppen = session.createCriteria(FLRMaschinengruppe.class); List<?> listMaschinengruppen = cMaschinengruppen.list(); // ------------------------------------------------------------------ // ----- // Anzahl der sub-Diagramme bestimmen // das ist grundsaetzlich (iParamAnzahlGruppen + 1) x 2 ... // (Anzahl d. anzuzeigenden Vatergruppen + Sonstige) f. AZ und // Maschinen // wenn es weniger Vatergruppen als anzuzeigende gibt, reduziert // sich das aber // Gibt es keine Vatergruppe, wird daher alles nach "Sonstige" // verdichtet // ------------------------------------------------------------------ // ----- final int iAnzuzeigendeArtikelgruppen = Math.min(iParamAnzahlGruppen, listArtikelgruppen.size()); final int iAnzuzeigendeMaschinengruppen = Math.min(iParamAnzahlGruppen, listMaschinengruppen.size()); final int iAnzahlZeilen = iAnzuzeigendeArtikelgruppen + 1 + iAnzuzeigendeMaschinengruppen + 1; // ------------------------------------------------------------------ // ----- // Dto initialisieren // ------------------------------------------------------------------ // ----- kapDto = new KapazitaetsvorschauDto(iAnzahlZeilen, iParamZeitraum); // ------------------------------------------------------------------ // ----- // Beschriftung der x-Achse ermitteln. das sind die Kalenderwochen // ------------------------------------------------------------------ // ----- HashMap<Integer, Integer> hmKWIndizes = new HashMap<Integer, Integer>(); String[] kw = new String[iParamZeitraum]; GregorianCalendar gc = new GregorianCalendar(); for (int i = 0; i < kw.length; i++) { int iKw = gc.get(GregorianCalendar.WEEK_OF_YEAR); kw[i] = "" + iKw; kapDto.setISpaltenueberschrift(i, kw[i]); hmKWIndizes.put(gc.get(GregorianCalendar.WEEK_OF_YEAR), i); gc.setTimeInMillis(gc.getTimeInMillis() + 7 * 24 * 60 * 60 * 1000); // 1 Woche dazu } // ------------------------------------------------------------------ // ----- // Beschriftung der y-Achse ermitteln. das sind die Namen der // Vatergruppen bzw. 2 x "Sonstige". // Weiters werden die Indizes im Daten-Array fuer die jeweiligen // Gruppen festgelegt. // ------------------------------------------------------------------ // ----- String sSonstige = getTextRespectUISpr("lp.sonstige", theClientDto.getMandant(), theClientDto.getLocUi()); HashMap<Integer, Integer> hmArtikelGruppenIndizes = new HashMap<Integer, Integer>(); HashMap<Integer, Integer> hmMaschinenGruppenIndizes = new HashMap<Integer, Integer>(); // zuerst die Artikelvatergruppen for (int i = 0; i < iAnzuzeigendeArtikelgruppen; i++) { FLRArtikelgruppe item = (FLRArtikelgruppe) listArtikelgruppen.get(i); kapDto.setIZeilenueberschrift(i, item.getC_nr()); hmArtikelGruppenIndizes.put(item.getI_id(), i); } // Dann Sonstige Artikelgruppen final int indexSonstigeArtikelGruppen = iAnzuzeigendeArtikelgruppen; kapDto.setIZeilenueberschrift(indexSonstigeArtikelGruppen, sSonstige); // Maschinengruppen for (int i = 0; i < iAnzuzeigendeMaschinengruppen; i++) { FLRMaschinengruppe item = (FLRMaschinengruppe) listMaschinengruppen.get(i); int index = iAnzuzeigendeArtikelgruppen + 1 + i; kapDto.setIZeilenueberschrift(index, item.getC_bez()); hmMaschinenGruppenIndizes.put(item.getI_id(), index); } // zuletzt Sonstige Maschinengruppen final int indexSonstigeMaschinenGruppen = iAnzuzeigendeArtikelgruppen + 1 + iAnzuzeigendeMaschinengruppen; kapDto.setIZeilenueberschrift(indexSonstigeMaschinenGruppen, sSonstige); // ------------------------------------------------------------------ // ----- // Lose holen // ------------------------------------------------------------------ // ----- Criteria cLose = session.createCriteria(FLRLos.class); // Filter nach Mandant cLose.add(Restrictions.eq(FertigungFac.FLR_LOS_MANDANT_C_NR, theClientDto.getMandant())); // Alle Stati ausser Erledigt, Gestoppt, Storniert Collection<String> cLoseStati = new LinkedList<String>(); cLoseStati.add(FertigungFac.STATUS_ERLEDIGT); cLoseStati.add(FertigungFac.STATUS_GESTOPPT); cLoseStati.add(FertigungFac.STATUS_STORNIERT); cLose.add(Restrictions.not(Restrictions.in(FertigungFac.FLR_LOS_STATUS_C_NR, cLoseStati))); List<?> listLose = cLose.list(); // ------------------------------------------------------------------ // ----- // Auswertungszeitraum und verfuegbare Kapazitaeten ermitteln // ------------------------------------------------------------------ // ----- // 3 Monate in die zukunft Calendar c = Calendar.getInstance(); c.setTimeInMillis(System.currentTimeMillis()); c.set(Calendar.MONTH, c.get(Calendar.MONTH) + 3); java.util.Date dMax = Helper.cutDate(new java.sql.Date(c.getTimeInMillis())); java.sql.Timestamp tVon = Helper.cutTimestamp(new java.sql.Timestamp(System.currentTimeMillis())); java.sql.Timestamp tBis = Helper.cutTimestamp(new java.sql.Timestamp(dMax.getTime())); // Verfuegbare Zeiten holen SollverfuegbarkeitDto[] oVerfuegbar = getZeiterfassungFac().getVerfuegbareSollzeit(tVon, tBis, theClientDto); // diese nun aufteilen for (int i = 0; i < oVerfuegbar.length; i++) { SollverfuegbarkeitDto svDto = oVerfuegbar[i]; // "normale" AZ if (svDto.isBMannarbeitszeit()) { // die sind einer Artikelgruppe zugeordnet if (svDto.getIGruppeid() != null) { Integer iZeile = hmArtikelGruppenIndizes.get(svDto.getIGruppeid()); // ist das eine sichtbare Gruppe if (iZeile != null) { for (int iSpalte = 0; iSpalte < kapDto.getDetails()[iZeile].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(iZeile, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } // wenn nicht, dann zu den sonstigen else { for (int iSpalte = 0; iSpalte < kapDto .getDetails()[indexSonstigeArtikelGruppen].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(indexSonstigeArtikelGruppen, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } } // Rest = Sonstige Artikelgruppen else { if (svDto.getTDatum() != null) { // Die KW dieses Datums ermitteln, damit das // zugeordnet werden kann GregorianCalendar gcSV = new GregorianCalendar(); gcSV.setTime(svDto.getTDatum()); int kwSV = gcSV.get(Calendar.WEEK_OF_YEAR); Integer iIndexDerKW = hmKWIndizes.get(kwSV); if (iIndexDerKW != null) { // Hier nicht mit 5 multiplizieren, da es fuer // jeden Tag einen eigenen Eintrag gibt kapDto.addBdVerfuegbareStunden(indexSonstigeArtikelGruppen, iIndexDerKW, svDto.getNSollstunden()); } else { // diese KW wird nicht mehr angezeigt - brauch // ich nicht einrechnen } } } } // Maschinenzeit - die Verfuegbarkeit ist jeden Tag gleich else { Integer iZeile = hmMaschinenGruppenIndizes.get(svDto.getIGruppeid()); // ist das eine sichtbare Gruppe if (iZeile != null) { for (int iSpalte = 0; iSpalte < kapDto.getDetails()[iZeile].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(iZeile, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } // wenn nicht, dann zu den sonstigen else { for (int iSpalte = 0; iSpalte < kapDto .getDetails()[indexSonstigeMaschinenGruppen].length; iSpalte++) { // mal 5 Tage kapDto.addBdVerfuegbareStunden(indexSonstigeMaschinenGruppen, iSpalte, svDto.getNSollstunden().multiply(new BigDecimal(5))); } } } } // ------------------------------------------------------------------ // ----- // Offene Zeiten ermitteln // ------------------------------------------------------------------ // ----- for (Iterator<?> iter = listLose.iterator(); iter.hasNext();) { FLRLos los = (FLRLos) iter.next(); // Offene Menge ermitteln BigDecimal bdOffen = los.getN_losgroesse(); for (Iterator<?> iterAblieferung = los.getAblieferungset().iterator(); iterAblieferung.hasNext();) { FLRLosablieferung item = (FLRLosablieferung) iterAblieferung.next(); bdOffen = bdOffen.subtract(item.getN_menge()); } // nur Lose mit tatsaechlich offener Menge>0 if (bdOffen.compareTo(new BigDecimal(0)) > 0) { // Faktor zur Berechnung der offenen Zeiten = offene Menge / // Losgroesse. 2 Nachkommastellen sollten reichen. BigDecimal bdFaktor = bdOffen.divide(los.getN_losgroesse(), 2, BigDecimal.ROUND_HALF_EVEN); // Arbeitsplan holen Criteria cLosAZ = session.createCriteria(FLRLossollarbeitsplan.class); cLosAZ.add(Restrictions.eq(FertigungFac.FLR_LOSSOLLARBEITSPLAN_LOS_I_ID, los.getI_id())); List<?> listLosAZ = cLosAZ.list(); // fuer alle Taetigkeiten for (Iterator<?> iterAZ = listLosAZ.iterator(); iterAZ.hasNext();) { FLRLossollarbeitsplan losAZ = (FLRLossollarbeitsplan) iterAZ.next(); BigDecimal bdOffeneStunden = losAZ.getN_gesamtzeit().multiply(bdFaktor); // ------------------------------------------------------ // ----------------- // Index der Gruppe bestimmen, der ich das zuordnen muss // ------------------------------------------------------ // ----------------- int iZeilenIndex; // 1. nach Maschinengruppe // 2. nach Artikelgruppe der Taetigkeit FLRMaschine flrMaschine = losAZ.getFlrmaschine(); Integer iMaschinengruppeIId = null; Integer iArtikelgruppeIId = null; if (flrMaschine != null) { FLRMaschinengruppe flrMaschinengruppe = flrMaschine.getFlrmaschinengruppe(); if (flrMaschinengruppe != null) { // Wenn diese Maschinengruppe dargestellt wird, // dann kommt hier der index raus. Integer i = hmMaschinenGruppenIndizes.get(flrMaschinengruppe.getI_id()); iMaschinengruppeIId = flrMaschinengruppe.getI_id(); if (i != null) { iZeilenIndex = i; } // wenn nicht -> sonstige. else { iZeilenIndex = indexSonstigeMaschinenGruppen; } } // Maschinen ohne Maschinengruppe werden nach // "Sonstige" verdichtet. else { iZeilenIndex = indexSonstigeMaschinenGruppen; } } else { FLRArtikel flrArtikel = losAZ.getFlrartikel(); FLRArtikelgruppe flrArtikelgruppe = flrArtikel.getFlrartikelgruppe(); if (flrArtikelgruppe != null) { // Wenn diese Artikelgruppe dargestellt wird, // dann kommt hier der index raus. Integer i = hmArtikelGruppenIndizes.get(flrArtikelgruppe.getI_id()); iArtikelgruppeIId = flrArtikelgruppe.getI_id(); if (i != null) { iZeilenIndex = i; } // wenn nicht -> sonstige. else { iZeilenIndex = indexSonstigeArtikelGruppen; } } // Taetigkeiten ohne Artikelgruppe werden nach // "Sonstige" verdichtet. else { iZeilenIndex = indexSonstigeArtikelGruppen; } } // ------------------------------------------------------ // ----------------- // Jetzt hab ich die Gruppe, der ich das zuordnen muss // nun muss die Zeit aufgeteilt werden // ------------------------------------------------------ // ----------------- java.util.Date tLosStarttermin = los.getT_produktionsbeginn(); java.util.Date tLosEndetermin = los.getT_produktionsende(); // beide Termine duerfen nicht vor heute liegen if (tLosStarttermin.before(getDate())) { tLosStarttermin = getDate(); } if (tLosEndetermin.before(getDate())) { tLosEndetermin = getDate(); } // Anzahl der betroffenen Kalenderwochen bestimmen GregorianCalendar gcStart = new GregorianCalendar(); gcStart.setTime(tLosStarttermin); GregorianCalendar gcEnde = new GregorianCalendar(); gcEnde.setTime(tLosEndetermin); int iStartKW = gcStart.get(Calendar.WEEK_OF_YEAR); int iEndeKW = gcEnde.get(Calendar.WEEK_OF_YEAR); int iAnzahlKW = 1 + iEndeKW - iStartKW; // nun auf die Wochen aufteilen BigDecimal bdOffeneStundenJeWoche = bdOffeneStunden; if (iAnzahlKW > 0) { bdOffeneStundenJeWoche = bdOffeneStunden.divide(new BigDecimal(iAnzahlKW), 2, RoundingMode.HALF_UP); } for (int iAktuelleKW = iStartKW; iAktuelleKW <= iEndeKW; iAktuelleKW++) { Integer indexDerKW = hmKWIndizes.get(iAktuelleKW); // wird diese Woche auch angezeigt? if (indexDerKW != null) { KapazitaetsvorschauDetailDto detailDto = new KapazitaetsvorschauDetailDto(); detailDto.setArtikelgruppeIId(iArtikelgruppeIId); detailDto.setArtikelIIdTaetigkeit(losAZ.getFlrartikel().getI_id()); detailDto.setBdDauer(bdOffeneStundenJeWoche); detailDto.setLosIId(los.getI_id()); detailDto.setLossollarbeitsplanIId(losAZ.getI_id()); detailDto.setMaschinengruppeIId(iMaschinengruppeIId); kapDto.addDetail(iZeilenIndex, indexDerKW, detailDto); } } } } } // ------------------------------------------------------------------ // ----- // Diagramm aus den Daten erstellen // ------------------------------------------------------------------ // ----- SymbolAxis xAchse = new SymbolAxis("KW", kw); CombinedDomainXYPlot plot = new CombinedDomainXYPlot(xAchse); for (int iZeile = 0; iZeile < kapDto.getDetails().length; iZeile++) { XYSeries datenZeile = new XYSeries(kapDto.getIZeilenueberschrift(iZeile)); // Balkenfarben festlegen ( >100% = rot, sonst hellgrau) // fuer jede zeile und jede spalte Paint[][] paints = new Paint[1][kapDto.getDetails()[iZeile].length]; for (int iSpalte = 0; iSpalte < kapDto.getDetails()[iZeile].length; iSpalte++) { BigDecimal bdVerfuegbar = kapDto.getBdVerfuegbareStunden()[iZeile][iSpalte]; BigDecimal bdBenoetigt = new BigDecimal(0); // Benoetigte Zeit jet Gruppe je Woche ermitteln for (Iterator<?> iter = kapDto.getDetails()[iZeile][iSpalte].iterator(); iter.hasNext();) { KapazitaetsvorschauDetailDto item = (KapazitaetsvorschauDetailDto) iter.next(); bdBenoetigt = bdBenoetigt.add(item.getBdDauer()); } BigDecimal value = new BigDecimal(0); if (bdVerfuegbar.compareTo(new BigDecimal(0)) > 0) { value = (bdBenoetigt.multiply(new BigDecimal(100))).divide(bdVerfuegbar, 4, BigDecimal.ROUND_HALF_EVEN); if (value.doubleValue() > 100.0) { paints[0][iSpalte] = Color.red; } else { paints[0][iSpalte] = Color.lightGray; } } // tage ohne Verfuegbarkeit mach ich 100% und weisz else { value = new BigDecimal(100.0); // Wochen ohne Kapazitaet aber mit geplanter Zeit if (bdBenoetigt.compareTo(new BigDecimal(0)) > 0) { paints[0][iSpalte] = Color.MAGENTA; } // Wenn nichts verfuegbar aber auch nichts benoetigt -> // weiss else { paints[0][iSpalte] = Color.white; } } XYDataItem data = new XYDataItem(iSpalte, value.doubleValue()); datenZeile.add(data); } // Zur Collection XYSeriesCollection xyDataset = new XYSeriesCollection(); xyDataset.addSeries(datenZeile); // subplot erstellen XYItemRenderer renderer1 = new CustomXYBarRenderer(paints); // renderer1.setItemLabelsVisible(true); // Legende nicht anzeigen renderer1.setBaseSeriesVisibleInLegend(false); NumberAxis zeilenAchse = new NumberAxis(kapDto.getIZeilenueberschrift(iZeile)); // Beschriftung der Y-Achse um 90 grad drehen zeilenAchse.setLabelAngle(Math.PI / 2.0); zeilenAchse.setAutoRange(true); XYPlot subplot1 = new XYPlot(xyDataset, null, zeilenAchse, renderer1); subplot1.setRangeAxisLocation(AxisLocation.BOTTOM_OR_LEFT); // Markierung bei 100% final Marker target = new ValueMarker(100.0); target.setPaint(Color.darkGray); // target.setLabel("100 %"); // Label // target.setLabelAnchor(RectangleAnchor.TOP_RIGHT); // target.setLabelTextAnchor(TextAnchor.BOTTOM_RIGHT); subplot1.addRangeMarker(target); plot.add(subplot1); // plot.add(subplot1, 1); } JFreeChart lStackedBarChart = new JFreeChart(plot); kapDto.setJfcKapazitaetsvorschau(lStackedBarChart); } catch (RemoteException ex) { throwEJBExceptionLPRespectOld(ex); } finally { if (session != null) { session.close(); } } return kapDto; }
From source file:org.jfree.chart.ChartFactory.java
/** * Creates a waterfall chart. The chart object returned by this method * uses a {@link CategoryPlot} instance as the plot, with a * {@link CategoryAxis} for the domain axis, a {@link NumberAxis} as the * range axis, and a {@link WaterfallBarRenderer} as the renderer. * * @param title the chart title ({@code null} permitted). * @param categoryAxisLabel the label for the category axis * ({@code null} permitted). * @param valueAxisLabel the label for the value axis ({@code null} * permitted)./*from w ww. j a va2 s . c o m*/ * @param dataset the dataset for the chart ({@code null} permitted). * * @return A waterfall chart. */ public static JFreeChart createWaterfallChart(String title, String categoryAxisLabel, String valueAxisLabel, CategoryDataset dataset) { CategoryAxis categoryAxis = new CategoryAxis(categoryAxisLabel); categoryAxis.setCategoryMargin(0.0); ValueAxis valueAxis = new NumberAxis(valueAxisLabel); WaterfallBarRenderer renderer = new WaterfallBarRenderer(); // FIXME create a new method for the horizontal version // if (orientation == PlotOrientation.HORIZONTAL) { // ItemLabelPosition position = new ItemLabelPosition( // ItemLabelAnchor.CENTER, TextAnchor.CENTER, // TextAnchor.CENTER, Math.PI / 2.0); // renderer.setBasePositiveItemLabelPosition(position); // renderer.setBaseNegativeItemLabelPosition(position); // } ItemLabelPosition position = new ItemLabelPosition(ItemLabelAnchor.CENTER, TextAnchor.CENTER, TextAnchor.CENTER, 0.0); renderer.setDefaultPositiveItemLabelPosition(position); renderer.setDefaultNegativeItemLabelPosition(position); StandardCategoryToolTipGenerator generator = new StandardCategoryToolTipGenerator(); renderer.setDefaultToolTipGenerator(generator); CategoryPlot plot = new CategoryPlot(dataset, categoryAxis, valueAxis, renderer); plot.clearRangeMarkers(); Marker baseline = new ValueMarker(0.0); baseline.setPaint(Color.BLACK); plot.addRangeMarker(baseline, Layer.FOREGROUND); JFreeChart chart = new JFreeChart(title, plot); currentTheme.apply(chart); return chart; }