void Visualizer::BodyFollower::generateControls(
        const Visualizer&             viz,
        const State&                  state,
        Array_< DecorativeGeometry >& geometry)
{
    // Offset.
    Vec3 offset(m_offset);
    if (m_offset.isNaN()) {
        // Default: offset is based on system up direction and ground height.
        offset = Vec3(1, 1, 1);
        offset[viz.getSystemUpDirection().getAxis()] += viz.getGroundHeight();
    }

    // Up direction. Default: use System up direction.
    const UnitVec3& upDirection = m_upDirection.isNaN() ?
        UnitVec3(viz.getSystemUpDirection()) : m_upDirection;

    const Vec3 P = m_mobodB.findStationLocationInGround(state, m_stationPinB);
    // Position of camera (C) from ground origin (G), expressed in ground.
    const Vec3 p_GC = P + offset;
    // Rotation of camera frame (C) in ground frame (G).
    // To get the camera to point at P, we require the camera's z direction
    // (which points "back") to be parallel to the offset. We also want the
    // camera's y direction (which points to the top of the screen) to be as
    // closely aligned with the provided up direction as is possible.
    const Rotation R_GC(UnitVec3(offset), ZAxis, upDirection, YAxis);
    viz.setCameraTransform(Transform(R_GC, p_GC));
}

void TrialVisualizer()
{
    Double_t width = 20;
    Double_t xlow = 0;
    Double_t xhi = 50;
    Double_t x1=10;

    for (Int_t i=0; i<n; i++)
    {
        TH1F *h = new TH1F(TString::Format("h%i",i),"",50,0,50);
        Fill(h);
        TLine *ll = new TLine(x1, 0, x1, 20);
        ll->SetLineColor(3);
        ll->SetLineWidth(3);
        vlo.push_back(ll);

        TLine *lh = new TLine(x1+width, 0, x1+width, 20);
        lh->SetLineColor(3);
        lh->SetLineWidth(3);
        vhi.push_back(lh);
    }


    Visualizer vis;
    vis.SetNRows(1);
    vis.SetNColumns(4);
    vis.Draw("h%i");
    vis.DrawLines(vlo,"canvas=h color=3");
    vis.DrawLines(vhi,"canvas=h color=2");
}

static jint
android_media_setPeriodicCapture(JNIEnv *env, jobject thiz, jint rate, jboolean jWaveform, jboolean jFft)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return VISUALIZER_ERROR_NO_INIT;
    }
    visualizerJniStorage* lpJniStorage = (visualizerJniStorage *)env->GetLongField(thiz,
            fields.fidJniData);
    if (lpJniStorage == NULL) {
        return VISUALIZER_ERROR_NO_INIT;
    }

    ALOGV("setPeriodicCapture: rate %d, jWaveform %d jFft %d",
            rate,
            jWaveform,
            jFft);

    uint32_t flags = Visualizer::CAPTURE_CALL_JAVA;
    if (jWaveform) flags |= Visualizer::CAPTURE_WAVEFORM;
    if (jFft) flags |= Visualizer::CAPTURE_FFT;
    Visualizer::capture_cbk_t cbk = captureCallback;
    if (!jWaveform && !jFft) cbk = NULL;

    return translateError(lpVisualizer->setCaptureCallBack(cbk,
                                                &lpJniStorage->mCallbackData,
                                                flags,
                                                rate));
}

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Visualizer w;
    w.show();
    
    return a.exec();
}

int main()
{
    FileReader* pointCloudReader = new FileReader("Jiangtailgong.pcd");
    Visualizer* visualizer = new Visualizer(pointCloudReader->getPointCloud());
    visualizer->visualize();

    return 0;
}

static jint
android_media_visualizer_native_setMeasurementMode(JNIEnv *env, jobject thiz, jint mode)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return VISUALIZER_ERROR_NO_INIT;
    }
    return translateError(lpVisualizer->setMeasurementMode(mode));
}

static jint
android_media_visualizer_native_getCaptureSize(JNIEnv *env, jobject thiz)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return -1;
    }
    return lpVisualizer->getCaptureSize();
}

static jint
android_media_visualizer_native_getMeasurementMode(JNIEnv *env, jobject thiz)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return MEASUREMENT_MODE_NONE;
    }
    return lpVisualizer->getMeasurementMode();
}

static jint
android_media_visualizer_native_getSamplingRate(JNIEnv *env, jobject thiz)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return -1;
    }
    return (jint) lpVisualizer->getSamplingRate();
}

static jboolean
android_media_visualizer_native_getEnabled(JNIEnv *env, jobject thiz)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return false;
    }

    return (jboolean)lpVisualizer->getEnabled();
}

static jboolean
android_media_visualizer_native_getEnabled(JNIEnv *env, jobject thiz)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return JNI_FALSE;
    }

    if (lpVisualizer->getEnabled()) {
        return JNI_TRUE;
    } else {
        return JNI_FALSE;
    }
}

void CounterexampleAnalyzer::writeDotGraphToDisk(string filename, Visualizer& visualizer) {
  cout << "generating dot IO graph file for an abstract STG:"<<filename<<endl;
  string dotFile="digraph G {\n";
  dotFile+=visualizer.abstractTransitionGraphToDot();
  dotFile+="}\n";
  write_file(filename, dotFile);
}

