PureBasic Forums - English

Code: Select all

;******************************************************************************
;*
;* Image Rotation routines for 24/32 bit with optional AA
;* by Luis, http://luis.no-ip.net
;* v1.11 for PB 5.73
;*
;* Tested under Windows 32/64 bit and Linux 32 bit with PB 4.40 B2
;*
;* These routines can deal with both 24/32 bit images and with the alpha channel.
;* The output of the routines will be an image with the same number of BPP
;* as the one passed in input to them. The source image is not freed.
;*
;* Inspired by a simpler Visual Basic code from Robert Rayment. Thank you.
;* http://www.planet-source-code.com/vb/scripts/ShowCode.asp?txtCodeId=23476&lngWId=1
;*
;* ----------------------------------------------------------------------------
;*
;* RotateImageFree (nSrcImage, fDegRot.f, flgAntiAliasing, FillColor)
;*
;*  nSrcImage           The 24/32 bit PureBasic's image to rotate
;*  fDegRot             Float angle in degrees (+/-) 0.0 -> 360.0
;*  flgAntiAliasing     0 for simpler rotation, 1 for antialiased rotation
;*  FillColor           Used to fill the new areas of the resulting image
;*
;*  Return              a 24/32 bit image rotated by fDegRot
;*
;* NOTES :
;*  FillColor is not used with 32 bit images, the new areas are always transparent.
;*
;*  FillColor can be set to a unique color with 24 bit images if you want to
;*  draw the resulting image with masking using GDI functions under Windows,
;*  for example. Or maybe to simply match a certain background color.
;*
;*  The anti aliasing use 4 pixels to do the AA, this is useful especially
;*  when text is present on the image to be rotated to obtain a good quality
;*  at the expense of speed. A free-angle rotation really need AA !
;*
;* ----------------------------------------------------------------------------
;*
;* RotateImage (nSrcImage, DegRot)
;*
;*  nSrcImage           The 24/32 bit PureBasic's image to rotate
;*  DegRot              Integer angle in degrees (+/-) 90/180/270
;*
;*  Return              a 24/32 bit image rotated by DegRot
;*
;* NOTES :
;*   Use this procedure to rotate by multiples of 90 degrees instead of RotateImageFree(). 
;*   It's faster and it's not subject to rounding errors.
;*
;* ----------------------------------------------------------------------------
;*
;* FlipImage (nSrcImage)
;*
;*  nSrcImage           The 24/32 bit PureBasic's image to flip
;*
;*  Return              a 24/32 bit image flipped vertically
;*
;* ----------------------------------------------------------------------------
;*
;* MirrorImage (nSrcImage)
;*
;*  nSrcImage           The 24/32 bit PureBasic's image to mirror
;*
;*  Return              a 24/32 bit image mirrored horizontally
;*
;******************************************************************************


#EXC_ALLOC_ERR = 1

