// InspectionBuffer.cpp: implementation of the CSISBuffer class.
|
//
|
//////////////////////////////////////////////////////////////////////
|
|
#include "stdafx.h"
|
#include "InspectionBuffer.h"
|
|
#ifdef _DEBUG
|
#undef THIS_FILE
|
static char THIS_FILE[]=__FILE__;
|
#define new DEBUG_NEW
|
#endif
|
|
//////////////////////////////////////////////////////////////////////
|
// Construction/Destruction
|
//////////////////////////////////////////////////////////////////////
|
|
void CSISBuffer::MemSet(BYTE val)
|
{
|
memset(GetDataAddress(), val, GetDataSize());
|
return;
|
for(int i= 0; i< GetHeight(); i++)
|
{
|
memset(GetDataAddress(0, i), val, GetWidth());
|
}
|
}
|
|
void CSISBuffer::FlipUpDown()
|
{
|
int hh= GetHeight()/2;
|
int eh= GetHeight()- 1;
|
LPBYTE lpBuffer = new BYTE[hh*GetDataWidth()];
|
|
memcpy(lpBuffer, GetDataAddress(), hh*GetDataWidth());
|
|
CSISBuffer temp(lpBuffer, GetWidth(), hh);
|
for (int i = 0; i <hh; i++)
|
{
|
memcpy(GetDataAddress(0, i), GetDataAddress(0, eh- i), GetDataWidth());
|
memcpy(GetDataAddress(0, eh-i), temp.GetDataAddress(0, i), GetDataWidth());
|
}
|
|
delete [] lpBuffer;
|
}
|
|
BOOL CSISBuffer::IsValidBuffer()
|
{
|
if(!m_pData)
|
return FALSE;
|
if(GetWidth() < 1 || GetHeight() < 1)
|
return FALSE;
|
return TRUE;
|
}
|
|
BYTE CSISBuffer::GetPixel(double fx, int y)
|
{
|
int x= (int)fx;
|
double second= fx- x;
|
double first= 1- second;
|
BYTE* pData= m_pData+ x+ y*GetDataWidth();
|
first= first*(*(pData));
|
second= second*(*(pData+ 1));
|
return (BYTE)(first+ second);
|
}
|
|
BYTE CSISBuffer::GetPixel(int x, double fy)
|
{
|
int y= (int)fy;
|
double second= fy- y;
|
double first= 1- second;
|
BYTE* pData= m_pData+ x+ y*GetDataWidth();
|
first= first*(*(pData));
|
second= second*(*(pData+ GetDataWidth()));
|
return (BYTE)(first+ second);
|
}
|
|
CRect CSISBuffer::IntersectRect(CRect &rectFrom)
|
{
|
CRect rect= rectFrom;
|
if(rect.left < 0)
|
rect.left= 0;
|
if(rect.top < 0)
|
rect.top= 0;
|
if(rect.right > GetWidth())
|
rect.right= GetWidth();
|
if(rect.bottom > GetHeight())
|
rect.bottom= GetHeight();
|
return rect;
|
}
|
|
int CSISBuffer::GetXDiff22(int x, int y, double xPitch)
|
{
|
int ret;
|
double xRef= x+ xPitch;
|
int iRef= (int)xRef;
|
double r2= xRef- iRef;
|
double r1= 1- r2;
|
|
BYTE *pData= GetDataAddress(x, y);
|
BYTE *pData2= GetDataAddress(iRef, y);
|
|
ret= *pData+ *(pData+ 1);
|
pData+= GetDataWidth();
|
ret+= *pData+ *(pData+ 1);
|
|
ret-= (int)((*pData2)*r1+ *(pData2+ 1)+ *(pData2+2)*r2);
|
pData2+= GetDataWidth();
|
ret-= (int)((*pData2)*r1+ *(pData2+ 1)+ *(pData2+2)*r2);
|
|
return ret;
|
}
|
|
int CSISBuffer::GetYDiff22(int x, int y, double yPitch)
|
{
|
int ret;
|
double yRef= y+ yPitch;
|
int iRef= (int)yRef;
|
double r2= yRef- iRef;
|
double r1= 1- r2;
|
|
BYTE *pData= GetDataAddress(x, y);
|
BYTE *pData2= GetDataAddress(x, iRef);
|
|
ret= *pData+ *(pData+ 1);
|
pData+= GetDataWidth();
|
ret+= *pData+ *(pData+ 1);
|
|
ret-= (int)(((*pData2)+ *(pData2+ 1))*r1);
|
pData2+= GetDataWidth();
|
ret-= (int)(((*pData2)+ *(pData2+ 1)));
|
pData2+= GetDataWidth();
|
ret-= (int)(((*pData2)+ *(pData2+ 1))*r2);
|
|
return ret;
|
}
|
|
int CSISBuffer::GetDiff32(int x, int y, double xPitch)
|
{
|
int ret;
|
double xRef= x+ xPitch;
|
int iRef= (int) xRef;
|
double pb= xRef- iRef;
|
double pa= 1- pb;
|
BYTE *pData= GetDataAddress(x, y);
|
BYTE *pData2= GetDataAddress(iRef, y);
|
|
ret= *pData+ *(pData+ 1)+ *(pData+2);
|
pData+= GetDataWidth();
|
ret+= *pData+ *(pData+ 1)+ *(pData+2);
|
|
ret-= (int)((*pData2)*pa+ *(pData2+ 1)+ *(pData2+2)+ (*(pData2+3))*pb);
|
pData2+= GetDataWidth();
|
ret-= (int)((*pData2)*pa+ *(pData2+ 1)+ *(pData2+2)+ (*(pData2+3))*pb);
|
|
return ret;
|
}
|
|
int CSISBuffer::GetDiff23(int x, int y, double yPitch)
|
{
|
int ret;
|
double yRef= y+ yPitch;
|
int iRef= (int) yRef;
|
double pb= yRef- iRef;
|
double pa= 1- pb;
|
BYTE *pData= GetDataAddress(x, y);
|
BYTE *pData2= GetDataAddress(x, iRef);
|
|
ret= *pData+ *(pData+1);
|
pData+= GetDataWidth();
|
ret+= *pData+ *(pData+1);
|
pData+= GetDataWidth();
|
ret+= *pData+ *(pData+1);
|
|
ret-= (int)((*pData2)*pa+ (*(pData2+1))*pa);
|
pData2+= GetDataWidth();
|
ret-= *pData2+ *(pData2+1);
|
pData2+= GetDataWidth();
|
ret-= *pData2+ *(pData2+1);
|
pData2+= GetDataWidth();
|
ret-= (int)((*pData2)*pb+ (*(pData2+1))*pb);
|
|
return ret;
|
}
|
|
BOOL CSISBuffer::CopyBtoA(CSISBuffer &aBuffer, int x, int y, CSISBuffer &bBuffer, CRect &rectFrom)
|
{
|
if(!aBuffer.IsValidBuffer())
|
return FALSE;
|
if(!bBuffer.IsValidBuffer())
|
return FALSE;
|
|
int xx= 0, yy= 0;
|
int width, ey;
|
|
|
CRect rect= rectFrom;
|
rect.NormalizeRect();
|
rect= bBuffer.IntersectRect(rect);
|
if(rectFrom.top < 0)
|
y-= rectFrom.top;
|
|
if(rectFrom.left < 0)
|
x-= rectFrom.left;
|
|
width= rect.Width();
|
ey= rect.Height();
|
|
if(x+ rect.Width() > aBuffer.GetWidth())
|
{
|
width= aBuffer.GetWidth()- x;
|
}
|
if(x < 0)
|
{
|
xx= -x;
|
width-= xx;
|
}
|
if(y < 0)
|
{
|
yy= -y;
|
}
|
if(y+ rect.Height() > aBuffer.GetHeight())
|
{
|
ey= aBuffer.GetHeight()- y;
|
}
|
|
|
if(width < 0)
|
return FALSE;
|
|
for(;yy < ey; yy++)
|
{
|
memcpy(aBuffer.GetDataAddress(x+ xx, y+ yy), bBuffer.GetDataAddress(rect.left+ xx, rect.top+ yy), width);
|
}
|
|
return TRUE;
|
}
|
|
void CSISBuffer::RotateImage()
|
{
|
if(IsValidBuffer() == FALSE)
|
return;
|
|
BYTE cTemp;
|
|
for(int h = 0; h < m_Height; h++)
|
{
|
for(int w = 0; w < m_Width / 2; w++)
|
{
|
cTemp = m_pData[w + h * m_DataWidth];
|
m_pData[w + h * m_DataWidth] = m_pData[(m_Width - 1 - w) + (m_Height - 1 - h) * m_DataWidth];
|
m_pData[(m_Width - 1 - w) + (m_Height - 1 - h) * m_DataWidth] = cTemp;
|
}
|
}
|
}
|
|
|
CBufferAttach::CBufferAttach(CString &name) : m_FileName(name)
|
{
|
m_bFileMade= FALSE;
|
m_FileName= name;
|
}
|
|
CBufferAttach::~CBufferAttach()
|
{
|
if(m_pImageFileHeader)
|
delete m_pImageFileHeader;
|
}
|
|
BOOL CBufferAttach::MakeFile()
|
{
|
m_pImageFileHeader= new stImageFileHeader;
|
CFile file;
|
if(! file.Open(m_FileName, CFile::modeCreate | CFile::modeWrite | CFile::typeBinary))
|
{
|
//file.Close();
|
return FALSE;
|
}
|
//file.Seek(0, CFile::begin);
|
file.Write(&m_pImageFileHeader->fileHeader, m_pImageFileHeader->fileHeader.bfOffBits);
|
file.Close();
|
m_bFileMade= TRUE;
|
return TRUE;
|
}
|
|
void CBufferAttach::AttachToFile(CSISBuffer &buffer)
|
{
|
CFile file;
|
|
if(! m_bFileMade)
|
{
|
MakeFile();
|
}
|
|
int width= buffer.GetWidth();
|
int height= m_pImageFileHeader->GetHeight()+ buffer.GetHeight();
|
|
m_pImageFileHeader->ChangeSize(width, height);
|
|
if(! file.Open(m_FileName, CFile::modeWrite | CFile::typeBinary))
|
{
|
//file.Close();
|
return;
|
}
|
|
file.Seek(0, CFile::begin);
|
file.Write(&m_pImageFileHeader->fileHeader, m_pImageFileHeader->fileHeader.bfOffBits);
|
file.Seek(0, CFile::end);
|
|
int wData= CSISBuffer::ChangeDataWidth(buffer.GetWidth());
|
for(int i= buffer.GetHeight()- 1; i >= 0; i--)
|
{
|
file.Write(buffer.GetDataAddress(0, i), wData);
|
}
|
file.Close();
|
}
|
|
BOOL CCopyBuffer::FillBuffer(CSISBuffer& buffer, int x, int y)
|
{
|
int end= y+ GetHeight();
|
int yy;
|
for(yy= 0; y< end; y++, yy++)
|
{
|
memcpy(GetDataAddress(0, yy), buffer.GetDataAddress(x, y), GetWidth());
|
}
|
return TRUE;
|
}
|
|
COwnerBuffer::COwnerBuffer(int width, int height)
|
: CSISBuffer(NULL, width, height)
|
{
|
m_DataSpace= 0;
|
SetSize(width, height);
|
}
|
|
void COwnerBuffer::ReleaseSpace()
|
{
|
if(m_pData)
|
delete[] m_pData;
|
CSISBuffer::SetSize(0, 0);
|
m_DataSpace= 0;
|
m_pData= NULL;
|
}
|
|
BOOL COwnerBuffer::SetSize(int width, int height)
|
{
|
int tempwidth= CSISBuffer::ChangeDataWidth(width);//(width+ 3)/4*4;
|
int space= tempwidth*height;
|
if(space < 1)
|
{
|
CSISBuffer::SetSize(0, 0);
|
return FALSE;
|
}
|
|
if(m_DataSpace < space)
|
{
|
ReleaseSpace();
|
}else
|
{
|
CSISBuffer::SetSize(width, height);
|
return IsValidBuffer();
|
}
|
|
if(m_pData == NULL)
|
{
|
m_pData= new BYTE[space+ 16];
|
m_DataSpace= space;
|
}
|
CSISBuffer::SetSize(width, height);
|
|
return IsValidBuffer();
|
}
|
|
COwnerBuffer::~COwnerBuffer()
|
{
|
if(m_pData)
|
{
|
delete[] m_pData;
|
m_pData= NULL;
|
}
|
}
|
/*
|
void stImageFileHeader::ChangeSize(int width, int height)// void ChangeHeader(int width, int height)
|
{
|
infoHeader.biWidth = width;
|
infoHeader.biHeight = height;
|
stBufferSize bufferSize(width, height);
|
infoHeader.biSizeImage = bufferSize.GetDataSize();//width*height*1;
|
|
// fileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD)*256;
|
fileHeader.bfSize = fileHeader.bfOffBits + infoHeader.biSizeImage;
|
}
|
|
void stImageFileHeader::ReadFromFile(CString &fileName)
|
{
|
CFile file;
|
file.Open(fileName, CFile::modeCreate | CFile::typeBinary);
|
ReadFromFile(file);
|
file.Close();
|
}
|
void stImageFileHeader::ReadFromFile(CFile &file)
|
{
|
file.Seek(0, SEEK_SET);
|
file.Read(&fileHeader, sizeof(BITMAPFILEHEADER));
|
file.Read(&infoHeader, sizeof(BITMAPINFOHEADER));
|
file.Read(quad, sizeof(RGBQUAD)*256);
|
ChangeSize(infoHeader.biWidth, infoHeader.biHeight);
|
}
|
*/
|
void CDynamicBuffer::FillBuffer(CSISBuffer &buffer, CRect &rect)
|
{
|
SetSize(rect.Width(), rect.Height());
|
CCopyBuffer copyer(*this);
|
copyer.FillBuffer(buffer, rect.left, rect.top);
|
}
|
CSISImageBuffer::CSISImageBuffer()
|
:CSISBuffer(NULL, 0, 0)
|
{
|
m_pFileHeader= new stImageFileHeader;
|
m_DataSpace= 0;
|
}
|
CSISImageBuffer::~CSISImageBuffer()
|
{
|
if(m_pData)
|
delete[] m_pData;
|
if(m_pFileHeader)
|
delete m_pFileHeader;
|
}
|
|
BOOL CSISImageBuffer::SetSize(int width, int height)
|
{
|
int tempwidth= CSISBuffer::ChangeDataWidth(width);//(width+ 3)/4*4;
|
int space= tempwidth*height;
|
if(space < 1)
|
return FALSE;
|
|
if(m_DataSpace < space)
|
{
|
ReleaseImage();
|
}
|
|
if(m_pData == NULL)
|
{
|
m_pData= new BYTE[space];
|
m_DataSpace= space;
|
}
|
CSISBuffer::SetSize(width, height);
|
m_pFileHeader->ChangeSize(GetWidth(), GetHeight());
|
|
return IsValidBuffer();
|
}
|
|
void CSISImageBuffer::ReleaseImage()
|
{
|
SetSize(0, 0);
|
if(m_pData)
|
delete[] m_pData;
|
m_pData= NULL;
|
}
|
|
BOOL CSISImageBuffer::ReadFromFile(CString &fileName)
|
{
|
CFile file;
|
if(file.Open(fileName, CFile::modeRead | CFile::typeBinary))
|
{
|
m_pFileHeader->ReadFromFile(file);
|
if(SetSize(m_pFileHeader->GetWidth(), m_pFileHeader->GetHeight()))
|
{
|
file.Seek(m_pFileHeader->GetDataOffset(), SEEK_SET);
|
for(int i= GetHeight()-1; i>= 0; i--)
|
{
|
file.Read(GetDataAddress(0, i), GetDataWidth());
|
}
|
//file.Read(m_pData, m_pFileHeader->GetDataSize());
|
}
|
}
|
else
|
return FALSE;
|
|
file.Close();
|
return TRUE;
|
}
|
|
|
CFrameSave_OneFile::CFrameSave_OneFile(CString &fileName_, int startFrame, int saveFrame, int width_, int height_)
|
: idStartFrame(startFrame), nSaveFrame(saveFrame), width(width_), height(height_)
|
, iSaveFrame(0)
|
{
|
pBufferAttach= new CBufferAttach(fileName_);
|
}
|
|
CFrameSave_OneFile::~CFrameSave_OneFile()
|
{
|
if(pBufferAttach)
|
delete pBufferAttach;
|
}
|
|
void CFrameSave_OneFile::SaveFrame(int iFrame, CSISBuffer &frameBuffer)
|
{
|
if(iFrame < idStartFrame)
|
return;
|
|
if(iSaveFrame >= nSaveFrame)
|
return;
|
|
int id;
|
id= iFrame- idStartFrame;
|
if(id != iSaveFrame)
|
{
|
// ¹öÆÛ ÀúÀå ¼ø¼°¡ ´Ù¸£³×??
|
}
|
|
pBufferAttach->AttachToFile(frameBuffer);
|
iSaveFrame++;
|
}
|
