Exemplo n.º 1
0
void rspfFilter::createMatrix(NEWMAT::Matrix& m,
                               long width,
                               double middle,
                               double scale)const
{
   NEWMAT::ColumnVector colVec(width);
   NEWMAT::RowVector    rowVec(width);

   double t = 0.0;
   double val = 0.0;
   if(width == 1)
   {
      t = 0;
      val = filter(t, getSupport());
      colVec[0] = val;
      rowVec[0] = val;
   }
   else
   {
      for(long index = 0; index < width; index++)
      {
         t = (double)index/(double)(width-1);
         t = middle + (t - .5)*scale;
         val = filter(t, getSupport());
         colVec[index] = val;
         rowVec[index] = val;
      }
   }

   // do the outer product to construct the
   // filter matrix
   m = colVec * rowVec;
}
Exemplo n.º 2
0
bool Film::operator == (const Film& f)
{
    return ((this->AbstractMedia::operator ==(f)) &&
            (getRealisateur() == f.getRealisateur()) &&
            (getScenariste() == f.getScenariste()) &&
            (getActeursPrincipaux() == f.getActeursPrincipaux()) &&
            (getType() == f.getType()) &&
            (getDuree() == f.getDuree()) &&
            (getSupport() == f.getSupport()));
}
Exemplo n.º 3
0
//**************************************************************************************************
ossimRefPtr<ossimImageData> ossimScaleFilter::getTile(
   const ossimIrect& tileRect, ossim_uint32 resLevel)
{
   
   if((!isSourceEnabled())||
      (!theInputConnection)||
      ((m_ScaleFactor.x == 1.0)&&
       (m_ScaleFactor.y == 1.0)&&
       (m_BlurFactor == 1.0)))
   {
      return ossimImageSourceFilter::getTile(tileRect, resLevel);
   }
   if(!m_Tile.valid())
   {
      allocate();
   }

   if(!m_Tile)
   {
      return ossimImageSourceFilter::getTile(tileRect, resLevel);
   }

   m_Tile->makeBlank();

                       
   ossimIrect imageRect = tileRect*m_InverseScaleFactor;

   m_Tile->setImageRectangle(tileRect);
   m_BlankTile->setImageRectangle(tileRect);


   double xSupport;
   double ySupport;

   getSupport(xSupport, ySupport);
   
   ossimIpt deltaPt;
   deltaPt.x = (ossim_int32)ceil(xSupport);
   deltaPt.y = (ossim_int32)ceil(ySupport);

   imageRect = ossimIrect(imageRect.ul().x - (deltaPt.x),
                          imageRect.ul().y - (deltaPt.y),
                          imageRect.lr().x + (deltaPt.x),
                          imageRect.lr().y + (deltaPt.y));

   
   runFilter(imageRect, tileRect);
   
   m_Tile->validate();
   
   return m_Tile;
}
Exemplo n.º 4
0
bool VACBinaryConstraint::revise (VACVariable* var, Value v) {
  bool wipeout = false;
  VACVariable* xi = (VACVariable*) getVar(0);
  VACVariable* xj = (VACVariable*) getVar(1);
  Value sup = getSupport(var,v);
  Value minsup = sup;
  if(var != xi) {  xi = (VACVariable*)getVar(1); xj = (VACVariable*)getVar(0); }
  Cost cost, minCost = wcsp->getUb();

  if(xj->canbe(sup)) {
	  if(xj->getVACCost(sup) != MIN_COST) { wipeout = xj->removeVAC(sup);  }
	  else {
		  if (getVACCost(xi,xj,v,sup) == MIN_COST) {
		    return false;
		  }
	  }
  }

  for (EnumeratedVariable::iterator it = xj->lower_bound(sup); it != xj->end(); ++it) {
	  Value w = *it;
	  if(xj->getVACCost(w) != MIN_COST) { wipeout = xj->removeVAC(w); xj->queueVAC(); }
	  else {
	      cost = getVACCost(xi,xj,v, w);
	      if (cost == MIN_COST) {
	      	setSupport(xi,v,w);
	        return false;
	      } else if (cost < minCost) {
	      	  minCost = cost;
	          minsup = w;
	      }
	  }
  }
  for (EnumeratedVariable::iterator it = xj->begin(); it != xj->lower_bound(sup); ++it) {
	  Value w = *it;
	  if(xj->getVACCost(w) != MIN_COST) { wipeout = xj->removeVAC(w); xj->queueVAC(); }
	  else {
	      cost = getVACCost(xi,xj,v, w);
	      if (cost == MIN_COST) {
	      	setSupport(xi,v,w);
	        return false;
	      } else if (cost < minCost) {
	      	  minCost = cost;
	          minsup = w;
	      }
	  }
  }

  setSupport(xi,v,minsup);
  return true;
}
Exemplo n.º 5
0
QLabel * ColumnarTableWidget::createLabel(const QString & text,const QString & style) const {
  //
  /// remove line breaks and leading/trailing spaces
  QString str = text.trimmed();
  str = str.replace(QRegularExpression("\\r|\\n")," ");

  QLabel * l;
  if (! style.isEmpty()) {
    l = new QLabel(getSupport()->scanAndStyle(str,style));
  }
  else {
    l = new QLabel(str);
  }
  return l;
}
Exemplo n.º 6
0
void Film::sauvegarde(QXmlStreamWriter & stream)
{
    qDebug()<<"Sauvegade de "<<nom();
    stream.writeStartElement("media");
    stream.writeTextElement("nom", nom());
    stream.writeTextElement("genre", genre());
    stream.writeTextElement("date", date().toString("d/M/yyyy"));
    stream.writeTextElement("vue", QString::number(isFini()));
    stream.writeTextElement("url", url().toString());
    stream.writeTextElement("type", getType());
    stream.writeTextElement("realisateur", getRealisateur());
    stream.writeTextElement("scenariste", getScenariste());
    stream.writeTextElement("support", QString::number(getSupport()));
    stream.writeTextElement("duree", getDuree().toString());

    foreach(QString jupiter, getActeursPrincipaux())
    {
        stream.writeTextElement("acteur", jupiter);
    }
Exemplo n.º 7
0
NEWMAT::RowVector *rspfFilter::newVector(long width,
                                          double middle,
                                          double scale)const
{
   NEWMAT::RowVector *result = new NEWMAT::RowVector(width);


   double t = 0.0;
   double val = 0.0;
   for(long index = 0; index < width; index++)
   {
      t = (double)index/(double)(width-1);
      t = middle + (t- .5)*scale;
      val = filter(t, getSupport());
      (*result)[index] = val;
   }

   return result;
}
Exemplo n.º 8
0
void VACVariable::VACextend (Value v, const Cost c) {
  decreaseCost(v,c);
  if (v == maxCostValue) queueNC();
  assert(canbe(getSupport()));
//   if(cannotbe(getSupport()) || getCost(getSupport())>MIN_COST) { // TO BE REMOVED ???
//     Value newSupport = getInf();
//     Cost minCost = getCost(newSupport);
//     EnumeratedVariable::iterator iter = begin();
//     for (++iter; minCost > MIN_COST && iter != end(); ++iter) {
//         Cost cost = getCost(*iter);
//         if (cost < minCost) {
//             minCost = cost;
//             newSupport = *iter;
//         }
//     }
// 	assert(canbe(newSupport));
// 	//	cout << "setsupport " << wcspIndex << " " << newSupport << endl;
// 	setSupport(newSupport);
//   } 
}
Exemplo n.º 9
0
void MtxLP::getSupport(strvec& support, int kind) const{
    strvec cnames = getColNames(kind);
    getSupport(support, cnames, kind);
}
Exemplo n.º 10
0
bool SteerLib::GJK_EPA::EPA(std::vector<Util::Vector> shape1, std::vector<Util::Vector> shape2, std::vector<Util::Vector> simplex, float& depth, Util::Vector& mtv) {
	
	float DEPTHTOLERANCE = .01f;

	while(true) { //CONDITION?
		int index = simplex.size()-1;
	
		float penDepth;
		Util::Vector addSimplex;
	
		float closest;
		Util::Vector closestVector;
		Util::Vector edge;

		edge = simplex[index] - simplex[0];
		closestVector = tripleProduct(edge, simplex[index], edge);
		//std::cout << closestVector;
		closestVector = closestVector / closestVector.norm(); //normalize vector
		//std::cout << closestVector << std::endl;
		closest = dotProduct(simplex[index], closestVector);

		for(int i=0; i < simplex.size()-1; i++) {
			//std::cout << simplex.size() << std::endl;
			//std::cout << simplex[i] << std::endl;
			Util::Vector testVector;
			float testDepth;
			
			edge = simplex[i+1] - simplex[i];
			testVector = tripleProduct(edge, simplex[i], edge);
			//std::cout << testVector;
			testVector = testVector / testVector.norm(); //normalize vector
			//std::cout << testVector << std::endl;
			testDepth = dotProduct(simplex[i], testVector);

			if(testDepth < closest) {
				closest = testDepth;
				closestVector = testVector;
				index = i;	
			}
		}

		addSimplex = getSupport(shape1, closestVector) - getSupport(shape2, closestVector*-1);
		penDepth = dotProduct(addSimplex, closestVector);

		//std::cout << closestVector << addSimplex << std::endl << std::endl;
		if(penDepth <= DEPTHTOLERANCE) {
			depth = penDepth;
			mtv = closestVector;
			return true;
		}
		

		if(index == simplex.size()-1) {
			if(simplex[simplex.size()-1] == addSimplex || simplex[0] == addSimplex) {
				depth = penDepth;
				mtv = closestVector;
				return true;
			}
			simplex.push_back(addSimplex);
		}
		else {
			std::vector<Util::Vector>::iterator it = simplex.begin();
			for(int i=0; i <= index; i++) {
				it++;
			}
			//std::cout << *it << std::endl;
			if(*it == addSimplex || (*(it-1) == addSimplex)) {
				depth = penDepth;
				mtv = closestVector;
				return true;
			}
			simplex.insert(it, addSimplex);
		}
	}
}
Exemplo n.º 11
0
bool SteerLib::GJK_EPA::GJK(std::vector<Util::Vector> shape1, std::vector<Util::Vector> shape2, std::vector<Util::Vector>& simplex) {
	
	std::vector<std::vector<Util::Vector>> decomp1, decomp2;
	convexDecomp(decomp1, shape1);
	convexDecomp(decomp2, shape2);
	
	for(int i=0; i<decomp1.size(); i++) {
		for(int j=0; j<decomp2.size(); j++) {
			/*for(int k=0; k<decomp1.at(i).size(); k++) {
						std::cout << decomp1.at(i).at(k) << " ";
					}
					std::cout << std::endl;
					for(int k=0; k<decomp2.at(j).size(); k++) {
						std::cout << decomp2.at(j).at(k) << " ";
					}
			std::cout << std::endl;*/

			Util::Vector v1, v2, v3;
			Util::Vector arbitraryVector =  Util::Vector(1,0,0);

			//pick point on Minkowski difference
			v1 = getSupport(decomp1.at(i), arbitraryVector) - getSupport(decomp2.at(j), arbitraryVector*-1);
			//std::cout << getSupport(decomp1.at(i), arbitraryVector) << "  " << getSupport(decomp2.at(j), arbitraryVector*-1) << std::endl;
			//std::cout << v1 << std::endl;
			//projection along v1 closest to origin
			arbitraryVector = v1*-1;
			v2 = getSupport(decomp1.at(i), arbitraryVector) - getSupport(decomp2.at(j), arbitraryVector*-1);
			//std::cout << v2 << std::endl;
			if(dotProduct(v2, arbitraryVector) <= 0) { //point added to simplex does not pass the origin, no intersect
				continue;
			}

			//find new vertex for simplex in direction of the origin
			arbitraryVector = tripleProduct(v1-v2, v2*-1, v1-v2);
			//std::cout << "new normal " << arbitraryVector << std::endl;
			if(arbitraryVector == Util::Vector(0,0,0)) { //these points are aligned with the origin
				float tempDot = dotProduct(v2-v1, v1*-1);
				float squaredLength = (v2.x-v1.x)*(v2.x-v1.x) + (v2.z-v1.z)*(v2.z-v1.z);
				if(tempDot < 0 || tempDot > squaredLength) //origin is not between the points, no intersect
					continue;
			}
			v3 = getSupport(decomp1.at(i), arbitraryVector) - getSupport(decomp2.at(j), arbitraryVector*-1);
			//std::cout << v3 << std::endl;
			
			while(true) { //CONDITION?
				//if(fabsf(v2.length() - v3.length()) <= EQUIVALENCERANGE || v1.length() - v3.length() <= EQUIVALENCERANGE) {
				if(v2 == v3 || v1 == v3) { //if the vertex closest to the origin is already in the simplex, no intersect
					break;
				}

				//std::cout << dotProduct(v3, arbitraryVector) << " " << " " << std::endl;
				if(dotProduct(v3, arbitraryVector) <= 0) //new point for simplex does not pass the origin, no intersect
					break;

				/*float findOrigin1, findOrigin2; //used to determine what partition of the extended edge minkowski difference that the origin is in
				findOrigin1 = dotProduct(v1-v3, v3*-1);
				std::cout << v1-v3 << std::endl;
				findOrigin2 = dotProduct(v2-v3, v3*-1);
				if(findOrigin1<0 && findOrigin2<0) //origin is outside simplex, no intersect
					break;
				else if(findOrigin1>=0 && findOrigin2>=0) { //origin is in simplex, shapes intersect
					std::vector<Util::Vector> returnSimplex;
					returnSimplex.push_back(v1);
					returnSimplex.push_back(v2);
					returnSimplex.push_back(v3);
					simplex = returnSimplex;
					std::cout << v1 << v2 << v3 << std::endl;
					for(int k=0; k<decomp1.at(i).size(); k++) {
						std::cout << decomp1.at(i).at(k) << " ";
					}
					std::cout << std::endl;
					for(int k=0; k<decomp2.at(j).size(); k++) {
						std::cout << decomp2.at(j).at(k) << " ";
					}

					return true;
				}

				if(findOrigin1>=0 && findOrigin2<0) { //keep v1, discard v2
					v2 = v3;
				}
				else if(findOrigin1<0 && findOrigin2>=0) { //keep v2, discard v1
					v1 = v2;
					v2 = v3;
				}*/
				Util::Vector edge1, edge2;
				edge1 = v1-v3;
				edge2 = v2-v3;
				Util::Vector edge1Perp, edge2Perp;
				edge1Perp = Util::Vector(edge1.z*-1, 0, edge1.x);
				if(edge1Perp * edge2 > 0)
					edge1Perp = Util::Vector(edge1.z, 0, edge1.x*-1);
				edge2Perp = Util::Vector(edge2.z*-1, 0, edge2.x);
				if(edge2Perp * edge1 > 0)
					edge2Perp = Util::Vector(edge2.z, 0, edge2.x*-1);
				Util::Vector findOrigin1, findOrigin2;
				//std::cout << v1<<v2<<v3<< std::endl;
				findOrigin1 = edge1Perp;
				findOrigin2 = edge2Perp;
				/*findOrigin1 = tripleProduct(v1-v3, v2-v3, v2-v3);
				findOrigin2 = tripleProduct(v2-v3, v1-v3, v1-v3);*/
				//std::cout << findOrigin1 << " " << findOrigin2 << std::endl;
				if(findOrigin1*(v3*-1)<=0 && findOrigin2*(v3*-1)<=0) { //simplex contains origin, intersects
					std::vector<Util::Vector> returnSimplex;
					returnSimplex.push_back(v1);
					returnSimplex.push_back(v2);
					returnSimplex.push_back(v3);
					simplex = returnSimplex;
					std::cout << v1 << v2 << v3 << std::endl;
					/*for(int k=0; k<decomp1.at(i).size(); k++) {
						std::cout << decomp1.at(i).at(k) << " ";
					}
					std::cout << std::endl;
					for(int k=0; k<decomp2.at(j).size(); k++) {
						std::cout << decomp2.at(j).at(k) << " ";
					}*/

					return true;

				}
				else if(findOrigin1*(v3*-1)>0 && findOrigin2*(v3*-1)>0) {
					break;
				}
				else if(findOrigin1*(v3*-1)>0) {
					v2 = v3;
				}
				else {
					v1 = v2;
					v2 = v3;
				}

				arbitraryVector = tripleProduct(v1-v2, v2*-1, v1-v2);
				v3 = getSupport(decomp1.at(i), arbitraryVector) - getSupport(decomp2.at(j), arbitraryVector*-1);

				//std::cout << v1 << v2 << v3 << std::endl;
			}
		}
	}
	return false;
}
Exemplo n.º 12
0
void BattleItem::update(GameState &state, unsigned int ticks)
{
	item->update(state, ticks);
	// May have exploded
	if (!tileObject)
	{
		return;
	}

	if (ticksUntilCollapse > 0)
	{
		if (ticksUntilCollapse > ticks)
		{
			ticksUntilCollapse -= ticks;
		}
		else
		{
			ticksUntilCollapse = 0;
			collapse();
		}
	}

	if (!falling)
	{
		return;
	}

	if (ownerInvulnerableTicks > 0)
	{
		if (ownerInvulnerableTicks > ticks)
		{
			ownerInvulnerableTicks -= ticks;
		}
		else
		{
			ownerInvulnerableTicks = 0;
		}
	}

	if (collisionIgnoredTicks > 0)
	{
		if (collisionIgnoredTicks > ticks)
		{
			collisionIgnoredTicks -= ticks;
		}
		else
		{
			collisionIgnoredTicks = 0;
		}
	}

	int remainingTicks = ticks;

	auto previousPosition = position;
	auto newPosition = position;

	while (remainingTicks-- > 0)
	{
		velocity.z -= FALLING_ACCELERATION_ITEM;
		newPosition += this->velocity / (float)TICK_SCALE / VELOCITY_SCALE_BATTLE;
	}

	// Check if new position is valid
	// FIXME: Collide with units but not with us
	bool collision = false;
	auto c = checkItemCollision(previousPosition, newPosition);
	if (c)
	{
		collision = true;
		// If colliding with anything but ground, bounce back once
		switch (c.obj->getType())
		{
			case TileObject::Type::Unit:
			case TileObject::Type::LeftWall:
			case TileObject::Type::RightWall:
			case TileObject::Type::Feature:
				if (!bounced)
				{
					// If bounced do not try to find support this time
					collision = false;
					bounced = true;
					newPosition = previousPosition;
					velocity.x = -velocity.x / 4;
					velocity.y = -velocity.y / 4;
					velocity.z = std::abs(velocity.z / 4);
					break;
				}
			// Intentional fall-through
			case TileObject::Type::Ground:
				// Let item fall so that it can collide with scenery or ground if falling on top of
				// it
				newPosition = {previousPosition.x, previousPosition.y,
				               std::min(newPosition.z, previousPosition.z)};
				break;
			default:
				LogError("What the hell is this item colliding with? Type is %d",
				         (int)c.obj->getType());
				break;
		}
	}

	// If moved but did not find support - check if within level bounds and set position
	if (newPosition != previousPosition)
	{
		auto mapSize = this->tileObject->map.size;

		// Collision with ceiling
		if (newPosition.z >= mapSize.z)
		{
			collision = true;
			newPosition.z = mapSize.z - 0.01f;
			velocity = {0.0f, 0.0f, 0.0f};
		}
		// Collision with map edge
		if (newPosition.x < 0 || newPosition.y < 0 || newPosition.y >= mapSize.y ||
		    newPosition.x >= mapSize.x || newPosition.y >= mapSize.y)
		{
			collision = true;
			velocity.x = -velocity.x / 4;
			velocity.y = -velocity.y / 4;
			velocity.z = 0;
			newPosition = previousPosition;
		}
		// Fell below 0???
		if (newPosition.z < 0)
		{
			LogError("Item at %f %f fell off the end of the world!?", newPosition.x, newPosition.y);
			die(state, false);
			return;
		}
		setPosition(newPosition);
	}

	if (collision)
	{
		if (findSupport())
		{
			getSupport();
			auto tile = tileObject->getOwningTile();
			if (tile->objectDropSfx)
			{
				fw().soundBackend->playSample(tile->objectDropSfx, getPosition(), 0.25f);
			}
		}
	}
}