Charts: भरा लाइन चार्ट

drawLinearFill पर एक नज़र डालें जहां यह भरण रेक्ट खींचता है। यह generateFilledPath और getFillLinePosition भीतर भरण रेक्ट की गणना करता है। आदर्श रूप से आपको लाइनों के बीच अपना रेक्ट पाने के लिए उन तरीकों को ओवरराइड करना चाहिए, आप जाने के लिए अच्छे हैं

मैंने LineChartRenderer को उप-वर्गीकृत करके @ liuxuan30 के सुझावों का पालन करके और IFillFormatter लागू करने वाले वर्ग में एक चर जोड़कर इसे प्राप्त करने में कामयाबी हासिल की, जो मुझे फिल लाइन के लिए संकेतक के रूप में दूसरा डेटा सेट पास करने देता है और तदनुसार पथ बनाएं (केवल रैखिक के लिए, लेकिन मुझे लगता है कि आप बेजियर के लिए भी ऐसा ही कर सकते हैं)।

class AreaFillFormatter: IFillFormatter {

    var fillLineDataSet: LineChartDataSet?

    init(fillLineDataSet: LineChartDataSet) {
        self.fillLineDataSet = fillLineDataSet
    }

    public func getFillLinePosition(dataSet: ILineChartDataSet, dataProvider: LineChartDataProvider) -> CGFloat {
        return 0.0
    }

    public func getFillLineDataSet() -> LineChartDataSet {
        return fillLineDataSet ?? LineChartDataSet()
    }

}

class CustomLineChartRenderer: LineChartRenderer {

    override open func drawLinearFill(context: CGContext, dataSet: ILineChartDataSet, trans: Transformer, bounds: XBounds) {
        guard let dataProvider = dataProvider else { return }

        let areaFillFormatter = dataSet.fillFormatter as? AreaFillFormatter

        let filled = generateFilledPath(
            dataSet: dataSet,
            fillMin: dataSet.fillFormatter?.getFillLinePosition(dataSet: dataSet, dataProvider: dataProvider) ?? 0.0,
            fillLineDataSet: areaFillFormatter?.getFillLineDataSet(),
            bounds: bounds,
            matrix: trans.valueToPixelMatrix)

        if dataSet.fill != nil
        {
            drawFilledPath(context: context, path: filled, fill: dataSet.fill!, fillAlpha: dataSet.fillAlpha)
        }
        else
        {
            drawFilledPath(context: context, path: filled, fillColor: dataSet.fillColor, fillAlpha: dataSet.fillAlpha)
        }
    }

    fileprivate func generateFilledPath(dataSet: ILineChartDataSet, fillMin: CGFloat, fillLineDataSet: ILineChartDataSet?, bounds: XBounds, matrix: CGAffineTransform) -> CGPath
    {
        let phaseY = animator?.phaseY ?? 1.0
        let isDrawSteppedEnabled = dataSet.mode == .stepped
        let matrix = matrix

        var e: ChartDataEntry!
        var fillLineE: ChartDataEntry?

        let filled = CGMutablePath()

        e = dataSet.entryForIndex(bounds.min)
        fillLineE = fillLineDataSet?.entryForIndex(bounds.min)

        if e != nil
        {
            if let fillLineE = fillLineE
            {
                filled.move(to: CGPoint(x: CGFloat(e.x), y: CGFloat(fillLineE.y * phaseY)), transform: matrix)
            }
            else
            {
                filled.move(to: CGPoint(x: CGFloat(e.x), y: fillMin), transform: matrix)
            }

            filled.addLine(to: CGPoint(x: CGFloat(e.x), y: CGFloat(e.y * phaseY)), transform: matrix)
        }

        // Create the path for the data set entries
        for x in stride(from: (bounds.min + 1), through: bounds.range + bounds.min, by: 1)
        {
            guard let e = dataSet.entryForIndex(x) else { continue }

            if isDrawSteppedEnabled
            {
                guard let ePrev = dataSet.entryForIndex(x-1) else { continue }
                filled.addLine(to: CGPoint(x: CGFloat(e.x), y: CGFloat(ePrev.y * phaseY)), transform: matrix)
            }

            filled.addLine(to: CGPoint(x: CGFloat(e.x), y: CGFloat(e.y * phaseY)), transform: matrix)
        }

        // Draw a path to the start of the fill line
        e = dataSet.entryForIndex(bounds.range + bounds.min)
        fillLineE = fillLineDataSet?.entryForIndex(bounds.range + bounds.min)
        if e != nil
        {
            if let fillLineE = fillLineE
            {
                filled.addLine(to: CGPoint(x: CGFloat(e.x), y: CGFloat(fillLineE.y * phaseY)), transform: matrix)
            }
            else
            {
                filled.addLine(to: CGPoint(x: CGFloat(e.x), y: fillMin), transform: matrix)
            }
        }

        // Draw the path for the fill line (backwards)
        if let fillLineDataSet = fillLineDataSet {
            for x in stride(from: (bounds.min + 1), through: bounds.range + bounds.min, by: 1).reversed()
            {
                guard let e = fillLineDataSet.entryForIndex(x) else { continue }

                if isDrawSteppedEnabled
                {
                    guard let ePrev = fillLineDataSet.entryForIndex(x-1) else { continue }
                    filled.addLine(to: CGPoint(x: CGFloat(e.x), y: CGFloat(ePrev.y * phaseY)), transform: matrix)
                }

                filled.addLine(to: CGPoint(x: CGFloat(e.x), y: CGFloat(e.y * phaseY)), transform: matrix)
            }
        }

        filled.closeSubpath()

        return filled
    }
}

