agast7_12s.cc
Go to the documentation of this file.
00001 //
00002 //    agast7s - AGAST, an adaptive and generic corner detector based on the
00003 //              accelerated segment test for a 12 pixel mask in square format
00004 //
00005 //    Copyright (C) 2010  Elmar Mair
00006 //
00007 //    This program is free software: you can redistribute it and/or modify
00008 //    it under the terms of the GNU General Public License as published by
00009 //    the Free Software Foundation, either version 3 of the License, or
00010 //    (at your option) any later version.
00011 //
00012 //    This program is distributed in the hope that it will be useful,
00013 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 //    GNU General Public License for more details.
00016 //
00017 //    You should have received a copy of the GNU General Public License
00018 //    along with this program.  If not, see <http://www.gnu.org/licenses/>.
00019 
00020 //machine generated code
00021 //probability of an equal pixel on the Bresenham's circle: 0.33 and 0.1
00022 //number of equal pixels to switch: 2
00023 //number of unequal pixels to switch: 9
00024 //memory costs: cache=0.2
00025 //              same line=1
00026 //              memory=4
00027 
00028 #include <stdint.h>                                                                                                                                                     
00029 #include <stdlib.h>
00030 #include "cvWrapper.h"
00031 #include "agast7_12s.h"
00032 
00033 using namespace std;
00034 using namespace agast;
00035 
00036 void AgastDetector7_12s::detect(const unsigned char* im, vector<CvPoint>& corners_all)
00037 {
00038         int total=0;
00039         int nExpectedCorners=corners_all.capacity();
00040         CvPoint h;
00041         register int x, y;
00042         register int xsizeB=xsize - 3; //2, +1 due to faster test x>xsizeB
00043         register int ysizeB=ysize - 2;
00044         register int_fast16_t offset0, offset1, offset2, offset3, offset4, offset5, offset6, offset7, offset8, offset9, offset10, offset11;
00045         register int width;
00046 
00047         corners_all.resize(0);
00048 
00049         offset0=s_offset0;
00050         offset1=s_offset1;
00051         offset2=s_offset2;
00052         offset3=s_offset3;
00053         offset4=s_offset4;
00054         offset5=s_offset5;
00055         offset6=s_offset6;
00056         offset7=s_offset7;
00057         offset8=s_offset8;
00058         offset9=s_offset9;
00059         offset10=s_offset10;
00060         offset11=s_offset11;
00061         width=xsize;
00062 
00063         for(y=2; y < ysizeB; y++)
00064         {                                                                               
00065                 x=1;
00066                 while(1)                                                        
00067                 {                                                                       
00068 homogeneous:
00069 {
00070                         x++;                    
00071                         if(x>xsizeB)    
00072                                 break;
00073                         else
00074                         {
00075                                 register const unsigned char* const p = im + y*width + x;
00076                                 register const int cb = *p + b;
00077                                 register const int c_b = *p - b;
00078                                 if(p[offset0] > cb)
00079                                   if(p[offset2] > cb)
00080                                         if(p[offset5] > cb)
00081                                           if(p[offset9] > cb)
00082                                                 if(p[offset7] > cb)
00083                                                   if(p[offset1] > cb)
00084                                                         if(p[offset6] > cb)
00085                                                           if(p[offset3] > cb)
00086                                                                 if(p[offset4] > cb)
00087                                                                   goto success_structured;
00088                                                                 else
00089                                                                   if(p[offset10] > cb)
00090                                                                         if(p[offset11] > cb)
00091                                                                           goto success_structured;
00092                                                                         else
00093                                                                           goto structured;
00094                                                                   else
00095                                                                         goto homogeneous;
00096                                                           else
00097                                                                 if(p[offset8] > cb)
00098                                                                   if(p[offset10] > cb)
00099                                                                         if(p[offset4] > cb)
00100                                                                           goto success_structured;
00101                                                                         else
00102                                                                           if(p[offset11] > cb)
00103                                                                                 goto success_structured;
00104                                                                           else
00105                                                                                 goto structured;
00106                                                                   else
00107                                                                         goto homogeneous;
00108                                                                 else
00109                                                                   goto homogeneous;
00110                                                         else
00111                                                           if(p[offset11] > cb)
00112                                                                 if(p[offset3] > cb)
00113                                                                   if(p[offset4] > cb)
00114                                                                         goto success_structured;
00115                                                                   else
00116                                                                         if(p[offset10] > cb)
00117                                                                           goto success_structured;
00118                                                                         else
00119                                                                           goto homogeneous;
00120                                                                 else
00121                                                                   if(p[offset8] > cb)
00122                                                                         if(p[offset10] > cb)
00123                                                                           goto success_structured;
00124                                                                         else
00125                                                                           goto homogeneous;
00126                                                                   else
00127                                                                         goto homogeneous;
00128                                                           else
00129                                                                 goto homogeneous;
00130                                                   else
00131                                                         if(p[offset6] > cb)
00132                                                           if(p[offset8] > cb)
00133                                                                 if(p[offset4] > cb)
00134                                                                   if(p[offset3] > cb)
00135                                                                         goto success_structured;
00136                                                                   else
00137                                                                         if(p[offset10] > cb)
00138                                                                           goto success_structured;
00139                                                                         else
00140                                                                           goto homogeneous;
00141                                                                 else
00142                                                                   if(p[offset10] > cb)
00143                                                                         if(p[offset11] > cb)
00144                                                                           goto success_structured;
00145                                                                         else
00146                                                                           goto homogeneous;
00147                                                                   else
00148                                                                         goto homogeneous;
00149                                                           else
00150                                                                 goto homogeneous;
00151                                                         else
00152                                                           goto homogeneous;
00153                                                 else
00154                                                   if(p[offset1] > cb)
00155                                                         if(p[offset11] > cb)
00156                                                           if(p[offset3] > cb)
00157                                                                 if(p[offset4] > cb)
00158                                                                   goto success_homogeneous;
00159                                                                 else
00160                                                                   if(p[offset10] > cb)
00161                                                                         goto success_homogeneous;
00162                                                                   else
00163                                                                         goto homogeneous;
00164                                                           else
00165                                                                 if(p[offset8] > cb)
00166                                                                   if(p[offset10] > cb)
00167                                                                         goto success_homogeneous;
00168                                                                   else
00169                                                                         goto homogeneous;
00170                                                                 else
00171                                                                   goto homogeneous;
00172                                                         else
00173                                                           if(p[offset6] > cb)
00174                                                                 if(p[offset3] > cb)
00175                                                                   if(p[offset4] > cb)
00176                                                                         goto success_homogeneous;
00177                                                                   else
00178                                                                         goto homogeneous;
00179                                                                 else
00180                                                                   goto homogeneous;
00181                                                           else
00182                                                                 goto homogeneous;
00183                                                   else
00184                                                         goto homogeneous;
00185                                           else
00186                                                 if(p[offset3] > cb)
00187                                                   if(p[offset4] > cb)
00188                                                         if(p[offset7] > cb)
00189                                                           if(p[offset1] > cb)
00190                                                                 if(p[offset6] > cb)
00191                                                                   goto success_homogeneous;
00192                                                                 else
00193                                                                   if(p[offset11] > cb)
00194                                                                         goto success_homogeneous;
00195                                                                   else
00196                                                                         goto homogeneous;
00197                                                           else
00198                                                                 if(p[offset6] > cb)
00199                                                                   if(p[offset8] > cb)
00200                                                                         goto success_homogeneous;
00201                                                                   else
00202                                                                         goto homogeneous;
00203                                                                 else
00204                                                                   goto homogeneous;
00205                                                         else
00206                                                           if(p[offset1] > cb)
00207                                                                 if(p[offset6] > cb)
00208                                                                   goto success_homogeneous;
00209                                                                 else
00210                                                                   if(p[offset11] > cb)
00211                                                                         goto success_homogeneous;
00212                                                                   else
00213                                                                         goto homogeneous;
00214                                                           else
00215                                                                 goto homogeneous;
00216                                                   else
00217                                                         goto homogeneous;
00218                                                 else
00219                                                   goto homogeneous;
00220                                         else
00221                                           if(p[offset9] < c_b)
00222                                                 if(p[offset7] < c_b)
00223                                                   if(p[offset5] < c_b)
00224                                                         if(p[offset1] > cb)
00225                                                           if(p[offset4] > cb)
00226                                                                 if(p[offset10] > cb)
00227                                                                   if(p[offset3] > cb)
00228                                                                         if(p[offset11] > cb)
00229                                                                           goto success_structured;
00230                                                                         else
00231                                                                           goto structured;
00232                                                                   else
00233                                                                         goto homogeneous;
00234                                                                 else
00235                                                                   if(p[offset6] < c_b)
00236                                                                         if(p[offset8] < c_b)
00237                                                                           if(p[offset11] < c_b)
00238                                                                                 if(p[offset10] < c_b)
00239                                                                                   goto success_structured;
00240                                                                                 else
00241                                                                                   goto structured;
00242                                                                           else
00243                                                                                 goto structured;
00244                                                                         else
00245                                                                           goto homogeneous;
00246                                                                   else
00247                                                                         goto homogeneous;
00248                                                           else
00249                                                                 if(p[offset6] < c_b)
00250                                                                   if(p[offset8] < c_b)
00251                                                                         if(p[offset10] < c_b)
00252                                                                           if(p[offset4] < c_b)
00253                                                                                 goto success_structured;
00254                                                                           else
00255                                                                                 if(p[offset11] < c_b)
00256                                                                                   goto success_structured;
00257                                                                                 else
00258                                                                                   goto structured;
00259                                                                         else
00260                                                                           if(p[offset3] < c_b)
00261                                                                                 if(p[offset4] < c_b)
00262                                                                                   goto success_structured;
00263                                                                                 else
00264                                                                                   goto structured;
00265                                                                           else
00266                                                                                 goto homogeneous;
00267                                                                   else
00268                                                                         goto homogeneous;
00269                                                                 else
00270                                                                   goto homogeneous;
00271                                                         else
00272                                                           if(p[offset6] < c_b)
00273                                                                 if(p[offset8] < c_b)
00274                                                                   if(p[offset4] < c_b)
00275                                                                         if(p[offset3] < c_b)
00276                                                                           goto success_structured;
00277                                                                         else
00278                                                                           if(p[offset10] < c_b)
00279                                                                                 goto success_structured;
00280                                                                           else
00281                                                                                 goto homogeneous;
00282                                                                   else
00283                                                                         if(p[offset10] < c_b)
00284                                                                           if(p[offset11] < c_b)
00285                                                                                 goto success_structured;
00286                                                                           else
00287                                                                                 goto homogeneous;
00288                                                                         else
00289                                                                           goto homogeneous;
00290                                                                 else
00291                                                                   goto homogeneous;
00292                                                           else
00293                                                                 goto homogeneous;
00294                                                   else
00295                                                         if(p[offset1] > cb)
00296                                                           if(p[offset3] > cb)
00297                                                                 if(p[offset4] > cb)
00298                                                                   if(p[offset10] > cb)
00299                                                                         if(p[offset11] > cb)
00300                                                                           goto success_structured;
00301                                                                         else
00302                                                                           goto homogeneous;
00303                                                                   else
00304                                                                         goto homogeneous;
00305                                                                 else
00306                                                                   goto homogeneous;
00307                                                           else
00308                                                                 goto homogeneous;
00309                                                         else
00310                                                           goto homogeneous;
00311                                                 else
00312                                                   if(p[offset1] > cb)
00313                                                         if(p[offset3] > cb)
00314                                                           if(p[offset4] > cb)
00315                                                                 if(p[offset10] > cb)
00316                                                                   if(p[offset11] > cb)
00317                                                                         goto success_homogeneous;
00318                                                                   else
00319                                                                         goto homogeneous;
00320                                                                 else
00321                                                                   goto homogeneous;
00322                                                           else
00323                                                                 goto homogeneous;
00324                                                         else
00325                                                           goto homogeneous;
00326                                                   else
00327                                                         goto homogeneous;
00328                                           else
00329                                                 if(p[offset10] > cb)
00330                                                   if(p[offset11] > cb)
00331                                                         if(p[offset9] > cb)
00332                                                           if(p[offset7] > cb)
00333                                                                 if(p[offset1] > cb)
00334                                                                   if(p[offset3] > cb)
00335                                                                         goto success_homogeneous;
00336                                                                   else
00337                                                                         if(p[offset8] > cb)
00338                                                                           goto success_homogeneous;
00339                                                                         else
00340                                                                           goto homogeneous;
00341                                                                 else
00342                                                                   if(p[offset6] > cb)
00343                                                                         if(p[offset8] > cb)
00344                                                                           goto success_homogeneous;
00345                                                                         else
00346                                                                           goto homogeneous;
00347                                                                   else
00348                                                                         goto homogeneous;
00349                                                           else
00350                                                                 if(p[offset1] > cb)
00351                                                                   if(p[offset3] > cb)
00352                                                                         goto success_homogeneous;
00353                                                                   else
00354                                                                         if(p[offset8] > cb)
00355                                                                           goto success_homogeneous;
00356                                                                         else
00357                                                                           goto homogeneous;
00358                                                                 else
00359                                                                   goto homogeneous;
00360                                                         else
00361                                                           if(p[offset1] > cb)
00362                                                                 if(p[offset3] > cb)
00363                                                                   if(p[offset4] > cb)
00364                                                                         goto success_homogeneous;
00365                                                                   else
00366                                                                         goto homogeneous;
00367                                                                 else
00368                                                                   goto homogeneous;
00369                                                           else
00370                                                                 goto homogeneous;
00371                                                   else
00372                                                         goto homogeneous;
00373                                                 else
00374                                                   goto homogeneous;
00375                                   else
00376                                         if(p[offset7] > cb)
00377                                           if(p[offset9] > cb)
00378                                                 if(p[offset8] > cb)
00379                                                   if(p[offset5] > cb)
00380                                                         if(p[offset1] > cb)
00381                                                           if(p[offset10] > cb)
00382                                                                 if(p[offset11] > cb)
00383                                                                   goto success_homogeneous;
00384                                                                 else
00385                                                                   if(p[offset6] > cb)
00386                                                                         if(p[offset4] > cb)
00387                                                                           goto success_structured;
00388                                                                         else
00389                                                                           goto homogeneous;
00390                                                                   else
00391                                                                         goto homogeneous;
00392                                                           else
00393                                                                 if(p[offset6] > cb)
00394                                                                   if(p[offset3] > cb)
00395                                                                         if(p[offset4] > cb)
00396                                                                           goto success_structured;
00397                                                                         else
00398                                                                           goto homogeneous;
00399                                                                   else
00400                                                                         goto homogeneous;
00401                                                                 else
00402                                                                   goto homogeneous;
00403                                                         else
00404                                                           if(p[offset6] > cb)
00405                                                                 if(p[offset4] > cb)
00406                                                                   if(p[offset3] > cb)
00407                                                                         goto success_homogeneous;
00408                                                                   else
00409                                                                         if(p[offset10] > cb)
00410                                                                           goto success_homogeneous;
00411                                                                         else
00412                                                                           goto homogeneous;
00413                                                                 else
00414                                                                   if(p[offset10] > cb)
00415                                                                         if(p[offset11] > cb)
00416                                                                           goto success_homogeneous;
00417                                                                         else
00418                                                                           goto homogeneous;
00419                                                                   else
00420                                                                         goto homogeneous;
00421                                                           else
00422                                                                 goto homogeneous;
00423                                                   else
00424                                                         if(p[offset10] > cb)
00425                                                           if(p[offset11] > cb)
00426                                                                 if(p[offset1] > cb)
00427                                                                   goto success_homogeneous;
00428                                                                 else
00429                                                                   if(p[offset6] > cb)
00430                                                                         goto success_homogeneous;
00431                                                                   else
00432                                                                         goto homogeneous;
00433                                                           else
00434                                                                 goto homogeneous;
00435                                                         else
00436                                                           goto homogeneous;
00437                                                 else
00438                                                   goto homogeneous;
00439                                           else
00440                                                 goto homogeneous;
00441                                         else
00442                                           if(p[offset7] < c_b)
00443                                                 if(p[offset5] < c_b)
00444                                                   if(p[offset2] < c_b)
00445                                                         if(p[offset6] < c_b)
00446                                                           if(p[offset4] < c_b)
00447                                                                 if(p[offset3] < c_b)
00448                                                                   if(p[offset1] < c_b)
00449                                                                         goto success_homogeneous;
00450                                                                   else
00451                                                                         if(p[offset8] < c_b)
00452                                                                           goto success_homogeneous;
00453                                                                         else
00454                                                                           goto homogeneous;
00455                                                                 else
00456                                                                   if(p[offset9] < c_b)
00457                                                                         if(p[offset8] < c_b)
00458                                                                           if(p[offset10] < c_b)
00459                                                                                 goto success_structured;
00460                                                                           else
00461                                                                                 goto homogeneous;
00462                                                                         else
00463                                                                           goto homogeneous;
00464                                                                   else
00465                                                                         goto homogeneous;
00466                                                           else
00467                                                                 if(p[offset9] < c_b)
00468                                                                   if(p[offset8] < c_b)
00469                                                                         if(p[offset10] < c_b)
00470                                                                           if(p[offset11] < c_b)
00471                                                                                 goto success_structured;
00472                                                                           else
00473                                                                                 goto homogeneous;
00474                                                                         else
00475                                                                           goto homogeneous;
00476                                                                   else
00477                                                                         goto homogeneous;
00478                                                                 else
00479                                                                   goto homogeneous;
00480                                                         else
00481                                                           goto homogeneous;
00482                                                   else
00483                                                         if(p[offset9] < c_b)
00484                                                           if(p[offset6] < c_b)
00485                                                                 if(p[offset8] < c_b)
00486                                                                   if(p[offset4] < c_b)
00487                                                                         if(p[offset3] < c_b)
00488                                                                           goto success_homogeneous;
00489                                                                         else
00490                                                                           if(p[offset10] < c_b)
00491                                                                                 goto success_homogeneous;
00492                                                                           else
00493                                                                                 goto homogeneous;
00494                                                                   else
00495                                                                         if(p[offset10] < c_b)
00496                                                                           if(p[offset11] < c_b)
00497                                                                                 goto success_homogeneous;
00498                                                                           else
00499                                                                                 goto homogeneous;
00500                                                                         else
00501                                                                           goto homogeneous;
00502                                                                 else
00503                                                                   goto homogeneous;
00504                                                           else
00505                                                                 goto homogeneous;
00506                                                         else
00507                                                           goto homogeneous;
00508                                                 else
00509                                                   goto homogeneous;
00510                                           else
00511                                                 goto homogeneous;
00512                                 else if(p[offset0] < c_b)
00513                                   if(p[offset2] < c_b)
00514                                         if(p[offset9] < c_b)
00515                                           if(p[offset5] < c_b)
00516                                                 if(p[offset7] < c_b)
00517                                                   if(p[offset1] < c_b)
00518                                                         if(p[offset6] < c_b)
00519                                                           if(p[offset3] < c_b)
00520                                                                 if(p[offset4] < c_b)
00521                                                                   goto success_structured;
00522                                                                 else
00523                                                                   if(p[offset10] < c_b)
00524                                                                         if(p[offset11] < c_b)
00525                                                                           goto success_structured;
00526                                                                         else
00527                                                                           goto structured;
00528                                                                   else
00529                                                                         goto homogeneous;
00530                                                           else
00531                                                                 if(p[offset8] < c_b)
00532                                                                   if(p[offset10] < c_b)
00533                                                                         if(p[offset4] < c_b)
00534                                                                           goto success_structured;
00535                                                                         else
00536                                                                           if(p[offset11] < c_b)
00537                                                                                 goto success_structured;
00538                                                                           else
00539                                                                                 goto structured;
00540                                                                   else
00541                                                                         goto homogeneous;
00542                                                                 else
00543                                                                   goto homogeneous;
00544                                                         else
00545                                                           if(p[offset11] < c_b)
00546                                                                 if(p[offset3] < c_b)
00547                                                                   if(p[offset4] < c_b)
00548                                                                         goto success_structured;
00549                                                                   else
00550                                                                         if(p[offset10] < c_b)
00551                                                                           goto success_structured;
00552                                                                         else
00553                                                                           goto homogeneous;
00554                                                                 else
00555                                                                   if(p[offset8] < c_b)
00556                                                                         if(p[offset10] < c_b)
00557                                                                           goto success_structured;
00558                                                                         else
00559                                                                           goto homogeneous;
00560                                                                   else
00561                                                                         goto homogeneous;
00562                                                           else
00563                                                                 goto homogeneous;
00564                                                   else
00565                                                         if(p[offset6] < c_b)
00566                                                           if(p[offset8] < c_b)
00567                                                                 if(p[offset4] < c_b)
00568                                                                   if(p[offset3] < c_b)
00569                                                                         goto success_structured;
00570                                                                   else
00571                                                                         if(p[offset10] < c_b)
00572                                                                           goto success_structured;
00573                                                                         else
00574                                                                           goto homogeneous;
00575                                                                 else
00576                                                                   if(p[offset10] < c_b)
00577                                                                         if(p[offset11] < c_b)
00578                                                                           goto success_structured;
00579                                                                         else
00580                                                                           goto homogeneous;
00581                                                                   else
00582                                                                         goto homogeneous;
00583                                                           else
00584                                                                 goto homogeneous;
00585                                                         else
00586                                                           goto homogeneous;
00587                                                 else
00588                                                   if(p[offset1] < c_b)
00589                                                         if(p[offset11] < c_b)
00590                                                           if(p[offset3] < c_b)
00591                                                                 if(p[offset4] < c_b)
00592                                                                   goto success_homogeneous;
00593                                                                 else
00594                                                                   if(p[offset10] < c_b)
00595                                                                         goto success_homogeneous;
00596                                                                   else
00597                                                                         goto homogeneous;
00598                                                           else
00599                                                                 if(p[offset8] < c_b)
00600                                                                   if(p[offset10] < c_b)
00601                                                                         goto success_homogeneous;
00602                                                                   else
00603                                                                         goto homogeneous;
00604                                                                 else
00605                                                                   goto homogeneous;
00606                                                         else
00607                                                           if(p[offset6] < c_b)
00608                                                                 if(p[offset3] < c_b)
00609                                                                   if(p[offset4] < c_b)
00610                                                                         goto success_homogeneous;
00611                                                                   else
00612                                                                         goto homogeneous;
00613                                                                 else
00614                                                                   goto homogeneous;
00615                                                           else
00616                                                                 goto homogeneous;
00617                                                   else
00618                                                         goto homogeneous;
00619                                           else
00620                                                 if(p[offset10] < c_b)
00621                                                   if(p[offset11] < c_b)
00622                                                         if(p[offset7] < c_b)
00623                                                           if(p[offset1] < c_b)
00624                                                                 if(p[offset3] < c_b)
00625                                                                   goto success_homogeneous;
00626                                                                 else
00627                                                                   if(p[offset8] < c_b)
00628                                                                         goto success_homogeneous;
00629                                                                   else
00630                                                                         goto homogeneous;
00631                                                           else
00632                                                                 if(p[offset6] < c_b)
00633                                                                   if(p[offset8] < c_b)
00634                                                                         goto success_homogeneous;
00635                                                                   else
00636                                                                         goto homogeneous;
00637                                                                 else
00638                                                                   goto homogeneous;
00639                                                         else
00640                                                           if(p[offset1] < c_b)
00641                                                                 if(p[offset3] < c_b)
00642                                                                   goto success_homogeneous;
00643                                                                 else
00644                                                                   if(p[offset8] < c_b)
00645                                                                         goto success_homogeneous;
00646                                                                   else
00647                                                                         goto homogeneous;
00648                                                           else
00649                                                                 goto homogeneous;
00650                                                   else
00651                                                         goto homogeneous;
00652                                                 else
00653                                                   goto homogeneous;
00654                                         else
00655                                           if(p[offset9] > cb)
00656                                                 if(p[offset5] > cb)
00657                                                   if(p[offset7] > cb)
00658                                                         if(p[offset1] < c_b)
00659                                                           if(p[offset4] < c_b)
00660                                                                 if(p[offset10] < c_b)
00661                                                                   if(p[offset3] < c_b)
00662                                                                         if(p[offset11] < c_b)
00663                                                                           goto success_structured;
00664                                                                         else
00665                                                                           goto structured;
00666                                                                   else
00667                                                                         goto homogeneous;
00668                                                                 else
00669                                                                   if(p[offset6] > cb)
00670                                                                         if(p[offset8] > cb)
00671                                                                           if(p[offset11] > cb)
00672                                                                                 if(p[offset10] > cb)
00673                                                                                   goto success_structured;
00674                                                                                 else
00675                                                                                   goto structured;
00676                                                                           else
00677                                                                                 goto structured;
00678                                                                         else
00679                                                                           goto homogeneous;
00680                                                                   else
00681                                                                         goto homogeneous;
00682                                                           else
00683                                                                 if(p[offset6] > cb)
00684                                                                   if(p[offset8] > cb)
00685                                                                         if(p[offset10] > cb)
00686                                                                           if(p[offset4] > cb)
00687                                                                                 goto success_structured;
00688                                                                           else
00689                                                                                 if(p[offset11] > cb)
00690                                                                                   goto success_structured;
00691                                                                                 else
00692                                                                                   goto structured;
00693                                                                         else
00694                                                                           if(p[offset3] > cb)
00695                                                                                 if(p[offset4] > cb)
00696                                                                                   goto success_structured;
00697                                                                                 else
00698                                                                                   goto structured;
00699                                                                           else
00700                                                                                 goto homogeneous;
00701                                                                   else
00702                                                                         goto homogeneous;
00703                                                                 else
00704                                                                   goto homogeneous;
00705                                                         else
00706                                                           if(p[offset6] > cb)
00707                                                                 if(p[offset8] > cb)
00708                                                                   if(p[offset4] > cb)
00709                                                                         if(p[offset3] > cb)
00710                                                                           goto success_structured;
00711                                                                         else
00712                                                                           if(p[offset10] > cb)
00713                                                                                 goto success_structured;
00714                                                                           else
00715                                                                                 goto homogeneous;
00716                                                                   else
00717                                                                         if(p[offset10] > cb)
00718                                                                           if(p[offset11] > cb)
00719                                                                                 goto success_structured;
00720                                                                           else
00721                                                                                 goto homogeneous;
00722                                                                         else
00723                                                                           goto homogeneous;
00724                                                                 else
00725                                                                   goto homogeneous;
00726                                                           else
00727                                                                 goto homogeneous;
00728                                                   else
00729                                                         if(p[offset1] < c_b)
00730                                                           if(p[offset3] < c_b)
00731                                                                 if(p[offset4] < c_b)
00732                                                                   if(p[offset10] < c_b)
00733                                                                         if(p[offset11] < c_b)
00734                                                                           goto success_structured;
00735                                                                         else
00736                                                                           goto homogeneous;
00737                                                                   else
00738                                                                         goto homogeneous;
00739                                                                 else
00740                                                                   goto homogeneous;
00741                                                           else
00742                                                                 goto homogeneous;
00743                                                         else
00744                                                           goto homogeneous;
00745                                                 else
00746                                                   if(p[offset3] < c_b)
00747                                                         if(p[offset4] < c_b)
00748                                                           if(p[offset5] < c_b)
00749                                                                 if(p[offset7] < c_b)
00750                                                                   if(p[offset1] < c_b)
00751                                                                         if(p[offset6] < c_b)
00752                                                                           goto success_structured;
00753                                                                         else
00754                                                                           if(p[offset11] < c_b)
00755                                                                                 goto success_structured;
00756                                                                           else
00757                                                                                 goto homogeneous;
00758                                                                   else
00759                                                                         if(p[offset6] < c_b)
00760                                                                           if(p[offset8] < c_b)
00761                                                                                 goto success_structured;
00762                                                                           else
00763                                                                                 goto homogeneous;
00764                                                                         else
00765                                                                           goto homogeneous;
00766                                                                 else
00767                                                                   if(p[offset1] < c_b)
00768                                                                         if(p[offset6] < c_b)
00769                                                                           goto success_homogeneous;
00770                                                                         else
00771                                                                           if(p[offset11] < c_b)
00772                                                                                 goto success_homogeneous;
00773                                                                           else
00774                                                                                 goto homogeneous;
00775                                                                   else
00776                                                                         goto homogeneous;
00777                                                           else
00778                                                                 if(p[offset1] < c_b)
00779                                                                   if(p[offset10] < c_b)
00780                                                                         if(p[offset11] < c_b)
00781                                                                           goto success_homogeneous;
00782                                                                         else
00783                                                                           goto homogeneous;
00784                                                                   else
00785                                                                         goto homogeneous;
00786                                                                 else
00787                                                                   goto homogeneous;
00788                                                         else
00789                                                           goto homogeneous;
00790                                                   else
00791                                                         goto homogeneous;
00792                                           else
00793                                                 if(p[offset3] < c_b)
00794                                                   if(p[offset4] < c_b)
00795                                                         if(p[offset5] < c_b)
00796                                                           if(p[offset7] < c_b)
00797                                                                 if(p[offset1] < c_b)
00798                                                                   if(p[offset6] < c_b)
00799                                                                         goto success_homogeneous;
00800                                                                   else
00801                                                                         if(p[offset11] < c_b)
00802                                                                           goto success_homogeneous;
00803                                                                         else
00804                                                                           goto homogeneous;
00805                                                                 else
00806                                                                   if(p[offset6] < c_b)
00807                                                                         if(p[offset8] < c_b)
00808                                                                           goto success_homogeneous;
00809                                                                         else
00810                                                                           goto homogeneous;
00811                                                                   else
00812                                                                         goto homogeneous;
00813                                                           else
00814                                                                 if(p[offset1] < c_b)
00815                                                                   if(p[offset6] < c_b)
00816                                                                         goto success_homogeneous;
00817                                                                   else
00818                                                                         if(p[offset11] < c_b)
00819                                                                           goto success_homogeneous;
00820                                                                         else
00821                                                                           goto homogeneous;
00822                                                                 else
00823                                                                   goto homogeneous;
00824                                                         else
00825                                                           if(p[offset1] < c_b)
00826                                                                 if(p[offset10] < c_b)
00827                                                                   if(p[offset11] < c_b)
00828                                                                         goto success_homogeneous;
00829                                                                   else
00830                                                                         goto homogeneous;
00831                                                                 else
00832                                                                   goto homogeneous;
00833                                                           else
00834                                                                 goto homogeneous;
00835                                                   else
00836                                                         goto homogeneous;
00837                                                 else
00838                                                   goto homogeneous;
00839                                   else
00840                                         if(p[offset7] > cb)
00841                                           if(p[offset5] > cb)
00842                                                 if(p[offset2] > cb)
00843                                                   if(p[offset6] > cb)
00844                                                         if(p[offset4] > cb)
00845                                                           if(p[offset3] > cb)
00846                                                                 if(p[offset1] > cb)
00847                                                                   goto success_homogeneous;
00848                                                                 else
00849                                                                   if(p[offset8] > cb)
00850                                                                         goto success_homogeneous;
00851                                                                   else
00852                                                                         goto homogeneous;
00853                                                           else
00854                                                                 if(p[offset9] > cb)
00855                                                                   if(p[offset8] > cb)
00856                                                                         if(p[offset10] > cb)
00857                                                                           goto success_structured;
00858                                                                         else
00859                                                                           goto homogeneous;
00860                                                                   else
00861                                                                         goto homogeneous;
00862                                                                 else
00863                                                                   goto homogeneous;
00864                                                         else
00865                                                           if(p[offset9] > cb)
00866                                                                 if(p[offset8] > cb)
00867                                                                   if(p[offset10] > cb)
00868                                                                         if(p[offset11] > cb)
00869                                                                           goto success_structured;
00870                                                                         else
00871                                                                           goto homogeneous;
00872                                                                   else
00873                                                                         goto homogeneous;
00874                                                                 else
00875                                                                   goto homogeneous;
00876                                                           else
00877                                                                 goto homogeneous;
00878                                                   else
00879                                                         goto homogeneous;
00880                                                 else
00881                                                   if(p[offset9] > cb)
00882                                                         if(p[offset6] > cb)
00883                                                           if(p[offset8] > cb)
00884                                                                 if(p[offset4] > cb)
00885                                                                   if(p[offset3] > cb)
00886                                                                         goto success_homogeneous;
00887                                                                   else
00888                                                                         if(p[offset10] > cb)
00889                                                                           goto success_homogeneous;
00890                                                                         else
00891                                                                           goto homogeneous;
00892                                                                 else
00893                                                                   if(p[offset10] > cb)
00894                                                                         if(p[offset11] > cb)
00895                                                                           goto success_homogeneous;
00896                                                                         else
00897                                                                           goto homogeneous;
00898                                                                   else
00899                                                                         goto homogeneous;
00900                                                           else
00901                                                                 goto homogeneous;
00902                                                         else
00903                                                           goto homogeneous;
00904                                                   else
00905                                                         goto homogeneous;
00906                                           else
00907                                                 goto homogeneous;
00908                                         else
00909                                           if(p[offset7] < c_b)
00910                                                 if(p[offset9] < c_b)
00911                                                   if(p[offset8] < c_b)
00912                                                         if(p[offset5] < c_b)
00913                                                           if(p[offset1] < c_b)
00914                                                                 if(p[offset10] < c_b)
00915                                                                   if(p[offset11] < c_b)
00916                                                                         goto success_homogeneous;
00917                                                                   else
00918                                                                         if(p[offset6] < c_b)
00919                                                                           if(p[offset4] < c_b)
00920                                                                                 goto success_structured;
00921                                                                           else
00922                                                                                 goto homogeneous;
00923                                                                         else
00924                                                                           goto homogeneous;
00925                                                                 else
00926                                                                   if(p[offset6] < c_b)
00927                                                                         if(p[offset3] < c_b)
00928                                                                           if(p[offset4] < c_b)
00929                                                                                 goto success_structured;
00930                                                                           else
00931                                                                                 goto homogeneous;
00932                                                                         else
00933                                                                           goto homogeneous;
00934                                                                   else
00935                                                                         goto homogeneous;
00936                                                           else
00937                                                                 if(p[offset6] < c_b)
00938                                                                   if(p[offset4] < c_b)
00939                                                                         if(p[offset3] < c_b)
00940                                                                           goto success_homogeneous;
00941                                                                         else
00942                                                                           if(p[offset10] < c_b)
00943                                                                                 goto success_homogeneous;
00944                                                                           else
00945                                                                                 goto homogeneous;
00946                                                                   else
00947                                                                         if(p[offset10] < c_b)
00948                                                                           if(p[offset11] < c_b)
00949                                                                                 goto success_homogeneous;
00950                                                                           else
00951                                                                                 goto homogeneous;
00952                                                                         else
00953                                                                           goto homogeneous;
00954                                                                 else
00955                                                                   goto homogeneous;
00956                                                         else
00957                                                           if(p[offset10] < c_b)
00958                                                                 if(p[offset11] < c_b)
00959                                                                   if(p[offset1] < c_b)
00960                                                                         goto success_homogeneous;
00961                                                                   else
00962                                                                         if(p[offset6] < c_b)
00963                                                                           goto success_homogeneous;
00964                                                                         else
00965                                                                           goto homogeneous;
00966                                                                 else
00967                                                                   goto homogeneous;
00968                                                           else
00969                                                                 goto homogeneous;
00970                                                   else
00971                                                         goto homogeneous;
00972                                                 else
00973                                                   goto homogeneous;
00974                                           else
00975                                                 goto homogeneous;
00976                                 else
00977                                   if(p[offset5] > cb)
00978                                         if(p[offset7] > cb)
00979                                           if(p[offset9] > cb)
00980                                                 if(p[offset6] > cb)
00981                                                   if(p[offset4] > cb)
00982                                                         if(p[offset3] > cb)
00983                                                           if(p[offset8] > cb)
00984                                                                 goto success_homogeneous;
00985                                                           else
00986                                                                 if(p[offset1] > cb)
00987                                                                   if(p[offset2] > cb)
00988                                                                         goto success_homogeneous;
00989                                                                   else
00990                                                                         goto homogeneous;
00991                                                                 else
00992                                                                   goto homogeneous;
00993                                                         else
00994                                                           if(p[offset8] > cb)
00995                                                                 if(p[offset10] > cb)
00996                                                                   goto success_homogeneous;
00997                                                                 else
00998                                                                   goto homogeneous;
00999                                                           else
01000                                                                 goto homogeneous;
01001                                                   else
01002                                                         if(p[offset11] > cb)
01003                                                           if(p[offset8] > cb)
01004                                                                 if(p[offset10] > cb)
01005                                                                   goto success_homogeneous;
01006                                                                 else
01007                                                                   goto homogeneous;
01008                                                           else
01009                                                                 goto homogeneous;
01010                                                         else
01011                                                           goto homogeneous;
01012                                                 else
01013                                                   goto homogeneous;
01014                                           else
01015                                                 if(p[offset2] > cb)
01016                                                   if(p[offset3] > cb)
01017                                                         if(p[offset4] > cb)
01018                                                           if(p[offset1] > cb)
01019                                                                 if(p[offset6] > cb)
01020                                                                   goto success_homogeneous;
01021                                                                 else
01022                                                                   goto homogeneous;
01023                                                           else
01024                                                                 if(p[offset6] > cb)
01025                                                                   if(p[offset8] > cb)
01026                                                                         goto success_homogeneous;
01027                                                                   else
01028                                                                         goto homogeneous;
01029                                                                 else
01030                                                                   goto homogeneous;
01031                                                         else
01032                                                           goto homogeneous;
01033                                                   else
01034                                                         goto homogeneous;
01035                                                 else
01036                                                   goto homogeneous;
01037                                         else
01038                                           goto homogeneous;
01039                                   else
01040                                         if(p[offset5] < c_b)
01041                                           if(p[offset7] < c_b)
01042                                                 if(p[offset9] < c_b)
01043                                                   if(p[offset6] < c_b)
01044                                                         if(p[offset4] < c_b)
01045                                                           if(p[offset3] < c_b)
01046                                                                 if(p[offset8] < c_b)
01047                                                                   goto success_homogeneous;
01048                                                                 else
01049                                                                   if(p[offset1] < c_b)
01050                                                                         if(p[offset2] < c_b)
01051                                                                           goto success_homogeneous;
01052                                                                         else
01053                                                                           goto homogeneous;
01054                                                                   else
01055                                                                         goto homogeneous;
01056                                                           else
01057                                                                 if(p[offset8] < c_b)
01058                                                                   if(p[offset10] < c_b)
01059                                                                         goto success_homogeneous;
01060                                                                   else
01061                                                                         goto homogeneous;
01062                                                                 else
01063                                                                   goto homogeneous;
01064                                                         else
01065                                                           if(p[offset11] < c_b)
01066                                                                 if(p[offset8] < c_b)
01067                                                                   if(p[offset10] < c_b)
01068                                                                         goto success_homogeneous;
01069                                                                   else
01070                                                                         goto homogeneous;
01071                                                                 else
01072                                                                   goto homogeneous;
01073                                                           else
01074                                                                 goto homogeneous;
01075                                                   else
01076                                                         goto homogeneous;
01077                                                 else
01078                                                   if(p[offset2] < c_b)
01079                                                         if(p[offset3] < c_b)
01080                                                           if(p[offset4] < c_b)
01081                                                                 if(p[offset1] < c_b)
01082                                                                   if(p[offset6] < c_b)
01083                                                                         goto success_homogeneous;
01084                                                                   else
01085                                                                         goto homogeneous;
01086                                                                 else
01087                                                                   if(p[offset6] < c_b)
01088                                                                         if(p[offset8] < c_b)
01089                                                                           goto success_homogeneous;
01090                                                                         else
01091                                                                           goto homogeneous;
01092                                                                   else
01093                                                                         goto homogeneous;
01094                                                           else
01095                                                                 goto homogeneous;
01096                                                         else
01097                                                           goto homogeneous;
01098                                                   else
01099                                                         goto homogeneous;
01100                                           else
01101                                                 goto homogeneous;
01102                                         else
01103                                           goto homogeneous;
01104                         }
01105 }
01106 structured:
01107 {
01108                         x++;                    
01109                         if(x>xsizeB)    
01110                                 break;          
01111                         else
01112                         {
01113                                 register const unsigned char* const p = im + y*width + x;
01114                                 register const int cb = *p + b;
01115                                 register const int c_b = *p - b;
01116                                 if(p[offset0] > cb)
01117                                   if(p[offset2] > cb)
01118                                         if(p[offset5] > cb)
01119                                           if(p[offset9] > cb)
01120                                                 if(p[offset7] > cb)
01121                                                   if(p[offset1] > cb)
01122                                                         if(p[offset6] > cb)
01123                                                           if(p[offset3] > cb)
01124                                                                 if(p[offset4] > cb)
01125                                                                   goto success_structured;
01126                                                                 else
01127                                                                   if(p[offset10] > cb)
01128                                                                         if(p[offset11] > cb)
01129                                                                           goto success_structured;
01130                                                                         else
01131                                                                           goto structured;
01132                                                                   else
01133                                                                         goto structured;
01134                                                           else
01135                                                                 if(p[offset8] > cb)
01136                                                                   if(p[offset10] > cb)
01137                                                                         if(p[offset4] > cb)
01138                                                                           goto success_structured;
01139                                                                         else
01140                                                                           if(p[offset11] > cb)
01141                                                                                 goto success_structured;
01142                                                                           else
01143                                                                                 goto structured;
01144                                                                   else
01145                                                                         goto structured;
01146                                                                 else
01147                                                                   goto structured;
01148                                                         else
01149                                                           if(p[offset11] > cb)
01150                                                                 if(p[offset3] > cb)
01151                                                                   if(p[offset4] > cb)
01152                                                                         goto success_structured;
01153                                                                   else
01154                                                                         if(p[offset10] > cb)
01155                                                                           goto success_structured;
01156                                                                         else
01157                                                                           goto structured;
01158                                                                 else
01159                                                                   if(p[offset8] > cb)
01160                                                                         if(p[offset10] > cb)
01161                                                                           goto success_structured;
01162                                                                         else
01163                                                                           goto structured;
01164                                                                   else
01165                                                                         goto structured;
01166                                                           else
01167                                                                 goto structured;
01168                                                   else
01169                                                         if(p[offset6] > cb)
01170                                                           if(p[offset8] > cb)
01171                                                                 if(p[offset4] > cb)
01172                                                                   if(p[offset3] > cb)
01173                                                                         goto success_structured;
01174                                                                   else
01175                                                                         if(p[offset10] > cb)
01176                                                                           goto success_structured;
01177                                                                         else
01178                                                                           goto structured;
01179                                                                 else
01180                                                                   if(p[offset10] > cb)
01181                                                                         if(p[offset11] > cb)
01182                                                                           goto success_structured;
01183                                                                         else
01184                                                                           goto structured;
01185                                                                   else
01186                                                                         goto structured;
01187                                                           else
01188                                                                 goto structured;
01189                                                         else
01190                                                           goto structured;
01191                                                 else
01192                                                   if(p[offset1] > cb)
01193                                                         if(p[offset11] > cb)
01194                                                           if(p[offset3] > cb)
01195                                                                 if(p[offset4] > cb)
01196                                                                   goto success_structured;
01197                                                                 else
01198                                                                   if(p[offset10] > cb)
01199                                                                         goto success_structured;
01200                                                                   else
01201                                                                         goto structured;
01202                                                           else
01203                                                                 if(p[offset8] > cb)
01204                                                                   if(p[offset10] > cb)
01205                                                                         goto success_structured;
01206                                                                   else
01207                                                                         goto structured;
01208                                                                 else
01209                                                                   goto structured;
01210                                                         else
01211                                                           if(p[offset6] > cb)
01212                                                                 if(p[offset3] > cb)
01213                                                                   if(p[offset4] > cb)
01214                                                                         goto success_structured;
01215                                                                   else
01216                                                                         goto structured;
01217                                                                 else
01218                                                                   goto structured;
01219                                                           else
01220                                                                 goto structured;
01221                                                   else
01222                                                         goto structured;
01223                                           else
01224                                                 if(p[offset3] > cb)
01225                                                   if(p[offset4] > cb)
01226                                                         if(p[offset7] > cb)
01227                                                           if(p[offset1] > cb)
01228                                                                 if(p[offset6] > cb)
01229                                                                   goto success_structured;
01230                                                                 else
01231                                                                   if(p[offset11] > cb)
01232                                                                         goto success_structured;
01233                                                                   else
01234                                                                         goto structured;
01235                                                           else
01236                                                                 if(p[offset6] > cb)
01237                                                                   if(p[offset8] > cb)
01238                                                                         goto success_structured;
01239                                                                   else
01240                                                                         goto structured;
01241                                                                 else
01242                                                                   goto structured;
01243                                                         else
01244                                                           if(p[offset1] > cb)
01245                                                                 if(p[offset6] > cb)
01246                                                                   goto success_structured;
01247                                                                 else
01248                                                                   if(p[offset11] > cb)
01249                                                                         goto success_structured;
01250                                                                   else
01251                                                                         goto structured;
01252                                                           else
01253                                                                 goto structured;
01254                                                   else
01255                                                         goto structured;
01256                                                 else
01257                                                   goto structured;
01258                                         else
01259                                           if(p[offset7] < c_b)
01260                                                 if(p[offset9] < c_b)
01261                                                   if(p[offset5] < c_b)
01262                                                         if(p[offset1] > cb)
01263                                                           if(p[offset4] > cb)
01264                                                                 if(p[offset10] > cb)
01265                                                                   if(p[offset3] > cb)
01266                                                                         if(p[offset11] > cb)
01267                                                                           goto success_structured;
01268                                                                         else
01269                                                                           goto structured;
01270                                                                   else
01271                                                                         goto structured;
01272                                                                 else
01273                                                                   if(p[offset6] < c_b)
01274                                                                         if(p[offset8] < c_b)
01275                                                                           if(p[offset11] < c_b)
01276                                                                                 if(p[offset10] < c_b)
01277                                                                                   goto success_structured;
01278                                                                                 else
01279                                                                                   goto structured;
01280                                                                           else
01281                                                                                 goto structured;
01282                                                                         else
01283                                                                           goto structured;
01284                                                                   else
01285                                                                         goto structured;
01286                                                           else
01287                                                                 if(p[offset6] < c_b)
01288                                                                   if(p[offset8] < c_b)
01289                                                                         if(p[offset10] < c_b)
01290                                                                           if(p[offset4] < c_b)
01291                                                                                 goto success_structured;
01292                                                                           else
01293                                                                                 if(p[offset11] < c_b)
01294                                                                                   goto success_structured;
01295                                                                                 else
01296                                                                                   goto structured;
01297                                                                         else
01298                                                                           if(p[offset3] < c_b)
01299                                                                                 if(p[offset4] < c_b)
01300                                                                                   goto success_structured;
01301                                                                                 else
01302                                                                                   goto structured;
01303                                                                           else
01304                                                                                 goto structured;
01305                                                                   else
01306                                                                         goto structured;
01307                                                                 else
01308                                                                   goto structured;
01309                                                         else
01310                                                           if(p[offset6] < c_b)
01311                                                                 if(p[offset8] < c_b)
01312                                                                   if(p[offset4] < c_b)
01313                                                                         if(p[offset3] < c_b)
01314                                                                           goto success_structured;
01315                                                                         else
01316                                                                           if(p[offset10] < c_b)
01317                                                                                 goto success_structured;
01318                                                                           else
01319                                                                                 goto structured;
01320                                                                   else
01321                                                                         if(p[offset10] < c_b)
01322                                                                           if(p[offset11] < c_b)
01323                                                                                 goto success_structured;
01324                                                                           else
01325                                                                                 goto structured;
01326                                                                         else
01327                                                                           goto structured;
01328                                                                 else
01329                                                                   goto structured;
01330                                                           else
01331                                                                 goto structured;
01332                                                   else
01333                                                         if(p[offset1] > cb)
01334                                                           if(p[offset3] > cb)
01335                                                                 if(p[offset4] > cb)
01336                                                                   if(p[offset10] > cb)
01337                                                                         if(p[offset11] > cb)
01338                                                                           goto success_structured;
01339                                                                         else
01340                                                                           goto structured;
01341                                                                   else
01342                                                                         goto structured;
01343                                                                 else
01344                                                                   goto structured;
01345                                                           else
01346                                                                 goto structured;
01347                                                         else
01348                                                           goto structured;
01349                                                 else
01350                                                   if(p[offset10] > cb)
01351                                                         if(p[offset11] > cb)
01352                                                           if(p[offset9] > cb)
01353                                                                 if(p[offset1] > cb)
01354                                                                   if(p[offset3] > cb)
01355                                                                         goto success_structured;
01356                                                                   else
01357                                                                         if(p[offset8] > cb)
01358                                                                           goto success_structured;
01359                                                                         else
01360                                                                           goto structured;
01361                                                                 else
01362                                                                   goto structured;
01363                                                           else
01364                                                                 if(p[offset1] > cb)
01365                                                                   if(p[offset3] > cb)
01366                                                                         if(p[offset4] > cb)
01367                                                                           goto success_structured;
01368                                                                         else
01369                                                                           goto structured;
01370                                                                   else
01371                                                                         goto structured;
01372                                                                 else
01373                                                                   goto structured;
01374                                                         else
01375                                                           goto structured;
01376                                                   else
01377                                                         goto structured;
01378                                           else
01379                                                 if(p[offset10] > cb)
01380                                                   if(p[offset11] > cb)
01381                                                         if(p[offset9] > cb)
01382                                                           if(p[offset1] > cb)
01383                                                                 if(p[offset3] > cb)
01384                                                                   goto success_structured;
01385                                                                 else
01386                                                                   if(p[offset8] > cb)
01387                                                                         goto success_structured;
01388                                                                   else
01389                                                                         goto structured;
01390                                                           else
01391                                                                 if(p[offset6] > cb)
01392                                                                   if(p[offset8] > cb)
01393                                                                         if(p[offset7] > cb)
01394                                                                           goto success_structured;
01395                                                                         else
01396                                                                           goto structured;
01397                                                                   else
01398                                                                         goto structured;
01399                                                                 else
01400                                                                   goto structured;
01401                                                         else
01402                                                           if(p[offset1] > cb)
01403                                                                 if(p[offset3] > cb)
01404                                                                   if(p[offset4] > cb)
01405                                                                         goto success_structured;
01406                                                                   else
01407                                                                         goto structured;
01408                                                                 else
01409                                                                   goto structured;
01410                                                           else
01411                                                                 goto structured;
01412                                                   else
01413                                                         goto structured;
01414                                                 else
01415                                                   goto structured;
01416                                   else
01417                                         if(p[offset7] > cb)
01418                                           if(p[offset9] > cb)
01419                                                 if(p[offset8] > cb)
01420                                                   if(p[offset5] > cb)
01421                                                         if(p[offset1] > cb)
01422                                                           if(p[offset10] > cb)
01423                                                                 if(p[offset11] > cb)
01424                                                                   goto success_structured;
01425                                                                 else
01426                                                                   if(p[offset6] > cb)
01427                                                                         if(p[offset4] > cb)
01428                                                                           goto success_structured;
01429                                                                         else
01430                                                                           goto structured;
01431                                                                   else
01432                                                                         goto structured;
01433                                                           else
01434                                                                 if(p[offset6] > cb)
01435                                                                   if(p[offset3] > cb)
01436                                                                         if(p[offset4] > cb)
01437                                                                           goto success_structured;
01438                                                                         else
01439                                                                           goto structured;
01440                                                                   else
01441                                                                         goto structured;
01442                                                                 else
01443                                                                   goto structured;
01444                                                         else
01445                                                           if(p[offset6] > cb)
01446                                                                 if(p[offset4] > cb)
01447                                                                   if(p[offset3] > cb)
01448                                                                         goto success_structured;
01449                                                                   else
01450                                                                         if(p[offset10] > cb)
01451                                                                           goto success_structured;
01452                                                                         else
01453                                                                           goto structured;
01454                                                                 else
01455                                                                   if(p[offset10] > cb)
01456                                                                         if(p[offset11] > cb)
01457                                                                           goto success_structured;
01458                                                                         else
01459                                                                           goto structured;
01460                                                                   else
01461                                                                         goto structured;
01462                                                           else
01463                                                                 goto structured;
01464                                                   else
01465                                                         if(p[offset10] > cb)
01466                                                           if(p[offset11] > cb)
01467                                                                 if(p[offset1] > cb)
01468                                                                   goto success_structured;
01469                                                                 else
01470                                                                   if(p[offset6] > cb)
01471                                                                         goto success_structured;
01472                                                                   else
01473                                                                         goto structured;
01474                                                           else
01475                                                                 goto structured;
01476                                                         else
01477                                                           goto structured;
01478                                                 else
01479                                                   goto structured;
01480                                           else
01481                                                 goto structured;
01482                                         else
01483                                           if(p[offset7] < c_b)
01484                                                 if(p[offset5] < c_b)
01485                                                   if(p[offset2] < c_b)
01486                                                         if(p[offset6] < c_b)
01487                                                           if(p[offset4] < c_b)
01488                                                                 if(p[offset3] < c_b)
01489                                                                   if(p[offset1] < c_b)
01490                                                                         goto success_structured;
01491                                                                   else
01492                                                                         if(p[offset8] < c_b)
01493                                                                           goto success_structured;
01494                                                                         else
01495                                                                           goto structured;
01496                                                                 else
01497                                                                   if(p[offset9] < c_b)
01498                                                                         if(p[offset8] < c_b)
01499                                                                           if(p[offset10] < c_b)
01500                                                                                 goto success_structured;
01501                                                                           else
01502                                                                                 goto structured;
01503                                                                         else
01504                                                                           goto structured;
01505                                                                   else
01506                                                                         goto structured;
01507                                                           else
01508                                                                 if(p[offset9] < c_b)
01509                                                                   if(p[offset8] < c_b)
01510                                                                         if(p[offset10] < c_b)
01511                                                                           if(p[offset11] < c_b)
01512                                                                                 goto success_structured;
01513                                                                           else
01514                                                                                 goto structured;
01515                                                                         else
01516                                                                           goto structured;
01517                                                                   else
01518                                                                         goto structured;
01519                                                                 else
01520                                                                   goto structured;
01521                                                         else
01522                                                           goto structured;
01523                                                   else
01524                                                         if(p[offset9] < c_b)
01525                                                           if(p[offset6] < c_b)
01526                                                                 if(p[offset8] < c_b)
01527                                                                   if(p[offset4] < c_b)
01528                                                                         if(p[offset3] < c_b)
01529                                                                           goto success_structured;
01530                                                                         else
01531                                                                           if(p[offset10] < c_b)
01532                                                                                 goto success_structured;
01533                                                                           else
01534                                                                                 goto structured;
01535                                                                   else
01536                                                                         if(p[offset10] < c_b)
01537                                                                           if(p[offset11] < c_b)
01538                                                                                 goto success_structured;
01539                                                                           else
01540                                                                                 goto structured;
01541                                                                         else
01542                                                                           goto structured;
01543                                                                 else
01544                                                                   goto structured;
01545                                                           else
01546                                                                 goto structured;
01547                                                         else
01548                                                           goto structured;
01549                                                 else
01550                                                   goto structured;
01551                                           else
01552                                                 goto structured;
01553                                 else if(p[offset0] < c_b)
01554                                   if(p[offset2] < c_b)
01555                                         if(p[offset11] < c_b)
01556                                           if(p[offset3] < c_b)
01557                                                 if(p[offset5] < c_b)
01558                                                   if(p[offset9] < c_b)
01559                                                         if(p[offset7] < c_b)
01560                                                           if(p[offset1] < c_b)
01561                                                                 if(p[offset4] < c_b)
01562                                                                   goto success_structured;
01563                                                                 else
01564                                                                   if(p[offset10] < c_b)
01565                                                                         goto success_structured;
01566                                                                   else
01567                                                                         goto structured;
01568                                                           else
01569                                                                 if(p[offset6] < c_b)
01570                                                                   if(p[offset8] < c_b)
01571                                                                         if(p[offset4] < c_b)
01572                                                                           goto success_structured;
01573                                                                         else
01574                                                                           if(p[offset10] < c_b)
01575                                                                                 goto success_structured;
01576                                                                           else
01577                                                                                 goto structured;
01578                                                                   else
01579                                                                         goto structured;
01580                                                                 else
01581                                                                   goto structured;
01582                                                         else
01583                                                           if(p[offset1] < c_b)
01584                                                                 if(p[offset4] < c_b)
01585                                                                   goto success_structured;
01586                                                                 else
01587                                                                   if(p[offset10] < c_b)
01588                                                                         goto success_structured;
01589                                                                   else
01590                                                                         goto structured;
01591                                                           else
01592                                                                 goto structured;
01593                                                   else
01594                                                         if(p[offset4] < c_b)
01595                                                           if(p[offset7] < c_b)
01596                                                                 if(p[offset1] < c_b)
01597                                                                   goto success_structured;
01598                                                                 else
01599                                                                   if(p[offset6] < c_b)
01600                                                                         if(p[offset8] < c_b)
01601                                                                           goto success_structured;
01602                                                                         else
01603                                                                           goto structured;
01604                                                                   else
01605                                                                         goto structured;
01606                                                           else
01607                                                                 if(p[offset1] < c_b)
01608                                                                   goto success_structured;
01609                                                                 else
01610                                                                   goto structured;
01611                                                         else
01612                                                           goto structured;
01613                                                 else
01614                                                   if(p[offset10] < c_b)
01615                                                         if(p[offset9] < c_b)
01616                                                           if(p[offset7] < c_b)
01617                                                                 if(p[offset1] < c_b)
01618                                                                   goto success_structured;
01619                                                                 else
01620                                                                   if(p[offset6] < c_b)
01621                                                                         if(p[offset8] < c_b)
01622                                                                           goto success_structured;
01623                                                                         else
01624                                                                           goto structured;
01625                                                                   else
01626                                                                         goto structured;
01627                                                           else
01628                                                                 if(p[offset1] < c_b)
01629                                                                   goto success_structured;
01630                                                                 else
01631                                                                   goto structured;
01632                                                         else
01633                                                           if(p[offset1] < c_b)
01634                                                                 if(p[offset4] < c_b)
01635                                                                   goto success_structured;
01636                                                                 else
01637                                                                   goto structured;
01638                                                           else
01639                                                                 goto structured;
01640                                                   else
01641                                                         if(p[offset7] > cb)
01642                                                           if(p[offset9] > cb)
01643                                                                 if(p[offset5] > cb)
01644                                                                   if(p[offset4] > cb)
01645                                                                         if(p[offset6] > cb)
01646                                                                           if(p[offset8] > cb)
01647                                                                                 if(p[offset10] > cb)
01648                                                                                   goto success_structured;
01649                                                                                 else
01650                                                                                   goto structured;
01651                                                                           else
01652                                                                                 goto structured;
01653                                                                         else
01654                                                                           goto structured;
01655                                                                   else
01656                                                                         goto structured;
01657                                                                 else
01658                                                                   goto structured;
01659                                                           else
01660                                                                 goto structured;
01661                                                         else
01662                                                           goto structured;
01663                                           else
01664                                                 if(p[offset9] < c_b)
01665                                                   if(p[offset8] < c_b)
01666                                                         if(p[offset10] < c_b)
01667                                                           if(p[offset7] < c_b)
01668                                                                 if(p[offset1] < c_b)
01669                                                                   goto success_structured;
01670                                                                 else
01671                                                                   if(p[offset6] < c_b)
01672                                                                         goto success_structured;
01673                                                                   else
01674                                                                         goto structured;
01675                                                           else
01676                                                                 if(p[offset1] < c_b)
01677                                                                   goto success_structured;
01678                                                                 else
01679                                                                   goto structured;
01680                                                         else
01681                                                           goto structured;
01682                                                   else
01683                                                         goto structured;
01684                                                 else
01685                                                   if(p[offset5] > cb)
01686                                                         if(p[offset7] > cb)
01687                                                           if(p[offset9] > cb)
01688                                                                 if(p[offset4] > cb)
01689                                                                   if(p[offset6] > cb)
01690                                                                         if(p[offset8] > cb)
01691                                                                           if(p[offset3] > cb)
01692                                                                                 goto success_structured;
01693                                                                           else
01694                                                                                 if(p[offset10] > cb)
01695                                                                                   goto success_structured;
01696                                                                                 else
01697                                                                                   goto structured;
01698                                                                         else
01699                                                                           goto structured;
01700                                                                   else
01701                                                                         goto structured;
01702                                                                 else
01703                                                                   goto structured;
01704                                                           else
01705                                                                 goto structured;
01706                                                         else
01707                                                           goto structured;
01708                                                   else
01709                                                         goto structured;
01710                                         else
01711                                           if(p[offset4] < c_b)
01712                                                 if(p[offset5] < c_b)
01713                                                   if(p[offset7] < c_b)
01714                                                         if(p[offset6] < c_b)
01715                                                           if(p[offset3] < c_b)
01716                                                                 if(p[offset1] < c_b)
01717                                                                   goto success_structured;
01718                                                                 else
01719                                                                   if(p[offset8] < c_b)
01720                                                                         goto success_structured;
01721                                                                   else
01722                                                                         goto structured;
01723                                                           else
01724                                                                 if(p[offset9] < c_b)
01725                                                                   if(p[offset8] < c_b)
01726                                                                         if(p[offset10] < c_b)
01727                                                                           goto success_structured;
01728                                                                         else
01729                                                                           goto structured;
01730                                                                   else
01731                                                                         goto structured;
01732                                                                 else
01733                                                                   goto structured;
01734                                                         else
01735                                                           goto structured;
01736                                                   else
01737                                                         if(p[offset1] < c_b)
01738                                                           if(p[offset6] < c_b)
01739                                                                 if(p[offset3] < c_b)
01740                                                                   goto success_structured;
01741                                                                 else
01742                                                                   goto structured;
01743                                                           else
01744                                                                 goto structured;
01745                                                         else
01746                                                           goto structured;
01747                                                 else
01748                                                   if(p[offset7] > cb)
01749                                                         if(p[offset9] > cb)
01750                                                           if(p[offset5] > cb)
01751                                                                 if(p[offset6] > cb)
01752                                                                   if(p[offset8] > cb)
01753                                                                         if(p[offset10] > cb)
01754                                                                           if(p[offset11] > cb)
01755                                                                                 goto success_structured;
01756                                                                           else
01757                                                                                 goto structured;
01758                                                                         else
01759                                                                           goto structured;
01760                                                                   else
01761                                                                         goto structured;
01762                                                                 else
01763                                                                   goto structured;
01764                                                           else
01765                                                                 goto structured;
01766                                                         else
01767                                                           goto structured;
01768                                                   else
01769                                                         goto structured;
01770                                           else
01771                                                 if(p[offset5] > cb)
01772                                                   if(p[offset7] > cb)
01773                                                         if(p[offset9] > cb)
01774                                                           if(p[offset6] > cb)
01775                                                                 if(p[offset8] > cb)
01776                                                                   if(p[offset10] > cb)
01777                                                                         if(p[offset4] > cb)
01778                                                                           goto success_structured;
01779                                                                         else
01780                                                                           if(p[offset11] > cb)
01781                                                                                 goto success_structured;
01782                                                                           else
01783                                                                                 goto homogeneous;
01784                                                                   else
01785                                                                         if(p[offset3] > cb)
01786                                                                           if(p[offset4] > cb)
01787                                                                                 goto success_structured;
01788                                                                           else
01789                                                                                 goto structured;
01790                                                                         else
01791                                                                           goto structured;
01792                                                                 else
01793                                                                   goto structured;
01794                                                           else
01795                                                                 goto structured;
01796                                                         else
01797                                                           goto structured;
01798                                                   else
01799                                                         goto structured;
01800                                                 else
01801                                                   goto structured;
01802                                   else
01803                                         if(p[offset7] > cb)
01804                                           if(p[offset5] > cb)
01805                                                 if(p[offset2] > cb)
01806                                                   if(p[offset6] > cb)
01807                                                         if(p[offset4] > cb)
01808                                                           if(p[offset3] > cb)
01809                                                                 if(p[offset1] > cb)
01810                                                                   goto success_structured;
01811                                                                 else
01812                                                                   if(p[offset8] > cb)
01813                                                                         goto success_structured;
01814                                                                   else
01815                                                                         goto structured;
01816                                                           else
01817                                                                 if(p[offset9] > cb)
01818                                                                   if(p[offset8] > cb)
01819                                                                         if(p[offset10] > cb)
01820                                                                           goto success_structured;
01821                                                                         else
01822                                                                           goto structured;
01823                                                                   else
01824                                                                         goto structured;
01825                                                                 else
01826                                                                   goto structured;
01827                                                         else
01828                                                           if(p[offset9] > cb)
01829                                                                 if(p[offset8] > cb)
01830                                                                   if(p[offset10] > cb)
01831                                                                         if(p[offset11] > cb)
01832                                                                           goto success_structured;
01833                                                                         else
01834                                                                           goto structured;
01835                                                                   else
01836                                                                         goto structured;
01837                                                                 else
01838                                                                   goto structured;
01839                                                           else
01840                                                                 goto structured;
01841                                                   else
01842                                                         goto structured;
01843                                                 else
01844                                                   if(p[offset9] > cb)
01845                                                         if(p[offset6] > cb)
01846                                                           if(p[offset8] > cb)
01847                                                                 if(p[offset4] > cb)
01848                                                                   if(p[offset3] > cb)
01849                                                                         goto success_structured;
01850                                                                   else
01851                                                                         if(p[offset10] > cb)
01852                                                                           goto success_structured;
01853                                                                         else
01854                                                                           goto structured;
01855                                                                 else
01856                                                                   if(p[offset10] > cb)
01857                                                                         if(p[offset11] > cb)
01858                                                                           goto success_structured;
01859                                                                         else
01860                                                                           goto structured;
01861                                                                   else
01862                                                                         goto structured;
01863                                                           else
01864                                                                 goto structured;
01865                                                         else
01866                                                           goto structured;
01867                                                   else
01868                                                         goto structured;
01869                                           else
01870                                                 goto structured;
01871                                         else
01872                                           if(p[offset7] < c_b)
01873                                                 if(p[offset9] < c_b)
01874                                                   if(p[offset8] < c_b)
01875                                                         if(p[offset5] < c_b)
01876                                                           if(p[offset1] < c_b)
01877                                                                 if(p[offset10] < c_b)
01878                                                                   if(p[offset11] < c_b)
01879                                                                         goto success_structured;
01880                                                                   else
01881                                                                         if(p[offset6] < c_b)
01882                                                                           if(p[offset4] < c_b)
01883                                                                                 goto success_structured;
01884                                                                           else
01885                                                                                 goto structured;
01886                                                                         else
01887                                                                           goto structured;
01888                                                                 else
01889                                                                   if(p[offset6] < c_b)
01890                                                                         if(p[offset3] < c_b)
01891                                                                           if(p[offset4] < c_b)
01892                                                                                 goto success_structured;
01893                                                                           else
01894                                                                                 goto structured;
01895                                                                         else
01896                                                                           goto structured;
01897                                                                   else
01898                                                                         goto structured;
01899                                                           else
01900                                                                 if(p[offset6] < c_b)
01901                                                                   if(p[offset4] < c_b)
01902                                                                         if(p[offset3] < c_b)
01903                                                                           goto success_structured;
01904                                                                         else
01905                                                                           if(p[offset10] < c_b)
01906                                                                                 goto success_structured;
01907                                                                           else
01908                                                                                 goto structured;
01909                                                                   else
01910                                                                         if(p[offset10] < c_b)
01911                                                                           if(p[offset11] < c_b)
01912                                                                                 goto success_structured;
01913                                                                           else
01914                                                                                 goto structured;
01915                                                                         else
01916                                                                           goto structured;
01917                                                                 else
01918                                                                   goto structured;
01919                                                         else
01920                                                           if(p[offset10] < c_b)
01921                                                                 if(p[offset11] < c_b)
01922                                                                   if(p[offset1] < c_b)
01923                                                                         goto success_structured;
01924                                                                   else
01925                                                                         if(p[offset6] < c_b)
01926                                                                           goto success_structured;
01927                                                                         else
01928                                                                           goto structured;
01929                                                                 else
01930                                                                   goto structured;
01931                                                           else
01932                                                                 goto structured;
01933                                                   else
01934                                                         goto structured;
01935                                                 else
01936                                                   goto structured;
01937                                           else
01938                                                 goto structured;
01939                                 else
01940                                   if(p[offset5] > cb)
01941                                         if(p[offset7] > cb)
01942                                           if(p[offset9] > cb)
01943                                                 if(p[offset6] > cb)
01944                                                   if(p[offset4] > cb)
01945                                                         if(p[offset3] > cb)
01946                                                           if(p[offset8] > cb)
01947                                                                 goto success_structured;
01948                                                           else
01949                                                                 if(p[offset1] > cb)
01950                                                                   if(p[offset2] > cb)
01951                                                                         goto success_structured;
01952                                                                   else
01953                                                                         goto structured;
01954                                                                 else
01955                                                                   goto structured;
01956                                                         else
01957                                                           if(p[offset8] > cb)
01958                                                                 if(p[offset10] > cb)
01959                                                                   goto success_structured;
01960                                                                 else
01961                                                                   goto structured;
01962                                                           else
01963                                                                 goto structured;
01964                                                   else
01965                                                         if(p[offset11] > cb)
01966                                                           if(p[offset8] > cb)
01967                                                                 if(p[offset10] > cb)
01968                                                                   goto success_structured;
01969                                                                 else
01970                                                                   goto structured;
01971                                                           else
01972                                                                 goto structured;
01973                                                         else
01974                                                           goto structured;
01975                                                 else
01976                                                   goto structured;
01977                                           else
01978                                                 if(p[offset2] > cb)
01979                                                   if(p[offset3] > cb)
01980                                                         if(p[offset4] > cb)
01981                                                           if(p[offset1] > cb)
01982                                                                 if(p[offset6] > cb)
01983                                                                   goto success_structured;
01984                                                                 else
01985                                                                   goto structured;
01986                                                           else
01987                                                                 if(p[offset6] > cb)
01988                                                                   if(p[offset8] > cb)
01989                                                                         goto success_structured;
01990                                                                   else
01991                                                                         goto structured;
01992                                                                 else
01993                                                                   goto structured;
01994                                                         else
01995                                                           goto structured;
01996                                                   else
01997                                                         goto structured;
01998                                                 else
01999                                                   goto structured;
02000                                         else
02001                                           goto structured;
02002                                   else
02003                                         if(p[offset5] < c_b)
02004                                           if(p[offset7] < c_b)
02005                                                 if(p[offset9] < c_b)
02006                                                   if(p[offset6] < c_b)
02007                                                         if(p[offset4] < c_b)
02008                                                           if(p[offset3] < c_b)
02009                                                                 if(p[offset8] < c_b)
02010                                                                   goto success_structured;
02011                                                                 else
02012                                                                   if(p[offset1] < c_b)
02013                                                                         if(p[offset2] < c_b)
02014                                                                           goto success_structured;
02015                                                                         else
02016                                                                           goto structured;
02017                                                                   else
02018                                                                         goto structured;
02019                                                           else
02020                                                                 if(p[offset8] < c_b)
02021                                                                   if(p[offset10] < c_b)
02022                                                                         goto success_structured;
02023                                                                   else
02024                                                                         goto structured;
02025                                                                 else
02026                                                                   goto structured;
02027                                                         else
02028                                                           if(p[offset11] < c_b)
02029                                                                 if(p[offset8] < c_b)
02030                                                                   if(p[offset10] < c_b)
02031                                                                         goto success_structured;
02032                                                                   else
02033                                                                         goto structured;
02034                                                                 else
02035                                                                   goto structured;
02036                                                           else
02037                                                                 goto structured;
02038                                                   else
02039                                                         goto structured;
02040                                                 else
02041                                                   if(p[offset2] < c_b)
02042                                                         if(p[offset3] < c_b)
02043                                                           if(p[offset4] < c_b)
02044                                                                 if(p[offset1] < c_b)
02045                                                                   if(p[offset6] < c_b)
02046                                                                         goto success_structured;
02047                                                                   else
02048                                                                         goto structured;
02049                                                                 else
02050                                                                   if(p[offset6] < c_b)
02051                                                                         if(p[offset8] < c_b)
02052                                                                           goto success_structured;
02053                                                                         else
02054                                                                           goto structured;
02055                                                                   else
02056                                                                         goto structured;
02057                                                           else
02058                                                                 goto structured;
02059                                                         else
02060                                                           goto structured;
02061                                                   else
02062                                                         goto structured;
02063                                           else
02064                                                 goto structured;
02065                                         else
02066                                           goto homogeneous;
02067                         }
02068 }
02069 success_homogeneous:
02070                         if(total == nExpectedCorners)
02071                         {
02072                                 if(nExpectedCorners==0)
02073                                 {
02074                                         nExpectedCorners=512;
02075                                         corners_all.reserve(nExpectedCorners);
02076                                 }
02077                                 else
02078                                 {
02079                                         nExpectedCorners *=2;
02080                                         corners_all.reserve(nExpectedCorners);
02081                                 }
02082                         }
02083                         h.x=x;
02084                         h.y=y;
02085                         corners_all.push_back(h);
02086                         total++;                                                
02087                         goto homogeneous;                               
02088 success_structured:
02089                         if(total == nExpectedCorners)
02090                         {
02091                                 if(nExpectedCorners==0)
02092                                 {
02093                                         nExpectedCorners=512;
02094                                         corners_all.reserve(nExpectedCorners);
02095                                 }
02096                                 else
02097                                 {
02098                                         nExpectedCorners *=2;
02099                                         corners_all.reserve(nExpectedCorners);
02100                                 }
02101                         }
02102                         h.x=x;
02103                         h.y=y;
02104                         corners_all.push_back(h);
02105                         total++;                                                
02106                         goto structured;                                
02107                 }                                                                       
02108         }                                                                               
02109 }
02110 
02111 //end of file

ptam
Author(s): Markus Achtelik , Stephan Weiss , Simon Lynen
autogenerated on Sun Oct 5 2014 23:52:33