コード例 #1
0
ファイル: kbplot.cpp プロジェクト: d-theus/kbplot
KbPlot::KbPlot(GLWidget *_container, double _xmin, double _xmax, double _ymin, double _ymax){

	xtick = ytick = 0;
	xgtick = ygtick = 0;
	isGridEnabled = false;

	datasetCounter = 0;


	const double framePos = 1.0 - KbPlot::c_frameThickness;
	
	framePoints.push_back(Txy(-1.0, 1.0));
	framePoints.push_back(Txy(-1.0, -1.0));
	framePoints.push_back(Txy(1.0, -1.0));
	framePoints.push_back(Txy(1.0, 1.0));
	framePoints.push_back(Txy(-1.0, 1.0));

	frame = new Polyline(&framePoints);
	frame->style.lineColor = 0x444444FF;
	frame->style.lineThickness = 15.0;
	frame->toggleFixed();


	this->container = _container;
	if(container != NULL){

		axisRebuild();

		this->xtick = (xmax - xmin)/20.0;
		this->ytick = (ymax - ymin)/20.0;
		container->subscribeToMouse(this);
		setRanges(_xmin, _xmax, _ymin, _ymax);
	}
}
コード例 #2
0
ファイル: Camera.cpp プロジェクト: Tuqz/Helion
Camera::Camera(float zNear, float zFar, float frustumScale) : worldToCamera(), cameraToClip(0.0f), orientation(), position() {
	setRanges(zNear, zFar);
	setFrustumScale(frustumScale);
	cameraToClip[2][3] = -1;
	dirChanged = true;
	posChanged = true;
}
コード例 #3
0
ファイル: Particle.cpp プロジェクト: maxluzius/BA
void particle::genParticles(glm::vec3 particleV)
{

    particleCenterM.setTo(cv::Scalar(0));
    //Bereich der Partikelstreuung
    setRanges(particleV.x, particleV.y, particleV.z, 0.5);

    CvMat LB, UB;
    cvInitMatHeader(&LB, 3, 1, CV_32FC1, minRange);
    cvInitMatHeader(&UB, 3, 1, CV_32FC1, maxRange);

      CvConDensation* condens = cvCreateConDensation(dim, dim, nParticles);

      cvConDensInitSampleSet(condens, &LB, &UB);

      //Einheitsmatrix
      condens->DynamMatr[0] = 1.0;
      condens->DynamMatr[1] = 0.0;
      condens->DynamMatr[2] = 0.0;

      condens->DynamMatr[3] = 0.0;
      condens->DynamMatr[4] = 1.0;
      condens->DynamMatr[5] = 0.0;

      condens->DynamMatr[6] = 0.0;
      condens->DynamMatr[7] = 0.0;
      condens->DynamMatr[8] = 1.0;

      cameraV.clear();
      newCameraV.clear();

      for (int i = 0; i < condens->SamplesNum; i++) {

         //Berechnung der Abweichung
//         float diffX = (particleV.x - condens->flSamples[i][0])/xRange;
//         float diffY = (particleV.y - condens->flSamples[i][1])/yRange;
//         float diffZ = (particleV.z - condens->flSamples[i][2])/zRange;
//         condens->flConfidence[i] = 1.0 / (sqrt(diffX * diffX + diffY * diffY + diffZ * diffZ));

         // Partikelstreuung werde ich benötigen
         //cv::Point3f partPt(condens->flSamples[i][0], condens->flSamples[i][1], condens->flSamples[i][2]);
         glm::vec3 partCenter(condens->flSamples[i][0], condens->flSamples[i][1], condens->flSamples[i][2]);

         particleCenterM(i,0) = partCenter.x;
         particleCenterM(i,1) = partCenter.y;
         particleCenterM(i,2) = partCenter.z;
         genParticles(lookAtCamera, partCenter, i);
         //cout << "PartikelPos: X-Achse: " << condens->flSamples[i][0] << "/" << lastCam(0) << " Y-Achse: " << condens->flSamples[i][1] << "/" << lastCam(1)<< " Z-Achse: " << condens->flSamples[i][2] << "/" << lastCam(2)<< endl;
         //writeFile(condens->flSamples[i][0], condens->flSamples[i][1], condens->flSamples[i][2], "particlePos.txt");

       }

       //cvConDensUpdateByTime(condens);

       //Bester Partikel, ist aber keine der Partikelpositionen
       //cv::Point3f statePt(condens->State[0], condens->State[1], condens->State[2]);
       //newCameraV.push_back(statePt);
       //cout << "NeuePose: X-Achse: " << condens->State[0] << "/" << lastCam(0) << " Y-Achse: " << condens->State[1] << "/" << lastCam(1)<< " Z-Achse: " << condens->State[2] << "/" << lastCam(2)<< endl;
}
コード例 #4
0
meegoaccelerometer::meegoaccelerometer(QSensor *sensor)
    : meegosensorbase(sensor)
{
    initSensor<AccelerometerSensorChannelInterface>(m_initDone);
    setDescription(QLatin1String("x, y, and z axes accelerations in m/s^2"));
    setRanges(GRAVITY_EARTH_THOUSANDTH);
    setReading<QAccelerometerReading>(&m_reading);
}
コード例 #5
0
meegomagnetometer::meegomagnetometer(QSensor *sensor)
    : meegosensorbase(sensor)
{
    initSensor<MagnetometerSensorChannelInterface>(m_initDone);
    setDescription(QLatin1String("magnetic flux density in teslas (T)"));
    setRanges(NANO);
    setReading<QMagnetometerReading>(&m_reading);
}
コード例 #6
0
ファイル: kbplot.cpp プロジェクト: d-theus/kbplot
void KbPlot::mouseScrollEvent(int a){
	double xrange = xmax - xmin;
	double yrange = ymax - ymin;
	double xscale = xrange*10e-5 * (double)a;
	double yscale = yrange*10e-5 * (double)a;
	setRanges(xmin-xscale, xmax+xscale, ymin-yscale, ymax+yscale);
	Txy t = myglPlaneWH();
	qDebug() << "plane wh: " << t.x << "; " << t.y;
}
コード例 #7
0
TEST_F(getFunctionStatementsTest, should_store_statments_source_code)
{
    parse("void f(int) {\n f(1 + 3); int a =\n 9; }");
    setRanges({ { stmtNo(0), {15, 24} }, { stmtNo(1), {25, 36} } });

    auto stmts = getFunctionStatements();
    EXPECT_EQ("f(1 + 3);", stmts[0]->getSourceCode());
    ASSERT_EQ("int a =\n 9;", stmts[1]->getSourceCode());
}
コード例 #8
0
ファイル: RfSensor.cpp プロジェクト: AFIT-Hodson/OpenEaagles
//------------------------------------------------------------------------------
//  setSlotRanges() -- Our list of valid ranges (nm)
//------------------------------------------------------------------------------
bool RfSensor::setSlotRanges(Basic::List* const list)
{
    bool ok = false;
    if (list != 0) {
        LCreal rngs[100];
        int n = list->getNumberList(rngs,100);
        ok = setRanges(rngs, n);
    }
    return ok;
}
コード例 #9
0
TEST_F(getFunctionStatementsTest, should_store_source_code_between_statements)
{
    parse("void f() {\n f();/* text */f();  /* whitespace */  f( );// not stored\n }");
    setRanges({ { stmtNo(0), {12, 16} }, { stmtNo(1), {26, 30} }, { stmtNo(2), {50, 55} } });

    auto stmts = getFunctionStatements();
    EXPECT_EQ("/* text */", stmts[0]->getSourceCodeAfter());
    EXPECT_EQ("  /* whitespace */  ", stmts[1]->getSourceCodeAfter());
    EXPECT_EQ("", stmts[2]->getSourceCodeAfter());
}
コード例 #10
0
//------------------------------------------------------------------------------
//  setSlotRanges() -- Our list of valid ranges (nm)
//------------------------------------------------------------------------------
bool RfSensor::setSlotRanges(base::List* const list)
{
    bool ok = false;
    if (list != nullptr) {
        double rngs[100];
        int n = list->getNumberList(rngs,100);
        ok = setRanges(rngs, n);
    }
    return ok;
}
コード例 #11
0
meegogyroscope::meegogyroscope(QSensor *sensor)
    : meegosensorbase(sensor)
{
    initSensor<GyroscopeSensorChannelInterface>(m_initDone);
    setDescription(QLatin1String("angular velocities around x, y, and z axis in degrees per second"));
    setRanges(MILLI);
    setReading<QGyroscopeReading>(&m_reading);
    addDataRate(10, 10);
    addDataRate(50, 50);
}
コード例 #12
0
SensorfwMagnetometer::SensorfwMagnetometer(QSensor *sensor)
    : SensorfwSensorBase(sensor)
    , m_initDone(false)
{
    init();
    setDescription(QLatin1String("magnetic flux density in teslas (T)"));
    setRanges(NANO);
    setReading<QMagnetometerReading>(&m_reading);
    sensor->setDataRate(50);//set a default rate
}
コード例 #13
0
ファイル: ArmSideView.cpp プロジェクト: albarral/amy
void ArmSideView::configDraw(std::string name, int w, int h)
{
    // create an image of the specified size
    // able to represent the arm in 3 directions (up, down and right)
    // with isotropic scaling (same scale in all directions)
    setIsotropic(true);
    initPlot(w, h, name);   
    // only positive x ranges
    setRanges(0, maxLen, -maxLen, maxLen);
}
コード例 #14
0
TEST_F(getFunctionStatementsTest, should_return_the_ranges_of_each_statements)
{
    parse("void f() {\n int x = 1; if (x == 1)\n; }");
    ast::SourceOffsetRange range0{1, 2}, range1{3, 4};
    setRanges({{ stmtNo(0), range0 }, { stmtNo(1), range1 }});

    auto stmts = getFunctionStatements();
    ASSERT_EQ(2u, stmts.size());
    ASSERT_EQ(range0, stmts[0]->getRange());
    ASSERT_EQ(range1, stmts[1]->getRange());
}
コード例 #15
0
ファイル: kbplot.cpp プロジェクト: d-theus/kbplot
void KbPlot::mouseMoveEvent(int x, int y){
	static int px = x;
	static int py = y;
	if(mouseNewMovement) {px = x; py = y;} //Avoid long jumps when release point
	mouseNewMovement = false;//		is far from new press point
	double dx = (xmax-xmin)*(double)(px - x)/(double)container->width();
	double dy = (ymax-ymin)*(double)(y - py)/(double)container->height();
	setRanges(xmin + dx, xmax + dx, ymin + dy, ymax + dy);
	px = x;
	py = y;
}
コード例 #16
0
ファイル: axisbase.cpp プロジェクト: houzhenggang/qsint
AxisBase::AxisBase(Qt::Orientation orient, PlotterBase *parent) :
    QObject(parent),
    m_orient(orient)
{
    setTicks(0, 10);
    setRanges(0, 100);
    setOffset(30);
    setType(AxisData);

    setMinorGridPen(Qt::NoPen);
    setMajorGridPen(Qt::NoPen);

    setModel(0);
}
コード例 #17
0
ファイル: ccgview.cpp プロジェクト: bashrc/ccg
CcgView::CcgView(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::CcgView)
{
    ui->setupUi(this);

    // check that the command line program is installed
    if (!fileExists(QString(CCG_BINARY))) {
        QMessageBox::information(this, "ccg binary not found",
                                 "The ccg command line program " \
                                 "must be installed in order for " \
                                 "this GUI to work");
        close();
        return;
    }

    setRanges();
    setDefaults();
    setupData();

    // When the calculate button is pressed
    connect(ui->pushButtonCalculate, SIGNAL(clicked()),
            this, SLOT(calculate()));
    // When data sources is selected open the data dialog
    connect(ui->actionDataSources,SIGNAL(triggered()),
            this,SLOT(openDataSources()));
    // Save the current image
    connect(ui->actionSaveImage,SIGNAL(triggered()),
            this,SLOT(saveImageAs()));
    // Exit the application
    connect(ui->actionExit,SIGNAL(triggered()),
            this,SLOT(close()));
    // open the about dialog
    connect(ui->actionAbout,SIGNAL(triggered()),
            this,SLOT(openAbout()));
    // Event for detecting mouse click on image
    ui->graphicsView->installEventFilter(this);

    statusLabel.setText("Ready");
    statusLabel.setIndent(3);
    ui->statusBar->addWidget(&statusLabel);

    ui->spinBoxStartYear->setValue(globals.startYear);
    ui->spinBoxEndYear->setValue(globals.endYear);
    ui->comboBoxPlotType->setCurrentIndex(globals.plotTypeIndex);
    ui->comboBoxRegion->setCurrentIndex(globals.regionIndex);

    showingImage=false;
}
コード例 #18
0
ファイル: IdacDriverES.cpp プロジェクト: roessingh/gcead
void IdacDriverES::initDataFirmware()
{
    // Connect to the IDAC DLL
    long lVersion = IdacLibVersion();
    if (lVersion != IDAC_LIB_VERSION)
    {
        addError(tr("Incorrect DLL version!"));
        return;
    }

    LPCSTR pResult = IdacLock("IdacTest");
    if (pResult)
    {
        addError(tr("DLL in use by: %0").arg(pResult));
        return;
    }

    m_bFirmwareSent = boot();
    if (!m_bFirmwareSent) {
        IdacUnlock();
        return;
    }

    // Get range information from the hardware
    LPDWORD pRanges = IdacGetRanges();
    QList<int> ranges;
    for (LPDWORD pnRange = pRanges; int(*pnRange) != -1; pnRange++)
    {
        ranges << *pnRange;
    }
    setRanges(ranges);
    qDebug() << ranges;

    // Get low-pass filter information from the hardware
    int nStrings;
    const char** asStrings;
    IdacLowPassStrings(&nStrings, &asStrings);
    QStringList list;
    for (int i = 0; i < nStrings; i++)
        list << asStrings[i];
    setHighcutStrings(list);

    // Get high-pass filter information from the hardware
    IdacHighPassStrings(&nStrings, &asStrings);
    list.clear();
    for (int i = 0; i < nStrings; i++)
        list << asStrings[i];
    setLowcutStrings(list);
}
コード例 #19
0
ファイル: kbplot.cpp プロジェクト: d-theus/kbplot
void KbPlot::setBackground(const unsigned int color){
	this->stBkgnd.fillColor = color;
	setRanges(xmin,xmax,ymin,ymax);
}
コード例 #20
0
int main(int argc, char** argv)
{
    // Create a value array of all possible code points.
    const UChar32 size = kMaxCodepoint + 1;
    CharacterProperty* values = new CharacterProperty[size];
    memset(values, 0, sizeof(CharacterProperty) * size);

    setRanges(values,
        cjkIdeographRanges, ARRAY_LENGTH(cjkIdeographRanges),
        CharacterProperty::isCJKIdeographOrSymbol);
    setRanges(values,
        cjkSymbolRanges, ARRAY_LENGTH(cjkSymbolRanges),
        CharacterProperty::isCJKIdeographOrSymbol);
    setValues(values,
        cjkIsolatedSymbolsArray, ARRAY_LENGTH(cjkIsolatedSymbolsArray),
        CharacterProperty::isCJKIdeographOrSymbol);

    setRanges(values,
        isUprightInMixedVerticalRanges,
        ARRAY_LENGTH(isUprightInMixedVerticalRanges),
        CharacterProperty::isUprightInMixedVertical);
    setValues(values,
        isUprightInMixedVerticalArray,
        ARRAY_LENGTH(isUprightInMixedVerticalArray),
        CharacterProperty::isUprightInMixedVertical);

    // Create a trie from the value array.
    UErrorCode error = U_ZERO_ERROR;
    UTrie2* trie = utrie2_open(0, 0, &error);
    assert(error == U_ZERO_ERROR);
    UChar32 start = 0;
    CharacterProperty value = values[0];
    for (UChar32 c = 1;; c++) {
        if (c < size && values[c] == value)
            continue;
        if (static_cast<uint32_t>(value)) {
            utrie2_setRange32(trie, start, c - 1,
                static_cast<uint32_t>(value), TRUE, &error);
            assert(error == U_ZERO_ERROR);
        }
        if (c >= size)
            break;
        start = c;
        value = values[start];
    }

    // Freeze and serialize the trie to a byte array.
    utrie2_freeze(trie, UTrie2ValueBits::UTRIE2_16_VALUE_BITS, &error);
    assert(error == U_ZERO_ERROR);
    int32_t serializedSize = utrie2_serialize(trie, nullptr, 0, &error);
    error = U_ZERO_ERROR;
    uint8_t* serialized = new uint8_t[serializedSize];
    serializedSize = utrie2_serialize(trie, serialized, serializedSize, &error);
    assert(error == U_ZERO_ERROR);

    // Write the serialized array to the source file.
    if (argc <= 1) {
        generate(stdout, serializedSize, serialized);
    } else {
        FILE* fp = fopen(argv[1], "wb");
        generate(fp, serializedSize, serialized);
        fclose(fp);
    }

    utrie2_close(trie);

    return 0;
}
コード例 #21
0
ファイル: kbplot.cpp プロジェクト: d-theus/kbplot
void KbPlot::setGridColor(const unsigned int color){
	this->stGridX.lineColor = color;
	this->stGridY.lineColor = color;
	setRanges(xmin,xmax,ymin,ymax);
}
コード例 #22
0
ファイル: kbplot.cpp プロジェクト: d-theus/kbplot
void KbPlot::toggleGrid(bool b){
	this->isGridEnabled = b;
	setRanges(xmin,xmax,ymin,ymax);//<=> refresh, TODO:fix it, GLupdate() is the way
}
コード例 #23
0
bool SensorfwSensorBase::initSensorInterface(QString const &name)
{
    if (!m_sensorInterface) {
        sensorError(KErrNotFound);
        return false;
    }

    //metadata
    const QList<DataRange> intervals = m_sensorInterface->getAvailableIntervals();

    for (int i = 0, l = intervals.size(); i < l; i++) {
        qreal intervalMax = intervals.at(i).max;
        qreal intervalMin = intervals.at(i).min;

        if (intervalMin == 0 && intervalMax == 0) {
            // 0 interval has different meanings in e.g. magge/acce
            // magge -> best-effort
            // acce -> lowest possible
            // in Qt API setting 0 means default
            continue;
        }

        qreal rateMin = intervalMax < 1 ? 1 : 1 / intervalMax * 1000;
        rateMin = rateMin < 1 ? 1 : rateMin;

        intervalMin = intervalMin < 1 ? 10: intervalMin;     // do not divide with 0
        qreal rateMax = 1 / intervalMin * 1000;
        addDataRate(rateMin, rateMax);
    }

    //bufferSizes
    if (m_bufferingSensors.contains(sensor()->identifier())) {

        IntegerRangeList sizes = m_sensorInterface->getAvailableBufferSizes();
        for (int i = 0; i < sizes.size(); i++) {
            int second = sizes.at(i).second;
            m_maxBufferSize = second > m_bufferSize ? second : m_maxBufferSize;
        }
        m_maxBufferSize = m_maxBufferSize < 0 ? 1 : m_maxBufferSize;
        //SensorFW guarantees to provide the most efficient size first
        //TODO: remove from comments
        //m_efficientBufferSize  = m_sensorInterface->hwBuffering()? (l>0?sizes.at(0).first:1) : 1;
    } else {
        m_maxBufferSize = 1;
    }

    sensor()->setMaxBufferSize(m_maxBufferSize);
    sensor()->setEfficientBufferSize(m_efficientBufferSize);

    // TODO deztructor: Leaking abstraction detected. Just copied code
    // from initSensor<>() here, need to
    QByteArray type = sensor()->type();
    if ((type == QAmbientLightSensor::type) // SensorFW returns lux values, plugin enumerated values
            || (type == QIRProximitySensor::type) // SensorFW returns raw reflectance values, plugin % of max reflectance
            || (name == "accelerometersensor") // SensorFW returns milliGs, plugin m/s^2
            || (name == "magnetometersensor") // SensorFW returns nanoTeslas, plugin Teslas
            || (name == "gyroscopesensor")) // SensorFW returns DSPs, plugin milliDSPs
        return true;

    setDescription(m_sensorInterface->description());

    if (name == "tapsensor") return true;
    setRanges();
    return true;
}