コード例 #1
0
ファイル: SaccadeImpl.cpp プロジェクト: dunghand/msrds
BmpArray * RasterSaccade::Run( int pRunFor, int & pSaccadesCompleted, int pSaccadesRequested )
{
    // RasterSaccade is used during learning as of version 1.3.3
    unsigned int minRow, minCol, height, width;
    BmpArray *lTemp;
    lTemp = cOrigPixArray;
    cOrigPixArray = cShiftedPixArray;
    cShiftedPixArray = lTemp;
    FindImageBoundaries(*cOrigPixArray, minRow, minCol, height, width);

    //int lLimit = 0;
    //if ( pSaccadesRequested == -1 )
    //{
    //   // do all
    //   lLimit = ( cCoveredImageSide - height + 1 ) * ( cCoveredImageSide - width + 1 );
    //}
    //else
    //{
    //   lLimit = pSaccadesRequested;
    //}
    //generate all possible shifts of the image
    pSaccadesCompleted = 0;
    unsigned i, j; //i, j - upper left corner of image rectangle
    for(i = 0; i <= cCoveredImageSide - height; i++) //move only within covered area
    {
        for(j = 0; j <= cCoveredImageSide - width; j++)
        {

            //all possible shifts, including beyond image boundaries
            //for(i = 1-height; i < (int)CoveredImageSide; i++) //move only within covered area
            //  for(j = 1-width; j < (int)CoveredImageSide; j++){

            //if something was drawn in the image area
            if(ShiftImage(cOrigPixArray, minRow, minCol, height, width, i, j, cShiftedPixArray))
            {
                emit VisionService(cShiftedPixArray, pRunFor);
            }
            pSaccadesCompleted++;
            if ( pSaccadesCompleted == pSaccadesRequested )  // this will never be true if requesting -1 saccades
            {
                break;
            }

            // Save some shifting;
            lTemp = cOrigPixArray;
            cOrigPixArray = cShiftedPixArray;
            cShiftedPixArray = lTemp; // don't actually need the data!
            // But now we have to get the boundaries again.
            FindImageBoundaries(*cOrigPixArray, minRow, minCol, height, width);
        }
        if ( pSaccadesCompleted == pSaccadesRequested ) // this will never be true if requesting -1 saccades
        {
            break;
        }
    }
    return cShiftedPixArray;
};
コード例 #2
0
int 	cutTheFrame	( Image *dest, Image *src, int width, int height, int showprogress )
{
    int xoff, yoff;

    if( width > src->width || height > src->height )
    {
        PrintError("Image smaller than Rectangle to cut");
        return -1;
    }

    if( getFrame( src, &xoff, &yoff, width, height, showprogress ) == 0 )
    {
        TrformStr	TrCrop;

        memcpy( dest, src, sizeof( Image ) );
        dest->width 			= width;
        dest->height 			= height;
        dest->bytesPerLine 		= dest->width * dest->bitsPerPixel/8;
        dest->dataSize 			= dest->height * dest->bytesPerLine ;
        dest->data 				= (unsigned char**) mymalloc( (size_t)dest->dataSize );
        if( dest->data == NULL )
        {
            PrintError("Could not allocate %ld bytes", dest->dataSize );
            return -1;
        }

        memset(&TrCrop, 0, sizeof(TrformStr));
        TrCrop.src 	= src;
        TrCrop.dest = dest;
        TrCrop.success = 0;


        ShiftImage( &TrCrop, xoff, yoff);
        if( TrCrop.success == 1 )
        {
            return 0;
        }
        else
        {
            myfree( (void**)dest->data );
            return -1;
        }
    }
    else
        return -1;
}
コード例 #3
0
ファイル: SaccadeImpl.cpp プロジェクト: dunghand/msrds
BmpArray * PingPongSaccade::Run( int pRunFor, int & pSaccadesCompleted, int pSaccadesRequested )
{
    // Make calling convention same as for RasterSaccade
    int lSaccadesRequested = pSaccadesRequested;
    if ( pSaccadesRequested == -1 )
    {
        lSaccadesRequested = 0;
    }
    unsigned int minRow, minCol, height, width;
    BmpArray *lTemp;
    lTemp = cOrigPixArray;
    cOrigPixArray = cShiftedPixArray;
    cShiftedPixArray = lTemp;
    pSaccadesCompleted = 0;
    FindImageBoundaries(*cOrigPixArray, minRow, minCol, height, width);

    // Always emit at least one image (for 0 saccades)
    emit VisionService(cShiftedPixArray, pRunFor);

    //generate all possible shifts of the image
    unsigned i, j; //i, j - upper left corner of image rectangle
    unsigned row = minRow, col = minCol;

    int deltaRow = -1, deltaCol = -1;

    if ( row+height == cCoveredImageSide )
    {
        deltaRow = 1;
    }
    else
    {
        deltaRow = -1;
    }

    if ( col+width == cCoveredImageSide )
    {
        deltaCol = 1;
    }
    else
    {
        deltaCol = -1;
    }

    for(i = 0; i < lSaccadesRequested; i++)
    {
        if ( height != cImageSide )
        {
            if(row == 0 || row+height == cCoveredImageSide)//bounce off boundaries
                deltaRow = -deltaRow;                       //assume height, width < CoveredImageSide
            row += deltaRow;
        }
        if ( width != cImageSide )
        {
            if(col == 0 || col+width == cCoveredImageSide) //
                deltaCol = -deltaCol;
            col += deltaCol;
        }
        ShiftImage(cOrigPixArray, minRow, minCol, height, width,
                   row, col, cShiftedPixArray);
        emit VisionService(cShiftedPixArray, pRunFor);
        pSaccadesCompleted++;
        // Save some shifting;
        lTemp = cOrigPixArray;
        cOrigPixArray = cShiftedPixArray;
        cShiftedPixArray = lTemp; // don't actually need the data!
        // But now we have to get the boundaries again.
        FindImageBoundaries(*cOrigPixArray, minRow, minCol, height, width);
    }
    return cShiftedPixArray;
};
コード例 #4
0
ファイル: ieproc.c プロジェクト: lycaner/open-watcom-v2
/*
 * ImgEdFrameProc - handle messages for the image editor application
 */
