The 3D Realtime Android Point-Cloud example shows how to update an XyzDataSeries3D in real-time to render a ScatterRenderableSeries3D.

Read more in SciChart 3D Android Tutorials and Documentation:

• Android Realtime Data Plotting in 3D;
• Android Scatter 3D Chart Type.

// Kotlin: RealTimePointCloud3DChartFragment.kt

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2021. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// RealTimePointCloud3DChartFragment.kt is part of SCICHART®, High Performance Scientific Charts
// For full terms and conditions of the license, see http://www.scichart.com/scichart-eula/
//
// This source code is protected by international copyright law. Unauthorized
// reproduction, reverse-engineering, or distribution of all or any portion of
// this source code is strictly prohibited.
//
// This source code contains confidential and proprietary trade secrets of
// SciChart Ltd., and should at no time be copied, transferred, sold,
// distributed or made available without express written permission.
//******************************************************************************

package com.scichart.examples.fragments.examples3d.realtime3DCharts.kt

import com.scichart.charting3d.visuals.SciChartSurface3D
import com.scichart.core.model.DoubleValues
import com.scichart.data.model.DoubleRange
import com.scichart.examples.data.DataManager
import com.scichart.examples.fragments.base.ExampleSingleChart3DBaseFragment
import com.scichart.examples.utils.scichartExtensions.*
import java.util.*
import java.util.concurrent.Executors
import java.util.concurrent.ScheduledFuture
import java.util.concurrent.TimeUnit

class RealTimePointCloud3DChartFragment : ExampleSingleChart3DBaseFragment() {
    private val dataSeries = XyzDataSeries3D<Double, Double, Double>()

    private val xData = DoubleValues()
    private val yData = DoubleValues()
    private val zData = DoubleValues()

    private val scheduledExecutorService = Executors.newSingleThreadScheduledExecutor()
    private lateinit var schedule: ScheduledFuture<*>

    override fun initExample(surface3d: SciChartSurface3D) {
        val dataManager = DataManager.getInstance()
        for (i in 0 until 1000) {
            xData.add(dataManager.getGaussianRandomNumber(5.0, 1.5))
            yData.add(dataManager.getGaussianRandomNumber(5.0, 1.5))
            zData.add(dataManager.getGaussianRandomNumber(5.0, 1.5))
        }
        dataSeries.append(xData, yData, zData)

        surface3d.suspendUpdates {
            xAxis = numericAxis3D { growBy = DoubleRange(0.1, 0.1) }
            yAxis = numericAxis3D { growBy = DoubleRange(0.1, 0.1) }
            zAxis = numericAxis3D { growBy = DoubleRange(0.1, 0.1) }

            renderableSeries {
                scatterRenderableSeries3D {
                    dataSeries = this@RealTimePointCloud3DChartFragment.dataSeries
                    ellipsePointMarker3D { fill = 0x77ADFF2F; size = 3f }
                }
            }

            chartModifiers { defaultModifiers3D() }
        }

        schedule = scheduledExecutorService.scheduleWithFixedDelay(scheduledRunnable, 0, 10, TimeUnit.MILLISECONDS)
    }

    override fun onDestroyView() {
        super.onDestroyView()
        schedule.cancel(true)
    }

    private val scheduledRunnable: Runnable = object : Runnable {
        private val random = Random()

        override fun run() {
            binding.surface3d.suspendUpdates {
                val xItems: DoubleArray = xData.itemsArray
                val yItems: DoubleArray = yData.itemsArray
                val zItems: DoubleArray = zData.itemsArray

                for (i in 0 until dataSeries.count) {
                    xItems[i] += random.nextDouble() - 0.5
                    yItems[i] += random.nextDouble() - 0.5
                    zItems[i] += random.nextDouble() - 0.5
                }

                dataSeries.updateRangeXyzAt(0, xData, yData, zData)
            }
        }
    }
}

// Java: RealTimePointCloud3DChartFragment.java

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2021. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// CreateRealTimePointCloud3DChartFragment.java is part of SCICHART®, High Performance Scientific Charts
// For full terms and conditions of the license, see http://www.scichart.com/scichart-eula/
//
// This source code is protected by international copyright law. Unauthorized
// reproduction, reverse-engineering, or distribution of all or any portion of
// this source code is strictly prohibited.
//
// This source code contains confidential and proprietary trade secrets of
// SciChart Ltd., and should at no time be copied, transferred, sold,
// distributed or made available without express written permission.
//******************************************************************************

