Exemplo n.º 1
0
 LinearOperator C1Operator::linearization( const ::Spacy::Vector& x ) const
 {
     return LinearOperator( derivative_( cast_ref< Vector >( x ).get() ), *operatorSpace_,
                            domain(), range() );
 }
Exemplo n.º 2
0
qboolean Makron_CheckAttack (edict_t *self)
{
	vec3_t	spot1, spot2;
	vec3_t	temp;
	float	chance;
	trace_t	tr;
	qboolean	enemy_infront;
	int			enemy_range;
	float		enemy_yaw;

	if (self->enemy->health > 0)
	{
	// see if any entities are in the way of the shot
		VectorCopy (self->s.origin, spot1);
		spot1[2] += self->viewheight;
		VectorCopy (self->enemy->s.origin, spot2);
		spot2[2] += self->enemy->viewheight;

		tr = gi.trace (spot1, NULL, NULL, spot2, self, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_SLIME|CONTENTS_LAVA);

		// do we have a clear shot?
		if (tr.ent != self->enemy)
			return false;
	}
	
	enemy_infront = infront(self, self->enemy);
	enemy_range = range(self, self->enemy);
	VectorSubtract (self->enemy->s.origin, self->s.origin, temp);
	enemy_yaw = vectoyaw(temp);

	self->ideal_yaw = enemy_yaw;


	// melee attack
	if (enemy_range == RANGE_MELEE)
	{
		if (self->monsterinfo.melee)
			self->monsterinfo.attack_state = AS_MELEE;
		else
			self->monsterinfo.attack_state = AS_MISSILE;
		return true;
	}
	
// missile attack
	if (!self->monsterinfo.attack)
		return false;
		
	if (level.time < self->monsterinfo.attack_finished)
		return false;
		
	if (enemy_range == RANGE_FAR)
		return false;

	if (self->monsterinfo.aiflags & AI_STAND_GROUND)
	{
		chance = 0.4;
	}
	else if (enemy_range == RANGE_MELEE)
	{
		chance = 0.8;
	}
	else if (enemy_range == RANGE_NEAR)
	{
		chance = 0.4;
	}
	else if (enemy_range == RANGE_MID)
	{
		chance = 0.2;
	}
	else
	{
		return false;
	}

	if (random () < chance)
	{
		self->monsterinfo.attack_state = AS_MISSILE;
		self->monsterinfo.attack_finished = level.time + 2*random();
		return true;
	}

	if (self->flags & FL_FLY)
	{
		if (random() < 0.3)
			self->monsterinfo.attack_state = AS_SLIDING;
		else
			self->monsterinfo.attack_state = AS_STRAIGHT;
	}

	return false;
}
Exemplo n.º 3
0
 list_inserter& range( const SinglePassRange& r )
 {
     return range( boost::begin(r), boost::end(r) );
 }