WPI_MRESULT CALLBACK ImgEdFrameProc( HWND hwnd, WPI_MSG msg,
                                 WPI_PARAM1 wparam, WPI_PARAM2 lparam )
{
    static BOOL         window_destroyed = FALSE;
    static HMENU        hmenu;
    ctl_id              cmdid;
    img_node            *node;
    WPI_RECT            rcmain;
#ifndef __OS2_PM__
    about_info          ai;
#endif
    WPI_RECTDIM         left, top;

    if( !window_destroyed ) {
        enableMainItems( hmenu );
    }

    switch( msg ) {
    case UM_EXIT:
        _wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );
        /* fall through */

    case UM_EXIT_NO_SAVE:
        if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
            break;
        }
#ifndef __OS2_PM__
        _wpi_destroywindow( _wpi_getframe( hwnd ) );
#else
        _wpi_sendmessage( hwnd, WM_CLOSE, 0, 0 );
#endif

        break;

    case UM_SAVE_ALL:
        SaveAllImages();
        break;

    case WM_CREATE:
        hmenu = _wpi_getmenu( _wpi_getframe( hwnd ) );
#ifndef __OS2_PM__
        createClientWindow( hwnd );
#endif
        if( !InitStatusLine( hwnd ) ) {
            return( -1 );
        }

        InitFunctionBar( hwnd );
        InitIconInfo();
        InitializeCursors();

        /*
         * Set values from profile information ...
         */
        if( ImgedConfigInfo.brush_size <= 5 && ImgedConfigInfo.brush_size >= 2 ) {
            checkBrushItem( hmenu, IMGED_2x2 - 2 + ImgedConfigInfo.brush_size );
        }
        if( ImgedConfigInfo.grid_on ) {
            CheckGridItem( hmenu );
        }
        if( ImgedConfigInfo.square_grid ) {
            CheckSquareGrid( hmenu );
        }
        if( ImgedConfigInfo.show_state & SET_SHOW_VIEW ) {
            CheckViewItem( hmenu );
        }

        _wpi_enablemenuitem( hmenu, IMGED_CRESET, FALSE, FALSE );
        _wpi_enablemenuitem( hmenu, IMGED_RCOLOR, FALSE, FALSE );
#ifndef __OS2_PM__
        // not necessary for PM
        InitMenus( hmenu );
#endif
        SetHintText( IEAppTitle );
        return( 0 );
#ifdef __NT__
    case WM_DROPFILES:
        OpenImage( (HANDLE)wparam );
        break;
#endif
    case WM_MOVE:
        _wpi_getwindowrect( hwnd, &rcmain );
        if( !ImgedConfigInfo.ismaximized ) {
            ImgedConfigInfo.last_xpos = ImgedConfigInfo.x_pos;
            ImgedConfigInfo.last_ypos = ImgedConfigInfo.y_pos;
            _wpi_getrectvalues( rcmain, &left, &top, NULL, NULL );
            ImgedConfigInfo.x_pos = (short)left;
            ImgedConfigInfo.y_pos = (short)top;
        }
        return( 0 );

    case WM_SIZE:
        ResizeFunctionBar( lparam );
        ResizeStatusBar( lparam );
#ifndef __OS2_PM__
        if( ClientWindow != NULL ) {
            setClientSize( hwnd );
        }
#else
        resizeClientArea( lparam );
#endif

        if( !_imgwpi_issizeminimized( wparam ) && !_imgwpi_issizemaximized( wparam ) ) {
            _wpi_getwindowrect( hwnd, &rcmain );
            ImgedConfigInfo.width = (short)_wpi_getwidthrect( rcmain );
            ImgedConfigInfo.height = (short)_wpi_getheightrect( rcmain );
            ImgedConfigInfo.ismaximized = FALSE;
        } else {
            ImgedConfigInfo.x_pos = ImgedConfigInfo.last_xpos;
            ImgedConfigInfo.y_pos = ImgedConfigInfo.last_ypos;
            ImgedConfigInfo.ismaximized = _imgwpi_issizemaximized( wparam );
        }
        return( FALSE );

    case WM_MENUSELECT:
