sources/app/image/image_prc.c

   1 #include "image_prc.h"
   2
   3 //#define DEBUG
   4
   5 struct track{
   6         int vector;
   7                 int x;
   8                 int y;
   9 };
  10
  11 struct track itrack[50];
  12
  13 unsigned char black=255;
  14 unsigned char white =0;
  15
  16
  17 void *image_prc(char *data, int v, int h){
  18         int t=0;
  19                 int i=0;
  20                 int ix,iy;
  21                 int tt=0;
  22
  23                 t=image_head(data, v, h);
  24
  25                 if(t==-1){
  26                         itrack[0].x = -1;
  27                         itrack[0].y = -1;
  28                         itrack[0].vector = 0;
  29                         return data;
  30                 }else{
  31                         tt=image_body(data,v,h,t);
  32                         itrack[tt].x=-1;
  33                         itrack[tt].y=-1;
  34                 }
  35
  36 #ifdef   DEBUG
  37         for(i=t;i<tt; i++){
  38                 ix=itrack[i].x;
  39                         iy=itrack[i].y;
  40                         *(data+iy*h+ix)=255;
  41         }
  42 #endif
  43
  44                 return data;
  45
  46 }
  47
  48
  49 int image_head(char *data, int v, int h){
  50
  51                 int temp;
  52                 int i=0, neg[100][2]={0},pos[100][2]={0};
  53         int pf=0,nf=0,j=0,k=0,t=0,offset=0,f=0,po=0,flag=0;
  54                 int left=h, right=0;
  55
  56
  57                 for(po=v-1; po>v-40; po--){
  58                         flag=0;
  59                                 temp = h*(po-1);
  60                                 pf=0;
  61                         nf=0;
  62                                 for(i=1; i< h-3; i++){
  63                                         j=(unsigned char)*(data+temp+i) ;
  64                                                 k=(unsigned char)*(data+temp+i+2) ;
  65                                                 if(j-k>80){
  66                                                         white=j;
  67                                                                 black=(unsigned char)*(data+temp+i+1) ;
  68
  69                                                                 left=i;
  70                                                         if(pf==0 && i>50 && po>70){
  71                                                                 pos[f++][0]=i;
  72                                                                         pos[f][1]=po;
  73                                                                 pf=1;
  74
  75                                                         }
  76                                                         flag=1;
  77                                                 }
  78                                         if(k-j>80){
  79                                                 right=i;
  80                                                         if(right-left<18&& right-left>2){                                               //Add start line searching here
  81                                                                 //*(data+i+temp)=255;
  82                                                                 itrack[0].x = i;
  83                                                                         itrack[0].y = po;
  84                                                                         itrack[0].vector = 0;
  85                                                                         return 0;
  86                                                         }else {
  87                                                                 //*(data+i+temp)=255;
  88                                                                 if(nf==0 && i<20 && po>70){
  89                                                                         neg[t++][0]=i;
  90                                                                                 neg[t][1]=po;
  91                                                                         nf=1;
  92                                                                 }
  93                                                         }
  94                                         }
  95                                 }
  96                 }
  97
  98 return -1;
  99 }
 100
 101 int image_body(char *data, int v, int h, char start){
 102
 103                 int i=0,j=0,k=0,t=0,offset=0,f=0,po=0,flag=0,sline=0;
 104                 int scale=0,temp=0,vo=0,pos=0;
 105
 106                 po=itrack[start].x;
 107                 sline=itrack[start].y-1;
 108                 vo=itrack[start].vector;
 109
 110                 offset=60;
 111                 f=start+1;
 112                 scale=25;
 113
 114                 po+=vo;
 115
 116                 for(t=sline; t>5; t--){
 117                         flag=0;
 118                                 temp = h*t;
 119                                 if(t==35) {
 120                                         scale=20;
 121                                         offset-=20;
 122                                 }
 123                         if(t==50){
 124                                 scale=25;
 125                                 offset-=20;
 126                         }
 127                         for(i=0-scale; i<scale; i++){
 128
 129                                         if(po+i+3<h && po+i>0) {
 130
 131
 132                                                         j=(unsigned char)*(data+temp+po+i) ;
 133                                                         k=(unsigned char)*(data+temp+po+i+2) ;
 134                                                         if(j-k>offset){
 135                                                                         pos=i+po;
 136                                                                         flag=1;
 137                                                                         //*(data+temp+po+i)=255;
 138                                                         }
 139
 140                                                         if(k-j>offset && flag==1){
 141                                                                 if((po+i-pos)>1){                                               // Ignore disturbance spot
 142                                                                         po=(pos+i+po)/2;
 143                                                                         itrack[f].x=po;
 144                                                                         itrack[f].y=t;
 145                                                                         itrack[f].vector=i;
 146                                                                         //*(data+temp+po+i)=255;
 147                                                                         po+=i;
 148
 149                                                                         break;
 150                                                                 }
 151                                                         }
 152
 153                                         }
 154
 155                         }
 156
 157                         if(i==scale) {
 158                                 itrack[f].x=-1;
 159                                 itrack[f].y=-1;
 160                                 itrack[f].vector=0;
 161                                 return f;
 162                         }
 163                                 f++;
 164                                 t--;
 165                 }
 166
 167         return f;
 168
 169
 170
 171
 172 }
 173
 174
 175 int image_trail(char *data, int v, int h, int offset){
 176
 177                 int vo=0, po=0,line=0;
 178                 int pos=0, neg=0;
 179                 int i=0, j=0;
 180                 int temp=0;
 181                 int step=0,flag=0;
 182                 int pf=0,nf=0;
 183                 unsigned char m,n;
 184
 185                 vo = itrack[offset].vector;
 186                 po = itrack[offset].x;
 187                 line = itrack[offset].y;
 188
 189                 step=25;
 190                 for(line=offset; line>5; line--){
 191                         temp=h*line;
 192                                 flag=0;
 193                                 for(i=0; i<h-3; i++){
 194                                         m=*(data+temp+i);
 195                                                 n=*(data+temp+i+2);
 196                                                 if(m-n>step && pf==0) {
 197
 198                                                                 pos=i;
 199                                                                 pf=1;
 200                                                 }
 201
 202                                                 if(n-m>step && pf==1){
 203                                                         neg=i;
 204                                                                 nf=1;
 205                                                                 if(neg-pos>1 && neg-pos<10){
 206                                                                         itrack[offset++].x = (neg+pos)/2;
 207                                                                                 itrack[offset].y = line;
 208                                                                                 itrack[offset].vector=itrack[offset].x - itrack[offset-1].x;
 209
 210                                                                                 break;
 211                                                                 }
 212                                                 }
 213                                 }
 214
 215                                 flag++;
 216                                 if(flag==4){
 217                                         itrack[offset++].x=-1;
 218                                                 itrack[offset].y=-1;
 219                                                 itrack[offset].vector=0;
 220
 221                                                 return offset;
 222                                 }
 223                 }
 224 }
 225
 226
 227
 228
 229 int image_body_old(char *data,  int v, int h, char start){
 230
 231                 int i=0,j=0;
 232
 233                 int base=0;
 234                 int px=0;
 235                 int py=0;
 236                 unsigned char val=0;
 237                 char flag = 0;
 238                 int cry=0;
 239
 240                 int cal = 0;
 241                 int temp=0;
 242                 int remote=0;
 243                 int iblack=0;
 244                 int li=0;
 245                 int k=0;
 246
 247
 248                 itrack[0].x = start;
 249                 itrack[0].y = v-1;
 250                 itrack[0].vector = 0;
 251                 black +=50;
 252                 //iblack=black;
 253
 254                 for(i =0; i<50; i++){
 255
 256                                 //black = black+40;
 257                                 //black=iblack;
 258                                 //white=50;
 259                                 //if(black >white) black=white-20;
 260                                 //if(white>220) white=black;
 261                                 flag=0;
 262                                 remote=0;
 263                                 li=6;
 264                                 base = itrack[i].vector;
 265                                 px = itrack[i].x;
 266                                 py = itrack[i].y;
 267                                 //              printf("i%d: px=%d py=%d\n",i,px,py);
 268                                 if(py<20 || px<2 || px>h-1) {
 269                                         //                                      itrack[i+1].x=-1;
 270                                         //                      itrack[i+1].y=-1;
 271                                         //                      itrack[i+1].vector=itrack[i].vector;
 272                                         return i;
 273                                 }
 274                         if(py<35){
 275                                 py=py+2;
 276                                         remote=1;
 277                                         //black+=10;
 278                                         li=6;
 279                         }
 280                         for(cal=0; cal < li; cal++){
 281                                 for(j=0; j<2; j++){
 282                                         if(j==0) temp = base+cal;
 283                                         else temp = base -cal;
 284                                                 //printf("-%d",temp);
 285                                                 k=0;
 286                                                         switch (temp){
 287                                                                 case 0:
 288
 289                                                                                if(py-4<0) break;
 290                                                                                        val = (unsigned char)*(data+(py-4)*h+px);
 291
 292                                                                                                if(val < black) {
 293                                                                                                        while(k<10){
 294                                                                                                                if(*(data+(py-4)*h+px-k)>black) break;
 295                                                                                                                        //printf("--%d",*(data+(py-4)*h+px-k));
 296                                                                                                                        k++;
 297                                                                                                        }
 298                                                                                                        if(k<10){
 299                                                                                                                *(data+(py-4)*h+px-k)=255;
 300                                                                                                                        //black=val;
 301                                                                                                                        itrack[i+1].x = px;
 302                                                                                                                        itrack[i+1].y = py-4;
 303                                                                                                                        itrack[i+1].vector =0;
 304                                                                                                                        flag =1;
 305                                                                                                        }
 306                                                                                                }
 307                                                                        break;
 308                                                                 case 1:
 309                                                                        if(py-4 <0 || px +2>h) break;
 310                                                                                val = (unsigned char)*(data+(py-4)*h+px+1);
 311                                                                                        //                                               printf("in case 1: black is %d, val is %d\n",black,val);
 312                                                                                        if(val < black) {
 313                                                                                                while(k<10){
 314                                                                                                        if(*(data+(py-4)*h+px+1-k)>black) break;
 315                                                                                                                k++;
 316                                                                                                }
 317                                                                                                if(k<10){
 318                                                                                                        *(data+(py-4)*h+px+1-k)=255;//black=val;
 319                                                                                                        itrack[i+1].x = px+1-k;
 320                                                                                                                itrack[i+1].y = py-4;
 321                                                                                                                itrack[i+1].vector =1;
 322                                                                                                                flag =1;
 323                                                                                                }
 324                                                                                        }
 325                                                                        break;
 326                                                                 case -1:
 327                                                                         if(py-4 <0 || px-1<0) break;
 328                                                                                 val = (unsigned char)*(data+(py-4)*h+px-1);
 329                                                                                         if(val < black) {
 330                                                                                                 while(k<10){
 331                                                                                                         if(*(data+(py-4)*h+px-1+k)>black) break;
 332                                                                                                                 k++;
 333                                                                                                 }
 334                                                                                                 if(k<10){
 335                                                                                                         *(data+(py-4)*h+px-1+k)=255;//black=val;
 336                                                                                                         itrack[i+1].x = px-1+k;
 337                                                                                                                 itrack[i+1].y = py-4;
 338                                                                                                                 itrack[i+1].vector =-1;
 339                                                                                                                 flag =1;
 340                                                                                                 }
 341                                                                                         }
 342                                                                         break;
 343                                                                 case 2:
 344                                                                        if(py-4 <0 || px+3>h) break;
 345                                                                                val = (unsigned char)*(data+(py-4)*h+px+2);
 346                                                                                        if(val < black) {
 347                                                                                                while(k<10){
 348                                                                                                        if(*(data+(py-4)*h+px+2-k)>black) break;
 349                                                                                                                k++;
 350                                                                                                }
 351                                                                                                if(k<10){
 352                                                                                                        *(data+(py-4)*h+px+2-k)=255;//black=val;
 353                                                                                                        itrack[i+1].x = px+2-k;
 354                                                                                                                itrack[i+1].y = py-4;
 355                                                                                                                itrack[i+1].vector =2;
 356                                                                                                                flag =1;
 357                                                                                                }
 358                                                                                        }
 359                                                                        break;
 360                                                                 case -2:
 361                                                                         if(py-4 <0 || px -2<0) break;
 362                                                                                 val = (unsigned char)*(data+(py-4)*h+px-2);
 363                                                                                         if(val < black) {
 364                                                                                                 while(k<10){
 365                                                                                                         if(*(data+(py-4)*h+px-2+k)>black) break;
 366                                                                                                                 k++;
 367                                                                                                 }
 368                                                                                                 if(k<10){
 369                                                                                                         *(data+(py-4)*h+px-2+k)=255;//black=val;
 370                                                                                                         itrack[i+1].x = px-2+k;
 371                                                                                                                 itrack[i+1].y = py-4;
 372                                                                                                                 itrack[i+1].vector =-2;
 373                                                                                                                 flag =1;
 374                                                                                                 }
 375                                                                                         }
 376                                                                         break;
 377                                                                 case 3:
 378                                                                        if(py-4 <0 || px+3>h) break;
 379                                                                                val = (unsigned char)*(data+(py-3)*h+px+2);
 380                                                                                        if(val < black) {
 381                                                                                                while(k<10){
 382                                                                                                        if(*(data+(py-3)*h+px+2-k)>black) break;
 383                                                                                                                k++;
 384                                                                                                }
 385                                                                                                if(k<10){
 386                                                                                                        *(data+(py-3)*h+px+2-k)=255;//black=val;
 387                                                                                                        itrack[i+1].x = px+2-k;
 388                                                                                                                itrack[i+1].y = py-3;
 389                                                                                                                itrack[i+1].vector =3;
 390                                                                                                                flag =1;
 391                                                                                                }
 392                                                                                        }
 393                                                                        break;
 394                                                                 case -3:
 395                                                                         if(py-4 <0 || px -2<0) break;
 396                                                                                 val = (unsigned char)*(data+(py-3)*h+px-2);
 397                                                                                         if(val < black) {
 398                                                                                                 while(k<10){
 399                                                                                                         if(*(data+(py-3)*h+px-2+k)>black) break;
 400                                                                                                                 k++;
 401                                                                                                 }
 402                                                                                                 if(k<10){
 403                                                                                                         *(data+(py-3)*h+px-2+k)=255;//black=val;
 404                                                                                                         itrack[i+1].x = px-2+k;
 405                                                                                                                 itrack[i+1].y = py-3;
 406                                                                                                                 itrack[i+1].vector =-3;
 407                                                                                                                 flag =1;
 408                                                                                                 }
 409                                                                                         }
 410                                                                         break;
 411                                                                 case 4:
 412                                                                        if(py-4 <0 || px+3>h) break;
 413                                                                                val = (unsigned char)*(data+(py-2)*h+px+2);
 414                                                                                        if(val < black) {
 415                                                                                                while(k<10){
 416                                                                                                        if(*(data+(py-2)*h+px+2-k)>black) break;
 417                                                                                                                k++;
 418                                                                                                }
 419                                                                                                if(k<10){
 420                                                                                                        *(data+(py-2)*h+px+2-k)=255;//black=val;
 421                                                                                                        itrack[i+1].x = px+2-k;
 422                                                                                                                itrack[i+1].y = py-2;
 423                                                                                                                itrack[i+1].vector =4;
 424                                                                                                                flag =1;
 425                                                                                                }
 426                                                                                        }
 427                                                                        break;
 428                                                                 case -4:
 429                                                                         if(py-4 <0 || px -2<0) break;
 430                                                                                 val = (unsigned char)*(data+(py-2)*h+px-2);
 431                                                                                         if(val < black) {
 432                                                                                                 while(k<10){
 433                                                                                                         if(*(data+(py-2)*h+px-2+k)>black) break;
 434                                                                                                                 k++;
 435                                                                                                 }
 436                                                                                                 if(k<10){
 437                                                                                                         *(data+(py-2)*h+px-2+k)=255;//black=val;
 438                                                                                                         itrack[i+1].x = px-2+k;
 439                                                                                                                 itrack[i+1].y = py-2;
 440                                                                                                                 itrack[i+1].vector =-4;
 441                                                                                                                 flag =1;
 442                                                                                                 }
 443                                                                                         }
 444                                                                         break;
 445
 446                                                                 case 5:
 447                                                                        if(py-4 <0 || px+3>h) break;
 448                                                                                val = (unsigned char)*(data+(py-1)*h+px+2);
 449                                                                                        if(val < black) {
 450                                                                                                while(k<10){
 451                                                                                                        if(*(data+(py-1)*h+px+2-k)>black) break;
 452                                                                                                                k++;
 453                                                                                                }
 454                                                                                                if(k<10){
 455
 456                                                                                                                *(data+(py-1)*h+px+2+k)=255;//black=val;
 457                                                                                                        itrack[i+1].x = px+2;
 458                                                                                                                itrack[i+1].y = py-1;
 459                                                                                                                itrack[i+1].vector =5;
 460                                                                                                                flag =1;
 461                                                                                                }
 462                                                                                        }
 463                                                                        break;
 464                                                                 case -5:
 465                                                                         if(py-4 <0 || px -2<0) break;
 466                                                                                 val = (unsigned char)*(data+(py-1)*h+px-2);
 467                                                                                         if(val < black) {
 468                                                                                                 while(k<10){
 469                                                                                                         if(*(data+(py-2)*h+px-2+k)>black) break;
 470                                                                                                                 k++;
 471                                                                                                 }
 472                                                                                                 if(k<10){
 473                                                                                                         *(data+(py-1)*h+px-2)=255;//black=val;
 474                                                                                                         itrack[i+1].x = px-2;
 475                                                                                                                 itrack[i+1].y = py-1;
 476                                                                                                                 itrack[i+1].vector =-5;
 477                                                                                                                 flag =1;
 478                                                                                                 }
 479                                                                                         }
 480                                                                         break;
 481                                                                 case 6:
 482                                                                        if(px+3>h ) break;
 483                                                                                val = (unsigned char)*(data+(py)*h+px+2);
 484                                                                                        if(val < black) {
 485                                                                                                while(k<10){
 486                                                                                                        if(*(data+(py)*h+px+2-k)>black) break;
 487                                                                                                                k++;
 488                                                                                                }
 489                                                                                                if(k<10){
 490
 491                                                                                                                *(data+(py)*h+px+2-k)=255;//black=val;
 492                                                                                                        itrack[i+1].x = px+2;
 493                                                                                                                itrack[i+1].y = py;
 494                                                                                                                itrack[i+1].vector =6;
 495                                                                                                                flag =1;
 496                                                                                                }
 497                                                                                        }
 498                                                                        break;
 499                                                                 case -6:
 500                                                                         if(px -2<0) break;
 501                                                                                 val = (unsigned char)*(data+(py)*h+px-2);
 502                                                                                         if(val < black) {
 503                                                                                                 while(k<10){
 504                                                                                                         if(*(data+(py-2)*h+px-2+k)>black) break;
 505                                                                                                                 k++;
 506                                                                                                 }
 507                                                                                                 if(k<10){
 508                                                                                                         *(data+(py)*h+px-2)=255;//black=val;
 509                                                                                                         itrack[i+1].x = px-2;
 510                                                                                                                 itrack[i+1].y = py;
 511                                                                                                                 itrack[i+1].vector =-6;
 512                                                                                                                 flag =1;
 513                                                                                                 }
 514                                                                                         }
 515                                                                         break;
 516
 517                                                                 case 7:
 518                                                                        if(py+5> v ||px+3>h) break;
 519                                                                                val = (unsigned char)*(data+(py+1)*h+px+2);
 520                                                                                        if(val < black) {
 521                                                                                                *(data+(py+1)*h+px+2)=255;//black=val;
 522                                                                                                itrack[i+1].x = px+2;
 523                                                                                                        itrack[i+1].y = py+1;
 524                                                                                                        itrack[i+1].vector =7;
 525                                                                                                        flag =1;
 526                                                                                        }
 527                                                                        break;
 528                                                                 case -7:
 529                                                                         if(py+5> v || px -2<0) break;
 530                                                                                 val = (unsigned char)*(data+(py+1)*h+px-2);
 531                                                                                         if(val < black) {
 532                                                                                                 *(data+(py+1)*h+px-2)=255;//black=val;
 533                                                                                                 itrack[i+1].x = px-2;
 534                                                                                                         itrack[i+1].y = py+1;
 535                                                                                                         itrack[i+1].vector =-7;
 536                                                                                                         flag =1;
 537                                                                                         }
 538                                                                         break;
 539                                                                 case 8:
 540                                                                        if(py+5> v || px+3>h) break;
 541                                                                                val = (unsigned char)*(data+(py+2)*h+px+2);
 542                                                                                        if(val < black) {
 543                                                                                                *(data+(py+2)*h+px+2)=255;//black=val;
 544                                                                                                itrack[i+1].x = px+2;
 545                                                                                                        itrack[i+1].y = py+2;
 546                                                                                                        itrack[i+1].vector =8;
 547                                                                                                        flag =1;
 548                                                                                        }
 549                                                                        break;
 550                                                                 case -8:
 551                                                                         if(py+5> v|| px -2<0) break;
 552                                                                                 val = (unsigned char)*(data+(py+2)*h+px-2);
 553                                                                                         if(val < black) {
 554                                                                                                 *(data+(py+2)*h+px-2)=255;//black=val;
 555                                                                                                 itrack[i+1].x = px-2;
 556                                                                                                         itrack[i+1].y = py+2;
 557                                                                                                         itrack[i+1].vector =-8;
 558                                                                                                         flag =1;
 559                                                                                         }
 560                                                                         break;
 561                                                                 case 9:
 562                                                                        if(py+5> v || px+3>h) break;
 563                                                                                val = (unsigned char)*(data+(py+3)*h+px+2);
 564                                                                                        if(val < black) {
 565                                                                                                *(data+(py+3)*h+px+2)=255;//black=val;
 566                                                                                                itrack[i+1].x = px+2;
 567                                                                                                        itrack[i+1].y = py+3;
 568                                                                                                        itrack[i+1].vector =9;
 569                                                                                                        flag =1;
 570                                                                                        }
 571                                                                        break;
 572                                                                 case -9:
 573                                                                         if(py+5> v ||px -2<0) break;
 574                                                                                 val = (unsigned char)*(data+(py+3)*h+px-2);
 575                                                                                         if(val < black) {
 576                                                                                                 *(data+(py+3)*h+px-2)=255;//black=val;
 577                                                                                                 itrack[i+1].x = px-2;
 578                                                                                                         itrack[i+1].y = py+3;
 579                                                                                                         itrack[i+1].vector =-9;
 580                                                                                                         flag =1;
 581                                                                                         }
 582                                                                         break;
 583                                                                 case 10:
 584                                                                         if(py+5> v || px+3>h ) break;
 585                                                                                 val = (unsigned char)*(data+(py+4)*h+px+2);
 586                                                                                         if(val < black) {
 587                                                                                                 *(data+(py+4)*h+px+2)=255;//black=val;
 588                                                                                                 itrack[i+1].x = px+2;
 589                                                                                                         itrack[i+1].y = py+4;
 590                                                                                                         itrack[i+1].vector =10;
 591                                                                                                         flag =1;
 592                                                                                         }
 593                                                                         break;
 594                                                                 case -10:
 595                                                                          if(py+5> v || px -2<0) break;
 596                                                                                  val = (unsigned char)*(data+(py+4)*h+px-2);
 597                                                                                          if(val < black) {
 598                                                                                                  *(data+(py+4)*h+px-2)=255;//black=val;
 599                                                                                                  itrack[i+1].x = px-2;
 600                                                                                                          itrack[i+1].y = py+4;
 601                                                                                                          itrack[i+1].vector =-10;
 602                                                                                                          flag =1;
 603                                                                                          }
 604                                                                          break;
 605                                                                 case 11:
 606                                                                         if(py+5> v || px+3>h) break;
 607                                                                                 val = (unsigned char)*(data+(py+4)*h+px+1);
 608                                                                                         if(val < black) {
 609                                                                                                 *(data+(py+4)*h+px+1)=255;//black=val;
 610                                                                                                 itrack[i+1].x = px+1;
 611                                                                                                         itrack[i+1].y = py+4;
 612                                                                                                         itrack[i+1].vector =11;
 613                                                                                                         flag =1;
 614                                                                                         }
 615                                                                         break;
 616                                                                 case -11:
 617                                                                          if(py+5> v || px -2<0) break;
 618                                                                                  val = (unsigned char)*(data+(py+4)*h+px-1);
 619                                                                                          if(val < black) {
 620                                                                                                  *(data+(py+4)*h+px-1)=255;//black=val;
 621                                                                                                  itrack[i+1].x = px-1;
 622                                                                                                          itrack[i+1].y = py+4;
 623                                                                                                          itrack[i+1].vector =-11;
 624                                                                                                          flag =1;
 625                                                                                          }
 626                                                                          break;
 627                                                                 case 12:
 628                                                                 case -12:
 629                                                                          if(py+5> v) break;
 630                                                                                  val = (unsigned char)*(data+(py+4)*h+px);
 631                                                                                          if(val < black) {
 632                                                                                                  *(data+(py+4)*h+px)=255;//black=val;
 633                                                                                                  itrack[i+1].x = px;
 634                                                                                                          itrack[i+1].y = py+4;
 635                                                                                                          itrack[i+1].vector =12;
 636                                                                                                          flag =1;
 637                                                                                          }
 638                                                                          break;
 639
 640                                                                 default:
 641                                                                         break;
 642                                                         }
 643
 644
 645                                                 if(py<35&& flag==1) {
 646                                                         if(itrack[i+1].vector<-1 || itrack[i+1].vector>1)
 647                                                                 itrack[i+1].vector -=2;
 648                                                                         break;
 649                                                 }
 650
 651                                 }
 652                                 if(flag==1) break;
 653
 654
 655
 656                         }
 657                         if(py>20&& flag==0){
 658                                 itrack[i+1].x=-1;
 659                                         itrack[i+1].y=-1;
 660                                         itrack[i+1].vector=itrack[i].vector;
 661                                         return i;
 662                         }else{
 663                                 if(flag==0) {
 664                                         if(cry>=3) return i;
 665                                         else cry++;
 666                                                 if(remote==1) py=py-2;
 667                                                         if(py<10 || px<1 || px>h-2) {
 668                                                                 itrack[i+1].x=-1;
 669                                                                         itrack[i+1].y=-1;
 670                                                                         itrack[i+1].vector=itrack[i].vector;
 671                                                                         return i;
 672                                                         }else
 673
 674                                                                         if((unsigned char)*(data+(py-1)*h+px) < black) {
 675                                                                                 black = (unsigned char)*(data+(py-1)*h+px);
 676                                                                                         itrack[i+1].x=px;
 677                                                                                         itrack[i+1].y=py-1;
 678                                                                                         itrack[i+1].vector=itrack[i].vector;
 679
 680                                                                         }else
 681                                                                                 if((unsigned char)*(data+(py-1)*h+px+1) < black) {
 682                                                                                         black = (unsigned char)*(data+(py-1)*h+px+1);
 683                                                                                                 itrack[i+1].x=px-1;
 684                                                                                                 itrack[i+1].y=py+1;
 685                                                                                                 itrack[i+1].vector=itrack[i].vector;
 686
 687                                                                                 }else
 688                                                                                         if((unsigned char)*(data+(py-1)*h+px-1) < black) {
 689                                                                                                 black = (unsigned char)*(data+(py-1)*h+px-1);
 690                                                                                                         itrack[i+1].x=px-1;
 691                                                                                                         itrack[i+1].y=py-1;
 692                                                                                                         itrack[i+1].vector=itrack[i].vector;
 693
 694                                                                                         }else
 695                                                                                                 if((unsigned char)*(data+py*h+px+1) < black) {
 696                                                                                                         black = (unsigned char)*(data+py*h+px+1);
 697                                                                                                                 itrack[i+1].x=px+2;
 698                                                                                                                 itrack[i+1].y=py;
 699                                                                                                                 itrack[i+1].vector=itrack[i].vector;
 700
 701                                                                                                 }else
 702                                                                                                         if((unsigned char)*(data+py*h+px-1) < black) {
 703                                                                                                                 black = (unsigned char)*(data+py*h+px-1);
 704                                                                                                                         itrack[i+1].x=px-1;
 705                                                                                                                         itrack[i+1].y=py;
 706                                                                                                                         itrack[i+1].vector=itrack[i].vector;
 707
 708                                                                                                         } else{
 709                                                                                                                 itrack[i+1].x=-1;
 710                                                                                                                         itrack[i+1].y=-1;
 711                                                                                                                         itrack[i+1].vector=itrack[i].vector;
 712                                                                                                                         return i;
 713                                                                                                         }
 714
 715                                 }else cry=0;
 716
 717                         }
 718
 719
 720                 }
 721         itrack[i+1].x=-1;
 722                 itrack[i+1].y=-1;
 723                 itrack[i+1].vector=itrack[i].vector;
 724                 return i;
 725 }
 726
 727 int image_trail_old(char *data, int v, int h, int offset){
 728
 729                 int x=0,y=0,vt=0;
 730                 int i=0,j=0,left=0,right=0,last=0;
 731
 732
 733                 while(j<10){
 734                         x=itrack[offset+j].x;
 735                                 y=itrack[offset+j].y;
 736                                 vt=itrack[offset+j].vector;
 737
 738                                 if(y<5 || x<1 || x>=h-1 || j+offset>49) return j;
 739                                         //if(y<20) return j;
 740
 741                                                 j++;
 742
 743                                                 left=*(data+y*h+x-1)+*(data+(y-1)*h+x-1);
 744                                                 right=*(data+y*h+x+1)+*(data+(y-1)*h+x+1);
 745
 746
 747                                                 if(left==right){
 748                                                         if(last<0) right+=1;
 749                                                         else if(last>0) left+=1;
 750                                                         else return offset+j;
 751                                                 }else if(left<right){
 752                                                         last=-1;
 753                                                                 if(*(data+y*h+x-1) < *(data+(y-1)*h+x-1)){
 754                                                                         itrack[offset+j].x=x-1;
 755                                                                                 itrack[offset+j].y=y;
 756                                                                                 itrack[offset+j].vector=-6;
 757                                                                                 *(data+y*h+x-1)=255;
 758                                                                 }else{
 759                                                                         itrack[offset+j].x=x-1;
 760                                                                                 itrack[offset+j].y=y-1;
 761                                                                                 itrack[offset+j].vector=-5;
 762                                                                                 *(data+(y-1)*h+x-1)=255;
 763                                                                 }
 764                                                 }else if(left>right){
 765                                                         last=1;
 766                                                                 if(*(data+y*h+x+1) < *(data+(y-1)*h+x+1)){
 767                                                                         itrack[offset+j].x=x+1;
 768                                                                                 itrack[offset+j].y=y;
 769                                                                                 itrack[offset+j].vector=6;
 770                                                                                 *(data+y*h+x+1)=255;
 771                                                                 }else{
 772                                                                         itrack[offset+j].x=x+1;
 773                                                                                 itrack[offset+j].y=y-1;
 774                                                                                 itrack[offset+j].vector=5;
 775                                                                                 *(data+(y-1)*h+x+1)=255;
 776                                                                 }
 777                                                 }
 778
 779                 }
 780         return j;
 781 }
 782