Exemplo n.º 4
0
int coll (struct object *objects, struct list *list, double *t_last, double t_now, double dt, int n1_sph, int n1, int n2, int last)
{
	double  x1, y1, z1, x2, y2, z2, x12, y12, z12, r12, sig;
	double  ux1, uy1, uz1, ux2, uy2, uz2;
	double  urx, ury, urz, ur, u12, ur2, t12;
	int     n2_sph, n2_obj, f1, f2, n;


	f1  =(objects[n1_sph].move_flag+1)/2;
	ux1 = objects[n1_sph].u.x*f1;
	uy1 = objects[n1_sph].u.y*f1;
	uz1 = objects[n1_sph].u.z*f1;
	x1  = objects[n1_sph].r.x + ux1*(t_now-t_last[n1_sph]);
	y1  = objects[n1_sph].r.y + uy1*(t_now-t_last[n1_sph]);
	z1  = objects[n1_sph].r.z + uz1*(t_now-t_last[n1_sph]);

	for (n = 1; n <= objects[n1_sph].list[0]; n++)
	{	
		n2_sph = objects[n1_sph].list[n];
		if (range(n2_sph, n1, n2))
		{
			f2  =(objects[n2_sph].move_flag+1)/2;
			ux2 = objects[n2_sph].u.x*f2;
			uy2 = objects[n2_sph].u.y*f2;
			uz2 = objects[n2_sph].u.z*f2;
			x2  = objects[n2_sph].r.x + ux2*(t_now-t_last[n2_sph]);
			y2  = objects[n2_sph].r.y + uy2*(t_now-t_last[n2_sph]);
			z2  = objects[n2_sph].r.z + uz2*(t_now-t_last[n2_sph]);
			x12 = n_image(x1 - x2, max_x);
			y12 = n_image(y1 - y2, max_y);
			z12 = n_image(z1 - z2, max_z);
			urx = ux1 - ux2;
			ury = uy1 - uy2;
			urz = uz1 - uz2;
			sig = objects[n1_sph].r_a + objects[n2_sph].r_a;
			r12 = x12*x12 + y12*y12 + z12*z12 - sig*sig;
			if (r12 < -Tol)  warning ("particle-particle overlap");
			
			ur  = urx*x12 + ury*y12 + urz*z12;
			if (ur < 0.0)
			{
				u12 = urx*urx + ury*ury + urz*urz;
				ur2 = u12*r12;
				if (ur*ur >= ur2)
				{
					t12 = - ur - sqrt(ur*ur - ur2);
					t12 = t12/u12 + t_now;
					if (t12 < dt)
					{
						list[last].t_coll = t12;
						list[last].coll_1 = n1_sph;
						list[last].coll_2 = n2_sph;
						list[last].next   = last + 1;
						last++;
						if (last > MAX_C)  fatal_err("too many collisions: MAX_C exceeded", -1);
					}
				}
			}
		}
	}
	
	
	if (objects[n1_sph].move_flag > 0)
	{
		for (n2_obj = num_sph; n2_obj < num_obj; n2_obj++)
		{
			x12 = (x1 - objects[n2_obj].r.x)*objects[n2_obj].e.x;
			y12 = (y1 - objects[n2_obj].r.y)*objects[n2_obj].e.y;
			z12 = (z1 - objects[n2_obj].r.z)*objects[n2_obj].e.z;

			sig =  objects[n1_sph].r_a;
			r12 = x12 + y12 + z12 - sig;
			if (r12 < -Tol)  warning ("particle-wall overlap");
		
			urx = objects[n1_sph].u.x*objects[n2_obj].e.x;
			ury = objects[n1_sph].u.y*objects[n2_obj].e.y;
			urz = objects[n1_sph].u.z*objects[n2_obj].e.z;
			ur	= urx + ury + urz;
			if (ur < 0.0)
			{
				t12 = -r12/ur + t_now;
				if (t12 < dt)
				{
					list[last].t_coll = t12;
					list[last].coll_1 = n1_sph;
					list[last].coll_2 = n2_obj;
					list[last].next   = last + 1;
					last++;
					if (last > MAX_C)  fatal_err("too many collisions: MAX_C exceeded", -1);
				}
			}
		}
	}
	return (last);
}
Exemplo n.º 5
0
void InputHandler::onButtonReleaseEvent(GdkEventButton * event, PageRef page) {
	XOJ_CHECK_TYPE(InputHandler);

	if (!this->tmpStroke) {
		return;
	}

	// Backward compatibility and also easier to handle for me;-)
	// I cannot draw a line with one point, to draw a visible line I need two points,
	// twice the same Point is also OK
	if (this->tmpStroke->getPointCount() == 1) {
		ArrayIterator<Point> it = this->tmpStroke->pointIterator();
		if (it.hasNext()) {
			this->tmpStroke->addPoint(it.next());
		}
		// No pressure sensitivity
		this->tmpStroke->clearPressure();
	}

	this->tmpStroke->freeUnusedPointItems();

	if (page.getSelectedLayerId() < 1) {
		// This creates a layer if none exists
		page.getSelectedLayer();
		page.setSelectedLayerId(1);
		xournal->getControl()->getWindow()->updateLayerCombobox();
	}

	Layer * layer = page.getSelectedLayer();

	UndoRedoHandler * undo = xournal->getControl()->getUndoRedoHandler();

	undo->addUndoAction(new InsertUndoAction(page, layer, this->tmpStroke, this->redrawable));

	ToolHandler * h = xournal->getControl()->getToolHandler();
	if (h->isShapeRecognizer()) {
		if (this->reco == NULL) {
			this->reco = new ShapeRecognizer();
		}
		ShapeRecognizerResult * result = this->reco->recognizePatterns(this->tmpStroke);

		if (result != NULL) {
			UndoRedoHandler * undo = xournal->getControl()->getUndoRedoHandler();

			Stroke * recognized = result->getRecognized();

			RecognizerUndoAction * recognizerUndo = new RecognizerUndoAction(page, this->redrawable, layer, this->tmpStroke, recognized);
			undo->addUndoAction(recognizerUndo);
			layer->addElement(result->getRecognized());

			Range range(recognized->getX(), recognized->getY());
			range.addPoint(recognized->getX() + recognized->getElementWidth(), recognized->getY() + recognized->getElementHeight());

			range.addPoint(this->tmpStroke->getX(), this->tmpStroke->getY());
			range.addPoint(this->tmpStroke->getX() + this->tmpStroke->getElementWidth(), this->tmpStroke->getY() + this->tmpStroke->getElementHeight());

			ListIterator<Stroke *> l = result->getSources();
			while (l.hasNext()) {
				Stroke * s = l.next();

				layer->removeElement(s, false);

				recognizerUndo->addSourceElement(s);

				range.addPoint(s->getX(), s->getY());
				range.addPoint(s->getX() + s->getElementWidth(), s->getY() + s->getElementHeight());
			}

			this->redrawable->rerenderRange(range);

			// delete the result object, this is not needed anymore, the stroke are not deleted with this
			delete result;
		} else {
			layer->addElement(this->tmpStroke);
			this->redrawable->rerenderElement(this->tmpStroke);
		}

	} else {
		layer->addElement(this->tmpStroke);
		this->redrawable->rerenderElement(this->tmpStroke);
	}

	this->tmpStroke = NULL;

	if (currentInputDevice == event->device) {
		currentInputDevice = NULL;
		INPUTDBG("currentInputDevice = NULL\n", 0);
	}

	this->tmpStrokeDrawElem = 0;
}
Exemplo n.º 6
0
void tag_run(void) {

	// Setup DECAWAVE
	cph_deca_init_device();
	cph_deca_init_network(cph_config->panid, cph_config->shortid);

	// Set our short id in common messages
	tx_poll_msg.header.source = cph_config->shortid;
	tx_discover_msg.header.source = cph_config->shortid;
	tx_pair_msg.header.source = cph_config->shortid;
	tx_range_results_msg.header.source = cph_config->shortid;

	// First, discover anchors
	uint32_t anchor_refresh_ts = 0;
	refresh_anchors();
	anchor_refresh_ts = cph_get_millis();

	// Poll loop
	while (1) {

		int ranges_countdown = MAX_RANGES_BEFORE_POLL_TIMEOUT;
		anchors_status = ANCHORS_MASK;

		while (anchors_status && (--ranges_countdown)) {

			// Check for refresh of anchors
			uint32_t elapsed = cph_get_millis() - anchor_refresh_ts;
			if (elapsed > ANCHORS_REFRESH_INTERVAL) {
				printf("Anchors refresh timeout.  anchors_status:%02X\r\n", anchors_status);
				refresh_anchors();
				anchor_refresh_ts = cph_get_millis();
				// Since we refreshed the anchors, need to range again for ALL anchors during this poll
				anchors_status = ANCHORS_MASK;
			}

			// Range each anchor once during this poll
			for (int i = 0; i < ANCHORS_MIN; i++) {
				if (anchors_status & (1 << i)) {
					anchors[i].range = 0;
					int result = range(&anchors[i]);

					if (result == CPH_OK) {
						anchors_status &= (~(1 << i));
					}

					deca_sleep(RNG_DELAY_MS);
				}
			}

			deca_sleep(RNG_DELAY_MS);
		}

		if (ranges_countdown) {
			send_ranges(MAX_RANGES_BEFORE_POLL_TIMEOUT - ranges_countdown);
		}
		else {
			printf("ranges_countdown expired!\r\n");
		}

		// Execute a delay between ranging exchanges.
		deca_sleep(POLL_DELAY_MS);
	}
}
Exemplo n.º 7
0
static KMAP *kbuild(CAP *cap, KMAP *kmap, unsigned char *seq, void *bind, int *err, unsigned char *capseq, int seql)
{
    int v, w;

    if (!seql && seq[0] == '.' && seq[1]) {
        int x, c;
        unsigned char *s;

        for (x = 0; seq[x] && seq[x] != ' '; ++x) ;
        c = seq[x];
        seq[x] = 0;
#ifdef __MSDOS__
        if (!zcmp(seq + 1, "ku")) {
            capseq = "\0H";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kd")) {
            capseq = "\0P";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kl")) {
            capseq = "\0K";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kr")) {
            capseq = "\0M";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kI")) {
            capseq = "\0R";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kD")) {
            capseq = "\0S";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kh")) {
            capseq = "\0G";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kH")) {
            capseq = "\0O";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kP")) {
            capseq = "\0I";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "kN")) {
            capseq = "\0Q";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k1")) {
            capseq = "\0;";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k2")) {
            capseq = "\0<";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k3")) {
            capseq = "\0=";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k4")) {
            capseq = "\0>";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k5")) {
            capseq = "\0?";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k6")) {
            capseq = "\[email protected]";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k7")) {
            capseq = "\0A";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k8")) {
            capseq = "\0B";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k9")) {
            capseq = "\0C";
            seql = 2;
        } else if (!zcmp(seq + 1, USTR "k0")) {
            capseq = "\0D";
            seql = 2;
        }
        seq[x] = c;
        if (seql) {
            for (seq += x; *seq == ' '; ++seq) ;
        }
#else
        s = jgetstr(cap, seq + 1);
        seq[x] = c;
        if (s && (s = tcompile(cap, s, 0, 0, 0, 0))
                && (sLEN(s) > 1 || (signed char)s[0] < 0)) {
            capseq = s;
            seql = sLEN(s);
            for (seq += x; *seq == ' '; ++seq) ;
        }
#endif
        else {
            *err = -2;
            return kmap;
        }
    }

    if (seql) {
        v = w = (unsigned char) *capseq++;
        --seql;
    } else {
        seq = range(seq, &v, &w);
        if (!seq) {
            *err = -1;
            return kmap;
        }
    }

    if (!kmap)
        kmap = mkkmap();	/* Create new keymap if 'kmap' was NULL */

    /* Make bindings between v and w */
    while (v <= w) {
        if (*seq || seql) {
            if (kmap->keys[v].k == 0)
                kmap->keys[v].value.submap = NULL;
            kmap->keys[v].k = 1;
            kmap->keys[v].value.submap = kbuild(cap, kmap->keys[v].value.submap, seq, bind, err, capseq, seql);
            if (!kmap->keys[v].value.submap) {
                /* Error during recursion. Prevent crash later. */
                kmap->keys[v].k = 0;
            }
        } else {
            if (kmap->keys[v].k == 1)
                rmkmap(kmap->keys[v].value.submap);
            kmap->keys[v].k = 0;
            kmap->keys[v].value.bind =
                /* This bit of code sticks the key value in the macro */
                (v == w ? macstk(bind, v) : dupmacro(macstk(bind, v)));
        }
        ++v;
    }
    return kmap;
}
Exemplo n.º 8
0
int vehicle::automatic_fire_turret( vehicle_part &pt )
{
    auto gun = turret_query( pt );
    if( gun.query() != turret_data::status::ready ) {
        return 0;
    }

    tripoint pos = global_part_pos3( pt );

    npc tmp;
    tmp.set_fake( true );
    tmp.name = rmp_format( _( "<veh_player>The %s" ), pt.name().c_str() );
    tmp.set_skill_level( gun.base()->gun_skill(), 8 );
    tmp.set_skill_level( skill_id( "gun" ), 4 );
    tmp.recoil = abs( velocity ) / 100 / 4;
    tmp.setpos( pos );
    tmp.str_cur = 16;
    tmp.dex_cur = 8;
    tmp.per_cur = 12;
    // Assume vehicle turrets are friendly to the player.
    tmp.attitude = NPCATT_FOLLOW;

    int area = aoe_size( gun.ammo_effects() );
    if( area > 0 ) {
        area += area == 1 ? 1 : 2; // Pad a bit for less friendly fire
    }

    tripoint targ = pos;
    auto &target = pt.target;
    if( target.first == target.second ) {
        // Manual target not set, find one automatically
        const bool u_see = g->u.sees( pos );
        int boo_hoo;

        // @todo calculate chance to hit and cap range based upon this
        int range = std::min( gun.range(), 12 );
        Creature *auto_target = tmp.auto_find_hostile_target( range, boo_hoo, area );
        if( auto_target == nullptr ) {
            if( u_see && boo_hoo ) {
                add_msg( m_warning, ngettext( "%s points in your direction and emits an IFF warning beep.",
                                              "%s points in your direction and emits %d annoyed sounding beeps.",
                                              boo_hoo ),
                         tmp.name.c_str(), boo_hoo );
            }
            return 0;
        }

        targ = auto_target->pos();
    } else if( target.first != target.second ) {
        // Target set manually
        // Make sure we didn't move between aiming and firing (it's a bug if we did)
        if( targ != target.first ) {
            target.second = target.first;
            return 0;
        }

        targ = target.second;
        // Remove the target
        target.second = target.first;
    } else {
        // Shouldn't happen
        target.first = target.second;
        return 0;
    }

    auto shots = gun.fire( tmp, targ );

    if( g->u.sees( pos ) && shots ) {
        add_msg( _( "The %1$s fires its %2$s!" ), name.c_str(), pt.name().c_str() );
    }

    return shots;
}
Exemplo n.º 9
0
//void AmplitudeWidget::drawChannelAmplitudeFilled(Channel *ch, QPainter &p)
void AmplitudeWidget::drawChannelAmplitudeFilledGL(Channel *ch)
{
  View *view = gdata->view;
  
  ChannelLocker channelLocker(ch);
  ZoomLookup *z = &ch->amplitudeZoomLookup;
  
  // baseX is the no. of chunks a pixel must represent.
  double baseX = view->zoomX() / ch->timePerChunk();

  z->setZoomLevel(baseX);
  
  double currentChunk = ch->chunkFractionAtTime(view->currentTime());
  double leftFrameTime = currentChunk - ((view->currentTime() - view->viewLeft()) / ch->timePerChunk());
  int n = 0;
  int baseElement = int(floor(leftFrameTime / baseX));
  if(baseElement < 0) { n -= baseElement; baseElement = 0; }
  int lastBaseElement = int(floor(double(ch->totalChunks()) / baseX));
  //double heightRatio = double(height()) / dBRange();
  double heightRatio = double(height()) / range();
  
  //int firstN = n;
  //int lastN = firstN;
  
  //Q3PointArray bottomPoints(width()*2);
  Array1d<MyGLfloat2d> vertexArray(width()*2);
  int pointIndex = 0;
  //int topBottomPointIndex = 0;

  if (baseX > 1) { // More samples than pixels
    int theWidth = width();
    //if(baseElement + theWidth > z->size()) z->setSize(baseElement + theWidth);
    if(lastBaseElement > z->size()) z->setSize(lastBaseElement);
    for(; n < theWidth && baseElement < lastBaseElement; n++, baseElement++) {
      myassert(baseElement >= 0);
      ZoomElement &ze = z->at(baseElement);
      //if(!z->hasValue(baseElement)) {
      if(!ze.isValid()) {
        if(!calcZoomElement(ze, ch, baseElement, baseX)) continue;
      }
      
      int y = height() - 1 - toInt((ze.high() - offsetInv()) * heightRatio);
      //bottomPoints.setPoint(topBottomPointIndex++, n, y);
      //bottomPoints.setPoint(topBottomPointIndex++, n, height());
      vertexArray[pointIndex++] = MyGLfloat2d(n, y);
      vertexArray[pointIndex++] = MyGLfloat2d(n, height());
      //lastN = n;
    }
    //p.setPen(Qt::NoPen);
    //p.setBrush(gdata->shading1Color());
    //p.drawRect(firstN, 0, lastN, height());
    //p.setPen(gdata->shading2Color());
    //p.drawLineSegments(bottomPoints, 0, topBottomPointIndex/2);
    qglColor(gdata->shading2Color());
    glVertexPointer(2, GL_FLOAT, 0, vertexArray.begin());
    glDrawArrays(GL_QUAD_STRIP, 0, pointIndex);
  } else { //baseX <= 1
    float err = 0.0;
    float val = 0.0;
    int intChunk = (int) floor(leftFrameTime); // Integer version of frame time
    double stepSize = 1.0 / baseX; // So we skip some pixels
    float x = 0.0f, y;

    //double start = 0 - stepSize;
    double start = (double(intChunk) - leftFrameTime) * stepSize;
    double stop = width() + (2 * stepSize);
    //int squareSize = (int(sqrt(stepSize)) / 2) * 2 + 1; //make it an odd number
    //int halfSquareSize = squareSize/2;

    double dn = start;
    int totalChunks = ch->totalChunks();
    if(intChunk < 0) { dn += stepSize * -intChunk; intChunk = 0; }
    //bottomPoints.setPoint(topBottomPointIndex++, toInt(dn), height());
    //vertexArray[pointIndex++] = MyGLfloat2d((GLfloat)dn, height());
    
    //firstN = toInt(dn);
    for(; dn < stop && intChunk < totalChunks; dn += stepSize, intChunk++) {
      AnalysisData *data = ch->dataAtChunk(intChunk);
      myassert(data);
      
      if(!data) continue;
      err = data->correlation();

      val = calculateElement(data);

      //p.setPen(QPen(colorBetween(colorGroup().background(), ch->color, val), 1));

      x = dn;
      y = height() - 1 - ((val - offsetInv()) * heightRatio);
      //bottomPoints.setPoint(topBottomPointIndex++, x, y);
      vertexArray[pointIndex++] = MyGLfloat2d(x, y);
      vertexArray[pointIndex++] = MyGLfloat2d(x, height());
      //lastN = x;
    }
    //bottomPoints.setPoint(topBottomPointIndex, bottomPoints.point(topBottomPointIndex-1).x(), height());
    //if(pointIndex > 0) {
    //  vertexArray[pointIndex] = MyGLfloat2d(vertexArray[pointIndex-1].x, height());
    //  pointIndex++;
    //}
    myassert(pointIndex <= width()*2);
    //p.setPen(Qt::NoPen);
    //p.setBrush(gdata->shading1Color());
    //p.drawRect(firstN, 0, lastN, height());
    //p.setPen(gdata->shading2Color());
    //p.setBrush(gdata->shading2Color());
    //p.drawPolygon(bottomPoints, false, 0, topBottomPointIndex);
    qglColor(gdata->shading2Color());
    glVertexPointer(2, GL_FLOAT, 0, vertexArray.begin());
    glDrawArrays(GL_QUAD_STRIP, 0, pointIndex);
  }
}
Exemplo n.º 10
0
Ray CCamera::GetEyeRay()
{
	glm::vec2 range(m_Width, m_Height);
	glm::vec2 s = GetUniformSample2D(range);
	return GetEyeRay(s.x, s.y);
}
Exemplo n.º 11
0
Ray CCamera::GetEyeRay(glm::vec2& pixel)
{
	glm::vec2 range(m_Width, m_Height);
	pixel = GetUniformSample2D(range);
	return GetEyeRay(pixel.x, pixel.y);
}
Exemplo n.º 12
0
 inline Iter range(Iter first, Iter last) {
     typedef typename std::iterator_traits<Iter>::value_type value_type;
     return range(first, last, std::equal_to<value_type>());
 } // range
Exemplo n.º 13
0
void ReplaceMatches::doReplaceNextMatch()
{
    if ((!m_manager) || (m_cancelReplace)) {
        m_rootIndex = -1;
        emit replaceDone();
        return;
    }

    // NOTE The document managers signal documentWillBeDeleted() must be connected to
    // cancelReplace(). A closed file could lead to a crash if it is not handled.

    // Open the file
    QTreeWidgetItem *rootItem = m_tree->topLevelItem(m_rootIndex);
    if (!rootItem) {
        m_rootIndex = -1;
        emit replaceDone();
        return;
    }

    if (rootItem->checkState(0) == Qt::Unchecked) {
        m_rootIndex++;
        emit replaceNextMatch();
        return;
    }

    KTextEditor::Document *doc = m_manager->findUrl(rootItem->data(0, Qt::UserRole).toString());
    if (!doc) {
        doc = m_manager->openUrl(rootItem->data(0, Qt::UserRole).toString());
    }

    if (!doc) {
        m_rootIndex++;
        emit replaceNextMatch();
        return;
    }

    QVector<KTextEditor::MovingRange*> rVector;
    KTextEditor::MovingInterface* miface = qobject_cast<KTextEditor::MovingInterface*>(doc);
    int line;
    int column;
    int len;
    QTreeWidgetItem *item;
    
    // lines might be modified so search the document again
    for (int i=0; i<rootItem->childCount(); i++) {
        item = rootItem->child(i);
        if (item->checkState(0) == Qt::Unchecked) continue;

        line = item->data(1, Qt::UserRole).toInt();
        column = item->data(2, Qt::UserRole).toInt();
        len = item->data(3, Qt::UserRole).toInt();
        if (m_regExp.indexIn(doc->line(line), column) != column) {
            kDebug() << "expression does not match";
            continue;
        }
        QString html = item->data(1, Qt::ToolTipRole).toString();
        html += "<i><s>" + item->data(2, Qt::ToolTipRole).toString() + "</s></i> ";
        html += "<b>" + m_replaceText + "</b>";
        html += item->data(3, Qt::ToolTipRole).toString();
        item->setData(0, Qt::DisplayRole, i18n("Line: <b>%1</b>: %2",line+1, html));
        KTextEditor::Range range(line, column, line, column+len);
        KTextEditor::MovingRange* mr = miface->newMovingRange(range);
        rVector.append(mr);
    }

    for (int i=0; i<rVector.size(); i++) {
        line = rVector[i]->start().line();
        column = rVector[i]->start().column();
        doc->replaceText(*rVector[i], m_replaceText);
        emit matchReplaced(doc, line, column, m_replaceText.length());
    }

    qDeleteAll(rVector);

    m_rootIndex++;
    emit replaceNextMatch();
}
Exemplo n.º 14
0
VectorXi range( int end ) {
	return range( 0, end );
}
Exemplo n.º 15
0
/**
 * Process a sentence with xml annotation
 * Xml tags may specifiy additional/replacing translation options
 * and reordering constraints
 *
 * \param line in: sentence, out: sentence without the xml
 * \param res vector with translation options specified by xml
 * \param reorderingConstraint reordering constraint zones specified by xml
 * \param walls reordering constraint walls specified by xml
 * \param lbrackStr xml tag's left bracket string, typically "<"
 * \param rbrackStr xml tag's right bracket string, typically ">"
 */
