void extenderPattern() { //! [2] // Get all loaded modules std::vector<Module*> modules; ModuleRegistry::GetLoadedModules(modules); // Check if a module defines a "service-component" property // and use its value to retrieve an embedded resource containing // a component description. for(std::size_t i = 0; i < modules.size(); ++i) { Module* const module = modules[i]; std::string componentPath = module->GetProperty("service-component"); if (!componentPath.empty()) { ModuleResource componentResource = module->GetResource(componentPath); if (!componentResource.IsValid() || componentResource.IsDir()) continue; // Create a std::istream compatible object and parse the // component description. ModuleResourceStream resStream(componentResource); parseComponentDefinition(resStream); } } //! [2] }
void ShellService::LoadSchemeResource(const BundleResource& res) { std::cout << "Reading " << res.GetResourcePath(); BundleResourceStream resStream(res); int resBufLen = res.GetSize() + 1; char* resBuf = new char[resBufLen]; resStream.read(resBuf, resBufLen); if (resStream.eof() || resStream.good()) { resBuf[static_cast<std::size_t>(resStream.gcount())] = '\0'; scheme_load_string(d->m_Scheme, resBuf); } else { std::cerr << "Could not read " << res.GetResourcePath() << " file from resource"; } delete[] resBuf; }
mitk::CameraIntrinsics::Pointer mitk::AbstractToFDeviceFactory::GetCameraIntrinsics() { us::ModuleResource resource = GetIntrinsicsResource(); if (! resource.IsValid()) { MITK_WARN << "Could not load resource '" << resource.GetName() << "'. CameraIntrinsics are invalid!"; } // Create ResourceStream from Resource us::ModuleResourceStream resStream(resource); // Parse XML TiXmlDocument xmlDocument; resStream >> xmlDocument; //Retrieve Child Element and convert to CamerIntrinsics TiXmlElement* element = xmlDocument.FirstChildElement(); mitk::CameraIntrinsics::Pointer intrinsics = mitk::CameraIntrinsics::New(); intrinsics->FromXML(element); return intrinsics; }
void GfxCursor32::setView(const GuiResourceId viewId, const int16 loopNo, const int16 celNo) { hide(); _cursorInfo.resourceId = viewId; _cursorInfo.loopNo = loopNo; _cursorInfo.celNo = celNo; if (_macCursorRemap.empty() && viewId != -1) { CelObjView view(viewId, loopNo, celNo); _hotSpot = view._displace; _width = view._width; _height = view._height; // SSCI never increased the size of cursors, but some of the cursors // in early SCI32 games were designed for low-resolution display mode // and so are kind of hard to pick out when running in high-resolution // mode. // To address this, we make some slight adjustments to cursor display // in these early games: // GK1: All the cursors are increased in size since they all appear to // be designed for low-res display. // PQ4: We only make the cursors bigger if they are above a set // threshold size because inventory items usually have a // high-resolution cursor representation. bool pixelDouble = false; if (g_sci->_gfxFrameout->_isHiRes && (g_sci->getGameId() == GID_GK1 || (g_sci->getGameId() == GID_PQ4 && _width <= 22 && _height <= 22))) { _width *= 2; _height *= 2; _hotSpot.x *= 2; _hotSpot.y *= 2; pixelDouble = true; } _cursor.data = (byte *)realloc(_cursor.data, _width * _height); _cursor.rect = Common::Rect(_width, _height); memset(_cursor.data, 255, _width * _height); _cursor.skipColor = 255; Buffer target(_width, _height, _cursor.data); if (pixelDouble) { view.draw(target, _cursor.rect, Common::Point(0, 0), false, 2, 2); } else { view.draw(target, _cursor.rect, Common::Point(0, 0), false); } } else if (!_macCursorRemap.empty() && viewId != -1) { // Mac cursor handling GuiResourceId viewNum = viewId; // Remap cursor view based on what the scripts have given us. for (uint32 i = 0; i < _macCursorRemap.size(); i++) { if (viewNum == _macCursorRemap[i]) { viewNum = (i + 1) * 0x100 + loopNo * 0x10 + celNo; break; } if (i == _macCursorRemap.size()) error("Unmatched Mac cursor %d", viewNum); } _cursorInfo.resourceId = viewNum; Resource *resource = g_sci->getResMan()->findResource(ResourceId(kResourceTypeCursor, viewNum), false); if (!resource) { // The cursor resources often don't exist, this is normal behavior debug(0, "Mac cursor %d not found", viewNum); return; } Common::MemoryReadStream resStream(resource->data, resource->size); Graphics::MacCursor *macCursor = new Graphics::MacCursor(); if (!macCursor->readFromStream(resStream)) { warning("Failed to load Mac cursor %d", viewNum); delete macCursor; return; } _hotSpot = Common::Point(macCursor->getHotspotX(), macCursor->getHotspotY()); _width = macCursor->getWidth(); _height = macCursor->getHeight(); _cursor.data = (byte *)realloc(_cursor.data, _width * _height); memcpy(_cursor.data, macCursor->getSurface(), _width * _height); _cursor.rect = Common::Rect(_width, _height); _cursor.skipColor = macCursor->getKeyColor(); // The cursor will be drawn on next refresh delete macCursor; } else { _hotSpot = Common::Point(0, 0); _width = _height = 1; _cursor.data = (byte *)realloc(_cursor.data, _width * _height); _cursor.rect = Common::Rect(_width, _height); *_cursor.data = _cursor.skipColor; _cursorBack.rect = _cursor.rect; _cursorBack.rect.clip(_vmapRegion.rect); if (!_cursorBack.rect.isEmpty()) { readVideo(_cursorBack); } } _cursorBack.data = (byte *)realloc(_cursorBack.data, _width * _height); _drawBuff1.data = (byte *)realloc(_drawBuff1.data, _width * _height); _drawBuff2.data = (byte *)realloc(_drawBuff2.data, _width * _height * 4); _savedVmapRegion.data = (byte *)realloc(_savedVmapRegion.data, _width * _height); unhide(); }
void mitk::TrackingVolumeGenerator::GenerateData() { mitk::Surface::Pointer output = this->GetOutput(); //the surface wich represents the tracking volume std::string filepath = ""; // Full path to file (wil be resolved later) std::string filename = this->m_Data.VolumeModelLocation; // Name of the file or possibly a magic String, e.g. "cube" MITK_INFO << "volume: " << filename; // See if filename matches a magic string. if (filename.compare("cube") == 0){ vtkSmartPointer<vtkCubeSource> cubeSource = vtkSmartPointer<vtkCubeSource>::New(); double bounds[6]; bounds[0] = bounds[2] = bounds[4] = -400.0; // initialize bounds to -400 ... +400 cube. This is the default value of the bounds[1] = bounds[3] = bounds[5] = 400.0; // virtual tracking device, but it can be changed. In that case, // the tracking volume polydata has to be updated manually cubeSource->SetBounds(bounds); cubeSource->Update(); output->SetVtkPolyData(cubeSource->GetOutput()); //set the vtkCubeSource as polyData of the surface return; } if (filename.compare("") == 0) // empty String means no model, return empty output { output->SetVtkPolyData(vtkPolyData::New()); //initialize with empty poly data (otherwise old surfaces may be returned) => so an empty surface is returned return; } // from here on, we assume that filename contains an actual filename and not a magic string us::Module* module = us::GetModuleContext()->GetModule(); us::ModuleResource moduleResource = module->GetResource(filename); bool isCompressed = moduleResource.IsCompressed(); // Create ResourceStream from Resource us::ModuleResourceStream resStream(moduleResource,std::ios_base::binary); ofstream tmpOutputStream; std::string tmpFilePath = mitk::IOUtil::CreateTemporaryFile(tmpOutputStream); if (!isCompressed) { tmpOutputStream << resStream.rdbuf(); } else { resStream.seekg(0, std::ios::end); std::ios::pos_type length = resStream.tellg(); resStream.seekg(0, std::ios::beg); char* data = new char[length]; resStream.read(data, length); tmpOutputStream.close(); tmpOutputStream.open(tmpFilePath.c_str(), std::ios_base::binary | std::ios_base::out); tmpOutputStream.write(data, length); tmpOutputStream.flush(); delete[] data; } tmpOutputStream.close(); //filepath = mitk::StandardFileLocations::GetInstance()->FindFile(filename.c_str()); if (tmpFilePath.empty()) { MITK_ERROR << ("Volume Generator could not find the specified file " + filename); return; } mitk::STLFileReader::Pointer stlReader = mitk::STLFileReader::New(); stlReader->SetFileName( tmpFilePath.c_str() ); stlReader->Update(); std::remove(tmpFilePath.c_str()); if ( stlReader->GetOutput() == NULL) { MITK_ERROR << "Error while reading file"; return ; } output->SetVtkPolyData( stlReader->GetOutput()->GetVtkPolyData());//set the visible trackingvolume }