/*! \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;
}
