pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-11 01:11:43 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
8edf8e808ece8fcc2e85a6ff03fc0d2fdbd0186e
core/ASCImageStudio3/Common/ImagePaintComposeUtility.h

4772 lines
183 KiB
C++
Raw Blame History

#pragma once
#pragma comment(lib, "ippcorel.lib")
#pragma comment(lib, "ippiemerged.lib")
#pragma comment(lib, "ippimerged.lib")
#pragma comment(lib, "ippsemerged.lib")
#pragma comment(lib, "ippsmerged.lib")
#pragma comment(lib, "ippcvemerged.lib")
#pragma comment(lib, "ippcvmerged.lib")
#include <ippcore.h>
#include <ippdefs.h>
#include <ippi.h>
#include <ippcv.h>
#include <algorithm>
#include <ImagePaintComposeConstants.h>
#pragma warning(disable: 4244)
namespace ImageStudio
{
namespace Paint
{
namespace Compose
{
inline int AlphaBlend( int dst, int src, int alpha )
{
return ((src - dst) * alpha >> 8) + dst;
}
namespace Utility
{
class CGraduate
{
public:
CGraduate()
{
m_nSize = 0;
m_pGraduation = NULL;
}
virtual ~CGraduate()
{
Clear();
}
BOOL Clear()
{
if (m_pGraduation)
delete[] m_pGraduation;
m_pGraduation = NULL;
m_nSize = 0;
return TRUE;
}
BOOL Create(int nSize)
{
if (nSize < 1)
return Clear();
if (nSize == m_nSize)
return TRUE;
m_nSize = nSize;
m_pGraduation = new int[m_nSize];
if (NULL == m_pGraduation)
{
Clear();
return FALSE;
}
for (int index = 0; index < m_nSize; ++index)
m_pGraduation[index] = index;
CRandom rnd( 1 );
for (int index = 0; index < m_nSize; ++index)
{
int nSwapIndex = rnd.Rand( m_nSize );
int nSwapValue = m_pGraduation[nSwapIndex];
m_pGraduation[nSwapIndex] = m_pGraduation[index];
m_pGraduation[index] = nSwapValue;
}
return TRUE;
}
double GetLevel(int nIndex, double dFrame)
{
if (nIndex < 0 || nIndex >= m_nSize)
return 0;
if (dFrame <= 0)
return 0;
if (dFrame >= 1)
return 1;
double dLevel = m_nSize*dFrame;
if (dLevel <= m_pGraduation[nIndex])
return 0;
if (dLevel >= m_pGraduation[nIndex] + 1)
return 1;
return dLevel - m_pGraduation[nIndex];
}
protected:
int m_nSize;
int* m_pGraduation;
};
class CTetrisFigure
{
public:
CTetrisFigure()
{
m_nFigHeight = 0;
m_nFigWidth = 0;
m_nPicHeight = 0;
m_nPicWidth = 0;
m_nType = 0;
m_nXCoorSource = 0;
m_nYCoorSource = 0;
}
CTetrisFigure(int nFigWidth, int nFigHeight, int nType, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
{
m_nFigHeight = nFigHeight;
m_nFigWidth = nFigWidth;
m_nType = nType;
m_nPicHeight = nPicHeight;
m_nPicWidth = nPicWidth;
m_pBGRASource = pBGRASource;
m_nXCoorSource = nXCoorSource;
m_nYCoorSource = nYCoorSource;
}
~CTetrisFigure()
{
}
private:
void DrawAlphaBlendingLine(BYTE* pBGRAResult, BYTE* pBGRASource, int nColor, int nNumLine, double dEffect)
{
int nAlpha = 7 * (1 << nNumLine) & 0xff;
nColor = nColor * nAlpha;
nAlpha = 255 - nAlpha;
if(1 == dEffect)
{
pBGRAResult[0] = (nColor + pBGRASource[0] *nAlpha) * 0x8081U >> (7 + 16);
pBGRAResult[1] = (nColor + pBGRASource[1] *nAlpha) * 0x8081U >> (7 + 16);
pBGRAResult[2] = (nColor + pBGRASource[2] *nAlpha) * 0x8081U >> (7 + 16);
}
else
{
double factor = 1 - dEffect;
pBGRAResult[0] = dEffect * ((nColor + pBGRASource[0] *nAlpha) * 0x8081U >> (7 + 16)) + pBGRASource[0] * factor;
pBGRAResult[1] = dEffect * ((nColor + pBGRASource[1] *nAlpha) * 0x8081U >> (7 + 16)) + pBGRASource[1] * factor;
pBGRAResult[2] = dEffect * ((nColor + pBGRASource[2] *nAlpha) * 0x8081U >> (7 + 16)) + pBGRASource[2] * factor;
}
pBGRAResult[3] = pBGRASource[3];
}
public:
void SetValue(int nFigWidth, int nFigHeight, int nType, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
{
m_nFigHeight = nFigHeight;
m_nFigWidth = nFigWidth;
m_nType = nType;
m_nPicHeight = nPicHeight;
m_nPicWidth = nPicWidth;
m_pBGRASource = pBGRASource;
m_nXCoorSource = nXCoorSource;
m_nYCoorSource = nYCoorSource;
}
BOOL Cpy(BYTE* pBGRAResult, int nXCoorResult, int nYCoorResult, int nWidth, int nHeight, double dEffect)
{
if(!pBGRAResult || nWidth != m_nPicWidth || nHeight != m_nPicHeight)
return FALSE;
BYTE* pSource = m_pBGRASource;
BYTE* pResultBuffer = new BYTE[ 4 * nWidth * ( 2 * nHeight)];
BYTE* pResultBufferCurent = pResultBuffer;
pResultBufferCurent += 4 * nWidth * nHeight;
BYTE* pResultBufferMiddle = pResultBufferCurent;
BYTE* pResult = pBGRAResult;
IppiSize roiSize = { nWidth, nHeight};
::memcpy(pResultBufferMiddle, pResult, 4 * nWidth * nHeight);
//ippiCopy_8u_C4R( pResult, 4 * nWidth, pResultBufferMiddle, 4 * nWidth, roiSize);
pSource += m_nYCoorSource * nWidth * 4;
pResultBufferCurent += nYCoorResult * nWidth * 4;
if (1 == m_nType)
{
for(int nYIndex = nYCoorResult; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
{
pSource += m_nXCoorSource*4;
pResultBufferCurent += nXCoorResult*4;
int nXIndex = nXCoorResult;
for(; nXIndex < min(nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if( nYCoorResult + 5 >= nYIndex &&
( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult)) &&
0 != dEffect)
{
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
}
else if( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex)) &&
0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= min(nWidth, nXCoorResult + m_nFigWidth) - (min(nHeight, nYCoorResult + m_nFigHeight) - nYIndex)) &&
0 != dEffect)
{
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)) &&
0 != dEffect)
{
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy(pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
}
else if(2 == m_nType)
{
int nYIndex = nYCoorResult;
for(; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight/2); nYIndex++)
{
pSource += m_nXCoorSource * 4;
pResultBufferCurent += nXCoorResult * 4;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if( nYCoorResult + 5 >= nYIndex &&
( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult)) &&
0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
}
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + ( min(nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex)) &&
0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if( min( nHeight, nYCoorResult + m_nFigHeight / 2) - 5 <= nYIndex &&
( ( nXIndex <= nXCoorResult + m_nFigWidth / 3 - ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex) && nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex)) ||
( nXIndex >= nXCoorResult + 2 * m_nFigWidth / 3 + ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nHeight, nYCoorResult + m_nFigHeight / 2) - nYIndex))) &&
0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight/2) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( nXIndex - nXCoorResult)) &&
0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy(pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
for(; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
{
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 3);
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 3);
int nXIndex = nXCoorResult + m_nFigWidth / 3;
for(; nXIndex < min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3); nXIndex++)
{
if
( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - 5 <= nXIndex
&& ( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex)
&& nYIndex <= min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - (min(nWidth, nXCoorResult + 2*m_nFigWidth/3)- 5), dEffect);
}
else if
( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex
&& ( nXIndex >= nXCoorResult + m_nFigWidth / 3 + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex)
&& nXIndex <= min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
}
else if
( nXCoorResult + m_nFigWidth / 3 + 5 >= nXIndex
&& ( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( nXIndex - ( nXCoorResult + m_nFigWidth / 3))
&& nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - ( nXCoorResult + m_nFigWidth / 3)))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth/3 + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
}
else if(3 == m_nType)
{
int nYIndex = nYCoorResult;
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 3); nYIndex++)
{
pSource += m_nXCoorSource * 4;
pResultBufferCurent += nXCoorResult * 4;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 2); nXIndex++)
{
if ( nYCoorResult + 5 >= nYIndex
&& ( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth / 2) - ( nYIndex - nYCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
}
else if
( min(nWidth, nXCoorResult + m_nFigWidth / 2) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - 5), dEffect);
}
else if
( nXCoorResult + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 3) - ( nXIndex - nXCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
for(; nYIndex < min(nHeight, nYCoorResult + 2 * m_nFigHeight / 3); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if ( nYCoorResult + m_nFigHeight / 3 + 5 >= nYIndex &&
( nXIndex <= nXCoorResult + m_nFigWidth - ( nYIndex - nYCoorResult - m_nFigHeight / 3) && nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( nYIndex - nYCoorResult - m_nFigHeight / 3))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 3 + 5 - nYIndex, dEffect);
}
else if
( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + m_nFigHeight / 3 + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 0, nXIndex - (min(nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if
( ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - 5 <= nYIndex) &&
( nXIndex <= nXCoorResult + m_nFigWidth - ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex) && nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + 2*m_nFigHeight/3) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex && 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 2); nXIndex++)
{
if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= nXCoorResult + m_nFigWidth / 2 - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - (min(nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
}
else if( min(nWidth, nXCoorResult + m_nFigWidth / 2) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + 2 * m_nFigHeight / 3 + ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex) && nYIndex <= nYCoorResult + m_nFigHeight - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth/2) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
}
else if(4 == m_nType)
{
int nYIndex = nYCoorResult;
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 3); nYIndex++)
{
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 2);
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 2);
int nXIndex = nXCoorResult + m_nFigWidth / 2;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if ( nYCoorResult + 5 >= nYIndex &&
( nXIndex >= nXCoorResult + m_nFigWidth/2 + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
}
else if
( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if
( nXCoorResult + m_nFigWidth / 2 + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult - m_nFigWidth / 2) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 3) - ( nXIndex - nXCoorResult - m_nFigWidth / 2))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth/2 + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
for(; nYIndex < min(nHeight, nYCoorResult + 2 * m_nFigHeight / 3); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if( nYCoorResult + m_nFigHeight / 3 + 5 >= nYIndex &&
( nXIndex <= nXCoorResult + m_nFigWidth / 2 - ( nYIndex - nYCoorResult - m_nFigHeight / 3) && nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult - m_nFigHeight / 3))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 3 + 5 - nYIndex, dEffect);
}
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex && 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - (min(nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if( ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - 5 <= nYIndex) &&
( nXIndex <= nXCoorResult + m_nFigWidth / 2 - ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex) && nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + m_nFigHeight / 3 + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - ( nXIndex - nXCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
{
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 2);
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 2);
int nXIndex = nXCoorResult + m_nFigWidth / 2;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
( nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= nXCoorResult + m_nFigWidth - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( nYCoorResult + m_nFigHeight - 5), dEffect);
}
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
nYIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex)
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if( nXCoorResult + m_nFigWidth / 2 + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + 2 * m_nFigHeight / 3 + ( nXIndex - nXCoorResult - m_nFigWidth / 2) && nYIndex <= nYCoorResult + m_nFigHeight - ( nXIndex - nXCoorResult - m_nFigWidth / 2))
&& 0 != dEffect)
{
DrawAlphaBlendingLine(pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth/2 + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
}
else if(5 == m_nType)
{
int nYIndex = nYCoorResult;
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 2); nYIndex++)
{
pSource += 4 * ( m_nXCoorSource + m_nFigWidth / 3);
pResultBufferCurent += 4 * ( nXCoorResult + m_nFigWidth / 3);
int nXIndex = nXCoorResult + m_nFigWidth / 3;
for(; nXIndex < min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3); nXIndex++)
{
if( nYCoorResult + 5 >= nYIndex &&
( nXIndex >= nXCoorResult + m_nFigWidth / 3 + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - ( nYIndex - nYCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
}
else if( min(nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + 2 * m_nFigWidth / 3) - 5), dEffect);
}
else if( nXCoorResult + m_nFigWidth / 3 + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult - m_nFigWidth / 3) && nYIndex <= min( nHeight, nYCoorResult + 2 * m_nFigHeight / 3) - ( nXIndex - nXCoorResult - m_nFigWidth / 3))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + m_nFigWidth / 3 + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4; pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4; pSource += 4;
}
}
for(; nYIndex < min(nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if( nYCoorResult + m_nFigHeight / 2 + 5 >= nYIndex &&
( ( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult - m_nFigHeight / 2) && nXIndex <= nXCoorResult + m_nFigWidth / 3 - ( nYIndex - nYCoorResult - m_nFigHeight / 2))
|| nXIndex >= nXCoorResult + 2 * m_nFigWidth / 3 + ( nYIndex - nYCoorResult - m_nFigHeight / 2) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult - m_nFigHeight / 2))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 2 + 5 - nYIndex, dEffect);
}
else if( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
( nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( nXIndex - nXCoorResult) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
}
else if(6 == m_nType)
{
int nYIndex = nYCoorResult;
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 3); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if( nYCoorResult + 5 >= nYIndex &&
(nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - nYCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
}
else if( min(nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 3) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if( min( nHeight, nYCoorResult + m_nFigHeight / 3) - 5 <= nYIndex &&
( nXIndex >= nXCoorResult + m_nFigWidth / 2 + ( min( nHeight, nYCoorResult + m_nFigHeight / 3) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nHeight, nYCoorResult + m_nFigHeight / 3) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight / 3) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult)
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 2); nXIndex++)
{
if( min( nWidth, nXCoorResult + m_nFigWidth / 2) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + m_nFigHeight / 3 + ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth / 2) - 5), dEffect);
}
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth / 2) - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
}
else if(7 == m_nType)
{
int nYIndex = nYCoorResult;
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight / 2); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth / 3); nXIndex++)
{
if( nYCoorResult + 5 >= nYIndex &&
( nXIndex >= nXCoorResult + ( nYIndex - nYCoorResult) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth / 3) - ( nYIndex - nYCoorResult))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + 5 - nYIndex, dEffect);
}
else if( min( nWidth, nXCoorResult + m_nFigWidth / 3) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + ( min( nWidth, nXCoorResult + m_nFigWidth / 3) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight / 2) - ( min( nWidth, nXCoorResult + m_nFigWidth / 3) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth / 3) - 5), dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
nYIndex >= nYCoorResult + ( nXIndex - nXCoorResult)
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
for(; nYIndex < min( nHeight, nYCoorResult + m_nFigHeight); nYIndex++)
{
pSource += 4 * m_nXCoorSource;
pResultBufferCurent += 4 * nXCoorResult;
int nXIndex = nXCoorResult;
for(; nXIndex < min( nWidth, nXCoorResult + m_nFigWidth); nXIndex++)
{
if( min( nWidth, nXCoorResult + m_nFigWidth) - 5 <= nXIndex &&
( nYIndex >= nYCoorResult + m_nFigHeight / 2 + ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex) && nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( min( nWidth, nXCoorResult + m_nFigWidth) - nXIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nXIndex - ( min( nWidth, nXCoorResult + m_nFigWidth) - 5), dEffect);
}
else if( min( nHeight, nYCoorResult + m_nFigHeight) - 5 <= nYIndex &&
( nXIndex >= nXCoorResult + ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex) && nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( min( nHeight, nYCoorResult + m_nFigHeight) - nYIndex))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nYIndex - ( min( nHeight, nYCoorResult + m_nFigHeight) - 5), dEffect);
}
else if( nYCoorResult + m_nFigHeight / 2 + 5 >= nYIndex &&
( nXIndex <= min( nWidth, nXCoorResult + m_nFigWidth) - ( nYIndex - ( nYCoorResult + m_nFigHeight / 2)) && nXIndex >= nXCoorResult + m_nFigWidth / 3 + ( nYIndex - ( nYCoorResult + m_nFigHeight / 2)))
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 0, nYCoorResult + m_nFigHeight / 2 + 5 - nYIndex, dEffect);
}
else if( nXCoorResult + 5 >= nXIndex &&
nYIndex <= min( nHeight, nYCoorResult + m_nFigHeight) - ( nXIndex - nXCoorResult)
&& 0 != dEffect)
{
DrawAlphaBlendingLine( pResultBufferCurent, pSource, 255, nXCoorResult + 5 - nXIndex, dEffect);
}
else
{
memcpy( pResultBufferCurent, pSource, 4);
}
pResultBufferCurent += 4;
pSource += 4;
}
for(; nXIndex < nWidth; nXIndex++)
{
pResultBufferCurent += 4;
pSource += 4;
}
}
}
else
{
return FALSE;
}
ippiCopy_8u_C4R(pResultBufferMiddle, 4 * nWidth, pResult, 4 * nWidth, roiSize);
delete pResultBuffer;
return TRUE;
}
public:
int m_nFigHeight;
int m_nFigWidth;
int m_nPicHeight;
int m_nPicWidth;
int m_nType;
BYTE* m_pBGRASource;
int m_nXCoorSource;
int m_nYCoorSource;
};
class CUtility
{
public:
DWORD m_dwBaseRnd;
protected:
BOOL DrawFilmsPerf(BYTE* pBGRA, int nWidth, int nHeight, int nBlendColor, int nBkColor, float dX, float dY, float dWidth, float dHeight, float dRadius)
{
BYTE* pBuffer = pBGRA;
pBuffer += 4 * nWidth * (nHeight - 1);
Gdiplus::Bitmap oImage( nWidth, nHeight, -4*nWidth, PixelFormat32bppARGB, pBuffer );
if( Gdiplus::Ok == oImage.GetLastStatus() )
{
Gdiplus::Graphics oRender( &oImage );
oRender.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
oRender.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
oRender.SetInterpolationMode(Gdiplus::InterpolationModeBilinear);
Gdiplus::GraphicsPath oPath;
oPath.AddLine(dX + dRadius, dY, dX + dWidth - (dRadius * 2), dY);
oPath.AddArc(dX + dWidth - (dRadius * 2), dY, dRadius * 2, dRadius * 2, 270, 90);
oPath.AddLine(dX + dWidth, dY + dRadius, dX + dWidth, dY + dHeight - (dRadius * 2));
oPath.AddArc(dX + dWidth - (dRadius * 2), dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2,0,90);
oPath.AddLine(dX + dWidth - (dRadius * 2), dY + dHeight, dX + dRadius, dY + dHeight);
oPath.AddArc(dX, dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2, 90, 90);
oPath.AddLine(dX, dY + dHeight - (dRadius * 2), dX, dY + dRadius);
oPath.AddArc(dX, dY, dRadius * 2, dRadius * 2, 180, 90);
oPath.CloseFigure();
Gdiplus::PathGradientBrush *oBrush = new Gdiplus::PathGradientBrush(&oPath);
oBrush->SetCenterPoint(Gdiplus::PointF(dX + dWidth / 2, dY + dHeight / 2));
oBrush->SetCenterColor(Color(nBkColor, nBkColor, nBkColor));
Color *oColor = new Color( nBkColor, nBkColor, nBkColor);
int nColorCount = 1;
oBrush->SetSurroundColors(oColor, &nColorCount);
oRender.FillPath(oBrush, &oPath);
Gdiplus::Pen *oPen = new Gdiplus::Pen(Color( nBlendColor, nBlendColor, nBlendColor), 1);
oRender.DrawArc( oPen, dX + dWidth - (dRadius * 2), dY, dRadius * 2, dRadius * 2, 315, 45);
oRender.DrawLine( oPen, dX + dWidth, dY + dRadius - 1, dX + dWidth, dY + dHeight - dRadius + 1);
oRender.DrawArc( oPen, dX + dWidth - (dRadius * 2), dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2,0,90);
oRender.DrawLine( oPen, dX + dWidth - dRadius + 1, dY + dHeight, dX + dRadius - 1, dY + dHeight);
oRender.DrawArc( oPen, dX, dY + dHeight - (dRadius * 2), dRadius * 2, dRadius * 2, 90, 45);
delete oColor;
delete oPen;
delete oBrush;
}
return TRUE;
}
BOOL DrawFilmsBorder(BYTE* pBGRA, int nWidth, int nHeight, int nFilmColorMid, int nFilmColorBorder, float dBorderWidth, float dBorderHeight, BOOL bVertical)
{
BYTE* pBuffer = pBGRA;
pBuffer += 4 * nWidth * (nHeight - 1);
Gdiplus::Bitmap oImage( nWidth, nHeight, -4*nWidth, PixelFormat32bppARGB, pBuffer );
if( Gdiplus::Ok == oImage.GetLastStatus() )
{
Gdiplus::Graphics oRender( &oImage );
oRender.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
oRender.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
oRender.SetInterpolationMode(Gdiplus::InterpolationModeBilinear);
Gdiplus::Color clMid(nFilmColorMid, nFilmColorMid, nFilmColorMid);
Gdiplus::Color clBorder(nFilmColorBorder, nFilmColorBorder, nFilmColorBorder);
if ( bVertical )
{
Gdiplus::SolidBrush *oSolidBrush = new Gdiplus::SolidBrush(clMid);
oRender.FillRectangle(oSolidBrush, -1.0, -1.0, float(nWidth + 1.0), float(nHeight + 1.0));
Gdiplus::LinearGradientBrush* oGradBrush1 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( -1.0, -1.0), Gdiplus::PointF( dBorderWidth + 1, -1.0), clBorder, clMid);
oRender.FillRectangle(oGradBrush1, -1.0, -1.0, dBorderWidth + 1, float(nHeight) + 1);
Gdiplus::LinearGradientBrush* oGradBrush2 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( nWidth + 1, -1.0), Gdiplus::PointF( nWidth - dBorderWidth -2.0, -1.0), clBorder, clMid);
oRender.FillRectangle(oGradBrush2, nWidth - dBorderWidth - 1, -1.0, dBorderWidth + 1, float(nHeight) + 1);
delete oGradBrush1;
delete oGradBrush2;
delete oSolidBrush;
}
else
{
Gdiplus::SolidBrush *oSolidBrush = new Gdiplus::SolidBrush(clMid);
oRender.FillRectangle(oSolidBrush, -1.0, -1.0, float(nWidth + 1.0), float(nHeight + 1.0));
Gdiplus::LinearGradientBrush* oGradBrush1 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( -1.0, -1.0), Gdiplus::PointF( -1.0, dBorderHeight + 1), clBorder, clMid);
oRender.FillRectangle(oGradBrush1, -1.0, -1.0, float(nWidth) + 2.0, dBorderHeight + 1);
Gdiplus::LinearGradientBrush* oGradBrush2 = new Gdiplus::LinearGradientBrush(Gdiplus::PointF( -1.0, float(nHeight) + 1.0), Gdiplus::PointF( -1.0, nHeight - dBorderHeight - 1.0), clBorder, clMid);
oRender.FillRectangle(oGradBrush2, float(-1.0), float(nHeight - dBorderHeight - 1.0), float(nWidth + 2.0), float(dBorderHeight + 2.0));
delete oGradBrush1;
delete oGradBrush2;
delete oSolidBrush;
}
}
return TRUE;
}
public:
CUtility()
{
//g_sBurningPalette = 0;
g_pBurningMask = 0;
g_nBurningMaskWidth = -1;
g_nBurningMaskHeight = -1;
g_nRand = -1;
//InitBurningPalette();
g_pShotSource1 = 0;
g_pShotSource2 = 0;
g_nShotWidth = -1;
g_nShotHeight = -1;
g_nShotType = -1;
g_ppWipeRandomStrips = 0;
g_nWipeStripsCount = -1;
m_dwBaseRnd = ::rand();
}
~CUtility()
{
//if (g_sBurningPalette)
// delete[] g_sBurningPalette;
if (g_pBurningMask)
delete[] g_pBurningMask;
if (g_pShotSource1)
delete[] g_pShotSource1;
if (g_pShotSource2)
delete[] g_pShotSource2;
for(int nIndex = 0; nIndex < g_nWipeStripsCount; nIndex++ )
{
if(g_ppWipeRandomStrips[nIndex])
delete[] g_ppWipeRandomStrips[nIndex];
}
if (g_ppWipeRandomStrips)
delete g_ppWipeRandomStrips;
}
//void InitBurningPalette()
//{
// if (!g_sBurningPalette)
// g_sBurningPalette = new Ipp32s[768];
// int r,g,b;
// r = 256+256+255;
// g = 256+255;
// b = 255;
//
// for( int i = 255; i > 239; i-- )
// {
// g_sBurningPalette[i] = 255;
// g_sBurningPalette[i+256] = 255;
// g_sBurningPalette[i+512] = 255;
// }
//
// for(int i = 239; i > 15; i--)
// {
// g_sBurningPalette[i] = (r > 255) ? 255 : r;
// g_sBurningPalette[i+256] = (g > 255) ? 255 : g;
// g_sBurningPalette[i+512] = (b > 255) ? 255 : b;
// r = (r > 3) ? (r - 4) : 0;
// g = (g > 3) ? (g - 4) : 0;
// b = (b > 3) ? (b - 4) : 0;
// }
// for(int i = 15; i >= 0; i--)
// {
// g_sBurningPalette[i] = 0;
// g_sBurningPalette[i+256] = 0;
// g_sBurningPalette[i+512] = 0;
// }
//}
BOOL GenerateBurningMask( int nWidth, int nHeight )
{
if ((nWidth == g_nBurningMaskWidth) && (nHeight == g_nBurningMaskHeight) && (g_pBurningMask))
return TRUE;
if (g_pBurningMask)
delete []g_pBurningMask;
int nSize = nWidth * nHeight;
if( nSize <= 0 )
return FALSE;
CRandom rnd( m_dwBaseRnd );
g_nBurningMaskWidth = nWidth;
g_nBurningMaskHeight = nHeight;
g_pBurningMask = new BYTE[nSize];
if( !g_pBurningMask )
return FALSE;
ZeroMemory( g_pBurningMask, nSize );
Ipp16s* pBuffer = new Ipp16s[nSize];
if( !pBuffer )
{
delete [] g_pBurningMask;
g_pBurningMask = NULL;
return FALSE;
}
ZeroMemory( pBuffer, nSize * sizeof(Ipp16s) );
IppiSize roiSize = {nWidth, nHeight};
int nH = 512;
float fR = (float)nWidth;
for( int k = 2; k <= 5; k++ )
{
if( k != 5 )
nH /= 2;
else
nH = 2;
fR /= 3;
int nRadius = int(fR);
int nSquareRadius = int(fR*fR) + 1;
int nSign = rnd.Rand( 2 ) ? -nH : nH;
double dFactorRadius = 1.0 / nSquareRadius;
for( int p = 20 * k; p > 0; p-- )
{
int nCenterX = rnd.Rand( nWidth );
int nCenterY = rnd.Rand( nHeight );
int nX1 = nCenterX - nRadius;
int nX2 = nCenterX + nRadius;
int nY1 = nCenterY - nRadius;
int nY2 = nCenterY + nRadius;
if( nX1 < 0 ) nX1 = 0;
if( nX2 >= nWidth) nX2 = nWidth - 1;
if( nY1 < 0 ) nY1 = 0;
if( nY2 >= nHeight) nY2 = nHeight - 1;
Ipp16s* pItem = pBuffer + nY1 * nWidth + nX1;
int nStride = nWidth - (nX2 - nX1 + 1);
int dy = nY1 - nCenterY;
for( int nRow = nY2 - nY1; nRow >= 0; --nRow, pItem += nStride, ++dy )
{
int dx = nX1 - nCenterX;
for( int nPos = nX2 - nX1; nPos >= 0; --nPos, ++pItem, ++dx )
{
int dot = dx*dx + dy*dy;
if( dot <= nSquareRadius )
{
double dTemp = (nSquareRadius - dot) * dFactorRadius;
*pItem += Ipp16s(nSign * dTemp * dTemp);
}
}
}
}
}
Ipp16s nMin, nMax;
ippiMin_16s_C1R(pBuffer, 2*nWidth, roiSize, &nMin);
ippiMax_16s_C1R(pBuffer, 2*nWidth, roiSize, &nMax);
nMax = max( nMax, nMin + 1 );
float fFactor = 255.0f/float(nMax - nMin);
Ipp8u* pMaskItem = g_pBurningMask;
Ipp16s* pBufItem = pBuffer;
for( int nPos = nSize; nPos > 0; --nPos, ++pBufItem, ++pMaskItem )
{
*pMaskItem = fFactor * (*pBufItem - nMin);
}
delete[] pBuffer;
return TRUE;
}
void GenerateRand(int nRandMax)
{
if (-1 != g_nRand)
return;
CRandom rnd( m_dwBaseRnd );
g_nRand = rnd.Rand( nRandMax + 1 );
}
BOOL RunTetris( CTetrisFigure *pList, int nFiguresCount, float dFrame, BYTE *pBGRAResult, int nWidth, int nHeight, int nStep, int *pnBottomLineFigures)
{
if( !pList )
return FALSE;
if( dFrame * nFiguresCount < 1 )
{
return pList[0].Cpy( pBGRAResult, pList[0].m_nXCoorSource, nHeight - pnBottomLineFigures[0] + pList[0].m_nYCoorSource, nWidth, nHeight, 1 );
}
if( nStep + 2 == nFiguresCount )
{
for( int i = 0; i <= nFiguresCount; i++ )
{
pList[i].Cpy( pBGRAResult, pList[i].m_nXCoorSource, pList[i].m_nYCoorSource, nWidth, nHeight, (1 - dFrame) * nFiguresCount );
}
return TRUE;
}
pList[nStep].Cpy( pBGRAResult, pList[nStep].m_nXCoorSource, pList[nStep].m_nYCoorSource, nWidth, nHeight, 1);
nStep += 1;
if( dFrame * nFiguresCount < nStep + 1 )
{
pList[nStep].Cpy( pBGRAResult, pList[nStep].m_nXCoorSource, nHeight - pnBottomLineFigures[nStep] + pList[nStep].m_nYCoorSource, nWidth, nHeight, 1);
}
else
{
RunTetris( pList, nFiguresCount, dFrame, pBGRAResult, nWidth, nHeight, nStep, pnBottomLineFigures );
}
return TRUE;
}
BOOL CollapseTetris(CTetrisFigure *pList, int nFiguresCount, float dFrame, BYTE *pBGRAResult, int nWidth, int nHeight, int nStep, int *pnBottomLineFigures)
{
if(!pList)
return FALSE;
if( dFrame * nFiguresCount < 1 )
{
for( int i = 0; i <= nFiguresCount; i++ )
{
pList[i].Cpy( pBGRAResult, pList[i].m_nXCoorSource, pList[i].m_nYCoorSource, nWidth, nHeight, dFrame * nFiguresCount);
}
return TRUE;
}
nStep += 1;
if( nStep > nFiguresCount )
return TRUE;
if( dFrame * nFiguresCount < nStep + 1 )
{
pList[nStep - 1].Cpy( pBGRAResult, pList[nStep - 1].m_nXCoorSource, pList[nStep - 1].m_nYCoorSource + (pList[nStep - 1].m_nYCoorSource + pList[nStep - 1].m_nFigHeight) * (nStep - dFrame * nFiguresCount), nWidth, nHeight, 1);
for(int i = nStep; i <= nFiguresCount; i++)
{
pList[i].Cpy( pBGRAResult, pList[i].m_nXCoorSource, pList[i].m_nYCoorSource, nWidth, nHeight, 1);
}
}
else
{
CollapseTetris( pList, nFiguresCount, dFrame, pBGRAResult, nWidth, nHeight, nStep, pnBottomLineFigures );
}
return TRUE;
}
void GenerateShot(int nWidth, int nHeight, int nDirection, int nType, BOOL bInverse, BOOL bRapprochement, double dPercent, BYTE nBkColor, BYTE nFilmColorMid, BYTE nFilmColorBorder, BYTE nBlendColor)
{
if(g_pShotSource1 && g_pShotSource2 && nType == g_nShotType && g_nShotWidth == nWidth && g_nShotHeight == nHeight)
return;
if(g_pShotSource1)
delete[] g_pShotSource1;
if(g_pShotSource2)
delete[] g_pShotSource2;
g_nShotWidth = nWidth;
g_nShotHeight = nHeight;
g_nShotType = nType;
g_pShotSource1 = new BYTE[nWidth*nHeight*4];
g_pShotSource2 = new BYTE[nWidth*nHeight*4];
BOOL bVertical = (1 == nDirection? TRUE : FALSE);
if( 1 == nDirection )
{
double dUnit = nWidth / 35.;
const double dWidthPerf = 2.8 * dUnit;
const double dHeightPerf = 1.98 * dUnit;
const double dRadiusPerf = 0.5 * dUnit;
const double dStepPerf = (4.75 * dUnit < 10? 10 : 4.75 * dUnit);
const double dBorderWidth = 1.01 * dUnit;
const double dMidLineWidth = 0.4 * dUnit;
const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
double dStartY1 = 0;
double dStartY2 = 0;
double dAdditional = nHeight;
if ( bRapprochement )
dAdditional += -nHeight * dPercent / 2;
if ( !bInverse )
dStartY2 = dAdditional;
else
dStartY1 = dAdditional;
const double dFullBorderWidth = dBorderWidth + dWidthPerf + dMidLineWidth;
DrawFilmsBorder(g_pShotSource1, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, dFullBorderWidth, 0.1 * dFullBorderWidth, bVertical);
DrawFilmsBorder(g_pShotSource2, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, dFullBorderWidth, 0.1 * dFullBorderWidth, bVertical);
for ( double dCurY = - 2 * nHeight - dStartY1; dCurY < nHeight + dStepPerf; dCurY += dStepPerf)
{
DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, dBorderWidth, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, nWidth - dBorderWidth - dWidthPerf, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
}
for ( double dCurY = - 2 * nHeight - dStartY2; dCurY < nHeight + dStepPerf; dCurY += dStepPerf)
{
DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, dBorderWidth, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, nWidth - dBorderWidth - dWidthPerf, dCurY, dWidthPerf, dHeightPerf, dRadiusPerf);
}
}
else
{
double dUnit = nHeight / 35.;
const double dWidthPerf = 2.8 * dUnit;
const double dHeightPerf = 1.98 * dUnit;
const double dRadiusPerf = 0.5 * dUnit;
const double dStepPerf = (4.75 * dUnit < 10? 10 : 4.75 * dUnit);
const double dBorderWidth = 1.01 * dUnit;
const double dMidLineWidth = 0.4 * dUnit;
const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
double dStartX1 = 0;
double dStartX2 = 0;
double dAdditional = nWidth;
if ( bRapprochement )
dAdditional += -nWidth * dPercent / 2;
if ( !bInverse )
dStartX2 = dAdditional;
else
dStartX1 = dAdditional;
const double dFullBorderWidth = dBorderWidth + dWidthPerf + dMidLineWidth;
DrawFilmsBorder(g_pShotSource1, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, 0.1 * dFullBorderWidth, dFullBorderWidth, bVertical);
DrawFilmsBorder(g_pShotSource2, nWidth, nHeight, nFilmColorMid, nFilmColorBorder, 0.1 * dFullBorderWidth, dFullBorderWidth, bVertical);
for ( double dCurX = - 2*nWidth - dStartX1; dCurX < nWidth + dStepPerf; dCurX += dStepPerf)
{
DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, dCurX, dBorderWidth, dHeightPerf, dWidthPerf, dRadiusPerf);
DrawFilmsPerf(g_pShotSource1, nWidth, nHeight, nBlendColor, nBkColor, dCurX, nHeight - dBorderWidth - dWidthPerf, dHeightPerf, dWidthPerf, dRadiusPerf);
}
for ( double dCurX = - 2*nWidth - dStartX2; dCurX < nWidth + dStepPerf; dCurX += dStepPerf)
{
DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, dCurX, dBorderWidth, dHeightPerf, dWidthPerf, dRadiusPerf);
DrawFilmsPerf(g_pShotSource2, nWidth, nHeight, nBlendColor, nBkColor, dCurX, nHeight - dBorderWidth - dWidthPerf, dHeightPerf, dWidthPerf, dRadiusPerf);
}
}
return;
//if( 1 == nDirection)
//{
// const double dUnit = nWidth / 35.;
// const double dWidthPerf = 2.8 * dUnit;
// const double dHeightPerf = 1.98 * dUnit;
// const double dRadiusPerf = 0.5 * dUnit;
// const double dStepPerf = 4.75 * dUnit;
// const double dBorderWidth = 1.01 * dUnit;
// const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
//
// BYTE *pBuffer = g_pShotSource1;
// for (int nIndex = 0; nIndex < 2; nIndex++ )
// {
// if ( 0 == nIndex )
// pBuffer = g_pShotSource1;
// else
// pBuffer = g_pShotSource2;
// for(int nYIndex = 0; nYIndex < nHeight; nYIndex++)
// {
// int nAdditional = nHeight;
// if ( bRapprochement )
// {
// nAdditional += - nHeight * dPercent / 2;
// }
// int nYIndexS1 = nYIndex;
// int nYIndexS2 = nYIndex + nAdditional;
// if(!bInverse)
// {
// nYIndexS1 += nAdditional;
// nYIndexS2 -= nAdditional;
// }
// int nIndexS;
// if ( 0 == nIndex )
// nIndexS = nYIndexS1;
// else
// nIndexS = nYIndexS2;
// for(int nXIndex = 0; nXIndex < nWidth; nXIndex++)
// {
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// const int nYStepCount = nIndexS % int(dStepPerf); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD> = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
// const int nFirstFocus = dBorderWidth + dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// const int nSecondFocus = dBorderWidth + dWidthPerf - dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// const int nFullBorderWidth = dBorderWidth + dWidthPerf; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>)
// const double dSqrRadiusPerf = dRadiusPerf * dRadiusPerf;
// const double dSqrDecRadiusPerf = (dRadiusPerf - 1) * (dRadiusPerf - 1);
// const double dSqrIncRadiusPerf = (dRadiusPerf + 1) * (dRadiusPerf + 1);
// if( nXIndex <= dBorderWidth || nXIndex > nWidth - dBorderWidth ||
// ((( nXIndex > dBorderWidth && nXIndex <= nFullBorderWidth) || ( nXIndex >= nWidth - nFullBorderWidth && nXIndex < nWidth - dBorderWidth)) && nYStepCount > int(dHeightPerf) ) ||
// /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>*/ /*<2A><><EFBFBD><EFBFBD><EFBFBD>*/
// (nXIndex <= nFirstFocus && (nYStepCount) <= dRadiusFactor && (nXIndex - nFirstFocus) * (nXIndex - nFirstFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
// (nXIndex <= nFirstFocus && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - nFirstFocus) * (nXIndex - nFirstFocus) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
// (nXIndex >= nSecondFocus && nXIndex <= nFullBorderWidth && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - nSecondFocus) * (nXIndex - nSecondFocus) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
// (nXIndex >= nSecondFocus && nXIndex <= nFullBorderWidth && (nYStepCount) <= dRadiusFactor && (nXIndex - nSecondFocus) * (nXIndex - nSecondFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
// /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
// (nXIndex <= nWidth - nSecondFocus && nXIndex >= nWidth - nFullBorderWidth && (nYStepCount) <= dRadiusFactor && (nXIndex - (nWidth - nSecondFocus)) * (nXIndex - (nWidth - nSecondFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
// (nXIndex <= nWidth - nSecondFocus && nXIndex >= nWidth - nFullBorderWidth && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - (nWidth - nSecondFocus)) * (nXIndex - (nWidth - nSecondFocus)) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
// (nXIndex >= nWidth - nFirstFocus && (nYStepCount) >= dHeightPerf - dRadiusFactor && (nXIndex - (nWidth - nFirstFocus)) * (nXIndex - (nWidth - nFirstFocus)) + (nYStepCount - dHeightPerf + dRadiusFactor) * (nYStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
// (nXIndex >= nWidth - nFirstFocus && (nYStepCount) <= dRadiusFactor && (nXIndex - (nWidth - nFirstFocus)) * (nXIndex - (nWidth - nFirstFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor) > dSqrRadiusPerf))
// {
// for(int i = 0; i < 3; i++)
// {
// if(nXIndex <= nFullBorderWidth)
// {
// *pBuffer = nFilmColorBorder * (1 - double(nXIndex) / double (nFullBorderWidth) ) + nFilmColorMid * (double(nXIndex) / double (nFullBorderWidth));
// }
// else
// {
// *pBuffer = nFilmColorBorder * double(nXIndex - (nWidth - nFullBorderWidth))/double(nFullBorderWidth) + nFilmColorMid * (1 - double(nXIndex - (nWidth - nFullBorderWidth))/double(nFullBorderWidth));
// }
// pBuffer++;
// }
// *pBuffer = 255;
// pBuffer++;
// }
// else if( nXIndex > nFullBorderWidth && nXIndex < nWidth - nFullBorderWidth)
// {
// for(int i = 0; i < 3; i++)
// {
// *pBuffer = nFilmColorMid;
// pBuffer++;
// }
// *pBuffer = 255;
// pBuffer++;
// }
// else
// {
// const double dLeftFirstSqrRad = ( nXIndex - nFirstFocus) * ( nXIndex - nFirstFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
// const double dLeftSecondSqrRad = ( nXIndex - nSecondFocus) * ( nXIndex - nSecondFocus) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
// const double dRightFirstSqrRad = ( nXIndex - ( nWidth - nSecondFocus)) * ( nXIndex - ( nWidth - nSecondFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
// const double dRightSecondSqrRad = ( nXIndex - ( nWidth - nFirstFocus)) * ( nXIndex - ( nWidth - nFirstFocus)) + (nYStepCount - dRadiusFactor) * (nYStepCount - dRadiusFactor);
//
// if //<2F><><EFBFBD><EFBFBD><EFBFBD>
// ( nXIndex >= dBorderWidth &&
// (( nYStepCount == 0 && nXIndex <= nSecondFocus && nXIndex >= nFirstFocus)
// ||
// ( dLeftFirstSqrRad > dSqrDecRadiusPerf && dLeftFirstSqrRad < dSqrIncRadiusPerf
// && nXIndex <= nFirstFocus && nYStepCount <= dRadiusFactor)
// ||
// ( dLeftSecondSqrRad > dSqrDecRadiusPerf && dLeftSecondSqrRad < dSqrIncRadiusPerf
// && nXIndex >= nSecondFocus && nXIndex <= nFullBorderWidth && nYStepCount <= dRadiusFactor)
// ||
// (nXIndex > nFullBorderWidth - 1 && nXIndex < nFullBorderWidth + 1 )) ||
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// nXIndex <= nWidth - dBorderWidth &&
// (( nYStepCount == 0 && nXIndex >= nWidth - nSecondFocus && nXIndex <= nWidth - nFirstFocus )
// ||
// ( dRightFirstSqrRad > dSqrDecRadiusPerf && dRightFirstSqrRad < dSqrIncRadiusPerf
// && nXIndex >= nWidth - nFullBorderWidth && nXIndex <= nWidth - nSecondFocus && nYStepCount <= dRadiusFactor)
// ||
// ( dRightSecondSqrRad > dSqrDecRadiusPerf && dRightSecondSqrRad < dSqrIncRadiusPerf
// && nXIndex >= nWidth - nFirstFocus && nYStepCount <= dRadiusFactor)
// ||
// (nXIndex > nWidth - dBorderWidth - 1 && nXIndex < nWidth - dBorderWidth + 1 ))
// )
// {
// for(int i = 0; i < 3; i++)
// {
// *pBuffer = nBlendColor;
// *pBuffer++;
// }
// *pBuffer = 255;
// pBuffer++;
// }
// else
// {
// for(int i = 0; i < 3; i++)
// {
// *pBuffer = nBkColor;
// *pBuffer++;
// }
// *pBuffer = 255;
// pBuffer++;
// }
// }
// }
// }
// }
//}
//else
//{
// const double dUnit = nHeight / 35.;
// const double dWidthPerf = 2.8 * dUnit;
// const double dHeightPerf = 1.98 * dUnit;
// const double dRadiusPerf = 0.5 * dUnit;
// const double dStepPerf = 4.75 * dUnit;
// const double dBorderWidth = 1. * dUnit;
// const double dRadiusFactor = 1.3 * sqrt(2.) / 2 * dRadiusPerf;
// BYTE *pBuffer = g_pShotSource1;
// for (int nIndex = 0; nIndex < 2; nIndex++ )
// {
// if ( 0 == nIndex )
// pBuffer = g_pShotSource1;
// else
// pBuffer = g_pShotSource2;
// for(int nYIndex = 0; nYIndex < nHeight; nYIndex++)
// {
// for(int nXIndex = 0; nXIndex < nWidth; nXIndex++)
// {
// int nAdditional = nWidth;
// if ( bRapprochement )
// {
// nAdditional -= nWidth * dPercent / 2;
// }
// int nXIndexS2 = nXIndex;
// int nXIndexS1 = nXIndex + nAdditional;
// if(!bInverse)
// {
// nXIndexS2 += nAdditional;
// nXIndexS1 -= nAdditional;
// }
// int nIndexS = 0;
// if ( 0 == nIndex)
// nIndexS = nXIndexS1;
// else
// nIndexS = nXIndexS2;
// //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// const int nXStepCount = nIndexS % int(dStepPerf); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>(<28><><EFBFBD> = <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
// const int nFirstFocus = dBorderWidth + dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// const int nSecondFocus = dBorderWidth + dWidthPerf - dRadiusFactor; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// const int nFullBorderWidth = dBorderWidth + dWidthPerf; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> + <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>)
// const double dSqrRadiusPerf = dRadiusPerf * dRadiusPerf;
// const double dSqrDecRadiusPerf = (dRadiusPerf - 1) * (dRadiusPerf - 1);
// const double dSqrIncRadiusPerf = (dRadiusPerf + 1) * (dRadiusPerf + 1);
// if( nYIndex <= dBorderWidth || nYIndex >= nHeight - dBorderWidth ||
// ((( nYIndex > dBorderWidth && nYIndex <= nFullBorderWidth) || ( nYIndex >= nHeight - nFullBorderWidth && nYIndex < nHeight - dBorderWidth)) && nXStepCount > int(dHeightPerf) ) ||
// /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>*/ /*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
// (nYIndex <= nFirstFocus && nXStepCount <= dRadiusFactor && (nYIndex - nFirstFocus) * (nYIndex - nFirstFocus) + (nXStepCount - dRadiusFactor) * (nXStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
// (nYIndex <= nFirstFocus && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - nFirstFocus) * (nYIndex - nFirstFocus) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
// (nYIndex >= nSecondFocus && nYIndex <= dBorderWidth + dWidthPerf && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - nSecondFocus) * (nYIndex - nSecondFocus) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
// (nYIndex >= nSecondFocus && nYIndex <= dBorderWidth + dWidthPerf && nXStepCount <= dRadiusFactor && (nYIndex - nSecondFocus) * (nYIndex - nSecondFocus) + (nXStepCount - dRadiusFactor) * (nXStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
// /*<2A><><EFBFBD><EFBFBD><EFBFBD>*/
// (nYIndex <= nHeight - nSecondFocus && nYIndex >= nHeight - dBorderWidth - dWidthPerf && nXStepCount <= dRadiusFactor && (nYIndex - (nHeight - nSecondFocus)) * (nYIndex - (nHeight - nSecondFocus)) + (nXStepCount - dRadiusFactor) * (nXStepCount - dRadiusFactor) > dSqrRadiusPerf) ||
// (nYIndex <= nHeight - nSecondFocus && nYIndex >= nHeight - dBorderWidth - dWidthPerf && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - (nHeight - nSecondFocus)) * (nYIndex - (nHeight - nSecondFocus)) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf) ||
// (nYIndex >= nHeight - nFirstFocus && nXStepCount >= dHeightPerf - dRadiusFactor && (nYIndex - (nHeight - nFirstFocus)) * (nYIndex - (nHeight - nFirstFocus)) + (nXStepCount - dHeightPerf + dRadiusFactor) * (nXStepCount - dHeightPerf + dRadiusFactor) > dSqrRadiusPerf ) ||
// (nYIndex >= nHeight - nFirstFocus && nXStepCount <= dRadiusFactor && (nYIndex - (nHeight - nFirstFocus)) * (nYIndex - (nHeight - nFirstFocus)) + (nXStepCount - dRadiusFactor) * (nXStepCount- dRadiusFactor) > dSqrRadiusPerf))
// {
// for(int i = 0; i < 3; i++)
// {
// if( nYIndex <= nFullBorderWidth)
// {
// *pBuffer = nFilmColorBorder * (1 - nYIndex / (dBorderWidth + dWidthPerf)) + nFilmColorMid * (nYIndex / (dBorderWidth + dWidthPerf));
// //double dKoef = double(nYIndex) / double(nFullBorderWidth);
// //*pBuffer = nFilmColorBorder * (1 - dKoef ) + nFilmColorMid * dKoef;
// }
// else
// {
// *pBuffer = nFilmColorBorder * (nYIndex - (nHeight - (dBorderWidth + dWidthPerf))) / (dBorderWidth + dWidthPerf) + nFilmColorMid * (1 - (nYIndex - (nHeight - (dBorderWidth + dWidthPerf)))/ (dBorderWidth + dWidthPerf));
// //double dKoef = double(nYIndex - (nHeight - nFullBorderWidth)) / double(nFullBorderWidth);
// //*pBuffer = nFilmColorBorder * dKoef + nFilmColorMid * (1 - dKoef);
// }
// pBuffer++;
// }
// *pBuffer = 255;
// pBuffer++;
// }
// else if(nYIndex > nFullBorderWidth && nYIndex < nHeight - nFullBorderWidth)
// {
// for(int i = 0; i < 3; i++)
// {
// *pBuffer = nFilmColorMid;
// pBuffer++;
// }
// *pBuffer = 255;
// pBuffer++;
// }
// else
// {
// const double dTopFirstSqrRad = ( nYIndex - nFirstFocus) * ( nYIndex - nFirstFocus) + (nXStepCount - dHeightPerf + dRadiusFactor ) * ( nXStepCount - dHeightPerf + dRadiusFactor);
// const double dTopSecondSqrRad = ( nYIndex - nFirstFocus) * ( nYIndex - nFirstFocus) + (nXStepCount - dRadiusFactor) * ( nXStepCount - dRadiusFactor);
// const double dBottomFirstSqrRad = ( nYIndex - ( nHeight - nSecondFocus)) * ( nYIndex - ( nHeight - nSecondFocus)) + (nXStepCount - dHeightPerf + dRadiusFactor) * ( nXStepCount - dHeightPerf + dRadiusFactor);
// const double dBottomSecondSqrRad = ( nYIndex - ( nHeight - nSecondFocus)) * ( nYIndex - ( nHeight - nSecondFocus)) + (nXStepCount - dRadiusFactor) * ( nXStepCount - dRadiusFactor);
// if(
// nYIndex >= dBorderWidth &&nYIndex <= nHeight - dBorderWidth &&
// ((( nXStepCount > dHeightPerf - 1 && nXStepCount < dHeightPerf + 1 && nYIndex > nFirstFocus - 10/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/)
// ||
// ( dTopFirstSqrRad > dSqrDecRadiusPerf && dTopFirstSqrRad < dSqrIncRadiusPerf
// && nYIndex < nFirstFocus && nXStepCount >= dHeightPerf - dRadiusFactor)
// ||
// ( dTopSecondSqrRad > dSqrDecRadiusPerf && dTopSecondSqrRad < dSqrIncRadiusPerf
// && nYIndex < nFirstFocus && nXStepCount <= dRadiusFactor)
// ||
// (nYIndex < dBorderWidth + 1 && nYIndex > dBorderWidth - 1) )
// ||
// (( nXStepCount > dHeightPerf - 1 && nXStepCount < dHeightPerf + 1 && nYIndex >= nHeight - nSecondFocus )
// ||
// ( dBottomFirstSqrRad > dSqrDecRadiusPerf && dBottomFirstSqrRad < dSqrIncRadiusPerf
// && nYIndex >= nHeight - nFullBorderWidth && nYIndex <= nHeight - nSecondFocus && nXStepCount >= dHeightPerf - dRadiusFactor) ||
// ( dBottomSecondSqrRad > dSqrDecRadiusPerf && dBottomSecondSqrRad < dSqrIncRadiusPerf
// && nYIndex >= nHeight - nFullBorderWidth && nYIndex <= nHeight - nSecondFocus && nXStepCount <= dRadiusFactor)
// ||
// (nYIndex < nHeight - nFullBorderWidth + 1 && nYIndex > nHeight - nFullBorderWidth - 1 ) )))
// {
// for(int i = 0; i < 3; i++)
// {
// *pBuffer = nBlendColor;
// pBuffer++;
// }
// }
// else
// {
// for(int i = 0; i < 3; i++)
// {
// *pBuffer = nBkColor;
// pBuffer++;
// }
// }
// *pBuffer = 255;
// pBuffer++;
// }
// }
// }
// }
//}
//return;
}
void GenerateWipeStrips(int nCount)
{
if ( g_ppWipeRandomStrips && g_nWipeStripsCount == nCount )
return;
if ( g_ppWipeRandomStrips )
{
for(int nIndex = 0; nIndex < g_nWipeStripsCount; nIndex++ )
{
if(g_ppWipeRandomStrips[nIndex])
delete[] g_ppWipeRandomStrips[nIndex];
}
if (g_ppWipeRandomStrips)
delete[] g_ppWipeRandomStrips;
}
g_nWipeStripsCount = nCount;
CRandom rnd( m_dwBaseRnd );
g_ppWipeRandomStrips = new int*[nCount];
for( int nIndex = 0; nIndex < nCount; nIndex++ )
{
g_ppWipeRandomStrips[nIndex] = new int[256];
}
for(int nCountIndex = 0; nCountIndex < nCount; nCountIndex++ )
{
for(int nTime = 0; nTime < 256; nTime++)
{
g_ppWipeRandomStrips[nCountIndex][nTime] = rnd.Rand( 100 );
}
}
return;
}
public:
int g_nBurningMaskWidth;
int g_nBurningMaskHeight;
//Ipp32s* g_sBurningPalette;
Ipp8u* g_pBurningMask;
int g_nRand;
BYTE* g_pShotSource1;
BYTE* g_pShotSource2;
int g_nShotWidth;
int g_nShotHeight;
int g_nShotType;
int** g_ppWipeRandomStrips;
int g_nWipeStripsCount;
};
class CMaskGraduate
{
public:
DWORD m_dwBaseRnd;
public:
CMaskGraduate()
{
m_nMaskWidth = -1;
m_nMaskHeight = -1;
m_nMaskType = -1;
g_nTilesX = -1;
g_nTilesY = -1;
m_pMask = 0;
g_nSize = 0;
g_pGraduation = NULL;
m_dwBaseRnd = ::rand();
}
~CMaskGraduate()
{
if ( m_pMask )
delete []m_pMask;
if ( g_pGraduation )
delete []g_pGraduation;
}
void GenerateMask(int nWidth, int nHeight, int nType)
{
if ((nWidth == m_nMaskWidth) && (nHeight == m_nMaskHeight) && (m_pMask) && (nType == m_nMaskType))
return ;
if (m_pMask)
delete []m_pMask;
int nSize = nWidth * nHeight;
if( !nSize )
return;
m_nMaskType = nType;
m_nMaskWidth = nWidth;
m_nMaskHeight = nHeight;
if ( Constants::c_nGraduateSideLeftToRight <= nType && Constants::c_nGraduateCornerRightTop >= nType)
{
g_nTilesX = 5;
g_nTilesY = 5;
}
else if ( Constants::c_nGraduateClockBottomClockwise <= nType && Constants::c_nGraduateClock3AnglesReverse >= nType )
{
g_nTilesX = 2;
g_nTilesY = 2;
}
g_nTileWidth = nWidth / g_nTilesX;
g_nTileHeight = nHeight / g_nTilesY;
m_pMask = new Ipp16u[nSize];
if( !m_pMask )
return;
::memset( m_pMask, 255, nSize * sizeof(Ipp16u) );
RandomShuffle(g_nTilesX * g_nTilesY);
if ( Constants::c_nGraduateSideLeftToRight <= nType && Constants::c_nGraduateCornerRightTop >= nType)
WipeSide();
else if ( Constants::c_nGraduateClockBottomClockwise <= nType && Constants::c_nGraduateClock3AnglesReverse >= nType )
Clock();
return;
}
protected:
void WipeSide()
{
CBuffer<double> oTable( m_nMaskWidth + m_nMaskHeight );
if( oTable.IsEmpty() )
{
::memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight * sizeof(Ipp16u) );
return;
}
double dFactorX = 1.0 / g_nTileWidth;
double dFactorY = 1.0 / g_nTileHeight;
double* pTable = oTable.GetPtr();
int nTileX = -1;
for( int i = 0; i < m_nMaskWidth; ++i, ++pTable )
{
if( Constants::c_nGraduateSideTopToBottom == m_nMaskType ||
Constants::c_nGraduateSideBottomToTop == m_nMaskType )
{
*pTable = 0;
}
else
{
if( ++nTileX >= g_nTileWidth )
nTileX = 0;
*pTable = nTileX * dFactorX;
}
}
int nTileY = -1;
for( int i = 0; i < m_nMaskHeight; ++i, ++pTable )
{
if( Constants::c_nGraduateSideLeftToRight == m_nMaskType ||
Constants::c_nGraduateSideRightToLeft == m_nMaskType )
{
*pTable = 0;
}
else
{
if( ++nTileY >= g_nTileHeight )
nTileY = 0;
*pTable = nTileY * dFactorY;
}
}
if( Constants::c_nGraduateSideRightToLeft == m_nMaskType ||
Constants::c_nGraduateCornerRightTop == m_nMaskType ||
Constants::c_nGraduateCornerRightBottom == m_nMaskType )
{
double* pTableX = oTable.GetPtr();
for( int i = 0; i < m_nMaskWidth; ++i, ++pTableX )
{
*pTableX = 1 - *pTableX;
}
}
if( Constants::c_nGraduateSideTopToBottom == m_nMaskType ||
Constants::c_nGraduateCornerLeftTop == m_nMaskType ||
Constants::c_nGraduateCornerRightTop == m_nMaskType )
{
double* pTableY = oTable.GetPtr() + m_nMaskWidth;
for( int i = 0; i < m_nMaskHeight; ++i, ++pTableY )
{
*pTableY = 1 - *pTableY;
}
}
double dFactor = 65535.0 / (g_nTilesX * g_nTilesY);
Ipp16u* pBuffer = m_pMask;
double* pTableY = oTable.GetPtr() + m_nMaskWidth;
for( int nY = 0; nY < m_nMaskHeight; ++nY, ++pTableY )
{
int* pStensil = g_pGraduation + nY / g_nTileHeight * g_nTilesX;
double* pTableX = oTable.GetPtr();
for( int nX = 0; nX < m_nMaskWidth; ++nX, ++pTableX )
{
int nCurTileX = nX / g_nTileWidth;
*pBuffer++ = Ipp16u((max(pTableX[0], pTableY[0]) + pStensil[nCurTileX]) * dFactor);
}
}
}
void Clock()
{
Ipp16u* pBuffer = m_pMask;
int nAnglesCount = 1;
double dStartAngle = 0;
if( Constants::c_nGraduateClockLeftOpposite == m_nMaskType ||
Constants::c_nGraduateClockLeftClockwise == m_nMaskType ||
Constants::c_nGraduateClockLeftReverse == m_nMaskType )
{
dStartAngle = 180 * IPP_PI180;
}
else
if( Constants::c_nGraduateClockTopOpposite == m_nMaskType ||
Constants::c_nGraduateClockTopClockwise == m_nMaskType ||
Constants::c_nGraduateClockTopReverse == m_nMaskType )
{
dStartAngle = 270 * IPP_PI180;
}
else
if( Constants::c_nGraduateClockBottomOpposite == m_nMaskType ||
Constants::c_nGraduateClockBottomClockwise == m_nMaskType ||
Constants::c_nGraduateClockBottomReverse == m_nMaskType )
{
dStartAngle = 90 * IPP_PI180;
}
else
if( Constants::c_nGraduateClock2AnglesClockwise == m_nMaskType ||
Constants::c_nGraduateClock2AnglesReverse == m_nMaskType )
{
dStartAngle = 270 * IPP_PI180;
nAnglesCount = 2;
}
else
if( Constants::c_nGraduateClock3AnglesClockwise == m_nMaskType ||
Constants::c_nGraduateClock3AnglesReverse == m_nMaskType )
{
dStartAngle = 270 * IPP_PI180;
nAnglesCount = 3;
}
double dFactor = 1;
int nOffset = 0;
BOOL bReverse = FALSE;
if( Constants::c_nGraduateClockRightOpposite == m_nMaskType ||
Constants::c_nGraduateClockLeftOpposite == m_nMaskType ||
Constants::c_nGraduateClockTopOpposite == m_nMaskType ||
Constants::c_nGraduateClockBottomOpposite == m_nMaskType)
{
bReverse = TRUE;
nOffset = 0;
dFactor = 1.0 / IPP_PI;
}
else
if( Constants::c_nGraduateClockRightClockwise == m_nMaskType ||
Constants::c_nGraduateClockLeftClockwise == m_nMaskType ||
Constants::c_nGraduateClockTopClockwise == m_nMaskType ||
Constants::c_nGraduateClockBottomClockwise == m_nMaskType ||
Constants::c_nGraduateClock2AnglesClockwise == m_nMaskType ||
Constants::c_nGraduateClock3AnglesClockwise == m_nMaskType )
{
nOffset = 1;
dFactor = -1.0 / IPP_2PI;
}
else
if( Constants::c_nGraduateClockRightReverse == m_nMaskType ||
Constants::c_nGraduateClockLeftReverse == m_nMaskType ||
Constants::c_nGraduateClockTopReverse == m_nMaskType ||
Constants::c_nGraduateClockBottomReverse == m_nMaskType ||
Constants::c_nGraduateClock2AnglesReverse == m_nMaskType ||
Constants::c_nGraduateClock3AnglesReverse == m_nMaskType )
{
dFactor = 1.0 / IPP_2PI;
}
double dValueFactor = 65535.0 / (g_nTilesX * g_nTilesY);
struct TTile
{
int tile;
float x;
};
CBuffer<TTile> table( m_nMaskWidth );
if( table.IsEmpty() )
{
::memset( pBuffer, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
for( int i = 0; i < m_nMaskWidth; ++i )
{
table[i].tile = i / g_nTileWidth;
table[i].x = i - (table[i].tile + 0.5) * g_nTileWidth;
}
for( int nY = 0; nY < m_nMaskHeight; nY++ )
{
int nCurTileY = nY / g_nTileHeight;
double dY = nY - (nCurTileY + 0.5) * g_nTileHeight;
nCurTileY *= g_nTilesX;
TTile* pTile = table.GetPtr();
for( int nX = 0; nX < m_nMaskWidth; ++nX, ++pTile )
{
double dAngle = atan2( dY, double(pTile->x) );
if( dAngle < 0 )
dAngle += IPP_2PI;
dAngle += dStartAngle;
dAngle *= nAnglesCount;
dAngle -= int(dAngle * (1.0 / IPP_2PI)) * IPP_2PI;
double dCur = nOffset + dAngle * dFactor;
if( bReverse )
{
if( dAngle > IPP_PI )
dCur = 2 - dCur;
}
*pBuffer++ = Ipp16u((dCur + g_pGraduation[pTile->tile + nCurTileY]) * dValueFactor);
}
}
}
BOOL RandomShuffle(int nSize)
{
if (nSize < 1)
return FALSE;
if (nSize == g_nSize)
return TRUE;
g_nSize = nSize;
g_pGraduation = new int[g_nSize];
if (NULL == g_pGraduation)
return FALSE;
for (int index = 0; index < g_nSize; ++index)
g_pGraduation[index] = index;
//srand( 1 );
CRandom rnd( m_dwBaseRnd );
for (int index = 0; index < g_nSize; ++index)
{
int nSwapIndex = rnd.Rand( g_nSize );
int nSwapValue = g_pGraduation[nSwapIndex];
g_pGraduation[nSwapIndex] = g_pGraduation[index];
g_pGraduation[index] = nSwapValue;
}
return TRUE;
}
public:
Ipp16u* m_pMask;
protected:
int m_nMaskWidth;
int m_nMaskHeight;
int g_nSize;
int* g_pGraduation;
int m_nMaskType;
int g_nTilesX;
int g_nTilesY;
int g_nTileWidth;
int g_nTileHeight;
};
class CMask
{
public:
DWORD m_dwBaseRnd;
CMask()
{
m_nMaskWidth = -1;
m_nMaskHeight = -1;
m_nMaskType = -1;
m_pMask = 0;
m_dwBaseRnd = ::rand();
}
~CMask()
{
if ( m_pMask )
delete []m_pMask;
}
void GenerateMask(int nWidth, int nHeight, int nType)
{
if ((nWidth == m_nMaskWidth) && (nHeight == m_nMaskHeight) && (m_pMask) && (nType == m_nMaskType))
return ;
if (m_pMask)
delete []m_pMask;
int nSize = nWidth * nHeight;
if( !nSize )
return;
m_nMaskType = nType;
m_nMaskWidth = nWidth;
m_nMaskHeight = nHeight;
m_pMask = new BYTE[nSize];
if( !m_pMask )
return;
ZeroMemory( m_pMask, nSize );
if ( Constants::c_nBowTileHorizontal == nType || Constants::c_nBowTileSmoothHorizontal == nType ||
Constants::c_nBowTileVertical == nType || Constants::c_nBowTileSmoothVertical == nType)
BowTile();
else
if ( Constants::c_nDiagonalBoxOut == nType || Constants::c_nDiagonalSmoothBoxOut == nType)
DiagonalBoxOut();
else
if ( Constants::c_nDiagonalCrossOut == nType || Constants::c_nDiagonalSmoothCrossOut == nType)
DiagonalCrossOut();
else
if ( Constants::c_nDiagonalDownRight == nType || Constants::c_nDiagonalSmoothDownRight == nType ||
Constants::c_nDiagonalDownLeft == nType || Constants::c_nDiagonalSmoothDownLeft == nType ||
Constants::c_nDiagonalUpRight == nType || Constants::c_nDiagonalSmoothUpRight == nType ||
Constants::c_nDiagonalUpLeft == nType || Constants::c_nDiagonalSmoothUpLeft == nType)
Diagonal();
else
if ( Constants::c_nFunIn == nType || Constants::c_nFunSmoothIn == nType)
FunIn();
else
if ( Constants::c_nFunOut == nType || Constants::c_nFunSmoothOut == nType)
FunOut();
else
if ( Constants::c_nFunUp == nType || Constants::c_nFunSmoothUp == nType)
FunUp();
else
if ( Constants::c_nFilledVDown == nType || Constants::c_nFilledVSmoothDown == nType ||
Constants::c_nFilledVRight == nType || Constants::c_nFilledVSmoothRight == nType ||
Constants::c_nFilledVLeft == nType || Constants::c_nFilledVSmoothLeft == nType ||
Constants::c_nFilledVUp == nType || Constants::c_nFilledVSmoothUp == nType )
FilledV();
else
if ( Constants::c_nInsertDownLeft == nType || Constants::c_nInsertSmoothDownLeft == nType ||
Constants::c_nInsertDownRight == nType || Constants::c_nInsertSmoothDownRight == nType ||
Constants::c_nInsertUpLeft == nType || Constants::c_nInsertSmoothUpLeft == nType ||
Constants::c_nInsertUpRight == nType || Constants::c_nInsertSmoothUpRight == nType )
Insert();
else
if ( Constants::c_nRevealUp == nType || Constants::c_nRevealDown == nType ||
Constants::c_nRevealLeft == nType || Constants::c_nRevealRight == nType)
Reveal();
else
if ( Constants::c_nSplitHorizontal == nType || Constants::c_nSplitSmoothHorizontal == nType ||
Constants::c_nSplitVertical == nType || Constants::c_nSplitSmoothVertical == nType )
Split();
else
if ( Constants::c_nSweepIn == nType || Constants::c_nSweepSmoothIn == nType )
SweepIn();
else
if ( Constants::c_nSweepOut == nType || Constants::c_nSweepSmoothOut == nType )
SweepOut();
else
if ( Constants::c_nSweepUp == nType || Constants::c_nSweepSmoothUp == nType )
SweepUp();
else
if ( Constants::c_nZigZagSmoothVertical == nType || Constants::c_nZigZagVertical == nType )
ZigZagVer();
else
if ( Constants::c_nZigZagSmoothHorizontal == nType || Constants::c_nZigZagHorizontal == nType )
ZigZagHor();
else
if ( Constants::c_nPinwheelCurvedSN5A <= nType && Constants::c_nPinwheelPropeller12Smooth >= nType )
PinwheelCurved();
else if ( Constants::c_nWipeSmoothDiamond == nType || Constants::c_nWipeSmoothDiamondIn == nType)
Diamonds( 1, 1, nType != Constants::c_nWipeSmoothDiamondIn );
else if ( Constants::c_nWipeSmoothDiamonds == nType || Constants::c_nWipeDiamonds == nType )
Diamonds( 5, 5, TRUE );
else if ( Constants::c_nWipeSmoothCircle == nType || Constants::c_nWipeSmoothCircleIn == nType )
Circles( 1, nType != Constants::c_nWipeSmoothCircleIn );
else if ( Constants::c_nWipeSmoothCircles == nType || Constants::c_nWipeCircles == nType)
Circles( 5, TRUE );
else if ( Constants::c_nWipeSmoothWideStar == nType || Constants::c_nWipeSmoothNarrowStar == nType ||
Constants::c_nWipeSmoothWideFlower == nType || Constants::c_nWipeSmoothNarrowFlower == nType)
StarFlower();
else if ( Constants::c_nWipeSmoothWideStars == nType || Constants::c_nWipeSmoothNarrowStars == nType ||
Constants::c_nWipeSmoothWideFlowers == nType || Constants::c_nWipeSmoothNarrowFlowers == nType)
StarsFlowers();
else if ( Constants::c_nWipeSmoothWideKeyHole == nType || Constants::c_nWipeSmoothNarrowKeyHole == nType)
KeyHole();
else if ( Constants::c_nWipeSmoothWideKeyHoles == nType || Constants::c_nWipeSmoothNarrowKeyHoles == nType)
KeyHoles();
else if ( Constants::c_nCircleCornerLeftBottom == nType || Constants::c_nCircleCornerSmoothLeftBottom == nType ||
Constants::c_nCircleCornerLeftTop == nType || Constants::c_nCircleCornerSmoothLeftTop == nType ||
Constants::c_nCircleCornerRightBottom == nType || Constants::c_nCircleCornerSmoothRightBottom == nType ||
Constants::c_nCircleCornerRightTop == nType || Constants::c_nCircleCornerSmoothRightTop == nType )
CircleCorner();
else if( Constants::c_nBarsHorizontal == nType)
BarsHorizontal();
else if( Constants::c_nBarsVertical == nType)
BarsVertical();
else if( Constants::c_nWipeSmoothBoxIn == nType || Constants::c_nWipeSmoothBoxOut == nType)
Box();
else if( Constants::c_nEnhancedAlphaNoise == nType )
Noise();
else if( Constants::c_nEnhancedShutter == nType )
Shutter();
return;
}
protected:
void BowTile()
{
CBuffer<double> oTable(m_nMaskWidth + m_nMaskHeight);
if( oTable.IsEmpty() )
{
::memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
double dFactorX = 2.0 / m_nMaskWidth;
double dFactorY = 2.0 / m_nMaskHeight;
double dSignX = (Constants::c_nBowTileHorizontal == m_nMaskType || Constants::c_nBowTileSmoothHorizontal == m_nMaskType) ? -128 : 128;
double dSignY = (Constants::c_nBowTileHorizontal == m_nMaskType || Constants::c_nBowTileSmoothHorizontal == m_nMaskType) ? 128 : -128;
double* pTableY = oTable.GetPtr();
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
*pTableY++ = abs(nX * dFactorX - 1) * dSignX;
}
for( int nY = m_nMaskHeight - 1; nY >= 0; --nY )
{
*pTableY++ = abs(nY * dFactorY - 1) * dSignY + 127.5;
}
double* pLimit = pTableY - m_nMaskHeight;
Ipp8u* pBuffer = m_pMask;
for( pTableY -= 1; pTableY >= pLimit; --pTableY )
{
for( double* pTableX = oTable.GetPtr(); pTableX < pLimit; ++pTableX )
{
*pBuffer++ = BYTE(pTableY[0] + pTableX[0]);
}
}
}
void DiagonalBoxOut()
{
CBuffer<double> oTable(m_nMaskWidth + m_nMaskHeight);
if( oTable.IsEmpty() )
{
::memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
double dFactorX = 2.0 / m_nMaskWidth;
double dFactorY = 2.0 / m_nMaskHeight;
double* pTableY = oTable.GetPtr();
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
*pTableY++ = abs(nX * dFactorX - 1) * 255;
}
for( int nY = m_nMaskHeight - 1; nY >= 0; --nY )
{
*pTableY++ = (1 - abs(nY * dFactorY - 1)) * 255;
}
double* pLimit = pTableY - m_nMaskHeight;
Ipp8u* pBuffer = m_pMask;
for( pTableY -= 1; pTableY >= pLimit; --pTableY )
{
for( double* pTableX = oTable.GetPtr(); pTableX < pLimit; ++pTableX )
{
*pBuffer++ = BYTE(abs(pTableY[0] - pTableX[0]));
}
}
}
void DiagonalCrossOut()
{
CBuffer<double> oTable(m_nMaskWidth + m_nMaskHeight);
if( oTable.IsEmpty() )
{
::memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
double dFactorX = 2.0 / m_nMaskWidth;
double dFactorY = 2.0 / m_nMaskHeight;
double* pTableY = oTable.GetPtr();
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
*pTableY++ = abs(nX * dFactorX - 1) * 255;
}
for( int nY = m_nMaskHeight - 1; nY >= 0; --nY )
{
*pTableY++ = abs(nY * dFactorY - 1) * 255;
}
double* pLimit = pTableY - m_nMaskHeight;
Ipp8u* pBuffer = m_pMask;
for( pTableY -= 1; pTableY >= pLimit; --pTableY )
{
for( double* pTableX = oTable.GetPtr(); pTableX < pLimit; ++pTableX )
{
*pBuffer++ = BYTE(abs(pTableX[0] - pTableY[0]));
}
}
}
void Diagonal()
{
CBuffer<double> oTable(m_nMaskWidth + m_nMaskHeight);
if( oTable.IsEmpty() )
{
::memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
double dOffset = 255.0 / (m_nMaskHeight + m_nMaskWidth);
double dFactorX = dOffset;
double dFactorY = dOffset;
if( Constants::c_nDiagonalDownRight == m_nMaskType ||
Constants::c_nDiagonalSmoothDownRight == m_nMaskType)
{
dOffset *= m_nMaskHeight;
dFactorX *= 1;
dFactorY *= -1;
}
else
if( Constants::c_nDiagonalDownLeft == m_nMaskType ||
Constants::c_nDiagonalSmoothDownLeft == m_nMaskType)
{
dOffset *= m_nMaskWidth + m_nMaskHeight;
dFactorX *= -1;
dFactorY *= -1;
}
else
if( Constants::c_nDiagonalUpRight == m_nMaskType ||
Constants::c_nDiagonalSmoothUpRight == m_nMaskType)
{
dOffset *= 0;
dFactorX *= 1;
dFactorY *= 1;
}
else
if( Constants::c_nDiagonalUpLeft == m_nMaskType ||
Constants::c_nDiagonalSmoothUpLeft == m_nMaskType)
{
dOffset *= m_nMaskWidth;
dFactorX *= -1;
dFactorY *= 1;
}
double* pTableY = oTable.GetPtr();
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
*pTableY++ = nX * dFactorX;
}
for( int nY = m_nMaskHeight - 1; nY >= 0; --nY )
{
*pTableY++ = nY * dFactorY + dOffset;
}
double* pLimit = pTableY - m_nMaskHeight;
Ipp8u* pBuffer = m_pMask;
for( pTableY -= 1; pTableY >= pLimit; --pTableY )
{
for( double* pTableX = oTable.GetPtr(); pTableX < pLimit; ++pTableX )
{
*pBuffer++ = BYTE(pTableY[0] + pTableX[0]);
}
}
}
void FunIn()
{
const double c_dFactor = 255 / IPP_PI;
CBuffer<double> oTable(m_nMaskWidth + m_nMaskHeight);
if( oTable.IsEmpty() )
{
::memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
double dHalfWidth = m_nMaskWidth / 2.0;
double dHalfHeight = m_nMaskHeight / 2.0;
double* pTableY = oTable.GetPtr();
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
*pTableY++ = nX - dHalfWidth;
}
for( int nY = m_nMaskHeight - 1; nY >= 0; --nY )
{
*pTableY++ = nY - dHalfHeight * (nY >= dHalfHeight ? 1.5 : 0.5);
}
double* pLimit = pTableY - m_nMaskHeight;
Ipp8u* pBuffer = m_pMask;
double* pHalfLimit = pLimit + m_nMaskHeight / 2;
for( pTableY -= 1; pTableY >= pLimit; --pTableY )
{
for( double* pTableX = oTable.GetPtr(); pTableX < pLimit; ++pTableX )
{
double dAngle = abs(atan2( pTableX[0], pTableY[0] ));
if( pTableY >= pHalfLimit )
dAngle = IPP_PI - dAngle;
*pBuffer++ = BYTE(dAngle * c_dFactor);
}
}
}
void FunOut()
{
Ipp8u* pBuffer = m_pMask;
const double dFactor = 255 / IPP_2PI;
int nHalfWidth = m_nMaskWidth / 2;
int nHalfHeight = m_nMaskHeight / 2;
double offset1 = m_nMaskWidth * 0.75;
double offset2 = m_nMaskWidth * 0.25;
for( int nY = 0; nY < m_nMaskHeight; ++nY )
{
double dY = nY - nHalfHeight;
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
double dAngle;
if( nX > nHalfWidth )
{
dAngle = IPP_PI - atan2( dY, nX - offset1 );
}
else
{
dAngle = atan2( dY, nX - offset2 );
if( dAngle < 0 )
dAngle += IPP_2PI;
}
*pBuffer++ = int(dAngle * dFactor);
}
}
}
void FunUp()
{
Ipp8u* pBuffer = m_pMask;
const double dFactor = 255 / IPP_PI2;
double dHalfWidth = m_nMaskWidth / 2.0;
for( int nY = 0; nY < m_nMaskHeight; nY++ )
{
double y = nY - m_nMaskHeight;
for( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double dAngle = IPP_PI - abs(atan2( nX - dHalfWidth, y ));
*pBuffer++ = int(dAngle * dFactor);
}
}
}
void FilledV()
{
double dFactorX = 128.0 / m_nMaskWidth;
double dFactorY = 128.0 / m_nMaskHeight;
double dOffsetX = 128.0;
double dOffsetY = 128.0;
if( Constants::c_nFilledVDown == m_nMaskType ||
Constants::c_nFilledVSmoothDown == m_nMaskType )
{
dFactorX *= 2; dOffsetX *= -1;
dFactorY *= -1; dOffsetY *= 1;
}
else
if( Constants::c_nFilledVRight == m_nMaskType ||
Constants::c_nFilledVSmoothRight == m_nMaskType )
{
dFactorX *= 1; dOffsetX *= 0;
dFactorY *= 2; dOffsetY *= -1;
}
else
if( Constants::c_nFilledVLeft == m_nMaskType ||
Constants::c_nFilledVSmoothLeft == m_nMaskType )
{
dFactorX *= -1; dOffsetX *= 1;
dFactorY *= 2; dOffsetY *= -1;
}
else
if( Constants::c_nFilledVUp == m_nMaskType ||
Constants::c_nFilledVSmoothUp == m_nMaskType )
{
dFactorX *= 2; dOffsetX *= -1;
dFactorY *= 1; dOffsetY *= 0;
}
Ipp8u* pBuffer = m_pMask;
for( int nY = 0; nY < m_nMaskHeight; ++nY )
{
double dY = abs(nY * dFactorY + dOffsetY);
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
*pBuffer++ = BYTE(abs(nX * dFactorX + dOffsetX) + dY);
}
}
}
void Insert()
{
double dFactorX = 255.0 / m_nMaskWidth;
double dFactorY = 255.0 / m_nMaskHeight;
double dOffsetX = 255.0;
double dOffsetY = 255.0;
if( Constants::c_nInsertDownLeft == m_nMaskType ||
Constants::c_nInsertSmoothDownLeft == m_nMaskType )
{
dFactorX *= -1; dOffsetX *= 1;
dFactorY *= -1; dOffsetY *= 1;
}
else
if( Constants::c_nInsertDownRight == m_nMaskType ||
Constants::c_nInsertSmoothDownRight == m_nMaskType )
{
dFactorX *= 1; dOffsetX *= 0;
dFactorY *= -1; dOffsetY *= 1;
}
else
if( Constants::c_nInsertUpLeft == m_nMaskType ||
Constants::c_nInsertSmoothUpLeft == m_nMaskType )
{
dFactorX *= -1; dOffsetX *= 1;
dFactorY *= 1; dOffsetY *= 0;
}
else
if( Constants::c_nInsertUpRight == m_nMaskType ||
Constants::c_nInsertSmoothUpRight == m_nMaskType )
{
dFactorX *= 1; dOffsetX *= 0;
dFactorY *= 1; dOffsetY *= 0;
}
Ipp8u* pBuffer = m_pMask;
for( int nY = 0; nY < m_nMaskHeight; nY++ )
{
double dY = nY * dFactorY + dOffsetY;
for( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double dX = nX * dFactorX + dOffsetX;
*pBuffer++ = BYTE(max(dX, dY));
}
}
}
void Reveal()
{
double dFactor = 255.0;
double dOffset = 255.0;
BOOL bHor = TRUE;
if( Constants::c_nRevealUp == m_nMaskType)
{
dFactor /= m_nMaskHeight; dOffset *= 0; bHor = FALSE;
}
else if( Constants::c_nRevealDown == m_nMaskType)
{
dFactor /= -m_nMaskHeight; dOffset *= 1; bHor = FALSE;
}
else if( Constants::c_nRevealLeft == m_nMaskType)
{
dFactor /= -m_nMaskWidth; dOffset *= 1;
}
else if( Constants::c_nRevealRight == m_nMaskType)
{
dFactor /= m_nMaskWidth; dOffset *= 0;
}
Ipp8u* pBuffer = m_pMask;
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
*pBuffer++ = BYTE((bHor ? nX : nY) * dFactor + dOffset);
}
}
}
void Split()
{
BOOL bHor = FALSE;
double dFactor = 511;
if( Constants::c_nSplitHorizontal == m_nMaskType ||
Constants::c_nSplitSmoothHorizontal == m_nMaskType )
{
dFactor /= m_nMaskHeight; bHor = FALSE;
}
else
if( Constants::c_nSplitVertical == m_nMaskType ||
Constants::c_nSplitSmoothVertical == m_nMaskType )
{
dFactor /= m_nMaskWidth; bHor = TRUE;
}
Ipp8u* pBuffer = m_pMask;
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
*pBuffer++ = BYTE(abs((bHor ? nX : nY) * dFactor - 255.5));
}
}
}
void SweepIn()
{
double dAngFactor = 255 / (IPP_PI2 - atan( m_nMaskHeight / (2.0 * m_nMaskWidth) ));
double dFactor = m_nMaskHeight / (2.0 * m_nMaskWidth );
double dOffset = m_nMaskHeight * 0.25;
Ipp8u* pBuffer = m_pMask;
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
double dY = nY - dOffset;
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double dAngle;
if ( dY > nX * dFactor )
{
double y = nX;
double x = dY;
dAngle = abs(atan2( y, x ));
}
else
{
double y = nX - m_nMaskWidth;
double x = dY - dOffset - dOffset;
dAngle = IPP_PI - abs(atan2( y, x ));
}
*pBuffer++ = BYTE(dAngle * dAngFactor);
}
}
}
void SweepOut()
{
Ipp8u* pBuffer = m_pMask;
const double dFactor = 255 / IPP_PI;
int nHalfWidth = m_nMaskWidth / 2;
int nHalfHeight = m_nMaskHeight / 2;
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double x = nY - nHalfHeight;
double y = nX;
if( nX > nHalfWidth)
y -= m_nMaskWidth;
double dAngle = abs( atan2( y, x ) );
*pBuffer++ = BYTE(dAngle * dFactor);
}
}
}
void SweepUp()
{
Ipp8u* pBuffer = m_pMask;
const double dFactor = 255 / IPP_PI2;
int nHalfWidth = m_nMaskWidth / 2;
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double dAngle;
if( nX > nHalfWidth )
{
double y = nY;
double x = nX - m_nMaskWidth;
dAngle = IPP_PI - abs( atan2( y, x ));
}
else
{
double y = nY;
double x = nX;
dAngle = abs( atan2( y, x ));
}
*pBuffer++ = BYTE(dAngle * dFactor);
}
}
}
void ZigZagHor()
{
Ipp8u* pBuffer = m_pMask;
const int nZigZagCount = 4;
double dZigZagWidth = m_nMaskWidth / (nZigZagCount * 2.0);
double dZigZagHeight = m_nMaskHeight / 5.0;
double dTimeUnit = 255.0 / (m_nMaskHeight * 0.6);
double factor = dZigZagHeight / dZigZagWidth;
double dAddOffset = (m_nMaskHeight + dZigZagHeight) / 2.0;
double dSubOffset = (m_nMaskHeight - dZigZagHeight) / 2.0;
for( int nY = 0; nY < m_nMaskHeight; nY++ )
{
int part = 0;
for( int nX = 0; nX < m_nMaskWidth; ++nX, ++part )
{
if( part >= dZigZagWidth * 2 )
part = 0;
int value = 0;
if( part < dZigZagWidth )
{
double offset = (dZigZagWidth - part) * factor;
if( nY > dAddOffset - part * factor )
value = int((nY - dSubOffset - offset) * dTimeUnit);
else
value = int((offset - nY + dSubOffset) * dTimeUnit);
}
else
{
double offset = (dZigZagWidth * 2 - part) * factor;
if(nY > dSubOffset + (part - dZigZagWidth) * factor )
value = int((nY - dAddOffset + offset) * dTimeUnit);
else
value = int((dAddOffset - nY - offset) * dTimeUnit);
}
*pBuffer++ = value;
}
}
}
void ZigZagVer()
{
Ipp8u* pBuffer = m_pMask;
const int nZigZagCount = 4;
double dZigZagHeight = m_nMaskHeight / (nZigZagCount * 2.0);
double dZigZagWidth = m_nMaskWidth / 5.0;
double dTimeUnit = 255 / (m_nMaskWidth * 0.6);
double factor = dZigZagWidth / dZigZagHeight;
double dAddOffset = (m_nMaskWidth + dZigZagWidth) / 2.0;
double dSubOffset = (m_nMaskWidth - dZigZagWidth) / 2.0;
int part = 0;
for( int nY = 0; nY < m_nMaskHeight; ++nY, ++part )
{
if( part >= dZigZagHeight * 2 )
part = 0;
for( int nX = 0; nX < m_nMaskWidth; ++nX )
{
int value = 0;
if( part < dZigZagHeight )
{
double offset = (dZigZagHeight - part) * factor;
if( nX > - part * factor + dAddOffset )
value = int((nX - dSubOffset - offset) * dTimeUnit);
else
value = int((dSubOffset - nX + offset) * dTimeUnit);
}
else
{
double offset = (dZigZagHeight * 2 - part) * factor;
if( nX > (part - dZigZagHeight) * factor + dSubOffset )
value = int((nX - dAddOffset + offset) * dTimeUnit);
else
value = int((dAddOffset - nX - offset) * dTimeUnit);
}
*pBuffer++ = value;
}
}
}
void PinwheelCurved()
{
double dParts = 1;
double dAmplitFactor = 0.1;
double dPhaseFactor = 2.0;
switch( m_nMaskType )
{
case Constants::c_nPinwheelCurvedSN5A: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelCurvedSN7A: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelCurvedSN12A: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelCurvedSW5A: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedSW7A: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedSW12A: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedLN5A: dParts = 5; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedLN7A: dParts = 7; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedLN12A: dParts = 12; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelPropeller4: dParts = 4; dAmplitFactor = 0.4; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelPropeller7: dParts = 7; dAmplitFactor = 0.4; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelPropeller12: dParts = 12; dAmplitFactor = 0.4; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelCurvedSN5ASmooth: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelCurvedSN7ASmooth: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelCurvedSN12ASmooth: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelCurvedSW5ASmooth: dParts = 5; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedSW7ASmooth: dParts = 7; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedSW12ASmooth: dParts = 12; dAmplitFactor = 0.1; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedLN5ASmooth: dParts = 5; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedLN7ASmooth: dParts = 7; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelCurvedLN12ASmooth: dParts = 12; dAmplitFactor = 0.8; dPhaseFactor = 2.0; break;
case Constants::c_nPinwheelPropeller4Smooth: dParts = 4; dAmplitFactor = 0.4; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelPropeller7Smooth: dParts = 7; dAmplitFactor = 0.4; dPhaseFactor = 10.0; break;
case Constants::c_nPinwheelPropeller12Smooth: dParts = 12; dAmplitFactor = 0.4; dPhaseFactor = 10.0; break;
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int nSizeTable = int(m_nMaskWidth + m_nMaskHeight);
double* pTable = new double[(nSizeTable + 1)];
if( !pTable )
{
memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
double dMaxRadius = (m_nMaskWidth * m_nMaskWidth + m_nMaskHeight * m_nMaskHeight) / 4.0;
double dFactor = dMaxRadius / nSizeTable;
double dAmplit = sqrt(dMaxRadius) * dAmplitFactor; // * 4;
if ( ( m_nMaskType >= Constants::c_nPinwheelPropeller4 && m_nMaskType <= Constants::c_nPinwheelPropeller12 ) ||
( m_nMaskType >= Constants::c_nPinwheelPropeller4Smooth && m_nMaskType <= Constants::c_nPinwheelPropeller12Smooth ))
dAmplit = dMaxRadius * dAmplitFactor;
double dPhase = IPP_2PI / m_nMaskWidth * dPhaseFactor;
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
pTable[0] = 0;
for( int i = 1; i <= nSizeTable; i++ )
{
double dr = sqrt(i * dFactor);
pTable[i] = sin( dr * dPhase ) * dAmplit / dr;
}
// <20><><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int nSizeHelp = max(m_nMaskWidth, m_nMaskHeight);
double* pHelp = new double[nSizeHelp * 2];
if( !pHelp )
{
delete [] pTable;
memset( m_pMask, 255, m_nMaskWidth * m_nMaskHeight );
return;
}
int nMinSize = nSizeHelp / 2;
int nMaxSize = nSizeHelp - nMinSize;
dFactor = nSizeTable / dMaxRadius;
double* pItem = pHelp;
for( int i = -nMinSize; i < nMaxSize; ++i, pItem += 2 )
{
pItem[1] = i;
pItem[0] = i * i * dFactor;
}
Ipp8u* pBuffer = m_pMask;
int nWidth = m_nMaskWidth;
int nHeight = m_nMaskHeight;
double* pItemY = pHelp + (nMinSize - nHeight / 2) * 2;
double* pItemX = pHelp + (nMinSize - nWidth / 2) * 2;
dParts *= 255 / IPP_2PI;
for( int nY = nHeight; nY > 0; --nY, pItemY += 2, pItemX -= nWidth * 2 )
{
for ( int nX = nWidth; nX > 0; --nX, pItemX += 2 )
{
double dot = pItemY[0] + pItemX[0];
int index = int(dot);
double dr = pTable[index];
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if( index < nSizeTable )
{
dot -= index;
dr += (pTable[index + 1] - dr) * dot;
}
double x = pItemX[1] - dr * pItemY[1];
double y = pItemY[1] + dr * pItemX[1];
double dAngle = atan2( y, x );
if( dAngle < 0 )
dAngle += IPP_2PI;
*pBuffer++ = int( dAngle * dParts);
}
}
delete [] pHelp;
delete [] pTable;
}
void Diamonds( int nHorDiamonds, int nVerDiamonds, BOOL bOut )
{
Ipp8u* pBuffer = m_pMask;
double dPartWidth = double(m_nMaskWidth) / nHorDiamonds;
double dPartHeight = double(m_nMaskHeight) / nVerDiamonds;
double dHalfWidth = dPartWidth / 2;
double dHalfHeight = dPartHeight / 2;
double dFactorX = 255.0 / dPartWidth;
double dFactorY = 255.0 / dPartHeight;
double dMaxY = dPartHeight;
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
if( dMaxY < nY )
dMaxY += dPartHeight;
double dY = abs( dMaxY - nY - dHalfHeight ) * dFactorY;
double dMaxX = dPartWidth;
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
if( dMaxX < nX )
dMaxX += dPartWidth;
int nValue = int(abs( dMaxX - nX - dHalfWidth ) * dFactorX + dY);
*pBuffer++ = bOut ? nValue : 255 - nValue;
}
}
}
void Circles( double dMaxCountCircles, BOOL bOut )
{
Ipp8u* pBuffer = m_pMask;
double dPartSize = max(m_nMaskWidth, m_nMaskHeight) / (dMaxCountCircles - 0.001);
double dHalfSize = dPartSize / 2;
double dStartX = (m_nMaskWidth - (int(m_nMaskWidth / dPartSize) + 1) * dPartSize) / 2 + dPartSize;
double dStartY = (m_nMaskHeight - (int(m_nMaskHeight / dPartSize) + 1) * dPartSize) / 2 + dPartSize;
double dFactor = 255 / sqrt(dHalfSize * dHalfSize * 2);
double dMaxY = dStartY;
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
if( dMaxY < nY )
dMaxY += dPartSize;
double dy = dMaxY - nY - dHalfSize;
dy *= dy;
double dMaxX = dStartX;
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
if( dMaxX < nX )
dMaxX += dPartSize;
double dx = dMaxX - nX - dHalfSize;
int nValue = sqrt(dx * dx + dy) * dFactor;
*pBuffer++ = bOut ? nValue : 255 - nValue;
}
}
}
void StarFlower()
{
int nType = m_nMaskType;
Ipp8u* pBuffer = m_pMask;
const int nStarsPoints = 5;
const int nCountSectors = nStarsPoints * 2;
const double dFactor = ::sin(IPP_PI2 * (nCountSectors - 4) / nCountSectors) / ::sin(IPP_PI2 * (nCountSectors - 8) / nCountSectors); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
const double dSector = IPP_2PI / nCountSectors;
const double dReSector = nCountSectors / IPP_2PI;
const double f1 = (dFactor - 1) * nCountSectors / IPP_2PI;
const double f2 = 1 / sqrt(dFactor * (dFactor - 2 * cos(dSector)) + 1);
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double y = nY - m_nMaskHeight / 2;
double x = nX - m_nMaskWidth / 2;
double dCurRadius = sqrt(x * x + y * y);
double angle = atan2( y, x ) - IPP_PI2;
if( angle < 0 )
angle += IPP_2PI;
int nCurSector = angle * dReSector;
double nCurAngle = angle - nCurSector * dSector;
double dSmallRadius; // <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if ( nCurSector & 1 )
{
if( Constants::c_nWipeSmoothWideFlower == nType ||
Constants::c_nWipeSmoothNarrowFlower == nType )
{
dSmallRadius = dCurRadius / (1 + nCurAngle * f1);
}
else
{
double dValue = 1 / tan( asin( f2 * (dFactor * sin(dSector - nCurAngle) + sin(nCurAngle))));
dSmallRadius = dCurRadius / (sin(nCurAngle) * dValue + cos(nCurAngle));
}
}
else
{
if( Constants::c_nWipeSmoothWideFlower == nType ||
Constants::c_nWipeSmoothNarrowFlower == nType )
{
dSmallRadius = dCurRadius / (dFactor - nCurAngle * f1);
}
else
{
double dValue = 1 / tan(asin( f2 * (dFactor * sin(nCurAngle) + sin(dSector - nCurAngle))));
dSmallRadius = dCurRadius / (sin(dSector - nCurAngle) * dValue + cos(dSector - nCurAngle));
}
}
double dCurTime = 255. * dSmallRadius * 2 / sqrt( double (m_nMaskHeight * m_nMaskHeight + m_nMaskWidth * m_nMaskWidth));
*pBuffer++ = int(dCurTime) & 255;
}
}
}
void StarsFlowers()
{
int nType = m_nMaskType;
Ipp8u* pBuffer = m_pMask;
for ( int nYIndex = 0; nYIndex < m_nMaskHeight; nYIndex++ )
{
for ( int nXIndex = 0; nXIndex < m_nMaskWidth; nXIndex++ )
{
const int nHorStars = 5;
const int nVerStars = 5;
int nPartWidth = m_nMaskWidth / nHorStars;
int nPartHeight = m_nMaskHeight / nVerStars;
int nHorIndex = nXIndex / nPartWidth;
int nVerIndex = nYIndex / nPartHeight;
const int nStarsPoints = 5;
const int nCountSectors = nStarsPoints * 2;
const int nSector = 360 / nCountSectors;
double dRad = 3.14159265 / 180;
double dFactor = sin(dRad * ( 90 - nSector)) / sin(dRad * ( 90 - 2 * nSector)); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
double dValue = 300;
for(int nIndex = 0; nIndex < 2; nIndex++ )
{
double dY = nYIndex - (nVerIndex + 0.5) * nPartHeight;
double dX = nXIndex - (nHorIndex + 0.5) * nPartWidth;
double dCurRadius = sqrt(dX * dX + dY * dY);
double dSecY = (dY >= 0 ? 1.0 : -1.0);
int nAngle = (dCurRadius ? acos( dX / dCurRadius) * dSecY : 0) /dRad;
nAngle = ( nAngle < 0? 360 + nAngle : nAngle);
nAngle -= 90;
nAngle = ( nAngle < 0? 360 + nAngle : nAngle);
int nCurSector = nAngle / nSector;
int nCurAngle = nAngle % nSector;
double dSmallRadius; // <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if ( nCurSector % 2 )
{
if (Constants::c_nWipeSmoothWideFlowers == nType || Constants::c_nWipeSmoothNarrowFlowers == nType)
dSmallRadius = dCurRadius * nSector / (nSector + nCurAngle * (dFactor - 1));
else
{
double dValue = 1 / tan(asin( ( dFactor * sin( dRad * (nSector - nCurAngle)) + sin(dRad * nCurAngle ) )/sqrt( dFactor * dFactor + 1 - 2 * dFactor * cos(dRad * nSector)) ));
dSmallRadius = dCurRadius / (sin(dRad * nCurAngle) * dValue + cos(dRad * nCurAngle));
}
}
else
{
if (Constants::c_nWipeSmoothWideFlowers == nType || Constants::c_nWipeSmoothNarrowFlowers == nType)
dSmallRadius = dCurRadius * nSector / (dFactor * nSector + nCurAngle * (1 - dFactor));
else
{
double dValue = 1 / tan(asin( ( dFactor * sin( dRad * (nCurAngle)) + sin(dRad * (nSector - nCurAngle) ) )/sqrt( dFactor * dFactor + 1 - 2 * dFactor * cos(dRad * nSector)) ));
dSmallRadius = dCurRadius / (sin(dRad * (nSector - nCurAngle)) * dValue + cos(dRad * (nSector - nCurAngle)));
}
}
double dCurTime = 255. * dSmallRadius * 2 / sqrt( double (nPartHeight * nPartHeight + nPartWidth * nPartWidth));
dValue = (dCurTime < dValue? dCurTime : dValue);
if (nIndex == 0)
{
if ( nYIndex % nPartHeight > nPartHeight / 2)
nVerIndex++;
else
nVerIndex--;
if ( nVerIndex < 0 || nVerIndex >= nVerStars )
nIndex = 2;
}
}
*pBuffer = int(dValue) % 255;
pBuffer++;
}
}
}
void KeyHoles()
{
Ipp8u* pBuffer = m_pMask;
for ( int nYIndex = 0; nYIndex < m_nMaskHeight; nYIndex++ )
{
for ( int nXIndex = 0; nXIndex < m_nMaskWidth; nXIndex++ )
{
const int nHorHoles = 5;
const int nVerHoles = 5;
int nPartWidth = m_nMaskWidth / nHorHoles;
int nPartHeight = m_nMaskHeight / nVerHoles;
int nHorIndex = nXIndex / nPartWidth;
int nVerIndex = nYIndex / nPartHeight;
double dResValue = 300;
for(int nIndex =0; nIndex < 2; nIndex++)
{
int nX = nXIndex - nHorIndex * nPartWidth;
int nY = nYIndex - nVerIndex * nPartHeight;
int nValue;
int nValue1;
double dUnit = 255. * 8. / (nPartWidth * 3. );
if ( nY - 2. * nPartHeight / 3. <= - abs(8. * ( nX - nPartWidth / 2. ) / 3.))
{
nValue = (2. * nPartHeight / 3. - nY) * dUnit / 6.;
}
else
{
int nX1 = nX - nPartWidth / 2.;
int nY1 = nY - 2. * nPartHeight / 3.;
int nCurY = nY1 + 12. * abs(nX1) / 3.;
nValue = nCurY * dUnit / 3.;
}
nValue1 = sqrt(double(( nX - nPartWidth / 2. ) * ( nX - nPartWidth / 2. ) + ( nY - 2 * nPartHeight / 3. ) * ( nY - 2. * nPartHeight / 3. ))) * dUnit / 2.;
if ( nValue1 < nValue || 2. * nPartHeight / 3. < nY)
nValue = nValue1;
double dValue = sqrt( nValue / 255.) * 255;
dResValue = (dValue < dResValue? dValue : dResValue);
if (nIndex == 0)
{
if ( nYIndex % nPartHeight > nPartHeight / 2)
nVerIndex++;
else
nVerIndex--;
if ( nVerIndex < 0 || nVerIndex >= nVerHoles )
nIndex = 2;
}
}
*pBuffer = dResValue ;
pBuffer++;
}
}
}
void KeyHole()
{
Ipp8u* pBuffer = m_pMask;
for ( int nYIndex = 0; nYIndex < m_nMaskHeight; nYIndex++ )
{
for ( int nXIndex = 0; nXIndex < m_nMaskWidth; nXIndex++ )
{
int nValue;
int nValue1;
double dUnit = 255. * 8 / (m_nMaskWidth * 3 );
if ( nYIndex - 2 * m_nMaskHeight / 3 <= - abs(8. * ( nXIndex - m_nMaskWidth / 2 ) / 3.))
{
nValue = (2 * m_nMaskHeight / 3 - nYIndex) * dUnit / 6;
}
else
{
int nX = nXIndex - m_nMaskWidth / 2;
int nY = nYIndex - 2 * m_nMaskHeight / 3;
int nCurY = nY + 12 * abs(nX) / 3;
nValue = nCurY * dUnit / 3;
}
nValue1 = sqrt(double(( nXIndex - m_nMaskWidth / 2 ) * ( nXIndex - m_nMaskWidth / 2 ) + ( nYIndex - 2 * m_nMaskHeight / 3 ) * ( nYIndex - 2 * m_nMaskHeight / 3 ))) * dUnit / 2;
if ( nValue1 < nValue || 2 * m_nMaskHeight / 3 < nYIndex)
nValue = nValue1;
double dValue = sqrt(nValue / 255.);
*pBuffer = dValue * 255;
pBuffer++;
}
}
}
void CircleCorner()
{
Ipp8u* pBuffer = m_pMask;
double dW = m_nMaskWidth;
double dH = m_nMaskHeight;
double dFactor = 255 / sqrt(dW * dW + dH * dH);
double dX = 0, dY = 0;
switch( m_nMaskType )
{
case Constants::c_nCircleCornerLeftBottom:
case Constants::c_nCircleCornerSmoothLeftBottom: dX = 0; dY = 0; break;
case Constants::c_nCircleCornerLeftTop:
case Constants::c_nCircleCornerSmoothLeftTop: dX = 0; dY = dH; break;
case Constants::c_nCircleCornerRightBottom:
case Constants::c_nCircleCornerSmoothRightBottom: dX = dW; dY = 0; break;
case Constants::c_nCircleCornerRightTop:
case Constants::c_nCircleCornerSmoothRightTop: dX = dW; dY = dH; break;
}
for ( int nY = 0; nY < m_nMaskHeight; nY++ )
{
for ( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double y = nY - dY;
double x = nX - dX;
*pBuffer++ = BYTE(dFactor * sqrt( x * x + y * y ));
}
}
}
void BarsHorizontal()
{
CRandom rnd( m_dwBaseRnd );
Ipp8u* pBuffer = m_pMask;
for( int nY = 0; nY < m_nMaskHeight; ++nY, pBuffer += m_nMaskWidth )
{
::memset( pBuffer, rnd.Rand( 255 ), m_nMaskWidth );
}
}
void BarsVertical()
{
CRandom rnd( m_dwBaseRnd );
Ipp8u* pBuffer = m_pMask;
for( int i = 0; i < m_nMaskWidth; ++i )
{
*pBuffer++ = rnd.Rand( 255 );
}
for( int nY = 1; nY < m_nMaskHeight; ++nY, pBuffer += m_nMaskWidth )
{
::memcpy( pBuffer, m_pMask, m_nMaskWidth );
}
}
void Box()
{
Ipp8u* pBuffer = m_pMask;
int nIn = 1;
if ( Constants::c_nWipeSmoothBoxIn == m_nMaskType )
nIn = 0;
double dFactorX = 511.0 / m_nMaskWidth ;
double dFactorY = 511.0 / m_nMaskHeight;
double dHalfWidth = m_nMaskWidth / 2.0;
double dHalfHeight = m_nMaskHeight / 2.0;
for( int nY = 0; nY < m_nMaskHeight; nY++ )
{
double y = dFactorY * abs(nY - dHalfHeight);
for( int nX = 0; nX < m_nMaskWidth; nX++ )
{
double x = dFactorX * abs(nX - dHalfWidth);
*pBuffer++ = 255 * (1 - nIn) + (2 * nIn - 1) * max(x, y);
}
}
}
void Noise()
{
CRandom rnd( m_dwBaseRnd );
int nSize = m_nMaskWidth * m_nMaskHeight;
Ipp8u* pBuffer = m_pMask;
for( int i = 0; i < nSize; ++i, ++pBuffer )
{
pBuffer[0] = rnd.Rand( 256 );
}
}
void Shutter()
{
const int c_nPathCount = 10;
double interval = m_nMaskHeight / double(c_nPathCount);
if( interval < 10 )
interval = 10;
double factor = 255 / interval;
Ipp8u* pBuffer = m_pMask;
double y = 0;
for( int row = 0; row < m_nMaskHeight; ++row, ++y )
{
if( y > interval )
y = 0;
memset( pBuffer, 255 - int(y * factor), m_nMaskWidth );
pBuffer += m_nMaskWidth;
}
}
public:
int m_nMaskWidth;
int m_nMaskHeight;
Ipp8u* m_pMask;
int m_nMaskType;
};
class CPuzzleFigure
{
public:
CPuzzleFigure()
{
m_nFigHeight = 0;
m_nFigWidth = 0;
m_nPicHeight = 0;
m_nPicWidth = 0;
m_nLeftFactor = 0;
m_nRightFactor = 0;
m_nTopFactor = 0;
m_nBottomFactor = 0;
m_nXCoorSource = 0;
m_nYCoorSource = 0;
}
CPuzzleFigure(int nFigWidth, int nFigHeight, int nTopFactor, int nRightFactor, int nBottomFactor, int nLeftFactor, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
{
m_nFigHeight = nFigHeight;
m_nFigWidth = nFigWidth;
m_nLeftFactor = nLeftFactor;
m_nRightFactor = nRightFactor;
m_nTopFactor = nTopFactor;
m_nBottomFactor = nBottomFactor;
m_nPicHeight = nPicHeight;
m_nPicWidth = nPicWidth;
m_pBGRASource = pBGRASource;
m_nXCoorSource = nXCoorSource;
m_nYCoorSource = nYCoorSource;
}
~CPuzzleFigure()
{
}
private:
void DrawAlphaBlendingLine(BYTE* pBGRAResult, BYTE* pBGRASource, int nColor, int nNumLine, double dEffect)
{
int nAlpha = 7 * (1 << nNumLine);
nColor = nColor * nAlpha + 127;
nAlpha = 255 - nAlpha;
if( 1 == dEffect )
{
pBGRAResult[0] = (nColor + pBGRASource[0] * nAlpha) * 0x8081U >> (7 + 16);
pBGRAResult[1] = (nColor + pBGRASource[1] * nAlpha) * 0x8081U >> (7 + 16);
pBGRAResult[2] = (nColor + pBGRASource[2] * nAlpha) * 0x8081U >> (7 + 16);
}
else
{
double factor = 1 - dEffect;
pBGRAResult[0] = BYTE(dEffect * ((nColor + pBGRASource[0] * nAlpha) * 0x8081U >> (7 + 16)) + pBGRASource[0] * factor + 0.5);
pBGRAResult[1] = BYTE(dEffect * ((nColor + pBGRASource[1] * nAlpha) * 0x8081U >> (7 + 16)) + pBGRASource[0] * factor + 0.5);
pBGRAResult[2] = BYTE(dEffect * ((nColor + pBGRASource[2] * nAlpha) * 0x8081U >> (7 + 16)) + pBGRASource[0] * factor + 0.5);
}
pBGRAResult[3] = 255;
}
public:
void SetValue(int nFigWidth, int nFigHeight, int nTopFactor, int nRightFactor, int nBottomFactor, int nLeftFactor, BYTE* pBGRASource, int nPicWidth, int nPicHeight, int nXCoorSource, int nYCoorSource)
{
m_nFigHeight = nFigHeight;
m_nFigWidth = nFigWidth;
m_nLeftFactor = nLeftFactor;
m_nRightFactor = nRightFactor;
m_nTopFactor = nTopFactor;
m_nBottomFactor = nBottomFactor;
m_nPicHeight = nPicHeight;
m_nPicWidth = nPicWidth;
m_pBGRASource = pBGRASource;
m_nXCoorSource = nXCoorSource;
m_nYCoorSource = nYCoorSource;
}
BOOL Cpy(BYTE* pBGRAResult, int nXCoorResult, int nYCoorResult, int nWidth, int nHeight, int nAlpha)
{
if(!pBGRAResult || nWidth != m_nPicWidth || nHeight != m_nPicHeight)
return FALSE;
int nSize = 4 * nHeight * nWidth;
BYTE* pSource = m_pBGRASource;
BYTE* pResult = pBGRAResult;
//double dDiagonal = sqrt(double(m_nFigHeight * m_nFigHeight + m_nFigWidth * m_nFigWidth));
//
//double dUnit = 1 / (72.0 * sqrt (2.0)) * dDiagonal;
double dDiagonal = min(m_nFigHeight, m_nFigWidth);
double dUnit = 1 / (72.0) * dDiagonal;
int nCircleWidth = 26 * dUnit; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20>.<2E>. 2 * <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - (<28><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
int nRadius = 15 * dUnit; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int nSqrRadius = nRadius * nRadius;
int nSqrIncRadius = ( nRadius + 1 ) * ( nRadius + 1 );
int nSqrDecRadius = ( nRadius - 1 ) * ( nRadius - 1 );
int nInStep = 37 * dUnit;
int nXStartRes = nXCoorResult - nCircleWidth;
int nYStartRes = nYCoorResult - nCircleWidth;
int nXStartSur = m_nXCoorSource - nCircleWidth;
int nYStartSur = m_nYCoorSource - nCircleWidth;
int nFullHeight = m_nFigHeight + 2 * nCircleWidth; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int nFullWidth = m_nFigWidth + 2 * nCircleWidth; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int nXSource = m_nXCoorSource - nCircleWidth;
int nYSource = m_nYCoorSource - nCircleWidth;
int nXResult = nXCoorResult - nCircleWidth;
int nYResult = nYCoorResult - nCircleWidth;
double dStep = 11 * dUnit;
double dSrez = sqrt(nSqrRadius - dStep * dStep);
double dAngle = acos(11 * dUnit / nRadius) * 180 / IPP_PI;
if ( nXStartRes < 0 )
{
nXStartSur += -nXStartRes;
nXStartRes = 0;
}
if (nYStartRes < 0)
{
nYStartSur += -nYStartRes;
nYStartRes = 0;
}
for ( int nYIndexResult = nYStartRes, nYIndexSource = nYStartSur; nYIndexResult < min( nHeight, nYResult + nFullHeight); nYIndexResult++, nYIndexSource++)
{
for(int nXIndexResult = nXStartRes, nXIndexSource = nXStartSur; nXIndexResult < min( nWidth, nXResult + nFullWidth); nXIndexResult++, nXIndexSource++)
{
BOOL bIn = FALSE;
int nYS = nYIndexSource;
int nXS = nXIndexSource;
if ( (nYS > nYSource + nCircleWidth && nYS < nYSource + nFullHeight - nCircleWidth &&
nXS > nXSource + nCircleWidth && nXS <= nXSource + nFullWidth - nCircleWidth &&
(m_nTopFactor >= 0 || (m_nTopFactor == -1 && ( nYS - nYSource - nInStep ) * ( nYS - nYSource - nInStep ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 ) >= nSqrRadius ))&&
(m_nLeftFactor >= 0 || (m_nLeftFactor == -1 && ( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nInStep ) * ( nXS - nXSource - nInStep ) >= nSqrRadius ))&&
(m_nRightFactor >= 0 || (m_nRightFactor == -1 && ( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nFullWidth + nInStep ) * ( nXS - nXSource - nFullWidth + nInStep ) >= nSqrRadius ))&&
(m_nBottomFactor >= 0 || (m_nBottomFactor == -1 && ( nYS - nYSource - nFullHeight + nInStep ) * ( nYS - nYSource - nFullHeight + nInStep ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 ) >= nSqrRadius ))
)
||
(m_nTopFactor == 1 && ( nYS - nYSource - nRadius ) * ( nYS - nYSource - nRadius ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 ) <= nSqrDecRadius )||
(m_nLeftFactor == 1 && ( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nRadius ) * ( nXS - nXSource - nRadius ) <= nSqrDecRadius )||
(m_nRightFactor == 1 && ( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nFullWidth + nRadius ) * ( nXS - nXSource - nFullWidth + nRadius ) <= nSqrDecRadius )||
(m_nBottomFactor == 1 && ( nYS - nYSource - nFullHeight + nRadius ) * ( nYS - nYSource - nFullHeight + nRadius ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 ) <= nSqrDecRadius )
)
{
bIn = TRUE;
}
int nResultIndex = 4 * nWidth * nYIndexResult + 4 * nXIndexResult;
int nSourceIndex = 4 * nWidth * nYIndexSource + 4 * nXIndexSource;
if ( bIn )
{
double dKoef = nAlpha / 255.0;
pResult[ nResultIndex + 0 ] = pSource[ nSourceIndex + 0 ] * dKoef + ( 1 - dKoef) * pResult[ nResultIndex + 0 ];
pResult[ nResultIndex + 1 ] = pSource[ nSourceIndex + 1 ] * dKoef + ( 1 - dKoef) * pResult[ nResultIndex + 1 ];
pResult[ nResultIndex + 2 ] = pSource[ nSourceIndex + 2 ] * dKoef + ( 1 - dKoef) * pResult[ nResultIndex + 2 ];
pResult[ nResultIndex + 3 ] = pSource[ nSourceIndex + 3 ] * dKoef + ( 1 - dKoef) * pResult[ nResultIndex + 3 ];
}
// if ( 1 == m_nTopFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nRadius ) * ( nYS - nYSource - nRadius ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 )));
//
// if ( nDistance > nRadius && nYS >= nYSource + nCircleWidth && nYS <= nYSource + nCircleWidth + 5 && nXS >= nXSource + nCircleWidth + (5 - (nYSource + nCircleWidth + 5 - nYS)) && nXS <= nXSource + nFullWidth - nCircleWidth - (5 - (nYSource + nCircleWidth + 5 - nYS)))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, nYSource + nCircleWidth + 5 - nYS, dEffect);
// if ( nDistance <= nRadius && nDistance >= nRadius - 5 && nYS <= nYSource + nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, 5 - (nRadius - nDistance), dEffect);
// }
// else if ( -1 == m_nTopFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nInStep ) * ( nYS - nYSource - nInStep ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 )));
//
// if ( nDistance <= nRadius + 5 && nDistance >= nRadius && nYS >= nYSource + nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, 5- (nDistance - nRadius), dEffect);
// if ( nDistance > nRadius && nYS >= nYSource + nCircleWidth && nYS <= nYSource + nCircleWidth + 5 && nXS >= nXSource + nCircleWidth + (5 - (nYSource + nCircleWidth + 5 - nYS)) && nXS <= nXSource + nFullWidth - nCircleWidth - (5 - (nYSource + nCircleWidth + 5 - nYS)))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, nYSource + nCircleWidth + 5 - nYS, dEffect);
// }
// else
// {
// if ( nYS >= nYSource + nCircleWidth && nYS <= nYSource + nCircleWidth + 5 && nXS >= nXSource + nCircleWidth + (5 - (nYSource + nCircleWidth + 5 - nYS)) && nXS <= nXSource + nFullWidth - nCircleWidth - (5 - (nYSource + nCircleWidth + 5 - nYS)))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, nYSource + nCircleWidth + 5 - nYS, dEffect);
// }
// if ( 1 == m_nBottomFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nFullHeight + nRadius ) * ( nYS - nYSource - nFullHeight + nRadius ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 )));
//
// if ( nDistance > nRadius && nYS <= nYSource + nFullHeight - nCircleWidth && nYS >= nYSource + nFullHeight - nCircleWidth - 5 && nXS >= nXSource + nCircleWidth + (nYSource + nFullHeight - nCircleWidth - nYS) && nXS <= nXSource + nFullWidth - nCircleWidth - (nYSource + nFullHeight - nCircleWidth - nYS))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, 5 - (nYSource + nFullHeight - nCircleWidth - nYS), dEffect);
// if ( nDistance <= nRadius && nDistance >= nRadius - 5 && nYS >= nYSource + nFullHeight - nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, 5 - (nRadius - nDistance), dEffect);
// }
// else if ( -1 == m_nBottomFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nFullHeight + nInStep ) * ( nYS - nYSource - nFullHeight + nInStep ) + ( nXS - nXSource - nFullWidth / 2 ) * ( nXS - nXSource - nFullWidth / 2 )));
// if ( nDistance <= nRadius + 5 && nDistance >= nRadius && nYS <= nYSource + nFullHeight - nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, 5 - (nDistance - nRadius), dEffect);
// if ( nDistance > nRadius && nYS <= nYSource + nFullHeight - nCircleWidth && nYS >= nYSource + nFullHeight - nCircleWidth - 5 && nXS >= nXSource + nCircleWidth + (nYSource + nFullHeight - nCircleWidth - nYS) && nXS <= nXSource + nFullWidth - nCircleWidth - (nYSource + nFullHeight - nCircleWidth - nYS))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, 5 - (nYSource + nFullHeight - nCircleWidth - nYS), dEffect);
// }
// else
// {
// if ( nYS <= nYSource + nFullHeight - nCircleWidth && nYS >= nYSource + nFullHeight - nCircleWidth - 5 && nXS >= nXSource + nCircleWidth + (nYSource + nFullHeight - nCircleWidth - nYS) && nXS <= nXSource + nFullWidth - nCircleWidth - (nYSource + nFullHeight - nCircleWidth - nYS))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, 5 - (nYSource + nFullHeight - nCircleWidth - nYS), dEffect);
// }
//
// if ( 1 == m_nLeftFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nRadius ) * ( nXS - nXSource - nRadius )));
//
// if ( nDistance > nRadius && nXS >= nXSource + nCircleWidth && nXS <= nXSource + nCircleWidth + 5 && nYS >= nYSource + nCircleWidth + (5 - (nXSource + nCircleWidth + 5 - nXS))&& nYS <= nYSource + nFullHeight - nCircleWidth - (5 - (nXSource + nCircleWidth + 5 - nXS)))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, nXSource + nCircleWidth + 5 - nXS, dEffect);
// if ( nDistance <= nRadius && nDistance >= nRadius - 5 && nXS <= nXSource + nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, 5 - (nRadius - nDistance), dEffect);
// }
// else if ( -1 == m_nLeftFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nInStep ) * ( nXS - nXSource - nInStep )));
// if ( nDistance <= nRadius + 5 && nDistance >= nRadius && nXS >= nXSource + nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, 5- (nDistance - nRadius), dEffect);
// if ( nDistance > nRadius && nXS >= nXSource + nCircleWidth && nXS <= nXSource + nCircleWidth + 5 && nYS >= nYSource + nCircleWidth + (5 - (nXSource + nCircleWidth + 5 - nXS))&& nYS <= nYSource + nFullHeight - nCircleWidth - (5 - (nXSource + nCircleWidth + 5 - nXS)))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, nXSource + nCircleWidth + 5 - nXS, dEffect);
// }
// else
// {
// if ( nXS >= nXSource + nCircleWidth && nXS <= nXSource + nCircleWidth + 5 && nYS >= nYSource + nCircleWidth + (5 - (nXSource + nCircleWidth + 5 - nXS))&& nYS <= nYSource + nFullHeight - nCircleWidth - (5 - (nXSource + nCircleWidth + 5 - nXS)))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 255, nXSource + nCircleWidth + 5 - nXS, dEffect);
// }
// if ( 1 == m_nRightFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nFullWidth + nRadius ) * ( nXS - nXSource - nFullWidth + nRadius )));
//
// if ( nDistance > nRadius && nXS <= nXSource + nFullWidth - nCircleWidth && nXS >= nXSource + nFullWidth - nCircleWidth - 5 && nYS >= nYSource + nCircleWidth + (nXSource + nFullWidth - nCircleWidth - nXS)&& nYS <= nYSource + nFullHeight - nCircleWidth - (nXSource + nFullWidth - nCircleWidth - nXS))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, 5 - (nXSource + nFullWidth - nCircleWidth - nXS), dEffect);
// if ( nDistance <= nRadius && nDistance >= nRadius - 5 && nXS >= nXSource + nFullWidth - nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, 5 - (nRadius - nDistance), dEffect);
// }
// else if ( -1 == m_nRightFactor )
// {
// int nDistance = sqrt(double(( nYS - nYSource - nFullHeight / 2 ) * ( nYS - nYSource - nFullHeight / 2 ) + ( nXS - nXSource - nFullWidth + nInStep ) * ( nXS - nXSource - nFullWidth + nInStep )));
//
// if ( nDistance <= nRadius + 5 && nDistance >= nRadius && nXS <= nXSource + nFullWidth - nCircleWidth )
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, 5- (nDistance - nRadius), dEffect);
// if ( nDistance > nRadius && nXS <= nXSource + nFullWidth - nCircleWidth && nXS >= nXSource + nFullWidth - nCircleWidth - 5 && nYS >= nYSource + nCircleWidth + (nXSource + nFullWidth - nCircleWidth - nXS)&& nYS <= nYSource + nFullHeight - nCircleWidth - (nXSource + nFullWidth - nCircleWidth - nXS))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, 5 - (nXSource + nFullWidth - nCircleWidth - nXS), dEffect);
// }
// else
// {
// if ( nXS <= nXSource + nFullWidth - nCircleWidth && nXS >= nXSource + nFullWidth - nCircleWidth - 5 && nYS >= nYSource + nCircleWidth + (nXSource + nFullWidth - nCircleWidth - nXS)&& nYS <= nYSource + nFullHeight - nCircleWidth - (nXSource + nFullWidth - nCircleWidth - nXS))
// DrawAlphaBlendingLine(pResult + nResultIndex, pSource + nSourceIndex, 0, 5 - (nXSource + nFullWidth - nCircleWidth - nXS), dEffect);
// }
}
}
int nXCur = nXResult;
int nYCur = nYResult;
BYTE* pBuffer = pResult;
pBuffer += 4 * nWidth * (nHeight - 1);
Gdiplus::Bitmap oImage( nWidth, nHeight, -4*nWidth, PixelFormat32bppARGB, pBuffer );
if( Gdiplus::Ok == oImage.GetLastStatus() )
{
Gdiplus::Graphics oRender( &oImage );
oRender.SetTextRenderingHint(Gdiplus::TextRenderingHintAntiAlias);
oRender.SetSmoothingMode(Gdiplus::SmoothingModeAntiAlias);
oRender.SetInterpolationMode(Gdiplus::InterpolationModeBilinear);
double dAlphaKoef = nAlpha / 255.0;
int nAlphaBlack = 448 * dAlphaKoef;
int nAlphaWhite = 448 * dAlphaKoef;
for (int nIndex = 0; nIndex < 4; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1)
{
nAlphaBlack = 224 * dAlphaKoef;
nAlphaWhite = 224 * dAlphaKoef;
}
Gdiplus::Pen oPen( Color( nAlphaBlack, 0, 0, 0) , 1);
if ( 0 == m_nRightFactor )
oRender.DrawLine(&oPen, float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex), float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nCircleWidth + nIndex));
else
{
if ( 1 == m_nRightFactor)
oRender.DrawArc(&oPen, float(nXResult + nFullWidth - 2 * nRadius + nIndex), nHeight - float(nYResult + nFullHeight / 2 + nRadius - nIndex), float(2 * (nRadius - nIndex)), float(2 * (nRadius - nIndex)), 180 + dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nRightFactor)
oRender.DrawArc(&oPen, float(nXResult + nFullWidth - 2 * nRadius - nIndex - 2 * dStep), nHeight - float(nYResult + nFullHeight / 2 + nRadius + nIndex), float(2 * (nRadius + nIndex)), float(2 * (nRadius + nIndex)), dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oRender.DrawLine(&oPen, float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex), float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nFullHeight / 2 + dSrez +nIndex));
oRender.DrawLine(&oPen, float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nFullHeight / 2 - dSrez - nIndex), float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nCircleWidth + nIndex));
}
if ( 0 == m_nTopFactor )
oRender.DrawLine(&oPen, float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nCircleWidth + nIndex), float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nCircleWidth + nIndex));
else
{
if ( 1 == m_nTopFactor)
oRender.DrawArc(&oPen, float(nXResult + nFullWidth / 2 - nRadius + nIndex), nHeight - float(nYResult + 2 * nRadius - nIndex), float(2 * (nRadius - nIndex)), float(2 * (nRadius - nIndex)), 270 + dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nTopFactor)
oRender.DrawArc(&oPen, float(nXResult + nFullWidth / 2 - nRadius - nIndex), nHeight - float(nYResult + 2 * nRadius + nIndex + 2 * dStep), float(2 * (nRadius + nIndex)), float(2 * (nRadius + nIndex)), 90 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oRender.DrawLine(&oPen, float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nCircleWidth + nIndex), float(nXResult + nFullWidth / 2 + dSrez + nIndex), nHeight - float(nYResult + nCircleWidth + nIndex));
oRender.DrawLine(&oPen, float(nXResult + nFullWidth / 2 - dSrez - nIndex), nHeight - float(nYResult + nCircleWidth + nIndex), float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nCircleWidth + nIndex));
}
nAlphaWhite /= 2;
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
if ( 0 == m_nLeftFactor )
oRender.DrawLine(&oPen, float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nCircleWidth + nIndex), float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex));
else
{
if ( 1 == m_nLeftFactor)
oRender.DrawArc(&oPen, float(nXResult + nIndex), nHeight - float(nYResult + nFullHeight / 2 + nRadius - nIndex), float(2 * (nRadius - nIndex)), float(2 * (nRadius - nIndex)), dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nLeftFactor)
oRender.DrawArc(&oPen, float(nXResult - nIndex + 2 * dStep), nHeight - float(nYResult + nFullHeight / 2 + nRadius + nIndex), float(2 * (nRadius + nIndex)), float(2 * (nRadius + nIndex)), 180 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oRender.DrawLine(&oPen, float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nCircleWidth + nIndex), float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nFullHeight / 2 - dSrez - nIndex));
oRender.DrawLine(&oPen, float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nFullHeight / 2 + dSrez + nIndex), float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex));
}
if ( 0 == m_nBottomFactor )
oRender.DrawLine(&oPen, float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex), float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex));
else
{
if ( 1 == m_nBottomFactor)
oRender.DrawArc(&oPen, float(nXResult + nFullWidth / 2 - nRadius + nIndex), nHeight - float(nYResult + nFullHeight - nIndex), float(2 * (nRadius - nIndex)), float(2 * (nRadius - nIndex)), 90 + dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nBottomFactor)
oRender.DrawArc(&oPen, float(nXResult + nFullWidth / 2 - nRadius - nIndex), nHeight - float(nYResult + nFullHeight + nIndex - 2 * dStep), float(2 * (nRadius + nIndex)), float(2 * (nRadius + nIndex)), 270 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oRender.DrawLine(&oPen, float(nXResult + nFullWidth - nCircleWidth - nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex), float(nXResult + nFullWidth / 2 + dSrez + nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex));
oRender.DrawLine(&oPen, float(nXResult + nFullWidth / 2 - dSrez - nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex), float(nXResult + nCircleWidth + nIndex), nHeight - float(nYResult + nFullHeight - nCircleWidth - nIndex));
}
}
}
return TRUE;
}
BOOL Draw(Gdiplus::Graphics *oMainRender, Gdiplus::TextureBrush *oBrush, double dXCoorResult, double dYCoorResult, int nWidth, int nHeight, double dEffect)
{
if(!oMainRender || !oBrush || nWidth != m_nPicWidth || nHeight != m_nPicHeight )
return FALSE;
int nSize = 4 * nHeight * nWidth;
double dDiagonal = min(m_nFigHeight, m_nFigWidth);
double dUnit = 1 / (72.0) * dDiagonal;
double dCircleWidth = 26 * dUnit; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20>.<2E>. 2 * <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> - (<28><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
double dRadius = 15 * dUnit; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
double dSqrRadius = dRadius * dRadius;
double dDiff = dCircleWidth - dRadius;
double dInStep = 37 * dUnit;
double dStep = 11 * dUnit;
double dSrez = sqrt(dSqrRadius - dStep * dStep);
double dAngle = acos(11 * dUnit / dRadius) * 180 / IPP_PI;
double dXSur = m_nXCoorSource;
double dYSur = m_nYCoorSource;
double dFullHeight = m_nFigHeight + 2 * dCircleWidth; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
double dFullWidth = m_nFigWidth + 2 * dCircleWidth; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
double dXResult = dXCoorResult - dCircleWidth;
double dYResult = dYCoorResult - dCircleWidth;
Gdiplus::GraphicsPath oPathAddEllipse;
if ( 1 == m_nLeftFactor )
oPathAddEllipse.AddEllipse( float(dXSur - dCircleWidth), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); // left
if ( 1 == m_nRightFactor )
oPathAddEllipse.AddEllipse( float(dXSur + dCircleWidth + m_nFigWidth - 2 * dRadius), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); //right
if ( 1 == m_nBottomFactor )
oPathAddEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur + m_nFigHeight + dCircleWidth), float(2 * dRadius), float(2 * dRadius)); //bottom
if ( 1 == m_nTopFactor )
oPathAddEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur - dCircleWidth + 2 * dRadius), float(2 * dRadius), float(2 * dRadius)); //top
oPathAddEllipse.CloseFigure();
Gdiplus::GraphicsPath oPathExclEllipse;
if ( -1 == m_nLeftFactor )
oPathExclEllipse.AddEllipse( float(dXSur - dCircleWidth + 2 * dDiff), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); // left
if ( -1 == m_nRightFactor )
oPathExclEllipse.AddEllipse( float(dXSur + dCircleWidth + m_nFigWidth - 2 * dRadius - 2 * dDiff), nHeight - float(dYSur + m_nFigHeight / 2 + dRadius), float(2 * dRadius), float(2 * dRadius)); //right
if ( -1 == m_nBottomFactor )
oPathExclEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur + m_nFigHeight + dCircleWidth - 2 * dDiff),float(2 * dRadius), float(2 * dRadius)); //bottom
if ( -1 == m_nTopFactor )
oPathExclEllipse.AddEllipse( float(dXSur + m_nFigWidth / 2 - dRadius), nHeight - float(dYSur - dCircleWidth + 2 * dRadius + 2 * dDiff), float(2 * dRadius), float(2 * dRadius)); //top
oPathExclEllipse.CloseFigure();
Gdiplus::Region oRegion(&oPathAddEllipse);
oRegion.Union(Gdiplus::RectF(dXSur, nHeight - (dYSur + m_nFigHeight), m_nFigWidth, m_nFigHeight));
oRegion.Exclude(&oPathExclEllipse);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
oBrush->TranslateTransform(-float(m_nXCoorSource - dXCoorResult), float(m_nYCoorSource - dYCoorResult), MatrixOrderAppend);
oRegion.Translate(-float(m_nXCoorSource - dXCoorResult), float(m_nYCoorSource - dYCoorResult));
oMainRender->FillRegion(oBrush, &oRegion);
int nAlphaBlack = 448 * dEffect;
int nAlphaWhite = 448 * dEffect;
for (int nIndex = 0; nIndex < 4; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1)
{
nAlphaBlack = 224 * dEffect;
nAlphaWhite = 224 * dEffect;
}
Gdiplus::Pen oPen( Color( nAlphaBlack, 0, 0, 0) , 1);
if ( 0 == m_nRightFactor )
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
else
{
if ( 1 == m_nRightFactor)
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth - 2 * dRadius + nIndex), nHeight - float(dYResult + dFullHeight / 2 + dRadius - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), 180 + dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nRightFactor)
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth - 2 * dRadius - nIndex - 2 * dStep), nHeight - float(dYResult + dFullHeight / 2 + dRadius + nIndex), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight / 2 + dSrez +nIndex));
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight / 2 - dSrez - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
}
if ( 0 == m_nTopFactor )
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
else
{
if ( 1 == m_nTopFactor)
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius + nIndex), nHeight - float(dYResult + 2 * dRadius - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), 270 + dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nTopFactor)
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius - nIndex), nHeight - float(dYResult + 2 * dRadius + nIndex + 2 * dStep), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), 90 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dFullWidth / 2 + dSrez + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth / 2 - dSrez - nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex));
}
nAlphaWhite /= 2;
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
if ( 0 == m_nLeftFactor )
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
else
{
if ( 1 == m_nLeftFactor)
oMainRender->DrawArc(&oPen, float(dXResult + nIndex), nHeight - float(dYResult + dFullHeight / 2 + dRadius - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nLeftFactor)
oMainRender->DrawArc(&oPen, float(dXResult - nIndex + 2 * dStep), nHeight - float(dYResult + dFullHeight / 2 + dRadius + nIndex), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), 180 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dCircleWidth + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight / 2 - dSrez - nIndex));
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight / 2 + dSrez + nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
}
if ( 0 == m_nBottomFactor )
oMainRender->DrawLine(&oPen, float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
else
{
if ( 1 == m_nBottomFactor)
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius + nIndex), nHeight - float(dYResult + dFullHeight - nIndex), float(2 * (dRadius - nIndex)), float(2 * (dRadius - nIndex)), 90 + dAngle, 360 - 2 * dAngle);
else if ( -1 == m_nBottomFactor)
oMainRender->DrawArc(&oPen, float(dXResult + dFullWidth / 2 - dRadius - nIndex), nHeight - float(dYResult + dFullHeight + nIndex - 2 * dStep), float(2 * (dRadius + nIndex)), float(2 * (dRadius + nIndex)), 270 + dAngle + nIndex, 360 - 2 * dAngle - 2* nIndex);
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth - dCircleWidth - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dFullWidth / 2 + dSrez + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
oMainRender->DrawLine(&oPen, float(dXResult + dFullWidth / 2 - dSrez - nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex), float(dXResult + dCircleWidth + nIndex), nHeight - float(dYResult + dFullHeight - dCircleWidth - nIndex));
}
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
oRegion.Translate(float(m_nXCoorSource - dXCoorResult), - float(m_nYCoorSource - dYCoorResult));
oBrush->TranslateTransform(float(m_nXCoorSource - dXCoorResult), - float(m_nYCoorSource - dYCoorResult), MatrixOrderAppend);
return TRUE;
}
public:
int m_nFigHeight;
int m_nFigWidth;
int m_nPicHeight;
int m_nPicWidth;
int m_nLeftFactor; // -1, 0, +1
int m_nRightFactor; // -1 : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int m_nTopFactor; // 0 : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int m_nBottomFactor; // +1 : <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
BYTE* m_pBGRASource;
int m_nXCoorSource; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int m_nYCoorSource; //
};
class CPuzzleUtility
{
public:
DWORD m_dwBaseRnd;
CPuzzleUtility()
{
g_pShuffle = 0;
g_nShuffleCount = -1;
g_pCorners = 0;
g_nCornersCount = -1;
g_pHorizontalFactor = 0;
g_pVerticalFactor = 0;
g_nRow = -1;
g_nCol = -1;
g_nTypeShuffle = -1;
g_nTypeCorners = -1;
g_nTypeGenerate = -1;
m_dwBaseRnd = ::rand();
}
~CPuzzleUtility()
{
if ( g_pShuffle )
delete []g_pShuffle;
if ( g_pCorners )
delete []g_pCorners;
if ( g_pHorizontalFactor )
delete []g_pHorizontalFactor;
if ( g_pVerticalFactor )
delete []g_pVerticalFactor;
}
void GenerateRandomShuffle(int nXCount, int nYCount, int nShuffle, int nPuzzleType)
{
int nCount = nXCount * nYCount;
if ( g_pShuffle && nCount == g_nShuffleCount && nPuzzleType == g_nTypeShuffle)
return;
if ( g_pShuffle )
delete []g_pShuffle;
g_nTypeShuffle = nPuzzleType;
g_nShuffleCount = nCount;
g_pShuffle = new int[nCount];
for(int nIndex = 0; nIndex < nCount; nIndex++)
g_pShuffle[nIndex] = nIndex;
if ( 0 == nShuffle )
return;
else if ( 1 == nShuffle )
{
::srand( m_dwBaseRnd );
std::random_shuffle(g_pShuffle, g_pShuffle + nCount);
return;
}
else if ( 2 == nShuffle )
{
for (int nIndex = 0; nIndex < nCount; nIndex++ )
{
g_pShuffle[nIndex] = nCount - 1 - nIndex;
}
return;
}
else if ( 3 == nShuffle )
{
int nYLevel = 0;
for (int nYIndex = 0; nYIndex < nYCount; nYIndex++, nYLevel = (nYLevel + 1) % 2 )
{
for (int nXIndex = 0; nXIndex < nXCount; nXIndex++ )
{
int nIndex = nYIndex * nXCount + nXIndex;
if ( 0 == nYLevel )
g_pShuffle[nIndex] = nCount - 1 - nIndex;
else
g_pShuffle[nIndex] = nCount - 1 - (nYIndex * nXCount + nXCount - 1 - nXIndex);
}
}
}
else if ( 4 == nShuffle )
{
for (int nYIndex = 0; nYIndex < nYCount; nYIndex++ )
{
for (int nXIndex = 0; nXIndex < nXCount; nXIndex++ )
{
int nIndex = nYIndex * nXCount + nXIndex;
if ( nXIndex % 2 == 0 )
{
int nCurX = nXIndex / 2;
g_pShuffle[nIndex] = nCount - 1 - nYIndex * nXCount - nCurX;
}
else
{
int nCurX = (nXIndex + 1) / 2;
g_pShuffle[nIndex] = nCount - 1 - (nYIndex * nXCount + nXCount - 1 - nCurX);
}
}
}
}
return;
}
void GenerateCorners(int nWidth, int nHeight, int nCount, int nType, int nPuzzleType)
{
if ( g_pCorners && nCount == g_nCornersCount && nPuzzleType == g_nTypeCorners && nHeight == g_nPicHeight && nWidth == g_nPicWidth )
return;
if ( g_pCorners )
delete []g_pCorners;
g_nPicWidth = nWidth;
g_nPicHeight = nHeight;
g_nTypeCorners = nPuzzleType;
g_nCornersCount = nCount;
g_pCorners = new int[nCount];
if ( (0 <= nType && nType <= 3) || 5 == nType || 6 == nType || 7 == nType)
{
for ( int nIndex = 0; nIndex < nCount; nIndex++)
g_pCorners[nIndex] = nType;
}
else if ( 4 == nType )
{
CRandom rnd( m_dwBaseRnd );
for ( int nIndex = 0; nIndex < nCount; nIndex++)
g_pCorners[nIndex] = rnd.Rand( 4 );
}
return;
}
void GeneratePuzzle(int nRow, int nCol, int nPuzzleType)
{
if ( g_pHorizontalFactor && g_pVerticalFactor && nRow == g_nRow && nCol == g_nCol && nPuzzleType == g_nTypeGenerate)
return;
if ( g_pHorizontalFactor )
delete []g_pHorizontalFactor;
if ( g_pVerticalFactor )
delete []g_pVerticalFactor;
int nSize = nCol * nRow * 2;
g_nTypeGenerate = nPuzzleType;
g_nRow = nRow;
g_nCol = nCol;
g_pHorizontalFactor = new int[nSize];
g_pVerticalFactor = new int[nSize];
CRandom rnd( m_dwBaseRnd );
for ( int nYIndex = 0, nIndex = 0; nYIndex < nRow; nYIndex++ )
{
for ( int nXIndex = 0; nXIndex < nCol; nXIndex++, nIndex += 2 )
{
if ( 1 == nRow )
{
g_pHorizontalFactor[nIndex + 0] = 0;
g_pHorizontalFactor[nIndex + 1] = 0;
continue;
}
if ( 0 == nYIndex )
{
g_pHorizontalFactor[nIndex + 0] = 0;
g_pHorizontalFactor[nIndex + 1] = -1 + 2 * rnd.Rand( 2 );
}
else if ( nRow - 1 == nYIndex )
{
g_pHorizontalFactor[nIndex + 1] = 0;
g_pHorizontalFactor[nIndex + 0] = - g_pHorizontalFactor[nIndex - nCol * 2 + 1];
}
else
{
g_pHorizontalFactor[nIndex + 1] = -1 + 2 * rnd.Rand( 2 );
g_pHorizontalFactor[nIndex + 0] = - g_pHorizontalFactor[nIndex - nCol * 2 + 1];
}
if ( 1 == nCol )
{
g_pVerticalFactor[nIndex + 0] = 0;
g_pVerticalFactor[nIndex + 1] = 0;
continue;
}
if ( 0 == nXIndex )
{
g_pVerticalFactor[nIndex + 0] = 0;
g_pVerticalFactor[nIndex + 1] = -1 + 2 * rnd.Rand( 2 );
}
else if ( nCol - 1 == nXIndex )
{
g_pVerticalFactor[nIndex + 1] = 0;
g_pVerticalFactor[nIndex + 0] = - g_pVerticalFactor[nIndex - 1];
}
else
{
g_pVerticalFactor[nIndex + 1] = -1 + 2 * rnd.Rand( 2 );
g_pVerticalFactor[nIndex + 0] = - g_pVerticalFactor[nIndex - 1];
}
}
}
return;
}
int GetStartX(int nFigWidth, int nFigHeight, int nXResult, int nYResult, int nIndex, int nCurX)
{
int nXStart = 0;
switch(nIndex)
{
case 0: nXStart = - nFigWidth; break;
case 1: nXStart = g_nPicWidth + nFigWidth; break;
case 2: nXStart = g_nPicWidth + nFigWidth; break;
case 3: nXStart = - nFigWidth; break;
case 5: nXStart = nXResult; break;
case 6: nXStart = nXResult; break;
case 7:
{
if (nCurX % 2)
nXStart = -nFigWidth;
else
nXStart = g_nPicWidth + nFigWidth;
}
}
return nXStart;
}
int GetStartY(int nFigWidth, int nFigHeight, int nXResult, int nYResult, int nIndex)
{
int nYStart = 0;
switch(nIndex)
{
case 0: nYStart = - nFigHeight; break;
case 1: nYStart = - nFigHeight; break;
case 2: nYStart = g_nPicHeight + nFigHeight; break;
case 3: nYStart = g_nPicHeight + nFigHeight; break;
case 5: nYStart = - nFigHeight; break;
case 6: nYStart = g_nPicHeight + nFigHeight; break;
case 7: nYStart = - nFigHeight; break;
}
return nYStart;
}
public:
//<2F><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD>
int *g_pShuffle;
int g_nShuffleCount;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int *g_pCorners;
int g_nCornersCount;
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int *g_pHorizontalFactor;
int *g_pVerticalFactor;
int g_nRow;
int g_nCol;
int g_nTypeShuffle;
int g_nTypeCorners;
int g_nTypeGenerate;
protected:
int g_nPicWidth;
int g_nPicHeight;
};
class CFigure
{
public:
CFigure()
{
m_dBigRadius = -1;
m_nPicHeight = -1;
m_nPicWidth = -1;
m_pBGRASource = 0;
m_dXCoorSource = -1;
m_dYCoorSource = -1;
m_arrPoints = 0;
m_nFigureType = -1;
m_nPointsCount = -1;
}
~CFigure()
{
if ( m_arrPoints )
delete[] m_arrPoints;
}
public:
void SetValue(int nFigureType, double dSide, BYTE* pBGRASource, int nPicWidth, int nPicHeight, double dXCoorSource, double dYCoorSource)
{
m_nPicHeight = nPicHeight;
m_nPicWidth = nPicWidth;
m_pBGRASource = pBGRASource;
m_dXCoorSource = dXCoorSource;
m_dYCoorSource = dYCoorSource;
m_arrPoints = 0;
m_nPointsCount = -1;
m_nFigureType = nFigureType;
// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if ( 6 == m_nFigureType )
{
m_dBigRadius = dSide;
m_dShiftX = m_dBigRadius / 2;
m_dShiftY = sqrt(3.0) * m_dBigRadius / 2;
}
else if ( 30 == m_nFigureType || 31 == m_nFigureType)
{
m_dBigRadius = sqrt(3.0) * dSide / 3; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
m_dShiftY = m_dBigRadius / 2; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
m_dShiftX = dSide / 2;
}
else if ( 41 == m_nFigureType )
{
m_dBigRadius = dSide / sqrt(2.0);
}
else if ( 42 == m_nFigureType )
{
m_dShiftX = dSide / 2;
m_dShiftY = dSide * ( 12.0 / 25.0 ) / 2;
}
else if ( 43 == m_nFigureType )
{
m_dShiftX = dSide / 2;
m_dShiftY = dSide * ( 12.0 / 25.0 ) / 2;
}
}
BOOL Draw(Gdiplus::Graphics *oMainRender, Gdiplus::TextureBrush *oBrush, double dXCoorResult, double dYCoorResult, int nWidth, int nHeight, double dEffect)
{
if(!oMainRender || !oBrush || nWidth != m_nPicWidth || nHeight != m_nPicHeight)
return FALSE;
int nSize = 4 * nHeight * nWidth;
CreatePolygon(m_nFigureType, m_dXCoorSource, m_dYCoorSource);
Gdiplus::GraphicsPath oPath;
oPath.AddPolygon(m_arrPoints, m_nPointsCount);
oPath.CloseFigure();
Gdiplus::Region oRegion(&oPath);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
oBrush->TranslateTransform(-float(m_dXCoorSource - dXCoorResult), -float(m_dYCoorSource - dYCoorResult), MatrixOrderAppend);
oRegion.Translate(-float(m_dXCoorSource - dXCoorResult), -float(m_dYCoorSource - dYCoorResult));
oMainRender->FillRegion(oBrush, &oRegion);
if (6 == m_nFigureType)
DrawHexagonBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
else if ( 30 == m_nFigureType || 31 == m_nFigureType )
DrawTriangleBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
else if ( 41 == m_nFigureType )
DrawRhombusBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
else if ( 42 == m_nFigureType )
DrawBrickBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
else if ( 43 == m_nFigureType )
DrawInclinedBrickBorder(oMainRender, dXCoorResult, dYCoorResult, dEffect);
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
oRegion.Translate(float(m_dXCoorSource - dXCoorResult), float(m_dYCoorSource - dYCoorResult));
oBrush->TranslateTransform(float(m_dXCoorSource - dXCoorResult), float(m_dYCoorSource - dYCoorResult), MatrixOrderAppend);
return TRUE;
}
protected:
BOOL CreatePolygon(int nNumber, double dX, double dY)
{
if (m_arrPoints)
delete []m_arrPoints;
if (6 == nNumber)
{
m_nPointsCount = 6;
m_arrPoints = new Gdiplus::PointF[6];
int nRadius = m_dBigRadius;
double dXShift = m_dShiftX;
double dYShift = m_dShiftY;
m_arrPoints[0].X = dX - dXShift;
m_arrPoints[0].Y = dY + dYShift;
m_arrPoints[1].X = dX + dXShift;
m_arrPoints[1].Y = dY + dYShift;
m_arrPoints[2].X = dX + nRadius;
m_arrPoints[2].Y = dY;
m_arrPoints[3].X = dX + dXShift;
m_arrPoints[3].Y = dY - dYShift;
m_arrPoints[4].X = dX - dXShift;
m_arrPoints[4].Y = dY - dYShift;
m_arrPoints[5].X = dX - nRadius;
m_arrPoints[5].Y = dY;
}
else if ( 30 == nNumber )
{
m_nPointsCount = 3;
m_arrPoints = new Gdiplus::PointF[3];
m_arrPoints[0].X = dX - m_dShiftX;
m_arrPoints[0].Y = dY + m_dShiftY;
m_arrPoints[1].X = dX;
m_arrPoints[1].Y = dY - m_dBigRadius;
m_arrPoints[2].X = dX + m_dShiftX;
m_arrPoints[2].Y = dY + m_dShiftY;
}
else if ( 31 == nNumber )
{
m_nPointsCount = 3;
m_arrPoints = new Gdiplus::PointF[3];
m_arrPoints[0].X = dX;
m_arrPoints[0].Y = dY + m_dBigRadius;
m_arrPoints[1].X = dX - m_dShiftX;
m_arrPoints[1].Y = dY - m_dShiftY;
m_arrPoints[2].X = dX + m_dShiftX;
m_arrPoints[2].Y = dY - m_dShiftY;
}
else if ( 41 == m_nFigureType )
{
m_nPointsCount = 4;
m_arrPoints = new Gdiplus::PointF[4];
m_arrPoints[0].X = dX - m_dBigRadius;
m_arrPoints[0].Y = dY;
m_arrPoints[1].X = dX;
m_arrPoints[1].Y = dY + m_dBigRadius;
m_arrPoints[2].X = dX + m_dBigRadius;
m_arrPoints[2].Y = dY;
m_arrPoints[3].X = dX;
m_arrPoints[3].Y = dY - m_dBigRadius;
}
else if ( 42 == m_nFigureType )
{
m_nPointsCount = 4;
m_arrPoints = new Gdiplus::PointF[4];
m_arrPoints[0].X = dX - m_dShiftX;
m_arrPoints[0].Y = dY - m_dShiftY;
m_arrPoints[1].X = dX + m_dShiftX;
m_arrPoints[1].Y = dY - m_dShiftY;
m_arrPoints[2].X = dX + m_dShiftX;
m_arrPoints[2].Y = dY + m_dShiftY;
m_arrPoints[3].X = dX - m_dShiftX;
m_arrPoints[3].Y = dY + m_dShiftY;
}
else if ( 43 == m_nFigureType )
{
m_nPointsCount = 4;
m_arrPoints = new Gdiplus::PointF[4];
double dCos = cos(-IPP_PI4);
double dSin = sin(-IPP_PI4);
m_arrPoints[3].X = - m_dShiftX * dCos - (- m_dShiftY) * dSin + dX;
m_arrPoints[3].Y = - m_dShiftX * dSin + (- m_dShiftY) * dCos + dY;
m_arrPoints[2].X = m_dShiftX * dCos - (- m_dShiftY) * dSin + dX;
m_arrPoints[2].Y = m_dShiftX * dSin + (- m_dShiftY) * dCos + dY;
m_arrPoints[1].X = m_dShiftX * dCos - ( m_dShiftY) * dSin + dX;
m_arrPoints[1].Y = m_dShiftX * dSin + ( m_dShiftY) * dCos + dY;
m_arrPoints[0].X = - m_dShiftX * dCos - ( m_dShiftY) * dSin + dX;
m_arrPoints[0].Y = - m_dShiftX * dSin + ( m_dShiftY) * dCos + dY;
}
return TRUE;
}
BOOL DrawHexagonBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
{
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
int nAlphaBlack = 448 * dEffect;
int nAlphaWhite = 448 * dEffect;
for ( int nIndex = 0; nIndex < 5; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1)
{
nAlphaBlack = 224 * dEffect;
nAlphaWhite = 224 * dEffect;
}
nAlphaWhite /= 2;
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[4]);
oMainRender->DrawLine(&oPen, m_arrPoints[4], m_arrPoints[5]);
oMainRender->DrawLine(&oPen, m_arrPoints[5], m_arrPoints[0]);
m_arrPoints[0].X++;
m_arrPoints[0].Y--;
m_arrPoints[1].X--;
m_arrPoints[1].Y--;
m_arrPoints[2].X--;
m_arrPoints[3].X--;
m_arrPoints[3].Y++;
m_arrPoints[4].X++;
m_arrPoints[4].Y++;
m_arrPoints[5].X++;
}
return TRUE;
}
BOOL DrawTriangleBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
{
if (30 == m_nFigureType )
{
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
int nAlphaBlack = 448 * dEffect;
int nAlphaWhite = 448 * dEffect;
for ( int nIndex = 0; nIndex < 5; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1 || nIndex == 2)
{
nAlphaBlack = 224 * dEffect;
nAlphaWhite = 224 * dEffect;
}
nAlphaWhite /= 2;
if(nIndex == 0)
{
nAlphaWhite = 128;
nAlphaBlack = 128;
}
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[0]);
m_arrPoints[0].X ++;
m_arrPoints[0].Y -= float(0.4);
m_arrPoints[1].Y++;
m_arrPoints[2].X --;
m_arrPoints[2].Y -= float(0.4);
}
}
else if ( 31 == m_nFigureType)
{
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
int nAlphaBlack = 448 * dEffect;
int nAlphaWhite = 448 * dEffect;
for ( int nIndex = 0; nIndex < 5; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1 || nIndex == 2)
{
nAlphaBlack = 224 * dEffect;
nAlphaWhite = 224 * dEffect;
}
nAlphaWhite /= 2;
if(nIndex == 0)
{
nAlphaWhite = 128;
nAlphaBlack = 128;
}
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[0]);
m_arrPoints[0].Y--;
m_arrPoints[1].X ++;
m_arrPoints[1].Y += float(0.4);
m_arrPoints[2].X --;
m_arrPoints[2].Y += float(0.4);
}
}
return TRUE;
}
BOOL DrawRhombusBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
{
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
int nAlphaBlack = 448 * dEffect;
int nAlphaWhite = 448 * dEffect;
for ( int nIndex = 0; nIndex < 5; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1)
{
nAlphaBlack = 224 * dEffect;
nAlphaWhite = 224 * dEffect;
}
nAlphaWhite /= 2;
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[0]);
m_arrPoints[0].X++;
m_arrPoints[1].Y--;
m_arrPoints[2].X--;
m_arrPoints[3].Y++;
}
return TRUE;
}
BOOL DrawBrickBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
{
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
int nAlphaBlack = 448 * dEffect;
int nAlphaWhite = 448 * dEffect;
for ( int nIndex = 0; nIndex < 5; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1)
{
nAlphaBlack = 224 * dEffect;
nAlphaWhite = 224 * dEffect;
}
nAlphaWhite /= 2;
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[0]);
m_arrPoints[0].X++;
m_arrPoints[0].Y++;
m_arrPoints[1].X--;
m_arrPoints[1].Y++;
m_arrPoints[2].X--;
m_arrPoints[2].Y--;
m_arrPoints[3].X++;
m_arrPoints[3].Y--;
}
return TRUE;
}
BOOL DrawInclinedBrickBorder(Gdiplus::Graphics *oMainRender, double dXCoorResult, double dYCoorResult, double dEffect)
{
Gdiplus::Pen oPen(Color(0, 0, 0), 1);
CreatePolygon(m_nFigureType, dXCoorResult, dYCoorResult);
int nAlphaBlack = 448 * dEffect;
int nAlphaWhite = 448 * dEffect;
for ( int nIndex = 0; nIndex < 5; nIndex++ )
{
nAlphaBlack /= 2;
if (nIndex == 1)
{
nAlphaBlack = 224 * dEffect;
nAlphaWhite = 224 * dEffect;
}
nAlphaWhite /= 2;
//oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oMainRender->DrawLine(&oPen, m_arrPoints[0], m_arrPoints[1]);
oMainRender->DrawLine(&oPen, m_arrPoints[1], m_arrPoints[2]);
//oPen.SetColor(Color(nAlphaBlack, 0, 0, 0));
oPen.SetColor(Color(nAlphaWhite, 255, 255, 255));
oMainRender->DrawLine(&oPen, m_arrPoints[2], m_arrPoints[3]);
oMainRender->DrawLine(&oPen, m_arrPoints[3], m_arrPoints[0]);
m_arrPoints[1].X--;
m_arrPoints[2].Y++;
m_arrPoints[3].X++;
m_arrPoints[0].Y--;
}
return TRUE;
}
public:
double m_dBigRadius;
int m_nPicHeight;
int m_nPicWidth;
BYTE* m_pBGRASource;
double m_dXCoorSource;
double m_dYCoorSource;
int m_nFigureType;
// 30, 31 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>)
// 6 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// 41 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> 45 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// 42 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20> <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> 25:12)
// 43 - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD> 45 <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
protected:
double m_dShiftY; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
double m_dShiftX; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
Gdiplus::PointF* m_arrPoints;
int m_nPointsCount;
};
}
}
}
}
#pragma warning(default: 4244)
Reference in New Issue View Git Blame Copy Permalink