bool
ProcessAndStripXMLTags(AllOptions const& opts, string &line,
                       vector<XmlOption const*> &res,
                       ReorderingConstraint &reorderingConstraint,
                       vector< size_t > &walls,
                       std::vector< std::pair<size_t, std::string> > &placeholders,
                       InputType &input)
{
  //parse XML markup in translation line

  const std::string& lbrackStr = opts.input.xml_brackets.first;
  const std::string& rbrackStr = opts.input.xml_brackets.second;
  int offset = is_syntax(opts.search.algo) ? 1 : 0;

  // const StaticData &staticData = StaticData::Instance();

  // hack. What pt should XML trans opt be assigned to?
  PhraseDictionary *firstPt = NULL;
  if (PhraseDictionary::GetColl().size() == 0) {
    firstPt = PhraseDictionary::GetColl()[0];
  }

  // no xml tag? we're done.
  if (line.find(lbrackStr) == string::npos) {
    return true;
  }

  // break up input into a vector of xml tags and text
  // example: (this), (<b>), (is a), (</b>), (test .)
  vector<string> xmlTokens = TokenizeXml(line, lbrackStr, rbrackStr);

  // we need to store opened tags, until they are closed
  // tags are stored as tripled (tagname, startpos, contents)
  typedef pair< string, pair< size_t, string > > OpenedTag;
  vector< OpenedTag > tagStack; // stack that contains active opened tags

  string cleanLine; // return string (text without xml)
  size_t wordPos = 0; // position in sentence (in terms of number of words)

  const vector<FactorType> &outputFactorOrder = opts.output.factor_order;

  // loop through the tokens
  for (size_t xmlTokenPos = 0 ; xmlTokenPos < xmlTokens.size() ; xmlTokenPos++) {
    // not a xml tag, but regular text (may contain many words)
    if(!isXmlTag(xmlTokens[xmlTokenPos], lbrackStr, rbrackStr)) {
      // add a space at boundary, if necessary
      if (cleanLine.size()>0 &&
          cleanLine[cleanLine.size() - 1] != ' ' &&
          xmlTokens[xmlTokenPos][0] != ' ') {
        cleanLine += " ";
      }
      cleanLine += xmlTokens[xmlTokenPos]; // add to output
      wordPos = Tokenize(cleanLine).size(); // count all the words
    }

    // process xml tag
    else {
      // *** get essential information about tag ***

      // strip extra boundary spaces and "<" and ">"
      string tag =  Trim(TrimXml(xmlTokens[xmlTokenPos], lbrackStr, rbrackStr));
      VERBOSE(3,"XML TAG IS: " << tag << std::endl);

      if (tag.size() == 0) {
        TRACE_ERR("ERROR: empty tag name: " << line << endl);
        return false;
      }

      // check if unary (e.g., "<wall/>")
      bool isUnary = ( tag[tag.size() - 1] == '/' );

      // check if opening tag (e.g. "<a>", not "</a>")g
      bool isClosed = ( tag[0] == '/' );
      bool isOpen = !isClosed;

      if (isClosed && isUnary) {
        TRACE_ERR("ERROR: can't have both closed and unary tag " << lbrackStr << tag << rbrackStr << ": " << line << endl);
        return false;
      }

      if (isClosed)
        tag = tag.substr(1); // remove "/" at the beginning
      if (isUnary)
        tag = tag.substr(0,tag.size()-1); // remove "/" at the end

      // find the tag name and contents
      string::size_type endOfName = tag.find_first_of(' ');
      string tagName = tag;
      string tagContent = "";
      if (endOfName != string::npos) {
        tagName = tag.substr(0,endOfName);
        tagContent = tag.substr(endOfName+1);
      }

      // *** process new tag ***

      if (isOpen || isUnary) {
        // put the tag on the tag stack
        OpenedTag openedTag = make_pair( tagName, make_pair( wordPos, tagContent ) );
        tagStack.push_back( openedTag );
        VERBOSE(3,"XML TAG " << tagName << " (" << tagContent << ") added to stack, now size " << tagStack.size() << endl);
      }

      // *** process completed tag ***

      if (isClosed || isUnary) {
        // pop last opened tag from stack;
        if (tagStack.size() == 0) {
          TRACE_ERR("ERROR: tag " << tagName << " closed, but not opened" << ":" << line << endl);
          return false;
        }
        OpenedTag openedTag = tagStack.back();
        tagStack.pop_back();

        // tag names have to match
        if (openedTag.first != tagName) {
          TRACE_ERR("ERROR: tag " << openedTag.first << " closed by tag " << tagName << ": " << line << endl );
          return false;
        }

        // assemble remaining information about tag
        size_t startPos = openedTag.second.first;
        string tagContent = openedTag.second.second;
        size_t endPos = wordPos;

        // span attribute overwrites position
        string span = ParseXmlTagAttribute(tagContent,"span");
        if (! span.empty()) {
          vector<string> ij = Tokenize(span, "-");
          if (ij.size() != 1 && ij.size() != 2) {
            TRACE_ERR("ERROR: span attribute must be of the form \"i-j\" or \"i\": " << line << endl);
            return false;
          }
          startPos = atoi(ij[0].c_str());
          if (ij.size() == 1) endPos = startPos + 1;
          else endPos = atoi(ij[1].c_str()) + 1;
        }

        VERBOSE(3,"XML TAG " << tagName << " (" << tagContent << ") spanning " << startPos << " to " << (endPos-1) << " complete, commence processing" << endl);

        // special tag: wall
        if (tagName == "wall") {
          size_t start = (startPos == 0) ? 0 : startPos-1;
          for(size_t pos = start; pos < endPos; pos++)
            walls.push_back( pos );
        }

        // special tag: zone
        else if (tagName == "zone") {
          if (startPos >= endPos) {
            TRACE_ERR("ERROR: zone must span at least one word: " << line << endl);
            return false;
          }
          reorderingConstraint.SetZone( startPos, endPos-1 );
        }

        // name-entity placeholder
        else if (tagName == "ne") {
          if (startPos != (endPos - 1)) {
            TRACE_ERR("ERROR: Placeholder must only span 1 word: " << line << endl);
            return false;
          }
          string entity = ParseXmlTagAttribute(tagContent,"entity");
          placeholders.push_back(std::pair<size_t, std::string>(startPos, entity));
        }

        // update: add new aligned sentence pair to Mmsapt identified by name
        else if (tagName == "update") {
#if PT_UG
          // get model name and aligned sentence pair
          string pdName = ParseXmlTagAttribute(tagContent,"name");
          string source = ParseXmlTagAttribute(tagContent,"source");
          string target = ParseXmlTagAttribute(tagContent,"target");
          string alignment = ParseXmlTagAttribute(tagContent,"alignment");
          // find PhraseDictionary by name
          const vector<PhraseDictionary*> &pds = PhraseDictionary::GetColl();
          PhraseDictionary* pd = NULL;
          for (vector<PhraseDictionary*>::const_iterator i = pds.begin(); i != pds.end(); ++i) {
            PhraseDictionary* curPd = *i;
            if (curPd->GetScoreProducerDescription() == pdName) {
              pd = curPd;
              break;
            }
          }
          if (pd == NULL) {
            TRACE_ERR("ERROR: No PhraseDictionary with name " << pdName << ", no update" << endl);
            return false;
          }
          // update model
          VERBOSE(3,"Updating " << pdName << " ||| " << source << " ||| " << target << " ||| " << alignment << endl);
          Mmsapt* pdsa = reinterpret_cast<Mmsapt*>(pd);
          pdsa->add(source, target, alignment);
#else
          TRACE_ERR("ERROR: recompile with --with-mm to update PhraseDictionary at runtime" << endl);
          return false;
#endif
        }

        // weight-overwrite: update feature weights, unspecified weights remain unchanged
        // IMPORTANT: translation models that cache phrases or apply table-limit during load
        // based on initial weights need to be reset.  Sending an empty update will do this
        // for PhraseDictionaryBitextSampling (Mmsapt) models:
        // <update name="TranslationModelName" source=" " target=" " alignment=" " />
        else if (tagName == "weight-overwrite") {

          // is a name->ff map stored anywhere so we don't have to build it every time?
          const vector<FeatureFunction*> &ffs = FeatureFunction::GetFeatureFunctions();
          boost::unordered_map<string, FeatureFunction*> map;
          BOOST_FOREACH(FeatureFunction* const& ff, ffs) {
            map[ff->GetScoreProducerDescription()] = ff;
          }

          // update each weight listed
          ScoreComponentCollection allWeights = StaticData::Instance().GetAllWeights();
          boost::unordered_map<string, FeatureFunction*>::iterator ffi;
          string ffName("");
          vector<float> ffWeights;
          vector<string> toks = Tokenize(ParseXmlTagAttribute(tagContent,"weights"));
          BOOST_FOREACH(string const& tok, toks) {
            if (ends_with(tok, "=")) {
              // start new feature
              if (ffName != "") {
                // set previous feature weights
                if (ffi != map.end()) {
                  allWeights.Assign(ffi->second, ffWeights);
                }
                ffWeights.clear();
              }
              ffName = tok.substr(0, tok.size() - 1);
              ffi = map.find(ffName);
              if (ffi == map.end()) {
                TRACE_ERR("ERROR: No FeatureFunction with name " << ffName << ", no weight update" << endl);
              }
            } else {
              // weight for current feature
              ffWeights.push_back(Scan<float>(tok));
            }
          }
          if (ffi != map.end()) {
            allWeights.Assign(ffi->second, ffWeights);
          }
          StaticData::InstanceNonConst().SetAllWeights(allWeights);
        }

        // Coord: coordinates of the input sentence in a user-defined space
        // <coord space="NAME" coord="X Y Z ..." />
        // where NAME is the name of the space and X Y Z ... are floats.  See
        // PhraseDistanceFeature for an example of using this information for
        // feature scoring.
        else if (tagName == "coord") {
          // Parse tag
          string space = ParseXmlTagAttribute(tagContent, "space");
          vector<string> tok = Tokenize(ParseXmlTagAttribute(tagContent, "coord"));
          size_t id = StaticData::Instance().GetCoordSpace(space);
          if (!id) {
            TRACE_ERR("ERROR: no models use space " << space << ", will be ignored" << endl);
          } else {
            // Init if needed
            if (!input.m_coordMap) {
              input.m_coordMap.reset(new map<size_t const, vector<float> >);
            }
            vector<float>& coord = (*input.m_coordMap)[id];
            Scan<float>(coord, tok);
          }
        }

        // default: opening tag that specifies translation options
        else {
          if (startPos > endPos) {
            TRACE_ERR("ERROR: tag " << tagName << " startPos > endPos: " << line << endl);
            return false;
          } else if (startPos == endPos) {
            TRACE_ERR("WARNING: tag " << tagName << " 0 span: " << line << endl);
            continue;
          }

          // specified translations -> vector of phrases
          // multiple translations may be specified, separated by "||"
          vector<string> altTexts = TokenizeMultiCharSeparator(ParseXmlTagAttribute(tagContent,"translation"), "||");
          if( altTexts.size() == 1 && altTexts[0] == "" )
            altTexts.pop_back(); // happens when nothing specified
          // deal with legacy annotations: "translation" was called "english"
          vector<string> moreAltTexts = TokenizeMultiCharSeparator(ParseXmlTagAttribute(tagContent,"english"), "||");
          if (moreAltTexts.size()>1 || moreAltTexts[0] != "") {
            for(vector<string>::iterator translation=moreAltTexts.begin();
                translation != moreAltTexts.end();
                translation++) {
              string t = *translation;
              altTexts.push_back( t );
            }
          }

          // specified probabilities for the translations -> vector of probs
          vector<string> altProbs = TokenizeMultiCharSeparator(ParseXmlTagAttribute(tagContent,"prob"), "||");
          if( altProbs.size() == 1 && altProbs[0] == "" )
            altProbs.pop_back(); // happens when nothing specified

          // report what we have processed so far
          VERBOSE(3,"XML TAG NAME IS: '" << tagName << "'" << endl);
          VERBOSE(3,"XML TAG TRANSLATION IS: '" << altTexts[0] << "'" << endl);
          VERBOSE(3,"XML TAG PROB IS: '" << altProbs[0] << "'" << endl);
          VERBOSE(3,"XML TAG SPAN IS: " << startPos << "-" << (endPos-1) << endl);
          if (altProbs.size() > 0 && altTexts.size() != altProbs.size()) {
            TRACE_ERR("ERROR: Unequal number of probabilities and translation alternatives: " << line << endl);
            return false;
          }

          // store translation options into members
          if (opts.input.xml_policy != XmlIgnore) {
            // only store options if we aren't ignoring them
            for (size_t i=0; i<altTexts.size(); ++i) {
              Phrase sourcePhrase; // TODO don't know what the source phrase is

              // set default probability
              float probValue = 1;
              if (altProbs.size() > 0) probValue = Scan<float>(altProbs[i]);
              // convert from prob to log-prob
              float scoreValue = FloorScore(TransformScore(probValue));

              Range range(startPos + offset,endPos-1 + offset); // span covered by phrase
              TargetPhrase targetPhrase(firstPt);
              // targetPhrase.CreateFromString(Output, outputFactorOrder,altTexts[i],factorDelimiter, NULL);
              targetPhrase.CreateFromString(Output, outputFactorOrder,altTexts[i], NULL);

              // lhs
              const UnknownLHSList &lhsList = opts.syntax.unknown_lhs; // staticData.GetUnknownLHS();
              if (!lhsList.empty()) {
                const Factor *factor = FactorCollection::Instance().AddFactor(lhsList[0].first, true);
                Word *targetLHS = new Word(true);
                targetLHS->SetFactor(0, factor); // TODO - other factors too?
                targetPhrase.SetTargetLHS(targetLHS);
              }

              targetPhrase.SetXMLScore(scoreValue);
              targetPhrase.EvaluateInIsolation(sourcePhrase);

              XmlOption *option = new XmlOption(range,targetPhrase);
              assert(option);

              res.push_back(option);
            }
            altTexts.clear();
            altProbs.clear();
          }
        }
      }
    }
  }
Exemplo n.º 16
0
void AmplitudeWidget::mousePressEvent(QMouseEvent *e)
{
  View *view = gdata->view;
  int timeX = toInt(view->viewOffset() / view->zoomX());
  //int pixelAtCurrentNoiseThresholdY = toInt(gdata->noiseThresholdDB() / gdata->dBFloor() / range() * double(height()));
  int pixelAtCurrentNoiseThresholdY;
  dragMode = DragNone;
  
  //Check if user clicked on center bar, to drag it
  if(within(4, e->x(), timeX)) {
    dragMode = DragTimeBar;
    mouseX = e->x();
    return;
  }
  //Check if user clicked on a threshold bar
  for(int j=0; j<2; j++) {
    pixelAtCurrentNoiseThresholdY = height() - 1 - toInt((getCurrentThreshold(j) - offsetInv()) / range() * double(height()));
    if(within(4, e->y(), pixelAtCurrentNoiseThresholdY)) {
      dragMode = DragNoiseThreshold;
      thresholdIndex = j; //remember which thresholdIndex the user clicked
      mouseY = e->y();
      return;
    }
  }
  //Otherwise user has clicked on background
  {
    mouseX = e->x();
    mouseY = e->y();
    dragMode = DragBackground;
    downTime = view->currentTime();
    downOffset = offset();
  }
}
Exemplo n.º 17
0
ValueBuffer * AutomatableModel::valueBuffer()
{
	QMutexLocker m( &m_valueBufferMutex );
	// if we've already calculated the valuebuffer this period, return the cached buffer
	if( m_lastUpdatedPeriod == s_periodCounter )
	{
		return m_hasSampleExactData
			? &m_valueBuffer
			: NULL;
	}

	float val = m_value; // make sure our m_value doesn't change midway

	ValueBuffer * vb;
	if( m_controllerConnection && m_controllerConnection->getController()->isSampleExact() )
	{
		vb = m_controllerConnection->valueBuffer();
		if( vb )
		{
			float * values = vb->values();
			float * nvalues = m_valueBuffer.values();
			switch( m_scaleType )
			{
			case Linear:
				for( int i = 0; i < m_valueBuffer.length(); i++ )
				{
					nvalues[i] = minValue<float>() + ( range() * values[i] );
				}
				break;
			case Logarithmic:
				for( int i = 0; i < m_valueBuffer.length(); i++ )
				{
					nvalues[i] = logToLinearScale( values[i] );
				}
				break;
			default:
				qFatal("AutomatableModel::valueBuffer() "
					"lacks implementation for a scale type");
				break;
			}
			m_lastUpdatedPeriod = s_periodCounter;
			m_hasSampleExactData = true;
			return &m_valueBuffer;
		}
	}
	AutomatableModel* lm = NULL;
	if( hasLinkedModels() )
	{
		lm = m_linkedModels.first();
	}
	if( lm && lm->controllerConnection() && lm->controllerConnection()->getController()->isSampleExact() )
	{
		vb = lm->valueBuffer();
		float * values = vb->values();
		float * nvalues = m_valueBuffer.values();
		for( int i = 0; i < vb->length(); i++ )
		{
			nvalues[i] = fittedValue( values[i] );
		}
		m_lastUpdatedPeriod = s_periodCounter;
		m_hasSampleExactData = true;
		return &m_valueBuffer;
	}

	if( m_oldValue != val )
	{
		m_valueBuffer.interpolate( m_oldValue, val );
		m_oldValue = val;
		m_lastUpdatedPeriod = s_periodCounter;
		m_hasSampleExactData = true;
		return &m_valueBuffer;
	}

	// if we have no sample-exact source for a ValueBuffer, return NULL to signify that no data is available at the moment
	// in which case the recipient knows to use the static value() instead
	m_lastUpdatedPeriod = s_periodCounter;
	m_hasSampleExactData = false;
	return NULL;
}
/** constructor; just initialize the base class */
TranslationOptionCollectionConfusionNet::TranslationOptionCollectionConfusionNet(
    const ConfusionNet &input
    , size_t maxNoTransOptPerCoverage, float translationOptionThreshold)
    : TranslationOptionCollection(input, maxNoTransOptPerCoverage, translationOptionThreshold)
{
    const InputFeature *inputFeature = StaticData::Instance().GetInputFeature();
    UTIL_THROW_IF2(inputFeature == NULL,
                   "Input feature must be specified");

    size_t inputSize = input.GetSize();
    m_inputPathMatrix.resize(inputSize);

    size_t maxSizePhrase = StaticData::Instance().GetMaxPhraseLength();
    maxSizePhrase = std::min(inputSize, maxSizePhrase);

    // 1-word phrases
    for (size_t startPos = 0; startPos < inputSize; ++startPos) {
        vector<InputPathList> &vec = m_inputPathMatrix[startPos];
        vec.push_back(InputPathList());
        InputPathList &list = vec.back();

        WordsRange range(startPos, startPos);
        const NonTerminalSet &labels = input.GetLabelSet(startPos, startPos);

        const ConfusionNet::Column &col = input.GetColumn(startPos);
        for (size_t i = 0; i < col.size(); ++i) {
            const Word &word = col[i].first;
            Phrase subphrase;
            subphrase.AddWord(word);

            const ScorePair &scores = col[i].second;
            ScorePair *inputScore = new ScorePair(scores);

            InputPath *path = new InputPath(subphrase, labels, range, NULL, inputScore);
            list.push_back(path);

            m_inputPathQueue.push_back(path);
        }
    }

    // subphrases of 2+ words
    for (size_t phraseSize = 2; phraseSize <= maxSizePhrase; ++phraseSize) {
        for (size_t startPos = 0; startPos < inputSize - phraseSize + 1; ++startPos) {
            size_t endPos = startPos + phraseSize -1;

            WordsRange range(startPos, endPos);
            const NonTerminalSet &labels = input.GetLabelSet(startPos, endPos);

            vector<InputPathList> &vec = m_inputPathMatrix[startPos];
            vec.push_back(InputPathList());
            InputPathList &list = vec.back();

            // loop thru every previous path
            const InputPathList &prevPaths = GetInputPathList(startPos, endPos - 1);

            int prevNodesInd = 0;
            InputPathList::const_iterator iterPath;
            for (iterPath = prevPaths.begin(); iterPath != prevPaths.end(); ++iterPath) {
                //for (size_t pathInd = 0; pathInd < prevPaths.size(); ++pathInd) {
                const InputPath &prevPath = **iterPath;
                //const InputPath &prevPath = *prevPaths[pathInd];

                const Phrase &prevPhrase = prevPath.GetPhrase();
                const ScorePair *prevInputScore = prevPath.GetInputScore();
                UTIL_THROW_IF2(prevInputScore == NULL,
                               "No input score for path: " << prevPath);

                // loop thru every word at this position
                const ConfusionNet::Column &col = input.GetColumn(endPos);

                for (size_t i = 0; i < col.size(); ++i) {
                    const Word &word = col[i].first;
                    Phrase subphrase(prevPhrase);
                    subphrase.AddWord(word);

                    const ScorePair &scores = col[i].second;
                    ScorePair *inputScore = new ScorePair(*prevInputScore);
                    inputScore->PlusEquals(scores);

                    InputPath *path = new InputPath(subphrase, labels, range, &prevPath, inputScore);
                    list.push_back(path);

                    m_inputPathQueue.push_back(path);
                } // for (size_t i = 0; i < col.size(); ++i) {

                ++prevNodesInd;
            } // for (iterPath = prevPaths.begin(); iterPath != prevPaths.end(); ++iterPath) {
        }
    }
}
	void getInterval(T * interval, int i, T max, T min = T(0)){
		double diam = range(max,min);
		double left = diam * i + min;
		interval[0] = left;
		interval[1] = left + diam;
	}
Exemplo n.º 20
0
void DSP::serialize(serializer& s) {
  Thread::serialize(s);

  s.array(apuram);

  s.array(state.regs, 128);
  s.array(state.echoHistory[0]);
  s.array(state.echoHistory[1]);
  s.integer(state.echoHistoryOffset);

  s.integer(state.everyOtherSample);
  s.integer(state.kon);
  s.integer(state.noise);
  s.integer(state.counter);
  s.integer(state.echoOffset);
  s.integer(state.echoLength);

  s.integer(state.konBuffer);
  s.integer(state.endxBuffer);
  s.integer(state.envxBuffer);
  s.integer(state.outxBuffer);

  s.integer(state._pmon);
  s.integer(state._non);
  s.integer(state._eon);
  s.integer(state._dir);
  s.integer(state._koff);

  s.integer(state._brrNextAddress);
  s.integer(state._adsr0);
  s.integer(state._brrHeader);
  s.integer(state._brrByte);
  s.integer(state._srcn);
  s.integer(state._esa);
  s.integer(state._echoDisabled);

  s.integer(state._dirAddress);
  s.integer(state._pitch);
  s.integer(state._output);
  s.integer(state._looped);
  s.integer(state._echoPointer);

  s.array(state._mainOut, 2);
  s.array(state._echoOut, 2);
  s.array(state._echoIn, 2);

  for(auto n : range(8)) {
    s.array(voice[n].buffer);
    s.integer(voice[n].bufferOffset);
    s.integer(voice[n].gaussianOffset);
    s.integer(voice[n].brrAddress);
    s.integer(voice[n].brrOffset);
    s.integer(voice[n].vbit);
    s.integer(voice[n].vidx);
    s.integer(voice[n].konDelay);
    s.integer(voice[n].envelopeMode);
    s.integer(voice[n].envelope);
    s.integer(voice[n].hiddenEnvelope);
    s.integer(voice[n]._envxOut);
  }
}
Exemplo n.º 21
0
static tree
move_brackets_sub (tree t, bool in) {
  //cout << t << INDENT << LF;
  if (is_compound (t)) {
    int i, n= N(t);
    tree r= tree (t, n);
    for (i=0; i<n; i++)
      r[i]= move_brackets_sub (t[i], in);
    t= r;
  }

  while (true) {
    tree r= t;
    bool search= true;
    if (is_concat (t))
      for (int i=0; i<N(t) && search; i++)
        if (is_compound (t[i], "math")) {
          array<tree> a= concat_tokenize (t[i][0]);
          for (int j=0; j<N(a) && search; j++)
            if (is_atomic (a[j]) && is_simple_opening (a[j]->label))
              for (int k= i+1; k<N(t) && search; k++)
                if (is_atomic (t[k])) {
                  string s= t[k]->label;
                  for (int l=0; l<N(s) && search; tm_char_forwards (s, l))
                    if (is_simple_matching (a[j]->label, s (l, l+1))) {
                      if (k == i+1 && l == 0 && in) {
                        array<tree> c= concat_decompose (t);
                        a << tree (s (0, 1));
                        c[i]= compound ("math", concat_recompose (a));
                        c[i]= upgrade_brackets (c[i]);
                        c[i+1]= s (1, N(s));
                        r= move_brackets_sub (concat_recompose (c), in);
                        search= false;
                      }
                      else if (j == 0 && !in) {
                        tree x= a[0];
                        array<tree> c= concat_decompose (t);
                        a= range (a, 1, N(a));
                        c[i]= compound ("math", concat_recompose (a));
                        c= append (range (c, 0, i),
                                   append (x, range (c, i, N(c))));
                        r= move_brackets_sub (concat_recompose (c), in);
                        search= false;
                      }
                    }
                }
          for (int j=N(a)-1; j>=0 && search; j--)
            if (is_atomic (a[j]) && is_simple_closing (a[j]->label))
              for (int k= i-1; k>=0 && search; k--)
                if (is_atomic (t[k])) {
                  string s= t[k]->label;
                  for (int l=N(s); l>0 && search; tm_char_backwards (s, l))
                    if (is_simple_matching (s (l-1, l), a[j]->label)) {
                      if (k == i-1 && l == N(s) && in) {
                        array<tree> c= concat_decompose (t);
                        a= append (tree (s (l-1, l)), a);
                        c[i]= compound ("math", concat_recompose (a));
                        c[i]= upgrade_brackets (c[i]);
                        c[i-1]= s (0, l-1);
                        r= move_brackets_sub (concat_recompose (c), in);
                        search= false;
                      }
                      else if (j == N(a)-1 && !in) {
                        tree x= a[j];
                        array<tree> c= concat_decompose (t);
                        a= range (a, 0, j);
                        c[i]= compound ("math", concat_recompose (a));
                        c= append (range (c, 0, i+1),
                                   append (x, range (c, i+1, N(c))));
                        r= move_brackets_sub (concat_recompose (c), in);
                        search= false;
                      }
                    }
                }
        }
    if (search) break;
    else {
      //cout << "< " << t << LF;
      //cout << "> " << r << LF;
      t= r;
    }
  }
  //cout << UNINDENT << "Done" << LF;
  return t;
}
Exemplo n.º 22
0
void MencoderTranscoding::updateArguments()
{
    QString fontFile = "/Users/doudou/workspaceQT/DLNA_server/exe/LucidaSansRegular.ttf";

    QStringList arguments;
    if (range() != 0 && !range()->isNull()) {
        if (range()->getStartByte() > 0 && lengthInSeconds() > 0) {
            double start_position = double(range()->getStartByte())/double(range()->getSize())*double(lengthInSeconds());
            arguments << "-ss" << QString("%1.0").arg(long(start_position));
        }
    } else if (timeSeekStart() > 0) {
        arguments << "-ss" << QString("%1.0").arg(timeSeekStart());
    }

    arguments << url();

    if (format() == MPEG2_AC3) {

        // set container format to MPEG
        arguments << "-of" << "mpeg";
        arguments << "-mpegopts" << "format=mpeg2:muxrate=500000:vbuf_size=1194:abuf_size=64";

        // set audio options
        arguments << "-oac" << "lavc";
        arguments << "-channels" << "6";
        arguments << "-af" << "lavcresample=48000";
        arguments << "-srate" << "48000";

        // set video options
        arguments << "-ovc" <<  "lavc";
        arguments << "-lavcopts" << "autoaspect=1:vcodec=mpeg2video:acodec=ac3:abitrate=448:keyint=25:vrc_maxrate=9800:vrc_buf_size=1835:vbitrate=5000";

        // set font file
        arguments << "-font" << fontFile;

        // set subtitles options
        arguments << "-ass" << "-ass-color" << "ffffff00" << "-ass-border-color" << "00000000" << "-ass-font-scale" << "1.4";
        arguments << "-ass-force-style" << QString("FontName=%1,Outline=1,Shadow=1,MarginV=10").arg(fontFile);

        // choose audio and subtitle language
        if (audioLanguages().contains("fre")) {
            arguments << "-aid" << QString("%1").arg(audioLanguages().indexOf("fre"));
            arguments << "-nosub";
        } else {
            if (subtitleLanguages().contains("fre")) {
                arguments << "-noautosub" << "-sid" << QString("%1").arg(subtitleLanguages().indexOf("fre"));
            } else if (subtitleLanguages().contains("eng")) {
                arguments << "-noautosub" << "-sid" << QString("%1").arg(subtitleLanguages().indexOf("eng"));
            }
        }

        // set frame rate
        if (!frameRate().isEmpty()) {
            if (frameRate() == "23.976") {
                arguments << "-ofps" << "24000/1001";
            } else if (frameRate() == "29.970") {
                arguments << "-ofps" << "30000/1001";
            } else {
                // default framerate output
                arguments << "-ofps" << "25.000";
            }
        } else {
            // default framerate output
            arguments << "-ofps" << "25.000";
        }

    } else {
        logError(QString("Invalid format: %1").arg(format()));
    }

    if (range() != 0 && !range()->isNull()) {
        if (range()->getLength() > 0) {
            if (range()->getHighRange() >= 0 && lengthInSeconds() > 0) {
                // calculate the endpos in seconds
                double endpos = double(range()->getLength())/double(range()->getSize())*double(lengthInSeconds());
                arguments << "-endpos" << QString("%1").arg(long(endpos));
            }
        } else {
            // invalid length
            arguments << "-endpos 0";
        }
    } else if (timeSeekEnd() > 0) {
        arguments << "-endpos" << QString("%1").arg(timeSeekEnd());
    }

    // set output = pipe
    arguments << "-o" << "-";

    // set option on loglevel (required to use seek time mode, option -ss)
    arguments << "-really-quiet";
    arguments << "-msglevel" << "statusline=2";

    setArguments(arguments);
}
///
/// Define all (nuisance) parameters.
///
///  scan:      defines scan range (for Prob and Plugin methods)
///  phys:      physically allowed range (needs to be set!)
///  bboos:     Ranges for Berger-Boos method
///  force:     min, max used by the force fit method
///
void ParametersGammaCombo::defineParameters()
{
	Parameter *p = 0;

	p = newParameter("g");
	p->title = "#gamma";
	p->startvalue = DegToRad(70);
	// p->startvalue = DegToRad(119);
	p->unit = "Rad";
	// p->unit = "";
	p->scan = range(DegToRad(0), DegToRad(180));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(0), DegToRad(180));

	p = newParameter("d_dk");
	//p->title = "#delta_{B}^{K}";
	p->title = "#delta_{B}^{DK}";
	p->startvalue = DegToRad(127);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(180));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(-180), DegToRad(180)); // B -> DK

	p = newParameter("r_dk");
	// p->title = "r_{B}^{K}";
	p->title = "r_{B}^{DK}";
	p->startvalue = 0.09;
	p->unit = "";
	p->scan = range(0.02, 0.2);
	p->phys = range(0, 1e4);
	p->force = range(0.02, 0.16);
	p->bboos = range(0.01, 0.22); // B -> DK

	p = newParameter("xm_dk");
	p->title = "x- (DK)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-0.2, 0.2);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> DK

	p = newParameter("ym_dk");
	p->title = "y- (DK)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(0.0, 0.3);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> DK

	p = newParameter("xp_dk");
	p->title = "x+ (DK)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-0.2, 0.2);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> DK

	p = newParameter("yp_dk");
	p->title = "y+ (DK)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-0.2, 0.2);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> DK

	p = newParameter("RBRdkdpi");
	p->title = "RBRdkdpi";
	p->startvalue = 0.076;
	p->unit = "";
	p->scan = range(0.07, 0.09);
	p->phys = range(0, 1e4);
	p->force = range(0.07, 0.09);
	p->bboos = range(0.02, 0.27); // B -> DK / B -> Dpi

	p = newParameter("d_dpi");
	// p->title = "#delta_{B}^{#pi}";
	p->title = "#delta_{B}^{D#pi}";
	p->startvalue = DegToRad(223);;
	p->unit = "Rad";
	// p->scan = range(DegToRad(0), DegToRad(180));
	p->scan = range(DegToRad(180), DegToRad(360));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(-180), DegToRad(180)); // B -> Dpi

	p = newParameter("r_dpi");
	// p->title = "r_{B}^{#pi}";
	p->title = "r_{B}^{D#pi}";
	p->startvalue = 0.005;
	p->unit = "";
	p->scan = range(0, 0.1);
	p->phys = range(0, 1e4);
	p->force = range(0.001, 0.04);
	p->bboos = range(0, 0.18); // B -> Dpi

	p = newParameter("xm_dpi");
	p->title = "x- (D#pi)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-0.2, 0.2);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> Dpi

	p = newParameter("ym_dpi");
	p->title = "y- (D#pi)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(0.0, 0.3);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> Dpi

	p = newParameter("xp_dpi");
	p->title = "x+ (D#pi)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-0.2, 0.2);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> Dpi

	p = newParameter("yp_dpi");
	p->title = "y+ (D#pi)";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-0.2, 0.2);
	p->phys = range(-1e4, 1e4);
	p->force = range(-0.2, 0.2);
	p->bboos = range(0.01, 0.22); // B -> Dpi

	p = newParameter("d_dkpipi");
	p->title = "#delta_{B}^{DK#pi#pi}";
	p->startvalue = DegToRad(338);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(180));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(-180), DegToRad(180));

	p = newParameter("r_dkpipi");
	p->title = "r_{B}^{DK#pi#pi}";
	p->startvalue = 0.09;
	p->unit = "";
	p->scan = range(0.02, 0.16);
	p->phys = range(0, 1e4);
	p->force = range(0.02, 0.16);
	p->bboos = range(0.01, 0.22);

	p = newParameter("k_dkpipi");
	p->title = "#kappa_{B}^{DK#pi#pi}";
	p->startvalue = 0.3;
	p->unit = "";
	p->scan = range(0.01, 1.0);
	p->phys = range(0, 1);
	p->force = range(0.01, 1.5);
	p->bboos = range(0.01, 1.5);

	p = newParameter("d_dpipipi");
	p->title = "#delta_{B}^{D#pi#pi#pi}";
	p->startvalue = DegToRad(330);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(180));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(-180), DegToRad(180));

	p = newParameter("r_dpipipi");
	p->title = "r_{B}^{D#pi#pi#pi}";
	p->startvalue = 0.015;
	p->unit = "";
	p->scan = range(0.02, 0.16);
	p->phys = range(0, 1e4);
	p->force = range(0.02, 0.16);
	p->bboos = range(0.01, 0.22);

	p = newParameter("k_dpipipi");
	p->title = "#kappa_{B}^{D#pi#pi#pi}";
	p->startvalue = 0.3;
	p->unit = "";
	p->scan = range(0.01, 1.0);
	p->phys = range(0, 1);
	p->force = range(0.01, 1.5);
	p->bboos = range(0.01, 1.5);

	// B -> DKpipi / B -> Dpipipi
	p = newParameter("RBRdhpipi");
	p->title = "R_{cab}^{Dh#pi#pi}";
	p->startvalue = 0.03;
	p->unit = "";
	p->scan = range(0.07, 0.09);
	p->phys = range(0, 1e4);
	p->force = range(0.07, 0.09);
	p->bboos = range(0.02, 0.27);

  // B+ -> D*K+
	p = newParameter("d_dstk");
	p->title = "#delta_{B}^{D*K}";
	p->startvalue = DegToRad(127);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(180));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(-180), DegToRad(180)); // B -> D*K

	p = newParameter("r_dstk");
	p->title = "r_{B}^{D*K}";
	p->startvalue = 0.09;
	p->unit = "";
	p->scan = range(0.02, 0.2);
	p->phys = range(0, 1e4);
	p->force = range(0.02, 0.16);
	p->bboos = range(0.01, 0.22); // B -> D*K

	// B+ -> DK*+
  p = newParameter("d_dkst");
	p->title = "#delta_{B}^{DK*}";
	p->startvalue = DegToRad(127);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(180));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(-180), DegToRad(180)); // B -> DK*

	p = newParameter("k_dkst");
	p->title = "#kappa_{B}^{DK*}";
	p->startvalue = 0.9;
	p->unit = "";
	p->scan = range(0, 2.5);
	p->phys = range(0, 1);
	p->force = range(0.001, 1);
	p->bboos = range(0, 1);

	p = newParameter("r_dkst");
	p->title = "r_{B}^{DK*}";
	p->startvalue = 0.09;
	p->unit = "";
	p->scan = range(0.02, 0.2);
	p->phys = range(0, 1e4);
	p->force = range(0.02, 0.16);
	p->bboos = range(0.01, 0.22); // B -> DK*


	// B0 -> D0Kst0
	p = newParameter("d_dkstz");
	p->title = "#delta_{D^{0}K^{*}}";
	p->startvalue = DegToRad(200);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(360));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(180), DegToRad(360));
	p->bboos = range(DegToRad(0), DegToRad(360)); // B0 -> D0Kst0

	p = newParameter("r_dkstz");
	p->title = "r_{D^{0}K^{*}}";
	p->startvalue = 0.3;
	p->unit = "";
	p->scan = range(0, 1.);
	p->phys = range(0.001, 1);
	p->force = range(0.001, 0.6);
	p->bboos = range(0, 1);

	p = newParameter("k_dkstz");
	p->title = "#kappa_{D^{0}K^{*}}";
	p->startvalue = 0.9;
	p->unit = "";
	p->scan = range(0, 2.5);
	p->phys = range(0, 1);
	p->force = range(0.001, 1);
	p->bboos = range(0, 1);

	// B0 -> D0Kpi
	//p = newParameter("d_dkpi");
	//p->title = "#delta_{D^{0}K#pi}";
	//p->startvalue = DegToRad(270);
	//p->unit = "Rad";
	//p->scan = range(DegToRad(0), DegToRad(180));
	//p->phys = range(-7, 7);
	//p->force = range(DegToRad(0), DegToRad(90));
	//p->bboos = range(DegToRad(-180), DegToRad(180)); // B0 -> D0Kst0

	//p = newParameter("r_dkpi");
	//p->title = "r_{D^{0}K#pi}";
	//p->startvalue = 0.3;
	//p->unit = "";
	//p->scan = range(0, 1.0);
	//p->phys = range(0.001, 1);
	//p->force = range(0.001, 0.5);
	//p->bboos = range(0, 1);

  // Special ratio parameters suggested by Tim
	p = newParameter("delta_dkstz");
	p->title = "#bar{#Delta}_{D^{0}K*^{0}}";
	p->startvalue = DegToRad(0.2);
	p->unit = "";
	p->scan = range(DegToRad(-20), DegToRad(20));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(-90), DegToRad(90));
	p->bboos = range(DegToRad(-180), DegToRad(180)); // B0 -> D0Kst0

	p = newParameter("R_dkstz");
	p->title = "#bar{R}_{D^{0}K*^{0}}";
	p->startvalue = 1.1;
	p->unit = "";
	p->scan = range(0.8, 1.2);
	p->phys = range(0.001, 10.);
	p->force = range(0.001, 10.0);
	p->bboos = range(0, 10);

	//p = newParameter("k_dkpi");
	//p->title = "#kappa_{D^{0}K#pi}";
	//p->startvalue = 0.9;
	//p->unit = "";
	//p->scan = range(0, 2.5);
	//p->phys = range(0, 1);
	//p->force = range(0.001, 1);
	//p->bboos = range(0, 1);

	// Bs -> DsK
	p = newParameter("l_dsk");
	// p->title = "#lambda_{D_{s}K}";
	p->title = "r_{D_{s}K}";
	// p->startvalue = 0.37;
	p->startvalue = 0.54;
	p->unit = "";
	p->scan = range(0, 1.4);
	p->phys = range(0, 1e4);
	p->force = range(0.01, 1);
	p->bboos = range(0, 1);

	p = newParameter("d_dsk");
	p->title = "#delta_{D_{s}K}";
	// p->startvalue = DegToRad(20);
	p->startvalue = DegToRad(8);
	p->unit = "Rad";
	p->scan = range(DegToRad(-90), DegToRad(90));
	// p->scan = range(DegToRad(-70), DegToRad(290));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(-90), DegToRad(90));

	// Bs mixing phase
	p = newParameter("phis");
	p->title = "#phi_{s}";
	p->startvalue = 0.01;
	//p->unit = "Rad"; // don't use Rad becaus phi cannot wrap around and then bring back angles messes with it
	p->unit = "";
	p->scan = range(-0.25, 0.25);
	p->phys = range(-7, 7);
	p->force = range(-0.25, 0.25);
	p->bboos = range(-0.25, 0.25); // Bs -> DsK

	p = newParameter("rD_kpi");
	p->title = "r_{K#pi}";
	p->startvalue = 0.058;
	p->unit = "";
	p->scan = range(0.054, 0.061);
	p->phys = range(0, 1e4);
	p->force = range(0.001, 0.15);
	p->bboos = range(0.01, 0.21); // D -> Kpi

	p = newParameter("dD_kpi");
	p->title = "#delta_{K#pi}";
	p->startvalue = DegToRad(188);
	p->unit = "Rad";
	p->scan = range(DegToRad(160), DegToRad(250));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(150), DegToRad(250));
	p->bboos = range(DegToRad(150), DegToRad(250)); // D -> Kpi

	p = newParameter("rD_k3pi");
	p->title = "r_{K3#pi}";
	p->startvalue = 0.056;
	p->unit = "";
	p->scan = range(0.045, 0.065);
	p->phys = range(0, 1e4);
	p->force = range(0.001, 0.15);
	p->bboos = range(0.01, 0.15); // D -> Kpipipi

	p = newParameter("dD_k3pi");
	p->title = "#delta_{K3#pi}";
	// p->startvalue = DegToRad(235);
	p->startvalue = DegToRad(127);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(360));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(20), DegToRad(180));
	p->bboos = range(DegToRad(150), DegToRad(300)); // D -> Kpipipi

	p = newParameter("kD_k3pi");
	p->title = "#kappa_{K3#pi}";
	p->startvalue = 0.26;
	p->unit = "";
	p->scan = range(0.01, 1);
	p->phys = range(0, 1);
	p->force = range(0.01, 0.8);
	p->bboos = range(0, 1); // D -> Kpipipi

	p = newParameter("rD_kpipi0");
	p->title = "r_{K#pi#pi^{0}}";
	p->startvalue = 0.046;
	p->unit = "";
	p->scan = range(0.035, 0.055);
	p->phys = range(0, 1e4);
	p->force = range(0.001, 0.15);
	p->bboos = range(0.01, 0.15);

	p = newParameter("dD_kpipi0");
	p->title = "#delta_{K#pi#pi^{0}}";
	p->startvalue = DegToRad(164);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(360));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(20), DegToRad(180));
	p->bboos = range(DegToRad(150), DegToRad(300));

	p = newParameter("kD_kpipi0");
	p->title = "#kappa_{K#pi#pi^{0}}";
	p->startvalue = 0.86;
	p->unit = "";
	p->scan = range(0.01, 1);
	p->phys = range(0, 1);
	p->force = range(0.01, 0.8);
	p->bboos = range(0, 1);

	p = newParameter("F_pipipi0");
	p->title = "F_{pipi#pi^{0}}";
	p->startvalue = 0.97;
	p->unit = "";
	p->scan = range(0,1);
	p->phys = range(0,1);
	p->force = range(0,1);
	p->bboos = range(0,1);

	p = newParameter("F_kkpi0");
	p->title = "F_{KK#pi^{0}}";
	p->startvalue = 0.73;
	p->unit = "";
	p->scan = range(0,1);
	p->phys = range(0,1);
	p->force = range(0,1);
	p->bboos = range(0,1);

	p = newParameter("F_pipipipi");
	p->title = "F_{4#pi}";
	p->startvalue = 0.74;
	p->unit = "";
	p->scan = range(0,1);
	p->phys = range(0,1);
	p->force = range(0,1);
	p->bboos = range(0,1);

	p = newParameter("BR_D_Kminus3pi");
	p->title = "BF(D#rightarrowK^{-}3#pi)";
	p->startvalue = 8.29e-2;
	p->unit = "";
	p->scan = range(0.,0.5);
	p->phys = range(0, 1);
	p->force = range(0.01, 0.8);
	p->bboos = range(0, 1);

	p = newParameter("BR_D_Kplus3pi");
	p->title = "BF(D#rightarrowK^{+}3#pi)";
	p->startvalue = 2.6e-4;
	p->unit = "";
	p->scan = range(0.,0.01);
	p->phys = range(0, 1);
	p->force = range(1.e-5,1.e-3);
	p->bboos = range(0, 1);

	p = newParameter("AcpDKK");
	p->title = "#A_{CP}(D #rightarrow KK)";
	p->startvalue = 0.0;
	p->unit = "";
	p->scan = range(-0.1, 0.1);
	p->phys = range(-1, 1);
	p->force = range(-0.1, 0.1);
	p->bboos = range(-0.1, 0.1); // D->KK

	p = newParameter("AcpDpipi");
	p->title = "#A_{CP}(D #rightarrow pipi)";
	p->startvalue = 0.0;
	p->unit = "";
	p->scan = range(-0.1, 0.1);
	p->phys = range(-1, 1);
	p->force = range(-0.1, 0.1);
	p->bboos = range(-0.1, 0.1); // D->pipi

	p = newParameter("AcpDzKstpKm");
	p->title = "#A_{CP}(D^{0} #rightarrow K^{*+}K^{-})";
	p->startvalue = 0.0;
	p->unit = "";
	p->scan = range(-0.1, 0.1);
	p->phys = range(-1, 1);
	p->force = range(-0.1, 0.1);
	p->bboos = range(-0.1, 0.1);

	p = newParameter("AcpDzKstmKp");
	p->title = "#A_{CP}(D^{0} #rightarrow K^{*-}K^{+})";
	p->startvalue = 0.0;
	p->unit = "";
	p->scan = range(-0.1, 0.1);
	p->phys = range(-1, 1);
	p->force = range(-0.1, 0.1);
	p->bboos = range(-0.1, 0.1);

	p = newParameter("rD_k2pi");
	p->title = "r_{K2#pi}";
	p->startvalue = 0.05;
	p->unit = "";
	p->scan = range(0, 0.1);
	p->phys = range(0, 1e4);
	p->force = range(0.001, 0.15);
	p->bboos = range(0, 0.15); // CLEO

	p = newParameter("kD_k2pi");
	p->title = "k_{K2#pi}";
	p->startvalue = 0.84;
	p->unit = "";
	p->scan = range(0, 1);
	p->phys = range(0, 1);
	p->force = range(0.01, 1);
	p->bboos = range(0, 1); // CLEO

	p = newParameter("dD_k2pi");
	p->title = "#delta_{K2#pi}";
	p->startvalue = 3.96;
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(360));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(0), DegToRad(360)); // CLEO

	p = newParameter("rD_kskpi");
	p->title = "r_{KSK#pi}";
	p->startvalue = 0.59;
	p->unit = "";
	p->scan = range(0, 0.1);
	p->phys = range(0, 1e4);
	p->force = range(0.001, 0.15);
	p->bboos = range(0, 0.15);

	p = newParameter("kD_kskpi");
	p->title = "k_{KSK#pi}";
	p->startvalue = 1.0;
	p->unit = "";
	p->scan = range(0, 1);
	p->phys = range(0, 1);
	p->force = range(0.01, 1);
	p->bboos = range(0, 1);

	p = newParameter("dD_kskpi");
	p->title = "#delta_{KSK#pi}";
	p->startvalue = DegToRad(26.);
	p->unit = "Rad";
	p->scan = range(DegToRad(0), DegToRad(360));
	p->phys = range(-7, 7);
	p->force = range(DegToRad(0), DegToRad(90));
	p->bboos = range(DegToRad(0), DegToRad(360));

	p = newParameter("xD");
	p->title = "x_{D}";
	p->startvalue = 4.1e-03;
	p->unit = "";
	p->scan = range(0.002, 0.012);
	p->phys = range(-1, 1);
	p->force = range(0.002, 0.012);
	p->bboos = range(0., 0.016); // D mixing

	p = newParameter("yD");
	p->title = "y_{D}";
	p->startvalue = 6.3e-03;
	p->unit = "";
	p->scan = range(0.002, 0.012);
	p->phys = range(-1, 1);
	p->force = range(0.002, 0.012);
	p->bboos = range(0., 0.016); // D mixing

	p = newParameter("B1");
	p->title = "BR(D #rightarrow K#pi)";
	p->startvalue = 3.89e-02;
	p->unit = "";
	p->scan = range(0.0380, 0.0395);
	p->phys = range(0, 1);
	p->force = range(0.0380, 0.0395);
	p->bboos = range(0.01, 0.05); // CLEO

	p = newParameter("B3");
	p->title = "BR(D #rightarrow K3#pi)";
	p->startvalue = 7.96e-02;
	p->unit = "";
	p->scan = range(0.07, 0.09);
	p->phys = range(0, 1);
	p->force = range(0.07, 0.09);
	p->bboos = range(0.02, 0.3); // CLEO

	p = newParameter("B5");
	p->title = "BR(D #rightarrow K2#pi)";
	p->startvalue = 1.38e-01;
	p->unit = "";
	p->scan = range(0.05, 0.2);
	p->phys = range(0, 1);
	p->force = range(0.05, 0.2);
	p->bboos = range(0.01, 0.6); // CLEO

	p = newParameter("Aprod");
	p->title = "Aprod(Bu)";
	p->startvalue = 0.0;
	p->unit = "";
	p->scan = range(-0.1, 0.1);
	p->phys = range(-1, 1);
	p->force = range(-0.1, 0.1);
	p->bboos = range(-0.1, 0.1);

	p = newParameter("a_gaus");
	p->title = "a_{Gaus}";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-2.5, 2.5);
	p->phys = range(0, 1e4); // to implement a Feldman-Cousins like forbidden region, change this range and use --pr
	p->force = range(-2, 4);
	p->bboos = range(-2, 4);
	p->free = range(-1e4, 1e4);

	p = newParameter("b_gaus");
	p->title = "b_{Gaus}";
	p->startvalue = 0;
	p->unit = "";
	p->scan = range(-2, 4);
	p->phys = range(-1e4, 1e4);
	p->force = range(-2, 4);
	p->bboos = range(-2, 4);

  p = newParameter("B_k3pi_FAV");
  p->title = "B(D#rightarrowK3#pi FAV)";
  p->startvalue = 8.e-02;
  p->unit = "";
  p->scan = range(0.,1.);
  p->phys = range(0.,1.);
  p->force = range(0.,1.);
  p->bboos = range(0.,1.);

  p = newParameter("B_k3pi_SUP");
  p->title = "B(D#rightarrowK3#pi SUP)";
  p->startvalue = 2.65e-04;
  p->unit = "";
  p->scan = range(0.,1.);
  p->phys = range(0.,1.);
  p->force = range(0.,1.);
  p->bboos = range(0.,1.);

  p = newParameter("B_kpipi0_FAV");
  p->title = "B(D#rightarrowK#pi#pi^{0} FAV)";
  p->startvalue = 13.8e-02;
  p->unit = "";
  p->scan = range(0.,1.);
  p->phys = range(0.,1.);
  p->force = range(0.,1.);
  p->bboos = range(0.,1.);

  p = newParameter("B_kpipi0_SUP");
  p->title = "B(D#rightarrowK#pi#pi^{0} SUP)";
  p->startvalue = 3.e-04;
  p->unit = "";
  p->scan = range(0.,1.);
  p->phys = range(0.,1.);
  p->force = range(0.,1.);
  p->bboos = range(0.,1.);

  p = newParameter("B_kpi_FAV");
  p->title = "B(D#rightarrowK#pi FAV)";
  p->startvalue = 4.e-02;
  p->unit = "";
  p->scan = range(0.,1.);
  p->phys = range(0.,1.);
  p->force = range(0.,1.);
  p->bboos = range(0.,1.);

  p = newParameter("B_kpi_SUP");
  p->title = "B(D#rightarrowK#pi SUP)";
  p->startvalue = 1.5e-04;
  p->unit = "";
  p->scan = range(0.,1.);
  p->phys = range(0.,1.);
  p->force = range(0.,1.);
  p->bboos = range(0.,1.);

  // u and v
  p = newParameter("u_dpi");
  p->title = "u^{D#pi}";
  p->startvalue = 0.01;
  p->unit = "";
  p->scan = range(-0.05,0.05);
  p->phys = range(-0.1,0.1);
  p->force = range(-0.1,0.1);
  p->bboos = range(-0.1,0.1);

  p = newParameter("v_dpi");
  p->title = "v^{D#pi}";
  p->startvalue = -0.01;
  p->unit = "";
  p->scan = range(-0.05,0.05);
  p->phys = range(-0.1,0.1);
  p->force = range(-0.1,0.1);
  p->bboos = range(-0.1,0.1);

}
Exemplo n.º 24
0
// read zone file, allowing for zones with or without end dates
bool Zones::read(QFile &file)
{
    defaults_from_user = false;
    scheme.zone_default.clear();
    scheme.zone_default_is_pct.clear();
    scheme.zone_default_name.clear();
    scheme.zone_default_desc.clear();
    scheme.nzones_default = 0;
    ranges.clear();

    // set up possible warning dialog
    warning = QString();
    int warning_lines = 0;
    const int max_warning_lines = 100;

    // macro to append lines to the warning
    #define append_to_warning(s) \
        if (warning_lines < max_warning_lines) \
	    warning.append(s);  \
        else if (warning_lines == max_warning_lines) \
	    warning.append("...\n"); \
        warning_lines ++;

    // read using text mode takes care of end-lines
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        err = "can't open file";
        return false;
    }
    QTextStream fileStream(&file);

    QRegExp commentrx("\\s*#.*$");
    QRegExp blankrx("^[ \t]*$");
    QRegExp rangerx[] = {
        QRegExp("^\\s*(?:from\\s+)?"                                 // optional "from"
                "((\\d\\d\\d\\d)[-/](\\d{1,2})[-/](\\d{1,2})|BEGIN)" // begin date
                "\\s*([,:]?\\s*(FTP|CP)\\s*=\\s*(\\d+))?"            // optional {CP/FTP = integer (optional %)}
                "\\s*:?\\s*$",                                       // optional :
                Qt::CaseInsensitive),
        QRegExp("^\\s*(?:from\\s+)?"                                 // optional "from"
                "((\\d\\d\\d\\d)[-/](\\d{1,2})[-/](\\d{1,2})|BEGIN)" // begin date
                "\\s+(?:until|to|-)\\s+"                             // until
                "((\\d\\d\\d\\d)[-/](\\d{1,2})[-/](\\d{1,2})|END)?"  // end date
                "\\s*:?,?\\s*((FTP|CP)\\s*=\\s*(\\d+))?"          // optional {CP/FTP = integer (optional %)}
                "\\s*:?\\s*$",                                       // optional :
                Qt::CaseInsensitive)
    };
    QRegExp zonerx("^\\s*([^ ,][^,]*),\\s*([^ ,][^,]*),\\s*"
		   "(\\d+)\\s*(%?)\\s*(?:,\\s*(\\d+|MAX)\\s*(%?)\\s*)?$",
		   Qt::CaseInsensitive);
    QRegExp zonedefaultsx("^\\s*(?:zone)?\\s*defaults?\\s*:?\\s*$",
			  Qt::CaseInsensitive);

    int lineno = 0;

    // the current range in the file
    // ZoneRange *range = NULL;
    bool in_range = false;
    QDate begin = date_zero, end = date_infinity;
    int cp=0;
    QList<ZoneInfo> zoneInfos;

    // true if zone defaults are found in the file (then we need to write them)
    bool zones_are_defaults = false;

    while (! fileStream.atEnd() ) {
        ++lineno;
	QString line = fileStream.readLine();
        int pos = commentrx.indexIn(line, 0);
        if (pos != -1)
            line = line.left(pos);
        if (blankrx.indexIn(line, 0) == 0)
	    goto next_line;

	// check for default zone range definition (may be followed by zone definitions)
	if (zonedefaultsx.indexIn(line, 0) != -1) {
	    zones_are_defaults = true;

	    // defaults are allowed only at the beginning of the file
	    if (ranges.size()) {
		err = "Zone defaults must be specified at head of power.zones file";
		return false;
	    }

	    // only one set of defaults is allowed
	    if (scheme.nzones_default) {
		err = "Only one set of zone defaults may be specified in power.zones file";
		return false;
	    }

	    goto next_line;
	}

	// check for range specification (may be followed by zone definitions)
        for (int r=0; r<2; r++) {
                if (rangerx[r].indexIn(line, 0) != -1) {

                        if (in_range) {

                                // if zones are empty, then generate them
                                ZoneRange range(begin, end, cp);
                                range.zones = zoneInfos;

                                if (range.zones.empty()) {
                                        if (range.cp > 0) setZonesFromCP(range);
                                        else {
                                                err = tr("line %1: read new range without reading "
                                                "any zones for previous one").arg(lineno);
                                                file.close();
                                                return false;
                                        }
                                } else {
                                        qSort(range.zones);
                                }
                                ranges.append(range);
                        }

                        in_range = true;
                        zones_are_defaults = false;
                        zoneInfos.clear();

                        // process the beginning date
                        if (rangerx[r].cap(1) == "BEGIN")
                                begin = date_zero;
                        else {
                                begin = QDate(rangerx[r].cap(2).toInt(),
                                rangerx[r].cap(3).toInt(),
                                rangerx[r].cap(4).toInt());
                        }

                        // process an end date, if any, else it is null
                        if (rangerx[r].cap(5) == "END") end = date_infinity;
                        else if (rangerx[r].cap(6).toInt() || rangerx[r].cap(7).toInt() ||
                                 rangerx[r].cap(8).toInt()) {

                                end = QDate(rangerx[r].cap(6).toInt(),
                                rangerx[r].cap(7).toInt(),
                                rangerx[r].cap(8).toInt());

                        } else {
                                end = QDate();
                        }

                        // set up the range, capturing CP if it's specified
                        // range = new ZoneRange(begin, end);
                        int nCP = (r ? 11 : 7);
                        if (rangerx[r].numCaptures() == (nCP)) cp = rangerx[r].cap(nCP).toInt();
                        else cp = 0;

                        // bleck
                        goto next_line;
                }
        }

	// check for zone definition
        if (zonerx.indexIn(line, 0) != -1) {
	    if (! (in_range || zones_are_defaults)) {
		err = tr("line %1: read zone without "
			 "preceding date range").arg(lineno);
		file.close();
		return false;
	    }

	    int lo = zonerx.cap(3).toInt();

	    // allow for zone specified as % of CP
	    bool lo_is_pct = false;
	    if (zonerx.cap(4) == "%") {
		if (zones_are_defaults) lo_is_pct = true;
		else if (cp > 0) lo = int(lo * cp / 100);
		else {
		    err = tr("attempt to set zone based on % of "
			     "CP without setting CP in line number %1.\n").
			arg(lineno);
		    file.close();
		    return false;
		}
            }

	    int hi;
	    // if this is not a zone defaults specification, process possible hi end of zones
	    if (zones_are_defaults || zonerx.cap(5).isEmpty())
		hi = -1;   // signal an undefined number
	    else if (zonerx.cap(5) == "MAX")
		hi = INT_MAX;
	    else {
		hi = zonerx.cap(5).toInt();

		// allow for zone specified as % of CP
		if (zonerx.cap(5) == "%") {
		    if (cp > 0)
			hi = int(hi * cp / 100);
		    else {
			    err = tr("attempt to set zone based on % of CP "
				    "without setting CP in line number %1.\n").
			        arg(lineno);
			    file.close();
			    return false;
		    }
                }
	    }

	    if (zones_are_defaults) {
		scheme.nzones_default ++;
		scheme.zone_default_is_pct.append(lo_is_pct);
		scheme.zone_default.append(lo);
		scheme.zone_default_name.append(zonerx.cap(1));
		scheme.zone_default_desc.append(zonerx.cap(2));
		defaults_from_user = true;
	    }
	    else {
		ZoneInfo zone(zonerx.cap(1), zonerx.cap(2), lo, hi);
		zoneInfos.append(zone);
	    }
	}
    next_line: {}
    }

    if (in_range) {
        ZoneRange range(begin, end, cp);
        range.zones = zoneInfos;
        if (range.zones.empty()) {
            if (range.cp > 0)
	        setZonesFromCP(range);
	    else {
                err = tr("file ended without reading any zones for last range");
                file.close();
                return false;
	    }
        }
	else {
	    qSort(range.zones);
	}

        ranges.append(range);
    }
    file.close();

    // sort the ranges
    qSort(ranges);

    // set the default zones if not in file
    if (!scheme.nzones_default)  {

        // do we have a zone which is explicitly set?
        for (int i=0; i<ranges.count(); i++) {
                if (ranges[i].zonesSetFromCP == false) {
                        // set the defaults using this one!
                        scheme.nzones_default = ranges[i].zones.count();
                        for (int j=0; j<scheme.nzones_default; j++) {
                                scheme.zone_default.append(((double)ranges[i].zones[j].lo / (double)ranges[i].cp) * 100.00);
                                scheme.zone_default_is_pct.append(true);
                                scheme.zone_default_name.append(ranges[i].zones[j].name);
                                scheme.zone_default_desc.append(ranges[i].zones[j].desc);
                        }
                }
        }

        // still not set then reset to defaults as usual
        if (!scheme.nzones_default) initializeZoneParameters();
    }

    // resolve undefined endpoints in ranges and zones
    for (int nr = 0; nr < ranges.size(); nr ++) {
	// clean up gaps or overlaps in zone ranges
	if (ranges[nr].end.isNull())
	    ranges[nr].end =
		(nr < ranges.size() - 1) ?
		ranges[nr + 1].begin :
		date_infinity;
	else if ((nr < ranges.size() - 1) &&
		 (ranges[nr + 1].begin != ranges[nr].end)) {

	    append_to_warning(tr("Setting end date of range %1 "
				 "to start date of range %2.\n").
			      arg(nr + 1).
			      arg(nr + 2)
			      );

	    ranges[nr].end = ranges[nr + 1].begin;
	}
	else if ((nr == ranges.size() - 1) &&
		 (ranges[nr].end < QDate::currentDate())) {

	    append_to_warning(tr("Extending final range %1 to infinite "
				 "to include present date.\n").arg(nr + 1));

	    ranges[nr].end = date_infinity;
	}

        if (ranges[nr].cp <= 0) {
            err = tr("CP must be greater than zero in zone "
                     "range %1 of power.zones").arg(nr + 1);
            return false;
        }

	if (ranges[nr].zones.size()) {
	    // check that the first zone starts with zero
	    ranges[nr].zones[0].lo = 0;

	    // resolve zone end powers
	    for (int nz = 0; nz < ranges[nr].zones.size(); nz ++) {
		if (ranges[nr].zones[nz].hi == -1)
		    ranges[nr].zones[nz].hi =
			(nz < ranges[nr].zones.size() - 1) ?
			ranges[nr].zones[nz + 1].lo :
			INT_MAX;
		else if ((nz < ranges[nr].zones.size() - 1) &&
			 (ranges[nr].zones[nz].hi != ranges[nr].zones[nz + 1].lo)) {
		    if (abs(ranges[nr].zones[nz].hi - ranges[nr].zones[nz + 1].lo) > 4) {
			append_to_warning(tr("Range %1: matching top of zone %2 "
					     "(%3) to bottom of zone %4 (%5).\n").
					  arg(nr + 1).
					  arg(ranges[nr].zones[nz].name).
					  arg(ranges[nr].zones[nz].hi).
					  arg(ranges[nr].zones[nz + 1].name).
					  arg(ranges[nr].zones[nz + 1].lo)
					  );
                    }
		    ranges[nr].zones[nz].hi = ranges[nr].zones[nz + 1].lo;

		} else if ((nz == ranges[nr].zones.size() - 1) &&
			 (ranges[nr].zones[nz].hi < INT_MAX)) {

		    append_to_warning(tr("Range %1: setting top of zone %2 from %3 to MAX.\n").
				      arg(nr + 1).
				      arg(ranges[nr].zones[nz].name).
				      arg(ranges[nr].zones[nz].hi)
				      );
		    ranges[nr].zones[nz].hi = INT_MAX;
		}
            }
	}
    }

    // mark zones as modified so pages which depend on zones can be updated
    modificationTime = QDateTime::currentDateTime();

    return true;
}
Exemplo n.º 25
0
ChunkMoppDemo::ChunkMoppDemo(hkDemoEnvironment* env)
	:	hkDefaultPhysicsDemo(env)
{
	//setGraphicsState(HKG_ENABLED_WIREFRAME, true);	
	//
	// Setup the camera
	//
	{
		hkVector4 from(55.0f, 50.0f, 55.0f);
		hkVector4 to  ( 0.0f,  0.0f,   0.0f);
		hkVector4 up  ( 0.0f,  1.0f,   0.0f);
		setupDefaultCameras(env, from, to, up, 0.1f, 20000.0f);
	}

	//
	// Create the world
	//
	{
		hkpWorldCinfo worldInfo;
		{
			worldInfo.m_gravity.set(0.0f, -9.81f, 0.0f);
			worldInfo.setBroadPhaseWorldSize(10000.0f);
			worldInfo.setupSolverInfo( hkpWorldCinfo::SOLVER_TYPE_4ITERS_MEDIUM );
			worldInfo.m_enableDeactivation = false;
		}
		m_world = new hkpWorld(worldInfo);
		m_world->lock();

		// Register ALL agents (though some may not be necessary)
		hkpAgentRegisterUtil::registerAllAgents(m_world->getCollisionDispatcher());

		setupGraphics();
	}

	hkpShapeCollection* meshShape = createMeshShape( VERTS_PER_SIDE, m_delayedCleanup );
	m_shape = createMoppShape( meshShape, true );
	m_shape->getAabb( hkTransform::getIdentity(), 0.1f, m_bounds );

	//
	//  create the ground mopp
	//
	{

		hkpRigidBodyCinfo terrainInfo;
		{
			hkVector4 size(100.0f, 1.0f, 100.0f);

			terrainInfo.m_shape = m_shape;
			terrainInfo.m_motionType = hkpMotion::MOTION_FIXED;
			terrainInfo.m_friction = 0.5f;

			hkpRigidBody* terrainBody = new hkpRigidBody(terrainInfo);
			m_world->addEntity(terrainBody);
			terrainBody->removeReference();	
		}
		terrainInfo.m_shape->removeReference();
	}

	hkVector4 halfExtents;
	hkVector4 centre;
	{
		m_bounds.getHalfExtents( halfExtents );
		m_bounds.getCenter( centre );

		m_minIndex = (halfExtents(0) < halfExtents(1)) ? 
			((halfExtents(0) < halfExtents(2)) ? 0 : 2) :
			((halfExtents(1) < halfExtents(2)) ? 1 : 2) ;
	}

	// Setup the camera
	{
		hkVector4 up; up.setZero4();
		up(m_minIndex) = 1.0f;

		hkVector4 from; from.setAddMul4( m_bounds.m_max, up, 5.0f);
		setupDefaultCameras(env, from, centre, up, 0.1f, 10000.0f);
	}

	//
	// Create objects at random coordinates
	//
	{
		hkVector4 size(0.5f, 0.5f, 0.5f);
		hkpBoxShape* boxShape =  new hkpBoxShape(size);

		hkpRigidBodyCinfo boxInfo;
		{
			boxInfo.m_mass = 1.0f;
			boxInfo.m_shape = boxShape;
			boxInfo.m_motionType = hkpMotion::MOTION_BOX_INERTIA;
		}

		hkPseudoRandomGenerator random(15);

		//
		// create the boxes
		//
		{
			hkVector4 range; range.setSub4( m_bounds.m_max, m_bounds.m_min );
			range.mul4( 1.0f );
			
			const int numObjects = 500;
			for (int i = 0; i < numObjects; i++)
			{
				hkVector4 pos; random.getRandomVector11(pos);
				pos.mul4(0.1f);
				pos.mul4(range);
				pos( m_minIndex ) += m_bounds.m_max( m_minIndex ) + i * (range(m_minIndex)) / numObjects + 4.0f;

				boxInfo.m_position = pos;
				hkpRigidBody* shape;
				shape = new hkpRigidBody(boxInfo);
				
				shape->setMaxLinearVelocity( 30 );
				m_world->addEntity(shape);
				shape->removeReference();
			}
		}

		boxShape->removeReference();
	}

	m_world->unlock();

	m_time = 0.0f;
}
Exemplo n.º 26
0
 constexpr auto count(T start, T step) noexcept {
   // if step is < 0, set the stop to numeric min, otherwise numeric max
   T stop = step < T(0) ? std::numeric_limits<T>::min()
                        : std::numeric_limits<T>::max();
   return range(start, stop, step);
 }