#ifndef __OS2_PM__
        if( GET_WM_MENUSELECT_FLAGS( wparam, lparam ) & MF_SEPARATOR ) {
            break;
        }
        if( GET_WM_MENUSELECT_FLAGS( wparam, lparam ) & MF_SYSMENU ) {
            PrintHintTextByID( WIE_SYSMENUOPERATIONS, NULL );
            break;
        }
#endif
        ShowHintText( LOWORD( wparam ) );
        break;

    case WM_COMMAND:
        cmdid = LOWORD( wparam );
        if( !IEIsMenuIDValid( hmenu, cmdid ) ) {
            break;
        }
        switch( cmdid ) {
        case IMGED_NEW:
            if( !ImgedIsDDE ) {
                if( !NewImage( UNDEF_IMG, NULL ) ) {
                    PrintHintTextByID( WIE_NEIMAGENOTCREATED, NULL );
                }
            }
            break;

        case IMGED_CLOSE:
            node = GetCurrentNode();
            if( node != NULL ) {
                _wpi_sendmessage( node->hwnd, WM_CLOSE, 0, 0L );
            }
            break;

        case IMGED_CLOSEALL:
            CloseAllImages();
            break;

        case IMGED_HELP:
            IEHelpRoutine();
            break;

        case IMGED_HELP_SEARCH:
            IEHelpSearchRoutine();
            break;

        case IMGED_HELP_ON_HELP:
            IEHelpOnHelpRoutine();
            break;

        case IMGED_ABOUT:
#ifndef __OS2_PM__
            ai.owner = hwnd;
            ai.inst = Instance;
            ai.name = IEAllocRCString( WIE_ABOUTTEXT );
            ai.version = IEAllocRCString( WIE_ABOUTVERSION );
            ai.title = IEAllocRCString( WIE_ABOUTTITLE );
            DoAbout( &ai );
            if( ai.name != NULL ) {
                IEFreeRCString( ai.name );
            }
            if( ai.version != NULL ) {
                IEFreeRCString( ai.version );
            }
            if( ai.title != NULL ) {
                IEFreeRCString( ai.title );
            }
#endif
            break;

#ifndef __OS2_PM__
        case IMGED_DDE_UPDATE_PRJ:
            IEUpdateDDEEditSession();
            break;
#endif

        case IMGED_SAVE_AS:
            SaveFile( SB_SAVE_AS );
            break;

        case IMGED_SAVE:
            SaveFile( SB_SAVE );
            break;

        case IMGED_OPEN:
            if( !ImgedIsDDE ) {
                OpenImage( NULL );
            }
            break;

        case IMGED_CLEAR:
            ClearImage();
            break;

        case IMGED_NEWIMG:
            AddNewIcon();
            break;

        case IMGED_SELIMG:
            SelectIconImg();
            break;

        case IMGED_DELIMG:
            DeleteIconImg();
            break;

        case IMGED_UNDO:
            UndoOp();
            break;

        case IMGED_REDO:
            RedoOp();
            break;

        case IMGED_REST:
            RestoreImage();
            break;

        case IMGED_SNAP:
#ifndef __OS2_PM__
            SnapPicture();
#endif
            break;

        case IMGED_RIGHT:
        case IMGED_LEFT:
        case IMGED_UP:
        case IMGED_DOWN:
            ShiftImage( cmdid );
            break;

        case IMGED_FLIPHORZ:
        case IMGED_FLIPVERT:
            FlipImage( cmdid );
            break;

        case IMGED_ROTATECC:
        case IMGED_ROTATECL:
            RotateImage( cmdid );
            break;

        case IMGED_PASTE:
            PlaceAndPaste();
            break;

        case IMGED_COPY:
            IECopyImage();
            break;

        case IMGED_CUT:
            CutImage();
            break;

        case IMGED_COLOR:
            CheckPaletteItem( hmenu );
            break;

        case IMGED_VIEW:
            CheckViewItem( hmenu );
            break;

        case IMGED_TOOLBAR:
            CheckToolbarItem( hmenu );
            break;

        case IMGED_SQUARE:
            CheckSquareGrid( hmenu );
            break;

        case IMGED_SIZE:
            ChangeImageSize();
            break;

        case IMGED_GRID:
            CheckGridItem( hmenu );
            break;

        case IMGED_MAXIMIZE:
            MaximizeCurrentChild();
            break;

        case IMGED_SETTINGS:
            SelectOptions();
            break;

        case IMGED_2x2:
        case IMGED_3x3:
        case IMGED_4x4:
        case IMGED_5x5:
            checkBrushItem( hmenu, cmdid );
            break;

        case IMGED_CEDIT:
#ifndef __OS2_PM__
            EditColors();
#endif
            break;

        case IMGED_CRESET:
#ifndef __OS2_PM__
            RestoreColors();
#endif
            break;

        case IMGED_CSCREEN:
            ChooseBkColor();
            break;

        case IMGED_SCOLOR:
#ifndef __OS2_PM__
            SaveColorPalette();
#endif
            break;

        case IMGED_LCOLOR:
#ifndef __OS2_PM__
            if( LoadColorPalette() ) {
                _wpi_enablemenuitem( hmenu, IMGED_RCOLOR, TRUE, FALSE );
            }
#endif
            break;

        case IMGED_RCOLOR:
            RestoreColorPalette();
            break;

        case IMGED_FREEHAND:
        case IMGED_LINE:
        case IMGED_RECTO:
        case IMGED_RECTF:
        case IMGED_CIRCLEO:
        case IMGED_CIRCLEF:
        case IMGED_FILL:
        case IMGED_BRUSH:
        case IMGED_CLIP:
        case IMGED_HOTSPOT:
            SetToolType( cmdid );
            PushToolButton( cmdid );
            break;

        case IMGED_ARRANGE:
#ifndef __OS2_PM__
            SendMessage( ClientWindow, WM_MDIICONARRANGE, 0, 0L );
#endif
            break;

        case IMGED_TILE:
#ifndef __OS2_PM__
            SendMessage( ClientWindow, WM_MDITILE, MDITILE_VERTICAL, 0L );
#endif
            break;

        case IMGED_CASCADE:
#ifndef __OS2_PM__
            SendMessage( ClientWindow, WM_MDICASCADE, MDITILE_SKIPDISABLED, 0L );
#endif
            break;

        case IMGED_EXIT:
            _wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );

            if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
                break;
            }