static jint
android_media_visualizer_native_getWaveForm(JNIEnv *env, jobject thiz, jbyteArray jWaveform)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return VISUALIZER_ERROR_NO_INIT;
    }

    jbyte* nWaveform = (jbyte *) env->GetPrimitiveArrayCritical(jWaveform, NULL);
    if (nWaveform == NULL) {
        return VISUALIZER_ERROR_NO_MEMORY;
    }
    jint status = translateError(lpVisualizer->getWaveForm((uint8_t *)nWaveform));

    env->ReleasePrimitiveArrayCritical(jWaveform, nWaveform, 0);
    return status;
}

AudioProcessorEditor* DisplayNode::createEditor()
{

    Visualizer* visualizer = new Visualizer(this, viewport, dataViewport);

    GenericProcessor* source = (GenericProcessor*) getSourceNode();


    visualizer->setBuffers(source->getContinuousBuffer(),source->getEventBuffer());
    visualizer->setUIComponent(getUIComponent());
    visualizer->setConfiguration(config);

    setEditor(visualizer);

    std::cout << "Creating visualizer." << std::endl;
    return visualizer;

}

static jint
android_media_visualizer_native_getPeakRms(JNIEnv *env, jobject thiz, jobject jPeakRmsObj)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return VISUALIZER_ERROR_NO_INIT;
    }
    int32_t measurements[2];
    jint status = translateError(
                lpVisualizer->getIntMeasurements(MEASUREMENT_MODE_PEAK_RMS,
                        2, measurements));
    if (status == VISUALIZER_SUCCESS) {
        // measurement worked, write the values to the java object
        env->SetIntField(jPeakRmsObj, fields.fidPeak, measurements[MEASUREMENT_IDX_PEAK]);
        env->SetIntField(jPeakRmsObj, fields.fidRms, measurements[MEASUREMENT_IDX_RMS]);
    }
    return status;
}

    void addDuplexDecorations(MobilizedBodyIndex bodyNum, Real r, Real halfHeight, Real slop, int nAtoms,
                              Real atomRadius, Visualizer& display) const
    {
        display.addDecoration(bodyNum, Transform(), 
            DecorativeCylinder(r+atomRadius+slop, halfHeight).setColor(Cyan).setOpacity(0.4));

        const Real pitch = 2*Pi/halfHeight;
        const Real trans = (2*halfHeight)/(nAtoms-1);
        const Real rot = pitch*trans;
        for (int i=0; i<nAtoms; ++i) {
            const Real h = halfHeight - i*trans;
            const Real th = i*rot;
            const Vec3 p1(-r*cos(th),h,r*sin(th)), p2(r*cos(th),h,-r*sin(th));
            display.addDecoration(bodyNum, Transform(Vec3(p1)), 
                DecorativeSphere(atomRadius).setColor(Red).setResolution(0.5));
            display.addDecoration(bodyNum, Transform(Vec3(p2)), 
                DecorativeSphere(atomRadius).setColor(Green).setResolution(0.5));
        }
    }

int main()
{
  constexpr int nSamples = 512;
  SimpleSphere sphere("Visualizer Sphere", 15., 20., 0., 2 * PI / 3., PI / 4., PI / 6.);
  AOS3D<Precision> points(nSamples);

  for (int i = 0; i < nSamples; ++i) {
    Vector3D<Precision> sample;
    do {
      sample = volumeUtilities::SamplePoint(Vector3D<Precision>(20, 20, 20));
    } while (!sphere.Contains(sample));
    points.set(i, sample);
  }
  points.resize(nSamples);
  Visualizer visualizer;
  visualizer.AddVolume(sphere);
  visualizer.AddPoints(points);
  visualizer.Show();
  return 0;
}

// ----------------------------------------------------------------------------
static void android_media_visualizer_native_finalize(JNIEnv *env,  jobject thiz) {
    ALOGV("android_media_visualizer_native_finalize jobject: %p\n", thiz);

    // delete the Visualizer object
    Visualizer* lpVisualizer = (Visualizer *)env->GetLongField(
        thiz, fields.fidNativeVisualizer);
    if (lpVisualizer) {
        lpVisualizer->cancelCaptureCallBack();
        ALOGV("deleting Visualizer: %p\n", lpVisualizer);
        delete lpVisualizer;
    }

    // delete the JNI data
    visualizerJniStorage* lpJniStorage = (visualizerJniStorage *)env->GetLongField(
        thiz, fields.fidJniData);
    if (lpJniStorage) {
        ALOGV("deleting pJniStorage: %p\n", lpJniStorage);
        delete lpJniStorage;
    }
}

static jint
android_media_visualizer_native_setEnabled(JNIEnv *env, jobject thiz, jboolean enabled)
{
    Visualizer* lpVisualizer = getVisualizer(env, thiz);
    if (lpVisualizer == NULL) {
        return VISUALIZER_ERROR_NO_INIT;
    }

    jint retVal = translateError(lpVisualizer->setEnabled(enabled));

    if (!enabled) {
        visualizerJniStorage* lpJniStorage = (visualizerJniStorage *)env->GetLongField(
            thiz, fields.fidJniData);

        if (NULL != lpJniStorage)
            lpJniStorage->mCallbackData.cleanupBuffers();
    }

    return retVal;
}

 void generateControls(const Visualizer&             viz,
                       const State&                  state,
                       Array_< DecorativeGeometry >& geometry) override
 {
     const Vec3 Bo = m_body.getBodyOriginLocation(state);
     //const Vec3 p_GC = Bo + Vec3(0,4,2);
     //const Rotation R1(-SimTK::Pi/3, XAxis);
     const Vec3 p_GC = Bo + Vec3(-1.,4.,0.5);
     const Rotation R1(-1.6, XAxis);
     const Rotation R2(SimTK::Pi, ZAxis);
     viz.setCameraTransform(Transform(R1*R2, p_GC));
 }