;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; ROLLIT because not near 90 degree roll angles, AND user want to roll image. 
;    Remember UVSP has already been adjusted -90 
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

PRO uvspROLLIT,struc=struc,data=data,hd=HD,rolls=ROLL,det=d, $
                  xcorners=xcorners,ycorners=ycorners
common order1, diskexp, control, generic, comment

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ; If needed, make roll angle less than 180 degrees
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 if abs(roll) le 180 then mroll = roll $
   else if roll lt 0 then mroll = roll + 360 else mroll = roll - 360  

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ; Which quadrant will the image be rolled to. 
 ;    Truncate quad; neg. rolls synched w/pos rolls by adding the number 3.
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 siz = size(data)   &   quad = roll/90.
 IF quad ge 0 THEN quad = fix(quad) ELSE quad = fix(quad) + 3 

 case 1 of    			; angle and hypotenuse, to figure Rside
   quad eq 2 : begin				; -90 to -180
	angle = 90 - (180 + mroll) & highhyp = siz(1)  & lowhyp = siz(2) & end
   quad eq 1 : begin				; +90 to +180
 	angle = 90 - (mroll - 90)  & highhyp = siz(2)  & lowhyp = siz(1) & end
   quad eq 3 : begin  			; -0 to -90
	angle = mroll &  highhyp = siz(2)  & lowhyp = siz(1) & end           
   quad eq 0 : begin				; +0 to +90
	angle = 90 - mroll & highhyp = siz(1)  & lowhyp = siz(2) & end
   else: widget_control, comment, set_value='ERROR-UVSPROLLIT, ' + $
				'invalid rotate variable.', /append
 endcase

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;	  
 ; Rside:  # pixels from bottom corner to right side of array
 ; Tside:  # pixels from right corner to top of array
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 theta = angle/!radeg  &  cosine = abs(cos(theta))  &  sine = abs(sin(theta))
 Rside = fix(lowhyp * cosine) + 1  &  Tside  = fix(highhyp * cosine) + 1

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ; Embed the raster in array large enough that ROT_INT doesn't truncate image
 ; Put data in a field of negative numbers to distinguish background from data.
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 twice = 2 * max([siz(1),siz(2)])    		; larger dimension 
 workarr = bytarr(twice,twice)        		; large embedding array
 workarr = workarr-1                            ; field of non-data values
 workarr(twice/2-siz(1)/2, twice/2-siz(2)/2) = data(*,*)  ; center embed raster 

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ; Roll the large array.
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 data = 0  &  data = rot_int(workarr,roll)  &  workarr = 0

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ; Read thru array until hit valid data value (not -1), indicating left edge
 ;       then read until hit invalid data (-1) indicating right edge of data.
 ; Read up until bottom edge of data, then to top edge.
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 i = 0  &  while max(data(i,*)) lt 0 and i lt twice do i = i+1  &  left = i
 while max(data(i,*)) ge 0 and i lt twice do i = i+1            &  right = i-1

 i = 0  &  while max(data(*,i)) lt 0 and i lt twice do i = i+1  &  bot = i
 while max(data(*,i)) ge 0 and i lt twice do i = i+1            &  top = i-1 

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ; Now cut away all the non-data part of large array
 ; Undo the -1 invalid data field
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 data = data(left:right,bot:top)   &   data = data * (data ge 0)  

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;	  
 ; Lside:  # pixels from left side of array to bottom corner
 ; Bside:  # pixels from bottom of array to right corner
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 height = top - bot +1  &  width = right - left +1
 Lside = width - Rside  &  Bside = height - Tside      	 
                  
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;
 ; The corners of the image, without xpos and ypos adjustment or normalized 
 ;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

 xcorners = [lside, width, rside,  0.,    lside] 
 ycorners = [0.,    bside, height, tside, 0.   ]

return & end