Subversion Repositories filter_foundry

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. <html><head>
  2. <meta http-equiv="Content-Type" content="text/html; charset=windows-1250"><title>prah.c</title></head>
  3.  
  4. <body>
  5.  
  6. <p><small>//-------------------------------------------------------------------------------<br>
  7. //<br>
  8. //    File:<br>
  9. //        prah.c<br>
  10. //<br>
  11. <br>
  12. <br>
  13. #include "PIDefines.h"<br>
  14. <br>
  15. #ifdef __PIMWCWMacPPC__<br>
  16.     #include "prah-PPC.ch"<br>
  17. #elif defined(__PIMWCWMac68K__)<br>
  18.     #include "prah-68k.ch"<br>
  19.     // We're using Metrowerks and they have an A4 library, so set that up:<br>
  20.     #include &lt;SetupA4.h&gt;<br>
  21.     #include &lt;A4Stuff.h&gt;<br>
  22.     <br>
  23.     #define UseA4 // We've now defined this for quick checks later.<br>
  24. #else<br>
  25.     #include "prah.h"<br>
  26. #endif<br>
  27. <br>
  28. #include &lt;math.h&gt;<br>
  29. #include &lt;stdio.h&gt;<br>
  30. #include &lt;stdlib.h&gt;<br>
  31. <br>
  32. #include &lt;math.h&gt;<br>
  33. <br>
  34. <br>
  35. // Peker til tabellen<br>
  36. //prcomplex *sincos_tab;<br>
  37. //-------------------------------------------------------------------------------<br>
  38. //    Prototypes.<br>
  39. //-------------------------------------------------------------------------------<br>
  40. <br>
  41. // Everything comes in and out of ENTRYPOINT. It must be first routine in source:<br>
  42. MACPASCAL void ENTRYPOINT (const short selector,<br>
  43.                         FilterRecord
  44. *filterParamBlock,<br>
  45.                         long
  46. *data,<br>
  47.                         short
  48. *result);<br>
  49. void InitGlobals (Ptr globalPtr);
  50.             // Initialize globals.<br>
  51. void ValidateParameters (GPtr globals);        //
  52. Validates (inits) parameters.<br>
  53. <br>
  54. void DoStart (GPtr globals);
  55.                 //
  56. Main routine.<br>
  57. void DoParameters (GPtr globals);<br>
  58. void DoPrepare (GPtr globals);<br>
  59. void DoContinue (GPtr globals);<br>
  60. void DoFinish (GPtr globals);<br>
  61. <br>
  62. void StartWithAdvanceState (GPtr globals);<br>
  63. <br>
  64. void prah (GPtr globals, const Boolean doProgress);<br>
  65. <br>
  66. void CalcProxyScaleFactor (Rect proxyScaleRect, Rect *proxyRect, short *scaleFactor);<br>
  67. boolean ParametersTest(GPtr globals);<br>
  68. <br>
  69. void ZoomInRect (GPtr globals, Boolean mask);<br>
  70. void ZoomOutRect (GPtr globals, Boolean mask);<br>
  71. <br>
  72. void StartNoAdvanceState (GPtr globals);<br>
  73. void DoInitialRect (GPtr globals);<br>
  74. Boolean DoNextRect (GPtr globals);<br>
  75. //void Ret(GPtr globals);<br>
  76. <br>
  77. void BuildProxy (GPtr globals);<br>
  78. void scaleRect(Rect *l, short n, short d);<br>
  79. void shrinkRect(Rect *l, short x, short y);<br>
  80. void copyRect(Rect *l, const Rect *r);<br>
  81.                 <br>
  82. //-------------------------------------------------------------------------------<br>
  83. //    Globals -- Define global variables for plug-in scope.<br>
  84. //-------------------------------------------------------------------------------<br>
  85. <br>
  86. // Windows global for plug-in (considered a Dynamically Linked Library).<br>
  87. // Leave NULL for Macintosh; many cross-platform library utilities require<br>
  88. // something passed in for hDllInstance:<br>
  89. Handle hDllInstance = NULL;<br>
  90. <br>
  91. //-------------------------------------------------------------------------------<br>
  92. //    ENTRYPOINT Export -- Export our entrypoint<br>
  93. //<br>
  94. //    Have to export our info for PPCGlue stub which needs a descriptor
  95. built<br>
  96. //    to be called from within a 68k code fragment.<br>
  97. //-------------------------------------------------------------------------------<br>
  98. <br>
  99. #ifdef __PIMacPPC__
  100.                         //
  101. For "fat" PowerMac plug-ins<br>
  102. <br>
  103.     enum<br>
  104.     {<br>
  105.         uppEntryProcInfo = kPascalStackBased<br>
  106.             | RESULT_SIZE(0)<br>
  107.             |
  108. STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(short)))<br>
  109.             |
  110. STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(FilterRecord *)))<br>
  111.             |
  112. STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(long *)))<br>
  113.             |
  114. STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(short *)))<br>
  115.     };<br>
  116. <br>
  117.     #if PRAGMA_EXPORT_SUPPORTED <br>
  118.         #pragma export on<br>
  119.     #endif<br>
  120. <br>
  121.     RoutineDescriptor main_PPC = BUILD_ROUTINE_DESCRIPTOR(uppEntryProcInfo,
  122. main);<br>
  123. <br>
  124.     #if PRAGMA_EXPORT_SUPPORTED<br>
  125.         #pragma export reset<br>
  126.     #endif<br>
  127. <br>
  128. #endif<br>
  129. <br>
  130. //-------------------------------------------------------------------------------<br>
  131. //<br>
  132. //    ENTRYPOINT / main<br>
  133. //<br>
  134. //    All calls to the plug-in module come through this routine.<br>
  135. //    It must be placed first in the resource. To achieve this,<br>
  136. //    most development systems require this be the first routine<br>
  137. //    in the source.<br>
  138. //<br>
  139. //    The entrypoint will be "pascal void" for Macintosh,<br>
  140. //    "void" for Windows.<br>
  141. //<br>
  142. //    Inputs:<br>
  143. //        const short selector
  144.                         Host
  145. provides selector indicating<br>
  146. //
  147.                                                     what
  148. command to do.<br>
  149. //<br>
  150. //        FilterRecord *filterParamBlock
  151.                 Host
  152. provides pointer to parameter<br>
  153. //
  154.                                                     block
  155. containing pertinent data<br>
  156. //
  157.                                                     and
  158. callbacks from the host.<br>
  159. //
  160.                                                     See
  161. PIFilter.h.<br>
  162. //<br>
  163. //    Outputs:<br>
  164. //        FilterRecord *filterParamBlock
  165.                 Host
  166. provides pointer to parameter<br>
  167. //
  168.                                                     block
  169. containing pertinent data<br>
  170. //
  171.                                                     and
  172. callbacks from the host.<br>
  173. //
  174.                                                     See
  175. PIFilter.h.<br>
  176. //<br>
  177. //        long *data
  178.                                     Use
  179. this to store a handle to our<br>
  180. //
  181.                                                     global
  182. parameters structure, which<br>
  183. //
  184.                                                     is
  185. maintained by the host between<br>
  186. //
  187.                                                     calls
  188. to the plug-in.<br>
  189. //<br>
  190. //        short *result
  191.                                 Return
  192. error result or noErr. Some<br>
  193. //
  194.                                                     errors
  195. are handled by the host, some<br>
  196. //
  197.                                                     are
  198. silent, and some you must handle.<br>
  199. //
  200.                                                     See
  201. PIGeneral.h.<br>
  202. //<br>
  203. //-------------------------------------------------------------------------------<br>
  204. <br>
  205. MACPASCAL void ENTRYPOINT (const short selector,<br>
  206.                         FilterRecord
  207. *filterParamBlock,<br>
  208.                         long
  209. *data,<br>
  210.                         short
  211. *result)<br>
  212. {<br>
  213.     //---------------------------------------------------------------------------<br>
  214.     //    (1) Enter code resource if Mac 68k.<br>
  215.     //---------------------------------------------------------------------------<br>
  216.     <br>
  217.     #ifdef UseA4
  218.                 //
  219. Are we in 68k Mac MW?<br>
  220.         EnterCodeResource();     //
  221. A4-globals<br>
  222.     #endif<br>
  223.     <br>
  224.     //---------------------------------------------------------------------------<br>
  225.     //    (2) Check for about box request.<br>
  226.     //<br>
  227.     //     The about box is a special request; the
  228. parameter block is not filled<br>
  229.     //     out, none of the callbacks or standard data
  230. is available. Instead,<br>
  231.     //     the parameter block points to an
  232. AboutRecord, which is used<br>
  233.     //     on Windows.<br>
  234.     //---------------------------------------------------------------------------<br>
  235. <br>
  236.     if (selector == filterSelectorAbout)<br>
  237.     {<br>
  238.         DoAbout((AboutRecordPtr)filterParamBlock);<br>
  239.     }<br>
  240.     else<br>
  241.     { // do the rest of the process as normal:<br>
  242. <br>
  243.         //-----------------------------------------------------------------------<br>
  244.         //    (3) Initialize function
  245. and global pointers.<br>
  246.         //<br>
  247.         //     Initialize function
  248. pointer routine dispatcher. We use this to jump<br>
  249.         //     to the different
  250. routines, instead of a long obnoxious switch<br>
  251.         //     statement. All
  252. routines are expected to have the same prototype<br>
  253.         //     of "void
  254. RoutineName (globals)". Returns any errors in gResult.<br>
  255.         //<br>
  256.         //     WARNING: These
  257. better be in the order of the selector AND there<br>
  258.         //     better be a routine
  259. for every selector call.<br>
  260.         //-----------------------------------------------------------------------<br>
  261.         <br>
  262.         static const FProc routineForSelector [] =<br>
  263.         {<br>
  264.             /* filterSelectorAbout
  265.              DoAbout, */<br>
  266.             /*
  267. filterSelectorParameters */    DoParameters,<br>
  268.             /*
  269. filterSelectorPrepare */        DoPrepare,<br>
  270.             /* filterSelectorStart
  271. */        DoStart,<br>
  272.             /*
  273. filterSelectorContinue */    DoContinue,<br>
  274.             /* filterSelectorFinish
  275. */        DoFinish<br>
  276.         };<br>
  277.         <br>
  278.         Ptr globalPtr = NULL;
  279.         // Pointer for global structure<br>
  280.         GPtr globals = NULL;
  281.          // actual globals<br>
  282. <br>
  283.         //-----------------------------------------------------------------------<br>
  284.         //    (4) Allocate and initalize
  285. globals.<br>
  286.         //<br>
  287.         //     AllocateGlobals
  288. requires the pointer to result, the pointer to the<br>
  289.         //     parameter block, a
  290. pointer to the handle procs, the size of our local<br>
  291.         //     "Globals"
  292. structure, a pointer to the long *data, a Function<br>
  293.         //     Proc (FProc) to the
  294. InitGlobals routine. It automatically sets-up,<br>
  295.         //     initializes the
  296. globals (if necessary), results result to 0, and<br>
  297.         //     returns with a valid
  298. pointer to the locked globals handle or NULL.<br>
  299.         //-----------------------------------------------------------------------<br>
  300.         <br>
  301.         globalPtr = AllocateGlobals ((uint32)result,<br>
  302.                                     (uint32)filterParamBlock,<br>
  303.                                     filterParamBlock-&gt;handleProcs,<br>
  304.                                     sizeof(Globals),<br>
  305.                                     data,<br>
  306.                                     InitGlobals);<br>
  307.         <br>
  308.         if (globalPtr == NULL)<br>
  309.         { // Something bad happened if we couldn't
  310. allocate our pointer.<br>
  311.         // Fortunately, everything's already been
  312. cleaned up,<br>
  313.         // so all we have to do is report an error.<br>
  314.         <br>
  315.         *result = memFullErr;<br>
  316.         return;<br>
  317.         }<br>
  318.         <br>
  319.         // Get our "globals" variable
  320. assigned as a Global Pointer struct with the<br>
  321.         // data we've returned:<br>
  322.         globals = (GPtr)globalPtr;<br>
  323. <br>
  324.         //-----------------------------------------------------------------------<br>
  325.         //    (5) Dispatch selector.<br>
  326.         //-----------------------------------------------------------------------<br>
  327. <br>
  328.         if (selector &gt; filterSelectorAbout
  329. &amp;&amp; selector &lt;= filterSelectorFinish)<br>
  330.             (routineForSelector[selector-1])(globals);
  331. // dispatch using jump table<br>
  332.         else<br>
  333.             gResult =
  334. filterBadParameters;<br>
  335.             <br>
  336.         //-----------------------------------------------------------------------<br>
  337.         //    (6) Unlock data, and exit
  338. resource.<br>
  339.         //<br>
  340.         //    Result is automatically
  341. returned in *result, which is<br>
  342.         //    pointed to by gResult.<br>
  343.         //-----------------------------------------------------------------------
  344.     <br>
  345.         <br>
  346.         // unlock handle pointing to parameter block
  347. and data so it can move<br>
  348.         // if memory gets shuffled:<br>
  349.         if ((Handle)*data != NULL)<br>
  350.             PIUnlockHandle((Handle)*data);<br>
  351.     <br>
  352.     } // about selector special        <br>
  353.     <br>
  354.     #ifdef UseA4
  355.             // Are we in 68k Mac
  356. MW?<br>
  357.         ExitCodeResource(); // A4-globals<br>
  358.     #endif<br>
  359.     <br>
  360. } // end ENTRYPOINT<br>
  361. <br>
  362. //-------------------------------------------------------------------------------<br>
  363. //<br>
  364. //    InitGlobals<br>
  365. //    <br>
  366. //    Initalize any global values here. Called only once when global<br>
  367. //    space is reserved for the first time.<br>
  368. //<br>
  369. //    Inputs:<br>
  370. //        Ptr globalPtr
  371.         Standard pointer to a global structure.<br>
  372. //<br>
  373. //    Outputs:<br>
  374. //        Initializes any global values with their
  375. defaults.<br>
  376. //<br>
  377. //-------------------------------------------------------------------------------<br>
  378. <br>
  379. <br>
  380. <br>
  381. void InitGlobals (Ptr globalPtr)<br>
  382. {    <br>
  383.     // create "globals" as a our struct global pointer so that
  384. any<br>
  385.     // macros work:<br>
  386.     GPtr globals = (GPtr)globalPtr;<br>
  387.     <br>
  388.     // Initialize global variables:<br>
  389.     ValidateParameters (globals);<br>
  390.     <br>
  391. } // end InitGlobals<br>
  392. <br>
  393. //-------------------------------------------------------------------------------<br>
  394. //<br>
  395. //    ValidateParameters<br>
  396. //<br>
  397. //    Initialize parameters to default values.<br>
  398. //<br>
  399. //    Inputs:<br>
  400. //        GPtr globals
  401.         Pointer to global structure.<br>
  402. //<br>
  403. //-------------------------------------------------------------------------------<br>
  404. <br>
  405. void ValidateParameters (GPtr globals)<br>
  406. {<br>
  407.     if (gStuff-&gt;parameters == NULL)<br>
  408.     { // We haven't created these yet.<br>
  409. <br>
  410.         gStuff-&gt;parameters = PINewHandle ((long)
  411. sizeof (TParameters));<br>
  412. <br>
  413.         if (gStuff-&gt;parameters != NULL)<br>
  414.         { // Got it. Fill out the fields.
  415.     <br>
  416.             <a name="gKanal1=128;">gKanal1=128;</a><br>
  417.             gKanal2=128;<br>
  418.             gKanal3=128;<br>
  419.             gKanal4=128;
  420.         <br>
  421.             <br>
  422.             gUseAdvance = false;<br>
  423.             gZoomFactor=6;
  424.         <br>
  425.             gHostIsPremiereWin =
  426. IsWindows(HostIsPremiere());<br>
  427.         }<br>
  428.         else<br>
  429.         { // Oops. Couldn't allocate memory.<br>
  430.                 <br>
  431.             gResult = memFullErr;<br>
  432.             return;<br>
  433.         }<br>
  434.     } // parameters<br>
  435.     <br>
  436. } // end ValidateParameters<br>
  437. <br>
  438. <br>
  439. <br>
  440. <br>
  441. <br>
  442. <br>
  443. /*****************************************************************************/<br>
  444. /* Inicializace vstupních parametrù filtru - neprobìhne pøi volání "Poslední
  445. Filtr"*/<br>
  446. <br>
  447. void DoParameters (GPtr globals)<br>
  448. {    <br>
  449.     ValidateParameters (globals);<br>
  450.     if (gStuff-&gt;parameters != NULL) <br>
  451.     {<br>
  452.     }<br>
  453.     gQueryForParameters = TRUE;<br>
  454. }<br>
  455. <br>
  456. /*****************************************************************************/<br>
  457. /* Výpoèet potøebné pamìti pro funkci filtru */<br>
  458. <br>
  459. <a name="void DoPrepare (GPtr globals){">void DoPrepare (GPtr globals)<br>
  460. {</a><br>
  461.     short     rowWidth = 0;<br>
  462.     short     total = 0;<br>
  463.     long    oneRow = 0;<br>
  464.     long    inOutRow = 0;<br>
  465.     long    inOutAndMask = 0;<br>
  466.     <br>
  467.     gStuff-&gt;bufferSpace = 0;    <br>
  468.     ValidateParameters (globals);<br>
  469.     total = gStuff-&gt;imageSize.v;<br>
  470.     rowWidth = gStuff-&gt;imageSize.h;    <br>
  471.     oneRow = rowWidth * (gStuff-&gt;planes);<br>
  472.     inOutRow = oneRow * 2; <br>
  473.     inOutAndMask = inOutRow + rowWidth; <br>
  474.     while (((inOutAndMask * gRowSkip) &lt;
  475. (gStuff-&gt;maxSpace-gStuff-&gt;bufferSpace)) &amp;&amp; (gRowSkip &lt; total))
  476. gRowSkip++;<br>
  477.     gStuff-&gt;maxSpace = gRowSkip * inOutAndMask + gStuff-&gt;bufferSpace;
  478. <br>
  479.     <br>
  480. }<br>
  481. <br>
  482. /*****************************************************************************/<br>
  483. /* Zobrazení UI a zaèátek filtrace */<br>
  484. <br>
  485. void DoStart (GPtr globals)<br>
  486. {    <br>
  487. <br>
  488.     Rect    imageRect;<br>
  489.         return;<br>
  490.     ValidateParameters (globals); // Pokud nejsou inicializovány parametry
  491. filtru, tak je inicializuje<br>
  492.     // lze použít Advance ?<br>
  493.     gUseAdvance = AdvanceStateAvailable () &amp;&amp;<br>
  494.                 DisplayPixelsAvailable
  495. () &amp;&amp;<br>
  496.                 !gHostIsPremiereWin;<br>
  497.                                             //
  498. Adobe Premiere for Windows doesn't do AdvanceState right<br>
  499.     ReadScriptParams (globals);
  500.                 //
  501. Pøeète pøedchozí nastavení filtru<br>
  502. <br>
  503.     if (gQueryForParameters) <br>
  504.     {<br>
  505.         DoUI (globals);
  506.                         //
  507. Zobrazí UI<br>
  508.         gQueryForParameters = FALSE;<br>
  509.     }<br>
  510.     else<br>
  511.     {<br>
  512.         imageRect.top = 0;//pokud je filtr vyvolán bez
  513. UI - inicializace rozmeru I/O oblastí<br>
  514.         imageRect.left = 0;<br>
  515.         imageRect.bottom = gStuff-&gt;imageSize.v;<br>
  516.         imageRect.right = gStuff-&gt;imageSize.h;<br>
  517.         copyRect(&amp;gStuff-&gt;filterRect,
  518. &amp;imageRect); <br>
  519.         copyRect(&amp;gStuff-&gt;inRect,
  520. &amp;imageRect);        <br>
  521. <br>
  522.         gStuff-&gt;inLoPlane = gStuff-&gt;outLoPlane =
  523. 0;<br>
  524.         gStuff-&gt;inHiPlane = gStuff-&gt;outHiPlane =
  525. gStuff-&gt;planes - 1;<br>
  526.         copyRect(&amp;gStuff-&gt;maskRect,
  527. &amp;gStuff-&gt;filterRect);<br>
  528.         gStuff-&gt;inputRate = long2fixed(1L);<br>
  529.         gStuff-&gt;maskRate = gStuff-&gt;inputRate; <br>
  530.         gStuff-&gt;inputPadding =
  531. plugInWantsEdgeReplication;<br>
  532.         gStuff-&gt;outputPadding =
  533. gStuff-&gt;inputPadding;<br>
  534.         gStuff-&gt;maskPadding =
  535. gStuff-&gt;inputPadding;<br>
  536.     <br>
  537.         gResult = AdvanceState ();<br>
  538.         DoZoomRect (globals,false);<br>
  539. //        Ret(globals);<br>
  540.         <br>
  541.     }<br>
  542.     if (gResult != noErr) return;<br>
  543.     <br>
  544.     if (gUseAdvance) StartWithAdvanceState(globals);<br>
  545. }<br>
  546.     <br>
  547. /*****************************************************************************/<br>
  548. /* Pokraèování filtrace - pokud se filtruje po èástech - not Advance */<br>
  549. <br>
  550. void DoContinue (GPtr globals)<br>
  551. {<br>
  552.     if (TestAbort () || gResult != noErr)<br>
  553.     {<br>
  554.         gResult = userCanceledErr;<br>
  555.         return;<br>
  556.     }<br>
  557.     if (!gUseAdvance)<br>
  558.     {<br>
  559.         Prah(globals,true); <br>
  560.         if (!DoNextRect (globals))<br>
  561.             {<br>
  562.                 PISetRect
  563. (&amp;gStuff-&gt;inRect, 0, 0, 0, 0);<br>
  564.                 PISetRect
  565. (&amp;gStuff-&gt;outRect, 0, 0, 0, 0);<br>
  566.                 PISetRect
  567. (&amp;gStuff-&gt;maskRect, 0, 0, 0, 0);<br>
  568.             }<br>
  569.     }<br>
  570.     else<br>
  571.     { <br>
  572.         PISetRect (&amp;gStuff-&gt;inRect, 0, 0, 0, 0);<br>
  573.         PISetRect (&amp;gStuff-&gt;outRect, 0, 0, 0,
  574. 0);<br>
  575.         PISetRect (&amp;gStuff-&gt;maskRect, 0, 0, 0,
  576. 0);<br>
  577.     } <br>
  578. }<br>
  579. <br>
  580. /*****************************************************************************/<br>
  581. /* Úklid po filtru a zápis nastavení parametrù filtru */<br>
  582. <br>
  583. void DoFinish (GPtr globals)<br>
  584. {<br>
  585.     WriteScriptParams (globals); <br>
  586. }<br>
  587. <br>
  588. /*****************************************************************************/<br>
  589. /* Filtrace celeho obrazu najednou */<br>
  590. <br>
  591. void StartWithAdvanceState (GPtr globals)<br>
  592. {<br>
  593.     int16 row;<br>
  594.     int32 total;<br>
  595. <br>
  596.     total = gStuff-&gt;filterRect.bottom - gStuff-&gt;filterRect.top;<br>
  597.     gStuff-&gt;inLoPlane = gStuff-&gt;outLoPlane = 0;<br>
  598.     gStuff-&gt;inHiPlane = gStuff-&gt;outHiPlane = gStuff-&gt;planes - 1;<br>
  599.     <br>
  600.     /* Pokud chceme použít kanály*/<br>
  601.     #if useAlpha<br>
  602.     if (!gStuff-&gt;isFloating)<br>
  603.     {<br>
  604.         gStuff-&gt;wantsAbsolute = true;<br>
  605.         <br>
  606.         if (gStuff-&gt;inLayerPlanes !=0 &amp;&amp;
  607. gStuff-&gt;inTransparencyMask != 0)<br>
  608.             gStuff-&gt;inHiPlane =
  609. gStuff-&gt;absLayerPlanes - 1 +<br>
  610.                                 gStuff-&gt;absTransparencyMask
  611. +<br>
  612.                                 gStuff-&gt;absLayerMasks
  613. +<br>
  614.                                 gStuff-&gt;absInvertedLayerMasks
  615. +<br>
  616.                                 gStuff-&gt;absNonLayerPlanes;<br>
  617.         <br>
  618.         if (gStuff-&gt;outLayerPlanes !=0 &amp;&amp;
  619. gStuff-&gt;outTransparencyMask !=0)<br>
  620.             gStuff-&gt;outHiPlane =
  621. gStuff-&gt;outLayerPlanes - 1 +<br>
  622.                                 gStuff-&gt;outTransparencyMask
  623. +<br>
  624.                                 gStuff-&gt;outLayerMasks
  625. +<br>
  626.                                 gStuff-&gt;outInvertedLayerMasks
  627. +<br>
  628.                                 gStuff-&gt;outNonLayerPlanes;<br>
  629.     }<br>
  630.     #endif<br>
  631.     gStuff-&gt;inRect.left = gStuff-&gt;outRect.left =
  632. gStuff-&gt;maskRect.left = gStuff-&gt;filterRect.left = 0;<br>
  633.     gStuff-&gt;inRect.right = gStuff-&gt;outRect.right =
  634. gStuff-&gt;maskRect.right = gStuff-&gt;filterRect.right = gStuff-&gt;imageSize.h;<br>
  635.     gStuff-&gt;inputRate = long2fixed (1L);<br>
  636.     gStuff-&gt;maskRate = long2fixed (1L);<br>
  637.     for (row = 0; row &lt; gStuff-&gt;imageSize.v; row += gRowSkip)<br>
  638.     {<br>
  639.         if (TestAbort () || gResult != noErr)<br>
  640.         {<br>
  641.             gResult =
  642. userCanceledErr;<br>
  643.             goto done;<br>
  644.         }<br>
  645.         gStuff-&gt;inRect.top = gStuff-&gt;outRect.top
  646. = gStuff-&gt;maskRect.top = gStuff-&gt;filterRect.top=row;<br>
  647.         gStuff-&gt;inRect.bottom =
  648. gStuff-&gt;outRect.bottom = gStuff-&gt;maskRect.bottom = gStuff-&gt;filterRect.bottom=row
  649. + gRowSkip;<br>
  650.         gResult = AdvanceState ();    <br>
  651.         if (gResult != noErr)<br>
  652.             goto done;
  653.         <br>
  654.         Prah (globals, true);<br>
  655.         }<br>
  656. done:<br>
  657.     PISetRect (&amp;gStuff-&gt;inRect, 0, 0, 0, 0);<br>
  658.     PISetRect (&amp;gStuff-&gt;outRect, 0, 0, 0, 0);<br>
  659.     PISetRect (&amp;gStuff-&gt;maskRect, 0, 0, 0, 0);<br>
  660. }<br>
  661. <br>
  662. <br>
  663. /******************************************************/<br>
  664. /* provedení filtrace
  665.             */<br>
  666. <br>
  667. <br>
  668. <br>
  669. void Prah(GPtr globals, Boolean doProgress )<br>
  670. {<br>
  671.     short i, j;<br>
  672.     int plane;<br>
  673.     int prah[4];<br>
  674. <br>
  675.     const short total = gStuff-&gt;filterRect.bottom -
  676. gStuff-&gt;filterRect.top;    //celkový pocet výstupního øádkù<br>
  677.     const short outColumns= gStuff-&gt;outRect.right -
  678. gStuff-&gt;outRect.left; //pocet sloupcù výstupního obrázku<br>
  679.     const short outRows = gStuff-&gt;outRect.bottom -
  680. gStuff-&gt;outRect.top;    // pocet øádkù výstupního obrázku<br>
  681.     const short outPlanes = gStuff-&gt;outHiPlane - gStuff-&gt;outLoPlane +
  682. 1; //pocet kanálù výstupního obrázku<br>
  683.     const short inColumns = gStuff-&gt;imageSize.h;
  684.                             //pocet
  685. sloupcù vstupniho obrázku<br>
  686.     const short inRows = gStuff-&gt;imageSize.v;
  687.                         //pocet
  688. øádkù vstupniho obrázku<br>
  689.     const short inPlanes = gStuff-&gt;inHiPlane - gStuff-&gt;inLoPlane + 1;
  690.         //pocet kanálù vstupniho obrázku<br>
  691.     <br>
  692. unsigned8 *srcPtr = (unsigned8 *) gStuff-&gt;inData;    //ukazatel na
  693. vstupní obrázek<br>
  694.     unsigned8 *dstPtr = (unsigned8 *) gStuff-&gt;outData;
  695.     //ukazatel na výstupní obrázek<br>
  696.     unsigned8 *mskPtr = (unsigned8 *) gStuff-&gt;maskData;
  697.     //ukazatel na masku vstupního obrázku<br>
  698.     Boolean maskPixel = false;<br>
  699. <br>
  700.     <br>
  701. <a name="prah[0]=gKanal1;//nastavení jednotlivých prahù">
  702.    prah[0]=gKanal1;//nastavení jednotlivých prahù</a><br>
  703.     prah[1]=gKanal2;<br>
  704.     prah[2]=gKanal3;<br>
  705.     prah[3]=gKanal4;<br>
  706.     for (i=0; i &lt; inRows; i++)<br>
  707.     {<br>
  708.         srcPtr = (unsigned8 *) gStuff-&gt;inData + (i *
  709. inColumns * inPlanes);//nastav na první pixel v øádku i<br>
  710.         dstPtr = (unsigned8 *) gStuff-&gt;outData + (i
  711. * inColumns * inPlanes);//nastav na první pixel v øádku i<br>
  712.         mskPtr = (unsigned8 *) gStuff-&gt;maskData + (i
  713. * inColumns);    //nastav na první pixel v øádku    i<br>
  714.             <br>
  715.         if (doProgress) UpdateProgress ((long)
  716. (gStuff-&gt;outRect.top + i) - gStuff-&gt;filterRect.top,(long) total);<br>
  717.         for(j=0;j&lt;inColumns;j++)<br>
  718.         {<br>
  719.             <br>
  720.             maskPixel = (!mskPtr
  721. [0]); //naètení masky<br>
  722.             if (!maskPixel)
  723.     //pokud není maska uprav<br>
  724.             {<br>
  725.                 for
  726. (plane = 0; plane &lt; inPlanes; plane++) <br>
  727.                 {<br>
  728.                 if(srcPtr[plane]&gt;prah[plane])
  729. srcPtr[plane]=255;<br>
  730.                 else
  731. srcPtr[plane]=0; <br>
  732.                 }<br>
  733.             }<br>
  734.             else //pokud je tak
  735. neupravuj<br>
  736.             {<br>
  737.                 for
  738. (plane = 0; plane &lt; inPlanes; plane++) dstPtr [plane] = srcPtr [plane];
  739.         <br>
  740.             }
  741.                     <br>
  742.             srcPtr +=
  743. inPlanes;//nastav na další pixel v øádku i<br>
  744.             dstPtr +=
  745. inPlanes;//nastav na další pixel v øádku i<br>
  746.             mskPtr++; //nastav na
  747. další pixel v øádku i<br>
  748.         }
  749.             <br>
  750.     }<br>
  751. }<br>
  752. <br>
  753. <br>
  754. <br>
  755. <br>
  756. <br>
  757. <br>
  758. /*****************************************************************************/<br>
  759. /* Výpoèet a úpravy rozmìrù obrázku pro potøeby UI */<br>
  760. <br>
  761. void CalcGlobalProxies (GPtr globals)<br>
  762. {<br>
  763.     Rect    imageRect,imageRect1;<br>
  764.     int16    selCenterH, selCenterV;<br>
  765.     int16    selLength, selWidth;<br>
  766.     int16    length, width;<br>
  767.     int16    length2, width2;<br>
  768.     length = (gOrigProxyRect.bottom - gOrigProxyRect.top); // zobrazovaná
  769. výška<br>
  770.     length2 = length / 2;<br>
  771.     width = (gOrigProxyRect.right - gOrigProxyRect.left); // zobrazovaná
  772. šíøka<br>
  773.     width2 = width / 2;<br>
  774.     selLength = gStuff-&gt;imageSize.v; // Vybraná výška<br>
  775.     selWidth = gStuff-&gt;imageSize.h; // Vybraná šíøka<br>
  776.     //Vycentrování preview<br>
  777.     selCenterV = (selLength / 2);<br>
  778.     selCenterH = (selWidth / 2);<br>
  779.     imageRect.top = selCenterV - (length2); <br>
  780.     imageRect.left = selCenterH - (width2);<br>
  781.     imageRect.bottom = imageRect.top+length;<br>
  782.     imageRect.right = imageRect.left+width;<br>
  783.     imageRect1.top = 0;<br>
  784.     imageRect1.left = 0;<br>
  785.     imageRect1.bottom = gStuff-&gt;imageSize.v;<br>
  786.     imageRect1.right = gStuff-&gt;imageSize.h;<br>
  787. copyRect(&amp;gProxyScaleRect, &amp;imageRect);<br>
  788.     copyRect(&amp;gStuff-&gt;inRect, &amp;imageRect1);<br>
  789.     copyRect(&amp;gStuff-&gt;outRect, &amp;imageRect);<br>
  790. }<br>
  791. <br>
  792. void SetupFilterRecordForProxy (GPtr globals, Rect proxyScaleRect, short scaleFactor)<br>
  793. {<br>
  794.     #ifdef __PIMWCW__<br>
  795.         #pragma unused (proxyScaleRect)<br>
  796.         #pragma unused (scaleFactor)<br>
  797.     #endif<br>
  798.     gStuff-&gt;inLoPlane = gStuff-&gt;outLoPlane = 0;<br>
  799.     gStuff-&gt;inHiPlane = gStuff-&gt;outHiPlane = gStuff-&gt;planes - 1;<br>
  800.     copyRect(&amp;gStuff-&gt;maskRect, &amp;gStuff-&gt;filterRect);<br>
  801.     gStuff-&gt;inputRate = long2fixed(1L);<br>
  802.     gStuff-&gt;maskRate = gStuff-&gt;inputRate; <br>
  803.     gStuff-&gt;inputPadding = plugInWantsEdgeReplication;<br>
  804.     gStuff-&gt;outputPadding = gStuff-&gt;inputPadding;<br>
  805.     gStuff-&gt;maskPadding = gStuff-&gt;inputPadding;<br>
  806.     gResult = AdvanceState ();<br>
  807. }<br>
  808.     <br>
  809. void CalcProxyScaleFactor (Rect proxyScaleRect, Rect *proxyRect, short *scaleFactor)<br>
  810. {<br>
  811.     short filterHeight;<br>
  812.     short filterWidth;<br>
  813.     short itemHeight;<br>
  814.     short itemWidth;<br>
  815. <br>
  816.     Point fraction;<br>
  817. <br>
  818.     shrinkRect (proxyRect, kGutter, kGutter);
  819.          // for the border<br>
  820.     filterHeight = (proxyScaleRect.bottom - proxyScaleRect.top);<br>
  821.     filterWidth = (proxyScaleRect.right - proxyScaleRect.left);<br>
  822.     itemHeight = (proxyRect-&gt;bottom - proxyRect-&gt;top);<br>
  823.     itemWidth = (proxyRect-&gt;right - proxyRect-&gt;left);<br>
  824.     if (itemHeight &gt; filterHeight) itemHeight = filterHeight;<br>
  825.     if (itemWidth &gt; filterWidth) itemWidth = filterWidth;<br>
  826.     fraction.h = ((filterWidth + itemWidth) / itemWidth)-1;<br>
  827.     fraction.v = ((filterHeight + itemHeight) / itemHeight)-1;<br>
  828.     if (fraction.h &gt; fraction.v) *scaleFactor = fraction.h;<br>
  829.     else *scaleFactor = fraction.v;<br>
  830.     copyRect (proxyRect, &amp;proxyScaleRect);    <br>
  831.     scaleRect (proxyRect, 1, *scaleFactor);<br>
  832. }<br>
  833. <br>
  834. <br>
  835. /****************************************************************************/<br>
  836. /* Hlavní rutina Zoomování preview */<br>
  837. void DoZoomRect (GPtr globals,Boolean mask)<br>
  838. {    <br>
  839. <br>
  840.     if (gResult == userCanceledErr) return;<br>
  841.         <br>
  842.     if (gRepFactor &lt;= 1 &amp;&amp; gRepFactor &gt; 0)<br>
  843.         ZoomOutRect (globals, mask);<br>
  844.     else if (gRepFactor &gt; 1)<br>
  845.         ZoomInRect (globals, mask);
  846.         <br>
  847. }<br>
  848. <br>
  849. /*****************************************************************************/<br>
  850. /* Zoom in. Zvìtšení gRepFactor &gt;= 1 */<br>
  851. /*****************************************************************************/<br>
  852. <br>
  853. void ZoomInRect (GPtr globals, Boolean mask)<br>
  854. {<br>
  855.     short offsetOutColumns, offsetOutRows;<br>
  856.     short centerInColumns, centerInRows;<br>
  857.     short offsetInColumns, offsetInRows;<br>
  858.     short difColumns, difRows;    <br>
  859.     short proxyCenterCol, proxyCenterRow;<br>
  860.     short proxyOffsetCol, proxyOffsetRow;<br>
  861.     int srcX,srcY ;<br>
  862.     int i,j,ii,jj,max,polo,plane;<br>
  863.     unsigned8 *dstPtr;<br>
  864.     unsigned8 *mskPtr;<br>
  865.     unsigned8 *mskPtr2;<br>
  866.     const short outColumns= gStuff-&gt;outRect.right -
  867. gStuff-&gt;outRect.left;<br>
  868.     const short outRows = gStuff-&gt;outRect.bottom -
  869. gStuff-&gt;outRect.top;    <br>
  870.     const short outPlanes = gStuff-&gt;outHiPlane - gStuff-&gt;outLoPlane +
  871. 1;<br>
  872.     const short inColumns = gStuff-&gt;imageSize.h;<br>
  873.     const short inRows = gStuff-&gt;imageSize.v;<br>
  874.     const short inPlanes =gStuff-&gt;outHiPlane - gStuff-&gt;outLoPlane +
  875. 1;<br>
  876.     double pomoc;    <br>
  877.     Boolean maskPixel = false;<br>
  878.     <br>
  879.     offsetOutColumns = outColumns / 2;<br>
  880.     offsetOutRows = outRows / 2;<br>
  881.     centerInColumns = inColumns / 2;<br>
  882.     centerInRows = inRows / 2;<br>
  883.     offsetInColumns = (short)(inColumns * gRepFactor / 2);<br>
  884.     offsetInRows = (short)(inRows * gRepFactor / 2);<br>
  885.     difColumns        = offsetInColumns
  886. - offsetOutColumns;<br>
  887.     difRows = offsetInRows - offsetOutRows;<br>
  888. difColumns /= (short)gRepFactor;<br>
  889.     difRows /=(short)gRepFactor;<br>
  890.     gPozice.x=gSPozice.x+(short)gDif.x;<br>
  891.     if (gPozice.x&gt; difColumns) gPozice.x=difColumns;<br>
  892.     if (gPozice.x&lt;-difColumns) gPozice.x=-difColumns;<br>
  893.     gPozice.y=gSPozice.y+(short)gDif.y;<br>
  894.     if (gPozice.y&gt; difRows) gPozice.y=difRows;<br>
  895.     if (gPozice.y&lt;-difRows) gPozice.y=-difRows;<br>
  896.     proxyCenterCol = gOrigProxyRect.left + ((gOrigProxyRect.right -
  897. gOrigProxyRect.left) / 4);<br>
  898.     proxyCenterRow = gOrigProxyRect.top + ((gOrigProxyRect.bottom -
  899. gOrigProxyRect.top) / 4);<br>
  900.     proxyOffsetCol = outColumns / 2;<br>
  901.     proxyOffsetRow = outRows / 2;<br>
  902. <br>
  903.     <br>
  904.     max=(int)sqrt((inRows/2)*(inRows/2)+(inColumns/2)*(inColumns/2));<br>
  905.     for (i = 0; i &lt; outRows; i ++)<br>
  906.     {<br>
  907.         i--;<br>
  908.         for(ii = 1;ii&lt;=gRepFactor;ii++)<br>
  909.         {<br>
  910.             i++;<br>
  911.             if(i==outRows) break;<br>
  912.             mskPtr2= (unsigned8
  913. *)gSHOWmask + (i * outColumns);<br>
  914.             dstPtr = (unsigned8
  915. *)gStuff-&gt;outData + (i * outColumns * outPlanes);
  916.         <br>
  917.             mskPtr = (unsigned8
  918. *)gFFTmask + (- gPozice.x + difColumns + (((int)(i/gRepFactor) + difRows - gPozice.y ) *
  919. inColumns));<br>
  920.             srcX= - gPozice.x +
  921. difColumns + (((int)(i/gRepFactor) + difRows - gPozice.y ) * inColumns);<br>
  922.             srcY=srcX-((short)(srcX/inColumns))*inColumns;
  923.         <br>
  924.             for (j = 0; j &lt;
  925. outColumns; j ++)<br>
  926.             {<br>
  927.                 j--;<br>
  928.                 for
  929. (jj = 1;jj&lt;=gRepFactor;jj++)<br>
  930.                 {<br>
  931.                     if
  932. (gIMaska) mskPtr2[0] = 255-mskPtr[0];<br>
  933.                     else
  934. mskPtr2[0]=255;<br>
  935.                 <br>
  936.                     if(!mask)<br>
  937.                     {<br>
  938.                         if (mskPtr[0]) for(plane=0;plane&lt;inPlanes;plane++)
  939. dstPtr[plane]=((gInten*gFFTdata[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100)+(100-gInten)*gFFTdata2[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100);
  940.                                             <br>
  941.                         else
  942.         for(plane=0;plane&lt;inPlanes;plane++)
  943. dstPtr[plane]=gFFTdata[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane];<br>
  944.                     }<br>
  945.                     mskPtr2++;<br>
  946.                     dstPtr
  947. +=outPlanes;<br>
  948.                     j++;<br>
  949.                     if
  950. (j==outColumns) break;<br>
  951.                 }<br>
  952.                 srcY
  953. ++;<br>
  954.                 mskPtr++;<br>
  955.             }<br>
  956.         }<br>
  957.     }<br>
  958.     <br>
  959.     gProxyRect.left = proxyCenterCol - proxyOffsetCol &gt;
  960. gOrigProxyRect.left<br>
  961.                     ?
  962. proxyCenterCol - proxyOffsetCol : gOrigProxyRect.left;<br>
  963.     gProxyRect.right = proxyCenterCol + proxyOffsetCol &lt;
  964. gOrigProxyRect.right<br>
  965.                     ?
  966. proxyCenterCol + proxyOffsetCol : gOrigProxyRect.right;<br>
  967.     gProxyRect.top = proxyCenterRow - proxyOffsetRow &gt;
  968. gOrigProxyRect.top<br>
  969.                     ?
  970. proxyCenterRow - proxyOffsetRow : gOrigProxyRect.top;<br>
  971.     gProxyRect.bottom = proxyCenterRow + proxyOffsetRow &lt;
  972. gOrigProxyRect.bottom<br>
  973.                     ?
  974. proxyCenterRow + proxyOffsetRow : gOrigProxyRect.bottom;<br>
  975. }<br>
  976.     <br>
  977. /*****************************************************************************/<br>
  978. /* Zoom Out. Zmenšení gRepFactor between 0...1. */<br>
  979. <br>
  980. void ZoomOutRect (GPtr globals,    Boolean mask)<br>
  981. {<br>
  982.     const unsigned8 kUIBackcolor = 191;<br>
  983.     short offsetOutColumns, offsetOutRows;<br>
  984.     short startOutColumns, startOutRows, endOutColumns, endOutRows;<br>
  985.     const short outColumns= gStuff-&gt;outRect.right -
  986. gStuff-&gt;outRect.left;<br>
  987.     const short outRows = gStuff-&gt;outRect.bottom -
  988. gStuff-&gt;outRect.top;    <br>
  989.     const short outPlanes = gStuff-&gt;outHiPlane - gStuff-&gt;outLoPlane +
  990. 1;<br>
  991.     const short inColumns = gStuff-&gt;imageSize.h;<br>
  992.     const short inRows = gStuff-&gt;imageSize.v;<br>
  993.     const short inPlanes = gStuff-&gt;inHiPlane - gStuff-&gt;inLoPlane + 1;<br>
  994.     short centerInColumns, centerInRows;<br>
  995.     short offsetInColumns, offsetInRows;<br>
  996.     short difColumns, difRows;<br>
  997. short offset = 0;<br>
  998.     short proxyCenterCol, proxyCenterRow;<br>
  999.     short proxyOffsetCol, proxyOffsetRow;<br>
  1000.     float HFactor = 0;<br>
  1001. float VFactor = 0;<br>
  1002.     double pomoc; <br>
  1003.     unsigned8 *dstPtr;<br>
  1004.     unsigned8 *mskPtr;<br>
  1005.     unsigned8 *mskPtr2;<br>
  1006.     int i,j,srcX,srcY,max,polo,plane;<br>
  1007.     Boolean maskPixel = false;<br>
  1008.     <br>
  1009.     offsetOutColumns = outColumns / 2;<br>
  1010.     offsetOutRows = outRows / 2;<br>
  1011.     startOutColumns = 0;<br>
  1012.     startOutRows = 0;<br>
  1013.     endOutColumns = outColumns-1;<br>
  1014.     endOutRows = outRows-1;<br>
  1015.     centerInColumns = inColumns / 2;<br>
  1016.     centerInRows = inRows / 2;<br>
  1017.     offsetInColumns = (short)(inColumns * gRepFactor / 2);<br>
  1018.     offsetInRows = (short)(inRows * gRepFactor / 2);<br>
  1019.     difColumns        = offsetInColumns
  1020. - offsetOutColumns;<br>
  1021.     difRows = offsetInRows - offsetOutRows;<br>
  1022. <br>
  1023.     <br>
  1024. <br>
  1025.     if (difColumns&lt;0) <br>
  1026.     {<br>
  1027.         difColumns++;<br>
  1028.         startOutColumns-=difColumns;<br>
  1029.         difColumns--;<br>
  1030.         endOutColumns+=difColumns;<br>
  1031.         difColumns=0;<br>
  1032.     }<br>
  1033.     if (difRows&lt;0) <br>
  1034.     {<br>
  1035.         difRows++;<br>
  1036.         startOutRows-=difRows;<br>
  1037.         difRows--;<br>
  1038.         endOutRows+=difRows;<br>
  1039.         difRows=0;<br>
  1040.     }<br>
  1041.     gPozice.x=gSPozice.x+(short)gDif.x;<br>
  1042.     if (gPozice.x&gt; difColumns) gPozice.x=difColumns;<br>
  1043.     if (gPozice.x&lt;-difColumns) gPozice.x=-difColumns;<br>
  1044.     gPozice.y=gSPozice.y+(short)gDif.y;<br>
  1045.     if (gPozice.y&gt; difRows) gPozice.y=difRows;<br>
  1046.     if (gPozice.y&lt;-difRows) gPozice.y=-difRows;<br>
  1047.     proxyCenterCol = gOrigProxyRect.left + ((gOrigProxyRect.right -
  1048. gOrigProxyRect.left) / 2);<br>
  1049.     proxyCenterRow = gOrigProxyRect.top + ((gOrigProxyRect.bottom -
  1050. gOrigProxyRect.top) / 2);<br>
  1051.     proxyOffsetCol = (short)((outColumns * gRepFactor) / 2);<br>
  1052.     proxyOffsetRow = (short)((outRows * gRepFactor) / 2);<br>
  1053.     if (!mask)<br>
  1054.     {<br>
  1055.         for (i = 0;i &lt; startOutRows;i ++)<br>
  1056.         {<br>
  1057.             dstPtr = (unsigned8 *)
  1058. gStuff-&gt;outData + (i * outColumns* outPlanes);<br>
  1059.             mskPtr2= (unsigned8 *)
  1060. gSHOWmask + (i * outColumns);<br>
  1061.             for (j = 0; j &lt;
  1062. outColumns; j ++)<br>
  1063.         {<br>
  1064.             for(plane=0;plane&lt;inPlanes;plane++)
  1065. dstPtr [plane] = kUIBackcolor;<br>
  1066.             mskPtr2[0]=255;<br>
  1067.             dstPtr +=outPlanes;<br>
  1068.             mskPtr2++;<br>
  1069.             }<br>
  1070.         }<br>
  1071.     }<br>
  1072.     max=(int)sqrt((inRows/2)*(inRows/2)+(inColumns/2)*(inColumns/2));<br>
  1073.     for (i = startOutRows;i &lt; endOutRows; i ++)<br>
  1074.     {<br>
  1075.         srcX =
  1076. (short)((-gPozice.x+difColumns)/gRepFactor) + ((i - startOutRows +
  1077. (short)((-gPozice.y+difRows)/gRepFactor) + offset) * inColumns );<br>
  1078.         dstPtr = (unsigned8 *) gStuff-&gt;outData + (i
  1079. * outColumns* outPlanes);<br>
  1080.     mskPtr2= (unsigned8 *) gSHOWmask + (i * outColumns);<br>
  1081.         mskPtr = (unsigned8 *) gFFTmask +
  1082. (short)((-gPozice.x+difColumns)/gRepFactor) + ((i - startOutRows + (short)((-gPozice.y +
  1083. difRows)/gRepFactor) + offset) * inColumns);<br>
  1084.         HFactor=0;<br>
  1085.         for (j = 0; j &lt; startOutColumns;j ++)<br>
  1086.         {<br>
  1087.             for(plane=0;plane&lt;inPlanes;plane++)
  1088. dstPtr [plane] = kUIBackcolor;<br>
  1089.             mskPtr2[0]=255;<br>
  1090.             dstPtr += outPlanes;<br>
  1091.             mskPtr2++;<br>
  1092.         }<br>
  1093.         srcY=srcX-((short)(srcX/inColumns))*inColumns;
  1094.         <br>
  1095.         for (j = startOutColumns;j &lt; endOutColumns;
  1096. j ++)<br>
  1097.         {
  1098.             <br>
  1099.             if (gIMaska) mskPtr2[0]
  1100. = 255-mskPtr[0];<br>
  1101.             else mskPtr2[0]=255;<br>
  1102.         <br>
  1103.             if(!mask)<br>
  1104.             {<br>
  1105.                 if(mskPtr[0]) for(plane=0;plane&lt;inPlanes;plane++) dstPtr[plane]=((gInten*gFFTdata[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100)+(100-gInten)*gFFTdata2[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100);
  1106.                                             <br>
  1107.                 else
  1108.         for(plane=0;plane&lt;inPlanes;plane++)
  1109. dstPtr[plane]=gFFTdata[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane];<br>
  1110.                 <br>
  1111.             }<br>
  1112.             dstPtr +=outPlanes;<br>
  1113.             srcY ++;<br>
  1114.             mskPtr++;<br>
  1115.             mskPtr2++;<br>
  1116.             HFactor +=
  1117. ((1/gRepFactor)-1);<br>
  1118.             while(HFactor&gt;=0.5)<br>
  1119. {<br>
  1120.                 HFactor-=1;<br>
  1121.                 srcY
  1122. ++;<br>
  1123.                 mskPtr++;<br>
  1124. }<br>
  1125.         }<br>
  1126.         if(!mask)<br>
  1127.         {<br>
  1128.             for (j = endOutColumns;
  1129. j &lt; outColumns; j ++)<br>
  1130.             {<br>
  1131.                 for(plane=0;plane&lt;inPlanes;plane++)
  1132. dstPtr [plane] = kUIBackcolor;<br>
  1133.                 mskPtr2[0]=255;<br>
  1134.             <br>
  1135.                 dstPtr
  1136. += outPlanes;<br>
  1137.                 mskPtr2++;<br>
  1138.             }<br>
  1139.         }<br>
  1140.         VFactor += ((1/gRepFactor)-1);<br>
  1141.         while(VFactor&gt;=0.5)<br>
  1142.         {<br>
  1143.             VFactor-=1;<br>
  1144.             offset+=1;<br>
  1145.         }<br>
  1146.     }<br>
  1147.     if(!mask)<br>
  1148.     {<br>
  1149.         for (i = endOutRows; i &lt; outRows; i ++)<br>
  1150.         {<br>
  1151.             dstPtr = (unsigned8 *)
  1152. gStuff-&gt;outData + (i * outColumns* outPlanes);<br>
  1153.             mskPtr2= (unsigned8 *)
  1154. gSHOWmask + (i * outColumns);<br>
  1155. <br>
  1156.             for (j = 0; j &lt;
  1157. outColumns; j ++)<br>
  1158.             {<br>
  1159.                 for(plane=0;plane&lt;inPlanes;plane++)
  1160. dstPtr [plane] = kUIBackcolor;    <br>
  1161.                 mskPtr2[0]=255;<br>
  1162.                 dstPtr
  1163. += outPlanes;<br>
  1164.                 mskPtr2++;<br>
  1165.             }<br>
  1166.         }<br>
  1167.     }<br>
  1168. <br>
  1169. <br>
  1170.     gProxyRect.left = proxyCenterCol - proxyOffsetCol &gt;
  1171. gOrigProxyRect.left<br>
  1172.                     ?
  1173. proxyCenterCol - proxyOffsetCol : gOrigProxyRect.left;<br>
  1174.     gProxyRect.right = proxyCenterCol + proxyOffsetCol &lt;
  1175. gOrigProxyRect.right<br>
  1176.                     ?
  1177. proxyCenterCol + proxyOffsetCol : gOrigProxyRect.right;<br>
  1178.     gProxyRect.top = proxyCenterRow - proxyOffsetRow &gt;
  1179. gOrigProxyRect.top<br>
  1180.                     ?
  1181. proxyCenterRow - proxyOffsetRow : gOrigProxyRect.top;<br>
  1182.     gProxyRect.bottom = proxyCenterRow + proxyOffsetRow &lt;
  1183. gOrigProxyRect.bottom;<br>
  1184. }<br>
  1185.     <br>
  1186. /*****************************************************************************/<br>
  1187. /* Zooms in by one factor (parts of 1.0 until 1.0, then 1.0, 2.0, etc. */<br>
  1188. <br>
  1189. void ZoomIn (short *zoom)<br>
  1190. {<br>
  1191.     if (*zoom &gt;= kNumZooms)<br>
  1192.         *zoom += kNumZooms;<br>
  1193.     else (*zoom)++;<br>
  1194. }<br>
  1195. <br>
  1196. void ZoomOut (short *zoom)<br>
  1197. {<br>
  1198.     if (*zoom &gt;= (kNumZooms*2))<br>
  1199.         *zoom -= kNumZooms;<br>
  1200.     else (*zoom)--;<br>
  1201. }<br>
  1202. <br>
  1203. /*****************************************************************************/<br>
  1204. /* Takes an enumeration and returns corresponding zoom size */<br>
  1205. <br>
  1206. short GetZoomFactor (GPtr globals)<br>
  1207. {<br>
  1208.     short    sub = 0;<br>
  1209.     short    returnValue = noErr;<br>
  1210.     <br>
  1211.     /* check for zoomFactor bounds */<br>
  1212.     <br>
  1213.     if (gZoomFactor &lt;= kMinZoom)<br>
  1214.     {<br>
  1215.         gZoomFactor = kMinZoom;<br>
  1216.         returnValue = hitLowBounds;<br>
  1217.     }<br>
  1218.     else if (gZoomFactor &gt;= kMaxZoom)<br>
  1219.     {<br>
  1220.         gZoomFactor = kMaxZoom;<br>
  1221.         returnValue = hitHighBounds;<br>
  1222.     }<br>
  1223.     <br>
  1224.     sub = gZoomFactor % kNumZooms;<br>
  1225.     <br>
  1226.     switch (sub)<br>
  1227.         {<br>
  1228.             case 1:<br>
  1229.                 gRepFactor
  1230. = (float)0.25;<br>
  1231.                 break;<br>
  1232.             case 2:<br>
  1233.                 gRepFactor
  1234. = (float)0.33;<br>
  1235.                 break;<br>
  1236.             case 3:<br>
  1237.                 gRepFactor
  1238. = (float)0.50;<br>
  1239.                 break;<br>
  1240.             case 4:<br>
  1241.                 gRepFactor
  1242. = (float)0.66;<br>
  1243.                 break;<br>
  1244.             case 5:<br>
  1245.                 gRepFactor
  1246. = (float)0.80;<br>
  1247.                 break;<br>
  1248.             default:<br>
  1249.                 gRepFactor
  1250. = (float)0;<br>
  1251.                 break;<br>
  1252.         }<br>
  1253.         gRepFactor += gZoomFactor / kNumZooms;<br>
  1254.     return returnValue;<br>
  1255. }<br>
  1256. <br>
  1257. <br>
  1258. void scaleRect(Rect *l, short n, short d) {<br>
  1259.     l-&gt;left = (l-&gt;left * n) / d;<br>
  1260.     l-&gt;top = (l-&gt;top * n) / d;<br>
  1261.     l-&gt;right = (l-&gt;right * n) / d;<br>
  1262.     l-&gt;bottom = (l-&gt;bottom * n) / d;<br>
  1263. }<br>
  1264. <br>
  1265. void shrinkRect(Rect *l, short x, short y) {<br>
  1266.     l-&gt;left += x;<br>
  1267.     l-&gt;top += y;<br>
  1268.     l-&gt;right -= x;<br>
  1269.     l-&gt;bottom -= y;<br>
  1270. }<br>
  1271. <br>
  1272. void copyRect(Rect *l, const Rect *r) {<br>
  1273.     l-&gt;left = r-&gt;left;<br>
  1274.     l-&gt;top = r-&gt;top;<br>
  1275.     l-&gt;right = r-&gt;right;<br>
  1276.     l-&gt;bottom = r-&gt;bottom;<br>
  1277. }<br>
  1278. <br>
  1279. <br>
  1280. <br>
  1281. <br>
  1282. <br>
  1283. <br>
  1284. <br>
  1285. <br>
  1286. <br>
  1287. <br>
  1288. <br>
  1289. <br>
  1290. <br>
  1291. <br>
  1292. <br>
  1293. <br>
  1294. /******************************************************************************/<br>
  1295. /* NEPOUŽITO - Pokud se filtruje po èástech */<br>
  1296. <br>
  1297. void StartNoAdvanceState (GPtr globals)<br>
  1298. {<br>
  1299.     DoInitialRect(globals);<br>
  1300. }<br>
  1301. <br>
  1302. /*****************************************************************************/<br>
  1303. /* NEPOUŽITO - inicializace první filtrované èásti - filtrování po èástech */<br>
  1304. <br>
  1305. void DoInitialRect (GPtr globals)<br>
  1306. {<br>
  1307.     int32 total;<br>
  1308.     total = gStuff-&gt;filterRect.bottom - gStuff-&gt;filterRect.top;<br>
  1309.     gStuff-&gt;inLoPlane = gStuff-&gt;outLoPlane = 0;<br>
  1310.     gStuff-&gt;inHiPlane = gStuff-&gt;outHiPlane = gStuff-&gt;planes - 1;<br>
  1311.     <br>
  1312.     /* Použítí Alfa kanálù */<br>
  1313.     #if useAlpha<br>
  1314.     if (!gStuff-&gt;isFloating)<br>
  1315.     {<br>
  1316.         gStuff-&gt;wantsAbsolute = true;<br>
  1317.         if (gStuff-&gt;inLayerPlanes !=0 &amp;&amp;
  1318. gStuff-&gt;inTransparencyMask != 0)<br>
  1319.             gStuff-&gt;inHiPlane =
  1320. gStuff-&gt;absLayerPlanes - 1 +<br>
  1321.                                 gStuff-&gt;absTransparencyMask
  1322. +<br>
  1323.                                 gStuff-&gt;absLayerMasks
  1324. +<br>
  1325.                                 gStuff-&gt;absInvertedLayerMasks
  1326. +<br>
  1327.                                 gStuff-&gt;absNonLayerPlanes;<br>
  1328.         <br>
  1329.         if (gStuff-&gt;outLayerPlanes !=0 &amp;&amp;
  1330. gStuff-&gt;outTransparencyMask !=0)<br>
  1331.             gStuff-&gt;outHiPlane =
  1332. gStuff-&gt;outLayerPlanes - 1 +<br>
  1333.                                 gStuff-&gt;outTransparencyMask
  1334. +<br>
  1335.                                 gStuff-&gt;outLayerMasks
  1336. +<br>
  1337.                                 gStuff-&gt;outInvertedLayerMasks
  1338. +<br>
  1339.                                 gStuff-&gt;outNonLayerPlanes;<br>
  1340.     }<br>
  1341.     #endif<br>
  1342.     gStuff-&gt;inputRate = long2fixed (1L);<br>
  1343.     gStuff-&gt;maskRate = long2fixed (1L);<br>
  1344.     gStuff-&gt;maskPadding = gStuff-&gt;outputPadding =
  1345. gStuff-&gt;inputPadding = 255;<br>
  1346.     gStuff-&gt;inRect = gStuff-&gt;outRect = gStuff-&gt;maskRect =
  1347. gStuff-&gt;filterRect;<br>
  1348.     gStuff-&gt;inRect.bottom = gStuff-&gt;outRect.bottom =
  1349. gStuff-&gt;maskRect.bottom = gStuff-&gt;inRect.top + gRowSkip;<br>
  1350. }<br>
  1351. <br>
  1352. /*****************************************************************************/<br>
  1353. /* NEPOUŽITO - Dotaz na další èást */<br>
  1354. <br>
  1355. Boolean DoNextRect (GPtr globals)<br>
  1356. {<br>
  1357.     gStuff-&gt;inRect.top += gRowSkip; // next batch<br>
  1358.     gStuff-&gt;inRect.bottom += gRowSkip; // next batch<br>
  1359.     gStuff-&gt;outRect = gStuff-&gt;maskRect = gStuff-&gt;inRect;<br>
  1360.     <br>
  1361.     return gStuff-&gt;inRect.top &lt; gStuff-&gt;filterRect.bottom;<br>
  1362. }<br>
  1363. <br>
  1364. <br>
  1365. </small></p>
  1366. </body></html>