Exemplo n.º 27
0
Arquivo: Panner.C Projeto: 0mk/non
void
Panner::draw ( void )
{
    int tw, th, tx, ty;

    bbox( tx, ty, tw, th );

    fl_push_clip( x(),y(),w(),h() );

    draw_the_box( tx, ty, tw, th );

//    draw_box();
    draw_label();

    /* if ( _bypassed ) */
    /* { */
    /*     draw_box(); */
    /*     fl_color( 0 ); */
    /*     fl_font( FL_HELVETICA, 12 ); */
    /*     fl_draw( "(bypass)", x(), y(), w(), h(), FL_ALIGN_CENTER ); */
    /*     goto done; */
    /* } */
   
    /* tx += b; */
    /* ty += b; */
    /* tw -= b * 2; */
    /* th -= b * 2; */

    fl_line_style( FL_SOLID, 1 );

    fl_color( FL_WHITE );

    for ( unsigned int i = 0; i < _points.size(); i++ )
    {
        Point *p = &_points[i];

        if ( ! p->visible )
            continue;

        Fl_Color c = fl_color_add_alpha( p->color, 100 );

        fl_color(c);

        int px, py, pw, ph;
        point_bbox( p, &px, &py, &pw, &ph );
      
        {
            float po = 5;

            fl_push_clip( px - ( po * 12 ), 
                          py - ( po * 12 ),
                          pw + ( po * 24 ), ph + (po * 24 ));

            fl_pie( px + 5, py + 5, pw - 10, ph - 10, 0, 360 );


            fl_pie( px, py, pw, ph, 0, 360 );

            fl_pop_clip();

            if ( projection() == POLAR )
            {
           
                fl_color( fl_color_average( fl_rgb_color( 127,127,127 ), p->color, 0.50 ) );
                fl_begin_loop();
                fl_circle( tx + tw/2, ty + th/2, tw/2.0f * ( ( p->radius() / range() )));
                fl_end_loop();
            }

        }
    
        const char *s = p->label;

        fl_color( fl_color_add_alpha( fl_rgb_color( 220,255,255 ), 127 ) );
        fl_font( FL_HELVETICA_BOLD_ITALIC, 10 );
        fl_draw( s, px + 20, py + 1, 50, ph - 1, FL_ALIGN_LEFT );

        if ( tw > 100 )
        {
            char pat[50];
            snprintf( pat, sizeof(pat), "%.1f°:%.1f° %.1fm", p->azimuth(), p->elevation(), p->radius() );
            
//        fl_color( fl_color_add_alpha( fl_rgb_color( 220,255,255 ), 127 ) );
            fl_font( FL_COURIER, 9 );

            fl_draw( pat, px + 20, py + 15, 50, ph - 1, FL_ALIGN_LEFT | FL_ALIGN_WRAP );

            /* fl_font( FL_HELVETICA_ITALIC, 9 ); */
            /* snprintf(pat, sizeof(pat), "range: %.1f meters", range() ); */
            /* fl_draw( pat, tx, ty, tw, th, FL_ALIGN_LEFT | FL_ALIGN_BOTTOM | FL_ALIGN_INSIDE ); */
                
            /* if ( _projection == POLAR ) */
            /* { */
            /*     fl_draw( "Polar perspective; azimuth, elevation and radius input. Right click controls radius.", tx, ty, tw, th, FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT | FL_ALIGN_INSIDE ); */
            /* } */
            /* else */
            /* { */
            /*     fl_draw( "Polar orthographic; angle and distance input.", tx, ty, tw, th, FL_ALIGN_BOTTOM | FL_ALIGN_RIGHT | FL_ALIGN_INSIDE ); */
            /* } */
        }

    }
    
    if ( tw > 200 )
        draw_children();

    fl_line_style( FL_SOLID, 0 );

    fl_pop_clip();
}
Exemplo n.º 28
0
	/**
	*	@brief	Range in bytes of buffer view
	*/
	auto range_bytes() const { return range() * buffer->get_element_size_bytes(); }