परियोजना में महारत हासिल करने के लिए आदर्श उदाहरण :)

इस समाधान को कैसे हल/उपयोग करें?

@ रोब-के क्या आप इसके लिए उपयोग उदाहरण प्रदान कर सकते हैं

निश्चित रूप से, मैं कोड का उपयोग निम्नानुसार करता हूं:

let maxDataSet = LineChartDataSet()
let minDataSet = LineChartDataSet()

// ... fill the data sets

// Set the data
self.lineChart.data = LineChartData(dataSets: [maxDataSet, minDataSet])

// Set the custom line chart renderer
self.lineChart.renderer = CustomLineChartRenderer(dataProvider: self.lineChart, animator: self.lineChart.chartAnimator, viewPortHandler: self.lineChart.viewPortHandler)

maxDataSet.drawFilledEnabled = true
maxDataSet.fillFormatter = AreaFillFormatter(fillLineDataSet: minDataSet)

मैंने इसे मैन्युअल रूप से स्थापित किया और उदाहरण के अनुसार प्रत्येक चरण का पालन किया, फिर भी ऐसा लगता है कि यह काम नहीं कर रहा है @ रोब-के

@ रोब-के मैंने CustomLineChartRenderer से किसी भी फ़ंक्शन को ब्रेक पॉइंट का उपयोग करके डीबग करने का प्रयास नहीं किया जा रहा है

मैंने LineChartRenderer को शामिल करने के लिए अपनी टिप्पणी अपडेट की।

अभी भी कोई भाग्य नहीं है यार @ रोब-के

यदि आप ucbDataSet और lcbDataSet बीच का रंग चाहते हैं तो आपको दूसरे डेटा सेट को पहले वाले के फ़ॉर्मेटर में पास करना होगा। आप डेटासेट को स्वयं के फ़ॉर्मेटर में पास कर रहे हैं। निम्न कार्य करने का प्रयास करें:

ucbDataSet.fillFormatter = AreaFillFormatter(fillLineDataSet: lcbDataSet)

(या फिर इसके विपरीत)

मैं जो समझाने की कोशिश कर रहा हूं वह पहले ही कोशिश कर चुका है
मैंने CustomLineChartRenderer क्लास से किसी भी फ़ंक्शन को ब्रेक पॉइंट का उपयोग करके डीबग करने का प्रयास नहीं किया, जिसे कॉल नहीं किया जा रहा है

मैं देख रहा हूं कि आप अपने कोड में बेजियर मोड का उपयोग कर रहे हैं:

lineChartDataSet.mode = .horizontalBezier
ucbDataSet.mode = .horizontalBezier
lcbDataSet.mode = .horizontalBezier

मैंने जो कोड प्रदान किया है वह केवल रैखिक मोड के लिए काम करता है। आपको मोड को .linear बदलना होगा या drawHorizontalBezier ओवरराइड करना होगा और तदनुसार कोड को समायोजित करना होगा।

@ रोब-के ने इसे अभी-अभी काम किया है धन्यवाद इसे खोजने के लिए बहुत बहुत आदमी

क्या संयुक्त चार्ट का उपयोग करके इसे कार्यान्वित करना संभव होगा?

क्या संयुक्त चार्ट का उपयोग करके इसे कार्यान्वित करना संभव होगा?

क्या आपको समाधान मिला? संयुक्त चार्ट संयुक्त चार्टरेंडर का उपयोग करता है, न कि LinearChartRender का, इसलिए कॉल बैक को drawLinearFill नहीं कहा जाता है, यह डिफ़ॉल्ट रेंडर का उपयोग करता है

विधि drawLinearFill मौजूद नहीं है, जब आप लाइब्रेरी में खोज करते हैं तो इसमें कई नए रेंडर लगते हैं

क्या संयुक्त चार्ट का उपयोग करके इसे कार्यान्वित करना संभव होगा?

समाधान संयुक्त चार्ट: https://github.com/PhilJay/MPAndroidChart/issues/338