Exemple #1
0
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));
}
Exemple #2
0
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();
}
Exemple #5
0
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 imageCallback(const sensor_msgs::ImageConstPtr& msg)
  {
    cv_bridge::CvImagePtr cv_img_ptr;
    msg->header;

    try
    {
      cv_img_ptr = cv_bridge::toCvCopy(msg, "mono8");
    }
    catch (cv_bridge::Exception& e)
    {
      ROS_ERROR_STREAM("Could not convert ROS image to CV: "<< e.what());
      return;
    }

    static int id = 0;
    int n = reader_.parse(cv_img_ptr);
    ROS_DEBUG_STREAM("Got image, has "<<n<<" barcodes");
    std::vector<barcode::Barcode> barcodes = reader_.getBarcodes();
    for (uint i = 0; i < reader_.getBarcodes().size(); i++)
    {
      ROS_DEBUG_STREAM("Barcode: " << barcodes[i].data //
          << " x:"<<barcodes[i].x//
          << " y:"<<barcodes[i].y);
      vis_.publish(barcodes[i].x, barcodes[i].y, barcodes[i].z, msg->header.frame_id, id++ % 1000);
    }
    if (msg->header.frame_id == "")
    {
      ROS_ERROR_THROTTLE(1, "Received image with empty frame_id, would cause tf connectivity issues.");
    }
    object_pub_.publish(barcodes, msg);
  }
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;
}
Exemple #15
0
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;
}
Exemple #17
0
    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));
        }
    }
Exemple #18
0
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));
 }
Exemple #22
0
ReconstructionAlgorithm* Framework::instantiateReconstructionAlgorithm()
{
    getParameterSet()->get<OutputParameterSet>()->testValidityOfOutputOptions(getVolumeSerializer());

    auto algorithm = getParameterSet()->get<AlgorithmParameterSet>()->getAlgorithm();
    std::transform(algorithm.begin(), algorithm.end(), algorithm.begin(), tolower);

    ReconstructionAlgorithm* reconstructionAlgorithm = nullptr;
    if(algorithm == "sart" || algorithm == "sirt" || algorithm == "blockiterative")
    {
        reconstructionAlgorithm = new BlockIterativeReconstructionOperator(this);
    } else {
        reconstructionAlgorithm = pluginManager->instantiateReconstructionAlgorithm(algorithm, this);
    }

    auto isDiscrete = getParameterSet()->get<AlgorithmParameterSet>()->isReconstructionDiscrete();
    if( isDiscrete )
    {
        ReconstructionAlgorithmUsingMask *maskedReconstructionAlgorithm = dynamic_cast<ReconstructionAlgorithmUsingMask *>(reconstructionAlgorithm);
        if( !maskedReconstructionAlgorithm )
        {
            throw Exception((boost::format("Discrete reconstruction cannot be done using %1% algorithm, because it does NOT support prior knowledge mask.") % algorithm).str());
        }
        auto discreteReconstructionAlgorithm = new DiscreteReconstructionAlgorithm(this, maskedReconstructionAlgorithm);
        discreteReconstructionAlgorithm->takeOwnershipOfMethod();
        reconstructionAlgorithm = discreteReconstructionAlgorithm;
    }

    auto meshExportPath = getParameterSet()->get<DebugParameterSet>()->getMeshExportPath();
    if(meshExportPath)
    {
        Visualizer* visualizer = new Visualizer(meshExportPath->string(), "ettention");
        reconstructionAlgorithm->exportGeometryTo(visualizer);
        visualizer->writeMesh();
        delete visualizer;
    }

    return reconstructionAlgorithm;
}
Exemple #23
0
int main(int argc, char *argv[]) {

        GPIO gpio;
        gpio.Init();
        RGBMatrix matrix(&gpio);
        Visualizer *visualizer = new Visualizer(&matrix);
        int command[]={2,0,0,0,0,0,0}; //Array with length 7 to get Information from the Webfile

        socketConnection();
        socketfunction(command); //Wait for the first command
        while(true) {

                Visualizer *visualizer = new Visualizer(&matrix);
                visualizer->setCommand(command);
                visualizer->Start(); // Start doing things.
                socketfunction(command); //change animation as needed
                visualizer->Stop();
        }

        getchar();
        close(sockfd);
        delete visualizer;

}
Exemple #24
0
int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
	LPSTR lpCmdLine, int nCmdShow)
{
	SpotifyPlayer *sp;
	HANDLE hSpotifyEvent;
	audio_fifo_t audioFifo;
	Visualizer *pVisualizer;

	// Setup an event to use for notification
	hSpotifyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (hSpotifyEvent == NULL) {
        return 0;
    }

	// Connect to spotify
	sp = new SpotifyPlayer(&audioFifo, hSpotifyEvent);

	// Create visualizer
	pVisualizer = new HistogramVisualizer();
	pVisualizer->SetSpotifyPlayer(sp);

	// Create window and run messageloop
	Candify app(sp, pVisualizer, hSpotifyEvent);

	if (FAILED(app.Initialize())) {
		MessageBox(NULL, "Application failed to initialize.", "Candify", MB_ICONEXCLAMATION);
		return 0;
	}

	// Initialize sound
	audio_init(&audioFifo, app.GetHWND());

	app.RunMessageLoop();

    return 0;
}
Exemple #25
0
/*
 * World state callback. Creates a marker for each detection.
 */
void worldStateCallback(const wire_msgs::WorldState::ConstPtr& msg) {


	// Iterate over world state objects
	for (vector<wire_msgs::ObjectState>::const_iterator it = msg->objects.begin(); it != msg->objects.end(); ++it) {

		// Get current object
		const wire_msgs::ObjectState& obj = *it;

		// Create marker
		visualization_msgs::MarkerArray markers_msg;
		world_state_visualizer_.createMarkers(msg->header, obj.ID, obj.properties, markers_msg.markers, marker_frame_);

		// Publish marker
		world_state_marker_pub_.publish(markers_msg);

	}
}
Exemple #26
0
/*
 * World evidence callback. Creates a marker for each of the world model objects
 */
void worldEvidenceCallback(const wire_msgs::WorldEvidence::ConstPtr& msg) {

	// ID for marker administration
	long ID = 0;

	// Iterate over all elements of evidence
	for (vector<wire_msgs::ObjectEvidence>::const_iterator it = msg->object_evidence.begin(); it != msg->object_evidence.end(); ++it) {

		// Get current evidence
		const wire_msgs::ObjectEvidence& obj_ev = *it;

		// Create marker
		visualization_msgs::MarkerArray markers_msg;
		world_evidence_visualizer_.createMarkers(msg->header, ID++, obj_ev.properties, markers_msg.markers, marker_frame_);

		// Publish marker
		world_evidence_marker_pub_.publish(markers_msg);

	}
}
static void lsthread(void *param)
{
    Visualizer* vis = static_cast<Visualizer*>(param);
    vis->LEDStripUpdateThread();
}
static void ckbthread(void *param)
{
    Visualizer* vis = static_cast<Visualizer*>(param);
    vis->CorsairKeyboardUpdateThread();
}
static void rkbthread(void *param)
{
	Visualizer* vis = static_cast<Visualizer*>(param);
	vis->RazerChromaUpdateThread();
}
//Thread starting static function
static void thread(void *param)
{
	Visualizer* vis = static_cast<Visualizer*>(param);
	vis->VisThread();
}