#ifndef __OS2_PM__
            _wpi_destroywindow( _wpi_getframe( hwnd ) );
#else
            _wpi_sendmessage( hwnd, WM_CLOSE, 0, 0 );
#endif
            break;

        default:
#if 1
            return( _imgwpi_defframeproc( hwnd, ClientWindow, msg, wparam, lparam ) );
#else
            return( 0 );
#endif
        }
        return( 0 );

#ifndef __OS2_PM__
    case WM_COMPACTING:
        RelieveUndos();
        return 0;
#endif

    case WM_QUERYENDSESSION:
        if( _wpi_isiconic( _wpi_getframe( hwnd ) ) ) {
            if( ImgedConfigInfo.ismaximized ) {
                _wpi_maximizewindow( _wpi_getframe( hwnd ) );
            } else {
                _wpi_showwindow( _wpi_getframe( hwnd ), SW_SHOWNORMAL );
            }
        }
        _wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );

        if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
            return( 0 );
        }
        return( (WPI_MRESULT)1 );

    case WM_CLOSE:
        // wParam is non-zero if the DDE connection died
        if( !wparam && !ImgEdEnableMenuInput ) {
            // this prevents the user from closing the editor during
            // DDE initialization
            return( 0 );
        }
        _wpi_sendmessage( hwnd, WM_COMMAND, IMGED_CLOSEALL, 0L );
#ifdef __OS2_PM__
        return( _wpi_defwindowproc( hwnd, msg, wparam, lparam ) );
#else

        if( _wpi_getfirstchild( _wpi_getclient( ClientWindow ) ) != NULL ) {
            return( 0 );
        }
        window_destroyed = TRUE;
        _wpi_destroywindow( _wpi_getframe( hwnd ) );
        return( 0 );
#endif

    case WM_DESTROY:
#ifndef __OS2_PM__
        WWinHelp( HMainWindow, "resimg.hlp", HELP_QUIT, 0 );
