/*! \brief Convenience function. * */ void TrackSpiralArcSpiral::setEndHeadingDeg(double endHeadingDeg) { pa_->headingEnd_ = endHeadingDeg * 2.0 * M_PI / 360.0; pa_->init(); applyParameters(); }
/*! \brief Convenience function. * */ void TrackSpiralArcSpiral::setLocalStartHeading(double startHeading) { while (startHeading <= -180.0) { startHeading += 360.0; } while (startHeading > 180.0) { startHeading -= 360.0; } // Local to internal (Parameters are given in internal coordinates) // // double deltaHeading(startHeading - heading()); QTransform trafo; trafo.rotate(deltaHeading); pa_->setEndHeadingDeg(pa_->getEndHeadingRad() * 360.0 / (2.0 * M_PI) - deltaHeading); pa_->setEndPoint(trafo.inverted().map(pa_->getEndPoint())); pa_->init(); applyParameters(); // Set local translation // // setLocalRotation(startHeading); }
void AndroidCameraPrivate::setFocusAreas(const QList<QRect> &areas) { if (QtAndroidPrivate::androidSdkVersion() < 14) return; QMutexLocker parametersLocker(&m_parametersMutex); if (!m_parameters.isValid()) return; QJNIObjectPrivate list; if (!areas.isEmpty()) { QJNIEnvironmentPrivate env; QJNIObjectPrivate arrayList("java/util/ArrayList", "(I)V", areas.size()); for (int i = 0; i < areas.size(); ++i) { arrayList.callMethod<jboolean>("add", "(Ljava/lang/Object;)Z", rectToArea(areas.at(i)).object()); exceptionCheckAndClear(env); } list = arrayList; } m_parameters.callMethod<void>("setFocusAreas", "(Ljava/util/List;)V", list.object()); applyParameters(); }
void AndroidCameraPrivate::updateRotation() { QMutexLocker parametersLocker(&m_parametersMutex); m_parameters.callMethod<void>("setRotation", "(I)V", m_rotation); applyParameters(); }
/*! \brief Convenience function. * */ void TrackSpiralArcSpiral::setEndPoint(const QPointF &endPoint) { pa_->pEnd_ = endPoint; pa_->init(); applyParameters(); }
void MooseObjectAction::addRelationshipManagers(Moose::RelationshipManagerType /*when_type*/) { const auto & buildable_types = _moose_object_pars.getBuildableRelationshipManagerTypes(); for (const auto & buildable_type : buildable_types) { /** * This method is always called twice. Once to attempt adding early RMs and once to add late * RMs. For generic MooseObjects, we'd like to add RMs as early as possible, but we'll have to * be careful not to add them twice! */ auto new_name = name() + '_' + buildable_type.first + "_rm"; if (_app.hasRelationshipManager(new_name)) continue; auto rm_params = _factory.getValidParams(buildable_type.first); rm_params.applyParameters(_moose_object_pars); rm_params.set<MooseMesh *>("mesh") = _mesh.get(); rm_params.set<Moose::RelationshipManagerType>("rm_type") = buildable_type.second; if (rm_params.areAllRequiredParamsValid()) { auto rm_obj = _factory.create<RelationshipManager>(buildable_type.first, new_name, rm_params); // Delete the resources created on behalf of the RM if it ends up not being added to the App. if (!_app.addRelationshipManager(rm_obj)) _factory.releaseSharedObjects(*rm_obj); } } }
void CreateProblemDefaultAction::act() { if (_current_task == "determine_system_type") { // Determine whether the Executioner is derived from EigenExecutionerBase and // set a flag on MooseApp that can be used during problem construction. bool use_nonlinear = true; bool use_eigenvalue = false; auto p = _awh.getActionByTask<CreateExecutionerAction>("setup_executioner"); if (p) { auto & exparams = p->getObjectParams(); use_nonlinear = !(exparams.isParamValid("_eigen") && exparams.get<bool>("_eigen")); use_eigenvalue = (exparams.isParamValid("_use_eigen_value") && exparams.get<bool>("_use_eigen_value")); } _app.useNonlinear() = use_nonlinear; _app.useEigenvalue() = use_eigenvalue; return; } // act only if we have mesh if (_mesh.get() != NULL) { // Make sure the problem hasn't already been created elsewhere if (!_problem) { std::string type; if (_app.useEigenvalue()) type = "EigenProblem"; else type = "FEProblem"; auto params = _factory.getValidParams(type); // apply common parameters of the object held by CreateProblemAction to honor user inputs in // [Problem] auto p = _awh.getActionByTask<CreateProblemAction>("create_problem"); if (p) params.applyParameters(p->getObjectParams()); params.set<MooseMesh *>("mesh") = _mesh.get(); params.set<bool>("use_nonlinear") = _app.useNonlinear(); if (_pars.isParamSetByUser("_solve")) params.set<bool>("solve") = getParam<bool>("_solve"); _problem = _factory.create<FEProblemBase>(type, "MOOSE Problem", params); } else { // otherwise perform necessary sanity checks if (_app.useEigenvalue() && !(std::dynamic_pointer_cast<EigenProblem>(_problem))) mooseError("Problem has to be of a EigenProblem (or derived subclass) type when using " "eigen executioner"); } } }
void AndroidCameraPrivate::setJpegQuality(int quality) { QMutexLocker parametersLocker(&m_parametersMutex); if (!m_parameters.isValid()) return; m_parameters.callMethod<void>("setJpegQuality", "(I)V", quality); applyParameters(); }
void AndroidCameraPrivate::setZoom(int value) { QMutexLocker parametersLocker(&m_parametersMutex); if (!m_parameters.isValid()) return; m_parameters.callMethod<void>("setZoom", "(I)V", value); applyParameters(); }
void AndroidCameraPrivate::setPreviewFormat(AndroidCamera::ImageFormat fmt) { QMutexLocker parametersLocker(&m_parametersMutex); if (!m_parameters.isValid()) return; m_parameters.callMethod<void>("setPreviewFormat", "(I)V", jint(fmt)); applyParameters(); }
/*! \brief Convenience function. * */ void TrackSpiralArcSpiral::setLocalEndPoint(const QPointF &endPoint) { // Local to internal (Parameters are given in internal coordinates) // // // setEndPoint(getLocalTransform().inverted().map(endPoint)); pa_->pEnd_ = getLocalTransform().inverted().map(endPoint); pa_->init(); applyParameters(); }
void AndroidCameraPrivate::setPictureSize(const QSize &size) { QMutexLocker parametersLocker(&m_parametersMutex); if (!m_parameters.isValid()) return; m_parameters.callMethod<void>("setPictureSize", "(II)V", size.width(), size.height()); applyParameters(); }
/*! \brief Convenience function. * */ void TrackSpiralArcSpiral::setLocalPointAndHeading(const QPointF &point, double hdg, bool isStart) { while (hdg <= -180.0) { hdg += 360.0; } while (hdg > 180.0) { hdg -= 360.0; } if (isStart) { // Local to internal (Parameters are given in internal coordinates) // // QPointF deltaPos(getLocalTransform().inverted().map(point) /* - getPoint(getSStart())*/); // getPoint(s_) == 0 by definition double deltaHeading(hdg - heading()); QTransform trafo; trafo.rotate(deltaHeading); pa_->setEndHeadingDeg(pa_->getEndHeadingRad() * 360.0 / (2.0 * M_PI) - deltaHeading); pa_->setEndPoint(trafo.inverted().map(pa_->pEnd_ - deltaPos)); pa_->init(); applyParameters(); // Set local transform // // setLocalTransform(point, hdg); } else { // Local to internal (Parameters are given in internal coordinates) // // pa_->pEnd_ = getLocalTransform().inverted().map(point); pa_->headingEnd_ = (hdg - getLocalHeading(getSStart())) * 2.0 * M_PI / 360.0; pa_->init(); applyParameters(); } }
void AndroidCameraPrivate::updatePreviewSize() { QMutexLocker parametersLocker(&m_parametersMutex); if (m_previewSize.isValid()) { m_parameters.callMethod<void>("setPreviewSize", "(II)V", m_previewSize.width(), m_previewSize.height()); applyParameters(); } emit previewSizeChanged(); }
void AndroidCameraPrivate::setFocusMode(const QString &value) { QMutexLocker parametersLocker(&m_parametersMutex); if (!m_parameters.isValid()) return; m_parameters.callMethod<void>("setFocusMode", "(Ljava/lang/String;)V", QJNIObjectPrivate::fromString(value).object()); applyParameters(); }
void AndroidCameraPrivate::setAutoWhiteBalanceLock(bool toggle) { if (QtAndroidPrivate::androidSdkVersion() < 14) return; QMutexLocker parametersLocker(&m_parametersMutex); if (!m_parameters.isValid()) return; m_parameters.callMethod<void>("setAutoWhiteBalanceLock", "(Z)V", toggle); applyParameters(); }
/*! \brief Convenience function. * */ void TrackSpiralArcSpiral::setLocalStartPoint(const QPointF &startPoint) { // Local to internal (Parameters are given in internal coordinates) // // QPointF deltaPos(getLocalTransform().inverted().map(startPoint) /* - getPoint(getSStart())*/); // getPoint(s_) == 0 by definition //setEndPoint(pa_->pEnd_ - deltaPos); pa_->pEnd_ = pa_->pEnd_ - deltaPos; pa_->init(); applyParameters(); // Set local translation // // setLocalTranslation(startPoint); }
void demo_CurveDetector::execute() { cv::namedWindow(m_originalWindow, CV_WINDOW_NORMAL); cv::namedWindow(m_openCVWindow, CV_WINDOW_NORMAL); cv::namedWindow(m_openVXWindow, CV_WINDOW_NORMAL); cv::namedWindow(m_diffWindow, CV_WINDOW_NORMAL); const std::string imgPath = "..\\Image\\test_curves.png"; m_srcImage = cv::imread(imgPath, CV_LOAD_IMAGE_GRAYSCALE); cv::imshow(m_originalWindow, m_srcImage); applyParameters(this); cv::waitKey(0); }
uint32_t ParameterList::applyTokens(uint32_t argc, const char** argv, const char* prefix, const char* defaultPath) const { uint32_t found = 0; for (uint32_t a = 0; a < argc; a++) { if (applyParameters(argc, argv, a, prefix, defaultPath)) { found++; } else { LOGI(" unhandled argument: %s\n", argv[a]) } } return found; }
bool VampPlugin::initialise(size_t channels, size_t stepSize, size_t blockSize) { delete m_system; m_channels = channels; m_step_size = stepSize; m_block_size = blockSize; { ScriptTranslator translator(get_marsystem_manager()); m_system = translator.translateFile(m_script_filename); } if (!m_system) return 0; cout << "Input format = " << channels << " / " << blockSize << " / " << stepSize << " @ " << m_input_sample_rate << endl; m_system->updControl("mrs_real/israte", (mrs_real) m_input_sample_rate); m_system->updControl("mrs_natural/inObservations", (mrs_natural) channels); m_system->updControl("mrs_natural/inSamples", (mrs_natural) blockSize); applyParameters(m_system); mrs_natural m_out_observations = m_system->getControl("mrs_natural/onObservations")->to<mrs_natural>(); mrs_natural m_out_samples = m_system->getControl("mrs_natural/onSamples")->to<mrs_natural>(); cout << "Output format = " << m_out_observations << " / " << m_out_samples << " @ " << m_system->getControl("mrs_real/osrate")->to<mrs_real>() << endl; m_input.create(m_channels, m_block_size); m_output.create(m_out_observations, m_out_samples); return true; }
/*! \brief Sets the unsymmetric arc insertion factor. * */ void TrackSpiralArcSpiral::setFactor(double factor) { if (factor < 0.001) factor = 0.001; if (factor > 0.999) factor = 0.999; SpArcSParameters *tmp = pa_; pa_ = new SpArcSParameters(outSpiral_->getLocalPoint(outSpiral_->getSEnd()), outSpiral_->getLocalHeadingRad(outSpiral_->getSEnd()), factor); if (!pa_->isValid()) // does also initialize the parameters { pa_ = tmp; pa_->isValid(); // check again qDebug() << "WARNING 1005170517! Factor for TrackSpiralArcSpiral is not valid!"; } else { delete tmp; applyParameters(); } }
struct RenderResults RenderWorker::renderSync(EGS_BaseGeometry *g, struct RenderParameters p) { struct RenderResults r; r.img = QImage(); r.elapsedTime = -1; r.timePerPixel = -1; // wall-clock time, not CPU time; to optimize response QTime time_i1 = QTime::currentTime(); applyParameters(vis, p); // create image buffer if new size is far enough away from previous size // it overallocates slightly (~16%) if `buffer` is not used. int new_bufsize = p.nx * p.ny; if (new_bufsize > last_bufsize || last_bufsize > 3*new_bufsize) { if (image) { delete[] image; } if (buffer) { delete[] buffer; } image = new EGS_Vector[new_bufsize]; buffer = new QRgb[new_bufsize]; last_bufsize = new_bufsize; } // modifies image and sets axeslabels if (p.draw_axes) { drawAxes(p); } // render tracks if (p.draw_tracks) { vis->setParticleVisibility(1,p.show_photons); vis->setParticleVisibility(2,p.show_electrons); vis->setParticleVisibility(3,p.show_positrons); vis->setParticleVisibility(4,p.show_other); if (!vis->renderTracks(g,p.nx,p.ny,image,&abort_location)) { // Undo track drawing and rezero image memset(image, 0, sizeof(EGS_Vector)); return r; } } // render main geometry QTime time_r1 = QTime::currentTime(); if (!vis->renderImage(g,p.nx,p.ny,image,&abort_location)) { return r; } QTime time_r2 = QTime::currentTime(); // RGB32 saves 1+ image traversals over other formats w/ Qt4.7-8 & X11 QImage img(p.nx*p.nxr, p.ny*p.nyr, QImage::Format_RGB32); if (p.nxr == 1 && p.nyr == 1) { // special case, straight to image for (int j=0; j<p.ny; j++) { QRgb *sl = (QRgb *) img.scanLine(j); for (int i=0; i<p.nx; i++) { EGS_Vector v = image[i+(p.ny-j-1)*p.nx]; quint8 r = (quint8)(v.x*255), g = (quint8)(v.y*255), b = (quint8)(v.z*255); sl[i] = qRgb(r,g,b); } } } else { // Copy image into buffer for (int j=0; j<p.ny; j++) { // flip the image vertically in this phase (it shouldn't matter where) int topd = (p.ny-j-1)*p.nx; int botu = j*p.nx; for (int i=0; i<p.nx; i++) { EGS_Vector v = image[i+topd]; quint8 r = (quint8)(v.x*255), g = (quint8)(v.y*255), b = (quint8)(v.z*255); buffer[botu+i] = qRgb(r,g,b); } } // Fast image scaling routine. int line_len = sizeof(QRgb)*p.nx*p.nxr; for (int j=0; j<p.ny; j++) { int start_row = j*p.nyr; QRgb *base = (QRgb *) img.scanLine(start_row); QRgb *al = buffer + j*p.nx; // Create a single image line for (int i=0,ib=0,mx=p.nxr; i<p.nx; i++,mx+=p.nxr) { QRgb v = al[i]; for (; ib<mx; ib++) { base[ib] = v; } } // Duplicate that line (p.nyr-1) times for (int i=1; i<p.nyr; i++) { memcpy(img.scanLine(start_row+i),base,line_len); } } } // Since we already have the image at full scale, draw the axes labels on it. { QPainter q(&img); if (p.draw_axeslabels) { q.setPen(QColor(255,255,255)); q.drawText((int)(p.nxr*axeslabelsX.x-3),p.nyr*p.ny-(int)(p.nyr*axeslabelsX.y-3),"x"); q.drawText((int)(p.nxr*axeslabelsY.x-3),p.nyr*p.ny-(int)(p.nyr*axeslabelsY.y-3),"y"); q.drawText((int)(p.nxr*axeslabelsZ.x-3),p.nyr*p.ny-(int)(p.nyr*axeslabelsZ.y-3),"z"); } } QTime time_i2 = QTime::currentTime(); r.img = img; r.elapsedTime = time_i1.msecsTo(time_i2); r.timePerPixel = ((EGS_Float)time_r1.msecsTo(time_r2)) / (p.nx * p.ny); return r; }