asCScriptObject &asCScriptObject::operator=(const asCScriptObject &other) { if( &other != this ) { asASSERT( other.objType->DerivesFrom(objType) ); asCScriptEngine *engine = objType->engine; // Copy all properties for( asUINT n = 0; n < objType->properties.GetLength(); n++ ) { asCObjectProperty *prop = objType->properties[n]; if( prop->type.IsObject() ) { void **dst = (void**)(((char*)this) + prop->byteOffset); void **src = (void**)(((char*)&other) + prop->byteOffset); if( !prop->type.IsObjectHandle() ) CopyObject(*src, *dst, prop->type.GetObjectType(), engine); else CopyHandle((asDWORD*)src, (asDWORD*)dst, prop->type.GetObjectType(), engine); } else { void *dst = ((char*)this) + prop->byteOffset; void *src = ((char*)&other) + prop->byteOffset; memcpy(dst, src, prop->type.GetSizeInMemoryBytes()); } } } return *this; }
void CDibView::OnEditPaste() { HDIB hNewDIB = NULL; if (OpenClipboard()) { BeginWaitCursor(); hNewDIB = (HDIB) CopyHandle(::GetClipboardData(CF_DIB)); CloseClipboard(); if (hNewDIB != NULL) { CDibDoc* pDoc = GetDocument(); pDoc->ReplaceHDIB(hNewDIB); // and free the old DIB pDoc->InitDIBData(); // set up new size & palette pDoc->SetModifiedFlag(TRUE); SetScrollSizes(MM_TEXT, pDoc->GetDocSize()); OnDoRealize((WPARAM)m_hWnd,0); // realize the new palette pDoc->UpdateAllViews(NULL); } EndWaitCursor(); } }
//**************************************************************************** // Sommaire: Copy l'image du contrôle dans le clipbord. // // Description: // // Entrée: // // Sortie: Bool: TRUE si succès, FALSE autrement. // // Note: //**************************************************************************** BOOL CDib::CopyFromClipboard() { BOOL bRep = FALSE; Empty(); if ( ::OpenClipboard(NULL) ) { CWaitCursor wait; HANDLE h; if ( (h = GetClipboardData (CF_DIB)) != NULL) { /* Delete current DIB and get CF_DIB and * CF_PALETTE format data from the clipboard */ // HANDLE hpal = GetClipboardData (CF_PALETTE); HGLOBAL hDib = CopyHandle (h); if (hDib) { Attach( (HBITMAP)hDib );//??est-ce que ça fonctionne //bRep = true; //LPVOID pData = ::GlobalLock(hDib); //AttachMemory(pData, TRUE, hDib); } } ::CloseClipboard(); } return bRep; }
void CDibView::OnEditCopy() { CDibDoc* pDoc = GetDocument(); // Clean clipboard of contents, and copy the DIB. if (OpenClipboard()) { BeginWaitCursor(); EmptyClipboard(); SetClipboardData (CF_DIB, CopyHandle((HANDLE) pDoc->GetHDIB()) ); CloseClipboard(); EndWaitCursor(); } }
KS_YKT_Clt::KS_YKT_Clt(const KS_YKT_Clt &rhs) { if(rhs.handler_) { if(this->handler_) { DeleteXpackHandle(this->handler_); } CopyHandle(this->handler_,rhs.handler_); this->err_code_ = rhs.err_code_; strcpy(this->err_msg_,rhs.err_msg_); this->record_count_ = rhs.record_count_; this->resp_row_ = rhs.resp_row_; this->resp_read_row_ = rhs.resp_read_row_; this->req_row_ = rhs.req_row_; this->return_code_ = rhs.return_code_; this->time_out_ = rhs.time_out_; } }
// save Jpeg file BOOL CJpeg::Save(LPCSTR lpstrFileName, CDib* pDib, BOOL bColor, int nQuality) { if (pDib == NULL) pDib = m_pDib; if (pDib == NULL) return FALSE; HDIB hDib = CopyHandle(pDib->GetHandle()); if (hDib == NULL) return FALSE; CDib* pDibTmp = new CDib; pDibTmp->Attach(hDib); if (pDibTmp->GetBitCount() != 24) pDibTmp->ConvertFormat(24); UINT uWidth = pDibTmp->GetWidth(); UINT uHeight = pDibTmp->GetHeight(); // convert from DIB format (DWORD aligned, vertically flipped, red and blue swapped) BYTE* tmp = ClearDwordAlign(pDibTmp->GetBitsPtr(), uWidth, WIDTHBYTES(uWidth * 24), uHeight); if (tmp == NULL) return FALSE; // convert from DIB VertFlipBuf(tmp, uWidth*3, uHeight); BGRFromRGB(tmp, uWidth, uHeight); BOOL bSuccess = WriteJPEGFile(lpstrFileName, tmp, uWidth, uHeight, bColor, nQuality); delete pDibTmp; FreeBuffer(tmp); return bSuccess; }
asCScriptObject &asCScriptObject::operator=(const asCScriptObject &other) { if( &other != this ) { asASSERT( other.objType->DerivesFrom(objType) ); // If the script class implements the opAssign method, it should be called asCScriptEngine *engine = objType->engine; asCScriptFunction *func = engine->scriptFunctions[objType->beh.copy]; if( func->funcType == asFUNC_SYSTEM ) { // Copy all properties for( asUINT n = 0; n < objType->properties.GetLength(); n++ ) { asCObjectProperty *prop = objType->properties[n]; if( prop->type.IsObject() ) { void **dst = (void**)(((char*)this) + prop->byteOffset); void **src = (void**)(((char*)&other) + prop->byteOffset); if( !prop->type.IsObjectHandle() ) CopyObject(*src, *dst, prop->type.GetObjectType(), engine); else CopyHandle((asPWORD*)src, (asPWORD*)dst, prop->type.GetObjectType(), engine); } else { void *dst = ((char*)this) + prop->byteOffset; void *src = ((char*)&other) + prop->byteOffset; memcpy(dst, src, prop->type.GetSizeInMemoryBytes()); } } } else { // Reuse the active context or create a new one to call the script class' opAssign method asIScriptContext *ctx = 0; int r = 0; bool isNested = false; ctx = asGetActiveContext(); if( ctx ) { r = ctx->PushState(); if( r == asSUCCESS ) isNested = true; else ctx = 0; } if( ctx == 0 ) { r = engine->CreateContext(&ctx, true); if( r < 0 ) return *this; } r = ctx->Prepare(engine->scriptFunctions[objType->beh.copy]); if( r < 0 ) { if( isNested ) ctx->PopState(); else ctx->Release(); return *this; } r = ctx->SetArgAddress(0, const_cast<asCScriptObject*>(&other)); asASSERT( r >= 0 ); r = ctx->SetObject(this); asASSERT( r >= 0 ); for(;;) { r = ctx->Execute(); // We can't allow this execution to be suspended // so resume the execution immediately if( r != asEXECUTION_SUSPENDED ) break; } if( r != asEXECUTION_FINISHED ) { if( isNested ) { ctx->PopState(); // If the execution was aborted or an exception occurred, // then we should forward that to the outer execution. if( r == asEXECUTION_EXCEPTION ) { // TODO: How to improve this exception ctx->SetException(TXT_EXCEPTION_IN_NESTED_CALL); } else if( r == asEXECUTION_ABORTED ) ctx->Abort(); } else ctx->Release(); return *this; } if( isNested ) ctx->PopState(); else ctx->Release(); } } return *this; }
/************************************************************************* * * DilationDIB() * * Parameters: * * HDIB hDib - objective DIB handle * BOOL bHori - dilation direction * * Return Value: * * BOOL - True is success, else False * * Description: * * This function do dilation with the specified direction * ************************************************************************/ BOOL DilationDIB(HDIB hDib, BOOL bHori) { // start wait cursor WaitCursorBegin(); // Old DIB buffer if (hDib == NULL) { WaitCursorEnd(); return FALSE; } // only support 256 color image WORD wBitCount = DIBBitCount(hDib); if (wBitCount != 8) { WaitCursorEnd(); return FALSE; } // new DIB HDIB hNewDIB = CopyHandle(hDib); if (! hNewDIB) { WaitCursorEnd(); return FALSE; } // source dib buffer LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib); if (! lpSrcDIB) { WaitCursorBegin(); return FALSE; } // New DIB buffer LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB); if (! lpbmi) { WaitCursorBegin(); return FALSE; } // start erosion... LPSTR lpPtr; LPSTR lpTempPtr; LONG x,y; BYTE num, num0; int i; LONG lHeight = DIBHeight(lpSrcDIB); LONG lWidth = DIBWidth(lpSrcDIB); DWORD dwBufferSize = GlobalSize(lpSrcDIB); int nLineBytes = BytesPerLine(lpSrcDIB); if(bHori) { for(y=0;y<lHeight;y++) { lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes)+1; lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes)+1; for(x=1;x<lWidth-1;x++) { num0 = num = 255; for(i=0;i<3;i++) { num=(unsigned char)*(lpPtr+i-1); if(num < num0) num0 = num; } *lpTempPtr=(unsigned char)num0; /* num=(unsigned char)*lpPtr; if (num==255) { *lpTempPtr=(unsigned char)255; for(i=0;i<3;i++) { num=(unsigned char)*(lpPtr+i-1); if(num==0) { *lpTempPtr=(unsigned char)0; break; } } } else *lpTempPtr=(unsigned char)0; */ lpPtr++; lpTempPtr++; } } } else { for(y=1;y<lHeight-1;y++) { lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes); lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes); for(x=0;x<lWidth;x++) { num0 = num = 255; for(i=0;i<3;i++) { num=(unsigned char)*(lpPtr+i-1); if(num < num0) num0 = num; } *lpTempPtr=(unsigned char)num0; /* num=(unsigned char)*lpPtr; if (num==255) { *lpTempPtr=(unsigned char)255; for(i=0;i<3;i++) { num=(unsigned char)*(lpPtr+(i-1)*nLineBytes); if(num==0) { *lpTempPtr=(unsigned char)0; break; } } } else *lpTempPtr=(unsigned char)0; */ lpPtr++; lpTempPtr++; } } } // cleanup GlobalUnlock(hDib); GlobalUnlock(hNewDIB); GlobalFree(hNewDIB); WaitCursorEnd(); return TRUE; }
/************************************************************************* * * ConvoluteDIB() * * Parameters: * * HDIB hDib - objective DIB handle * KERNEL *lpKernel - pointer of kernel used to convolute with DIB * int Strength - operation strength set to the convolute * int nKernelNum - kernel number used to convolute * * Return Value: * * BOOL - True is success, else False * * Description: * * This is the generic convolute function to DIB * ************************************************************************/ BOOL ConvoluteDIB(HDIB hDib, KERNEL *lpKernel, int Strength, int nKernelNum) { WaitCursorBegin(); HDIB hNewDib = NULL; // we only convolute 24bpp DIB, so first convert DIB to 24bpp WORD wBitCount = DIBBitCount(hDib); if (wBitCount != 24) hNewDib = ConvertDIBFormat(hDib, 24, NULL); else hNewDib = CopyHandle(hDib); if (! hNewDib) { WaitCursorEnd(); return FALSE; } // new DIB attributes WORD wDIBWidth = (WORD)DIBWidth(hNewDib); WORD wDIBHeight = (WORD)DIBHeight(hNewDib); WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib); DWORD dwImageSize = wBytesPerLine * wDIBHeight; // Allocate and lock memory for filtered image data HGLOBAL hFilteredBits = GlobalAlloc(GHND, dwImageSize); if (!hFilteredBits) { WaitCursorEnd(); return FALSE; } LPBYTE lpDestImage = (LPBYTE)GlobalLock(hFilteredBits); // get bits address in DIB LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib); LPBYTE lpDIBits = FindDIBBits(lpDIB); // convolute... for (int i=1; i<wDIBHeight-1; i++) for (int j=1; j<wDIBWidth-1; j++) { int red=0, green=0, blue=0; for (int k=0; k<nKernelNum; ++k) { int r=0, g=0, b=0; DoConvoluteDIB(&r, &g, &b, i, j, wBytesPerLine, lpDIBits, lpKernel+k); if (r > red) red = r; if (g > green) green = g; if (b > blue) blue = b; //red += r; green += g; blue += b; } // original RGB value in center pixel (j, i) LONG lOffset= PIXEL_OFFSET(i,j, wBytesPerLine); BYTE OldB = *(lpDIBits + lOffset++); BYTE OldG = *(lpDIBits + lOffset++); BYTE OldR = *(lpDIBits + lOffset); // When we get here, red, green and blue have the new RGB value. if (Strength != 10) { // Interpolate pixel data red = OldR + (((red - OldR) * Strength) / 10); green = OldG + (((green - OldG) * Strength) / 10); blue = OldB + (((blue - OldB) * Strength) / 10); } lOffset= PIXEL_OFFSET(i,j, wBytesPerLine); *(lpDestImage + lOffset++) = BOUND(blue, 0, 255); *(lpDestImage + lOffset++) = BOUND(green, 0, 255); *(lpDestImage + lOffset) = BOUND(red, 0, 255); } // a filtered image is available in lpDestImage // copy it to DIB bits memcpy(lpDIBits, lpDestImage, dwImageSize); // cleanup temp buffers GlobalUnlock(hFilteredBits); GlobalFree(hFilteredBits); GlobalUnlock(hNewDib); // rebuild hDib HDIB hTmp = NULL; if (wBitCount != 24) hTmp = ConvertDIBFormat(hNewDib, wBitCount, NULL); else hTmp = CopyHandle(hNewDib); GlobalFree(hNewDib); DWORD dwSize = GlobalSize(hTmp); memcpy((LPBYTE)GlobalLock(hDib), (LPBYTE)GlobalLock(hTmp), dwSize); GlobalUnlock(hTmp); GlobalFree(hTmp); GlobalUnlock(hDib); WaitCursorEnd(); return TRUE; }
/************************************************************************* * * MedianFilterDIB() * * Parameters: * * HDIB hDib - objective DIB handle * * Return Value: * * BOOL - True is success, else False * * Description: * * This is the media filtering function to DIB * ************************************************************************/ BOOL MedianFilterDIB(HDIB hDib) { WaitCursorBegin(); HDIB hNewDib = NULL; // we only convolute 24bpp DIB, so first convert DIB to 24bpp WORD wBitCount = DIBBitCount(hDib); if (wBitCount != 24) hNewDib = ConvertDIBFormat(hDib, 24, NULL); else hNewDib = CopyHandle(hDib); if (! hNewDib) { WaitCursorEnd(); return FALSE; } // new DIB attributes WORD wDIBWidth = (WORD)DIBWidth(hNewDib); WORD wDIBHeight = (WORD)DIBHeight(hNewDib); WORD wBytesPerLine = (WORD)BytesPerLine(hNewDib); DWORD dwImageSize = wBytesPerLine * wDIBHeight; // Allocate and lock memory for filtered image data HGLOBAL hFilteredBits = GlobalAlloc(GHND, dwImageSize); if (!hFilteredBits) { WaitCursorEnd(); return FALSE; } LPBYTE lpDestImage = (LPBYTE)GlobalLock(hFilteredBits); // get bits address in DIB LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib); LPBYTE lpDIBits = FindDIBBits(lpDIB); // convolute... for (int i=1; i<wDIBHeight-1; i++) for (int j=1; j<wDIBWidth-1; j++) { int red=0, green=0, blue=0; DoMedianFilterDIB(&red, &green, &blue, i, j, wBytesPerLine, lpDIBits); LONG lOffset= PIXEL_OFFSET(i,j, wBytesPerLine); *(lpDestImage + lOffset++) = BOUND(blue, 0, 255); *(lpDestImage + lOffset++) = BOUND(green, 0, 255); *(lpDestImage + lOffset) = BOUND(red, 0, 255); } // a filtered image is available in lpDestImage // copy it to DIB bits memcpy(lpDIBits, lpDestImage, dwImageSize); // cleanup temp buffers GlobalUnlock(hFilteredBits); GlobalFree(hFilteredBits); GlobalUnlock(hNewDib); // rebuild hDib HDIB hTmp = NULL; if (wBitCount != 24) hTmp = ConvertDIBFormat(hNewDib, wBitCount, NULL); else hTmp = CopyHandle(hNewDib); GlobalFree(hNewDib); DWORD dwSize = GlobalSize(hTmp); memcpy((LPBYTE)GlobalLock(hDib), (LPBYTE)GlobalLock(hTmp), dwSize); GlobalUnlock(hTmp); GlobalFree(hTmp); GlobalUnlock(hDib); WaitCursorEnd(); return TRUE; }
/**************************************************** WALhDIB() 参数: hDIB为输入的DIB句柄 返回值: 成功为TRUE;失败为FALSE 说明: 本函数实现DIB位图的快速沃尔什-哈达玛变换 ****************************************************/ BOOL WALhDIB(HDIB hDIB) { if (hDIB == NULL) return FALSE; // start wait cursor WaitCursorBegin(); HDIB hDib = NULL; HDIB hNewDib = NULL; // we only convolute 24bpp DIB, so first convert DIB to 24bpp WORD wBitCount = DIBBitCount(hDIB); if (wBitCount != 24) { hNewDib = ConvertDIBFormat(hDIB, 24, NULL); hDib = CopyHandle(hNewDib); } else { hNewDib = CopyHandle(hDIB); hDib = CopyHandle(hDIB); } if (hNewDib == NULL && hDib == NULL) { WaitCursorEnd(); return FALSE; } // process! LPBYTE lpSrcDIB = (LPBYTE)GlobalLock(hDib); LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib); LPBYTE lpInput = FindDIBBits(lpSrcDIB); LPBYTE lpOutput = FindDIBBits(lpDIB); int nWidth = DIBWidth(lpSrcDIB); int nHeight = DIBHeight(lpSrcDIB); int w=1,h=1,wp=0,hp=0; while(w*2<=nWidth) { w*=2; wp++; } while(h*2<=nHeight) { h*=2; hp++; } int x,y; BYTE *lpPoints=new BYTE[nWidth*nHeight]; GetPoints(nWidth,nHeight,lpInput,lpPoints); double *f=new double[w*h]; double *W=new double[w*h]; for(y=0;y<h;y++) { for(x=0;x<w;x++) { f[x+y*w]=Point(x,y); } } for(y=0;y<h;y++) { WALh(f+w*y,W+w*y,wp); } for(y=0;y<h;y++) { for(x=0;x<w;x++) { f[x*h+y]=W[x+w*y]; } } for(x=0;x<w;x++) { WALh(f+x*h,W+x*h,hp); } double a; memset(lpPoints,0,nWidth*nHeight); for(y=0;y<h;y++) { for(x=0;x<w;x++) { a=fabs(W[x*h+y]*1000); if (a>255) a=255; Point(x,nHeight-y-1)=(BYTE)a; } } delete f; delete W; PutPoints(nWidth,nHeight,lpOutput,lpPoints); delete lpPoints; // recover DWORD dwSize = GlobalSize(hDib); memcpy(lpSrcDIB, lpDIB, dwSize); GlobalUnlock(hDib); GlobalUnlock(hNewDib); if (wBitCount != 24) { hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL); lpSrcDIB = (LPBYTE)GlobalLock(hDIB); lpDIB = (LPBYTE)GlobalLock(hNewDib); dwSize = GlobalSize(hNewDib); memcpy(lpSrcDIB, lpDIB, dwSize); GlobalUnlock(hDIB); GlobalUnlock(hNewDib); } else { lpSrcDIB = (LPBYTE)GlobalLock(hDIB); lpDIB = (LPBYTE)GlobalLock(hDib); dwSize = GlobalSize(hDib); memcpy(lpSrcDIB, lpDIB, dwSize); GlobalUnlock(hDIB); GlobalUnlock(hDib); } // cleanup GlobalFree(hDib); GlobalFree(hNewDib); // return WaitCursorEnd(); return TRUE; }
/**************************************************** FFTDIB() 参数: hDIB为输入的DIB句柄 返回值: 成功为TRUE;失败为FALSE 说明: 本函数实现DIB位图的快速傅立叶变换 ****************************************************/ BOOL FFTDIB(HDIB hDIB) { if (hDIB == NULL) return FALSE; // start wait cursor WaitCursorBegin(); HDIB hDib = NULL; HDIB hNewDib = NULL; // we only convolute 24bpp DIB, so first convert DIB to 24bpp WORD wBitCount = DIBBitCount(hDIB); if (wBitCount != 24) { hNewDib = ConvertDIBFormat(hDIB, 24, NULL); hDib = CopyHandle(hNewDib); } else { hNewDib = CopyHandle(hDIB); hDib = CopyHandle(hDIB); } if (hNewDib == NULL && hDib == NULL) { WaitCursorEnd(); return FALSE; } // process! LPBYTE lpSrcDIB = (LPBYTE)GlobalLock(hDib); LPBYTE lpDIB = (LPBYTE)GlobalLock(hNewDib); LPBYTE lpInput = FindDIBBits(lpSrcDIB); LPBYTE lpOutput = FindDIBBits(lpDIB); int nWidth = DIBWidth(lpSrcDIB); int nHeight = DIBHeight(lpSrcDIB); int w=1,h=1,wp=0,hp=0; while(w*2<=nWidth) { w*=2; wp++; } while(h*2<=nHeight) { h*=2; hp++; } int x,y; BYTE *lpPoints=new BYTE[nWidth*nHeight]; GetPoints(nWidth,nHeight,lpInput,lpPoints); COMPLEX *TD=new COMPLEX[w*h]; COMPLEX *FD=new COMPLEX[w*h]; for(y=0;y<h;y++) { for(x=0;x<w;x++) { TD[x+w*y].re=Point(x,y); TD[x+w*y].im=0; } } for(y=0;y<h;y++) { FFT(&TD[w*y],&FD[w*y],wp); } for(y=0;y<h;y++) { for(x=0;x<w;x++) { TD[y+h*x]=FD[x+w*y]; // TD[x+w*y]=FD[x*h+y]; } } for(x=0;x<w;x++) { FFT(&TD[x*h],&FD[x*h],hp); } memset(lpPoints,0,nWidth*nHeight); double m; for(y=0;y<h;y++) { for(x=0;x<w;x++) { m=sqrt(FD[x*h+y].re*FD[x*h+y].re+FD[x*h+y].im*FD[x*h+y].im)/100; if (m>255) m=255; Point((x<w/2?x+w/2:x-w/2),nHeight-1-(y<h/2?y+h/2:y-h/2))=(BYTE)(m); } } delete TD; delete FD; PutPoints(nWidth,nHeight,lpOutput,lpPoints); delete lpPoints; // recover DWORD dwSize = GlobalSize(hDib); memcpy(lpSrcDIB, lpDIB, dwSize); GlobalUnlock(hDib); GlobalUnlock(hNewDib); if (wBitCount != 24) { hNewDib = ConvertDIBFormat(hDib, wBitCount, NULL); lpSrcDIB = (LPBYTE)GlobalLock(hDIB); lpDIB = (LPBYTE)GlobalLock(hNewDib); dwSize = GlobalSize(hNewDib); memcpy(lpSrcDIB, lpDIB, dwSize); GlobalUnlock(hDIB); GlobalUnlock(hNewDib); } else { lpSrcDIB = (LPBYTE)GlobalLock(hDIB); lpDIB = (LPBYTE)GlobalLock(hDib); dwSize = GlobalSize(hDib); memcpy(lpSrcDIB, lpDIB, dwSize); GlobalUnlock(hDIB); GlobalUnlock(hDib); } // cleanup GlobalFree(hDib); GlobalFree(hNewDib); // return WaitCursorEnd(); return TRUE; }
/************************************************************************* * * ThinningDIB() * * Parameters: * * HDIB hDib - objective DIB handle * * Return Value: * * BOOL - True is success, else False * * Description: * * This function thins a DIB * ************************************************************************/ BOOL ThinningDIB(HDIB hDib) { static int erasetable[256]= { 0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1, 1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,1, 0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1, 1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,1, 1,1,0,0,1,1,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 1,1,0,0,1,1,0,0, 1,1,0,1,1,1,0,1, 0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0, 0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1, 1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,1, 0,0,1,1,0,0,1,1, 1,1,0,1,1,1,0,1, 1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,0, 1,1,0,0,1,1,0,0, 0,0,0,0,0,0,0,0, 1,1,0,0,1,1,1,1, 0,0,0,0,0,0,0,0, 1,1,0,0,1,1,0,0, 1,1,0,1,1,1,0,0, 1,1,0,0,1,1,1,0, 1,1,0,0,1,0,0,0 }; // start wait cursor WaitCursorBegin(); // Old DIB buffer if (hDib == NULL) { WaitCursorEnd(); return FALSE; } // only support 256 color image WORD wBitCount = DIBBitCount(hDib); if (wBitCount != 8) { WaitCursorEnd(); return FALSE; } // new DIB HDIB hNewDIB = CopyHandle(hDib); if (! hNewDIB) { WaitCursorEnd(); return FALSE; } // source dib buffer LPBITMAPINFO lpSrcDIB = (LPBITMAPINFO)GlobalLock(hDib); if (! lpSrcDIB) { WaitCursorBegin(); return FALSE; } // New DIB buffer LPBITMAPINFO lpbmi = (LPBITMAPINFO)GlobalLock(hNewDIB); if (! lpbmi) { WaitCursorBegin(); return FALSE; } // start erosion... LPSTR lpPtr; LPSTR lpTempPtr; LONG x,y; BYTE num; LONG lHeight = DIBHeight(lpSrcDIB); LONG lWidth = DIBWidth(lpSrcDIB); DWORD dwBufferSize = GlobalSize(lpSrcDIB); int nLineBytes = BytesPerLine(lpSrcDIB); int nw,n,ne,w,e,sw,s,se; BOOL Finished=FALSE; while(!Finished) { Finished=TRUE; for (y=1;y<lHeight-1;y++) { lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes); lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes); x=1; while(x<lWidth-1) { if(*(lpPtr+x)==0) { w=(unsigned char)*(lpPtr+x-1); e=(unsigned char)*(lpPtr+x+1); if( (w==255)|| (e==255)) { nw=(unsigned char)*(lpPtr+x+nLineBytes-1); n=(unsigned char)*(lpPtr+x+nLineBytes); ne=(unsigned char)*(lpPtr+x+nLineBytes+1); sw=(unsigned char)*(lpPtr+x-nLineBytes-1); s=(unsigned char)*(lpPtr+x-nLineBytes); se=(unsigned char)*(lpPtr+x-nLineBytes+1); num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128; if(erasetable[num]==1) { *(lpPtr+x)=(BYTE)255; *(lpTempPtr+x)=(BYTE)255; Finished=FALSE; x++; } } } x++; } } for (x=1;x<lWidth-1;x++) { y=1; while(y<lHeight-1) { lpPtr=(char *)lpbmi+(dwBufferSize-nLineBytes-y*nLineBytes); lpTempPtr=(char *)lpSrcDIB+(dwBufferSize-nLineBytes-y*nLineBytes); if(*(lpPtr+x)==0) { n=(unsigned char)*(lpPtr+x+nLineBytes); s=(unsigned char)*(lpPtr+x-nLineBytes); if( (n==255)|| (s==255)) { nw=(unsigned char)*(lpPtr+x+nLineBytes-1); ne=(unsigned char)*(lpPtr+x+nLineBytes+1); w=(unsigned char)*(lpPtr+x-1); e=(unsigned char)*(lpPtr+x+1); sw=(unsigned char)*(lpPtr+x-nLineBytes-1); se=(unsigned char)*(lpPtr+x-nLineBytes+1); num=nw/255+n/255*2+ne/255*4+w/255*8+e/255*16+sw/255*32+s/255*64+se/255*128; if(erasetable[num]==1) { *(lpPtr+x)=(BYTE)255; *(lpTempPtr+x)=(BYTE)255; Finished=FALSE; y++; } } } y++; } } } // cleanup GlobalUnlock(hDib); GlobalUnlock(hNewDIB); GlobalFree(hNewDIB); return TRUE; }
//******************* 保存为PCX (由CDib对象) *********************** BOOL LanImage::SavePcx(LPCTSTR lpstrFileName, CDib* pDib) { int i = 0; if (pDib == NULL) return FALSE; HDIB hDib = CopyHandle(pDib->GetHandle()); if (hDib == NULL) return FALSE; CDib* pDibTmp = new CDib(); pDibTmp->Attach(hDib); UINT uWidth = pDibTmp->GetWidth(); UINT uHeight = pDibTmp->GetHeight(); // 当打开的图像BitCount不为8时,转为8位格式 if (pDibTmp->GetBitCount() != 8) pDibTmp->ConvertFormat(8); // make PCX header PCXHEAD header; memset((LPBYTE)&header, 0, sizeof(PCXHEAD)); header.manufacturer = 0x0A; header.version = 5; header.encoding = 1; header.bit_per_pixel = 8; //header.bit_per_pixel = 24; header.xmin = 0; header.ymin = 0; header.xmax = uWidth-1; header.ymax = uHeight-1; //header.Xresolution; //header.Yresolution; header.palette[0] = (BYTE)0x00; // for correct process for mono header.palette[1] = (BYTE)0x00; header.palette[2] = (BYTE)0x00; header.palette[3] = (BYTE)0xff; header.palette[4] = (BYTE)0xff; header.palette[5] = (BYTE)0xff; //header.palette[48]; header.reserved = 0; header.color_planes = 1; header.byte_per_line = uWidth; header.palette_type = 1; //filler[58]; // construct PCX palette from DIB color table PCXPALETTE palette[256]; PALETTEENTRY PaletteColors[256]; pDibTmp->GetPalette()->GetPaletteEntries(0, 256, PaletteColors); for (i=0;i<256;i++) { palette[i].rgbRed = PaletteColors[i].peRed; palette[i].rgbGreen = PaletteColors[i].peGreen; palette[i].rgbBlue = PaletteColors[i].peBlue; } // get bits ptr HDIB hDIB = CopyHandle(pDibTmp->GetHandle()); delete pDibTmp; LPBYTE lpDIB = (LPBYTE)GlobalLock(hDIB); BYTE* lpBuffer = (BYTE *)FindDIBBits(lpDIB); WORD wWidthBytes = (WORD)BytesPerLine(lpDIB); /*** Open the PCX file ***/ FILE *outFile; if ((outFile=fopen(lpstrFileName,"wb")) == NULL) { GlobalUnlock(hDIB); GlobalFree(hDIB); return FALSE; } /*** Write the header ***/ fwrite((char *)&header, sizeof(PCXHEAD), 1, outFile); /*** Write image data ***/ for ( i=(int)uHeight-1; i>=0; --i) { if (! WritePCXLine(header.byte_per_line, lpBuffer+i*wWidthBytes, outFile)) { fclose(outFile); GlobalUnlock(hDIB); GlobalFree(hDIB); return FALSE; } } /*** Write the palette data ***/ fputc(0x0c, outFile); fwrite((char *)palette, 1, sizeof(palette), outFile); // clear & close fclose(outFile); GlobalUnlock(hDIB); GlobalFree(hDIB); return TRUE; }