Exemplo n.º 29
0
	// return 0 to do nothing
	// return 1 to play last_state
	// return 2 to play silence
	int update( _DataType control_bit )
	{
		__DEBUG__NORMAL__ printf( "%u: Updating %s\n", timer_counter, GAUtil::Str<_DataType>::str( control_bit ).c_str() );

		int result = 0;
		bool do_commit = false;
		switch ( control_bit.toggle_type )
		{
		//bool - toggle if( value )
		case AudioBitEncodings::commit:
			do_commit = control_bit.toggle_value;
			if ( do_commit ) __DEBUG__NORMAL__ printf( "Saving current state:\n%s\n", state.toString().c_str() );
			// save our current state for reference; start making changes to our new state
			last_state = state;
			has_previous_state = true;
			break;
		case AudioBitEncodings::key_rotate:
			state.key_index += control_bit.toggle_value ? 1 : -1;
			range( state.key_index, (int) 0, (int) 12, true );
			__DEBUG__NORMAL__ printf( "Updated key_index: %u\n", state.key_index );
			break;
		case AudioBitEncodings::key_flip:
			if ( control_bit.toggle_value ) state.key_is_major = !state.key_is_major;
			__DEBUG__NORMAL__ printf( "Updated key_is_major: %u\n", state.key_is_major );
			break;

			// int - increment by value
		case AudioBitEncodings::duration:
			state.duration_index += control_bit.toggle_value;
			range( state.duration_index, (int) 0, (int) 4 );
			__DEBUG__NORMAL__ printf( "Updated duration_index: %u\n", state.duration_index );
			break;
		case AudioBitEncodings::time:
			state.beat_frequency_index += control_bit.toggle_value;
			range( state.beat_frequency_index, (int) 0, (int) 3 );
			__DEBUG__NORMAL__ printf( "Updated beat_frequency_index: %u\n", state.beat_frequency_index );
			break;
		case AudioBitEncodings::pitch:
			state.pitch_index += control_bit.toggle_value;
			range( state.pitch_index, (int) 21, (int) 68 );
			__DEBUG__NORMAL__ printf( "Updated pitch_index: %u\n", state.pitch_index );
			break;
		}

		if ( timer_enabled ) ++timer_counter;
		if ( timer_counter == timer_max ) timer_enabled = false;

		if ( !has_previous_state ) return 0;

		// commit reached
		if ( do_commit )
		{
			// our counter now contains the number of cycles for which we should play silence
			if ( counting_silence )
			{
				result = 2;
				last_note_duration = timer_counter;
				__DEBUG__NORMAL__ printf( "We should play silence for %u cycles\n", last_note_duration );
			}
			// we interrupted playback of the previous note; our counter shows how many cycles we should play it for
			else
			{
				result = 1;
				last_note_duration = timer_counter;
				__DEBUG__NORMAL__ printf( "Note interrupted. We should play sound for %u cycles\n", last_note_duration );
			}

			// start a timer to count the number of cycles the current note is active
			startTimer( getDuration( state.duration_index ) );
		}
		// we timed out, store how long we were playing the note for and start tracking how long we should play silence
		else if ( !timer_enabled )
		{
			result = 1;
			counting_silence = true;
			last_note_duration = timer_counter;
			__DEBUG__NORMAL__ printf( "Note finished playing normally. We should play sound for %u cycles\n", last_note_duration );
			startTimer();
		}

		return result;
	}
Exemplo n.º 30
0
 ::Spacy::Vector C1Operator::d1( const ::Spacy::Vector& x, const ::Spacy::Vector& dx ) const
 {
     return Vector( derivative_( cast_ref< Vector >( x ).get() ) *
                        cast_ref< Vector >( dx ).get(),
                    range() );
 }