int main(int argc, char ** argv) { // Global errno reset to properly parse errors from fopen() function call errno = 0; // User specified passphrase char password[BUFSIZ]; // Length of the password int length = 0; // Randomly generated key char key[BUFSIZ]; // Bitmask used to encrypt file char mask[BUFSIZ]; // Set to user-specified file FILE * file = 0; // Check if a file is specified if(--argc != 1) { (void)fprintf(stderr, USAGE); return EXIT_FAILURE; } file = fopen(argv[1], READ_MODE); // Check if file is valid if(file == NULL) { if(errno == EACCES) { // User does not have permission to read/write file, print error (void)fprintf(stderr, NO_ACCESS); return EXIT_FAILURE; } else { // File itself is invalid, print error (void)fprintf(stderr, FILE_INVALID); return EXIT_FAILURE; } } else { (void)printf(PASS_PROMPT); (void)scanf("%s", password); // Check if password is at least 8 characters long if(!parsePassword(password, &length)) { (void)fprintf(stderr, PASS_SHORT); return EXIT_FAILURE; } // Randomly generate the key based on password length (void)generateKey(length, key); (void)generateMask(key, password, mask, length); } return EXIT_SUCCESS; }
void loadTextData(const char *pFileName, byte *pDestinationBuffer) { Common::File pFileHandle; uint16 entrySize; uint16 numEntry; uint16 i; byte *tempBuffer; uint16 dataSize; assert(pFileName); assert(pDestinationBuffer); pFileHandle.open(pFileName); assert(pFileHandle.isOpen()); entrySize = pFileHandle.readUint16BE(); numEntry = pFileHandle.readUint16BE(); dataSize = numEntry * entrySize; pFileHandle.read(pDestinationBuffer, numEntry * entrySize); tempBuffer = pDestinationBuffer; if (gameType == Cine::GID_FW) { dataSize = dataSize / 0x4E; loadRelatedPalette(pFileName); for (i = 0; i < 0x4E; i++) { gfxConvertSpriteToRaw(textTable[i][0], tempBuffer, 16, 8); generateMask(textTable[i][0], textTable[i][1], 16 * 8, 0); tempBuffer += dataSize; } } else { for (i = 0; i < 90; i++) { gfxConvertSpriteToRaw(textTable[i][0], tempBuffer, 8, 8); generateMask(textTable[i][0], textTable[i][1], 8 * 8, 0); tempBuffer += 0x40; } } pFileHandle.close(); }
void init(Parameter *para) { generateMask(para); size_t initCount = this->initCount_.fetch_add(1); CHECK_EQ(initCount, 0UL) << "Currently the StaticPruningHook must invoke " "in same ParamterUpdater"; VLOG(3) << "Initialize Parameter " << para; SetDevice device(para->getDeviceId()); auto ¶Vec = para->getBuf(PARAMETER_VALUE); paraVec->dotMul(*maskVec_); }
void Websocket::makeHeader(uint8_t *data, const uint64_t data_size, const uint64_t length,const uint16_t flags) { if(Websocket::reserve(length , flags) > data_size) { //todo throw exception } uint8_t header_size = 1; flags2header(data,flags); header_size += length2header(data,length); if( data[1] & 0x80) { generateMask(data + header_size); header_size += 4; } }
void SkScalerContext::getImage(const SkGlyph& origGlyph) { const SkGlyph* glyph = &origGlyph; SkGlyph tmpGlyph; if (fMaskFilter) { // restore the prefilter bounds tmpGlyph.init(origGlyph.fID); // need the original bounds, sans our maskfilter SkMaskFilter* mf = fMaskFilter; fMaskFilter = NULL; // temp disable this->getMetrics(&tmpGlyph); fMaskFilter = mf; // restore tmpGlyph.fImage = origGlyph.fImage; // we need the prefilter bounds to be <= filter bounds SkASSERT(tmpGlyph.fWidth <= origGlyph.fWidth); SkASSERT(tmpGlyph.fHeight <= origGlyph.fHeight); glyph = &tmpGlyph; } if (fGenerateImageFromPath) { SkPath devPath, fillPath; SkMatrix fillToDevMatrix; SkMask mask; this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix); glyph->toMask(&mask); if (fRasterizer) { mask.fFormat = SkMask::kA8_Format; sk_bzero(glyph->fImage, mask.computeImageSize()); if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, NULL, fMaskFilter, &mask, SkMask::kJustRenderImage_CreateMode)) { return; } } else { generateMask(mask, devPath); } } else { this->getGlyphContext(*glyph)->generateImage(*glyph); } if (fMaskFilter) { SkMask srcM, dstM; SkMatrix matrix; // the src glyph image shouldn't be 3D SkASSERT(SkMask::k3D_Format != glyph->fMaskFormat); glyph->toMask(&srcM); fRec.getMatrixFrom2x2(&matrix); if (fMaskFilter->filterMask(&dstM, srcM, matrix, NULL)) { int width = SkFastMin32(origGlyph.fWidth, dstM.fBounds.width()); int height = SkFastMin32(origGlyph.fHeight, dstM.fBounds.height()); int dstRB = origGlyph.rowBytes(); int srcRB = dstM.fRowBytes; const uint8_t* src = (const uint8_t*)dstM.fImage; uint8_t* dst = (uint8_t*)origGlyph.fImage; if (SkMask::k3D_Format == dstM.fFormat) { // we have to copy 3 times as much height *= 3; } // clean out our glyph, since it may be larger than dstM //sk_bzero(dst, height * dstRB); while (--height >= 0) { memcpy(dst, src, width); src += srcRB; dst += dstRB; } SkMask::FreeImage(dstM.fImage); } } }
void convertImages(Arguments* args){ char** mask = NULL; TwoPoints source, dest; FILE* eyeList; char line[ FILE_LINE_LENGTH ]; char filename[MAX_FILENAME_LENGTH]; char imagename[MAX_FILENAME_LENGTH]; char suffix[MAX_FILENAME_LENGTH]; int i; scaleArgs(args, args->scale); dest.x1 = args->eyeLx; dest.y1 = args->eyeLy; dest.x2 = args->eyeRx; dest.y2 = args->eyeRy; /* Prepare file suffix encoding preprocessing settings, blank if not requested */ if (args->configSuffix) { sprintf(suffix,"_%s", imageSuffix(args)); } else { suffix[0] = '\0'; } if(args->maskType == CL_YES){ MESSAGE("Creating Mask."); mask = generateMask(args->sizeWidth, args->sizeHeight, args->ellipseX, args->ellipseY, args->ellipseA, args->ellipseB); } eyeList = fopen(args->eyeFile,"r"); DEBUG_CHECK(eyeList,"Error opening eye coordinates file"); for(i = 1;;i++){ Image pgm; Image geo; Matrix transform; fgets(line, FILE_LINE_LENGTH, eyeList); if(feof(eyeList)) break; if(sscanf(line,"%s %lf %lf %lf %lf",filename, &(source.x1), &(source.y1), &(source.x2), &(source.y2)) != 5){ printf("Error parsing line %d of eye coordinate file. Exiting...",i); exit(1); } /* shift the eye coordinates if neccessary */ source.x1 += args->shiftX; source.y1 += args->shiftY; source.x2 += args->shiftX; source.y2 += args->shiftY; sprintf(imagename,"%s\\%s.pgm",args->inputDir,filename); MESSAGE1ARG("Processing image: %s",filename); pgm = readPGMImage(imagename); if(args->histType == HIST_PRE){ DEBUG(1," Performing Pre Histogram Equalization."); histEqual(pgm,256); } if(args->preNormType == CL_YES){ DEBUG(1," Performing Pre Pixel Normalization."); ZeroMeanOneStdDev(pgm); } if(args->preEdge){ smoothImageEdge(pgm, args->preEdge); } if(args->geoType == CL_YES){ DEBUG(1," Performing Geometric Normalization."); transform = generateTransform(&source,&dest,args->reflect); geo = transformImage(pgm,args->sizeWidth,args->sizeHeight,transform); } else{ transform = makeIdentityMatrix(3); geo = transformImage(pgm,args->sizeWidth,args->sizeHeight,transform); } if(args->noise != 0.0){ DEBUG(1," Adding Gausian Noise."); gaussianNoise(geo,args->noise); } if(args->histType == HIST_POST){ DEBUG(1," Performing Post Histogram Equalization."); histEqualMask(geo,256, (const char**) mask); } if(args->nrmType == CL_YES){ DEBUG(1," Performing final value normalization and Applying Mask."); ZeroMeanOneStdDevMasked(geo, (const char **) mask); } else{ DEBUG(1," No Value Normalization. Just Applying Mask."); applyMask(geo, (const char **) mask); } if(args->postEdge){ smoothImageEdge(geo, args->postEdge); } if(args->nrmDir){ sprintf(imagename,"%s\\%s%s.nrm", args->nrmDir, filename, suffix); DEBUG_STRING(1," Saving nrm: %s",imagename); writeFeretImage(geo,imagename); } if(args->pgmDir){ sprintf(imagename,"%s\\%s%s.pgm", args->pgmDir, filename, suffix); DEBUG_STRING(1," Saving pgm: %s",imagename); writePGMImage(geo,imagename,0); } if(args->sfiDir){ sprintf(imagename,"%s\\%s%s.sfi", args->sfiDir, filename, suffix); DEBUG_STRING(1," Saving sfi: %s",imagename); writeRawImage(geo,imagename); } freeImage(geo); freeImage(pgm); freeMatrix(transform); } fclose(eyeList); }
/** * Draw one overlay * @param it Overlay info * @todo Add handling of type 22 overlays */ void OSRenderer::renderOverlay(const Common::List<overlay>::iterator &it) { int len, idx, width, height; ObjectStruct *obj; AnimData *sprite; byte *mask; byte color; switch (it->type) { // color sprite case 0: if (g_cine->_objectTable[it->objIdx].frame < 0) { break; } sprite = &g_cine->_animDataTable[g_cine->_objectTable[it->objIdx].frame]; len = sprite->_realWidth * sprite->_height; mask = new byte[len]; generateMask(sprite->data(), mask, len, g_cine->_objectTable[it->objIdx].part); remaskSprite(mask, it); drawMaskedSprite(g_cine->_objectTable[it->objIdx], mask); delete[] mask; break; // game message case 2: if (it->objIdx >= g_cine->_messageTable.size()) { return; } _messageLen += g_cine->_messageTable[it->objIdx].size(); drawMessage(g_cine->_messageTable[it->objIdx].c_str(), it->x, it->y, it->width, it->color); if (it->color >= 0) { // This test isn't in Future Wars's implementation waitForPlayerClick = 1; } break; // action failure message case 3: idx = it->objIdx * 4 + g_cine->_rnd.getRandomNumber(3); len = strlen(failureMessages[idx]); _messageLen += len; width = 6 * len + 20; width = width > 300 ? 300 : width; // The used color here differs from Future Wars drawMessage(failureMessages[idx], (320 - width) / 2, 80, width, _messageBg); waitForPlayerClick = 1; break; // bitmap case 4: if (g_cine->_objectTable[it->objIdx].frame >= 0) { FWRenderer::renderOverlay(it); } break; // masked background case 20: assert(it->objIdx < NUM_MAX_OBJECT); var5 = it->x; // A global variable updated here! obj = &g_cine->_objectTable[it->objIdx]; sprite = &g_cine->_animDataTable[obj->frame]; if (obj->frame < 0 || it->x < 0 || it->x > 8 || !_bgTable[it->x].bg || sprite->_bpp != 1) { break; } maskBgOverlay(_bgTable[it->x].bg, sprite->data(), sprite->_realWidth, sprite->_height, _backBuffer, obj->x, obj->y); break; // FIXME: Implement correct drawing of type 21 overlays. // Type 21 overlays aren't just filled rectangles, I found their drawing routine // from Operation Stealth's drawSprite routine. So they're likely some kind of sprites // and it's just a coincidence that the oxygen meter during the first arcade sequence // works even somehow currently. I tried the original under DOSBox and the oxygen gauge // is a long red bar that gets shorter as the air runs out. case 21: // A filled rectangle: case 22: // TODO: Check it this implementation really works correctly (Some things might be wrong, needs testing). assert(it->objIdx < NUM_MAX_OBJECT); obj = &g_cine->_objectTable[it->objIdx]; color = obj->part & 0x0F; width = obj->frame; height = obj->costume; drawPlainBox(obj->x, obj->y, width, height, color); debug(5, "renderOverlay: type=%d, x=%d, y=%d, width=%d, height=%d, color=%d", it->type, obj->x, obj->y, width, height, color); break; // something else default: FWRenderer::renderOverlay(it); break; } }
void SkScalerContext::getImage(const SkGlyph& origGlyph) { const SkGlyph* glyph = &origGlyph; SkGlyph tmpGlyph; // in case we need to call generateImage on a mask-format that is different // (i.e. larger) than what our caller allocated by looking at origGlyph. SkAutoMalloc tmpGlyphImageStorage; // If we are going to draw-from-path, then we cannot generate color, since // the path only makes a mask. This case should have been caught up in // generateMetrics(). SkASSERT(!fGenerateImageFromPath || SkMask::kARGB32_Format != origGlyph.fMaskFormat); if (fMaskFilter) { // restore the prefilter bounds tmpGlyph.initGlyphIdFrom(origGlyph); // need the original bounds, sans our maskfilter SkMaskFilter* mf = fMaskFilter; fMaskFilter = nullptr; // temp disable this->getMetrics(&tmpGlyph); fMaskFilter = mf; // restore // we need the prefilter bounds to be <= filter bounds SkASSERT(tmpGlyph.fWidth <= origGlyph.fWidth); SkASSERT(tmpGlyph.fHeight <= origGlyph.fHeight); if (tmpGlyph.fMaskFormat == origGlyph.fMaskFormat) { tmpGlyph.fImage = origGlyph.fImage; } else { tmpGlyphImageStorage.reset(tmpGlyph.computeImageSize()); tmpGlyph.fImage = tmpGlyphImageStorage.get(); } glyph = &tmpGlyph; } if (fGenerateImageFromPath) { SkPath devPath, fillPath; SkMatrix fillToDevMatrix; SkMask mask; this->internalGetPath(*glyph, &fillPath, &devPath, &fillToDevMatrix); glyph->toMask(&mask); if (fRasterizer) { mask.fFormat = SkMask::kA8_Format; sk_bzero(glyph->fImage, mask.computeImageSize()); if (!fRasterizer->rasterize(fillPath, fillToDevMatrix, nullptr, fMaskFilter, &mask, SkMask::kJustRenderImage_CreateMode)) { return; } if (fPreBlend.isApplicable()) { applyLUTToA8Mask(mask, fPreBlend.fG); } } else { SkASSERT(SkMask::kARGB32_Format != mask.fFormat); generateMask(mask, devPath, fPreBlend); } } else { generateImage(*glyph); } if (fMaskFilter) { SkMask srcM, dstM; SkMatrix matrix; // the src glyph image shouldn't be 3D SkASSERT(SkMask::k3D_Format != glyph->fMaskFormat); SkAutoSMalloc<32*32> a8storage; glyph->toMask(&srcM); if (SkMask::kARGB32_Format == srcM.fFormat) { // now we need to extract the alpha-channel from the glyph's image // and copy it into a temp buffer, and then point srcM at that temp. srcM.fFormat = SkMask::kA8_Format; srcM.fRowBytes = SkAlign4(srcM.fBounds.width()); size_t size = srcM.computeImageSize(); a8storage.reset(size); srcM.fImage = (uint8_t*)a8storage.get(); extract_alpha(srcM, (const SkPMColor*)glyph->fImage, glyph->rowBytes()); } fRec.getMatrixFrom2x2(&matrix); if (fMaskFilter->filterMask(&dstM, srcM, matrix, nullptr)) { int width = SkFastMin32(origGlyph.fWidth, dstM.fBounds.width()); int height = SkFastMin32(origGlyph.fHeight, dstM.fBounds.height()); int dstRB = origGlyph.rowBytes(); int srcRB = dstM.fRowBytes; const uint8_t* src = (const uint8_t*)dstM.fImage; uint8_t* dst = (uint8_t*)origGlyph.fImage; if (SkMask::k3D_Format == dstM.fFormat) { // we have to copy 3 times as much height *= 3; } // clean out our glyph, since it may be larger than dstM //sk_bzero(dst, height * dstRB); while (--height >= 0) { memcpy(dst, src, width); src += srcRB; dst += dstRB; } SkMask::FreeImage(dstM.fImage); if (fPreBlendForFilter.isApplicable()) { applyLUTToA8Mask(srcM, fPreBlendForFilter.fG); } } } }
void Popover::setupUi(PopoverType type) { mType = type; switch(mType) { case Class: mForm = new PopoverClass(); mForm->setupUi(); break; case Package: mForm = new PopoverPackage(); mForm->setupUi(); break; case Primitive: mForm = new PopoverPrimitive(); mForm->setupUi(); break; case Enumeration: mForm = new PopoverEnumeration(); mForm->setupUi(); break; case Comment: mForm = new PopoverComment(); mForm->setupUi(); break; case Attribute: mForm = new PopoverAttribute(); mForm->setupUi(); break; case Literal: mForm = new PopoverLiteral(); mForm->setupUi(); break; case Operation: mForm = new PopoverOperation(); mForm->setupUi(); break; } if(mForm) { mLayout->addWidget(dynamic_cast<QWidget*>(mForm)); auto location = findWindowLocation(mPos, dynamic_cast<QWidget*>(mForm)->width() + 20, dynamic_cast<QWidget*>(mForm)->height() + 20, mOrientation, QApplication::desktop()->availableGeometry(mMouse)); setGeometry(location.first.x(), location.first.y(), 0, 0); setFixedSize(dynamic_cast<QWidget*>(mForm)->width() + 20, dynamic_cast<QWidget*>(mForm)->height() + 20); setLayout(mLayout); mLayout->setAlignment(Qt::AlignTop); int offset; if(mOrientation == Qt::Horizontal) { offset = mMouse.y() - location.first.y(); } else { offset = mMouse.x() - location.first.x(); } generateMask(location.second, offset); } }
unsigned int BitOperations::invertBitsUsingMask(const unsigned int num) { // TODO invertBitsUsingMask return num ^ generateMask(); }
void SubPixelCorner::RefineCorner(cv::Mat image, std::vector< cv::Point2f > &corners) { if (enable == false) return; checkTerm(); generateMask(); // loop over all the corner points for (int k = 0; k < corners.size(); k++) { cv::Point2f curr_corner; // initial estimate cv::Point2f estimate_corner = corners[k]; // cerr << 'SSS" << corners[k].x <<":" << corners[k].y << endl; if (estimate_corner.x < 0 || estimate_corner.y < 0 || estimate_corner.y > image.rows || estimate_corner.y > image.cols) continue; int iter = 0; double dist = TermCriteria::EPS; // loop till termination criteria is met do { iter = iter + 1; curr_corner = estimate_corner; /* Point cx; cx.x=floor(curr_corner.x); cx.y=floor(curr_corner.y); double dx=curr_corner.x-cx.x; double dy=curr_corner.y-cx.y; float vIx[2]; float vIy[2]; vIx[0] = dx; vIx[1] = 1 - dx; vIy[0] = dy; vIy[1] = 1 - dy; int x1=std::max((int)(cx.x-_winSize-_apertureSize/2),0); int y1=std::max((int)(cx.y-_winSize-_apertureSize/2),0); xmin = x1<0?0:x1; xmax = x1+_winSize<image.cols?x1+_winSize:image.cols-1; ymin = y1<0?0:y1; ymax = y1+_winSize<image.rows?y1+_winSize:image.rows-1; Rect roi=Rect(xmin,ymin,xmax-xmin,ymax-ymin); */ Mat local; cv::getRectSubPix(image, Size(_winSize + 2 * (_apertureSize / 2), _winSize + 2 * (_apertureSize / 2)), curr_corner, local); cv::Mat Dx, Dy; // extracing image ROI about the corner point // Mat local=image(roi); // computing the gradients over the neighborhood about corner point cv::Sobel(local, Dx, CV_32FC(1), 1, 0, _apertureSize, 1, 0); cv::Sobel(local, Dy, CV_32FC(1), 0, 1, _apertureSize, 1, 0); // parameters requried for estimations double A = 0, B = 0, C = 0, D = 0, E = 0, F = 0; int lx = 0, ly = 0; for (int i = _apertureSize / 2; i <= _winSize; i++) { float *dx_ptr = Dx.ptr< float >(i); float *dy_ptr = Dy.ptr< float >(i); ly = i - _winSize / 2 - _apertureSize / 2; float *mask_ptr = mask.ptr< float >(ly + _winSize / 2); for (int j = _apertureSize / 2; j <= _winSize; j++) { lx = j - _winSize / 2 - _apertureSize / 2; // cerr << lx+_winSize/2 << ":" ; double val = mask_ptr[lx + _winSize / 2]; double dxx = dx_ptr[j] * dx_ptr[j] * val; double dyy = dy_ptr[j] * dy_ptr[j] * val; double dxy = dx_ptr[j] * dy_ptr[j] * val; A = A + dxx; B = B + dxy; E = E + dyy; C = C + dxx * lx + dxy * ly; F = F + dxy * lx + dyy * ly; } } // computing denominator double det = (A * E - B * B); if (fabs(det) > DBL_EPSILON * DBL_EPSILON) { det = 1.0 / det; // translating back to original corner and adding new estimates estimate_corner.x = curr_corner.x + ((C * E) - (B * F)) * det; estimate_corner.y = curr_corner.y + ((A * F) - (C * D)) * det; } else { estimate_corner.x = curr_corner.x; estimate_corner.y = curr_corner.y; } dist = pointDist(estimate_corner, curr_corner); } while (iter < _max_iters && dist > eps); // double dist=pointDist(corners[k],estimate_corner); if (fabs(corners[k].x - estimate_corner.x) > _winSize || fabs(corners[k].y - estimate_corner.y) > _winSize) { estimate_corner.x = corners[k].x; estimate_corner.y = corners[k].y; } corners[k].x = estimate_corner.x; corners[k].y = estimate_corner.y; // cerr << "EEE" << corners[k].x <<":" << corners[k].y << endl; } }