#endif
        FiniStatusLine();
        CleanupClipboard();
        CleanupCursors();
        CloseToolBar();
        CloseFunctionBar();
        _wpi_deletefont( SmallFont );
        _wpi_postquitmessage( 0 );
        return( 0 );
    default:
        break;
    }
    return( _imgwpi_defframeproc( hwnd, ClientWindow, msg, wparam, lparam ) );

} /* ImgEdFrameProc */
コード例 #5
0
ファイル: main.cpp プロジェクト: brantr/lucy
int main(int argc, char **argv)
{
  int nx = 512;
  int ny = 512;
  int nxp;
  int nyp;
  int na = 128;
  int nb = 128;
  int *ix;
  int *iy;
  int nr = 1000;
  Real x;
  Real **hst;
  Real **image;
  Real **pimage;
  Real **wimage;
  Real **fimage;
  Real **fimage_hr;
  Real **fimage_lr;
  Real **fimage_a;
  Real **fimage_b;
  Real **cimage;
  Real **timage;
  Real **kernel;
  Real **kb;
  Real **kc;
  Real *amp_a;
  Real *amp_b;
  FILE *fp;
  int n_iter;

  Real sigma_a = 0.01;
  Real sigma_b = 0.001;

  Lucy L;

#ifdef HST
  n_iter = 1;
  image  = LoadHST(&nx,&ny,&nxp,&nyp);
  na = nx;
  nb = ny;
  printf("nx = %d, ny = %d\n",nx,ny);
#else
  n_iter = 20;
  image  = MakeImage(nx,ny);
  wimage = MakeWrongImage(nx,ny);
  set_rng_integer_seed(10209);
  ix = MakeRandomIndices(nr,0.1*nx,nx-0.1*nx);
  set_rng_integer_seed(7493);
  iy = MakeRandomIndices(nr,0.1*ny,ny-0.1*ny);
  set_rng_uniform_seed(12930);
  amp_a = MakeRandomAmplitudes(nr, 0.1, 10.0);
  set_rng_uniform_seed(320943);
  amp_b = MakeRandomAmplitudes(nr, 0.5, 5.0);
  fimage_a = MakeFakeImage(nx,ny,ix,iy,amp_a,nr);
  fimage_b = MakeFakeImage(nx,ny,ix,iy,amp_b,nr);
#endif  

  printf("HERE!\n");

  /* make low-res kernel */
  //kernel = MakeKernel(nx,ny,sigma_a);
  //printf("HERE!\n");
  //fflush(stdout);
  //kb     = RebinImage(kernel,nx,ny,nx,ny);
  kernel = MakeKernel(nx,ny,sigma_a);
  kb     = ShiftImage(kernel,nx,ny);
  //kernel = MakeKernel(na,nb,sigma_a);
  //kb     = RebinImage(kernel,na,nb,nx,ny);

  printf("HERE!\n");

  //deallocate_2d_array(kernel,na,nb);

  /* make high-res kernel */
  //kernel = MakeKernel(nx,ny,sigma_b);
  //kc     = RebinImage(kernel,nx,ny,nx,ny);
  //kernel = MakeKernel(na,nb,sigma_b);
  //kc     = RebinImage(kernel,na,nb,nx,ny);
  //kc = MakeKernel(nx,ny,sigma_b);

  printf("HERE (LAST)!\n");

  /* initialize the cuda convolution */
  initialize_cuda_convolve_2d(nx,ny);

  /* blur image to make "observed" */
#ifdef HST
  printf("nx = %d, ny = %d\n",nx,ny);
  cimage = cuda_convolve_2d(image, kb, nx, ny);

  
#else
  cimage = cuda_convolve_2d(fimage_a, kb, nx, ny);
  pimage = cuda_convolve_2d(fimage_b, kc, nx, ny);
  timage = cuda_convolve_2d(fimage_a, kc, nx, ny);
#endif

  //pimage = cuda_convolve_2d(image, kc, nx, ny);
  //pimage = cuda_convolve_2d(wimage, kc, nx, ny);

  /*load image an kernel*/
  L.LoadImage(  cimage, nx, ny);
  L.LoadKernel( kb,     nx, ny);

#ifdef HST
 
  pimage = ModulateImage( image, nx, ny); 
  L.LoadPriorImage( pimage, nx, ny);
#else
  L.LoadPriorImage( pimage, nx, ny);
#endif

  /*perform n_iterations of deconvolution*/
#ifndef PRIOR
  L.Deconvolve(n_iter);
#else
  L.DeconvolveWithPrior(n_iter);
#endif

#ifdef HST
  fp = fopen("hst.dat","w");  
#else
  fp = fopen("out.dat","w");  
#endif
  fwrite(&nx,1,sizeof(int),fp); 
  fwrite(&ny,1,sizeof(int),fp); 
 
  printf("image %e %e\n",image[0][0],image[0][1]);
  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
#ifdef HST
      fwrite(&image[i][j],1,sizeof(Real),fp); 
#else
      fwrite(&fimage_a[i][j],1,sizeof(Real),fp); 
#endif

  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
      fwrite(&L.phi_tilde[i][j],1,sizeof(Real),fp); 
      //fwrite(&cimage[i][j],1,sizeof(Real),fp); 

  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
      fwrite(&L.phi_r[i][j],1,sizeof(Real),fp); 

  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
      fwrite(&L.psi_0[i][j],1,sizeof(Real),fp); 

  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
      fwrite(&L.psi_r[i][j],1,sizeof(Real),fp); 

  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
      fwrite(&L.prior_r[i][j],1,sizeof(Real),fp); 

  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
#ifdef HST
      fwrite(&image[i][j],1,sizeof(Real),fp); 
#else
      fwrite(&timage[i][j],1,sizeof(Real),fp); 
      //fwrite(&pimage[i][j],1,sizeof(Real),fp); 
#endif

  for(int i=0;i<nx;i++)
    for(int j=0;j<ny;j++)
      fwrite(&kb[i][j],1,sizeof(Real),fp); 
#ifndef HST
  fwrite(&nr,1,sizeof(int),fp); 
  fwrite(&ix[0],nr,sizeof(int),fp); 
  fwrite(&iy[0],nr,sizeof(int),fp); 
  fwrite(&amp_a[0],nr,sizeof(Real),fp); 
  fwrite(&amp_b[0],nr,sizeof(Real),fp); 
#endif
  fclose(fp);

  /* clean up */ 
  destroy_cuda_convolve(); 

  return 0;
}
コード例 #6
0
void 	correct (TrformStr *TrPtr, cPrefs *prefs)
{

    int 	i=0,j,k, kstart, kend, kdone, color;

    double 	scale_params[2];			// scaling factors for resize;
    double 	shear_params[2];			// shear values
    double	radial_params[6];			// coefficients for polynomial correction (0,...3)
    // and source width/2 (4) and correctionradius (5)
    double  lum_params[2];				// parameters to correct luminance variation

    struct  fDesc stack[10];            // Parameters for execute stack function
    struct  fDesc stackinv[10];         // Parameters for execute stack function

    int		destwidth, destheight;
    int 	xoff = 0, yoff = 0;
    int		sizesqr;

    double  xdoff, ydoff;
    Image	im, *dest, *src;
    fDesc	fD;
    fDesc	fDinv;

    im.data = NULL;

    src			= TrPtr->src;
    dest		= TrPtr->dest;

    // Apply filters, if required


    TrPtr->success = 1;

    if( prefs->luminance )
    {


        destwidth 		= TrPtr->src->width;
        destheight 		= TrPtr->src->height;

        // Allocate memory for destination image
        // If no further Xform: simply use SetDest

        if( !( 	prefs->resize 		||
                prefs->shear		||
                prefs->horizontal	||
                prefs->vertical 	||
                prefs->radial 		||
                prefs->cutFrame		||
                prefs->fourier)	)
        {
            if( SetDestImage(TrPtr, destwidth, destheight) != 0 )
            {
                TrPtr->success = 0;
                PrintError( "Not enough Memory.");
                return;
            }
        }
        else // Further Xform requested: use separate new image
        {
            memcpy( &im, TrPtr->src, sizeof(Image) );
            im.data = (unsigned char**) mymalloc( (size_t)im.dataSize );
            if( im.data == NULL )
            {
                TrPtr->success = 0;
                PrintError( "Not enough Memory.");
                return;
            }
            TrPtr->dest 	= &im;
        }

        // JMW 2003/08/25 Use the smaller of the width or height to
        // calculate luminance so that the same change is made to portrait and
        // landscape images.
        // MRDL 2003/08/25 Makes behavior consistent with lens distortion correction
        // algorithm
        if( TrPtr->src->width < TrPtr->src->height )
            sizesqr = (int)((TrPtr->src->width/2.0) * (TrPtr->src->width/2.0));
        else
            sizesqr = (int)((TrPtr->src->height/2.0) * (TrPtr->src->height/2.0));

        if( prefs->lum_params[0] ==  prefs->lum_params[1] &&
                prefs->lum_params[1] ==  prefs->lum_params[2] )  // Color independent
        {
            lum_params[0] =  - prefs->lum_params[0] / sizesqr;
            lum_params[1] =    prefs->lum_params[0] / 2.0 ;
            if( TrPtr->success != 0 )
            {
                filter( TrPtr, radlum, radlum16, (void*) lum_params, 0 );
            }
        }
        else // Color dependent
        {
            for(k=1; k<4; k++)
            {
                lum_params[0] =  - prefs->lum_params[k-1] / sizesqr;
                lum_params[1] =   prefs->lum_params[k-1] / 2.0 ;
                if( TrPtr->success != 0 )
                {
                    filter( TrPtr, radlum, radlum16, (void*) lum_params, k );
                }
            }
        }
    }

    if( TrPtr->success	&&  prefs->fourier )	// Fourier filtering required
    {
        if( prefs->luminance )
        {
            CopyImageData( src, &im );
            TrPtr->src = src;
        }

        if( prefs->fourier_mode == _fresize )
        {
            if( prefs->width == 0 && prefs->height == 0 )
            {
                TrPtr->success = 0;
                PrintError( "Zero Destination Image Size" );
                return;
            }

            if( prefs->width  )
                destwidth 		= prefs->width;
            else
                destwidth 		= (int)((double)TrPtr->src->width * (double)prefs->height / (double)TrPtr->src->height);

            if( prefs->height)
                destheight 		= prefs->height;
            else
                destheight		= (int)((double)TrPtr->src->height * (double)prefs->width / (double)TrPtr->src->width);
        }
        else
        {
            destwidth 		= TrPtr->src->width;
            destheight 		= TrPtr->src->height;
        }

        // Allocate memory for destination image
        // If no further Xform: simply use SetDest

        if( !( 	prefs->resize 		||
                prefs->shear		||
                prefs->horizontal	||
                prefs->vertical 	||
                prefs->radial 		||
                prefs->cutFrame	)	)
        {
            if( SetDestImage(TrPtr, destwidth, destheight) != 0 )
            {
                TrPtr->success = 0;
                PrintError( "Not enough Memory.");
                return;
            }
        }
        else // Further Xform requested: use separate new image
        {
            if( prefs->luminance )  // since then we have allocated im already
            {
                if( im.data ) myfree( (void**)im.data );
            }
            memcpy( &im, TrPtr->src, sizeof(Image) );
            im.width = destwidth;
            im.height = destheight;
            im.bytesPerLine = im.width * im.bitsPerPixel/8;
            im.dataSize = im.height * im.bytesPerLine;
            im.data = (unsigned char**) mymalloc( (size_t)im.dataSize );
            if( im.data == NULL )
            {
                TrPtr->success = 0;
                PrintError( "Not enough Memory.");
                return;
            }
            TrPtr->dest 	= &im;
        }

        fourier( TrPtr, prefs );
    }





    if( TrPtr->success		&&
            ( 	prefs->resize 		||
                prefs->shear		||
                prefs->horizontal	||
                prefs->vertical 	||
                prefs->radial 		||
                prefs->cutFrame)	)			// Displacement Xform requested
    {

        // First check whether recent luminance or fourier filtering
        if( prefs->luminance || prefs->fourier )
            TrPtr->src	= &im;

        TrPtr->dest = dest;

        // Set destination image parameters

        // most Xforms: dest = src

        destwidth 		= TrPtr->src->width;
        destheight 		= TrPtr->src->height;


        if( prefs->cutFrame )
        {
            if( getFrame( TrPtr->src, &xoff, &yoff, prefs->fwidth, prefs->fheight, TrPtr->mode & _show_progress ) != 0 )
            {
                TrPtr->success = 0;
                return;
            }
            //PrintError("x= %d, y= %d", xoff, yoff);
            destwidth 		=  prefs->fwidth ;
            destheight 		=  prefs->fheight ;
        }


        if(prefs->resize)
        {
            if( prefs->width == 0 && prefs->height == 0 )
            {
                TrPtr->success = 0;
                PrintError( "Zero Destination Image Size" );
                return;
            }

            if( prefs->width  )
                destwidth 		= prefs->width;
            else
                destwidth 		= (int)((double)TrPtr->src->width * (double)prefs->height / (double)TrPtr->src->height);

            if( prefs->height)
                destheight 		= prefs->height;
            else
                destheight		= (int)((double)TrPtr->src->height * (double)prefs->width / (double)TrPtr->src->width);
        }

        if( destwidth <= 0 || destheight <= 0 )
        {
            TrPtr->success = 0;
            PrintError( "Zero Destination Image Size" );
            return;
        }



        // Allocate memory for destination image

        if( SetDestImage(TrPtr, destwidth, destheight) != 0 )
        {
            TrPtr->success = 0;
            PrintError( "Not enough Memory.");
            goto _correct_exit;
        }



        // Check to see if the colors have the same or different displacement paras
        if( isColorSpecific( prefs ) )  // Color dependent
        {

            if( haveSameColorParas( prefs,0,1)) // R==G??
            {
                fprintf(stderr, "PT correct "PROGRESS_VERSION" R==G\n" );
                if( ! hasUsefulColorParas(prefs,0))
                {
                    fprintf(stderr, "Red/Green do NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing just the Blue...\n" );
                    kstart=3;
                    kend  =3;
                }
                else if( ! hasUsefulColorParas(prefs,2))
                {
                    fprintf(stderr, "Blue does NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing the Red/Green simultaneously...\n" );
                    kstart=4;
                    kend  =4;
                }
                else
                {
                    kstart=4;
                    kend  =3;
                }


            }
            else if( haveSameColorParas( prefs,1,2)) // G==B??
            {
                fprintf(stderr, "PT correct "PROGRESS_VERSION" G==B\n" );
                if( ! hasUsefulColorParas(prefs,1))
                {
                    fprintf(stderr, "Green/Blue do NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing just the Red...\n" );
                    kstart=1;
                    kend  =1;
                }
                else if( ! hasUsefulColorParas(prefs,0))
                {
                    fprintf(stderr, "Red does NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing the Green/Blue simultaneously...\n" );
                    kstart=6;
                    kend  =6;
                }
                else
                {
                    kstart=6;
                    kend  =1;
                }



            }
            else if( haveSameColorParas( prefs,2,0)) // R==B??
            {
                fprintf(stderr, "PT correct "PROGRESS_VERSION" R==B\n" );
                if( ! hasUsefulColorParas(prefs,0))
                {
                    fprintf(stderr, "Red/Blue do NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing just the Green...\n" );
                    kstart=2;
                    kend  =2;
                }
                else if( ! hasUsefulColorParas(prefs,1))
                {
                    fprintf(stderr, "Green does NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing the Red/Blue simultaneously...\n" );
                    kstart=5;
                    kend  =5;
                }
                else
                {
                    kstart=5;
                    kend  =2;
                }


            }
            else
            {
                fprintf(stderr, "PT correct "PROGRESS_VERSION" R!=G!=B\n" );
                if( ! hasUsefulColorParas(prefs,0))
                {
                    fprintf(stderr, "Red does NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing the Green then Blue separately...\n" );
                    kstart=2;
                    kend  =3;
                }
                else if( ! hasUsefulColorParas(prefs,1))
                {
                    fprintf(stderr, "Green does NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing the Blue then Red separately...\n" );
                    kstart=3;
                    kend  =1;
                }
                else if( ! hasUsefulColorParas(prefs,2))
                {
                    fprintf(stderr, "Blue does NOTHING! Copying image data...\n" );
                    CopyImageData( TrPtr->dest, TrPtr->src );
                    fprintf(stderr, "Displacing the Red then Green separately...\n" );
                    kstart=1;
                    kend  =2;
                }
                else
                {
                    kstart 	= 1;
                    kend	= 3;
                }

            }
        }
        else // Color independent
        {
            fprintf(stderr, "PT correct "PROGRESS_VERSION" R==G==B\n" );
            if( ! hasUsefulColorParas(prefs,0))
            {
                fprintf(stderr, "Red,Green,Blue do NOTHING! But you asked for it...\n" );
            }
            kstart	= 0;
            kend	= 0;
        }

        // Do the necessary displacements, either per color, 2-colors, or on all 3 colors.
        kdone=0;
        k=kstart;
        while(!kdone)
        {
            switch(k) // choose which color's paras to use
            {
            case 0: // RGB
                color = 0;// Use the Red paras
                break;

            case 1: // [0] = R
            case 2: // [1] = G
            case 3: // [2] = B
                color = k-1;
                break;

            case 4:// RG
                color=0;
                break;
            case 5:// RB
                color=0;
                break;
            case 6:// GB
                color=1;
                break;
            default:
                color=0;
                break;
            }

            i = 0;

            if( prefs->resize )
            {
                if(prefs->cutFrame)
                {
                    if( prefs->width )
                        scale_params[0] = ((double)prefs->fwidth)/ prefs->width;
                    else
                        scale_params[0] = ((double)prefs->fheight)/ prefs->height;

                    if( prefs->height )
                        scale_params[1] = ((double)prefs->fheight)/ prefs->height;
                    else
                        scale_params[1] = scale_params[0];
                }
                else
                {
                    if( prefs->width )
                        scale_params[0] = ((double)TrPtr->src->width)/ prefs->width;
                    else
                        scale_params[0] = ((double)TrPtr->src->height)/ prefs->height;

                    if( prefs->height )
                        scale_params[1] = ((double)TrPtr->src->height)/ prefs->height;
                    else
                        scale_params[1] = scale_params[0];
                }
                SetDesc(stack[i],resize,scale_params);
                i++;
            }

            // JMW 2008/01/03 make the order the same as Adjust doing correct
            if( prefs->radial )
            {
                switch( prefs->correction_mode)
                {
                case correction_mode_radial:
                    SetDesc(stack[i],radial, radial_params);
                    i++;
                    radial_params[4] = ( (double)( TrPtr->src->width < TrPtr->src->height ?
                                                   TrPtr->src->width : TrPtr->src->height) ) / 2.0;
                    break;
                case correction_mode_vertical:
                    SetDesc(stack[i],vertical, radial_params);
                    i++;
                    radial_params[4] = ((double)TrPtr->src->height) / 2.0;
                    break;
                case correction_mode_deregister:
                    SetDesc(stack[i],deregister, radial_params);
                    i++;
                    radial_params[4] = ((double)TrPtr->src->height) / 2.0;
                    break;
                }
                for(j=0; j<4; j++)
                    radial_params[j] = prefs->radial_params[color][j];
                radial_params[5] = prefs->radial_params[color][4];
            }

            if (prefs->vertical)
            {
                SetDesc(stack[i],vert,&(prefs->vertical_params[color]));
                i++;
            }

            if (prefs->horizontal)
            {
                SetDesc(stack[i],horiz,&(prefs->horizontal_params[color]) );
                i++;
            }

            if( prefs->shear )
            {
                shear_params[0] = prefs->shear_x / TrPtr->src->height;
                shear_params[1] = prefs->shear_y / TrPtr->src->width;
                SetDesc(stack[i],shear,shear_params);
                i++;
            }

            if( prefs->cutFrame )
            {
                if( xoff != 0 )
                {
                    xdoff = (double) xoff + 0.5 * ( prefs->fwidth - TrPtr->src->width ) ;
                    SetDesc(stack[i],horiz, &xdoff );
                    i++;
                }

                if( yoff != 0 )
                {
                    ydoff = (double)yoff + 0.5 * ( prefs->fheight - TrPtr->src->height) ;
                    SetDesc(stack[i],vert,&ydoff);
                    i++;
                }
            }

            stack[i].func = (trfn)NULL;

            if( 	!prefs->resize 		&&
                    !prefs->shear		&&
                    !prefs->horizontal	&&
                    !prefs->vertical 	&&
                    !prefs->radial 		&&
                    prefs->cutFrame )	// Only cutframe
            {
                ShiftImage(TrPtr, xoff, yoff);
            }
            else if( TrPtr->success != 0 && i != 0 )
            {
                // Copy and reverse the stack to make the inverse stack
                int ii = 0;
                while(i)
                {
                    stackinv[ii] = stack[i-1];
                    i--;
                    ii++;
                }
                stackinv[ii].func = (trfn)NULL;

                fD.func    = execute_stack_new;
                fD.param    = stack;
                fDinv.func = execute_stack_new;
                fDinv.param = stackinv;
                transFormEx( TrPtr, &fD, &fDinv, k, 1 );
                i = ii;
            }

            switch(k) // We use k as control var for a little statemachine:
            {
            case 0:// RGB
                kdone=1;
                break;

            case 1:// R
            case 2:// G
            case 3:// B
                if(k==kend)
                {
                    kdone=1;
                }
                else
                {
                    k++;

                    if(k==4)
                        k=1;
                }
                break;

            case 4:// RG
            case 5:// RB
            case 6:// GB
                if(k==kend)
                {
                    kdone=1;
                }
                else
                {
                    k=kend;
                }
                break;

            default:
                kdone=1;
                break;
            }

        }// END:while(!kdone)
    }


    if( !prefs->luminance && !prefs->fourier && !prefs->cutFrame && i == 0 ) // We did nothing!
    {
        TrPtr->success = 0;
    }

    if( TrPtr->success == 0 && ! (TrPtr->mode & _destSupplied))
        myfree( (void**)TrPtr->dest->data );

_correct_exit:

    TrPtr->src 		= src;
    TrPtr->dest 	= dest;


    if( im.data != NULL )
        myfree((void**)im.data);


}