//void itsHybridContinuousInteractingAntColony::addAnt( vector<double> aPoint, vector<double> aMoveRange, double aProbaUseMemory )
void itsHybridContinuousInteractingAntColony::addAnt( vector<double> aPoint, double aMoveRange, double aProbaUseMemory )
{
  // variables
  antProbaMemory.push_back( aProbaUseMemory );
  //antMoveRange.push_back( aMoveRange );
  antMoveRange.push_back( aMoveRange );
  antCurrentPoint.push_back( aPoint );
  
  // initialisations
  itsPoint p;
  p.setSolution( aPoint );
  antCurrentValue.push_back( evaluate( p ).getValues()[0] );
  antState.push_back( 0 );

  // ini piles messages
  vector<double> nullValuesStack;
  double nullValue = 0;
  nullValuesStack.push_back( nullValue );
  antIncomingValues.push_back( nullValuesStack );

  vector< vector<double> > nullPointsStack;
  vector<double> nullPoint( this->getProblem()->getDimension(), 0 );
  nullPointsStack.push_back( nullPoint );
  antIncomingPoints.push_back( nullPointsStack );
}
Ejemplo n.º 2
0
void parseTriangle(GLfloat refractIndex){
    char * token;
    ShapeData parsedShape;

    parsedShape.type = TRIANGLE;

    /*Coordinates of vertex 1*/
    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[0].x = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 1 'x' position.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[0].y = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 1 'y' position.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[0].z = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 1 'z' position.\n", globals.numberOfShapes);
        return;
    }


    /*Coordinates of vertex 2*/
    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[1].x = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 2 'x' position.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[1].y = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 2 'y' position.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[1].z = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 2 'z' position.\n", globals.numberOfShapes);
        return;
    }


    /*Coordinates of vertex 3*/
    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[2].x = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 3 'x' position.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[2].y = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 3 'y' position.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.theShape.triangle.points[2].z = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Vertex 3 'z' position.\n", globals.numberOfShapes);
        return;
    }


    /*Colour*/
    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.colour.red = (GLfloat)atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Red colour amount.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.colour.green = (GLfloat)atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Green colour amount.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.colour.blue = (GLfloat)atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Blue colour amount.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.reflectivity = atof(token);
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Reflectivity.\n", globals.numberOfShapes);
        return;
    }

    token = strtok(NULL, PARSE_DELIMITERS);
    if(token != NULL){
        parsedShape.opacity = atof(token);

        token = strtok(NULL, PARSE_DELIMITERS);
        if(token != NULL){
            parsedShape.refractionIndex = atof(token);
        }
        else{
            printf("Warning: Missing parameter for shape %d (triangle): Index of Refraction.\n", globals.numberOfShapes);
            printf("Setting to default: Air refraction index\n");
            parsedShape.refractionIndex = AIR_REFRACTION_INDEX;
        }
    }
    else{
        printf("Parse error: Missing parameter for shape %d (triangle): Opacity.\n", globals.numberOfShapes);
        printf("Setting opacity to default: 1.0\n");
        parsedShape.opacity = 1.0;
        parsedShape.refractionIndex = AIR_REFRACTION_INDEX;
    }

    parsedShape.theShape.triangle.normal.direction = nullPoint();
    parsedShape.theShape.triangle.normal = getNormal(parsedShape, parsedShape.theShape.triangle.points[0]);

    globals.shapes = realloc(globals.shapes, sizeof(ShapeData) * (globals.numberOfShapes + 1));
    globals.shapes[globals.numberOfShapes] = parsedShape;
    printShape(globals.shapes[globals.numberOfShapes]);
    globals.numberOfShapes++;
}
Ejemplo n.º 3
0
/*Lens intersection. Basically the same as a sphere except with another check for concavity*/
Point3D lensIntersection(LensData lens, Vector3D ray){
    Point3D intersection1;
    Point3D intersection2;

    double quadraticA = 1;
    double quadraticB;
    double quadraticC;

    double discriminant;

    double quadraticNegativeT;
    double quadraticPositiveT;

    double inter1Length;
    double inter2Length;


    quadraticB = 2 * ((ray.direction.x * (ray.position.x - lens.position.x))
                      + (ray.direction.y * (ray.position.y - lens.position.y))
                      + (ray.direction.z * (ray.position.z - lens.position.z)));

    quadraticC = pow((ray.position.x - lens.position.x), 2)
    + pow((ray.position.y - lens.position.y), 2)
    + pow((ray.position.z - lens.position.z), 2)
    - pow(lens.radius, 2);

    discriminant = (pow(quadraticB, 2) - (4 * quadraticA * quadraticC));

    /*Test discriminant, if not negative an intersection exists*/
    if(discriminant >= 0){
        quadraticNegativeT = (-quadraticB - sqrt(discriminant)) / 2;
        quadraticPositiveT = (-quadraticB + sqrt(discriminant)) / 2;

        intersection1.x = ray.position.x + (ray.direction.x * quadraticNegativeT);
        intersection1.y = ray.position.y + (ray.direction.y * quadraticNegativeT);
        intersection1.z = ray.position.z + (ray.direction.z * quadraticNegativeT);

        intersection2.x = ray.position.x + (ray.direction.x * quadraticPositiveT);
        intersection2.y = ray.position.y + (ray.direction.y * quadraticPositiveT);
        intersection2.z = ray.position.z + (ray.direction.z * quadraticPositiveT);

        inter1Length = getLength(ray.position, intersection1);
        inter2Length = getLength(ray.position, intersection2);

        /*Check concavity, take the correct intersection*/
        if(lens.isConvex == true){
            /*The closest intersection is the convex one*/
            if((isInRayPath(ray, intersection1)) && (inter1Length > 0.01)){
                return intersection1;
            }
            else{
                return nullPoint();
            }
        }
        else{
            /*Concave - the farthest intersection is the concave one*/
            if((isInRayPath(ray, intersection2)) && (inter2Length > 0.01)){
                return intersection2;
            }
            else{
                //printVector(ray);
                return nullPoint();
            }
        }

    }

    return nullPoint();
}
/********** routine de d�lacement **********/ 
void itsHybridContinuousInteractingAntColony::antMove( int antId )
{  
  printDebug( "antState", antState[0]);
  
  // si fourmi viens de faire un simplexe
  if ( antState[antId] == 0 ) {
    // re-placement al�toire :
    vector<double> aPoint;
    aPoint.reserve( this->getProblem()->getDimension() );
    
    
    // tirage al�toire uniforme sur l'hypercube de l'espace de recherche
    // aPoint = RandomVector_Cube( getBoundsMinima(), getBoundsMaxima() );
    
    // tirage al�toire dans la zone de visibilit�    //aPoint = RandomVector_Noise( antCurrentPoint[antId], antMoveRange[antId] );
    vector<double> tempVec( this->getProblem()->getDimension(),antMoveRange[antId] );
    aPoint = noiseUniform( antCurrentPoint[antId], tempVec );
    
    antMoveTo(antId, aPoint);
    
    // efface la pile de message
    vector<double> nullValuesStack;
    double nullValue = 0;
    nullValuesStack.push_back( nullValue );
    antIncomingValues[antId] =  nullValuesStack;
    
    vector< vector<double> > nullPointsStack;
    vector<double> nullPoint( this->getProblem()->getDimension(), 0 );
    nullPointsStack.push_back( nullPoint );
    antIncomingPoints[antId] = nullPointsStack;
    
    
    // fin de cet �at
    antState[antId]=0.0001;
    
    spotsEvaporate();
    return;
    
  } else { // fourmi n'as pas encore fait de simplexe
    // d�lacement normal
    
    // choix du d�lacement
    int ok=0;
    int choice;
    // si choix des spots
    choice = thresholdChoice( antProbaMemory[antId], probaUseMemoryThreshold, probaUseMemoryPower, 'e' );
    
    if ( choice  ) {
      ok += antMoveSpots( antId );
    } else { // choix des messages
      ok += antMoveMessages( antId );
    }
        
    // si d�lacement spots/message fait
    if ( ok > 0 ) {
      spotsEvaporate();
      return;
    }
    
    // teste motivation simplexe
    choice = thresholdChoice( antState[antId], probaUseNMSThreshold, probaUseNMSPower, 'e' );

    if ( choice ) {
      // intensification par simplexe
      ok += antMoveNMS(antId);
      // d�ot spot
      antSpotLay( antId, antCurrentPoint[antId], antCurrentValue[antId] );
      // a fait son intensification
      antState[antId] = 0;

    } else { // pas motiv� pour le simplexe
      // test envoi de message
      choice = thresholdChoice( 1 - antState[antId], probaUseNMSThreshold, probaUseNMSPower, 'e' );
      
      if ( choice ) {
        // envoi de message
        antMessageSend( antId, antMessageChooseMate(antId) );	
        // augmentation motivation
        antIncreaseState(antId);
      }
    }
    
    // si d�lacement simplexe impossible
    if ( ok == 0 ) {
      antMoveRandom( antId );
      spotsEvaporate();
      return;
    }
    
  }
  
  spotsEvaporate();
}