package com.scichart.examples.fragments.examples3d.realtime3DCharts;

import androidx.annotation.NonNull;

import com.scichart.charting3d.model.dataSeries.xyz.XyzDataSeries3D;
import com.scichart.charting3d.visuals.SciChartSurface3D;
import com.scichart.charting3d.visuals.axes.NumericAxis3D;
import com.scichart.charting3d.visuals.pointMarkers.EllipsePointMarker3D;
import com.scichart.charting3d.visuals.renderableSeries.scatter.ScatterRenderableSeries3D;
import com.scichart.core.framework.UpdateSuspender;
import com.scichart.core.model.DoubleValues;
import com.scichart.examples.data.DataManager;
import com.scichart.examples.fragments.base.ExampleSingleChart3DBaseFragment;

import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;

public class RealTimePointCloud3DChartFragment extends ExampleSingleChart3DBaseFragment {
    private final XyzDataSeries3D<Double, Double, Double> dataSeries = new XyzDataSeries3D<>(Double.class, Double.class, Double.class);

    private final DoubleValues xData = new DoubleValues();
    private final DoubleValues yData = new DoubleValues();
    private final DoubleValues zData = new DoubleValues();

    private final ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
    private ScheduledFuture<?> schedule;

    @Override
    protected void initExample(@NonNull SciChartSurface3D surface3d) {
        final NumericAxis3D xAxis = sciChart3DBuilder.newNumericAxis3D().withGrowBy(.1, .1).build();
        final NumericAxis3D yAxis = sciChart3DBuilder.newNumericAxis3D().withGrowBy(.1, .1).build();
        final NumericAxis3D zAxis = sciChart3DBuilder.newNumericAxis3D().withGrowBy(.1, .1).build();

        final EllipsePointMarker3D pointMarker3D = sciChart3DBuilder.newEllipsePointMarker3D()
                .withFill(0x77ADFF2F)
                .withSize(3f)
                .build();

        final ScatterRenderableSeries3D scatterRenderableSeries3D = sciChart3DBuilder.newScatterSeries3D()
                .withDataSeries(dataSeries)
                .withPointMarker(pointMarker3D)
                .build();

        final DataManager dataManager = DataManager.getInstance();
        for (int i = 0; i < 1000; i++) {
            xData.add(dataManager.getGaussianRandomNumber(5, 1.5));
            yData.add(dataManager.getGaussianRandomNumber(5, 1.5));
            zData.add(dataManager.getGaussianRandomNumber(5, 1.5));
        }

        dataSeries.append(xData, yData, zData);

        UpdateSuspender.using(surface3d, () -> {
            surface3d.setXAxis(xAxis);
            surface3d.setYAxis(yAxis);
            surface3d.setZAxis(zAxis);
            surface3d.getRenderableSeries().add(scatterRenderableSeries3D);
            surface3d.getChartModifiers().add(sciChart3DBuilder.newModifierGroupWithDefaultModifiers().build());
        });

        schedule = scheduledExecutorService.scheduleWithFixedDelay(() -> UpdateSuspender.using(surface3d, scheduledRunnable), 0, 10, TimeUnit.MILLISECONDS);
    }

    private final Runnable scheduledRunnable = new Runnable() {
        private final Random random = new Random();

        @Override
        public void run() {
            final double[] xItems = xData.getItemsArray();
            final double[] yItems = yData.getItemsArray();
            final double[] zItems = zData.getItemsArray();

            for (int i = 0, size = dataSeries.getCount(); i < size; i++) {
                xItems[i] += random.nextDouble() - 0.5;
                yItems[i] += random.nextDouble() - 0.5;
                zItems[i] += random.nextDouble() - 0.5;
            }

            dataSeries.updateRangeXyzAt(0, xData, yData, zData);
        }
    };

    @Override
    public void onDestroyView() {
        super.onDestroyView();

        if (schedule != null) {
            schedule.cancel(true);
        }
    }
}

< BACK TO ALL ANDROID CHART CHART EXAMPLES