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 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; }
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)); }
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; }
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; }
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; }
/* * 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); } }
/* * 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(); }