CompilerIf Defined(Macro_TRY, #PB_Constant) = 0
#Macro_TRY = 1

Global EXCEPTION

Macro TRY (exp, exc = 0)
; [DESC]
; Evaluate the expression and jump to the corresponding CATCH if it's false.
;
; [INPUT]
; exp : The expression to test.
; exc : An optional numeric code to identify the exception type for the CATCH.
;
; [NOTES]
; This is inspired to real exception handling but it isn't.
; The purpose of this TRY/CATCH pair is to avoid messy, deep error checking in structured code 
; and to wrap the use of GOTO inside something more convenient to read/follow.
; You can write the main body of the code under the assumption nothing is going wrong, 
; and concentrate the cleanup / recovery in a single place, keeping single entry and exit points.
;
; Example:
;
; Procedure.i MyProc()
; 
;  TRY (ProcA(), 1)
;  ...
;  TRY (ProcB(), 2)
;  ...
;  TRY (ProcC(), 3)
;  ...
; 
;  ProcedureReturn 1 ; success
;  
;  CATCH
;  
;  Select EXCEPTION
;   Case 1 : ; specific cleanup
;   Case 2 : ; specific cleanup
;   Case 3 : ; specific cleanup
;   Default : ; fallback
;  EndSelect
; 
;  ProcedureReturn 0 ; failure
; EndProcedure
;
  
 If Not (exp)
    EXCEPTION = exc
    Goto label_catch_exception
 Else
    EXCEPTION = 0
 EndIf
EndMacro

Macro RAISE (exc = 0)
; [DESC]
; Unconditionally jump to the corresponding CATCH.
;
; [INPUT]
; exc : An optional numeric code to identify the exception type for the CATCH.
  
 EXCEPTION = exc
 Goto label_catch_exception
 EndMacro

Macro CATCH()
; [DESC]
; Receive the control from the program when the TRY expression is false.
;
; [NOTES]
; See the command TRY

 label_catch_exception:
EndMacro

CompilerEndIf

Structure T_RGBA
 B.a
 G.a
 R.a
 A.a
EndStructure

Macro RGB_B(color)
 ((color & $FF0000) >> 16) 
EndMacro

Macro RGB_G(color)
 ((color & $FF00) >> 8) 
EndMacro

Macro RGB_R(color)
 (color & $FF) 
EndMacro 

Macro RGB_Mix (r, g, b)
 ((((b) << 8 + (g)) << 8) + (r))
EndMacro

Macro CopyPixel32 (Xs, Ys, Xd, Yd, BufferPitchSrc, BufferPitchDest, ptRGBAs, ptRGBAd, pMemSrc, pMemDest)
 ptRGBAs = pMemSrc  + (Ys) * BufferPitchSrc + (Xs) << 2
 ptRGBAd = pMemDest + (Yd) * BufferPitchDest + (Xd) << 2        
 ptRGBAd\R = ptRGBAs\R
 ptRGBAd\G = ptRGBAs\G
 ptRGBAd\B = ptRGBAs\B        
 ptRGBAd\A = ptRGBAs\A
EndMacro

Macro CopyPixel24 (Xs, Ys, Xd, Yd, BufferPitchSrc, BufferPitchDest, ptRGBAs, ptRGBAd, pMemSrc, pMemDest)
 ptRGBAs = pMemSrc  + (Ys) * BufferPitchSrc + (Xs) * 3
 ptRGBAd = pMemDest + (Yd) * BufferPitchDest + (Xd) * 3
 ptRGBAd\R = ptRGBAs\R
 ptRGBAd\G = ptRGBAs\G
 ptRGBAd\B = ptRGBAs\B        
EndMacro

Macro ReadPixel32 (X, Y, BufferPitchSrc, ptRGBA, pMemSrc) 
 ptRGBA = pMemSrc + (Y) * BufferPitchSrc + (X) << 2
EndMacro

Macro ReadPixel24 (X, Y, BufferPitchSrc, ptRGBA, pMemSrc) 
 ptRGBA = pMemSrc + (Y) * BufferPitchSrc + (X) * 3
EndMacro

Macro WritePixel32 (tPixel, X, Y, BufferPitchDest, ptRGBA, pMemDest)
 ptRGBA = pMemDest + (Y) * BufferPitchDest + (X) << 2                       
 ptRGBA\R = tPixel\R
 ptRGBA\G = tPixel\G
 ptRGBA\B = tPixel\B
 ptRGBA\A = tPixel\A
EndMacro

Macro WritePixel24 (tPixel, X, Y, BufferPitchDest, ptRGBA, pMemDest)
 ptRGBA = pMemDest + (Y) * BufferPitchDest + (X) * 3
 ptRGBA\R = tPixel\R
 ptRGBA\G = tPixel\G
 ptRGBA\B = tPixel\B
EndMacro

Procedure.i AllocateImageData (nImage, *BufferPitch.Integer, FillColor = -1)
 Protected *ImageMem, *AllocMem, BufferPitch

 StartDrawing(ImageOutput(nImage))
   
  *ImageMem = DrawingBuffer()
  BufferPitch = DrawingBufferPitch()

   If FillColor <> -1
    Select ImageDepth(nImage)
        Case 24
            Box(0, 0, ImageWidth(nImage), ImageHeight(nImage), FillColor)
        Case 32
            DrawingMode(#PB_2DDrawing_AlphaChannel)   
            Box(0, 0, ImageWidth(nImage), ImageHeight(nImage), $00) ; full transparent
    EndSelect
  EndIf

  *AllocMem = AllocateMemory(BufferPitch * ImageHeight(nImage))

  If *AllocMem
    CopyMemory(*ImageMem, *AllocMem, MemorySize(*AllocMem))
    *BufferPitch\i = BufferPitch
  Else
    *BufferPitch\i = 0
  EndIf

 StopDrawing()

 ProcedureReturn *AllocMem
EndProcedure

Procedure CopyImageData (nImage, *DestMem)
 StartDrawing(ImageOutput(nImage))
  CopyMemory(*DestMem, DrawingBuffer(), MemorySize(*DestMem))
 StopDrawing()
EndProcedure

Procedure.i RotateImage (nSrcImage, DegRot)

; Rotate 24 bit images at (+/-) 90/180/270 degrees

; Rotate 32 bit images at (+/-) 90/180/270 degrees preserving the alpha-channel
 
 Protected *tRGBAs.T_RGBA, *tRGBAd.T_RGBA, tPixel.T_RGBA, RotType
 Protected *SrcMem, *DestMem, BufferPitchSrc, BufferPitchDest
 Protected SrcWidth, SrcHeight, DestWidth, DestHeight, nDestImage
 Protected X, Y, Xs, Ys
 Protected BitPlanes
 
 ; sanity checks
 
 If IsImage(nSrcImage) = 0
    ProcedureReturn 0
 EndIf

 BitPlanes = ImageDepth(nSrcImage)

 If BitPlanes <> 24 And BitPlanes <> 32
    ProcedureReturn 0
 EndIf

 If DegRot % 90
    ProcedureReturn 0
 EndIf

 DegRot % 360

 If DegRot = 0
    ProcedureReturn CopyImage(nSrcImage, #PB_Any)
 EndIf

 CompilerIf (#PB_Compiler_OS = #PB_OS_Linux)
  DegRot = -DegRot
 CompilerEndIf

 SrcWidth = ImageWidth(nSrcImage)
 SrcHeight = ImageHeight(nSrcImage)

 Select DegRot            
    Case 90, -270
        DestWidth = SrcHeight
        DestHeight = SrcWidth
        RotType = 1
    Case 180, -180
        RotType = 2
        DestWidth = SrcWidth
        DestHeight = SrcHeight
    Case 270, -90
        RotType = 3
        DestWidth = SrcHeight
        DestHeight = SrcWidth
 EndSelect

 ; create 24/32 bit destination image
 nDestImage = CreateImage(#PB_Any, DestWidth, DestHeight, BitPlanes)
 TRY (nDestImage)

 ; copy src image to allocated memory
 *SrcMem = AllocateImageData(nSrcImage, @BufferPitchSrc)
 TRY (*SrcMem, #EXC_ALLOC_ERR)

 ; copy dest image to allocated memory
 *DestMem = AllocateImageData(nDestImage, @BufferPitchDest)
 TRY (*DestMem, #EXC_ALLOC_ERR)

 Select BitPlanes
    Case 24
        For Y = 0 To DestHeight - 1
            For X = 0 To DestWidth - 1
           
                Select RotType
                    Case 1
                        Ys = SrcHeight - X - 1
                        Xs = Y
                    Case 2
                        Ys = SrcHeight - Y - 1
                        Xs = SrcWidth - X - 1   
                    Case 3
                        Ys = X
                        Xs = SrcWidth - Y - 1
                EndSelect

                CopyPixel24 (Xs, Ys, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)
                           
            Next
         Next   
    Case 32
        For Y = 0 To DestHeight - 1
            For X = 0 To DestWidth - 1
           
                Select RotType
                    Case 1
                        Ys = SrcHeight - X - 1
                        Xs = Y
                    Case 2
                        Ys = SrcHeight - Y - 1
                        Xs = SrcWidth - X - 1   
                    Case 3
                        Ys = X
                        Xs = SrcWidth - Y - 1
                EndSelect

                CopyPixel32 (Xs, Ys, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)                   
                           
            Next
         Next   
 EndSelect

 CopyImageData(nDestImage, *DestMem)
   
 FreeMemory(*SrcMem)
 FreeMemory(*DestMem)

 ProcedureReturn nDestImage

 CATCH()

 If EXCEPTION = #EXC_ALLOC_ERR
    If *SrcMem <> 0 : FreeMemory(*SrcMem) : EndIf
    If *DestMem <> 0 : FreeMemory(*DestMem) : EndIf    
    FreeImage(nDestImage)
 EndIf
 
 ProcedureReturn 0
EndProcedure


Procedure.i RotateImageFree (nSrcImage, fDegRot.f, flgAntiAliasing, FillColor = $ffffff)
; Rotates 24 bit images at any angle optionally with anti-aliasing filling the new area of the resulting image with the specified color.

; Rotates 32 bit images at any angle optionally with anti-aliasing preserving the alpha-channel.
 
 Protected *tRGBAs.T_RGBA, *tRGBAd.T_RGBA, tPixel.T_RGBA
 Protected *SrcMem, *DestMem, BufferPitchSrc, BufferPitchDest
 Protected fzCos.f, fzSin.f
 Protected SrcWidth, SrcHeight, DestWidth, DestHeight, BitPlanes, nDestImage
 Protected X, Y, Xs, Ys, Xc1, Yc1, Xc2, Yc2, iColor

 ; sanity checks
 If IsImage(nSrcImage) = 0
    ProcedureReturn 0
 EndIf

 BitPlanes = ImageDepth(nSrcImage)

 If BitPlanes <> 24 And BitPlanes <> 32
    ProcedureReturn 0
 EndIf

 If fDegRot >= 360.0 ; wrap it
    fDegRot = 360.0 * (fDegRot / 360.0 - Int(fDegRot / 360.0))
 EndIf

 If fDegRot = 0.0 Or fDegRot = 90.0 Or fDegRot = 180.0 Or fDegRot = 270.0
    ProcedureReturn RotateImage(nSrcImage, fDegRot)
 EndIf
 
 CompilerIf (#PB_Compiler_OS = #PB_OS_Linux)
 fDegRot = -fDegRot
 CompilerEndIf

 fzCos = Cos(Radian(fDegRot))
 fzSin = Sin(Radian(fDegRot)) 

 SrcWidth = ImageWidth(nSrcImage)
 SrcHeight = ImageHeight(nSrcImage)

 DestWidth = Round(SrcWidth * Abs(fzCos) + SrcHeight * Abs(fzSin), #PB_Round_Up)
 DestHeight = Round(SrcHeight * Abs(fzCos) + SrcWidth * Abs(fzSin), #PB_Round_Up)

 Xc1 = SrcWidth / 2
 Yc1 = SrcHeight / 2
 Xc2 = DestWidth / 2
 Yc2 = DestHeight / 2

 ; create 24/32 bit destination image
 nDestImage = CreateImage(#PB_Any, DestWidth, DestHeight, BitPlanes)
 TRY (nDestImage)

 ; copy src image to allocated memory
 *SrcMem = AllocateImageData (nSrcImage, @BufferPitchSrc)
 TRY (*SrcMem, #EXC_ALLOC_ERR)

 ; copy dest image to allocated memory and fill with backcolor
 *DestMem = AllocateImageData(nDestImage, @BufferPitchDest, FillColor)
 TRY (*DestMem, #EXC_ALLOC_ERR)
     
 Select flgAntiAliasing

    Case #False   
   
        Select BitPlanes
            Case 24
     
                For Y = 0 To DestHeight - 1
                    For X = 0 To DestWidth - 1
                   
                        ; For each nDestImage point find rotated nSrcImage source point
                        Xs = Xc1 + (X - Xc2) * fzCos + (Y - Yc2) * fzSin 
                        Ys = Yc1 + (Y - Yc2) * fzCos - (X - Xc2) * fzSin 
                                   
                        If Xs >= 0 And Xs < SrcWidth  And Ys >= 0 And Ys < SrcHeight
                            ; Move valid rotated nSrcImage source points to nDestImage                   
                            CopyPixel24 (Xs, Ys, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)
                        EndIf
                                   
                    Next
                Next   
           
            Case 32
           
                For Y = 0 To DestHeight - 1
                    For X = 0 To DestWidth - 1
                        ; For each nDestImage point find rotated nSrcImage source point
                        Xs = Xc1 + (X - Xc2) * fzCos + (Y - Yc2) * fzSin 
                        Ys = Yc1 + (Y - Yc2) * fzCos - (X - Xc2) * fzSin 
                                   
                        If Xs >= 0 And Xs < SrcWidth  And Ys >= 0 And Ys < SrcHeight
                            ; Move valid rotated nSrcImage source points to nDestImage                   
                            CopyPixel32 (Xs, Ys, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)
                        EndIf
                                   
                    Next
                Next   
                                     
        EndSelect
         
    Case #True
    
        Protected Xs0, Ys0, icr, icg, icb, icr0, icg0, icb0, icr1, icg1, icb1
        Protected fXs.f, fYs.f, fXfs1.f, fYfs1.f
        Protected fXfs1less.f, fYfs1less.f

        Select BitPlanes
           
            Case 24
           
                For Y = 0 To DestHeight - 1
                    For X = 0 To DestWidth - 1
           
                        ; For each nDestImage point find rotated nSrcImage source point
                        fXs = Xc1 + (X - Xc2) * fzCos + (Y - Yc2) * fzSin 
                        fYs = Yc1 + (Y - Yc2) * fzCos - (X - Xc2) * fzSin  
             
                        ; Bottom left coords of bounding floating point rectangle on nSrcImage
                        Xs0 = Int(fXs)   
                        Ys0 = Int(fYs)
                           
                        If Xs0 >= 0 And Xs0 < SrcWidth - 1 And Ys0 >= 0 And Ys0 < SrcHeight - 1
                            fXfs1 = fXs - Int(fXs)
                            fYfs1 = fYs - Int(fYs)
       
                            fXfs1less = 1 - fXfs1 - 0.000005 : If fXfs1less < 0 : fXfs1less = 0 : EndIf
                            fYfs1less = 1 - fYfs1 - 0.000005 : If fYfs1less < 0 : fYfs1less = 0 : EndIf
                                                                     
                            ReadPixel24 (Xs0, Ys0, BufferPitchSrc, *tRGBAs, *SrcMem)                                                                                                                               
                            icr = *tRGBAs\R * fXfs1less
                            icg = *tRGBAs\G * fXfs1less
                            icb = *tRGBAs\B * fXfs1less
                               
                            ReadPixel24 (Xs0 + 1, Ys0, BufferPitchSrc, *tRGBAs, *SrcMem)
                            icr0 = *tRGBAs\R * fXfs1 + icr
                            icg0 = *tRGBAs\G * fXfs1 + icg
                            icb0 = *tRGBAs\B * fXfs1 + icb
                                 
                            ReadPixel24 (Xs0, Ys0 + 1, BufferPitchSrc, *tRGBAs, *SrcMem)
                            icr = *tRGBAs\R * fXfs1less
                            icg = *tRGBAs\G * fXfs1less
                            icb = *tRGBAs\B * fXfs1less
                                                                       
                            ReadPixel24 (Xs0 + 1, Ys0 + 1, BufferPitchSrc, *tRGBAs, *SrcMem)
                            icr1 = *tRGBAs\R * fXfs1 + icr
                            icg1 = *tRGBAs\G * fXfs1 + icg
                            icb1 = *tRGBAs\B * fXfs1 + icb
                   
                            ; Weight along axis Y
                            tPixel\R = fYfs1less * icr0 + fYfs1 * icr1
                            tPixel\G = fYfs1less * icg0 + fYfs1 * icg1
                            tPixel\B = fYfs1less * icb0 + fYfs1 * icb1                           
                           
                            WritePixel24 (tPixel, X, Y, BufferPitchDest, *tRGBAd, *DestMem)                               
                        EndIf           
                    Next
                Next           
           
            Case 32

                Protected ica, ica0, ica1
               
                For Y = 0 To DestHeight - 1
                    For X = 0 To DestWidth - 1
           
                        ; For each nDestImage point find rotated nSrcImage source point
                        fXs = Xc1 + (X - Xc2) * fzCos + (Y - Yc2) * fzSin 
                        fYs = Yc1 + (Y - Yc2) * fzCos - (X - Xc2) * fzSin 
             
                        ; Bottom left coords of bounding floating point rectangle on nSrcImage
                        Xs0 = Int(fXs)   
                        Ys0 = Int(fYs)                       

                        If Xs0 >= 0 And Xs0 < SrcWidth - 1 And Ys0 >= 0 And Ys0 < SrcHeight - 1
                       
                            fXfs1 = fXs - Int(fXs)
                            fYfs1 = fYs - Int(fYs)
       
                            fXfs1less = 1 - fXfs1 - 0.000005 : If fXfs1less < 0 : fXfs1less = 0 : EndIf
                            fYfs1less = 1 - fYfs1 - 0.000005 : If fYfs1less < 0 : fYfs1less = 0 : EndIf
                                                                     
                            ReadPixel32 (Xs0, Ys0, BufferPitchSrc, *tRGBAs, *SrcMem)                                                                                                                                                       
                            icr = *tRGBAs\R * fXfs1less
                            icg = *tRGBAs\G * fXfs1less
                            icb = *tRGBAs\B * fXfs1less
                            ica = *tRGBAs\A * fXfs1less
                                                           
                            ReadPixel32 (Xs0 + 1, Ys0, BufferPitchSrc, *tRGBAs, *SrcMem)
                            icr0 = *tRGBAs\R * fXfs1 + icr
                            icg0 = *tRGBAs\G * fXfs1 + icg
                            icb0 = *tRGBAs\B * fXfs1 + icb
                            ica0 = *tRGBAs\A * fXfs1 + ica
                                                             
                            ReadPixel32 (Xs0, Ys0 + 1, BufferPitchSrc, *tRGBAs, *SrcMem)
                            icr = *tRGBAs\R * fXfs1less
                            icg = *tRGBAs\G * fXfs1less
                            icb = *tRGBAs\B * fXfs1less
                            ica = *tRGBAs\A * fXfs1less
                                                                                                   
                            ReadPixel32 (Xs0 + 1, Ys0 + 1, BufferPitchSrc, *tRGBAs, *SrcMem)
                            icr1 = *tRGBAs\R * fXfs1 + icr
                            icg1 = *tRGBAs\G * fXfs1 + icg
                            icb1 = *tRGBAs\B * fXfs1 + icb
                            ica1 = *tRGBAs\A * fXfs1 + ica
                                               
                            ; Weight along axis Y
                            tPixel\R = fYfs1less * icr0 + fYfs1 * icr1
                            tPixel\G = fYfs1less * icg0 + fYfs1 * icg1
                            tPixel\B = fYfs1less * icb0 + fYfs1 * icb1
                            tPixel\A = fYfs1less * ica0 + fYfs1 * ica1                           
                           
                            WritePixel32 (tPixel, X, Y, BufferPitchDest, *tRGBAd, *DestMem)
                        EndIf           
                    Next
                Next           

        EndSelect
 EndSelect

 CopyImageData(nDestImage, *DestMem)
   
 FreeMemory(*SrcMem)
 FreeMemory(*DestMem)

 ProcedureReturn nDestImage

 CATCH()

 If EXCEPTION = #EXC_ALLOC_ERR
    If *SrcMem <> 0 : FreeMemory(*SrcMem) : EndIf
    If *DestMem <> 0 : FreeMemory(*DestMem) : EndIf
    FreeImage(nDestImage)
 EndIf
 
 ProcedureReturn 0
EndProcedure


Procedure.i FlipImage (nSrcImage)

; Flip vertically a 24/32 bit image preserving the alpha-channel

 Protected *tRGBAs.T_RGBA, *tRGBAd.T_RGBA, tPixel.T_RGBA, RotType
 Protected *SrcMem, *DestMem, BufferPitchSrc, BufferPitchDest
 Protected SrcWidth, SrcHeight, DestWidth, DestHeight, nDestImage
 Protected X, Y
 Protected BitPlanes
   
 ; sanity checks
 If IsImage(nSrcImage) = 0
    ProcedureReturn 0
 EndIf

 BitPlanes = ImageDepth(nSrcImage)

 If BitPlanes <> 24 And BitPlanes <> 32
    ProcedureReturn 0
 EndIf

 SrcWidth = ImageWidth(nSrcImage)
 SrcHeight = ImageHeight(nSrcImage)

 DestWidth = SrcWidth
 DestHeight = SrcHeight

 ; create 24/32 bit destination image
 nDestImage = CreateImage(#PB_Any, DestWidth, DestHeight, BitPlanes)
 TRY (nDestImage)

 ; copy src image to allocated memory
 *SrcMem = AllocateImageData(nSrcImage, @BufferPitchSrc)
 TRY (*SrcMem, #EXC_ALLOC_ERR)

 ; copy dest image to allocated memory
 *DestMem = AllocateImageData(nDestImage, @BufferPitchDest)
 TRY (*DestMem, #EXC_ALLOC_ERR)

 Select BitPlanes
    Case 24
        For Y = 0 To DestHeight - 1
            For X = 0 To DestWidth - 1           
                CopyPixel24 (X, SrcHeight - Y - 1, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)
            Next
         Next       
    Case 32
        For Y = 0 To DestHeight - 1
            For X = 0 To DestWidth - 1           
                CopyPixel32 (X, SrcHeight - Y - 1, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)
            Next
         Next   
 EndSelect

 CopyImageData(nDestImage, *DestMem)

 FreeMemory(*SrcMem)
 FreeMemory(*DestMem)

 ProcedureReturn nDestImage

 CATCH()

 If EXCEPTION = #EXC_ALLOC_ERR
    If *SrcMem <> 0 : FreeMemory(*SrcMem) : EndIf
    If *DestMem <> 0 : FreeMemory(*DestMem) : EndIf    
    FreeImage(nDestImage) 
 EndIf
 
 ProcedureReturn 0
EndProcedure

Procedure.i MirrorImage (nSrcImage)

; Mirror horizontally a 24/32 bit image preserving the alpha-channel

 Protected *tRGBAs.T_RGBA, *tRGBAd.T_RGBA, tPixel.T_RGBA, RotType
 Protected *SrcMem, *DestMem, BufferPitchSrc, BufferPitchDest, BitPlanes
 Protected SrcWidth, SrcHeight, DestWidth, DestHeight, nDestImage
 Protected X, Y

 ; sanity checks
 If IsImage(nSrcImage) = 0
    ProcedureReturn 0
 EndIf

 BitPlanes = ImageDepth(nSrcImage)

 If BitPlanes <> 24 And BitPlanes <> 32
    ProcedureReturn 0
 EndIf

 SrcWidth = ImageWidth(nSrcImage)
 SrcHeight = ImageHeight(nSrcImage)

 DestWidth = SrcWidth
 DestHeight = SrcHeight

 ; create 24/32 bit destination image
 nDestImage = CreateImage(#PB_Any, DestWidth, DestHeight, BitPlanes)
 TRY (nDestImage)

 ; copy src image to allocated memory
 *SrcMem = AllocateImageData(nSrcImage, @BufferPitchSrc)
 TRY (*SrcMem, #EXC_ALLOC_ERR)

 ; copy dest image to allocated memory
 *DestMem = AllocateImageData(nDestImage, @BufferPitchDest)
 TRY (*DestMem, #EXC_ALLOC_ERR)

 Select BitPlanes
    Case 24
        For Y = 0 To DestHeight - 1
            For X = 0 To DestWidth - 1
                CopyPixel24 (SrcWidth - X - 1, Y, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)     
            Next
        Next   
    Case 32
        For Y = 0 To DestHeight - 1
            For X = 0 To DestWidth - 1
                CopyPixel32 (SrcWidth - X - 1, Y, X, Y, BufferPitchSrc, BufferPitchDest, *tRGBAs, *tRGBAd, *SrcMem, *DestMem)     
            Next
        Next   
 EndSelect

 CopyImageData(nDestImage, *DestMem)

 FreeMemory(*SrcMem)
 FreeMemory(*DestMem)

 ProcedureReturn nDestImage
   
 CATCH()

 If EXCEPTION = #EXC_ALLOC_ERR   
    If *SrcMem <> 0 : FreeMemory(*SrcMem) : EndIf
    If *DestMem <> 0 : FreeMemory(*DestMem) : EndIf        
    FreeImage(nDestImage) 
 EndIf

 ProcedureReturn 0
EndProcedure

Code: Select all

; TEST - RotateImageFree

EnableExplicit

IncludeFile "..\RotateImage.pb"

Procedure.i CreateCheckers (Width, Height)
 Protected x, y
 Protected nImage, Size = 12
   
 nImage = CreateImage(#PB_Any, Width, Height, 24)
   
 If nImage
    StartDrawing(ImageOutput(nImage))
      
     Box(0, 0, Width, Height, $FFFFFF)
      
     While y < Height + Size
         While x < Width + Size
            Box(x, y, Size, Size, $C0C0C0)
            Box(x + Size, y + Size, Size, Size, $C0C0C0)
            x + Size * 2
         Wend
         x = 0
         y + Size * 2
     Wend
      
    StopDrawing()
 EndIf
   
 ProcedureReturn nImage
EndProcedure

Procedure.i MergeImages (nImgCheck, nImgOut)
 Protected nImage
   
 nImage = CreateImage(#PB_Any, ImageWidth(nImgCheck), ImageHeight(nImgCheck), 24)
   
 If nImage
    StartDrawing(ImageOutput(nImage))
      
     DrawImage(ImageID(nImgCheck), 0, 0)
     DrawAlphaImage(ImageID(nImgOut), 0, 0)
      
    StopDrawing()
 EndIf
   
 ProcedureReturn nImage   
EndProcedure


#WIN = 1
#IMG = 1

#IW = 640
#IH = 480

Define Event, Time1, k
Define nImgSrc, nImgOut, nFont
Define nImgCheck, nImgDisp


; ****************************************************************
; try to change these vars to check out the various combinations *
; ****************************************************************

Define BitPlanes = 32                   ; try 24 or 32 bpp image
Define flgAntiAlias = 1                 ; try antialias (1) or simpler rotation (0)
Define fRot = 33                        ; angle used for rotation
Define FillColor = RGB(255,255,255)     ; useful for transparent masking using GDI or simply to fill the background

nFont = LoadFont(#PB_Any, "Arial", 12, #PB_Font_Bold)

nImgSrc = CreateImage(#PB_Any, #IW, #IH, BitPlanes)

StartDrawing(ImageOutput(nImgSrc))

For k = 0 To 100 Step 20
   Box(0 + k, 0 + k, #IW - k * 2, #IH - k * 2, RGB(k + 50, k + 100, k + 150))
Next

DrawingMode(#PB_2DDrawing_Transparent)
DrawingFont(FontID(nFont))

For k = 0 To #IH Step #IH / 10
   DrawText(20, k + 10, "TEXT - " + Str(BitPlanes) + " BPP IMAGE - TEXT", RGB(k/3, k/2, k/2))
Next

If BitPlanes = 24
   DrawingMode(#PB_2DDrawing_Default)
   Circle(#IW - 200, 100, 50, RGB(128,0,0))
   Circle(#IW - 200, #IH - 100, 50, RGB(0,128,0))   
   Circle(#IW - 80, #IH/2, 50, RGB(0,0,128))
Else
   FillColor = 0
   
   ; make 3 holes
   DrawingMode(#PB_2DDrawing_AlphaChannel)
   Circle(#IW - 200, 100, 50,  $00)
   Circle(#IW - 200, #IH - 100, 50, $00)
   Circle(#IW - 80, #IH/2, 50, $00)
   
   ; fill them with semi-transparent circles
   DrawingMode(#PB_2DDrawing_AlphaBlend)
   Circle(#IW - 200, 100, 50, RGBA(128,0,0,100))
   Circle(#IW - 200, #IH - 100, 50, RGBA(0,128,0,100))
   Circle(#IW - 80, #IH/2, 50, RGBA(0,0,128,100))
EndIf

StopDrawing()

If OpenWindow(#WIN, 0, 0, 800, 800, "", #PB_Window_SystemMenu | #PB_Window_ScreenCentered)   
   Time1 = ElapsedMilliseconds()
   
   nImgOut = RotateImageFree(nImgSrc, fRot, flgAntiAlias, FillColor)
   
   Time1 = ElapsedMilliseconds() - Time1
   
   SetWindowTitle(#WIN, "Test " + Str(BitPlanes) + " bit, AA = " + Str(flgAntiAlias) + ", msec = " + Str(Time1) + ", deg = " + StrF(fRot,1))
   
   nImgCheck = CreateCheckers(ImageWidth(nImgOut), ImageHeight(nImgOut))
   nImgDisp = MergeImages(nImgCheck, nImgOut)
      
   FreeImage(nImgOut)
   FreeImage(nImgCheck)
      
  
   ImageGadget(#IMG, 0, 0, 0, 0, ImageID(nImgDisp))
   
   FreeImage(nImgDisp)
   
   While Event <> #PB_Event_CloseWindow           
      Event = WaitWindowEvent()
   Wend
      
   FreeImage(nImgSrc)
   FreeFont(nFont)
EndIf

Code: Select all

; TEST - RotateImage

EnableExplicit

IncludeFile "..\RotateImage.pb"

Procedure.i CreateCheckers (Width, Height)
 Protected x, y
 Protected nImage, Size = 12
 
 nImage = CreateImage(#PB_Any, Width, Height, 24)
 
 If nImage
    StartDrawing(ImageOutput(nImage))
    
     Box(0, 0, Width, Height, $FFFFFF)
     
     While y < Height + Size
        While x < Width + Size
            Box(x, y, Size, Size, $C0C0C0)
            Box(x + Size, y + Size, Size, Size, $C0C0C0)
            x + Size * 2
        Wend
        x = 0
        y + Size * 2
     Wend
     
    StopDrawing()
 EndIf
 
 ProcedureReturn nImage 
EndProcedure

Procedure.i MergeImages (nImgCheck, nImgOut)
 Protected nImage
 
 nImage = CreateImage(#PB_Any, ImageWidth(nImgCheck), ImageHeight(nImgCheck), 24)

 If nImage
    StartDrawing(ImageOutput(nImage))
    
     DrawImage(ImageID(nImgCheck), 0, 0)
     DrawAlphaImage(ImageID(nImgOut), 0, 0)
          
    StopDrawing()
 EndIf
 
 ProcedureReturn nImage 

EndProcedure


#WIN = 1
#IMG = 1

#IW = 640
#IH = 480

Define Event, Time1, k
Define nImgSrc, nImgOut, nFont
Define nImgCheck, nImgDisp


; ****************************************************************
; try to change these vars to check out the various combinations *
; ****************************************************************

Define BitPlanes = 32          ; test 24 or 32 bpp image
Define Rot = 90                ; angle used for rotation (+/-) 90, 180, 270


nFont = LoadFont(#PB_Any, "Arial", 14, #PB_Font_Bold)

nImgSrc = CreateImage(#PB_Any, #IW, #IH, BitPlanes)
       
StartDrawing(ImageOutput(nImgSrc))
 
 For k = 0 To 100 Step 20
    Box(0 + k, 0 + k, #IW - k * 2, #IH - k * 2, RGB(k + 50, k + 100, k + 150)) 
 Next

 DrawingMode(#PB_2DDrawing_Transparent)
 DrawingFont(FontID(nFont))
 
 For k = 0 To #IH Step #IH / 10
    DrawText(20, k + 8, "Text - " + Str(BitPlanes) + " BPP image - Text", RGB(k/3, k/2, k/2))
 Next

 If BitPlanes = 24        
    DrawingMode(#PB_2DDrawing_Default)                
    Circle(#IW - 200, 100, 50, RGB(128,0,0))
    Circle(#IW - 200, #IH - 100, 50, RGB(0,128,0))    
    Circle(#IW - 80, #IH/2, 50, RGB(0,0,128))        
 Else
    ; make 3 holes
    DrawingMode(#PB_2DDrawing_AlphaChannel)    
    Circle(#IW - 80, #IH/2, 50, $00)
    Circle(#IW - 200, 100, 50,  $00)
    Circle(#IW - 200, #IH - 100, 50, $00)
    
    ; fill them with semi-transparent circles
    DrawingMode(#PB_2DDrawing_AlphaBlend)
    Circle(#IW - 200, 100, 50, RGBA(128,0,0,100))
    Circle(#IW - 200, #IH - 100, 50, RGBA(0,128,0,100))
    Circle(#IW - 80, #IH/2, 50, RGBA(0,0,128,100))        
 EndIf
  
StopDrawing() 

    
; UsePNGImageDecoder()
; nImgSrc = LoadImage(#PB_Any, "test32.png")


If OpenWindow(#WIN, 0, 0, 600, 700, "", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) 
            
    Time1 = ElapsedMilliseconds()          
    nImgOut = RotateImage (nImgSrc, Rot)
    Time1 = ElapsedMilliseconds() - Time1
    
    If nImgOut = 0 : MessageRequester("Test", "Invalid angle ? (" + Str(Rot) + ")") :End: EndIf
    
    SetWindowTitle(#WIN, "Test " + Str(BitPlanes) + " bit, msec = " + Str(Time1) + ", deg = " + Str(Rot))

    nImgCheck = CreateCheckers(ImageWidth(nImgOut), ImageHeight(nImgOut))
    nImgDisp = MergeImages(nImgCheck, nImgOut)
        
    FreeImage(nImgOut)
    FreeImage(nImgCheck)
        
    ImageGadget(#IMG, 0, 0, 0, 0, ImageID(nImgDisp), #PB_Image_Border)
    
    While Event <> #PB_Event_CloseWindow            
        Event = WaitWindowEvent()
    Wend
                
    FreeImage(nImgDisp)
    FreeImage(nImgSrc)
    FreeFont(nFont)
EndIf

Code: Select all

; TEST - Flip and Mirror

EnableExplicit

IncludeFile "..\RotateImage.pb"

Procedure.i CreateCheckers (Width, Height)
 Protected x, y
 Protected nImage, Size = 12
 
 nImage = CreateImage(#PB_Any, Width, Height, 24)
 
 If nImage
    StartDrawing(ImageOutput(nImage))
    
     Box(0, 0, Width, Height, $FFFFFF)
     
     While y < Height + Size
        While x < Width + Size
            Box(x, y, Size, Size, $C0C0C0)
            Box(x + Size, y + Size, Size, Size, $C0C0C0)
            x + Size*2           
        Wend
        x = 0
        y + Size*2
     Wend
     
    StopDrawing()
 EndIf
 
 ProcedureReturn nImage 
EndProcedure

Procedure.i MergeImages (nImgCheck, nImgOut)
 Protected nImage
 
 nImage = CreateImage(#PB_Any, ImageWidth(nImgCheck), ImageHeight(nImgCheck), 24)

 If nImage
    StartDrawing(ImageOutput(nImage))
    
     DrawImage(ImageID(nImgCheck), 0, 0)
     DrawAlphaImage(ImageID(nImgOut), 0, 0)
          
    StopDrawing()
 EndIf
 
 ProcedureReturn nImage 

EndProcedure


#WIN   = 1
#IMG_1 = 1
#IMG_2 = 2

#IW = 512
#IH = 360

Define Event, Time1, k, Title$
Define nImgSrc, nImgOut, nFont
Define nImgCheck, nImgDisp1, nImgDisp2


; ****************************************************************
; try to change these vars to check out the various combinations *
; ****************************************************************

Define BitPlanes = 32          ; test 24 or 32 bpp image
Define flgFlipOrMirror = 0     ; 1 = FlipImage(),  0 = MirrorImage()


nFont = LoadFont(#PB_Any, "Arial", 12, #PB_Font_Bold)

nImgSrc = CreateImage(#PB_Any, #IW, #IH, BitPlanes)
       
StartDrawing(ImageOutput(nImgSrc))
 
 For k = 0 To 100 Step 20
    Box(0 + k, 0 + k, #IW - k * 2, #IH - k * 2, RGB(k + 50, k + 100, k + 150)) 
 Next

 DrawingMode(#PB_2DDrawing_Transparent)
 DrawingFont(FontID(nFont))
 
 For k = 0 To #IH Step #IH / 10
    DrawText(20, k + 8, "Text - " + Str(BitPlanes) + " BPP image - Text", RGB(k/3, k/2, k/2))
 Next

 If BitPlanes = 24
    DrawingMode(#PB_2DDrawing_Default)                
    Circle(#IW - 180, 100, 50, RGB(128,0,0))
    Circle(#IW - 180, #IH - 100, 50, RGB(0,128,0))    
    Circle(#IW - 80, #IH/2, 50, RGB(0,0,128))        
 Else
    ; make 3 holes
    DrawingMode(#PB_2DDrawing_AlphaChannel)        
    Circle(#IW - 180, 100, 50,  $00)
    Circle(#IW - 180, #IH - 100, 50, $00)
    Circle(#IW - 80, #IH/2, 50, $00)
    
    ; fill them with semi-transparent circles
    DrawingMode(#PB_2DDrawing_AlphaBlend)
    Circle(#IW - 180, 100, 50, RGBA(128,0,0,100))
    Circle(#IW - 180, #IH - 100, 50, RGBA(0,128,0,100))
    Circle(#IW - 80, #IH/2, 50, RGBA(0,0,128,100))        
 EndIf
  
StopDrawing() 

    
;;UsePNGImageDecoder()    
;;nImgSrc = LoadImage(#PB_Any, "test24.bmp")
;;nImgSrc = LoadImage(#PB_Any, "test32.png")


If OpenWindow(#WIN, 0, 0, 600, 800, "", #PB_Window_SystemMenu | #PB_Window_ScreenCentered) 
            
    Time1 = ElapsedMilliseconds()          

    If flgFlipOrMirror = 1        
        nImgOut = FlipImage(nImgSrc)
    Else
        nImgOut = MirrorImage(nImgSrc)
    EndIf   
    
    Time1 = ElapsedMilliseconds() - Time1
    
    If flgFlipOrMirror = 1
        Title$ = "Test FlipImage(), " 
    Else
        Title$ = "Test MirrorImage(), " 
    EndIf   
                       
    SetWindowTitle(#WIN, Title$ + Str(BitPlanes) + " bit, msec = " + Str(Time1))

    nImgCheck = CreateCheckers(ImageWidth(nImgOut), ImageHeight(nImgOut))
    
    nImgDisp1 = MergeImages(nImgCheck, nImgSrc)
        
    nImgDisp2 = MergeImages(nImgCheck, nImgOut)
        
        
    FreeImage(nImgOut)
    FreeImage(nImgCheck)
    
    ImageGadget(#IMG_1, 0, 0, 0, 0, ImageID(nImgDisp1), #PB_Image_Border)    
    ImageGadget(#IMG_2, 0, 400, 0, 0, ImageID(nImgDisp2), #PB_Image_Border)
    
    While Event <> #PB_Event_CloseWindow            
        Event = WaitWindowEvent()
    Wend
    
    FreeImage(nImgDisp1)            
    FreeImage(nImgDisp2)
    FreeImage(nImgSrc)
    FreeFont(nFont)
EndIf

Code: Select all

For iY = 0 To iDestHeight - 1
            For iX = 0 To iDestWidth - 1
                ; For each nDestImage point find rotated nSrcImage source point
                fXs = iXc1 + (iX - iXc2) * fzCos + (iY - iYc2) * fzSin
                fYs = iYc1 + (iY - iYc2) * fzCos - (iX - iXc2) * fzSin

Code: Select all

For iY = 0 To iDestHeight - 1
            For iX = 0 To iDestWidth - 1
                ; For each nDestImage point find rotated nSrcImage source point
                fXs = iX
                fYs = iY

Code: Select all

                ; Bottom left coords of bounding floating point rectangle on nSrcImage
                iXs0 = Int(fXs)   
                iYs0 = Int(fYs)
                   
                If iXs0 > 0 And iXs0 < iSrcWidth -1 And iYs0 > 0 And iYs0 < iSrcHeight - 1
                
                    fXfs1 = fXs - Int(fXs)
                    fYfs1 = fYs - Int(fYs)

                    fXfs1less = 1 - fXfs1
                    fYfs1less = 1 - fYfs1

Code: Select all

;Fast and clean rotation 
;Original Code : LSI (le soldat inconnu) for his effects library (http://www.purearea.net/pb/download/userlibs/Effect.zip) 
;Optimisation (not fully optimised) by djes (djes@free.fr)
;Not needing assembly inline by psychopanta

;#PI.f=3.14159265 

;******************************************************************************************************
; RotateImageEx2
;>= Angle (in degrees :()
ProcedureDLL.l RotateImageEx2(ImageID, Angle.f)
  Protected bmi.BITMAPINFO, bmi2.BITMAPINFO, Hdc.l, NewImageID, Mem, n, nn, bm.BITMAP 
  
  ;radian conversion
  Debug "Angle : "+Str(angle)
  Angle*#PI/180 
  
  Protected Cos.f = Cos(Angle) 
  Protected Sin.f = Sin(Angle) 
  
  Protected CouleurFond = 0 
  
  GetObject_(ImageID, SizeOf(BITMAP), @bm.BITMAP) 
  
  bmi\bmiHeader\biSize = SizeOf(BITMAPINFOHEADER) 
  bmi\bmiHeader\biWidth = bm\bmWidth 
  bmi\bmiHeader\biHeight = bm\bmHeight 
  bmi\bmiHeader\biPlanes = 1 
  bmi\bmiHeader\biBitCount = 32 
  bmi\bmiHeader\biCompression = #BI_RGB 
  
  bmi2\bmiHeader\biSize = SizeOf(BITMAPINFOHEADER) 
  bmi2\bmiHeader\biWidth = bm\bmWidth * Abs(Cos) + bm\bmHeight * Abs(Sin) 
  bmi2\bmiHeader\biHeight = bm\bmHeight * Abs(Cos) + bm\bmWidth * Abs(Sin) 
  bmi2\bmiHeader\biPlanes = 1 
  bmi2\bmiHeader\biBitCount = 32 
  bmi2\bmiHeader\biCompression = #BI_RGB 
  
  Mem = AllocateMemory(bm\bmWidth * bm\bmHeight * 4) 
  If Mem 
    Protected Mem2 = AllocateMemory(bmi2\bmiHeader\biWidth * bmi2\bmiHeader\biHeight * 4) 
    If Mem2 
      
      ;retrieves the bits of the specified bitmap and copies them into a buffer
      Hdc = CreateCompatibleDC_(GetDC_(ImageID)) 
      If Hdc 
        GetDIBits_(Hdc, ImageID, 0, bm\bmHeight, Mem, @bmi, #DIB_RGB_COLORS)
        ReleaseDC_(0, Hdc) 
      EndIf 
      
      Protected CX1 = bm\bmWidth - 1 
      Protected CY1 = bm\bmHeight - 1 
      Protected CX2 = bmi2\bmiHeader\biWidth - 1 
      Protected CY2 = bmi2\bmiHeader\biHeight - 1 
      
      Protected Mem01 = Mem + bm\bmWidth * 4 
      Protected Mem10 = Mem + 4 
      Protected Mem11 = Mem01 + 4 
      
      Protected Mem2Temp = Mem2 
      Protected deb=-CX2/2
      Protected fin=deb+CX2;= Round(CX2/2,1) but <> (CX2*2-CX2)/2 
          
      For nn = 0 To CY2 

        Protected x1b.l
        Protected y1b.l = (nn * 2) - CY2 

        Protected Temp1.f = (CX1 - (y1b * Sin))/2
        Protected Temp2.f = (CY1 + (y1b * Cos))/2       

        Protected x1.f = Temp1 + (deb * Cos)
        Protected y1.f = Temp2 + (deb * Sin)

        For x1b = deb To fin 
          
          ;could be faster with arrays
          
          Protected x2.l = x1 
          Protected y2.l = y1 
          
          If x1 < x2 
            !dec dword[p.v_x2] 
          EndIf 
          If y1 < y2 
            !dec dword[p.v_y2] 
          EndIf 
          
          Protected x2b.l = x2 + 1 
          Protected y2b.l = y2 + 1 
          
          ;test boundaries
          If x2b >= 0 And x2 <= CX1 And y2b >= 0 And y2 <= CY1  
          
            Protected fx.f = x1 - x2 
            Protected fy.f = y1 - y2 
            Protected f00.f = 1 - fx 
            Protected f10.f = 1 - fy 
            Protected f01.f = f00 * fy 
            f00 * f10 
            f10 * fx 
            Protected f11.f = fx * fy 
          
            Protected MemTemp = (x2 + y2 * bm\bmWidth) * 4 
            Protected c00.l, c01.l, c11.l, c10.l 
            
            If x2 >= 0 And x2 <= CX1 
              If y2 >= 0 And y2 <= CY1 
                !mov eax,dword[p.v_Mem] 
                !add eax,dword[p.v_MemTemp] 
                !mov eax,dword[eax] 
                !mov dword[p.v_c00],eax 
                ;c00 = PeekL(Mem + MemTemp) 
              Else 
                c00 = 0 
              EndIf 
              If y2b >= 0 And y2b <= CY1 
                !mov eax,dword[p.v_Mem01] 
                !add eax,dword[p.v_MemTemp] 
                !mov eax,dword[eax] 
                !mov dword[p.v_c01],eax 
                ;c01 = PeekL(Mem01 + MemTemp) 
              Else 
                c01 = 0 
              EndIf 
            Else 
              c00 = 0 
              c01 = 0 
            EndIf 
            If x2b >= 0 And x2b <= CX1 
              If y2 >= 0 And y2 <= CY1 
                !mov eax,dword[p.v_Mem10] 
                !add eax,dword[p.v_MemTemp] 
                !mov eax,dword[eax] 
                !mov dword[p.v_c10],eax 
                ;c10 = PeekL(Mem10 + MemTemp) 
              Else 
                c10 = 0 
              EndIf 
              If  y2b >= 0 And y2b <= CY1 
                !mov eax,dword[p.v_Mem11] 
                !add eax,dword[p.v_MemTemp] 
                !mov eax,dword[eax] 
                !mov dword[p.v_c11],eax 
                ;c11 = PeekL(Mem11 + MemTemp) 
              Else 
                c11 = 0 
              EndIf 
            Else 
              c10 = 0 
              c11 = 0 
            EndIf 
    
            Protected r1.l,r2.l,r3.l,r4.l,g1.l,g2.l,g3.l,g4.l,b1.l,b2.l,b3.l,b4.l 

            !mov eax,dword[p.v_c00] 
            !mov ebx,eax 
            !mov ecx,eax 

            !and eax,$FF 
            !mov dword[p.v_r1],eax 
            !and ebx,$FF00 
            !mov dword[p.v_g1],ebx 
            !and ecx,$FF0000 
            !mov dword[p.v_b1],ecx 

            !mov eax,dword[p.v_c10] 
            !mov ebx,eax 
            !mov ecx,eax 

            !and eax,$FF 
            !mov dword[p.v_r2],eax 
            !and ebx,$FF00 
            !mov dword[p.v_g2],ebx 
            !and ecx,$FF0000 
            !mov dword[p.v_b2],ecx 

            !mov eax,dword[p.v_c01] 
            !mov ebx,eax 
            !mov ecx,eax 

            !and eax,$FF 
            !mov dword[p.v_r3],eax 
            !and ebx,$FF00 
            !mov dword[p.v_g3],ebx 
            !and ecx,$FF0000 
            !mov dword[p.v_b3],ecx 

            !mov eax,dword[p.v_c11] 
            !mov ebx,eax 
            !mov ecx,eax 

            !and eax,$FF 
            !mov dword[p.v_r4],eax 
            !and ebx,$FF00 
            !mov dword[p.v_g4],ebx 
            !and ecx,$FF0000 
            !mov dword[p.v_b4],ecx 
      
           ;pure knows well how to do this 
            Protected r.l = r1 * f00 + r2 * f10 + r3 * f01 + r4 * f11
            Protected g.l = g1 * f00 + g2 * f10 + g3 * f01 + g4 * f11 
            Protected b.l = b1 * f00 + b2 * f10 + b3 * f01 + b4 * f11 
          
            !mov eax,dword[p.v_r] 
            !mov ebx,dword[p.v_g] 
            !mov ecx,dword[p.v_b]
            ;one trick is to let triplets at the same place to avoid shifting
            !and eax,$FF                                      
            !and ebx,$FF00 
            !and ecx,$FF0000 
            !or eax,ebx 
            !or eax,ecx 

            !mov ebx,dword[p.v_Mem2Temp] 
            !mov dword[ebx],eax 
          
          Else 

            !mov ebx,dword[p.v_Mem2Temp] 
            !xor eax,eax 
            !mov dword[ebx],eax 

          EndIf 
          
          Mem2Temp + 4 
          x1 + cos
          y1 + sin
          
        Next 
      Next 
      
      ; On crée la nouvelle image 
      NewImageID = CreateImage(#PB_Any, bmi2\bmiHeader\biWidth, bmi2\bmiHeader\biHeight) 
      Hdc = CreateCompatibleDC_(GetDC_(ImageID(NewImageID))) 
      If Hdc 
        SetDIBits_(Hdc, ImageID(NewImageID), 0, bmi2\bmiHeader\biHeight, Mem2, @bmi2, #DIB_RGB_COLORS) ; on envoie la liste dans l'image 
        ReleaseDC_(0, Hdc) 
      EndIf 
      
      FreeMemory(Mem2) 
    EndIf 
    FreeMemory(Mem) 
  EndIf 
  
  ProcedureReturn NewImageID 
EndProcedure 

;******************************************************************************************************
;- Speed Test

SetPriorityClass_(GetCurrentProcess_(),#REALTIME_PRIORITY_CLASS) 

#NbTest = 4 

MessageRequester("Speed test",Str(#NbTest)+" rotations of a 1000x1000 image...") 

BigImage = CreateImage(#PB_Any, 1000, 1000) 
If BigImage<>0 
  StartDrawing(ImageOutput(BigImage)) 
    For n = 0 To 999 
      For nn = 0 To 999 
        Plot(n, nn, Random($FFFFFF)) 
      Next 
    Next 
  StopDrawing() 
  
  Dim Liste(ImageWidth(BigImage) - 1, ImageHeight(BigImage) - 1) 
  
  Time1 = ElapsedMilliseconds() 
  
  For n = 1 To #NbTest 
    DestImage = RotateImageEx2(ImageID(BigImage), 30) 
  Next 
  
  Time2 = ElapsedMilliseconds() 
  
  Speed = (Time2 - Time1) / #NbTest 
  NbPixels = ImageHeight(BigImage) * ImageWidth(BigImage) 
  
  MessageRequester("Results", "Average speed of "+Str(Speed) + " ms" + Chr(10) + "Image of " + Str(ImageWidth(BigImage)) + " * " + Str(ImageHeight(BigImage)) + " pixels" + Chr(10) + "Pixels nb = " + Str(NbPixels), 0) 
EndIf 

;******************************************************************************************************
;- Drawing test 

SrcImage = CreateImage(#PB_Any, 80, 100) 

If SrcImage<>0 
  StartDrawing(ImageOutput(SrcImage)) 
    Box(0, 0, 80, 100, $6F6F6F) 
    Box(5, 5, 35, 45, $FF) 
    Box(40, 5, 35, 45, $FF00) 
    Box(5, 50, 35, 45, $FF0000) 
    Box(40, 50, 35, 45, $FFFFFF) 
  StopDrawing() 
  
  RotImage = RotateImageEx2(ImageID(SrcImage), u)  

EndIf 

SetPriorityClass_(GetCurrentProcess_(),#NORMAL_PRIORITY_CLASS) 

; Création de la fenêtre et de la GadgetList 
If OpenWindow(0, 0, 0, 250, 300, "Effect - Image rotation", #PB_Window_SystemMenu | #PB_Window_ScreenCentered | #PB_Window_MinimizeGadget) = 0 Or CreateGadgetList(WindowID(0)) = 0 
  End 
EndIf 

TextGadget(#PB_Any, 10, 10, 100, 15, "Src Image") 
ImageGadget(#PB_Any, 10, 25, 0, 0, ImageID(SrcImage)) 

TextGadget(1, 10, 135, 100, 15, "Rotation") 
ImageGadget(2, 10, 150, 0, 0, ImageID(RotImage)) 

angle = 1

Repeat

  Event = WindowEvent() 
  Delay(20)

  RotImage1 = ImageID(RotateImageEx2(ImageID(SrcImage), angle))

  SetGadgetText(1, "Rotation : " + Str(angle))
  SetGadgetState(2, RotImage1)

  If IsImage(RotImage2) : FreeImage(RotImage2) : Delay(20) : EndIf

  angle + 1

  RotImage2 = ImageID(RotateImageEx2(ImageID(SrcImage), angle))

  SetGadgetText(1, "Rotation : " + Str(angle))
  SetGadgetState(2, RotImage2)

  If IsImage(RotImage1) : FreeImage(RotImage1) : Delay(20) : EndIf

  angle + 1
  

Until Event = #PB_Event_CloseWindow 

End