Beispiel #1
0
void LocationParser_ns::parsePointList(PointList &list) {
	debugC(5, kDebugParser, "parsePointList()");

	_script->readLineToken(true);
	while (scumm_stricmp(_tokens[0], "ENDNODES")) {

		if (!scumm_stricmp(_tokens[0], "COORD")) {
			list.push_front(Common::Point(atoi(_tokens[1]), atoi(_tokens[2])));
		}

		_script->readLineToken(true);
	}

	debugC(5, kDebugParser, "parsePointList() done");

	return;
}
Beispiel #2
0
bool CCurviDetect2D::SuiviFreeman(utls::BAry *Image)
{
   // init tableau
   byte FreemanHoraire[] = {0, 2, 4, 6, 1, 3, 5, 7};

   // par sécurité
   BordAZero(Image->el[0],Image->cols(),Image->rows());

   /////////////////////////////////////////////////////////////////////////////////////
   //////////////////////////////////recherche du premier point/////////////////////////
   /////////////////////////////////////////////////////////////////////////////////////
   utls::BAry::pointer ptr=Image->first(), size=Image->last();
   IPoint2D FirstPoint(0,0);
   do 
   {  
      // find first unvisited point in the image
      for (; ptr<size && (*ptr)!=255; ptr++) ;

      // still in the image?
      if (ptr<size)
      {
         // translate offset to x,y
         FirstPoint.y = (ptr - Image->first()         ) / Image->cols();
         FirstPoint.x = (ptr - Image->el[FirstPoint.y]);
         /////////////////////////////////////////////////////////////////////////////////////
         //////////////////////////Etude de la connexité du premier point/////////////////////
         /////////////////////////////////////////////////////////////////////////////////////

         IPoint2D CurrentPoint = FirstPoint;
         bool Rebouclage = false, ConditionArret=true;   

         //allocation d'un pointeur pour ajouter une nouvelle liste à l'array
         ConnexityDegreeAFreemanCode ConnexityFirstPoint;
         ConnexityFirstPoint.ConnexityDegree = 0;
         for(int i=0;i<8;i++)
         {
            IPoint2D NewPoint = CurrentPoint;
            switch (i)
            {
            case 0 : NewPoint.x++; break;
            case 1 :
               {
                  NewPoint.x++;
                  NewPoint.y++;
               } 
               break;		
            case 2 : NewPoint.y++; break;
            case 3 : 
               {
                  NewPoint.x--;
                  NewPoint.y++;
               }
               break;
            case 4 : NewPoint.x--; break;
            case 5 : 
               {
                  NewPoint.x--;
                  NewPoint.y--; 
               }
               break;
            case 6 : NewPoint.y--; break;
            case 7 : 
               {
                  NewPoint.x++;
                  NewPoint.y--;
               }
               break;
            } // switch
            if (Image->el[NewPoint.y][NewPoint.x]==255)
            {
               ConnexityFirstPoint.ConnexityDegree++;
               ConnexityFirstPoint.FreemanCode[i]=true;
            }
            else
               ConnexityFirstPoint.FreemanCode[i]=false;
         } // for i - les 8 directions 

         /////////////////////////////////////////////////////////////////////////////////////
         //////////////////////////////////Parcours pour le suivi Freeman/////////////////////
         /////////////////////////////////////////////////////////////////////////////////////
         if(ConnexityFirstPoint.ConnexityDegree!=0)
         {
            PointList *ListePointContour = new PointList;
            ListePointContour->push_back(FirstPoint);
            CurrentPoint = FirstPoint;
            do
            {		
               int  CodeFreeman = 0, NbZero = 0, NbMoinsUn = 0;
               bool bFinFreeman = false, BoolRetour=false, CandidatTrouve = false;
               ConditionArret=true;
               do	
               {
                  IPoint2D NewPoint = CurrentPoint;
                  switch (FreemanHoraire[CodeFreeman])
                  {
                  case 0 : NewPoint.x++; break;
                  case 1 :
                     {
                        NewPoint.x++;
                        NewPoint.y++;
                     } 
                     break;		
                  case 2 : NewPoint.y++; break;
                  case 3 : 
                     {
                        NewPoint.x--;
                        NewPoint.y++;
                     }
                     break;
                  case 4 : NewPoint.x--; break;
                  case 5 : 
                     {
                        NewPoint.x--;
                        NewPoint.y--; 
                     }
                     break;
                  case 6 : NewPoint.y--; break;
                  case 7 : 
                     {
                        NewPoint.x++;
                        NewPoint.y--;
                     }
                     break;
                  } // fin switch
                  utls::BAry::value v = Image->el[NewPoint.y][NewPoint.x];
                  if (v == 0)            NbZero++;
                  if (v == MARKED_PIXEL) NbMoinsUn++;
                  if (v == 255)
                  {
                     ListePointContour->push_back(NewPoint);
                     CurrentPoint = NewPoint;
                     CandidatTrouve = true;
                     Image->el[NewPoint.y][NewPoint.x] = MARKED_PIXEL;
                     if (CurrentPoint == FirstPoint)
                     {
                        ConditionArret = false; //on sort si la tete = la queue
                        Rebouclage = true; // pas la peine de traiter la connexité
                     }
                     bFinFreeman=true; // pas la peine de continuer				
                  }
                  else// si on a pas trouvé de point blanc
                  {
                     if (CodeFreeman == 7)// et qu'on a balayé tous les freemans alors on sort
                     {
                        if (BoolRetour)
                           ConditionArret = false;
                        else
                        {
                           if(ListePointContour->size() > 1)
                           {                                 
                              BoolRetour=true;
                              Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                              PointList::iterator PositionQueue = ListePointContour->end();// ListePointContour->GetTailPosition();
                              PositionQueue--;
                              PositionQueue--;
                              CurrentPoint = *PositionQueue;
                              CodeFreeman = -1;
                              NbZero=0;
                              NbMoinsUn=0;
                           }
                           else
                           {	
                              ConditionArret = false;
                           }
                        } // fin else
                     }
                  }
                  CodeFreeman++;
                  if (CodeFreeman > 7) bFinFreeman=true;			
               } while (!bFinFreeman);

               if ((NbZero==7) && (CandidatTrouve==false))//extremité
               {
                  Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                  ConditionArret=false;
               }

               if ((NbZero<=7)&&(NbMoinsUn<=7)&&(CandidatTrouve==false))//cas d'un point emprisonné
               {
                  Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                  ConditionArret=false;
               }

               if ((NbZero==8)&&(CandidatTrouve==false))//cas d'un point isolé
               {
                  Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                  ConditionArret=false;
               }
            } while (ConditionArret); //condition d'arrêt

            if (ConnexityFirstPoint.ConnexityDegree>1 && !Rebouclage)
            {
               CurrentPoint = FirstPoint;
               do
               {
                  int  CodeFreeman = 0, NbZero = 0, NbMoinsUn = 0;
                  bool bFinFreeman = false, BoolRetour=false, CandidatTrouve = false;
                  ConditionArret=true;
                  do	
                  {
                     IPoint2D NewPoint = CurrentPoint;
                     switch (FreemanHoraire[CodeFreeman])
                     {
                     case 0 : NewPoint.x++; break;
                     case 1 :
                        {
                           NewPoint.x++;
                           NewPoint.y++;
                        } 
                        break;		
                     case 2 : NewPoint.y++; break;
                     case 3 : 
                        {
                           NewPoint.x--;
                           NewPoint.y++;
                        }
                        break;
                     case 4 : NewPoint.x--; break;
                     case 5 : 
                        {
                           NewPoint.x--;
                           NewPoint.y--; 
                        }
                        break;
                     case 6 : NewPoint.y--; break;
                     case 7 : 
                        {
                           NewPoint.x++;
                           NewPoint.y--;
                        }
                        break;
                     } // fin switch
                     utls::BAry::value v = Image->el[NewPoint.y][NewPoint.x];
                     if (v == 0)            NbZero++;
                     if (v == MARKED_PIXEL) NbMoinsUn++;
                     if (v == 255)
                     {
                        ListePointContour->push_front(NewPoint);
                        CurrentPoint = NewPoint;
                        CandidatTrouve = true;
                        Image->el[NewPoint.y][NewPoint.x] = MARKED_PIXEL;
                        if(CurrentPoint == FirstPoint)
                        {
                           Image->el[FirstPoint.y][FirstPoint.x] = MARKED_PIXEL;
                           ConditionArret = false; //on sort si la tete = la queue
                           Rebouclage = true; // pas la peine de traiter la connexité
                        }
                        bFinFreeman=true; // pas la peine de continuer
                     }
                     else// si on a pas trouvé de point blanc
                     {
                        if(CodeFreeman == 7)// et qu'on a balayé tous les freemans alors on sort
                        {
                           if(BoolRetour)
                              ConditionArret = false;
                           else
                           {
                              if(ListePointContour->size() > 1)
                              {
                                 BoolRetour=true;
                                 Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                                 PointList::iterator PositionQueue = ListePointContour->begin();   
                                 PositionQueue++;
                                 CurrentPoint = *PositionQueue;
                                 CodeFreeman = -1;
                                 NbZero=0;
                                 NbMoinsUn=0;
                              }
                              else
                                 ConditionArret = false;
                           }
                        }
                     }
                     CodeFreeman++;
                     if (CodeFreeman >7) bFinFreeman=true;
                  } while (!bFinFreeman);

                  if ((NbZero==7) && (CandidatTrouve==false))//extremité -- end of the edge
                  {
                     Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                     ConditionArret=false;
                  }

                  if ((NbZero<=7)&&(NbMoinsUn<=7)&&(CandidatTrouve==false))//cas d'un point emprisonné  -- problem blocked poimt
                  {
                     Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                     ConditionArret=false;
                  }

                  if ((NbZero==8)&&(CandidatTrouve==false))//cas d'un point isolé -- just one point
                  {
                     Image->el[CurrentPoint.y][CurrentPoint.x] = MARKED_PIXEL;
                     ConditionArret=false;
                  }
               }while (ConditionArret); //condition d'arrêt; //condition d'arrêt

            }//fin traitement cas U

            TabListePoint.push_back(ListePointContour);
         }// fin if point isolé
         else
            Image->el[FirstPoint.y][FirstPoint.x] = MARKED_PIXEL;
      }// fin if (ptr<size)
   } while (ptr<size);
   return true;
}