std::list<CvBox2D> BouyBaseObject::GetBounding(const IplImage * imgIn, IplImage * imgOut) const
{
std::list<CvBox2D> blobList;
if(imgIn == NULL) return blobList;
IplImage * imgOut1 = GetMask(imgIn);
if(imgOut1)
{
blobList = Zebulon::Vision::VisionUtils::GetBlobBoxes(imgOut1,.001,.95);
if (imgOut)
{
cvCopy(imgOut1, imgOut);
}
cvReleaseImage(&imgOut1);
}
return blobList;
}
void GLVertexDecompilerThread::SetDST(bool is_sca, std::string value)
{
if(d0.cond == 0) return;
enum
{
lt = 0x1,
eq = 0x2,
gt = 0x4,
};
std::string mask = GetMask(is_sca);
value += mask;
if(is_sca && d0.vec_result)
{
value = "vec4(" + value + ")" + mask;
}
if(d0.staturate)
{
value = "clamp(" + value + ", 0.0, 1.0)";
}
std::string dest;
if (d0.cond_update_enable_0 && d0.cond_update_enable_1)
{
dest += m_parr.AddParam(PARAM_NONE, "vec4", "cc" + std::to_string(d0.cond_reg_sel_1), "vec4(0.0)") + mask + " = ";
}
if (d3.dst != 0x1f || (is_sca ? d3.sca_dst_tmp != 0x3f : d0.dst_tmp != 0x3f))
{
dest += GetDST(is_sca) + mask + " = ";
}
std::string code;
if (d0.cond_test_enable)
code += "$ifcond ";
code += dest + value;
AddCode(code + ";");
}
wxImage wxBitmap::ConvertToImage() const
{
wxCHECK_MSG( Ok(), wxNullImage, wxT("invalid bitmap") );
wxImage img(GetWidth(), GetHeight());
wxIDirectFBSurfacePtr dst(CreateSurfaceForImage(img));
wxIDirectFBSurfacePtr src = M_BITMAP->m_surface;
if ( !dst->SetBlittingFlags(DSBLIT_NOFX) )
return wxNullImage;
if ( !dst->Blit(src->GetRaw(), NULL, 0, 0) )
return wxNullImage;
// FIXME: implement mask setting in the image
wxASSERT_MSG( GetMask() == NULL, _T("bitmap masks are ignored for now") );
return img;
}
BOOL NetworkPrefs2Gadgets
(
struct NetPEditor_DATA *data
)
{
NNSET(data->netped_deviceString, MUIA_String_Contents, (IPTR)GetDevice());
NNSET(data->netped_IPString, MUIA_String_Contents, (IPTR)GetIP());
NNSET(data->netped_maskString, MUIA_String_Contents, (IPTR)GetMask());
NNSET(data->netped_gateString, MUIA_String_Contents, (IPTR)GetGate());
NNSET(data->netped_DNSString[0], MUIA_String_Contents, (IPTR)GetDNS(0));
NNSET(data->netped_DNSString[1], MUIA_String_Contents, (IPTR)GetDNS(1));
NNSET(data->netped_hostString, MUIA_String_Contents, (IPTR)GetHost());
NNSET(data->netped_domainString, MUIA_String_Contents, (IPTR)GetDomain());
NNSET(data->netped_DHCPState, MUIA_Cycle_Active, (IPTR)GetDHCP());
NNSET(data->netped_Autostart, MUIA_Selected, (IPTR)GetAutostart());
return TRUE;
}
void VertexProgramDecompiler::SetDST(bool is_sca, std::string value)
{
if (d0.cond == 0) return;
enum
{
lt = 0x1,
eq = 0x2,
gt = 0x4,
};
std::string mask = GetMask(is_sca);
if (is_sca)
{
value = getFloatTypeName(4) + "(" + value + ")";
}
value += mask;
if (d0.staturate)
{
value = "clamp(" + value + ", 0.0, 1.0)";
}
std::string dest;
if (d0.cond_update_enable_0 && d0.cond_update_enable_1)
{
dest = m_parr.AddParam(PF_PARAM_NONE, getFloatTypeName(4), "cc" + std::to_string(d0.cond_reg_sel_1), getFloatTypeName(4) + "(0., 0., 0., 0.)") + mask;
}
else if (d3.dst != 0x1f || (is_sca ? d3.sca_dst_tmp != 0x3f : d0.dst_tmp != 0x3f))
{
dest = GetDST(is_sca) + mask;
}
//std::string code;
//if (d0.cond_test_enable)
// code += "$ifcond ";
//code += dest + value;
//AddCode(code + ";");
AddCodeCond(Format(dest), value);
}
void OutPutAgent::handleEvent(WEvent& event)
{
if (outMode == OUT_NULL)
{
// No out put device available here, return immediate.
return;
}
if (event.what & GetMask( ))
{
struct tm * ltm;
//char buf[256];
char buf[512] = {0};
int len = (event.msgPtr != NULL) ? strlen(event.msgPtr) : 0;
ltm = localtime(&event.prEvent.timeStamp);
//sprintf(buf, "<%04d-%02d-%02d %02d:%02d:%02d> ", ltm->tm_year+1900, ltm->tm_mon+1,
// ltm->tm_mday, ltm->tm_hour, ltm->tm_min, ltm->tm_sec);
//memcpy(buf+24, event.msgPtr, len); //@zh 很有问题???缓冲区溢出
//buf[24+len] = '\0';
snprintf(buf, 511, "<%04d-%02d-%02d %02d:%02d:%02d> %s", ltm->tm_year+1900, ltm->tm_mon+1,
ltm->tm_mday, ltm->tm_hour, ltm->tm_min, ltm->tm_sec, event.msgPtr);
if (outMode & OUT_STDOUT)
{
printf("%s\n", buf);
}
if (outMode & OUT_STDERR)
{
fprintf(stderr, "%s\n", buf);
}
if (outMode & OUT_PTERM)
{
// Send the message to PTERM process.
// ......
}
if (outMode & OUT_FILE)
{
// Log the message into disk file.
log.Log(buf);
}
}
}
CStr VerifyCard(CStr CardNumber)
{
CardNumber = CleanCard(CardNumber);
if (CardNumber.Length() == 0)
return 0;
const char * b = CardNumber;
const char * p;
p = b;
while (*p) {
if (!isdigit(*p))
return 0;
++p;
}
int l = p - b;
// check the length
if ( l > 28 )
return 0;
int type = GetCardType(b, l);
int mask = GetMask( type );
if ( (l < 12) || ( (ShiftMask(l) && mask) == 0 ) )
return 0;
// check the checksum computation
bool doChecksum;
if ( type == cc_enroute )
doChecksum = false;
else
doChecksum = true;
if ( doChecksum && ( !ConfirmChecksum( CardNumber ) ) )
return 0;
return GetCardName(type);
}
void InnerGlowStyle::operator() (Pixels destPixels, Pixels maskPixels)
{
if (!active)
return;
SharedTable <Colour> table;
if (reverse)
table = colours.withReversedStops().createLookupTable ();
else
table = colours.createLookupTable ();
#if 1
// Anti-Aliased
//
DistanceTransform::Meijster::calculateAntiAliased (
RenderPixelAntiAliased (
destPixels,
opacity,
choke,
size,
table),
GetMask (maskPixels),
maskPixels.getWidth (),
maskPixels.getHeight (),
DistanceTransform::Meijster::EuclideanMetric ());
#else
// Regular
//
DistanceTransform::Meijster::calculate (
RenderPixel (
destPixels,
opacity,
choke,
size,
table),
TestMask (maskPixels),
maskPixels.getWidth (),
maskPixels.getHeight (),
DistanceTransform::Meijster::EuclideanMetric ());
#endif
}
void AllFiles::SearchFiles(const char* path, unsigned long& count)
{
AccessFile pAccFile;
ClientFile pClFile;
char direct[256] = "";
char direct_copy[256] = "";
strcpy(direct, path);
strcat(direct, "\\*.*");
_finddata_t* fi = new _finddata_t;//alternative - unique_ptr<_finddata_t> fi(new _finddata_t);
intptr_t handle = 0, copy_handle = 0;
handle = copy_handle = _findfirst(direct, fi);//handle = copy_handle = _findfirst(dir, fi.get());
while (copy_handle != -1)
{
if (fi->name[0] != '.')
{
if (fi->attrib & _A_SUBDIR)
{
strcpy(direct_copy, path);
strcat(direct_copy, "\\");
strcat(direct_copy, fi->name);
SearchFiles(direct_copy, count);
}
else
{
itoa(count, pAccFile.IDFile, 10);
GetMask(pAccFile.name, pAccFile.mask, fi->name);
//strcpy(pAccFile.size, std::to_string(fi->size).c_str());
GetFileSize(pAccFile.size, fi->size);
CString PathFile = path;
pClFile.SetClientFile(pAccFile, PathFile);
m_ClFiles.emplace_back(pClFile);
count++;
}
}
copy_handle = _findnext(handle, fi);
}
_findclose(handle);
_findclose(copy_handle);
if (fi)
delete fi;
}
// Gets the current mask if any.
// If no mask exists then create one using fOn and fNoUndo.
// bCreated is TRUE if a new mask was created.
LPMASK CImage::GetMaskEx(BOOL fOn, BOOL fNoUndo, LPINT bCreated, LPRECT lpUpdateRect)
{
LPMASK lpMask;
LPFRAME lpFrame;
FRMTYPEINFO TypeInfo;
FRMDATATYPE FrameType = FDT_GRAYSCALE;
AstralSetRectEmpty(lpUpdateRect);
if (lpMask = GetMask())
{
if (bCreated)
*bCreated = FALSE;
return(lpMask);
}
lpFrame = GetBaseEditFrame();
FrameGetTypeInfo(lpFrame, &TypeInfo);
if (TypeInfo.DataType == FDT_LINEART && Mask.OneBitMask)
FrameType = FDT_LINEART;
if (!(lpMask = MaskCreate(NULL, FrameXSize(lpFrame),
FrameYSize(lpFrame),
fOn,
fNoUndo, FrameType)))
{
Message( IDS_EMEMALLOC );
return(NULL);
}
// sync up the resolution of the image data and the mask
// don't ever rely on the mask's resolution being correct
// cause other size can change the image data resolution
// without changing the mask's resolution. Also, there are
// other places the mask gets created without syncing up
// the resolution. I am doing it here so we can begin
// to track it correctly (Ted)
FrameSetResolution(AlphaGetEditFrame(lpMask), FrameResolution(lpFrame));
if (bCreated)
*bCreated = TRUE;
if (!Control.UseMaskAndObjects)
GetObjectMarqueeRect(this, lpUpdateRect);
SetMask(lpMask);
return(lpMask);
}
std::list<CvBox2D> BouyObject::GetBounding(const IplImage * imgIn, IplImage * debugOut) const
{
std::list<CvBox2D> blobList;
if(imgIn == NULL) return blobList;
IplImage * imgOut1 = GetMask(imgIn);
if(imgOut1)
{
blobList = Zebulon::Vision::VisionUtils::GetBlobBoxes(imgOut1,.001,.95,false);
if (debugOut)
{
//cvConvertImage(imgOut1, debugOut);
if(blobList.size() > 0)
{
VisionUtils::DrawSquare(debugOut,blobList.front(),mNearColor);
}
}
cvReleaseImage(&imgOut1);
}
return blobList;
}
BOOL IsIgnored(MCONTACT hContact, WORD eventType)
{
WORD ignoreID = 0;
DWORD mask = GetMask(hContact);
switch(eventType) {
case EVENTTYPE_MESSAGE:
ignoreID = 0;
break;
case EVENTTYPE_URL:
ignoreID = 1;
break;
case EVENTTYPE_FILE:
ignoreID = 2;
break;
default:
ignoreID = 3;
}
return (mask>>ignoreID)&1;
}
std::string VertexProgramDecompiler::GetDST(bool isSca)
{
std::string ret;
std::string mask = GetMask(isSca);
switch ((isSca && d3.sca_dst_tmp != 0x3f) ? 0x1f : d3.dst)
{
case 0x1f:
ret += m_parr.AddParam(PF_PARAM_NONE, getFloatTypeName(4), std::string("tmp") + std::to_string(isSca ? d3.sca_dst_tmp : d0.dst_tmp)) + mask;
break;
default:
if (d3.dst > 15)
LOG_ERROR(RSX, "dst index out of range: %u", d3.dst);
ret += m_parr.AddParam(PF_PARAM_NONE, getFloatTypeName(4), std::string("dst_reg") + std::to_string(d3.dst), d3.dst == 0 ? getFloatTypeName(4) + "(0.0f, 0.0f, 0.0f, 1.0f)" : getFloatTypeName(4) + "(0.0, 0.0, 0.0, 0.0)") + mask;
// Handle double destination register as 'dst_reg = tmp'
if (d0.dst_tmp != 0x3f)
ret += " = " + m_parr.AddParam(PF_PARAM_NONE, getFloatTypeName(4), std::string("tmp") + std::to_string(d0.dst_tmp)) + mask;
break;
}
return ret;
}
void COrnament::Draw(void)
{
ASSERT(m_pContext != NULL);
ASSERT(!CommitNeeded());
// Only draw the object if it's visible.
if (CurrentState()->m_fVisible)
{
// Make sure the object has been sized.
CDC* pDC = m_pContext->GetDC();
ASSERT(pDC != NULL);
if (pDC != NULL)
{
// Save the state of the DC.
int nContext;
if ((nContext = pDC->SaveDC()) != 0)
{
// Set MM_TEXT for all the creation and drawing functions.
pDC->SetMapMode(MM_TEXT);
// Get the mask bitmap.
CBitmap* pbmMask;
if ((pbmMask = GetMask()) != NULL)
{
CDC MaskDC;
// Create a compatible memory DC and select the mask bitmap into it.
if (MaskDC.CreateCompatibleDC(pDC))
{
MaskDC.SetMapMode(MM_TEXT);
CBitmap* pbmOldMask;
if ((pbmOldMask = MaskDC.SelectObject(pbmMask)) != NULL)
{
// Get the image bitmap.
CBitmap* pbmImage;
if ((pbmImage = GetImage()) != NULL)
{
// Create another compatible memory DC for the image.
CDC ImageDC;
if (ImageDC.CreateCompatibleDC(pDC))
{
ImageDC.SetMapMode(MM_TEXT);
CBitmap* pbmOldImage;
if ((pbmOldImage = ImageDC.SelectObject(pbmImage)) != NULL)
{
pDC->SetTextColor(RGB(0,0,0));
pDC->SetBkColor(RGB(255,255,255));
// Compute the drawing position.
CRect crBounds = CurrentState()->m_crBounds;
// Mask out the area where we will be drawing the image.
m_pContext->Toggle(TRUE, &crBounds);
pDC->BitBlt(
crBounds.left,
crBounds.top,
crBounds.Width(),
crBounds.Height(),
&MaskDC,
0,
0,
SRCAND);
// Draw the image into the area that was masked out.
pDC->BitBlt(
crBounds.left,
crBounds.top,
crBounds.Width(),
crBounds.Height(),
&ImageDC,
0,
0,
SRCPAINT);
m_pContext->Toggle(FALSE, &crBounds);
ImageDC.SelectObject(pbmOldImage);
}
}
}
MaskDC.SelectObject(pbmOldMask);
}
}
}
pDC->RestoreDC(nContext);
}
}
m_pContext->ReleaseDC();
}
}
static INT_PTR IsIgnored(WPARAM wParam,LPARAM lParam)
{
DWORD mask=GetMask((HANDLE)wParam);
if(lParam<1 || lParam>IGNOREEVENT_MAX) return 1;
return (mask>>(lParam-1))&1;
}
void CImage::EditUndo( BOOL fEditUndo, BOOL fMaskUndo,
LPUPDATE_TYPE lpUpdateType, LPRECT lpUpdateRect)
{
RECT rUndo, rUndoMask, rTemp;
LPOBJECT lpBase, lpObject, lpNext;
BOOL fNewSize, fSetupMiniViews, fRemoveMarquee, fUndoDelete, fColorMapChanged;
BOOL fUndoAlpha, fUndoData;
int nDeleted;
LPMASK lpMask;
EDIT_TARGET Target;
AstralSetRectEmpty(lpUpdateRect);
// Initialize things for updating the display
fNewSize = fSetupMiniViews = fUndoDelete = fColorMapChanged = NO;
AstralSetRectEmpty(&rUndo);
AstralSetRectEmpty(&rUndoMask);
// loop through objects doing undo
lpBase = GetBase();
lpObject = NULL;
// get the target of the last edit
Target = EditTarget;
while (lpObject = GetNextObject(lpObject, NO, NO, fEditUndo))
{
// See if this is an object we are undoing
if (fEditUndo)
{
// check for special undo processing of a deleted object
if (lpObject->fDeleted)
continue; // do no undo processing for a deleted object
// {
// if (Control.UndoObjects && !IsSelectedObject(lpBase))
// continue;
// }
else
// if target is not the entire image and we are in undo
// object mode and the object is not selected then
// skip this object
if (Target != ET_ALLOBJECTS && Control.UndoObjects && !IsSelectedObject(lpObject))
continue;
}
// Only handle mask undo for the base object
if (fMaskUndo)
{
if (lpObject != lpBase || lpObject->fBothDirty ||
!lpObject->AlphaDirty)
continue;
}
fUndoData = fUndoAlpha = NO;
// Do preprocess for doing a data undo
if (fEditUndo)
{
if (lpObject->DataDirty)
fUndoData = YES;
// See if we need to undo the alpha for this object
if ((lpObject != lpBase) && lpObject->lpAlpha && lpObject->AlphaDirty)
fUndoAlpha = YES;
if (!fUndoData && !fUndoAlpha)
continue;
// check to see and undoing/redoing deleted objects will change
// the select state, if so undraw the object marquee
if (lpObject == lpBase &&
lpObject->DataUndoType & UT_DELETEOBJECTS)
{
fUndoDelete = YES;
fRemoveMarquee = NO;
nDeleted = 0;
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fUndoDeleted)
++nDeleted;
else
if (lpNext->fDeleted && lpNext->fSelected)
{
fRemoveMarquee = YES;
break;
}
}
if (GetSelObject(NULL) == lpBase && !fRemoveMarquee)
{
if (CountObjects() - nDeleted <= 1)
fRemoveMarquee = YES;
}
if (fRemoveMarquee)
{
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
}
}
else // fMaskUndo
if (!lpObject->AlphaDirty)
continue;
else
fUndoAlpha = YES;
// do a preprocess for undoing the mask caused either by
// a mask undo or by an edit function that also edits the mask
if (((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) ||
fMaskUndo)
{
if ( lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
// if the undo is going to delete the mask,
// we need to undraw the mask
if (GetMask())
{
GetMaskMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
if (GetMaskUpdateRect(YES, NO, &rTemp))
AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp);
}
// if the undo is going to create the mask,
// we need to undraw the object marquees if
// not in mask and object marquee mode
else
{
if (!Control.UseMaskAndObjects)
{
GetObjectMarqueeRect(this, &rTemp);
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rTemp);
}
}
}
}
// Actually do the undo
ObjEditUndo(lpObject, fUndoData, fUndoAlpha);
// do a postprocess for undoing the mask
if ((lpMask = GetMask()) &&
(((lpObject == lpBase) && fEditUndo && lpObject->fBothDirty) ||
fMaskUndo))
{
// if the undo is going to add the mask, we need to redraw the mask
if (lpObject->AlphaUndoType & (UT_CREATEMASK|UT_DELETEMASK) )
{
if (GetMaskUpdateRect(YES, NO, &rTemp))
AstralUnionRect(&rUndoMask, &rUndoMask, &rTemp);
}
else
// just redraw the undo area for the mask
AstralUnionRect(&rUndoMask, &rUndoMask, &lpMask->Pixmap.UndoRect);
}
// Setup rectangle for undoing deletion of objects
// Handled specially so that moved objects will still undo
// and redo properly
if (fEditUndo)
{
if (lpObject == lpBase &&
lpObject->DataUndoType & UT_DELETEOBJECTS)
{
lpNext = lpObject;
while (lpNext = GetNextObject(lpNext, YES, NO, YES))
{
if (lpNext->fDeleted || lpNext->fUndoDeleted)
AstralUnionRect(&rUndo, &rUndo, &lpNext->rObject);
}
fSetupMiniViews = YES;
}
if (lpObject->DataUndoType & UT_COLORMAP)
fColorMapChanged = YES;
if (lpObject->Pixmap.fNewFrame)
{
/* if new frame, cause window to be redisplayed */
if (lpObject == lpBase)
fNewSize = YES;
else
{
if (!fNewSize)
{
AstralUnionRect(&rUndo, &rUndo, &lpObject->rObject);
AstralUnionRect(&rUndo, &rUndo, &lpObject->rUndoObject);
}
}
}
else
{
AstralSetRectEmpty(&rTemp);
if (fUndoData)
AstralUnionRect(&rTemp, &rTemp, &lpObject->Pixmap.UndoRect);
if (fUndoAlpha)
AstralUnionRect(&rTemp, &rTemp,
&lpObject->lpAlpha->Pixmap.UndoRect);
if (rTemp.right >= rTemp.left)
{
if (!fNewSize)
{
OffsetRect(&rTemp, lpObject->rObject.left,
lpObject->rObject.top);
AstralUnionRect(&rUndo, &rUndo, &rTemp);
}
}
if( lpObject->DataUndoType & UT_OBJECTRECT )
{
AstralUnionRect( &rUndo, &rUndo, &lpObject->rObject );
AstralUnionRect( &rUndo, &rUndo, &lpObject->rUndoObject );
}
}
}
}
// now redisplay whatever changes are necessary for the undo
if (fColorMapChanged)
{
ImgColorMapChanged(this);
*lpUpdateType |= UT_DATATYPE;
}
if (fNewSize)
{
*lpUpdateType |= UT_DATATYPE;
if (lpBase->Pixmap.UndoFrame)
{
if ((FrameXSize(lpBase->Pixmap.UndoFrame) ==
FrameXSize(lpBase->Pixmap.EditFrame)) &&
(FrameYSize(lpBase->Pixmap.UndoFrame) ==
FrameYSize(lpBase->Pixmap.EditFrame)))
fNewSize = NO;
}
if (fNewSize)
*lpUpdateType |= UT_SIZE;
else
{
int dx, dy;
GetInfo(&dx, &dy, NULL, NULL);
SetRect(lpUpdateRect, 0, 0, dx-1, dy-1);
}
}
else
{
if (!AstralIsRectEmpty(lpUpdateRect))
*lpUpdateType |= UT_ACTIVEAREA;
if (rUndoMask.right >= rUndoMask.left)
{
*lpUpdateType |= UT_ACTIVEAREA;
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndoMask);
}
if (rUndo.right >= rUndo.left)
{
*lpUpdateType |= UT_AREA;
AstralUnionRect(lpUpdateRect, lpUpdateRect, &rUndo);
}
}
}
void OuterGlowStyle::operator() (Pixels destPixels, Pixels stencilPixels)
{
if (!active)
return;
//int const width = stencilPixels.getWidth ();
//int const height = stencilPixels.getHeight ();
SharedTable <Colour> table = colours.createLookupTable ();
Map2D <int> dist (stencilPixels.getWidth (), stencilPixels.getHeight ());
Map2D <int> temp (stencilPixels.getWidth (), stencilPixels.getHeight ());
if (precise)
{
LayerStyles::DistanceMap () (
Pixels::Map2D (stencilPixels),
temp,
stencilPixels.getWidth (),
stencilPixels.getHeight (),
size);
#if 0
DistanceTransform::Meijster::calculateAntiAliased (
RenderPixelAntiAliased (
destPixels,
opacity,
spread,
size,
table),
GetMask (stencilPixels),
stencilPixels.getWidth (),
stencilPixels.getHeight (),
DistanceTransform::Meijster::EuclideanMetric ());
#endif
for (int y = 0; y < temp.getRows (); ++y)
{
for (int x = 0; x < temp.getCols (); ++x)
{
int const v = temp (x, y);
if (v > 0)
temp (x, y) = (255 - v) * 256;
}
}
}
else
{
// "Softer"
LayerStyles::BoxBlurAndDilateSettings bd (size, spread);
LayerStyles::GrayscaleDilation () (
Pixels::Map2D (stencilPixels),
stencilPixels.getWidth (),
stencilPixels.getHeight (),
dist,
stencilPixels.getWidth (),
stencilPixels.getHeight (),
0,
0,
bd.getDilatePixels ());
BoxBlur () (dist, temp, temp.getCols (), temp.getRows (), bd.getBoxBlurRadius ());
}
// Fill
//
PixelARGB c (0);
for (int y = 0; y < temp.getRows (); ++y)
{
for (int x = 0; x < temp.getCols (); ++x)
{
int const v = (temp (x, y) + 128) / 256;
PixelRGB& dest (*((PixelRGB*)destPixels.getPixelPointer (x, y)));
c.setAlpha (uint8(v));
dest.blend (c);
}
}
}
OP_STATUS ContentDetector::LookUpInSniffTable(const char *octets, unsigned long octets_length, BOOL must_be_non_scriptable, BOOL check_with_mask,
BOOL specific_type_only, ContentDetectorSimpleType specific_type, int &found_at_index)
{
found_at_index = -1;
unsigned char pattern[PATTERN_MAX_LENGTH];
unsigned char mask[PATTERN_MAX_LENGTH];
for (int index = 0; index < NUMBER_OF_MIMETYPES; index++)
{
if (must_be_non_scriptable && GetPatternData(index).scriptable != SAFE)
continue;
if (specific_type_only && GetPatternData(index).simple_type != specific_type)
continue;
unsigned int octet_index = 0;
unsigned int pattern_index = 0;
GetPattern(index, pattern);
unsigned int pattern_length = GetPatternData(index).length;
if (octets_length < pattern_length)
continue;
// if needed, check for arbitrary amount of white spaces.
if (pattern[0] == WS)
{
while (octet_index < octets_length)
{
char c = octets[octet_index];
if (!op_isspace(c) || c == 0x0B) // vertical tabs (0x0B) not included.
{
break;
}
octet_index++;
}
if (octet_index == octets_length)
continue;
pattern_index++;
}
BOOL check_if_octets_terminate_with_space_or_bracket = FALSE;
char last_octet = 0; // dummy value, not used if check_if_octets_terminate_with_space_or_bracket == FALSE
if (pattern[pattern_length - 1] == SB)
{
last_octet = octets[pattern_length - 1 - pattern_index + octet_index];
pattern_length--;
check_if_octets_terminate_with_space_or_bracket = TRUE;
}
unsigned potential_octet_match_length = MIN(octets_length - octet_index, pattern_length - pattern_index);
if (check_with_mask)
{
GetMask(index, mask);
BOOL match = TRUE;
for (unsigned i = 0; i < potential_octet_match_length && match; ++i)
match = (octets[octet_index+i] & mask[pattern_index+i]) == pattern[pattern_index+i];
if (!match)
continue;
}
else if (op_memcmp(octets + octet_index, pattern + pattern_index, potential_octet_match_length) != 0)
continue;
if (check_if_octets_terminate_with_space_or_bracket && last_octet != 0x20 && last_octet != 0x3E)
continue;
found_at_index = index;
break;
}
return OpStatus::OK;
}
void RecorderDlg::AutoKeyChanComb(int comb)
{
VRenderFrame* vr_frame = (VRenderFrame*)m_frame;
if (!vr_frame)
return;
if (!m_view)
{
if (vr_frame && vr_frame->GetView(0))
m_view = vr_frame->GetView(0);
else
return;
}
DataManager* mgr = vr_frame->GetDataManager();
if (!mgr)
return;
Interpolator *interpolator = vr_frame->GetInterpolator();
if (!interpolator)
return;
wxString str = m_duration_text->GetValue();
double duration;
str.ToDouble(&duration);
KeyCode keycode;
FlKeyBoolean* flkeyB = 0;
double t = interpolator->GetLastT();
t = t<0.0?0.0:t;
if (t>0.0) t += duration;
int i;
int numChan = m_view->GetAllVolumeNum();
vector<bool> chan_mask;
//initiate mask
for (i=0; i<numChan; i++)
{
if (i < comb)
chan_mask.push_back(true);
else
chan_mask.push_back(false);
}
do
{
interpolator->Begin(t);
//for all volumes
for (i=0; i<m_view->GetAllVolumeNum(); i++)
{
VolumeData* vd = m_view->GetAllVolumeData(i);
keycode.l0 = 1;
keycode.l0_name = m_view->GetName();
keycode.l1 = 2;
keycode.l1_name = vd->GetName();
//display only
keycode.l2 = 0;
keycode.l2_name = "display";
flkeyB = new FlKeyBoolean(keycode, chan_mask[i]);
interpolator->AddKey(flkeyB);
}
interpolator->End();
t += duration;
} while (GetMask(chan_mask));
m_keylist->Update();
}
std::string VertexProgramDecompiler::GetVecMask()
{
return GetMask(false);
}
std::string VertexProgramDecompiler::GetScaMask()
{
return GetMask(true);
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
Data data;
mxArray *Im;
int nof_dim;
const int *elem_per_dim;
int nargout;
int i;
// set default values
SetDefaults(&data);
// check number of input arguments
if( (nrhs % 2 == 0) || (nrhs < 3 ) )
{
ErrorMessage(ERR_NARGIN);
ClearMemory(&data);
return;
}
// initialize that part of the data depending only on input image
{
if( !mxIsDouble(prhs[0]) ) // check if image is given as double
{
ErrorMessage(ERR_DOUBLE);
ClearMemory(&data);
return;
}
// get image dimensions
nof_dim = mxGetNumberOfDimensions(prhs[0]);
elem_per_dim = mxGetDimensions(prhs[0]);
if( nof_dim > 3 )
{
ErrorMessage(ERR_DIM);
ClearMemory(&data);
return;
}
plhs[0] = mxDuplicateArray(prhs[0]); // output image
Im = mxDuplicateArray(prhs[0]); // smoothed image
data.rows = elem_per_dim[0];
data.cols = elem_per_dim[1];
data.size = data.rows * data.cols;
data.channels = 1;
if( nof_dim == 3 )
data.channels = elem_per_dim[2];
data.Image = mxGetPr(plhs[0]);
data.MImage = mxGetPr(Im);
data.Ihelp = (double *)AllocMem(sizeof(double) * data.channels);
data.Tfield = (hItem *) AllocMem(sizeof(hItem) * data.size);
data.Domain = (double *) AllocMem(sizeof(double) * data.size);
data.MDomain = (double *) AllocMem(sizeof(double) * data.size);
data.heap = (hItem **) AllocMem(sizeof(hItem *) * data.size);
data.ordered_points = (double *) AllocMem(sizeof(double) * data.size *3);
// number of output arguments
if( nlhs <= 2 )
nargout = nlhs;
else
nargout = 2;
}
// get and check arguments
{
char guidance_done = 0;
char order_done = 0;
char argname[100];
int len;
int err;
for( i = 1 ; i < nrhs ; i = i+2 )
{
if( !mxIsChar( prhs[i] ) )
{
ErrorMessage(ERR_STRING);
ClearMemory(&data);
return;
}
else
{
len = mxGetN( prhs[i] );
mxGetString( prhs[i], argname, len+1);
//mexPrintf(" %s \n", argname);
switch( argname[0] )
{
case 'o': // orderD , orderT
{
if( !order_done )
{
if( !mxIsEmpty(prhs[i+1]) )
{
if( argname[len-1] == 'D' )
{
err = GetMask( prhs[i+1], &data);
data.ordergiven = 0;
}
else if( argname[len-1] == 'T' )
{
err = GetOrder( prhs[i+1], &data);
data.ordergiven =1;
}
else
err = ERR_UNKNOWN_ID;
}
else
err = ERR_ARG_MISSING;
order_done = 1;
}
break;
}
case 'g': // guidanceN , guidanceC , guidanceD
{
if( !guidance_done )
{
if( !mxIsEmpty(prhs[i+1]) )
{
if( argname[len-1] == 'N' )
{
err = GetParam( prhs[i+1], &data, TYPE_N);
data.guidance = 0;
}
else if( argname[len-1] == 'C' )
{
err = GetParam( prhs[i+1], &data, TYPE_C);
data.guidance = 1;
}
else if( argname[len-1] == 'D' )
{
err = GetParam( prhs[i+1], &data, TYPE_D);
data.guidance = 2;
}
else
err = ERR_UNKNOWN_ID;
}
else
err = ERR_ARG_MISSING;
// guidance_done = 1;
if(data.GivenGuidanceT != NULL)
data.guidance = 2;
}
break;
}
default:
err = ERR_UNKNOWN_ID;
break;
}
if( err )
{
ErrorMessage(err);
ClearMemory(&data);
return;
}
}
}
if( !order_done ) // at least mask must be specified
{
ErrorMessage(ERR_NO_MASK_ORDER);
ClearMemory(&data);
return;
}
}
if( data.guidance == 1)
SetKernels(&data);
InpaintImage(&data);
if(data.inpaint_undefined == 1)
{
mexPrintf("\n\n");
mexPrintf("Error:\n");
mexPrintf("Some inpainted image values are undefined !\n");
mexPrintf("This happens if the order is not well-defined. \n");
mexPrintf("You can find out the undefined pixels by: > ind = find( isnan(result) ) \n\n\n");
}
if( nargout == 2 )
{
double *p;
int size;
size = 3 * data.nof_points2inpaint;
plhs[1] = mxCreateDoubleMatrix(3, data.nof_points2inpaint , mxREAL);
p = mxGetPr(plhs[1]);
for( i=0 ; i < size ; i++ )
if( (i+1) % 3 != 0 )
p[i] = data.ordered_points[i] + 1;
else
p[i] = data.ordered_points[i];
}
//CopyMask(&data);
//CopyParam( &data );
//CopyDirfield( &data );
//CopyMImage( &data );
//CopyTfield(&data);
ClearMemory(&data);
return;
}
/*
==============
sdDeployMaskEditSession::UpdateProjection
==============
*/
void sdDeployMaskEditSession::UpdateProjection( const idVec3& position ) {
if ( !decalMaterial ) {
return;
}
if ( decalHandle == -1 ) {
decalHandle = gameLocal.RegisterLoggedDecal( decalMaterial );
}
gameLocal.ResetLoggedDecal( decalHandle );
gameDecalInfo_t* decalInfo = gameLocal.GetLoggedDecal( decalHandle );
sdDeployMaskInstance* mask = GetMask( position );
const sdHeightMapInstance* heightMap = GetHeightMap( position );
if ( mask != NULL && mask->IsValid() && heightMap != NULL ) {
sdDeployMask::extents_t extents;
GetExtents( position, *mask, extents );
float depth = 512.0f;
int maxX, maxY;
mask->GetDimensions( maxX, maxY );
sdDeployMask::extents_t expandedExtents;
expandedExtents.minx = Max( 0, extents.minx - 2 );
expandedExtents.miny = Max( 0, extents.miny - 2 );
expandedExtents.maxx = Min( maxX, extents.maxx + 2 );
expandedExtents.maxy = Min( maxY, extents.maxy + 2 );
idList< const idMaterial* > megaTextureMaterials;
const idStrList& megaTextureMaterialNames = gameLocal.GetMapInfo().GetMegatextureMaterials();
for ( int i = 0; i < megaTextureMaterialNames.Num(); i++ ) {
megaTextureMaterials.Append( declHolder.FindMaterial( megaTextureMaterialNames[ i ] ) );
}
idFixedWinding winding;
int spawnID = WORLD_SPAWN_ID;
for ( int i = expandedExtents.minx; i <= expandedExtents.maxx; i++ ) {
for ( int j = expandedExtents.miny; j <= expandedExtents.maxy; j++ ) {
gameDecalInfo_t* info = decalInfo;
if ( !info ) {
continue;
}
sdDeployMask::extents_t localExtents;
localExtents.minx = i;
localExtents.maxx = i;
localExtents.miny = j;
localExtents.maxy = j;
idBounds bounds;
mask->GetBounds( localExtents, bounds, heightMap );
idVec3 top = bounds.GetCenter();
top[ 2 ] = bounds.GetMaxs()[ 2 ];
deployResult_t localResult = mask->IsValid( localExtents );
idVec4 localColor;
switch ( localResult ) {
case DR_CLEAR:
localColor = colorGreen;
break;
default:
case DR_FAILED:
localColor = colorDkRed;
break;
}
if ( !( ( i >= extents.minx ) && ( i <= extents.maxx ) && ( j >= extents.miny ) && ( j <= extents.maxy ) ) ) {
localColor.x *= 0.3f;
localColor.y *= 0.3f;
localColor.z *= 0.3f;
}
winding.Clear();
winding += idVec5( idVec3( bounds.GetMins()[ 0 ], bounds.GetMins()[ 1 ], bounds.GetMins()[ 2 ] - depth ), idVec2( 0.0f, 0.0f ) );
winding += idVec5( idVec3( bounds.GetMins()[ 0 ], bounds.GetMaxs()[ 1 ], bounds.GetMins()[ 2 ] - depth ), idVec2( 0.0f, 1.0f ) );
winding += idVec5( idVec3( bounds.GetMaxs()[ 0 ], bounds.GetMaxs()[ 1 ], bounds.GetMins()[ 2 ] - depth ), idVec2( 1.0f, 1.0f ) );
winding += idVec5( idVec3( bounds.GetMaxs()[ 0 ], bounds.GetMins()[ 1 ], bounds.GetMins()[ 2 ] - depth ), idVec2( 1.0f, 0.0f ) );
gameRenderWorld->AddToProjectedDecal( winding, top + idVec3( 0, 0, 64.f + depth ), true, localColor, info->renderEntity.hModel, spawnID, megaTextureMaterials.Begin(), megaTextureMaterials.Num() );
}
}
}
}
void GLVertexDecompilerThread::AddCode(bool is_sca, const std::string& pCode, bool src_mask, bool set_dst, bool set_cond)
{
std::string code = pCode;
if(d0.cond == 0) return;
enum
{
lt = 0x1,
eq = 0x2,
gt = 0x4,
};
static const char* cond_string_table[(lt | gt | eq) + 1] =
{
"error",
"lessThan",
"equal",
"lessThanEqual",
"greaterThan",
"notEqual",
"greaterThanEqual",
"error"
};
std::string cond;
if((set_cond || d0.cond_test_enable) && d0.cond != (lt | gt | eq))
{
static const char f[4] = {'x', 'y', 'z', 'w'};
std::string swizzle;
swizzle += f[d0.mask_x];
swizzle += f[d0.mask_y];
swizzle += f[d0.mask_z];
swizzle += f[d0.mask_w];
swizzle = swizzle == "xyzw" ? "" : "." + swizzle;
cond = fmt::Format("if(all(%s(rc%s, vec4(0.0)%s))) ", cond_string_table[d0.cond], swizzle.c_str(), swizzle.c_str());
}
std::string mask = GetMask(is_sca);
std::string value = src_mask ? code + mask : code;
if(is_sca && d0.vec_result)
{
value = "vec4(" + value + ")" + mask;
}
if(d0.staturate)
{
value = "clamp(" + value + ", 0.0, 1.0)";
}
if(set_dst)
{
std::string dest;
if(d0.cond_update_enable_0)
{
dest = m_parr.AddParam(PARAM_NONE, "vec4", "rc", "vec4(0.0)") + mask;
}
else if(d3.dst == 5 || d3.dst == 6)
{
if(d3.vec_writemask_x)
{
dest = m_parr.AddParam(PARAM_OUT, "vec4", "fogc") + mask;
}
else
{
int num = d3.dst == 5 ? 0 : 3;
//if(d3.vec_writemask_y) num += 0;
if(d3.vec_writemask_z) num += 1;
else if(d3.vec_writemask_w) num += 2;
dest = fmt::Format(GetDST(is_sca) + "/*" + mask + "*/", num);
}
}
else
{
dest = GetDST(is_sca) + mask;
}
code = cond + dest + " = " + value;
}
else
{
code = cond + value;
}
m_body.push_back(code + ";");
}
std::string GLVertexDecompilerThread::GetScaMask()
{
return GetMask(true);
}
void GLFragmentDecompilerThread::AddCode(std::string code, bool append_mask)
{
if(!src0.exec_if_eq && !src0.exec_if_gr && !src0.exec_if_lt) return;
const std::string mask = GetMask();
std::string cond;
if(!src0.exec_if_gr || !src0.exec_if_lt || !src0.exec_if_eq)
{
static const char f[4] = {'x', 'y', 'z', 'w'};
std::string swizzle;
swizzle += f[src0.cond_swizzle_x];
swizzle += f[src0.cond_swizzle_y];
swizzle += f[src0.cond_swizzle_z];
swizzle += f[src0.cond_swizzle_w];
swizzle = swizzle == "xyzw" ? "" : "." + swizzle;
if(src0.exec_if_gr && src0.exec_if_eq)
{
cond = "greaterThanEqual";
}
else if(src0.exec_if_lt && src0.exec_if_eq)
{
cond = "lessThanEqual";
}
else if(src0.exec_if_gr && src0.exec_if_lt)
{
cond = "notEqual";
}
else if(src0.exec_if_gr)
{
cond = "greaterThan";
}
else if(src0.exec_if_lt)
{
cond = "lessThan";
}
else //if(src0.exec_if_eq)
{
cond = "equal";
}
cond = "if(all(" + cond + "(" + AddCond(dst.no_dest) + swizzle + ", vec4(0.0)))) ";
}
if(src1.scale)
{
switch(src1.scale)
{
case 1: code = "(" + code + " * 2)"; break;
case 2: code = "(" + code + " * 4)"; break;
case 3: code = "(" + code + " * 8)"; break;
case 5: code = "(" + code + " / 2)"; break;
case 6: code = "(" + code + " / 4)"; break;
case 7: code = "(" + code + " / 8)"; break;
default:
ConLog.Error("Bad scale: %d", fmt::by_value(src1.scale));
Emu.Pause();
break;
}
}
if(dst.saturate)
{
code = "clamp(" + code + ", 0.0, 1.0)";
}
std::string dest;
if(dst.no_dest)
{
if(dst.set_cond)
{
dest = m_parr.AddParam(PARAM_NONE , "vec4", std::string(dst.fp16 ? "hc" : "rc") + std::to_string(src0.cond_reg_index));
}
}
else
{
dest = AddReg(dst.dest_reg, dst.fp16);
}
code = cond + (dest.length() ? dest + mask + " = " : "") + code + (append_mask ? mask : "");
main += "\t" + code + ";\n";
}
void COXMaskedEdit::SetMask(LPCTSTR pszMask)
{
if(pszMask==NULL)
{
pszMask=_T("");
}
DeleteContents();
CMaskData* pobjData=NULL;
for(LPCTSTR pszInsertionPoint=pszMask; *pszInsertionPoint; pszInsertionPoint++)
{
TCHAR chNew=*pszInsertionPoint;
pobjData=new CMaskData();
m_listData.AddTail(pobjData);
switch(chNew)
{
case chMaskPlaceholderDECIMALSEPARATOR :
pobjData->m_eType =MaskDataTypeDECIMALSEPARATOR ;
pobjData->m_chValue=m_chIntlDecimal ;
break;
case chMaskPlaceholderTHOUSANDSSEPARATOR:
pobjData->m_eType =MaskDataTypeTHOUSANDSSEPARATOR;
pobjData->m_chValue=m_chIntlThousands ;
break;
case chMaskPlaceholderTIMESEPARATOR :
pobjData->m_eType =MaskDataTypeTIMESEPARATOR ;
pobjData->m_chValue=m_chIntlTime ;
break;
case chMaskPlaceholderDATESEPARATOR :
pobjData->m_eType =MaskDataTypeDATESEPARATOR ;
pobjData->m_chValue=m_chIntlDate ;
break;
case chMaskPlaceholderDIGIT :
pobjData->m_eType =MaskDataTypeDIGIT ;
pobjData->m_chValue=m_chPromptSymbol ;
break;
case chMaskPlaceholderALPHANUMERIC :
pobjData->m_eType =MaskDataTypeALPHANUMERIC ;
pobjData->m_chValue=m_chPromptSymbol ;
break;
case chMaskPlaceholderALPHABETIC :
pobjData->m_eType =MaskDataTypeALPHABETIC ;
pobjData->m_chValue=m_chPromptSymbol ;
break;
case chMaskPlaceholderALPHABETICUPPER :
pobjData->m_eType =MaskDataTypeALPHAETICUPPER ;
pobjData->m_chValue=m_chPromptSymbol ;
break;
case chMaskPlaceholderALPHABETICLOWER :
pobjData->m_eType =MaskDataTypeALPHAETICLOWER ;
pobjData->m_chValue=m_chPromptSymbol ;
break;
case chMaskPlaceholderCHARACTER :
pobjData->m_eType =MaskDataTypeCHARACTER ;
pobjData->m_chValue=m_chPromptSymbol ;
break;
case chMaskPlaceholderLITERALESCAPE :
// It is the next character that is inserted.
pszInsertionPoint++;
chNew=*pszInsertionPoint;
if(chNew)
{
pobjData->m_eType =MaskDataTypeLITERALESCAPE ;
pobjData->m_chValue=chNew ;
break;
}
// If there is no character following the escape,
// just treat the escape as a literal so that the user
// will see the problem.
default:
// Everything else is just a literal.
pobjData->m_eType =MaskDataTypeLITERAL ;
pobjData->m_chValue=chNew ;
break;
}
}
ASSERT(GetMask()==pszMask);
Update();
if(::IsWindow(GetSafeHwnd()))
SetModify(FALSE);
}
// May Trigger GC if get is false, str, if not NULL, needs to be rooted prior to calling Add()
HRESULT CLR_RT_HeapBlock_XmlNameTable::Add( LPCSTR key, CLR_UINT32 length, CLR_RT_HeapBlock_String*& str, bool get )
{
TINYCLR_HEADER();
CLR_RT_HeapBlock_XmlNameTable_Entry* entry;
CLR_RT_HeapBlock_String* match;
CLR_INT32 hashCode;
CLR_UINT32 i;
if(length == 0)
{
// if length is 0, return String.Empty
str = CLR_RT_HeapBlock_String::GetStringEmpty();
TINYCLR_SET_AND_LEAVE(S_OK);
}
// Calculating the hash code
hashCode = length + GetRandomizer();
for(i = 0; i < length; i++)
{
hashCode += (hashCode << 7) ^ key[ i ];
}
hashCode -= hashCode >> 17;
hashCode -= hashCode >> 11;
hashCode -= hashCode >> 5;
// Retrieve the entry (or entries) that hash to that bucket
entry = (CLR_RT_HeapBlock_XmlNameTable_Entry*)(((CLR_RT_HeapBlock*)GetEntries()->GetElement( hashCode & GetMask() ))->Dereference());
// Go through all the entries in the singly linked list to make sure there's no match
while(entry != NULL)
{
if(entry->GetHashCode() == hashCode)
{
match = entry->GetStr();
if((hal_strncmp_s( match->StringText(), key, length ) == 0) && (match->StringText()[ length ] == '\0'))
{
// if we find a match, we return the matched string
str = match;
TINYCLR_SET_AND_LEAVE(S_OK);
}
}
entry = entry->GetNext();
}
if(get)
{
// we're only getting, so return null if no string is found
str = NULL;
TINYCLR_SET_AND_LEAVE(S_OK);
}
else
{
// we'll re-use the String object if we were given one, if not, we'll create it here
if(str == NULL)
{
CLR_RT_HeapBlock strHB;
TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( strHB, key, length ));
str = strHB.DereferenceString();
// Attach the new string to the managed handle to prevent it from being GC when we allocate the Entry object in AddEntry()
SetTmp( str );
}
TINYCLR_SET_AND_LEAVE(AddEntry( str, hashCode ));
}
TINYCLR_NOCLEANUP();
}
wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight, int newx, int newy )
{
wxCHECK_MSG( Ok(), wxNullBitmap, wxT("invalid bitmap") );
if (newy==M_BMPDATA->m_width && newy==M_BMPDATA->m_height)
return *this;
int width = wxMax(newx, 1);
int height = wxMax(newy, 1);
width = wxMin(width, clipwidth);
height = wxMin(height, clipheight);
wxBitmap bmp;
#ifdef __WXGTK20__
if (HasPixbuf())
{
bmp.SetWidth(width);
bmp.SetHeight(height);
bmp.SetDepth(GetDepth());
bmp.SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB,
gdk_pixbuf_get_has_alpha(GetPixbuf()),
8, width, height));
gdk_pixbuf_scale(GetPixbuf(), bmp.GetPixbuf(),
0, 0, width, height,
clipx, clipy,
(double)newx/GetWidth(), (double)newy/GetHeight(),
GDK_INTERP_BILINEAR);
}
else
#endif // __WXGTK20__
{
GdkImage *img = (GdkImage*) NULL;
if (GetPixmap())
img = gdk_image_get( GetPixmap(), 0, 0, GetWidth(), GetHeight() );
else if (GetBitmap())
img = gdk_image_get( GetBitmap(), 0, 0, GetWidth(), GetHeight() );
else
wxFAIL_MSG( wxT("Ill-formed bitmap") );
wxCHECK_MSG( img, wxNullBitmap, wxT("couldn't create image") );
int bpp = -1;
GdkGC *gc = NULL;
GdkPixmap *dstpix = NULL;
if (GetPixmap())
{
GdkVisual *visual = gdk_window_get_visual( GetPixmap() );
if (visual == NULL)
visual = wxTheApp->GetGdkVisual();
bpp = visual->depth;
bmp = wxBitmap(width,height,bpp);
dstpix = bmp.GetPixmap();
gc = gdk_gc_new( dstpix );
}
char *dst = NULL;
long dstbyteperline = 0;
if (GetBitmap())
{
bpp = 1;
dstbyteperline = width/8*M_BMPDATA->m_bpp;
if (width*M_BMPDATA->m_bpp % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
}
// be careful to use the right scaling factor
float scx = (float)M_BMPDATA->m_width/(float)newx;
float scy = (float)M_BMPDATA->m_height/(float)newy;
// prepare accel-tables
int *tablex = (int *)calloc(width,sizeof(int));
int *tabley = (int *)calloc(height,sizeof(int));
// accel table filled with clipped values
for (int x = 0; x < width; x++)
tablex[x] = (int) (scx * (x+clipx));
for (int y = 0; y < height; y++)
tabley[y] = (int) (scy * (y+clipy));
// Main rescaling routine starts here
for (int h = 0; h < height; h++)
{
char outbyte = 0;
int old_x = -1;
guint32 old_pixval = 0;
for (int w = 0; w < width; w++)
{
guint32 pixval;
int x = tablex[w];
if (x == old_x)
pixval = old_pixval;
else
{
pixval = gdk_image_get_pixel( img, x, tabley[h] );
old_pixval = pixval;
old_x = x;
}
if (bpp == 1)
{
if (!pixval)
{
char bit=1;
char shift = bit << w % 8;
outbyte |= shift;
}
if ((w+1)%8==0)
{
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
}
else
{
GdkColor col;
col.pixel = pixval;
gdk_gc_set_foreground( gc, &col );
gdk_draw_point( dstpix, gc, w, h);
}
}
// do not forget the last byte
if ((bpp == 1) && (width % 8 != 0))
dst[h*dstbyteperline+width/8] = outbyte;
}
gdk_image_destroy( img );
if (gc) gdk_gc_unref( gc );
if (bpp == 1)
{
bmp = wxBitmap( (const char *)dst, width, height, 1 );
free( dst );
}
if (GetMask())
{
dstbyteperline = width/8;
if (width % 8 != 0)
dstbyteperline++;
dst = (char*) malloc(dstbyteperline*height);
img = gdk_image_get( GetMask()->GetBitmap(), 0, 0, GetWidth(), GetHeight() );
for (int h = 0; h < height; h++)
{
char outbyte = 0;
int old_x = -1;
guint32 old_pixval = 0;
for (int w = 0; w < width; w++)
{
guint32 pixval;
int x = tablex[w];
if (x == old_x)
pixval = old_pixval;
else
{
pixval = gdk_image_get_pixel( img, x, tabley[h] );
old_pixval = pixval;
old_x = x;
}
if (pixval)
{
char bit=1;
char shift = bit << w % 8;
outbyte |= shift;
}
if ((w+1)%8 == 0)
{
dst[h*dstbyteperline+w/8] = outbyte;
outbyte = 0;
}
}
// do not forget the last byte
if (width % 8 != 0)
dst[h*dstbyteperline+width/8] = outbyte;
}
wxMask* mask = new wxMask;
mask->m_bitmap = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) dst, width, height );
bmp.SetMask(mask);
free( dst );
gdk_image_destroy( img );
}
free( tablex );
free( tabley );
}
return bmp;
}
std::string GLVertexDecompilerThread::GetVecMask()
{
return GetMask(false);
}