<
meta http-equiv="Content-Type" content="text/html; charset=windows-1250"><
title>prah.c<
/title><
/head>
<
p><
small>
//-------------------------------------------------------------------------------<
br>
#include
"PIDefines.h"<
br>
#ifdef __PIMWCWMacPPC__<
br>
#include
"prah-PPC.ch"<
br>
#elif defined
(__PIMWCWMac68K__
)<
br>
#include
"prah-68k.ch"<
br>
// We're using Metrowerks and they have an A4 library, so set that up:<br>
#include <SetupA4.h><br>
#include <A4Stuff.h><br>
<br>
#define UseA4 // We've now defined this
for quick checks later.<
br>
#include <math.h><
br>
#include <stdio.h><
br>
#include <stdlib.h><
br>
#include <math.h><
br>
// Peker til tabellen<
br>
//prcomplex *sincos_tab;<
br>
//-------------------------------------------------------------------------------<
br>
//-------------------------------------------------------------------------------<
br>
// Everything comes in and out of ENTRYPOINT. It must be first routine in source:<
br>
MACPASCAL void ENTRYPOINT
(const short selector,<
br>
FilterRecord
long
short
void InitGlobals (Ptr globalPtr);
// Initialize globals.<
br>
void ValidateParameters (GPtr globals); //
Validates
(inits
) parameters.<
br>
void DoStart (GPtr globals);
//
void DoParameters
(GPtr globals
);<
br>
void DoPrepare
(GPtr globals
);<
br>
void DoContinue
(GPtr globals
);<
br>
void DoFinish
(GPtr globals
);<
br>
void StartWithAdvanceState
(GPtr globals
);<
br>
void prah
(GPtr globals, const Boolean doProgress
);<
br>
void CalcProxyScaleFactor
(Rect proxyScaleRect, Rect *proxyRect, short *scaleFactor
);<
br>
boolean ParametersTest
(GPtr globals
);<
br>
void ZoomInRect
(GPtr globals, Boolean mask
);<
br>
void ZoomOutRect
(GPtr globals, Boolean mask
);<
br>
void StartNoAdvanceState
(GPtr globals
);<
br>
void DoInitialRect
(GPtr globals
);<
br>
Boolean DoNextRect
(GPtr globals
);<
br>
//void Ret
(GPtr globals
);<
br>
void BuildProxy
(GPtr globals
);<
br>
void scaleRect
(Rect *l, short n, short d
);<
br>
void shrinkRect
(Rect *l, short x, short y
);<
br>
void copyRect
(Rect *l, const Rect *r
);<
br>
//-------------------------------------------------------------------------------<
br>
// Globals -- Define global variables
for plug-in
scope.<
br>
//-------------------------------------------------------------------------------<
br>
// Windows global
for plug-in
(considered a Dynamically Linked Library
).<
br>
// Leave NULL
for Macintosh; many cross-platform library utilities require<
br>
// something passed in
for hDllInstance:<
br>
Handle hDllInstance
= NULL;<
br>
//-------------------------------------------------------------------------------<
br>
// ENTRYPOINT Export -- Export our entrypoint<
br>
// Have to export our info for PPCGlue stub which needs a descriptor
// to be called from within a 68k
code fragment.<
br>
//-------------------------------------------------------------------------------<
br>
#ifdef __PIMacPPC__
//
For "fat" PowerMac plug-ins<
br>
uppEntryProcInfo
= kPascalStackBased<
br>
|
STACK_ROUTINE_PARAMETER
(1, SIZE_CODE
(sizeof
(short
)))<
br>
|
STACK_ROUTINE_PARAMETER
(2, SIZE_CODE
(sizeof
(FilterRecord *
)))<
br>
|
STACK_ROUTINE_PARAMETER
(3, SIZE_CODE
(sizeof
(long *
)))<
br>
|
STACK_ROUTINE_PARAMETER
(4, SIZE_CODE
(sizeof
(short *
)))<
br>
#if PRAGMA_EXPORT_SUPPORTED <
br>
RoutineDescriptor main_PPC = BUILD_ROUTINE_DESCRIPTOR(uppEntryProcInfo,
#if PRAGMA_EXPORT_SUPPORTED<
br>
//-------------------------------------------------------------------------------<
br>
// All calls to the plug-in module come through this routine.<
br>
// It must be placed first in the resource. To achieve this,<
br>
// most development systems require this be the first routine<
br>
// The entrypoint will be
"pascal void" for Macintosh,<
br>
// "void" for Windows.<
br>
// const short selector
Host
provides selector indicating<
br>
//
what
// FilterRecord *filterParamBlock
Host
provides pointer to parameter<
br>
//
block
containing pertinent data<
br>
//
and
callbacks from the host.<
br>
//
See
// FilterRecord *filterParamBlock
Host
provides pointer to parameter<
br>
//
block
containing pertinent data<
br>
//
and
callbacks from the host.<
br>
//
See
// long *data
Use
this to store a handle to our<
br>
//
global
parameters structure, which<
br>
//
is
maintained by the host between<
br>
//
calls
// short *result
Return
error result or noErr. Some<
br>
//
errors
are handled by the host, some<
br>
//
are
silent, and some you must handle.<
br>
//
See
//-------------------------------------------------------------------------------<
br>
MACPASCAL void ENTRYPOINT
(const short selector,<
br>
FilterRecord
long
short
//---------------------------------------------------------------------------<
br>
// (1) Enter
code resource if Mac 68k.<
br>
//---------------------------------------------------------------------------<
br>
#ifdef UseA4
//
Are we in 68k Mac MW?<
br>
EnterCodeResource(); //
//---------------------------------------------------------------------------<
br>
// (2) Check
for about box request.<
br>
// The about box is a special request; the
parameter block is not filled<
br>
// out, none of the callbacks or standard data
is available. Instead,<
br>
// the parameter block points to an
AboutRecord, which is used<
br>
//---------------------------------------------------------------------------<
br>
if
(selector
== filterSelectorAbout
)<
br>
DoAbout
((AboutRecordPtr
)filterParamBlock
);<
br>
{ // do the rest of the process as normal:<
br>
//-----------------------------------------------------------------------<
br>
// (3) Initialize function
// Initialize function
pointer routine dispatcher. We use this to jump<
br>
// to the different
routines, instead of a long obnoxious switch<
br>
// statement. All
routines are expected to have the same prototype<
br>
// of "void
RoutineName (globals)". Returns any errors in gResult.<
br>
// WARNING: These
better be in the order of the selector AND there<
br>
// better be a routine
for every selector call.<
br>
//-----------------------------------------------------------------------<
br>
static const FProc routineForSelector
[] =<
br>
/* filterSelectorAbout
/*
filterSelectorParameters *
/ DoParameters,<
br>
/*
filterSelectorPrepare *
/ DoPrepare,<
br>
/* filterSelectorStart
/*
filterSelectorContinue *
/ DoContinue,<
br>
/* filterSelectorFinish
Ptr globalPtr = NULL;
// Pointer
for global structure<
br>
GPtr globals = NULL;
//-----------------------------------------------------------------------<
br>
// (4) Allocate and initalize
// AllocateGlobals
requires the pointer to result, the pointer to the<
br>
// parameter block, a
pointer to the handle procs, the
size of our local<
br>
// "Globals"
structure, a pointer to the long *
data, a Function<
br>
// Proc (FProc) to the
InitGlobals routine. It automatically sets-up,<
br>
// initializes the
globals
(if necessary
), results result to
0, and<
br>
// returns with a valid
pointer to the locked globals handle or NULL.<
br>
//-----------------------------------------------------------------------<
br>
globalPtr
= AllocateGlobals
((uint32
)result,<
br>
(uint32
)filterParamBlock,<
br>
filterParamBlock->handleProcs,<
br>
if
(globalPtr
== NULL
)<
br>
{ // Something bad happened if we couldn't
allocate our pointer.<br>
// Fortunately, everything's already been
// so all we have to do is report an error.<
br>
*result
= memFullErr;<
br>
// Get our "globals" variable
assigned as a Global Pointer struct with the<
br>
// data we've returned:<br>
globals = (GPtr)globalPtr;<br>
<br>
//-----------------------------------------------------------------------<br>
// (5) Dispatch selector.<br>
//-----------------------------------------------------------------------<br>
<br>
if (selector > filterSelectorAbout
&& selector <= filterSelectorFinish)<br>
(routineForSelector[selector-1])(globals);
// dispatch using jump table<br>
else<br>
gResult =
filterBadParameters;<br>
<br>
//-----------------------------------------------------------------------<br>
// (6) Unlock data, and exit
resource.<br>
//<br>
// Result is automatically
returned in *result, which is<br>
// pointed to by gResult.<br>
//-----------------------------------------------------------------------
<br>
<br>
// unlock handle pointing to parameter block
and data so it can move<br>
// if memory gets shuffled:<br>
if ((Handle)*data != NULL)<br>
PIUnlockHandle((Handle)*data);<br>
<br>
} // about selector special <br>
<br>
#ifdef UseA4
// Are we in 68k Mac
MW?<br>
ExitCodeResource(); // A4-globals<br>
#endif<br>
<br>
} // end ENTRYPOINT<br>
<br>
//-------------------------------------------------------------------------------<br>
//<br>
// InitGlobals<br>
// <br>
// Initalize any global values here. Called only once when global<br>
// space is reserved for the first time.<br>
//<br>
// Inputs:<br>
// Ptr globalPtr
Standard pointer to a global structure.<br>
//<br>
// Outputs:<br>
// Initializes any global values with their
defaults.<br>
//<br>
//-------------------------------------------------------------------------------<br>
<br>
<br>
<br>
void InitGlobals (Ptr globalPtr)<br>
{ <br>
// create "globals" as a our struct global pointer so that
any<br>
// macros work:<br>
GPtr globals = (GPtr)globalPtr;<br>
<br>
// Initialize global variables:<br>
ValidateParameters (globals);<br>
<br>
} // end InitGlobals<br>
<br>
//-------------------------------------------------------------------------------<br>
//<br>
// ValidateParameters<br>
//<br>
// Initialize parameters to default values.<br>
//<br>
// Inputs:<br>
// GPtr globals
Pointer to global structure.<br>
//<br>
//-------------------------------------------------------------------------------<br>
<br>
void ValidateParameters (GPtr globals)<br>
{<br>
if (gStuff->parameters == NULL)<br>
{ // We haven't created these yet.<
br>
gStuff->parameters = PINewHandle ((long)
sizeof
(TParameters
));<
br>
if
(gStuff->parameters !
= NULL
)<
br>
{ // Got it. Fill out the fields.
<
a name="gKanal1=128;">gKanal1
=128;<
/a><
br>
gKanal4=128;
gZoomFactor=6;
gHostIsPremiereWin =
IsWindows
(HostIsPremiere
());<
br>
{ // Oops. Couldn't allocate memory.<br>
<br>
gResult = memFullErr;<br>
return;<br>
}<br>
} // parameters<br>
<br>
} // end ValidateParameters<br>
<br>
<br>
<br>
<br>
<br>
<br>
/*****************************************************************************/<br>
/* Inicializace vstupních parametrù filtru - neprobìhne pøi volání "Poslední
Filtr"*/<br>
<br>
void DoParameters (GPtr globals)<br>
{ <br>
ValidateParameters (globals);<br>
if (gStuff->parameters != NULL) <br>
{<br>
}<br>
gQueryForParameters = TRUE;<br>
}<br>
<br>
/*****************************************************************************/<br>
/* Výpoèet potøebné pamìti pro funkci filtru */<br>
<br>
<a name="void DoPrepare (GPtr globals){">void DoPrepare (GPtr globals)<br>
{</a><br>
short rowWidth = 0;<br>
short total = 0;<br>
long oneRow = 0;<br>
long inOutRow = 0;<br>
long inOutAndMask = 0;<br>
<br>
gStuff->bufferSpace = 0; <br>
ValidateParameters (globals);<br>
total = gStuff->imageSize.v;<br>
rowWidth = gStuff->imageSize.h; <br>
oneRow = rowWidth * (gStuff->planes);<br>
inOutRow = oneRow * 2; <br>
inOutAndMask = inOutRow + rowWidth; <br>
while (((inOutAndMask * gRowSkip) <
(gStuff->maxSpace-gStuff->bufferSpace)) && (gRowSkip < total))
gRowSkip++;<br>
gStuff->maxSpace = gRowSkip * inOutAndMask + gStuff->bufferSpace;
<br>
<br>
}<br>
<br>
/*****************************************************************************/<br>
/* Zobrazení UI a zaèátek filtrace */<br>
<br>
void DoStart (GPtr globals)<br>
{ <br>
<br>
Rect imageRect;<br>
return;<br>
ValidateParameters (globals); // Pokud nejsou inicializovány parametry
filtru, tak je inicializuje<br>
// lze pouít Advance ?<br>
gUseAdvance = AdvanceStateAvailable () &&<br>
DisplayPixelsAvailable
() &&<br>
!gHostIsPremiereWin;<br>
//
Adobe Premiere for Windows doesn't do AdvanceState right<
br>
ReadScriptParams (globals);
//
Pøeète pøedchozí nastavení filtru<
br>
if
(gQueryForParameters
) <
br>
DoUI (globals);
//
gQueryForParameters
= FALSE;<
br>
imageRect.top = 0;//pokud je filtr vyvolán bez
UI - inicializace rozmeru I
/O oblastí<
br>
imageRect.bottom
= gStuff->imageSize.v;<
br>
imageRect.right
= gStuff->imageSize.h;<
br>
copyRect(&gStuff->filterRect,
copyRect(&gStuff->inRect,
gStuff->inLoPlane = gStuff->outLoPlane =
gStuff->inHiPlane = gStuff->outHiPlane =
gStuff->planes -
1;<
br>
copyRect(&gStuff->maskRect,
&gStuff->filterRect
);<
br>
gStuff->inputRate
= long2fixed
(1L
);<
br>
gStuff->maskRate
= gStuff->inputRate; <
br>
gStuff->inputPadding =
plugInWantsEdgeReplication;<
br>
gStuff->outputPadding =
gStuff->inputPadding;<
br>
gStuff->maskPadding =
gStuff->inputPadding;<
br>
gResult
= AdvanceState
();<
br>
DoZoomRect
(globals,false
);<
br>
if
(gResult !
= noErr
) return;<
br>
if
(gUseAdvance
) StartWithAdvanceState
(globals
);<
br>
/*****************************************************************************
/<
br>
/* Pokraèování filtrace - pokud se filtruje po èástech - not Advance *
/<
br>
void DoContinue
(GPtr globals
)<
br>
if
(TestAbort
() || gResult !
= noErr
)<
br>
gResult
= userCanceledErr;<
br>
if
(!DoNextRect
(globals
))<
br>
PISetRect
(&gStuff->inRect,
0,
0,
0,
0);<
br>
PISetRect
(&gStuff->outRect,
0,
0,
0,
0);<
br>
PISetRect
(&gStuff->maskRect,
0,
0,
0,
0);<
br>
PISetRect
(&gStuff->inRect,
0,
0,
0,
0);<
br>
PISetRect (&gStuff->outRect, 0, 0, 0,
PISetRect (&gStuff->maskRect, 0, 0, 0,
/*****************************************************************************
/<
br>
/* Úklid po filtru a zápis nastavení parametrù filtru *
/<
br>
void DoFinish
(GPtr globals
)<
br>
WriteScriptParams
(globals
); <
br>
/*****************************************************************************
/<
br>
/* Filtrace celeho obrazu najednou *
/<
br>
void StartWithAdvanceState
(GPtr globals
)<
br>
total
= gStuff->filterRect.bottom - gStuff->filterRect.top;<
br>
gStuff->inLoPlane
= gStuff->outLoPlane
= 0;<
br>
gStuff->inHiPlane
= gStuff->outHiPlane
= gStuff->planes -
1;<
br>
/* Pokud chceme pouít kanály*
/<
br>
if
(!gStuff->isFloating
)<
br>
gStuff->wantsAbsolute
= true;<
br>
if (gStuff->inLayerPlanes !=0 &&
gStuff->inTransparencyMask !
= 0)<
br>
gStuff->inHiPlane =
gStuff->absLayerPlanes -
1 +<
br>
gStuff->absTransparencyMask
gStuff->absLayerMasks
gStuff->absInvertedLayerMasks
gStuff->absNonLayerPlanes;<
br>
if (gStuff->outLayerPlanes !=0 &&
gStuff->outTransparencyMask !
=0)<
br>
gStuff->outHiPlane =
gStuff->outLayerPlanes -
1 +<
br>
gStuff->outTransparencyMask
gStuff->outLayerMasks
gStuff->outInvertedLayerMasks
gStuff->outNonLayerPlanes;<
br>
gStuff->inRect.left = gStuff->outRect.left =
gStuff->maskRect.left
= gStuff->filterRect.left
= 0;<
br>
gStuff->inRect.right = gStuff->outRect.right =
gStuff->maskRect.right
= gStuff->filterRect.right
= gStuff->imageSize.h;<
br>
gStuff->inputRate
= long2fixed
(1L
);<
br>
gStuff->maskRate
= long2fixed
(1L
);<
br>
for (row
= 0; row < gStuff->imageSize.v; row +
= gRowSkip
)<
br>
if
(TestAbort
() || gResult !
= noErr
)<
br>
gResult =
gStuff->inRect.top = gStuff->outRect.top
= gStuff->maskRect.top
= gStuff->filterRect.top
=row;<
br>
gStuff->inRect.bottom =
gStuff->outRect.bottom = gStuff->maskRect.bottom = gStuff->filterRect.bottom=row
gResult
= AdvanceState
(); <
br>
if
(gResult !
= noErr
)<
br>
goto done;
Prah
(globals, true
);<
br>
PISetRect
(&gStuff->inRect,
0,
0,
0,
0);<
br>
PISetRect
(&gStuff->outRect,
0,
0,
0,
0);<
br>
PISetRect
(&gStuff->maskRect,
0,
0,
0,
0);<
br>
/******************************************************
/<
br>
/* provedení filtrace
void Prah
(GPtr globals, Boolean doProgress
)<
br>
const short total = gStuff->filterRect.bottom -
gStuff->filterRect.top;
//celkový pocet výstupního øádkù<
br>
const short outColumns= gStuff->outRect.right -
gStuff->outRect.left;
//pocet sloupcù výstupního obrázku<
br>
const short outRows = gStuff->outRect.bottom -
gStuff->outRect.top;
// pocet øádkù výstupního obrázku<
br>
const short outPlanes = gStuff->outHiPlane - gStuff->outLoPlane +
1;
//pocet kanálù výstupního obrázku<
br>
const short inColumns = gStuff->imageSize.h;
//pocet
sloupcù vstupniho obrázku<
br>
const short inRows = gStuff->imageSize.v;
//pocet
øádkù vstupniho obrázku<
br>
const short inPlanes = gStuff->inHiPlane - gStuff->inLoPlane + 1;
//pocet kanálù vstupniho obrázku<
br>
unsigned8 *srcPtr = (unsigned8 *) gStuff->inData; //ukazatel na
unsigned8 *dstPtr = (unsigned8 *) gStuff->outData;
//ukazatel na výstupní obrázek<
br>
unsigned8 *mskPtr = (unsigned8 *) gStuff->maskData;
//ukazatel na masku vstupního obrázku<
br>
Boolean maskPixel
= false;<
br>
<
a name="prah[0]=gKanal1;//nastavení jednotlivých prahù">
prah
[0]=gKanal1;
//nastavení jednotlivých prahù<
/a><
br>
for (i
=0; i < inRows; i++
)<
br>
srcPtr = (unsigned8 *) gStuff->inData + (i *
inColumns * inPlanes
);
//nastav na první pixel v øádku i<
br>
dstPtr = (unsigned8 *) gStuff->outData + (i
* inColumns * inPlanes
);
//nastav na první pixel v øádku i<
br>
mskPtr = (unsigned8 *) gStuff->maskData + (i
* inColumns
);
//nastav na první pixel v øádku i<
br>
if (doProgress) UpdateProgress ((long)
(gStuff->outRect.top + i
) - gStuff->filterRect.top,
(long
) total
);<
br>
for(j
=0;j<inColumns;j++
)<
br>
maskPixel = (!mskPtr
[0]);
//naètení masky<
br>
if (!maskPixel)
//pokud není maska uprav<
br>
for
(plane
= 0; plane < inPlanes; plane++
) <
br>
if(srcPtr[plane]>prah[plane])
else
else //pokud je tak
for
(plane = 0; plane < inPlanes; plane++) dstPtr [plane] = srcPtr [plane];
}
srcPtr +=
inPlanes;
//nastav na dalí pixel v øádku i<
br>
dstPtr +=
inPlanes;
//nastav na dalí pixel v øádku i<
br>
mskPtr++; //nastav na
dalí pixel v øádku i<
br>
}
/*****************************************************************************
/<
br>
/* Výpoèet a úpravy rozmìrù obrázku pro potøeby UI *
/<
br>
void CalcGlobalProxies
(GPtr globals
)<
br>
Rect imageRect,imageRect1;<
br>
int16 selCenterH, selCenterV;<
br>
int16 selLength, selWidth;<
br>
int16 length2, width2;<
br>
length = (gOrigProxyRect.bottom - gOrigProxyRect.top); // zobrazovaná
length2
= length
/ 2;<
br>
width = (gOrigProxyRect.right - gOrigProxyRect.left); // zobrazovaná
selLength
= gStuff->imageSize.v;
// Vybraná výka<
br>
selWidth
= gStuff->imageSize.h;
// Vybraná íøka<
br>
//Vycentrování preview<
br>
selCenterV
= (selLength
/ 2);<
br>
selCenterH
= (selWidth
/ 2);<
br>
imageRect.top
= selCenterV -
(length2
); <
br>
imageRect.left
= selCenterH -
(width2
);<
br>
imageRect.bottom
= imageRect.top+length;<
br>
imageRect.right
= imageRect.left+
width;<
br>
imageRect1.bottom
= gStuff->imageSize.v;<
br>
imageRect1.right
= gStuff->imageSize.h;<
br>
copyRect
(&gProxyScaleRect, &imageRect
);<
br>
copyRect
(&gStuff->inRect, &imageRect1
);<
br>
copyRect
(&gStuff->outRect, &imageRect
);<
br>
void SetupFilterRecordForProxy
(GPtr globals, Rect proxyScaleRect, short scaleFactor
)<
br>
#pragma unused
(proxyScaleRect
)<
br>
#pragma unused
(scaleFactor
)<
br>
gStuff->inLoPlane
= gStuff->outLoPlane
= 0;<
br>
gStuff->inHiPlane
= gStuff->outHiPlane
= gStuff->planes -
1;<
br>
copyRect
(&gStuff->maskRect, &gStuff->filterRect
);<
br>
gStuff->inputRate
= long2fixed
(1L
);<
br>
gStuff->maskRate
= gStuff->inputRate; <
br>
gStuff->inputPadding
= plugInWantsEdgeReplication;<
br>
gStuff->outputPadding
= gStuff->inputPadding;<
br>
gStuff->maskPadding
= gStuff->inputPadding;<
br>
gResult
= AdvanceState
();<
br>
void CalcProxyScaleFactor
(Rect proxyScaleRect, Rect *proxyRect, short *scaleFactor
)<
br>
shrinkRect (proxyRect, kGutter, kGutter);
filterHeight
= (proxyScaleRect.bottom - proxyScaleRect.top
);<
br>
filterWidth
= (proxyScaleRect.right - proxyScaleRect.left
);<
br>
itemHeight
= (proxyRect->bottom - proxyRect->top
);<
br>
itemWidth
= (proxyRect->right - proxyRect->left
);<
br>
if
(itemHeight > filterHeight
) itemHeight
= filterHeight;<
br>
if
(itemWidth > filterWidth
) itemWidth
= filterWidth;<
br>
fraction.h
= ((filterWidth + itemWidth
) / itemWidth
)-
1;<
br>
fraction.v
= ((filterHeight + itemHeight
) / itemHeight
)-
1;<
br>
if
(fraction.h > fraction.v
) *scaleFactor
= fraction.h;<
br>
else *scaleFactor
= fraction.v;<
br>
copyRect
(proxyRect, &proxyScaleRect
); <
br>
scaleRect
(proxyRect,
1, *scaleFactor
);<
br>
/****************************************************************************
/<
br>
/* Hlavní rutina Zoomování preview *
/<
br>
void DoZoomRect
(GPtr globals,Boolean mask
)<
br>
if
(gResult
== userCanceledErr
) return;<
br>
if
(gRepFactor <
= 1 && gRepFactor >
0)<
br>
ZoomOutRect
(globals, mask
);<
br>
else if
(gRepFactor >
1)<
br>
ZoomInRect (globals, mask);
/*****************************************************************************
/<
br>
/* Zoom in. Zvìtení gRepFactor >
= 1 *
/<
br>
/*****************************************************************************
/<
br>
void ZoomInRect
(GPtr globals, Boolean mask
)<
br>
short offsetOutColumns, offsetOutRows;<
br>
short centerInColumns, centerInRows;<
br>
short offsetInColumns, offsetInRows;<
br>
short difColumns, difRows; <
br>
short proxyCenterCol, proxyCenterRow;<
br>
short proxyOffsetCol, proxyOffsetRow;<
br>
int i,j,ii,jj,max,polo,plane;<
br>
const short outColumns= gStuff->outRect.right -
gStuff->outRect.left;<
br>
const short outRows = gStuff->outRect.bottom -
gStuff->outRect.top; <
br>
const short outPlanes = gStuff->outHiPlane - gStuff->outLoPlane +
const short inColumns
= gStuff->imageSize.h;<
br>
const short inRows
= gStuff->imageSize.v;<
br>
const short inPlanes =gStuff->outHiPlane - gStuff->outLoPlane +
Boolean maskPixel
= false;<
br>
offsetOutColumns
= outColumns
/ 2;<
br>
offsetOutRows
= outRows
/ 2;<
br>
centerInColumns
= inColumns
/ 2;<
br>
centerInRows
= inRows
/ 2;<
br>
offsetInColumns
= (short
)(inColumns * gRepFactor
/ 2);<
br>
offsetInRows
= (short
)(inRows * gRepFactor
/ 2);<
br>
difColumns = offsetInColumns
difRows
= offsetInRows - offsetOutRows;<
br>
difColumns
/= (short
)gRepFactor;<
br>
difRows
/=(short
)gRepFactor;<
br>
gPozice.x
=gSPozice.x+
(short
)gDif.x;<
br>
if
(gPozice.x> difColumns
) gPozice.x
=difColumns;<
br>
if
(gPozice.x<-difColumns
) gPozice.x
=-difColumns;<
br>
gPozice.y
=gSPozice.y+
(short
)gDif.y;<
br>
if
(gPozice.y> difRows
) gPozice.y
=difRows;<
br>
if
(gPozice.y<-difRows
) gPozice.y
=-difRows;<
br>
proxyCenterCol = gOrigProxyRect.left + ((gOrigProxyRect.right -
gOrigProxyRect.left
) / 4);<
br>
proxyCenterRow = gOrigProxyRect.top + ((gOrigProxyRect.bottom -
gOrigProxyRect.top
) / 4);<
br>
proxyOffsetCol
= outColumns
/ 2;<
br>
proxyOffsetRow
= outRows
/ 2;<
br>
max
=(int
)sqrt
((inRows
/2)*
(inRows
/2)+
(inColumns
/2)*
(inColumns
/2));<
br>
for (i
= 0; i < outRows; i ++
)<
br>
for(ii
= 1;ii<
=gRepFactor;ii++
)<
br>
if
(i
==outRows
) break;<
br>
mskPtr2= (unsigned8
*
)gSHOWmask +
(i * outColumns
);<
br>
dstPtr = (unsigned8
*)gStuff->outData + (i * outColumns * outPlanes);
mskPtr = (unsigned8
*)gFFTmask + (- gPozice.x + difColumns + (((int)(i/gRepFactor) + difRows - gPozice.y ) *
srcX= - gPozice.x +
difColumns +
(((int
)(i
/gRepFactor
) + difRows - gPozice.y
) * inColumns
);<
br>
srcY=srcX-((short)(srcX/inColumns))*inColumns;
for (j = 0; j <
for
(jj
= 1;jj<
=gRepFactor;jj++
)<
br>
if
(gIMaska
) mskPtr2
[0] = 255-mskPtr
[0];<
br>
else
if (mskPtr[0]) for(plane=0;plane<inPlanes;plane++)
dstPtr[plane]=((gInten*gFFTdata[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100)+(100-gInten)*gFFTdata2[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100);
else
for(plane=0;plane<inPlanes;plane++)
dstPtr
[plane
]=gFFTdata
[((srcX
/inColumns
)*inColumns+srcY
)*inPlanes+plane
];<
br>
dstPtr
if
(j
==outColumns
) break;<
br>
srcY
gProxyRect.left = proxyCenterCol - proxyOffsetCol >
?
proxyCenterCol - proxyOffsetCol : gOrigProxyRect.left;<
br>
gProxyRect.right = proxyCenterCol + proxyOffsetCol <
?
proxyCenterCol + proxyOffsetCol : gOrigProxyRect.right;<
br>
gProxyRect.top = proxyCenterRow - proxyOffsetRow >
?
proxyCenterRow - proxyOffsetRow : gOrigProxyRect.top;<
br>
gProxyRect.bottom = proxyCenterRow + proxyOffsetRow <
gOrigProxyRect.bottom<
br>
?
proxyCenterRow + proxyOffsetRow : gOrigProxyRect.bottom;<
br>
/*****************************************************************************
/<
br>
/* Zoom Out. Zmenení gRepFactor between
0...
1. *
/<
br>
void ZoomOutRect
(GPtr globals, Boolean mask
)<
br>
const unsigned8 kUIBackcolor
= 191;<
br>
short offsetOutColumns, offsetOutRows;<
br>
short startOutColumns, startOutRows, endOutColumns, endOutRows;<
br>
const short outColumns= gStuff->outRect.right -
gStuff->outRect.left;<
br>
const short outRows = gStuff->outRect.bottom -
gStuff->outRect.top; <
br>
const short outPlanes = gStuff->outHiPlane - gStuff->outLoPlane +
const short inColumns
= gStuff->imageSize.h;<
br>
const short inRows
= gStuff->imageSize.v;<
br>
const short inPlanes
= gStuff->inHiPlane - gStuff->inLoPlane +
1;<
br>
short centerInColumns, centerInRows;<
br>
short offsetInColumns, offsetInRows;<
br>
short difColumns, difRows;<
br>
short proxyCenterCol, proxyCenterRow;<
br>
short proxyOffsetCol, proxyOffsetRow;<
br>
int i,j,srcX,srcY,max,polo,plane;<
br>
Boolean maskPixel
= false;<
br>
offsetOutColumns
= outColumns
/ 2;<
br>
offsetOutRows
= outRows
/ 2;<
br>
endOutColumns
= outColumns-
1;<
br>
endOutRows
= outRows-
1;<
br>
centerInColumns
= inColumns
/ 2;<
br>
centerInRows
= inRows
/ 2;<
br>
offsetInColumns
= (short
)(inColumns * gRepFactor
/ 2);<
br>
offsetInRows
= (short
)(inRows * gRepFactor
/ 2);<
br>
difColumns = offsetInColumns
difRows
= offsetInRows - offsetOutRows;<
br>
if
(difColumns<
0) <
br>
startOutColumns-
=difColumns;<
br>
endOutColumns+
=difColumns;<
br>
startOutRows-
=difRows;<
br>
gPozice.x
=gSPozice.x+
(short
)gDif.x;<
br>
if
(gPozice.x> difColumns
) gPozice.x
=difColumns;<
br>
if
(gPozice.x<-difColumns
) gPozice.x
=-difColumns;<
br>
gPozice.y
=gSPozice.y+
(short
)gDif.y;<
br>
if
(gPozice.y> difRows
) gPozice.y
=difRows;<
br>
if
(gPozice.y<-difRows
) gPozice.y
=-difRows;<
br>
proxyCenterCol = gOrigProxyRect.left + ((gOrigProxyRect.right -
gOrigProxyRect.left
) / 2);<
br>
proxyCenterRow = gOrigProxyRect.top + ((gOrigProxyRect.bottom -
gOrigProxyRect.top
) / 2);<
br>
proxyOffsetCol
= (short
)((outColumns * gRepFactor
) / 2);<
br>
proxyOffsetRow
= (short
)((outRows * gRepFactor
) / 2);<
br>
for (i
= 0;i < startOutRows;i ++
)<
br>
dstPtr = (unsigned8 *)
gStuff->outData +
(i * outColumns* outPlanes
);<
br>
mskPtr2= (unsigned8 *)
gSHOWmask +
(i * outColumns
);<
br>
for (j = 0; j <
for(plane=0;plane<inPlanes;plane++)
dstPtr
[plane
] = kUIBackcolor;<
br>
max
=(int
)sqrt
((inRows
/2)*
(inRows
/2)+
(inColumns
/2)*
(inColumns
/2));<
br>
for (i
= startOutRows;i < endOutRows; i ++
)<
br>
srcX =
(short)((-gPozice.x+difColumns)/gRepFactor) + ((i - startOutRows +
(short
)((-gPozice.y+difRows
)/gRepFactor
) + offset
) * inColumns
);<
br>
dstPtr = (unsigned8 *) gStuff->outData + (i
* outColumns* outPlanes
);<
br>
mskPtr2
= (unsigned8 *
) gSHOWmask +
(i * outColumns
);<
br>
mskPtr = (unsigned8 *) gFFTmask +
(short)((-gPozice.x+difColumns)/gRepFactor) + ((i - startOutRows + (short)((-gPozice.y +
difRows
)/gRepFactor
) + offset
) * inColumns
);<
br>
for (j
= 0; j < startOutColumns;j ++
)<
br>
for(plane=0;plane<inPlanes;plane++)
dstPtr
[plane
] = kUIBackcolor;<
br>
srcY=srcX-((short)(srcX/inColumns))*inColumns;
for (j = startOutColumns;j < endOutColumns;
{
if (gIMaska) mskPtr2[0]
if(mskPtr[0]) for(plane=0;plane<inPlanes;plane++) dstPtr[plane]=((gInten*gFFTdata[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100)+(100-gInten)*gFFTdata2[((srcX/inColumns)*inColumns+srcY)*inPlanes+plane]/100);
else
for(plane=0;plane<inPlanes;plane++)
dstPtr
[plane
]=gFFTdata
[((srcX
/inColumns
)*inColumns+srcY
)*inPlanes+plane
];<
br>
HFactor +=
while
(HFactor>
=0.5)<
br>
srcY
for (j = endOutColumns;
j < outColumns; j ++
)<
br>
for(plane=0;plane<inPlanes;plane++)
dstPtr
[plane
] = kUIBackcolor;<
br>
dstPtr
VFactor +
= ((1/gRepFactor
)-
1);<
br>
while
(VFactor>
=0.5)<
br>
for (i
= endOutRows; i < outRows; i ++
)<
br>
dstPtr = (unsigned8 *)
gStuff->outData +
(i * outColumns* outPlanes
);<
br>
mskPtr2= (unsigned8 *)
gSHOWmask +
(i * outColumns
);<
br>
for (j = 0; j <
for(plane=0;plane<inPlanes;plane++)
dstPtr
[plane
] = kUIBackcolor; <
br>
dstPtr
gProxyRect.left = proxyCenterCol - proxyOffsetCol >
?
proxyCenterCol - proxyOffsetCol : gOrigProxyRect.left;<
br>
gProxyRect.right = proxyCenterCol + proxyOffsetCol <
?
proxyCenterCol + proxyOffsetCol : gOrigProxyRect.right;<
br>
gProxyRect.top = proxyCenterRow - proxyOffsetRow >
?
proxyCenterRow - proxyOffsetRow : gOrigProxyRect.top;<
br>
gProxyRect.bottom = proxyCenterRow + proxyOffsetRow <
gOrigProxyRect.bottom;<
br>
/*****************************************************************************
/<
br>
/* Zooms in by one factor
(parts of
1.0 until
1.0, then
1.0,
2.0, etc. *
/<
br>
void ZoomIn
(short *zoom
)<
br>
if
(*zoom >
= kNumZooms
)<
br>
void ZoomOut
(short *zoom
)<
br>
if
(*zoom >
= (kNumZooms*
2))<
br>
/*****************************************************************************
/<
br>
/* Takes an enumeration and returns corresponding zoom
size *
/<
br>
short GetZoomFactor
(GPtr globals
)<
br>
short returnValue
= noErr;<
br>
/* check
for zoomFactor bounds *
/<
br>
if
(gZoomFactor <
= kMinZoom
)<
br>
gZoomFactor
= kMinZoom;<
br>
returnValue
= hitLowBounds;<
br>
else if
(gZoomFactor >
= kMaxZoom
)<
br>
gZoomFactor
= kMaxZoom;<
br>
returnValue
= hitHighBounds;<
br>
sub
= gZoomFactor % kNumZooms;<
br>
gRepFactor
gRepFactor
gRepFactor
gRepFactor
gRepFactor
gRepFactor
gRepFactor +
= gZoomFactor
/ kNumZooms;<
br>
void scaleRect
(Rect *l, short n, short d
) {<
br>
l->left
= (l->left * n
) / d;<
br>
l->top
= (l->top * n
) / d;<
br>
l->right
= (l->right * n
) / d;<
br>
l->bottom
= (l->bottom * n
) / d;<
br>
void shrinkRect
(Rect *l, short x, short y
) {<
br>
void copyRect
(Rect *l, const Rect *r
) {<
br>
l->left
= r->left;<
br>
l->top
= r->top;<
br>
l->right
= r->right;<
br>
l->bottom
= r->bottom;<
br>
/******************************************************************************
/<
br>
/* NEPOUITO - Pokud se filtruje po èástech *
/<
br>
void StartNoAdvanceState
(GPtr globals
)<
br>
DoInitialRect
(globals
);<
br>
/*****************************************************************************
/<
br>
/* NEPOUITO - inicializace první filtrované èásti - filtrování po èástech *
/<
br>
void DoInitialRect
(GPtr globals
)<
br>
total
= gStuff->filterRect.bottom - gStuff->filterRect.top;<
br>
gStuff->inLoPlane
= gStuff->outLoPlane
= 0;<
br>
gStuff->inHiPlane
= gStuff->outHiPlane
= gStuff->planes -
1;<
br>
/* Pouítí Alfa kanálù *
/<
br>
if
(!gStuff->isFloating
)<
br>
gStuff->wantsAbsolute
= true;<
br>
if (gStuff->inLayerPlanes !=0 &&
gStuff->inTransparencyMask !
= 0)<
br>
gStuff->inHiPlane =
gStuff->absLayerPlanes -
1 +<
br>
gStuff->absTransparencyMask
gStuff->absLayerMasks
gStuff->absInvertedLayerMasks
gStuff->absNonLayerPlanes;<
br>
if (gStuff->outLayerPlanes !=0 &&
gStuff->outTransparencyMask !
=0)<
br>
gStuff->outHiPlane =
gStuff->outLayerPlanes -
1 +<
br>
gStuff->outTransparencyMask
gStuff->outLayerMasks
gStuff->outInvertedLayerMasks
gStuff->outNonLayerPlanes;<
br>
gStuff->inputRate
= long2fixed
(1L
);<
br>
gStuff->maskRate
= long2fixed
(1L
);<
br>
gStuff->maskPadding = gStuff->outputPadding =
gStuff->inputPadding
= 255;<
br>
gStuff->inRect = gStuff->outRect = gStuff->maskRect =
gStuff->filterRect;<
br>
gStuff->inRect.bottom = gStuff->outRect.bottom =
gStuff->maskRect.bottom
= gStuff->inRect.top + gRowSkip;<
br>
/*****************************************************************************
/<
br>
/* NEPOUITO - Dotaz na dalí èást *
/<
br>
Boolean DoNextRect
(GPtr globals
)<
br>
gStuff->inRect.top +
= gRowSkip;
// next batch<
br>
gStuff->inRect.bottom +
= gRowSkip;
// next batch<
br>
gStuff->outRect
= gStuff->maskRect
= gStuff->inRect;<
br>
return gStuff->inRect.top < gStuff->filterRect.bottom;<
br>