HRESULT cDxCapture::WriteBitmapFromBuffer(const char* fileName, const BYTE *buffer, const long bufferSize)
{
if (!m_mt.pbFormat)
m_pGrabber->GetConnectedMediaType(&m_mt);
VIDEOINFOHEADER *pVih = (VIDEOINFOHEADER*)m_mt.pbFormat;
HRESULT hr = WriteBitmap(fileName, &pVih->bmiHeader,
m_mt.cbFormat - SIZE_PREHEADER, buffer, bufferSize);
return hr;
}
void framecapture_writebmpframes(int frames) {
int frame;
for (frame = 0; frames < frames; frames++) {
printf("writebmp[%d]\n", frame);
char fname[64];
sprintf(fname, "%d.bmp", frame);
WriteBitmap(fname,
(unsigned char *)(framesbuffer + (frame * FRAMESIZE)), 1280,
720, 4);
}
}
void StencilComp::Write (ostream& out) {
GraphicComp::Write(out);
UStencil* stencil = GetStencil();
Bitmap* image, *mask;
stencil->GetOriginal(image, mask);
WriteBitmap(image, out);
Mark(out);
if (mask == nil) {
out << no_mask;
} else if (mask == image) {
out << mask_equals_image;
} else {
out << valid_mask;
WriteBitmap(mask, out);
}
WriteBgFilled(stencil->BgFilled(), out);
WriteColor(stencil->GetFgColor(), out);
WriteColor(stencil->GetBgColor(), out);
WriteTransformer(stencil->GetTransformer(), out);
WriteString(_filename, out);
}
int main(int argc, char* argv[])
{
FILE *fpout;
BITMAP immagine;
int n = atoi(argv[2]);
int j,i;
/* utilizzo: copia_immagine file_originale.bmp file_copia.bmp */
if (argc != 3 )
{
printf ("servono due argomenti!\n");
exit (EXIT_FAILURE);
}
if ((fpout = fopen (argv[1], "wb")) == NULL)
{
printf ("errore di apertura del file copia\n");
exit (EXIT_FAILURE);
}
immagine = CreateEmptyBitmap( n, n);
for(i = 0; i < n; i++)
{
for(j = 0; j < n; j++)
{
if( (pow((n/2 - 10), 2) <= (pow(i-n/2,2)+pow(j-n/2, 2))) &&
(pow(n/2, 2) >= (pow(i-n/2,2) + pow(j-n/2, 2))))
PIXEL (immagine, i, j).red = 255;
else
PIXEL (immagine, i, j).blue = 255;
}
}
WriteBitmap (immagine, fpout);
ReleaseBitmapData (&immagine);
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
FILE *fpin, *fpout, *fptxt;
BITMAP img;
if (argc != 4)
{
printf ("ARGOMENTI: <file in> <file out> <textfile>\n");
exit (EXIT_FAILURE);
}
if ((fpin = fopen (argv[1], "rb")) == NULL)
{
printf ("Error opening input file\n");
exit (EXIT_FAILURE);
}
if ((fpout = fopen (argv[2], "wb")) == NULL)
{
printf ("Error opening output file\n");
exit (EXIT_FAILURE);
}
if ((fptxt = fopen (argv[3], "r")) == NULL)
{
printf ("Error opening text file\n");
exit (EXIT_FAILURE);
}
img = ReadBitmap (fpin);
fclose (fpin);
encode (img, fptxt);
fclose (fptxt);
WriteBitmap (img, fpout);
fclose (fpout);
ReleaseBitmapData (&img);
return EXIT_SUCCESS;
}
int _tmain(int argc, _TCHAR* argv[])
{
if( argc < 2 )
{
_tprintf(_T("converts a picture to a tank skin\n"));
_tprintf(_T("only 24-bit windows bitmaps supports\n"));
_tprintf(_T("using: mkskin input_file.bmp [output_file.bmp]\n"));
return 0;
}
_tprintf(_T("input file: \n %s\n"), argv[1]);
BITMAPFILEHEADER bmfh = {0};
BITMAPINFOHEADER bmih = {0};
RGBTRIPLE *pInputBits = NULL;
if( !ReadBitmap(argv[1], &bmfh, &bmih, &pInputBits) )
return -1;
RGBTRIPLE *pOutputBits = new RGBTRIPLE[FRAME_WIDTH * FRAME_HEIGHT * FRAME_COUNT];
MakeSkin(pOutputBits, pInputBits, &bmih);
bmih.biSizeImage = FRAME_WIDTH * FRAME_HEIGHT * FRAME_COUNT * sizeof(RGBTRIPLE);
bmfh.bfSize = bmih.biSizeImage + bmfh.bfOffBits;
bmih.biWidth = FRAME_WIDTH * X_FRAMES;
bmih.biHeight = FRAME_HEIGHT * Y_FRAMES;
_TCHAR outfn[MAX_PATH];
if( argc > 2 ) _tcscpy(outfn, argv[2]);
else _stprintf(outfn, _T("%s-skin.bmp"), argv[1]);
_tprintf(_T("output file: \n %s\n"), outfn);
if( WriteBitmap(outfn, &bmfh, &bmih, pOutputBits) )
_tprintf(_T("OK.\n"));
else
Sleep(1000);
delete[] pOutputBits;
delete[] pInputBits;
return 0;
}
int main()
{
#if defined(WRITE_BMP)
BGR buf[OUTW*OUTH];
#else
BGR buf[TILEW];
#endif
memset(buf, 0, sizeof(buf));
PixelWriter pix;
pix.buffer = &buf[0];
#if defined(WRITE_BMP)
Buffer<0,0,OUTW,OUTH,SceneTracer<TestScene,TestLights,OUTW,OUTH>::Tracer,
TILEW,1>::Visit(pix);
WriteBitmap("output.bmp", OUTW, OUTH, &buf[0]);
#else
Tile<UX,UY,TILEW,1,SceneTracer<TestScene,TestLights,OUTW,OUTH>::Tracer>::Visit(pix);
fwrite(&buf[0], 1, sizeof(buf), stdout);
#endif
return 0;
}
void ImageWriter::WriteImage(Image* img, ProgressCallback* callback)
{
Managed<Bitmap> bmp = img->ToBitmap();
WriteBitmap(bmp, callback);
}
/*
* WriteBGFFile: Write Bitmaps and Options structures out to given filename.
* Return FALSE on error.
*/
BOOL WriteBGFFile(Bitmaps *b, Options *opts, char *filename)
{
int i, j, temp, max_indices, len;
Group *g;
file_node f;
len = EstimateBGFFileSize(b);
if (!MappedFileOpenWrite(filename, &f, len))
return FALSE;
// Write magic number
for (i=0; i < 4; i++)
if (MappedFileWrite(&f, &magic[i], 1) < 0) return FALSE;
// Write version
temp = VERSION;
if (MappedFileWrite(&f, &temp, 4) < 0) return FALSE;
// Write bitmap name
if (MappedFileWrite(&f, &b->name, MAX_BITMAPNAME) < 0) return FALSE;
// Write # of bitmaps
if (MappedFileWrite(&f, &b->num_bitmaps, 4) < 0) return FALSE;
// Write # of index groups
if (MappedFileWrite(&f, &b->num_groups, 4) < 0) return FALSE;
// Find most indices in a group
max_indices = 0;
for (i=0; i < b->num_groups; i++)
if (b->groups[i].num_indices > max_indices)
max_indices = b->groups[i].num_indices;
if (MappedFileWrite(&f, &max_indices, 4) < 0) return FALSE;
// Write shrink factor
if (MappedFileWrite(&f, &opts->shrink, 4) < 0) return FALSE;
// Write out bitmaps
for (i=0; i < b->num_bitmaps; i++)
{
PDIB pdib = b->bitmaps[i];
// Write out bitmap size (swap width and height if rotated)
if (opts->rotate)
{
temp = DibHeight(pdib);
if (MappedFileWrite(&f, &temp, 4) < 0) return FALSE;
temp = DibWidth(pdib);
if (MappedFileWrite(&f, &temp, 4) < 0) return FALSE;
}
else
{
temp = DibWidth(pdib);
if (MappedFileWrite(&f, &temp, 4) < 0) return FALSE;
temp = DibHeight(pdib);
if (MappedFileWrite(&f, &temp, 4) < 0) return FALSE;
}
// Write out x and y offsets
temp = b->offsets[i].x;
if (MappedFileWrite(&f, &temp, 4) < 0) return FALSE;
temp = b->offsets[i].y;
if (MappedFileWrite(&f, &temp, 4) < 0) return FALSE;
// Write out hotspots
if (MappedFileWrite(&f, &b->hotspots[i].num_hotspots, 1) < 0) return FALSE;
for (j=0; j < b->hotspots[i].num_hotspots; j++)
{
if (MappedFileWrite(&f, &b->hotspots[i].numbers[j], 1) < 0) return FALSE;
if (MappedFileWrite(&f, &b->hotspots[i].positions[j].x, 4) < 0) return FALSE;
if (MappedFileWrite(&f, &b->hotspots[i].positions[j].y, 4) < 0) return FALSE;
}
// Write out the bytes of the bitmap
if (!WriteBitmap(&f, pdib, opts)) return FALSE;
}
// Write out indices
for (i=0; i < b->num_groups; i++)
{
g = &b->groups[i];
if (MappedFileWrite(&f, &g->num_indices, 4) < 0) return FALSE;
for (j=0; j < g->num_indices; j++)
if (MappedFileWrite(&f, &g->indices[j], 4) < 0) return FALSE;
}
UnmapViewOfFile(f.mem);
CloseHandle(f.mapfh);
SetFilePointer(f.fh, (f.ptr - f.mem), NULL, FILE_BEGIN);
SetEndOfFile(f.fh);
CloseHandle(f.fh);
return TRUE;
}
int DetectFP(BYTE *ImgBuf,int Width,int Height, int HasFingerThreshold,int NoFingerThreshold,int Reverse,int DetectCount,int IsSingle)
{
int v,avg_cur,avg_cur_div,avg_diff,m1,m2,size,pixel_diff,whiteSum=0,iTemp=0;
int avgPixel=0;
/* int ImgSize= Width*Height;
BYTE *prev_fp = ImgBuf + (ImgSize),
*diff_fp = ImgBuf + (ImgSize) + DETECT_IMG_SIZE,
*cur_fp = ImgBuf + (ImgSize) + (DETECT_IMG_SIZE <<1); */
// printf(" ********** DetectFP ImgBuf=%p,prev_fp=%p,diff_fp=%p,cur_fp=%p \n",ImgBuf,prev_fp,diff_fp,cur_fp);
static int LeaveFinger=0,
validCount=0,
pre_avg_cur_div=0;
if(!CutDetectArea(ImgBuf,cur_fp,(Width>>1)-64 ,(Height>>1),Width,Height,DETECT_WIDTH,DETECT_HEIGHT))
{
return 0;
}
if(Reverse)
{
ReverseImage(cur_fp,DETECT_WIDTH,DETECT_HEIGHT);
}
#ifdef DEBUGME
WriteBitmap(cur_fp,DETECT_WIDTH,DETECT_HEIGHT,"fp_cut.bmp");
WriteBitmap(ImgBuf,Width,Height,"fp_cut_src.bmp");
#endif
CalcVar(cur_fp,DETECT_WIDTH,DETECT_HEIGHT,&avg_cur,&m1,&whiteSum,0);
RegionDivideAdaptive((BYTE*)cur_fp,DETECT_WIDTH,DETECT_HEIGHT,-12,&avgPixel);
size = DETECT_IMG_SIZE;
for(v=0;v<size;v++)
{
if(cur_fp[v]==prev_fp[v])
pixel_diff=255;
else
pixel_diff=0;
diff_fp[v]=(BYTE)pixel_diff;
}
CalcVar(cur_fp,DETECT_WIDTH,DETECT_HEIGHT,&avg_cur_div,&m1,&iTemp,0);
CalcVar(diff_fp,DETECT_WIDTH, DETECT_HEIGHT,&avg_diff,&m2,&iTemp,0);
#ifdef DEBUGME
WriteBitmap(cur_fp, DETECT_WIDTH, DETECT_HEIGHT,"cur.bmp");
WriteBitmap( prev_fp, DETECT_WIDTH, DETECT_HEIGHT,"prev.bmp");
WriteBitmap( diff_fp,DETECT_WIDTH, DETECT_HEIGHT,"diff.bmp");
#endif
if(!IsSingle && !LeaveFinger && (avg_cur_div<NoFingerThreshold || avg_diff>NoFingerThreshold))
{
LeaveFinger=TRUE;
memcpy(prev_fp,cur_fp,DETECT_WIDTH*DETECT_HEIGHT);
validCount=0;
pre_avg_cur_div=0;
// printf("No finger\n");
return 0;
}else if (IsSingle && ((avg_cur_div>HasFingerThreshold ) || //正常探测
(avgPixel>180 && avg_cur_div>HasFingerThreshold-1200 ) || //适当考虑过湿指纹
(avgPixel<80 && avg_cur_div>HasFingerThreshold+800 )))
{
return TRUE;
}else if(LeaveFinger && ((avg_cur_div>HasFingerThreshold && avg_diff>NoFingerThreshold) || //正常探测
(avgPixel>180 && avg_cur_div>HasFingerThreshold-1200 && avg_diff>NoFingerThreshold-1200) || //适当考虑过湿指纹
(avgPixel<80 && avg_cur_div>HasFingerThreshold+800 && avg_diff>NoFingerThreshold+800))) //适当过滤残留指纹
{
// printf("debug me avg_cur_div=%d,count=%d,avgPixel=%d\n",avg_cur_div,validCount,avgPixel);
validCount++;
if(validCount==DetectCount)
{
//filter black background
if(avgPixel>216 || (avg_cur<696 && avgPixel>136 && whiteSum<104) || (avg_cur<480 && avgPixel>120))
{
validCount=0;
DBPRINTF("a fake finger\n");
//write_bitmap("/mnt/ramdisk/finger_fake.bmp",ImgBuf,Width,Height);
return FALSE;
}
//write_bitmap("/mnt/ramdisk/finger.bmp",ImgBuf,Width,Height);
LeaveFinger=FALSE;
memcpy(prev_fp,cur_fp,DETECT_IMG_SIZE);
#ifdef DEBUGME //get a best finger image
if(validCount>1 && pre_avg_cur_div> avg_cur_div)
memcpy(ImgBuf,ImgBuf+ImgSize,ImgSize);
#endif
pre_avg_cur_div = 0;
validCount=0;
return TRUE;
}else
{
pre_avg_cur_div = avg_cur_div;
#ifdef DEBUGME
memcpy(ImgBuf+ImgSize,ImgBuf,ImgSize);
#endif
return 0;
}
}else
{
//_RPT3(0,"else debug me avg_cur_div=%d,avg_diff=%d,avgPixel=%d\n",avg_cur_div,avg_diff,avgPixel);
// printf("else debug me avg_cur_div=%d,avg_diff=%d,avgPixel=%d\n",avg_cur_div,avg_diff,avgPixel);
validCount=0;
pre_avg_cur_div=0;
if(LeaveFinger && avgPixel>180)
return FALSE;// -1;
else
return FALSE;
}
}
NS_IMETHODIMP
nsWindowsHooks::SetImageAsWallpaper(nsIDOMElement* aElement, PRBool aUseBackground)
{
nsresult rv;
nsCOMPtr<gfxIImageFrame> gfxFrame;
if (aUseBackground) {
// XXX write background loading stuff!
} else {
nsCOMPtr<nsIImageLoadingContent> imageContent = do_QueryInterface(aElement, &rv);
if (!imageContent) return rv;
// get the image container
nsCOMPtr<imgIRequest> request;
rv = imageContent->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
getter_AddRefs(request));
if (!request) return rv;
nsCOMPtr<imgIContainer> container;
rv = request->GetImage(getter_AddRefs(container));
if (!container)
return NS_ERROR_FAILURE;
// get the current frame, which holds the image data
container->GetCurrentFrame(getter_AddRefs(gfxFrame));
}
if (!gfxFrame)
return NS_ERROR_FAILURE;
// get the profile root directory
nsCOMPtr<nsIFile> file;
rv = NS_GetSpecialDirectory(NS_APP_APPLICATION_REGISTRY_DIR,
getter_AddRefs(file));
NS_ENSURE_SUCCESS(rv, rv);
// get the product brand name from localized strings
nsXPIDLString brandName, fileLeafName;
nsCOMPtr<nsIStringBundleService> bundleService =
do_GetService(NS_STRINGBUNDLE_CONTRACTID, &rv);
NS_ENSURE_TRUE(bundleService, rv);
// get the product brand name from localized strings
nsCOMPtr<nsIStringBundle> bundle;
rv = bundleService->CreateBundle("chrome://branding/locale/brand.properties",
getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
rv = bundle->GetStringFromName(NS_LITERAL_STRING("brandShortName").get(),
getter_Copies(brandName));
NS_ENSURE_SUCCESS(rv, rv);
// get the file leaf name from localized strings (e.g. "%S Wallpaper.bmp")
rv = bundleService->CreateBundle("chrome://global-platform/locale/nsWindowsHooks.properties",
getter_AddRefs(bundle));
NS_ENSURE_SUCCESS(rv, rv);
const PRUnichar* stringArray[] = { brandName.get() };
rv = bundle->FormatStringFromName(NS_LITERAL_STRING("wallpaperFile").get(),
stringArray, NS_ARRAY_LENGTH(stringArray),
getter_Copies(fileLeafName));
NS_ENSURE_SUCCESS(rv, rv);
// eventually, the path is %APPDATA%\Mozilla\Mozilla Wallpaper.bmp
fileLeafName.AppendLiteral(".bmp");
rv = file->Append(fileLeafName);
NS_ENSURE_SUCCESS(rv, rv);
// write the bitmap to the target file
rv = WriteBitmap(file, gfxFrame);
NS_ENSURE_SUCCESS(rv, rv);
// set it as the system wallpaper
nsCAutoString nativePath;
rv = file->GetNativePath(nativePath);
NS_ENSURE_SUCCESS(rv, rv);
::SystemParametersInfo(SPI_SETDESKWALLPAPER, 0, (PVOID) nativePath.get(),
SPIF_UPDATEINIFILE | SPIF_SENDWININICHANGE);
return rv;
}
bool AreaWayIndexGenerator::Import(const ImportParameter& parameter,
Progress& progress,
const TypeConfig& typeConfig)
{
FileScanner wayScanner;
FileWriter writer;
std::set<TypeId> remainingWayTypes;
std::vector<TypeData> wayTypeData;
size_t level;
size_t maxLevel=0;
wayTypeData.resize(typeConfig.GetTypes().size());
if (!wayScanner.Open(AppendFileToDir(parameter.GetDestinationDirectory(),
"ways.dat"),
FileScanner::Sequential,
parameter.GetWayDataMemoryMaped())) {
progress.Error("Cannot open 'ways.dat'");
return false;
}
//
// Scanning distribution
//
progress.SetAction("Scanning level distribution of way types");
for (size_t i=0; i<typeConfig.GetTypes().size(); i++) {
if (typeConfig.GetTypeInfo(i).CanBeWay() &&
!typeConfig.GetTypeInfo(i).GetIgnore()) {
remainingWayTypes.insert(i);
}
}
level=parameter.GetAreaWayMinMag();
while (!remainingWayTypes.empty()) {
uint32_t wayCount=0;
std::set<TypeId> currentWayTypes(remainingWayTypes);
double cellWidth=360.0/pow(2.0,(int)level);
double cellHeight=180.0/pow(2.0,(int)level);
std::vector<CoordCountMap> cellFillCount(typeConfig.GetTypes().size());
progress.Info("Scanning Level "+NumberToString(level)+" ("+NumberToString(remainingWayTypes.size())+" types remaining)");
wayScanner.GotoBegin();
if (!wayScanner.Read(wayCount)) {
progress.Error("Error while reading number of data entries in file");
return false;
}
Way way;
for (uint32_t w=1; w<=wayCount; w++) {
progress.SetProgress(w,wayCount);
if (!way.Read(wayScanner)) {
progress.Error(std::string("Error while reading data entry ")+
NumberToString(w)+" of "+
NumberToString(wayCount)+
" in file '"+
wayScanner.GetFilename()+"'");
return false;
}
// Count number of entries per current type and coordinate
if (currentWayTypes.find(way.GetType())==currentWayTypes.end()) {
continue;
}
double minLon;
double maxLon;
double minLat;
double maxLat;
way.GetBoundingBox(minLon,maxLon,minLat,maxLat);
//
// Calculate minimum and maximum tile ids that are covered
// by the way
// Renormated coordinate space (everything is >=0)
//
uint32_t minxc=(uint32_t)floor((minLon+180.0)/cellWidth);
uint32_t maxxc=(uint32_t)floor((maxLon+180.0)/cellWidth);
uint32_t minyc=(uint32_t)floor((minLat+90.0)/cellHeight);
uint32_t maxyc=(uint32_t)floor((maxLat+90.0)/cellHeight);
for (uint32_t y=minyc; y<=maxyc; y++) {
for (uint32_t x=minxc; x<=maxxc; x++) {
cellFillCount[way.GetType()][Pixel(x,y)]++;
}
}
}
// Check if cell fill for current type is in defined limits
for (size_t i=0; i<typeConfig.GetTypes().size(); i++) {
if (currentWayTypes.find(i)!=currentWayTypes.end()) {
CalculateStatistics(level,wayTypeData[i],cellFillCount[i]);
if (!FitsIndexCriteria(parameter,
progress,
typeConfig.GetTypeInfo(i),
wayTypeData[i],
cellFillCount[i])) {
currentWayTypes.erase(i);
}
}
}
for (std::set<TypeId>::const_iterator cwt=currentWayTypes.begin();
cwt!=currentWayTypes.end();
cwt++) {
maxLevel=std::max(maxLevel,level);
progress.Info("Type "+typeConfig.GetTypeInfo(*cwt).GetName()+"(" + NumberToString(*cwt)+"), "+NumberToString(wayTypeData[*cwt].indexCells)+" cells, "+NumberToString(wayTypeData[*cwt].indexEntries)+" objects");
remainingWayTypes.erase(*cwt);
}
level++;
}
//
// Writing index file
//
progress.SetAction("Generating 'areaway.idx'");
if (!writer.Open(AppendFileToDir(parameter.GetDestinationDirectory(),
"areaway.idx"))) {
progress.Error("Cannot create 'areaway.idx'");
return false;
}
uint32_t indexEntries=0;
for (size_t i=0; i<typeConfig.GetTypes().size(); i++)
{
if (typeConfig.GetTypeInfo(i).CanBeWay() &&
wayTypeData[i].HasEntries()) {
indexEntries++;
}
}
writer.Write(indexEntries);
for (size_t i=0; i<typeConfig.GetTypes().size(); i++)
{
if (typeConfig.GetTypeInfo(i).CanBeWay() &&
wayTypeData[i].HasEntries()) {
uint8_t dataOffsetBytes=0;
FileOffset bitmapOffset=0;
writer.WriteNumber(typeConfig.GetTypeInfo(i).GetId());
writer.GetPos(wayTypeData[i].indexOffset);
writer.WriteFileOffset(bitmapOffset);
if (wayTypeData[i].HasEntries()) {
writer.Write(dataOffsetBytes);
writer.WriteNumber(wayTypeData[i].indexLevel);
writer.WriteNumber(wayTypeData[i].cellXStart);
writer.WriteNumber(wayTypeData[i].cellXEnd);
writer.WriteNumber(wayTypeData[i].cellYStart);
writer.WriteNumber(wayTypeData[i].cellYEnd);
}
}
}
for (size_t l=parameter.GetAreaWayMinMag(); l<=maxLevel; l++) {
std::set<TypeId> indexTypes;
uint32_t wayCount;
double cellWidth=360.0/pow(2.0,(int)l);
double cellHeight=180.0/pow(2.0,(int)l);
for (size_t i=0; i<typeConfig.GetTypes().size(); i++) {
if (typeConfig.GetTypeInfo(i).CanBeWay() &&
wayTypeData[i].HasEntries() &&
wayTypeData[i].indexLevel==l) {
indexTypes.insert(i);
}
}
if (indexTypes.empty()) {
continue;
}
progress.Info("Scanning ways for index level "+NumberToString(l));
std::vector<CoordOffsetsMap> typeCellOffsets(typeConfig.GetTypes().size());
wayScanner.GotoBegin();
if (!wayScanner.Read(wayCount)) {
progress.Error("Error while reading number of data entries in file");
return false;
}
Way way;
for (uint32_t w=1; w<=wayCount; w++) {
progress.SetProgress(w,wayCount);
FileOffset offset;
wayScanner.GetPos(offset);
if (!way.Read(wayScanner)) {
progress.Error(std::string("Error while reading data entry ")+
NumberToString(w)+" of "+
NumberToString(wayCount)+
" in file '"+
wayScanner.GetFilename()+"'");
return false;
}
if (indexTypes.find(way.GetType())==indexTypes.end()) {
continue;
}
double minLon;
double maxLon;
double minLat;
double maxLat;
way.GetBoundingBox(minLon,maxLon,minLat,maxLat);
//
// Calculate minimum and maximum tile ids that are covered
// by the way
// Renormated coordinate space (everything is >=0)
//
uint32_t minxc=(uint32_t)floor((minLon+180.0)/cellWidth);
uint32_t maxxc=(uint32_t)floor((maxLon+180.0)/cellWidth);
uint32_t minyc=(uint32_t)floor((minLat+90.0)/cellHeight);
uint32_t maxyc=(uint32_t)floor((maxLat+90.0)/cellHeight);
for (uint32_t y=minyc; y<=maxyc; y++) {
for (uint32_t x=minxc; x<=maxxc; x++) {
typeCellOffsets[way.GetType()][Pixel(x,y)].push_back(offset);
}
}
}
for (std::set<TypeId>::const_iterator type=indexTypes.begin();
type!=indexTypes.end();
++type) {
if (!WriteBitmap(progress,
writer,
typeConfig.GetTypeInfo(*type),
wayTypeData[*type],
typeCellOffsets[*type])) {
return false;
}
}
}
return !writer.HasError() && writer.Close();
}
bool AreaWayIndexGenerator::Import(const TypeConfigRef& typeConfig,
const ImportParameter& parameter,
Progress& progress)
{
FileScanner wayScanner;
FileWriter writer;
std::vector<TypeData> wayTypeData;
size_t maxLevel;
progress.Info("Minimum magnification: "+NumberToString(parameter.GetAreaWayMinMag()));
//
// Scanning distribution
//
progress.SetAction("Scanning level distribution of way types");
if (!CalculateDistribution(typeConfig,
parameter,
progress,
wayTypeData,
maxLevel)) {
return false;
}
// Calculate number of types which have data
uint32_t indexEntries=0;
for (const auto& type : typeConfig->GetWayTypes())
{
if (wayTypeData[type->GetIndex()].HasEntries()) {
indexEntries++;
}
}
//
// Writing index file
//
progress.SetAction("Generating 'areaway.idx'");
if (!writer.Open(AppendFileToDir(parameter.GetDestinationDirectory(),
"areaway.idx"))) {
progress.Error("Cannot create 'areaway.idx'");
return false;
}
writer.Write(indexEntries);
for (const auto &type : typeConfig->GetWayTypes()) {
size_t i=type->GetIndex();
if (wayTypeData[i].HasEntries()) {
uint8_t dataOffsetBytes=0;
FileOffset bitmapOffset=0;
writer.WriteTypeId(type->GetWayId(),
typeConfig->GetWayTypeIdBytes());
writer.GetPos(wayTypeData[i].indexOffset);
writer.WriteFileOffset(bitmapOffset);
writer.Write(dataOffsetBytes);
writer.WriteNumber(wayTypeData[i].indexLevel);
writer.WriteNumber(wayTypeData[i].cellXStart);
writer.WriteNumber(wayTypeData[i].cellXEnd);
writer.WriteNumber(wayTypeData[i].cellYStart);
writer.WriteNumber(wayTypeData[i].cellYEnd);
}
}
if (!wayScanner.Open(AppendFileToDir(parameter.GetDestinationDirectory(),
"ways.dat"),
FileScanner::Sequential,
parameter.GetWayDataMemoryMaped())) {
progress.Error("Cannot open 'ways.dat'");
return false;
}
for (size_t l=parameter.GetAreaWayMinMag(); l<=maxLevel; l++) {
TypeInfoSet indexTypes(*typeConfig);
uint32_t wayCount;
double cellWidth=360.0/pow(2.0,(int)l);
double cellHeight=180.0/pow(2.0,(int)l);
wayScanner.GotoBegin();
for (const auto &type : typeConfig->GetWayTypes()) {
if (wayTypeData[type->GetIndex()].HasEntries() &&
wayTypeData[type->GetIndex()].indexLevel==l) {
indexTypes.Set(type);
}
}
if (indexTypes.Empty()) {
continue;
}
progress.Info("Scanning ways for index level "+NumberToString(l));
std::vector<CoordOffsetsMap> typeCellOffsets(typeConfig->GetTypeCount());
if (!wayScanner.Read(wayCount)) {
progress.Error("Error while reading number of data entries in file");
return false;
}
Way way;
for (uint32_t w=1; w<=wayCount; w++) {
progress.SetProgress(w,wayCount);
FileOffset offset;
wayScanner.GetPos(offset);
if (!way.Read(*typeConfig,
wayScanner)) {
progress.Error(std::string("Error while reading data entry ")+
NumberToString(w)+" of "+
NumberToString(wayCount)+
" in file '"+
wayScanner.GetFilename()+"'");
return false;
}
if (!indexTypes.IsSet(way.GetType())) {
continue;
}
GeoBox boundingBox;
way.GetBoundingBox(boundingBox);
//
// Calculate minimum and maximum tile ids that are covered
// by the way
// Renormalized coordinate space (everything is >=0)
//
uint32_t minxc=(uint32_t)floor((boundingBox.GetMinLon()+180.0)/cellWidth);
uint32_t maxxc=(uint32_t)floor((boundingBox.GetMaxLon()+180.0)/cellWidth);
uint32_t minyc=(uint32_t)floor((boundingBox.GetMinLat()+90.0)/cellHeight);
uint32_t maxyc=(uint32_t)floor((boundingBox.GetMaxLat()+90.0)/cellHeight);
for (uint32_t y=minyc; y<=maxyc; y++) {
for (uint32_t x=minxc; x<=maxxc; x++) {
typeCellOffsets[way.GetType()->GetIndex()][Pixel(x,y)].push_back(offset);
}
}
}
for (const auto &type : indexTypes) {
size_t index=type->GetIndex();
if (!WriteBitmap(progress,
writer,
*typeConfig->GetTypeInfo(index),
wayTypeData[index],
typeCellOffsets[index])) {
return false;
}
}
}
return !writer.HasError() && writer.Close();
}
