void vtFence3d::LoadProfile() { vtString path = FindFileOnPaths(vtGetDataPath(), "BuildingData/" + m_Params.m_ConnectProfile); if (path != "") LoadFLine2FromSHP(path, m_Profile); else m_Profile.Clear(); }
void InstanceDlg::OnBrowseModelFile( wxCommandEvent &event ) { wxString filter = _("3D Model files"); filter += _T("|"); AddType(filter, FSTRING_3DS); AddType(filter, FSTRING_DAE); AddType(filter, FSTRING_OBJ); AddType(filter, FSTRING_LWO); AddType(filter, FSTRING_FLT); AddType(filter, FSTRING_OSG); AddType(filter, FSTRING_IVE); filter += _T("|"); filter += FSTRING_ALL; wxFileDialog SelectFile(this, _("Choose model file"), _T(""), _T(""), filter, wxFD_OPEN); if (SelectFile.ShowModal() != wxID_OK) return; // If model file can be found by mimicing the search strategy implemented by // vtStructInstance3d::CreateNode then remove the directory part of the path // so that paths are not stored unnecessarily wxFileName TargetModel(SelectFile.GetPath()); wxString filepart = TargetModel.GetFullName(); vtString FoundModel = FindFileOnPaths(vtGetDataPath(), filepart.mb_str(wxConvUTF8)); if ("" != FoundModel) { GetModelFile()->SetValue(filepart); return; } wxString test = wxT("BuildingModels/") + filepart; FoundModel = FindFileOnPaths(vtGetDataPath(), test.mb_str(wxConvUTF8)); if ("" != FoundModel) { GetModelFile()->SetValue(filepart); return; } // Otherwise, use the full absolute path GetModelFile()->SetValue(SelectFile.GetPath()); }
int vtRoadMap3d::_CreateMaterial(const char *texture_filename, bool bTransparency) { vtString fname = "GeoTypical/"; fname += texture_filename; vtString path = FindFileOnPaths(vtGetDataPath(), fname); if (path == "") return -1; osg::Image *image = LoadOsgImage(path); if (!image) return -1; int material_index = m_pMats->AddTextureMaterial(image, true, true, bTransparency, false, ROAD_AMBIENT, ROAD_DIFFUSE, 1.0f, TERRAIN_EMISSIVE); if (material_index == -1) return -1; // All the road textures repeat, so don't clamp. vtMaterial *pMaterial = m_pMats->at(material_index); pMaterial->SetClamp(false); return material_index; }
void vtElevLayer::RenderBitmap() { if (!m_pGrid) return; // flag as being rendered m_bNeedsDraw = false; // safety check if (m_ImageSize.x == 0 || m_ImageSize.y == 0) return; DetermineMeterSpacing(); clock_t tm1 = clock(); #if 0 // TODO: re-enable this friendly cancel behavior if (UpdateProgressDialog(j*100/m_ImageSize.y)) { wxString msg = _("Turn off displayed elevation for elevation layers?"); if (wxMessageBox(msg, _T(""), wxYES_NO) == wxYES) { m_draw.m_bShowElevation = false; CloseProgressDialog(); return; } else ResumeProgressDialog(); } #endif ColorMap cmap; vtString cmap_fname = m_draw.m_strColorMapFile; vtString cmap_path = FindFileOnPaths(vtGetDataPath(), "GeoTypical/" + cmap_fname); bool bLoaded = false; if (cmap_path != "") { if (cmap.Load(cmap_path)) bLoaded = true; } if (!bLoaded) SetupDefaultColors(cmap); bool has_invalid = m_pGrid->ColorDibFromElevation(m_pBitmap, &cmap, 8000, RGBi(255,0,0), progress_callback_minor); if (m_draw.m_bShadingQuick) m_pGrid->ShadeQuick(m_pBitmap, SHADING_BIAS, true, progress_callback_minor); else if (m_draw.m_bShadingDot) { // Quick and simple sunlight vector FPoint3 light_dir = LightDirection(m_draw.m_iCastAngle, m_draw.m_iCastDirection); if (m_draw.m_bCastShadows) m_pGrid->ShadowCastDib(m_pBitmap, light_dir, 1.0f, m_draw.m_fAmbient, progress_callback_minor); else m_pGrid->ShadeDibFromElevation(m_pBitmap, light_dir, 1.0f, m_draw.m_fAmbient, m_draw.m_fGamma, true, progress_callback_minor); } m_pBitmap->ContentsChanged(); if (has_invalid && m_draw.m_bDoMask) { m_pMask = new wxMask(*m_pBitmap->m_pBitmap, wxColour(255, 0, 0)); m_pBitmap->m_pBitmap->SetMask(m_pMask); m_bHasMask = true; } else m_bHasMask = false; clock_t tm2 = clock(); float time = ((float)tm2 - tm1)/CLOCKS_PER_SEC; VTLOG("RenderBitmap: %.3f seconds.\n", time); m_bBitmapRendered = true; }
bool vtElevLayer::WriteElevationTileset(TilingOptions &opts, BuilderView *pView) { // Avoid trouble with '.' and ',' in Europe ScopedLocale normal_numbers(LC_NUMERIC, "C"); // Check that options are valid CheckCompressionMethod(opts); // grid size int base_tilesize = opts.lod0size; int gridcols, gridrows; m_pGrid->GetDimensions(gridcols, gridrows); DRECT area = m_pGrid->GetEarthExtents(); DPoint2 tile_dim(area.Width()/opts.cols, area.Height()/opts.rows); DPoint2 cell_size = tile_dim / base_tilesize; const vtProjection &proj = m_pGrid->GetProjection(); vtString units = GetLinearUnitName(proj.GetUnits()); units.MakeLower(); int zone = proj.GetUTMZone(); vtString crs; if (proj.IsGeographic()) crs = "LL"; else if (zone != 0) crs = "UTM"; else crs = "Other"; // Try to create directory to hold the tiles vtString dirname = opts.fname; RemoveFileExtensions(dirname); if (!vtCreateDir(dirname)) return false; // We won't know the exact height extents until the tiles have generated, // so gather extents as we produce the tiles and write the INI later. float minheight = 1E9, maxheight = -1E9; ColorMap cmap; vtElevLayer::SetupDefaultColors(cmap); // defaults vtString dirname_image = opts.fname_images; RemoveFileExtensions(dirname_image); if (opts.bCreateDerivedImages) { if (!vtCreateDir(dirname_image)) return false; vtString cmap_fname = opts.draw.m_strColorMapFile; vtString cmap_path = FindFileOnPaths(vtGetDataPath(), "GeoTypical/" + cmap_fname); if (cmap_path == "") DisplayAndLog("Couldn't find color map."); else { if (!cmap.Load(cmap_path)) DisplayAndLog("Couldn't load color map."); } } ImageGLCanvas *pCanvas = NULL; #if USE_OPENGL wxFrame *frame = new wxFrame; if (opts.bCreateDerivedImages && opts.bUseTextureCompression && opts.eCompressionType == TC_OPENGL) { frame->Create(g_bld->m_pParentWindow, -1, _T("Texture Compression OpenGL Context"), wxPoint(100,400), wxSize(280, 300), wxCAPTION | wxCLIP_CHILDREN); pCanvas = new ImageGLCanvas(frame); } #endif // make a note of which lods exist LODMap lod_existence_map(opts.cols, opts.rows); bool bFloat = m_pGrid->IsFloatMode(); bool bJPEG = (opts.bUseTextureCompression && opts.eCompressionType == TC_JPEG); int i, j, lod; int total = opts.rows * opts.cols, done = 0; for (j = 0; j < opts.rows; j++) { for (i = 0; i < opts.cols; i++) { // We might want to skip certain tiles if (opts.iMinRow != -1 && (i < opts.iMinCol || i > opts.iMaxCol || j < opts.iMinRow || j > opts.iMaxRow)) continue; DRECT tile_area; tile_area.left = area.left + tile_dim.x * i; tile_area.right = area.left + tile_dim.x * (i+1); tile_area.bottom = area.bottom + tile_dim.y * j; tile_area.top = area.bottom + tile_dim.y * (j+1); int col = i; int row = opts.rows-1-j; // draw our progress in the main view if (pView) pView->ShowGridMarks(area, opts.cols, opts.rows, col, opts.rows-1-row); // Extract the highest LOD we need vtElevationGrid base_lod(tile_area, IPoint2(base_tilesize+1, base_tilesize+1), bFloat, proj); bool bAllInvalid = true; bool bAllZero = true; int iNumInvalid = 0; DPoint2 p; int x, y; for (y = base_tilesize; y >= 0; y--) { p.y = area.bottom + (j*tile_dim.y) + ((double)y / base_tilesize * tile_dim.y); for (x = 0; x <= base_tilesize; x++) { p.x = area.left + (i*tile_dim.x) + ((double)x / base_tilesize * tile_dim.x); float fvalue = m_pGrid->GetFilteredValue(p); base_lod.SetFValue(x, y, fvalue); if (fvalue == INVALID_ELEVATION) iNumInvalid++; else { bAllInvalid = false; // Gather height extents if (fvalue < minheight) minheight = fvalue; if (fvalue > maxheight) maxheight = fvalue; } if (fvalue != 0) bAllZero = false; } } // Increment whether we omit or not done++; // If there is no real data there, omit this tile if (bAllInvalid) continue; // Omit all-zero tiles (flat sea-level) if desired if (opts.bOmitFlatTiles && bAllZero) continue; // Now we know this tile will be included, so note the LODs present int base_tile_exponent = vt_log2(base_tilesize); lod_existence_map.set(i, j, base_tile_exponent, base_tile_exponent-(opts.numlods-1)); if (iNumInvalid > 0) { UpdateProgressDialog2(done*99/total, 0, _("Filling gaps")); bool bGood; int method = g_Options.GetValueInt(TAG_GAP_FILL_METHOD); if (method == 1) bGood = base_lod.FillGaps(NULL, progress_callback_minor); else if (method == 2) bGood = base_lod.FillGapsSmooth(NULL, progress_callback_minor); else if (method == 3) bGood = (base_lod.FillGapsByRegionGrowing(2, 5, progress_callback_minor) != -1); if (!bGood) return false; opts.iNoDataFilled += iNumInvalid; } // Create a matching derived texture tileset if (opts.bCreateDerivedImages) { // Create a matching derived texture tileset vtDIB dib; base_lod.ComputeHeightExtents(); if (opts.bImageAlpha) { dib.Create(IPoint2(base_tilesize, base_tilesize), 32); base_lod.ColorDibFromElevation(&dib, &cmap, 4000, RGBAi(0,0,0,0)); } else { dib.Create(IPoint2(base_tilesize, base_tilesize), 24); base_lod.ColorDibFromElevation(&dib, &cmap, 4000, RGBi(255,0,0)); } if (opts.draw.m_bShadingQuick) base_lod.ShadeQuick(&dib, SHADING_BIAS, true); else if (opts.draw.m_bShadingDot) { FPoint3 light_dir = LightDirection(opts.draw.m_iCastAngle, opts.draw.m_iCastDirection); // Don't cast shadows for tileset; they won't cast // correctly from one tile to the next. base_lod.ShadeDibFromElevation(&dib, light_dir, 1.0f, opts.draw.m_fAmbient, opts.draw.m_fGamma, true); } for (int k = 0; k < opts.numlods; k++) { vtString fname = MakeFilenameDB(dirname_image, col, row, k); int tilesize = base_tilesize >> k; vtMiniDatabuf output_buf; output_buf.xsize = tilesize; output_buf.ysize = tilesize; output_buf.zsize = 1; output_buf.tsteps = 1; output_buf.SetBounds(proj, tile_area); int depth = dib.GetDepth() / 8; int iUncompressedSize = tilesize * tilesize * depth; uchar *rgb_bytes = (uchar *) malloc(iUncompressedSize); uchar *dst = rgb_bytes; if (opts.bImageAlpha) { RGBAi rgba; for (int ro = 0; ro < base_tilesize; ro += (1<<k)) for (int co = 0; co < base_tilesize; co += (1<<k)) { dib.GetPixel32(co, ro, rgba); *dst++ = rgba.r; *dst++ = rgba.g; *dst++ = rgba.b; *dst++ = rgba.a; } } else { RGBi rgb; for (int ro = 0; ro < base_tilesize; ro += (1<<k)) for (int co = 0; co < base_tilesize; co += (1<<k)) { dib.GetPixel24(co, ro, rgb); *dst++ = rgb.r; *dst++ = rgb.g; *dst++ = rgb.b; } } // Write and optionally compress the image WriteMiniImage(fname, opts, rgb_bytes, output_buf, iUncompressedSize, pCanvas); // Free the uncompressed image free(rgb_bytes); } } for (lod = 0; lod < opts.numlods; lod++) { int tilesize = base_tilesize >> lod; vtString fname = MakeFilenameDB(dirname, col, row, lod); // make a message for the progress dialog wxString msg; msg.Printf(_("Writing tile '%hs', size %dx%d"), (const char *)fname, tilesize, tilesize); UpdateProgressDialog2(done*99/total, 0, msg); vtMiniDatabuf buf; buf.SetBounds(proj, tile_area); buf.alloc(tilesize+1, tilesize+1, 1, 1, bFloat ? 2 : 1); float *fdata = (float *) buf.data; short *sdata = (short *) buf.data; DPoint2 p; for (int y = base_tilesize; y >= 0; y -= (1<<lod)) { p.y = area.bottom + (j*tile_dim.y) + ((double)y / base_tilesize * tile_dim.y); for (int x = 0; x <= base_tilesize; x += (1<<lod)) { p.x = area.left + (i*tile_dim.x) + ((double)x / base_tilesize * tile_dim.x); if (bFloat) { *fdata = base_lod.GetFilteredValue(p); fdata++; } else { *sdata = (short) base_lod.GetFilteredValue(p); sdata++; } } } if (buf.savedata(fname) == 0) { // what should we do if writing a tile fails? } } } }
vtMaterialArray *vtIcoGlobe::CreateMaterialsFromFiles(const vtString &strImagePrefix) { vtMaterialArray *mats = new vtMaterialArray; #if 0 if (m_style == INDEPENDENT_GEODESIC) { int mat = 0; for (int pair = 0; pair < 10; pair++) { for (int j = 0; j < m_freq; j++) for (int i = 0; i < m_freq; i++) { // TEMP for testing: pretty colors float r = (pair+1) * (1.0f / 10); float g = (j+1) * (1.0f / m_freq); float b = (i+1) * (1.0f / m_freq); m_globe_mat[mat++] = mats->AddRGBMaterial1(RGBf(r, g, b), true, true); } } return; } #endif vtString base; vtString fname; vtString fullpath; bool bCulling = true; bool bLighting = false; int pair, index; for (pair = 0; pair < 10; pair++) { if (strImagePrefix == "") { m_globe_mat[pair] = m_white; continue; } int f1 = icosa_face_pairs[pair][0]; int f2 = icosa_face_pairs[pair][1]; base = "WholeEarth/"; base += strImagePrefix; base += "_"; fname.Format("%s%02d%02d.jpg", (const char *)base, f1+1, f2+1); VTLOG("\t texture: %s\n", (const char *)fname); fullpath = FindFileOnPaths(vtGetDataPath(), (const char *)fname); if (fullpath == "") { // try again with png fname.Format("%s%02d%02d.png", (const char *)base, f1+1, f2+1); VTLOG("\t texture: %s\n", (const char *)fname); fullpath = FindFileOnPaths(vtGetDataPath(), (const char *)fname); } if (fullpath == "") { VTLOG("\t\tnot found on data paths.\n"); index = -1; } else { ImagePtr img = osgDB::readImageFile((const char *)fullpath); if (img.valid()) { index = mats->AddTextureMaterial(img, bCulling, bLighting, GetDepth(img) == 32, false, // transp, additive 0.1f, 1.0f, 1.0f, 0.0f, // ambient, diffuse, alpha, emmisive false, true, false); // texgen, clamp, mipmap } else index = -1; } if (index == -1) { VTLOG("\t\ttexture load failed, using red material.\n"); m_globe_mat[pair] = m_red; } else m_globe_mat[pair] = index; } return mats; }