lang
stringclasses
3 values
file_path
stringlengths
5
150
repo_name
stringlengths
6
110
commit
stringlengths
40
40
file_code
stringlengths
1.52k
18.9k
prefix
stringlengths
82
16.5k
suffix
stringlengths
0
15.1k
middle
stringlengths
121
8.18k
strategy
stringclasses
8 values
context_items
listlengths
0
100
C++
Samples/NiUserSelection/DefaultTrackingInitializer.cpp
Wessi/OpenNI
613b0a43e66e1e97488624dec285341bc047d6d4
#include "DefaultTrackingInitializer.h" DefaultTrackingInitializer::DefaultTrackingInitializer(xn::UserGenerator *pUserGenerator) : TrackingInitializer(pUserGenerator), m_hCalibrationStartCallback(NULL), m_hCalibrationCompleteCallback(NULL), m_hInProgressCallback(NULL) { if(m_pUserGenerator->IsCapabilitySupported(XN_CAPABILITY_SKELETON)==FALSE) { m_bValid=FALSE; return; } XnStatus res=m_pUserGenerator->GetSkeletonCap().RegisterToCalibrationStart(CalibrationStartCallback,this,m_hCalibrationStartCallback); if(res!=XN_STATUS_OK) { m_hCalibrationStartCallback=NULL; m_bValid=FALSE; return; } res=m_pUserGenerator->GetSkeletonCap().RegisterToCalibrationComplete(CalibrationCompleteCallback,this,m_hCalibrationStartCallback); if(res!=XN_STATUS_OK) { m_hCalibrationStartCallback=NULL; m_bValid=FALSE; return; } res=m_pUserGenerator->GetSkeletonCap().RegisterToCalibrationInProgress(CalibrationInProgressCallback,this,m_hInProgressCallback); if(res!=XN_STATUS_OK) { m_hInProgressCallback=NULL; m_bValid=FALSE; return; } } DefaultTrackingInitializer::~DefaultTrackingInitializer() { if(m_pUserGenerator==NULL) return; if(m_hCalibrationStartCallback!=NULL) { m_pUserGenerator->GetSkeletonCap().UnregisterFromCalibrationStart(m_hCalibrationStartCallback); m_hCalibrationStartCallback=NULL; } if(m_hCalibrationCompleteCallback!=NULL) { m_pUserGenerator->GetSkeletonCap().UnregisterFromCalibrationComplete(m_hCalibrationCompleteCallback); m_hCalibrationCompleteCallback=NULL; } if(m_hInProgressCallback!=NULL) { m_pUserGenerator->GetSkeletonCap().UnregisterFromCalibrationInProgress(m_hInProgressCallback); m_hInProgressCallback=NULL; } } XnStatus DefaultTrackingInitializer::StartTracking(XnUserID nUserId, XnBool bForce) { if(m_pUserGenerator->GetSkeletonCap().IsTracking(nUserId)==TRUE) { if(m_pUserSelector!=NULL) { return m_pUserSelector->UpdateUserTracking(nUserId,TRUE,0); } else return XN_STATUS_OK; } return m_pUserGenerator->GetSkeletonCap().RequestCalibration(nUserId,bForce); } XnStatus DefaultTrackingInitializer::AbortTracking(XnUserID nUserId) { if(m_pUserGenerator->GetSkeletonCap().IsTracking(nUserId)==TRUE) { XnStatus res=m_pUserGenerator->GetSkeletonCap().StopTracking(nUserId); return res; } return m_pUserGenerator->GetSkeletonCap().AbortCalibration(nUserId); } XnStatus DefaultTrackingInitializer::CalibrationStart(XnUserID ) { return XN_STATUS_OK; } XnStatus DefaultTrackingInitializer::CalibrationComplete(XnUserID nUserId,XnCalibrationStatus eStatus) { XnBool retVal=FALSE; if (eStatus == XN_CALIBRATION_STATUS_OK) { if(m_pUserGenerator->GetSkeletonCap().StartTracking(nUserId)==XN_STATUS_OK) { retVal=TRUE; } } if(m_pUserSelector!=NULL) { return m_pUserSelector->UpdateUserTracking(nUserId,retVal,eStatus); } return XN_STATUS_OK; } XnStatus DefaultTrackingInitializer::CalibrationInProgress(XnUserID nUserId,XnCalibrationStatus eStatus) { if(m_pUserSelector!=NULL) return m_pUserSelector->UpdateUserTrackingProgress(nUserId,eStatus); return XN_STATUS_OK; } void XN_CALLBACK_TYPE DefaultTrackingInitializer::CalibrationStartCallback(xn::SkeletonCapability& , XnUserID nUserId, void* pCookie) { DefaultTrackingInitializer *pDefaultTrackingInitializer=(DefaultTrackingInitializer *)pCookie; pDefaultTrackingInitializer->CalibrationStart(nUserId); } void XN_CALLBACK_TYPE DefaultTrackingInitializer::CalibrationCompleteCallback(xn::SkeletonCapability& , XnUserID nUserId, XnCalibrationStatus eStatus, void* pCookie) { DefaultTrackingInitializer *pDefaultTrackingInitializer=(DefaultTrackingInitializer *)pCookie; pDefaultTrackingInitializer->CalibrationComplete(nUserId,eStatus); } void XN_CALLBACK_TYPE DefaultTrackingInitializer::CalibrationInProgressCallback(xn::SkeletonCapability& , XnUserID nUserId, XnCalibrationStatus eStatus, void* pCookie) { DefaultTrackingInitializer *pDefaultTrackingInitializer=(DefaultTrackingInitializer *)pCookie; pDefaultTrackingInitializer->CalibrationInProgress(nUserId,eStatus); }
#include "DefaultTrackingInitializer.h" DefaultTrackingInitializer::DefaultTrackingInitializer(xn::UserGenerator *pUserGenerator) : TrackingInitializer(pUserGenerator), m_hCalibrationStartCallback(NULL), m_hCalibrationCompleteCallback(NULL), m_hInProgressCallback(NULL) { if(m_pUserGenerator->IsCapabilitySupported(XN_CAPABILITY_SKELETON)==FALSE) { m_bValid=FALSE; return; } XnStatus res=m_pUserGenerator->GetSkeletonCap().RegisterToCalibrationStart(CalibrationStartCallback,this,m_hCalibrationStartCallback); if(res!=XN_STATUS_OK) { m_hCalibrationStartCallback=NULL; m_bValid=FALSE; return; } res=m_pUserGenerator->GetSkeletonCap().RegisterToCalibrationComplete(CalibrationCompleteCallback,this,m_hCalibrationStartCallback); if(res!=XN_STATUS_OK) { m_hCalibrationStartCallback=NULL; m_bValid=FALSE; return; } res=m_pUserGenerator->GetSkeletonCap().RegisterToCalibrationInProgress(CalibrationInProgressCallback,this,m_hInProgressCallback); if(res!=XN_STATUS_OK) { m_hInProgressCallback=NULL; m_bValid=FALSE; return; } } DefaultTrackingInitializer::~DefaultTrackingInitializer() { if(m_pUserGenerator==NULL) return; if(m_hCalibrationStartCallback!=NULL) { m_pUserGenerator->GetSkeletonCap().UnregisterFromCalibrationStart(m_hCalibrationStartCallback); m_hCalibrationStartCallback=NULL; } if(m_hCalibrationCompleteCallback!=NULL) { m_pUserGenerator->GetSkeletonCap().UnregisterFromCalibrationComplete(m_hCalibrationCompleteCallback); m_hCalibrationCompleteCallback=NULL; } if(m_hInProgressCallback!=NULL) { m_pUserGenerator->GetSkeletonCap().UnregisterFromCalibrationInProgress(m_hInProgressCallback); m_hInProgressCallback=NULL; } } XnStatus DefaultTrackingInitializer::StartTracking(XnUserID nUserId, XnBool bForce) { if(m_pUserGenerator->GetSkeletonCap().IsTracking(nUserId)==TRUE) { if(m_pUserSelector!=NULL) { return m_pUserSelector->UpdateUserTracking(nUserId,TRUE,0); } else return XN_STATUS_OK; } return m_pUserGenerator->GetSkeletonCap().RequestCalibration(nUserId,bForce); } XnStatus DefaultTrackingInitializer::AbortTracking(XnUserID nUserId) {
XnStatus DefaultTrackingInitializer::CalibrationStart(XnUserID ) { return XN_STATUS_OK; } XnStatus DefaultTrackingInitializer::CalibrationComplete(XnUserID nUserId,XnCalibrationStatus eStatus) { XnBool retVal=FALSE; if (eStatus == XN_CALIBRATION_STATUS_OK) { if(m_pUserGenerator->GetSkeletonCap().StartTracking(nUserId)==XN_STATUS_OK) { retVal=TRUE; } } if(m_pUserSelector!=NULL) { return m_pUserSelector->UpdateUserTracking(nUserId,retVal,eStatus); } return XN_STATUS_OK; } XnStatus DefaultTrackingInitializer::CalibrationInProgress(XnUserID nUserId,XnCalibrationStatus eStatus) { if(m_pUserSelector!=NULL) return m_pUserSelector->UpdateUserTrackingProgress(nUserId,eStatus); return XN_STATUS_OK; } void XN_CALLBACK_TYPE DefaultTrackingInitializer::CalibrationStartCallback(xn::SkeletonCapability& , XnUserID nUserId, void* pCookie) { DefaultTrackingInitializer *pDefaultTrackingInitializer=(DefaultTrackingInitializer *)pCookie; pDefaultTrackingInitializer->CalibrationStart(nUserId); } void XN_CALLBACK_TYPE DefaultTrackingInitializer::CalibrationCompleteCallback(xn::SkeletonCapability& , XnUserID nUserId, XnCalibrationStatus eStatus, void* pCookie) { DefaultTrackingInitializer *pDefaultTrackingInitializer=(DefaultTrackingInitializer *)pCookie; pDefaultTrackingInitializer->CalibrationComplete(nUserId,eStatus); } void XN_CALLBACK_TYPE DefaultTrackingInitializer::CalibrationInProgressCallback(xn::SkeletonCapability& , XnUserID nUserId, XnCalibrationStatus eStatus, void* pCookie) { DefaultTrackingInitializer *pDefaultTrackingInitializer=(DefaultTrackingInitializer *)pCookie; pDefaultTrackingInitializer->CalibrationInProgress(nUserId,eStatus); }
if(m_pUserGenerator->GetSkeletonCap().IsTracking(nUserId)==TRUE) { XnStatus res=m_pUserGenerator->GetSkeletonCap().StopTracking(nUserId); return res; } return m_pUserGenerator->GetSkeletonCap().AbortCalibration(nUserId); }
function_block-function_prefix_line
[ { "content": "XN_C_API XnBool XN_C_DECL xnProfilingIsActive();\n", "file_path": "Include/XnProfiling.h", "rank": 0, "score": 107637.93107806591 }, { "content": "XN_C_API XnBool XN_C_DECL xnLoggerIsEnabled(XnLogger* pLogger, XnLogSeverity severity);\n", "file_path": "Include/XnLog.h", ...
C++
src/game/scenes/GameScene.cpp
rkolovanov/game-sapper
b59b6a8ac56b5337c880ba26dbabf0200318dd93
#include "GameScene.h" #include "../Game.h" #include "../audio/MusicManager.h" #include "MainMenuScene.h" #include <random> #include <iostream> Game::Scenes::GameScene::GameScene(Game& game, size_t sizeX, size_t sizeY, size_t minesNumber) : Scene(game), m_field(sizeX, sizeY) { this->m_minesNumber = minesNumber; generateMines(minesNumber); calculateNearbyMinesCount(); Audio::MusicManager::getInstance().playMusic("resources/music/game-theme.ogg"); } void Game::Scenes::GameScene::onEvent(const sf::Event& event) { if (event.type == sf::Event::MouseButtonPressed) { float rectangleSizeX = static_cast<float>(m_game.getWindow().getSize().x) / static_cast<float>(m_field.getSizeX()); float rectangleSizeY = static_cast<float>(m_game.getWindow().getSize().y) / static_cast<float>(m_field.getSizeY()); size_t cellX = event.mouseButton.x / rectangleSizeX; size_t cellY = event.mouseButton.y / rectangleSizeY; Cell& cell = m_field.get(cellX, cellY); if (event.mouseButton.button == sf::Mouse::Left) { if (!cell.isChecked) { checkCell(cellX, cellY); } } else if (event.mouseButton.button == sf::Mouse::Right) { if (!cell.isChecked) { cell.isMarked = !cell.isMarked; } } if (getFieldStatus() == Field::FieldStatus::Lose) { m_game.changeScene(std::make_unique<MainMenuScene>(m_game)); } else if (getFieldStatus() == Field::FieldStatus::Win) { m_game.changeScene(std::make_unique<MainMenuScene>(m_game)); } } } void Game::Scenes::GameScene::onUpdate(const sf::Time& elapsedTime) { float rectangleSizeX = static_cast<float>(m_game.getWindow().getSize().x) / static_cast<float>(m_field.getSizeX()); float rectangleSizeY = static_cast<float>(m_game.getWindow().getSize().y) / static_cast<float>(m_field.getSizeY()); sf::RectangleShape shape(sf::Vector2f(rectangleSizeX, rectangleSizeY)); sf::Font font; sf::Text text; font.loadFromFile("resources/fonts/arial.ttf"); shape.setOutlineThickness(1.0); shape.setOutlineColor(sf::Color::Black); text.setFont(font); text.setCharacterSize(std::min(rectangleSizeX, rectangleSizeY) / 2); text.setFillColor(sf::Color::Black); for (size_t y = 0; y < m_field.getSizeY(); ++y) { for (size_t x = 0; x < m_field.getSizeX(); ++x) { Cell& cell = m_field.get(x, y); shape.setPosition(x * rectangleSizeX, y * rectangleSizeY); text.setPosition(x * rectangleSizeX, y * rectangleSizeY); if (cell.isChecked) { if (cell.isMine) { shape.setFillColor(sf::Color::Red); } else { shape.setFillColor(sf::Color::White); } text.setString(std::to_string(cell.nearbyMinesNumber)); } else if (cell.isMarked) { shape.setFillColor(sf::Color::Yellow); } else { shape.setFillColor(sf::Color(100, 100, 100)); } m_game.getWindow().draw(shape); m_game.getWindow().draw(text); text.setString(""); } } } void Game::Scenes::GameScene::generateMines(size_t minesNumber) { std::random_device rd; std::mt19937 mersenne(rd()); size_t sizeX = m_field.getSizeX(); size_t sizeY = m_field.getSizeX(); if (minesNumber > sizeX * sizeY) { throw std::invalid_argument("Mines count greater than cells count."); } for (size_t i = 0; i < minesNumber; ++i) { size_t generatedX = mersenne() % sizeX; size_t generatedY = mersenne() % sizeY; while (m_field.get(generatedX, generatedY).isMine) { generatedX = mersenne() % sizeX; generatedY = mersenne() % sizeY; } Cell& cell = m_field.get(generatedX, generatedY); cell.isMine = true; } } void Game::Scenes::GameScene::calculateNearbyMinesCount() { for (size_t y = 0; y < m_field.getSizeY(); ++y) { for (size_t x = 0; x < m_field.getSizeX(); ++x) { size_t minesCount = 0; std::vector<std::pair<size_t, size_t>> shifts = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}}; for (const auto& shift : shifts) { try { if (m_field.get(x + shift.first, y + shift.second).isMine) { ++minesCount; } } catch (const std::invalid_argument&) { } } m_field.get(x, y).nearbyMinesNumber = minesCount; } } } void Game::Scenes::GameScene::checkCell(size_t x, size_t y) { Cell& cell = m_field.get(x, y); if (cell.isChecked) { return; } cell.isChecked = true; if (cell.nearbyMinesNumber == 0) { std::vector<std::pair<size_t, size_t>> shifts = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}}; for (const auto& shift : shifts) { try { checkCell(x + shift.first, y + shift.second); } catch (const std::invalid_argument&) { } } } } Game::Field::FieldStatus Game::Scenes::GameScene::getFieldStatus() { size_t markedCells = 0; size_t markedMines = 0; size_t uncheckedCells = 0; for (size_t y = 0; y < m_field.getSizeY(); ++y) { for (size_t x = 0; x < m_field.getSizeX(); ++x) { try { Cell& cell = m_field.get(x, y); if (cell.isChecked) { if (cell.isMine) { return Field::FieldStatus::Lose; } } else { if (cell.isMarked) { if (cell.isMine) { ++markedMines; } else { ++markedCells; } } else { ++uncheckedCells; } } } catch (const std::invalid_argument&) { } } } if (markedMines == m_minesNumber && markedCells == 0 && uncheckedCells == 0) { return Field::FieldStatus::Win; } return Field::FieldStatus::Unknown; }
#include "GameScene.h" #include "../Game.h" #include "../audio/MusicManager.h" #include "MainMenuScene.h" #include <random> #include <iostream> Game::Scenes::GameScene::GameScene(Game& game, size_t sizeX, size_t sizeY, size_t minesNumber) : Scene(game), m_field(sizeX, sizeY) { this->m_minesNumber = minesNumber; generateMines(minesNumber); calculateNearbyMinesCount(); Audio::MusicManager::getInstance().playMusic("resources/music/game-theme.ogg"); } void Game::Scenes::GameScene::onEvent(const sf::Event& event) { if (event.type == sf::Event::MouseButtonPressed) { float rectangleSizeX = static_cast<float>(m_game.getWindow().getSize().x) / static_cast<float>(m_field.getSizeX()); float rectangleSizeY = static_cast<float>(m_game.getWindow().getSize().y) / static_cast<float>(m_field.getSizeY()); size_t cellX = event.mouseButton.x / rectangleSizeX; size_t cellY = event.mouseButton.y / rectangleSizeY; Cell& cell = m_field.get(cellX, cellY); if (event.mouseButton.button == sf::Mouse::Left) { if (!cell.isChecked) { checkCell(cellX, cellY); } } else if (event.mouseButton.button == sf::Mouse::Right) { if (!cell.isChecked) { cell.isMarked = !cell.isMarked; } } if (getFieldStatus() == Field::FieldStatus::Lose) { m_game.changeScene(std::make_unique<MainMenuScene>(m_game)); } else if (getFieldStatus() == Field::FieldStatus::Win) { m_game.changeScene(std::make_unique<MainMenuScene>(m_game)); } } } void Game::Scenes::GameScene::onUpdate(const sf::Time& elapsedTime) { float rectangleSizeX = static_cast<float>(m_game.getWindow().getSize().x) / static_cast<float>(m_field.getSizeX()); float rectangleSizeY = static_cast<float>(m_game.getWindow().getSize().y) / static_cast<float>(m_field.getSizeY()); sf::RectangleShape shape(sf::Vector2f(rectangleSizeX, rectangleSizeY)); sf::Font font; sf::Text text; font.loadFromFile("resources/fonts/arial.ttf"); shape.setOutlineThickness(1.0); shape.setOutlineColor(sf::Color::Black); text.setFont(font); text.setCharacterSize(std::min(rectangleSizeX, rectangleSizeY) / 2); text.setFillColor(sf::Color::Black); for (size_t y = 0; y < m_field.getSizeY(); ++y) { for (size_t x = 0; x < m_field.getSizeX(); ++x) { Cell& cell = m_field.get(x, y); shape.setPosition(x * rectangleSizeX, y * rectangleSizeY); text.setPosition(x * rectangleSizeX, y * rectangleSizeY); if (cell.isChecked) { if (cell.isMine) { shape.setFillColor(sf::Color::Red); } else { shape.setFillColor(sf::Color::White); } text.setString(std::to_string(cell.nearbyMinesNumber)); } else if (cell.isMarked) { shape.setFillColor(sf::Color::Yellow); } else { shape.setFillColor(sf::Color(100, 100, 100)); } m_game.getWindow().draw(shape); m_game.getWindow().draw(text); text.setString(""); } } } void Game::Scenes::GameScene::generateMines(size_t minesNumber) { std::random_device rd; std::mt19937 mersenne(rd()); size_t sizeX = m_field.getSizeX(); size_t sizeY = m_field.getSizeX(); if (minesNumber > sizeX * sizeY) { throw std::invalid_argument("Mines count greater than cells count."); } for (size_t i = 0; i < minesNumber; ++i) { size_t generatedX = mersenne() % sizeX; size_t generatedY = mersenne() % sizeY; while (m_field.get(generatedX, generatedY).isMine) { generatedX = mersenne() % sizeX; generatedY = mersenne() % sizeY; } Cell& cell = m_field.get(generatedX, generatedY); cell.isMine = true; } } void Game::Scenes::GameScene::calculateNearbyMinesCount() { for (size_t y = 0; y < m_field.getSizeY(); ++y) { for (size_t x = 0; x < m_field.getSizeX(); ++x) { size_t minesCount = 0; std::vector<std::pair<size_t, size_t>> shifts = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}}; for (const auto& shift : shifts) { try { if (m_field.get(x + shift.first, y + shift.second).isMine) { ++minesCount; } } catch (const std::invalid_argument&) { } } m_field.get(x, y).nearbyMinesNumber = minesCount; } } } void Game::Scenes::GameScene::checkCell(size_t x, size_t y) { Cell& cell = m_field.get(x, y);
} else { ++markedCells; } } else { ++uncheckedCells; } } } catch (const std::invalid_argument&) { } } } if (markedMines == m_minesNumber && markedCells == 0 && uncheckedCells == 0) { return Field::FieldStatus::Win; } return Field::FieldStatus::Unknown; }
if (cell.isChecked) { return; } cell.isChecked = true; if (cell.nearbyMinesNumber == 0) { std::vector<std::pair<size_t, size_t>> shifts = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}}; for (const auto& shift : shifts) { try { checkCell(x + shift.first, y + shift.second); } catch (const std::invalid_argument&) { } } } } Game::Field::FieldStatus Game::Scenes::GameScene::getFieldStatus() { size_t markedCells = 0; size_t markedMines = 0; size_t uncheckedCells = 0; for (size_t y = 0; y < m_field.getSizeY(); ++y) { for (size_t x = 0; x < m_field.getSizeX(); ++x) { try { Cell& cell = m_field.get(x, y); if (cell.isChecked) { if (cell.isMine) { return Field::FieldStatus::Lose; } } else { if (cell.isMarked) { if (cell.isMine) { ++markedMines;
random
[ { "content": "#ifndef GAME_SAPPER_SRC_GAME_FIELD_CELL_H\n\n#define GAME_SAPPER_SRC_GAME_FIELD_CELL_H\n\n\n\n#include <cstddef>\n\n\n\n\n\nstruct Cell {\n\n size_t nearbyMinesNumber;\n\n bool isMine;\n\n bool isChecked;\n\n bool isMarked;\n\n};\n\n\n\n\n", "file_path": "src/game/field/Cell.h", ...
C++
include/torquis/split.hpp
devfix/torquis
5d42ee8e6af332bbfc5aaa2741405e72109e3d14
#ifndef TORQUIS_INCLUDE_GUARD #error "Do not include this file directly, include tho torquis.hpp" #endif #ifndef TORQUIS_SPLIT_HPP #define TORQUIS_SPLIT_HPP namespace torquis { template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const CharT delim) { std::vector<std::basic_string_view<CharT>> parts; std::size_t prev = 0, curr; do { curr = str.find(delim, prev); if (curr == std::string::npos) { parts.push_back(str.substr(prev)); } else { parts.push_back(str.substr(prev, curr - prev)); } prev = curr + 1; } while (curr != std::string::npos); return parts; } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const std::basic_string_view<CharT> delim) { std::vector<std::basic_string_view<CharT>> parts; if (delim.length()) { std::size_t prev = 0, curr; do { curr = str.find(delim, prev); if (curr == std::string::npos) { parts.push_back(str.substr(prev)); } else { parts.push_back(str.substr(prev, curr - prev)); } prev = curr + delim.length(); } while (curr != std::string::npos && prev <= str.length()); } else { for (std::size_t i = 0; i < str.length(); i++) { parts.push_back(str.substr(i, 1)); } } return parts; } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const std::basic_string<CharT>& delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const CharT* delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string<CharT>& str, const std::basic_string_view<CharT> delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string<CharT>& str, const std::basic_string<CharT>& delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string<CharT>& str, const CharT* delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const CharT* str, const std::basic_string_view<CharT> delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const CharT* str, const std::basic_string<CharT>& delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const CharT* str, const CharT* delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } } #endif
#ifndef TORQUIS_INCLUDE_GUARD #error "Do not include this file directly, include tho torquis.hpp" #endif #ifndef TORQUIS_SPLIT_HPP #define TORQUIS_SPLIT_HPP namespace torquis { template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const CharT delim) { std::vector<st
()) { std::size_t prev = 0, curr; do { curr = str.find(delim, prev); if (curr == std::string::npos) { parts.push_back(str.substr(prev)); } else { parts.push_back(str.substr(prev, curr - prev)); } prev = curr + delim.length(); } while (curr != std::string::npos && prev <= str.length()); } else { for (std::size_t i = 0; i < str.length(); i++) { parts.push_back(str.substr(i, 1)); } } return parts; } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const std::basic_string<CharT>& delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const CharT* delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string<CharT>& str, const std::basic_string_view<CharT> delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string<CharT>& str, const std::basic_string<CharT>& delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string<CharT>& str, const CharT* delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const CharT* str, const std::basic_string_view<CharT> delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const CharT* str, const std::basic_string<CharT>& delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const CharT* str, const CharT* delim) { return split<CharT>(std::basic_string_view<CharT>(str), std::basic_string_view<CharT>(delim)); } } #endif
d::basic_string_view<CharT>> parts; std::size_t prev = 0, curr; do { curr = str.find(delim, prev); if (curr == std::string::npos) { parts.push_back(str.substr(prev)); } else { parts.push_back(str.substr(prev, curr - prev)); } prev = curr + 1; } while (curr != std::string::npos); return parts; } template<typename CharT> [[nodiscard]] std::vector<std::basic_string_view<CharT>> split(const std::basic_string_view<CharT> str, const std::basic_string_view<CharT> delim) { std::vector<std::basic_string_view<CharT>> parts; if (delim.length
random
[ { "content": "\n\n#define TORQUIS_INCLUDE_GUARD\n\n#include \"torquis/join.hpp\"\n\n#include \"torquis/replace.hpp\"\n\n#include \"torquis/split.hpp\"\n\n#include \"torquis/tolower.hpp\"\n\n#include \"torquis/toupper.hpp\"\n\n#undef TORQUIS_INCLUDE_GUARD\n\n\n\n#endif //TORQUIS_HPP\n", "file_path": "include...
C++
atlas_npu/ascendbase/src/Base/SingleOpProcess/SingleOpProcess.cpp
wangshankun/Tengine_Atlas
b5485039e72b4a624c795ff95d73eb6d719c7706
#include "SingleOpProcess.h" #include "acl/acl.h" SingleOpProcess::SingleOpProcess() : inputTensorNum_(0), outputTensorNum_(0), stream_(nullptr), attr_(nullptr), withHandle_(false), opHandle_(nullptr) {} SingleOpProcess::SingleOpProcess(const aclrtStream &stream) : inputTensorNum_(0), outputTensorNum_(0), attr_(nullptr), withHandle_(false), opHandle_(nullptr) { stream_ = stream; } SingleOpProcess::~SingleOpProcess() { if (withHandle_ == true) { aclopDestroyHandle(opHandle_); opHandle_ = nullptr; } stream_ = nullptr; } void SingleOpProcess::SetTypeName(std::string typeName) { typeName_ = typeName; } std::string SingleOpProcess::GetTypeName() { return typeName_; } APP_ERROR SingleOpProcess::SetInputTensor(std::vector<Tensor> tensors) { inputTensorDesc_.clear(); for (int i = 0; i < inputTensorNum_; i++) { std::shared_ptr<aclTensorDesc> tensorDesc(aclCreateTensorDesc(tensors[i].dataType, tensors[i].numDim, tensors[i].dims.data(), tensors[i].format), aclDestroyTensorDesc); if (tensorDesc == nullptr) { LogError << "Failed to create acl input tensor description."; return APP_ERR_COMM_INVALID_POINTER; } inputTensorDesc_.push_back(tensorDesc); } return APP_ERR_OK; } APP_ERROR SingleOpProcess::SetInputDataBuffer(std::vector<std::shared_ptr<void>> inputDataBuf, std::vector<size_t> inputBufSize) { inputDataBuf_.clear(); inputData_ = inputDataBuf; for (int i = 0; i < inputTensorNum_; i++) { std::shared_ptr<aclDataBuffer> dataBuffer(aclCreateDataBuffer(inputDataBuf[i].get(), inputBufSize[i]), aclDestroyDataBuffer); if (dataBuffer == nullptr) { LogError << "Failed to create acl input data buffer."; return APP_ERR_COMM_INVALID_POINTER; } inputDataBuf_.push_back(dataBuffer); } return APP_ERR_OK; } APP_ERROR SingleOpProcess::SetOutputTensor(std::vector<Tensor> tensors) { outputTensorDesc_.clear(); outputDataBuf_.clear(); outputData_.clear(); outputDataSize_.clear(); APP_ERROR ret = APP_ERR_OK; for (int i = 0; i < outputTensorNum_; i++) { std::shared_ptr<aclTensorDesc> tensorDesc(aclCreateTensorDesc(tensors[i].dataType, tensors[i].numDim, tensors[i].dims.data(), tensors[i].format), aclDestroyTensorDesc); if (tensorDesc == nullptr) { LogError << "Failed to create acl output tensor description."; return APP_ERR_COMM_INVALID_POINTER; } outputTensorDesc_.push_back(tensorDesc); void *outDevBuf = nullptr; size_t size = aclGetTensorDescSize(tensorDesc.get()); ret = aclrtMalloc(&outDevBuf, size, ACL_MEM_MALLOC_NORMAL_ONLY); if (ret != APP_ERR_OK) { LogError << "Failed to aclrtMalloc out result."; return ret; } std::shared_ptr<aclDataBuffer> dataBuf(aclCreateDataBuffer(outDevBuf, size), aclDestroyDataBuffer); if (dataBuf == nullptr) { LogError << "Failed to create acl output data buffer."; return APP_ERR_COMM_INVALID_POINTER; } outputDataBuf_.push_back(dataBuf); std::shared_ptr<void> data(outDevBuf, aclrtFree); outputData_.push_back(data); outputDataSize_.push_back(size); } return APP_ERR_OK; } void SingleOpProcess::SetInputTensorNum(int num) { inputTensorNum_ = num; } int SingleOpProcess::GetInputTensorNum() const { return inputTensorNum_; } void SingleOpProcess::SetOutputTensorNum(int num) { outputTensorNum_ = num; } int SingleOpProcess::GetOutputTensorNum() const { return outputTensorNum_; } std::vector<std::shared_ptr<void>> SingleOpProcess::GetOutputData() { return outputData_; } std::vector<size_t> SingleOpProcess::GetOutputDataSize() { return outputDataSize_; } APP_ERROR SingleOpProcess::SetOpAttr(std::shared_ptr<aclopAttr> attr, OpAttr attrDesc) { attr_ = attr; switch (attrDesc.type) { case BOOL: aclopSetAttrBool(attr.get(), attrDesc.name.c_str(), attrDesc.numBool); break; case INT: aclopSetAttrInt(attr.get(), attrDesc.name.c_str(), attrDesc.numInt); break; case FLOAT: aclopSetAttrFloat(attr.get(), attrDesc.name.c_str(), attrDesc.numFloat); break; case STRING: aclopSetAttrString(attr.get(), attrDesc.name.c_str(), attrDesc.numString.c_str()); break; case LIST_BOOL: aclopSetAttrListBool(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.valuesBool.data()); break; case LIST_INT: aclopSetAttrListInt(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.valuesInt.data()); break; case LIST_FLOAT: aclopSetAttrListFloat(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.valuesFloat.data()); break; case LIST_STRING: { const char **valuesString = new const char *[attrDesc.num]; for (int i = 0; i < attrDesc.num; i++) { valuesString[i] = attrDesc.valuesString[i].c_str(); } aclopSetAttrListString(attr.get(), attrDesc.name.c_str(), attrDesc.num, valuesString); delete[] valuesString; break; } case LIST_LIST_INT: { const int64_t **valuesListList = new const int64_t *[attrDesc.num]; for (int i = 0; i < attrDesc.num; i++) { valuesListList[i] = attrDesc.valuesListList[i].data(); } aclopSetAttrListListInt(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.numLists.data(), valuesListList); delete[] valuesListList; break; } default : break; } return APP_ERR_OK; } std::shared_ptr<aclopAttr> SingleOpProcess::GetOpAttr() { return attr_; } void SingleOpProcess::SetStream(aclrtStream stream) { stream_ = stream; } const aclrtStream& SingleOpProcess::GetStream() const { return stream_; } APP_ERROR SingleOpProcess::RunSingleOp(const bool &withHandle) { withHandle_ = withHandle; std::vector<aclTensorDesc *> inTensorDesc; for (auto tensor : inputTensorDesc_) { inTensorDesc.push_back(tensor.get()); } std::vector<aclDataBuffer *> inData; for (auto data : inputDataBuf_) { inData.push_back(data.get()); } std::vector<aclTensorDesc *> outTensorDesc; for (auto tensor : outputTensorDesc_) { outTensorDesc.push_back(tensor.get()); } std::vector<aclDataBuffer *> outData; for (auto data : outputDataBuf_) { outData.push_back(data.get()); } APP_ERROR ret = APP_ERR_OK; if (withHandle_ == true) { ret = aclopCreateHandle(typeName_.c_str(), inputTensorNum_, inTensorDesc.data(), outputTensorNum_, outTensorDesc.data(), attr_.get(), &opHandle_); if (ret != APP_ERR_OK) { LogError << typeName_ << "Failed to create handle, ret = " << ret; return ret; } ret = aclopExecWithHandle(opHandle_, inputTensorNum_, inData.data(), outputTensorNum_, outData.data(), stream_); if (ret != APP_ERR_OK) { LogError << typeName_ << "Failed to execute single operator with handle, ret = " << ret; return ret; } } else { ret = aclopExecute(typeName_.c_str(), inputTensorNum_, inTensorDesc.data(), inData.data(), outputTensorNum_, outTensorDesc.data(), outData.data(), attr_.get(), stream_); if (ret != APP_ERR_OK) { LogError << "Failed to execute singleOp: " << typeName_ << " ret = " << ret; return ret; } } return APP_ERR_OK; }
#include "SingleOpProcess.h" #include "acl/acl.h" SingleOpProcess::SingleOpProcess() : inputTensorNum_(0), outputTensorNum_(0), stream_(nullptr), attr_(nullptr), withHandle_(false), opHandle_(nullptr) {} SingleOpProcess::SingleOpProcess(const aclrtStream &stream) : inputTensorNum_(0), outputTensorNum_(0), attr_(nullptr), withHandle_(false), opHandle_(nullptr) { stream_ = stream; } SingleOpProcess::~SingleOpProcess() { if (withHandle_ == true) { aclopDestroyHandle(opHandle_); opHandle_ = nullptr; } s
e); } return APP_ERR_OK; } void SingleOpProcess::SetInputTensorNum(int num) { inputTensorNum_ = num; } int SingleOpProcess::GetInputTensorNum() const { return inputTensorNum_; } void SingleOpProcess::SetOutputTensorNum(int num) { outputTensorNum_ = num; } int SingleOpProcess::GetOutputTensorNum() const { return outputTensorNum_; } std::vector<std::shared_ptr<void>> SingleOpProcess::GetOutputData() { return outputData_; } std::vector<size_t> SingleOpProcess::GetOutputDataSize() { return outputDataSize_; } APP_ERROR SingleOpProcess::SetOpAttr(std::shared_ptr<aclopAttr> attr, OpAttr attrDesc) { attr_ = attr; switch (attrDesc.type) { case BOOL: aclopSetAttrBool(attr.get(), attrDesc.name.c_str(), attrDesc.numBool); break; case INT: aclopSetAttrInt(attr.get(), attrDesc.name.c_str(), attrDesc.numInt); break; case FLOAT: aclopSetAttrFloat(attr.get(), attrDesc.name.c_str(), attrDesc.numFloat); break; case STRING: aclopSetAttrString(attr.get(), attrDesc.name.c_str(), attrDesc.numString.c_str()); break; case LIST_BOOL: aclopSetAttrListBool(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.valuesBool.data()); break; case LIST_INT: aclopSetAttrListInt(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.valuesInt.data()); break; case LIST_FLOAT: aclopSetAttrListFloat(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.valuesFloat.data()); break; case LIST_STRING: { const char **valuesString = new const char *[attrDesc.num]; for (int i = 0; i < attrDesc.num; i++) { valuesString[i] = attrDesc.valuesString[i].c_str(); } aclopSetAttrListString(attr.get(), attrDesc.name.c_str(), attrDesc.num, valuesString); delete[] valuesString; break; } case LIST_LIST_INT: { const int64_t **valuesListList = new const int64_t *[attrDesc.num]; for (int i = 0; i < attrDesc.num; i++) { valuesListList[i] = attrDesc.valuesListList[i].data(); } aclopSetAttrListListInt(attr.get(), attrDesc.name.c_str(), attrDesc.num, attrDesc.numLists.data(), valuesListList); delete[] valuesListList; break; } default : break; } return APP_ERR_OK; } std::shared_ptr<aclopAttr> SingleOpProcess::GetOpAttr() { return attr_; } void SingleOpProcess::SetStream(aclrtStream stream) { stream_ = stream; } const aclrtStream& SingleOpProcess::GetStream() const { return stream_; } APP_ERROR SingleOpProcess::RunSingleOp(const bool &withHandle) { withHandle_ = withHandle; std::vector<aclTensorDesc *> inTensorDesc; for (auto tensor : inputTensorDesc_) { inTensorDesc.push_back(tensor.get()); } std::vector<aclDataBuffer *> inData; for (auto data : inputDataBuf_) { inData.push_back(data.get()); } std::vector<aclTensorDesc *> outTensorDesc; for (auto tensor : outputTensorDesc_) { outTensorDesc.push_back(tensor.get()); } std::vector<aclDataBuffer *> outData; for (auto data : outputDataBuf_) { outData.push_back(data.get()); } APP_ERROR ret = APP_ERR_OK; if (withHandle_ == true) { ret = aclopCreateHandle(typeName_.c_str(), inputTensorNum_, inTensorDesc.data(), outputTensorNum_, outTensorDesc.data(), attr_.get(), &opHandle_); if (ret != APP_ERR_OK) { LogError << typeName_ << "Failed to create handle, ret = " << ret; return ret; } ret = aclopExecWithHandle(opHandle_, inputTensorNum_, inData.data(), outputTensorNum_, outData.data(), stream_); if (ret != APP_ERR_OK) { LogError << typeName_ << "Failed to execute single operator with handle, ret = " << ret; return ret; } } else { ret = aclopExecute(typeName_.c_str(), inputTensorNum_, inTensorDesc.data(), inData.data(), outputTensorNum_, outTensorDesc.data(), outData.data(), attr_.get(), stream_); if (ret != APP_ERR_OK) { LogError << "Failed to execute singleOp: " << typeName_ << " ret = " << ret; return ret; } } return APP_ERR_OK; }
tream_ = nullptr; } void SingleOpProcess::SetTypeName(std::string typeName) { typeName_ = typeName; } std::string SingleOpProcess::GetTypeName() { return typeName_; } APP_ERROR SingleOpProcess::SetInputTensor(std::vector<Tensor> tensors) { inputTensorDesc_.clear(); for (int i = 0; i < inputTensorNum_; i++) { std::shared_ptr<aclTensorDesc> tensorDesc(aclCreateTensorDesc(tensors[i].dataType, tensors[i].numDim, tensors[i].dims.data(), tensors[i].format), aclDestroyTensorDesc); if (tensorDesc == nullptr) { LogError << "Failed to create acl input tensor description."; return APP_ERR_COMM_INVALID_POINTER; } inputTensorDesc_.push_back(tensorDesc); } return APP_ERR_OK; } APP_ERROR SingleOpProcess::SetInputDataBuffer(std::vector<std::shared_ptr<void>> inputDataBuf, std::vector<size_t> inputBufSize) { inputDataBuf_.clear(); inputData_ = inputDataBuf; for (int i = 0; i < inputTensorNum_; i++) { std::shared_ptr<aclDataBuffer> dataBuffer(aclCreateDataBuffer(inputDataBuf[i].get(), inputBufSize[i]), aclDestroyDataBuffer); if (dataBuffer == nullptr) { LogError << "Failed to create acl input data buffer."; return APP_ERR_COMM_INVALID_POINTER; } inputDataBuf_.push_back(dataBuffer); } return APP_ERR_OK; } APP_ERROR SingleOpProcess::SetOutputTensor(std::vector<Tensor> tensors) { outputTensorDesc_.clear(); outputDataBuf_.clear(); outputData_.clear(); outputDataSize_.clear(); APP_ERROR ret = APP_ERR_OK; for (int i = 0; i < outputTensorNum_; i++) { std::shared_ptr<aclTensorDesc> tensorDesc(aclCreateTensorDesc(tensors[i].dataType, tensors[i].numDim, tensors[i].dims.data(), tensors[i].format), aclDestroyTensorDesc); if (tensorDesc == nullptr) { LogError << "Failed to create acl output tensor description."; return APP_ERR_COMM_INVALID_POINTER; } outputTensorDesc_.push_back(tensorDesc); void *outDevBuf = nullptr; size_t size = aclGetTensorDescSize(tensorDesc.get()); ret = aclrtMalloc(&outDevBuf, size, ACL_MEM_MALLOC_NORMAL_ONLY); if (ret != APP_ERR_OK) { LogError << "Failed to aclrtMalloc out result."; return ret; } std::shared_ptr<aclDataBuffer> dataBuf(aclCreateDataBuffer(outDevBuf, size), aclDestroyDataBuffer); if (dataBuf == nullptr) { LogError << "Failed to create acl output data buffer."; return APP_ERR_COMM_INVALID_POINTER; } outputDataBuf_.push_back(dataBuf); std::shared_ptr<void> data(outDevBuf, aclrtFree); outputData_.push_back(data); outputDataSize_.push_back(siz
random
[ { "content": " uint8_t *data = nullptr; // Image data\n", "file_path": "atlas_npu/ascendbase/src/Base/CommonDataType/CommonDataType.h", "rank": 0, "score": 95849.1341938177 }, { "content": "template<typename T> FLATBUFFERS_CONSTEXPR inline bool IsConst...
C++
src/scanner/src/scanner.cpp
zainmehdi/graphslam
7abb9fd99e03f422e98571b89c6fb03208a7a64f
#include "utils.hpp" #include "scanner.hpp" #include <iostream> int gicp_maximum_iterations; double gicp_maximum_correspondence_distance, gicp_transformation_epsilon, gicp_euclidean_fitness_epsilon; int loop_closure_skip; double fitness_keyframe_threshold, fitness_loop_threshold, distance_threshold, rotation_threshold; double k_disp_disp, k_rot_disp, k_rot_rot; double sigma_xy, sigma_th; ros::Publisher registration_pub; ros::Publisher pointcloud_debug_pub; ros::Publisher delta_pub; ros::ServiceClient keyframe_last_client; ros::ServiceClient keyframe_closest_client; pcl::IterativeClosestPoint<pcl::PointXYZ, pcl::PointXYZ> gicp; Eigen::Matrix4f carry_transform; unsigned int loop_closure_skip_count; using namespace scanner; Alignement gicp_register(const sensor_msgs::PointCloud2 input_1, const sensor_msgs::PointCloud2 input_2, Eigen::Matrix4f& transform){ pcl::PointCloud<pcl::PointXYZ>::Ptr pointcloud_1 = format_pointcloud(input_1); pcl::PointCloud<pcl::PointXYZ>::Ptr pointcloud_2 = format_pointcloud(input_2); gicp.setInputSource(pointcloud_1); gicp.setInputTarget(pointcloud_2); pcl::PointCloud<pcl::PointXYZ>::Ptr pointcloud_transform(new pcl::PointCloud<pcl::PointXYZ>); gicp.align(*pointcloud_transform, transform); Alignement output; output.convergence_state = gicp.getConvergeCriteria()->getConvergenceState(); output.converged = gicp.hasConverged(); output.fitness = gicp.getFitnessScore(); if (gicp.hasConverged()) { transform = gicp.getFinalTransformation(); output.transform = transform; geometry_msgs::Pose2D transform_Delta = make_Delta(transform); Eigen::MatrixXd covariance_Delta = compute_covariance(sigma_xy, sigma_th); output.Delta = create_Pose2DWithCovariance_msg(transform_Delta, covariance_Delta); } return output; } Alignement gicp_register(const sensor_msgs::PointCloud2 input_1, const sensor_msgs::PointCloud2 input_2){ Eigen::Matrix4f guess_null(Eigen::Matrix4f::Identity()); return gicp_register(input_1, input_2, guess_null); } bool vote_for_keyframe(const common::Pose2DWithCovariance Delta, const double fitness) { if (fitness > fitness_keyframe_threshold) return true; if (fabs(Delta.pose.theta) > rotation_threshold) return true; if ((Delta.pose.x*Delta.pose.x+Delta.pose.y*Delta.pose.y) > distance_threshold*distance_threshold) return true; return false; } void scanner_callback(const sensor_msgs::LaserScan& input) { common::Registration output; output.first_frame_flag = false; output.keyframe_flag = false; output.loop_closure_flag = false; common::LastKeyframe keyframe_last_request; bool keyframe_last_request_returned = keyframe_last_client.call(keyframe_last_request); if (!keyframe_last_request_returned) { ROS_INFO("### NO LAST KEYFRAME FOUND : ASSUME FIRST KEYFRAME ###"); output.first_frame_flag = true; output.keyframe_new.scan = input; output.keyframe_new.pointcloud = scan_to_pointcloud(input); } if (keyframe_last_request_returned) { sensor_msgs::PointCloud2 input_pointcloud = scan_to_pointcloud(input); sensor_msgs::PointCloud2 keyframe_last_pointcloud = keyframe_last_request.response.keyframe_last.pointcloud; double start = ros::Time::now().toSec(); gicp.setMaxCorrespondenceDistance(0.5); Alignement alignement_last = gicp_register(input_pointcloud, keyframe_last_pointcloud, carry_transform); double end = ros::Time::now().toSec(); output.keyframe_flag = vote_for_keyframe(alignement_last.Delta, alignement_last.fitness); output.keyframe_new.ts = input.header.stamp; output.keyframe_new.pointcloud = input_pointcloud; output.keyframe_new.scan = input; output.keyframe_last = keyframe_last_request.response.keyframe_last; output.factor_new.id_1 = keyframe_last_request.response.keyframe_last.id; output.factor_new.id_2 = output.keyframe_new.id; output.factor_new.delta = alignement_last.Delta; if (output.keyframe_flag) { ROS_INFO("RG: align time: %f; fitness: %f", end - start, alignement_last.fitness); ROS_INFO_STREAM("RG: convergence state: " << convergence_text(alignement_last.convergence_state)); ROS_INFO("RG: Delta: %f %f %f", alignement_last.Delta.pose.x, alignement_last.Delta.pose.y, alignement_last.Delta.pose.theta); carry_transform.setIdentity(); loop_closure_skip_count++; if (loop_closure_skip_count >= loop_closure_skip) { common::ClosestKeyframe keyframe_closest_request; keyframe_closest_request.request.keyframe_last = keyframe_last_request.response.keyframe_last; bool keyframe_closest_request_returned = keyframe_closest_client.call(keyframe_closest_request); if (keyframe_closest_request_returned) { Eigen::Matrix4f T_last = make_transform(keyframe_last_request.response.keyframe_last.pose_opti.pose); Eigen::Matrix4f T_loop = make_transform(keyframe_closest_request.response.keyframe_closest.pose_opti.pose); Eigen::Matrix4f loop_transform = T_last.inverse()*T_loop; sensor_msgs::PointCloud2 keyframe_closest_pointcloud = keyframe_closest_request.response.keyframe_closest.pointcloud; start = ros::Time::now().toSec(); gicp.setMaxCorrespondenceDistance(1.0); Alignement alignement_loop = gicp_register(keyframe_closest_pointcloud, keyframe_last_pointcloud, loop_transform); end = ros::Time::now().toSec(); ROS_INFO("LC: align time: %f; fitness: %f", end - start, alignement_loop.fitness); ROS_INFO_STREAM("LC: convergence state: " << convergence_text(alignement_loop.convergence_state)); ROS_INFO("LC: Delta: %f %f %f", alignement_loop.Delta.pose.x, alignement_loop.Delta.pose.y, alignement_loop.Delta.pose.theta); output.loop_closure_flag = (alignement_loop.converged && alignement_loop.fitness < fitness_loop_threshold); output.keyframe_last = keyframe_last_request.response.keyframe_last; output.keyframe_loop = keyframe_closest_request.response.keyframe_closest; output.factor_loop.id_1 = keyframe_last_request.response.keyframe_last.id; output.factor_loop.id_2 = keyframe_closest_request.response.keyframe_closest.id; output.factor_loop.delta = alignement_loop.Delta; if (output.loop_closure_flag) loop_closure_skip_count = 0; } } } } registration_pub.publish(output); } int main(int argc, char** argv) { ros::init(argc, argv, "scanner"); ros::NodeHandle n; ros::Subscriber scanner_sub = n.subscribe("/base_scan", 1, scanner_callback); delta_pub = n.advertise<geometry_msgs::Pose2D>("/scanner/delta", 1); registration_pub = n.advertise<common::Registration>("/scanner/registration", 1); pointcloud_debug_pub = n.advertise<sensor_msgs::PointCloud2>("/scanner/debug_pointcloud", 1); keyframe_last_client = n.serviceClient<common::LastKeyframe>("/graph/last_keyframe"); keyframe_closest_client = n.serviceClient<common::ClosestKeyframe>("/graph/closest_keyframe"); gicp.setUseReciprocalCorrespondences(true); if(ros::param::get("/scanner/gicp_maximum_iterations", gicp_maximum_iterations)) { gicp.setMaximumIterations(gicp_maximum_iterations); ROS_INFO("ROSPARAM: [LOADED] /scanner/gicp_maximum_iterations = %d", gicp_maximum_iterations); } else { gicp_maximum_iterations = 50; gicp.setMaximumIterations(gicp_maximum_iterations); ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/gicp_maximum_iterations = %d", gicp_maximum_iterations); } if(ros::param::get("/scanner/gicp_maximum_correspondence_distance", gicp_maximum_correspondence_distance)) { gicp.setMaxCorrespondenceDistance(gicp_maximum_correspondence_distance); ROS_INFO("ROSPARAM: [LOADED] /scanner/gicp_maximum_correspondence_distance = %f", gicp_maximum_correspondence_distance); } else { gicp_maximum_correspondence_distance = 0.05; gicp.setMaxCorrespondenceDistance(gicp_maximum_correspondence_distance); ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/gicp_maximum_correspondence_distance = %f", gicp_maximum_correspondence_distance); } gicp_transformation_epsilon = 1e-8; gicp.setTransformationEpsilon(gicp_transformation_epsilon); if(ros::param::get("/scanner/gicp_euclidean_fitness_epsilon", gicp_euclidean_fitness_epsilon)) { gicp.setEuclideanFitnessEpsilon(gicp_euclidean_fitness_epsilon); ROS_INFO("ROSPARAM: [LOADED] /scanner/gicp_euclidean_fitness_epsilon = %f", gicp_euclidean_fitness_epsilon); } else { gicp_euclidean_fitness_epsilon = 1.0; gicp.setEuclideanFitnessEpsilon(gicp_euclidean_fitness_epsilon); ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/gicp_euclidean_fitness_epsilon = %f", gicp_euclidean_fitness_epsilon); } if(ros::param::get("/scanner/fitness_keyframe_threshold", fitness_keyframe_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/fitness_keyframe_threshold = %f", fitness_keyframe_threshold); } else { fitness_keyframe_threshold = 1.5; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/fitness_keyframe_threshold = %f", fitness_keyframe_threshold); } if(ros::param::get("/scanner/fitness_loop_threshold", fitness_loop_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/fitness_loop_threshold = %f", fitness_loop_threshold); } else { fitness_loop_threshold = 4.5; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/fitness_loop_threshold = %f", fitness_loop_threshold); } if(ros::param::get("/scanner/distance_threshold", distance_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/distance_threshold = %f", distance_threshold); } else { distance_threshold = 1.0; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/distance_threshold = %f", distance_threshold); } if(ros::param::get("/scanner/rotation_threshold", rotation_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/rotation_threshold = %f", rotation_threshold); } else { rotation_threshold = 1.0; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/rotation_threshold = %f", rotation_threshold); } if(ros::param::get("/scanner/loop_closure_skip", loop_closure_skip)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/loop_closure_skip = %d", loop_closure_skip); } else { loop_closure_skip = 4; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/loop_closure_skip = %d", loop_closure_skip); } if(ros::param::get("/scanner/k_disp_disp", k_disp_disp)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/k_disp_disp = %f", k_disp_disp); } else { k_disp_disp = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/k_disp_disp = %f", k_disp_disp); } if(ros::param::get("/scanner/k_rot_disp", k_rot_disp)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/k_rot_disp = %f", k_rot_disp); } else { k_rot_disp = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/k_rot_disp = %f", k_rot_disp); } if(ros::param::get("/scanner/k_rot_rot", k_rot_rot)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/k_rot_rot = %f", k_rot_rot); } else { k_rot_rot = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/k_rot_rot = %f", k_rot_rot); } if(ros::param::get("/scanner/sigma_xy", sigma_xy)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/sigma_xy = %f", sigma_xy); } else { sigma_xy = 0.002; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/sigma_xy = %f", sigma_xy); } if(ros::param::get("/scanner/sigma_th", sigma_th)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/sigma_th = %f", sigma_th); } else { sigma_th = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/sigma_th = %f", sigma_th); } ROS_INFO("ICP: max iter sim transf: %d", gicp.getConvergeCriteria()->getMaximumIterationsSimilarTransforms()); ROS_INFO("ICP: fail after max iter: %d ", gicp.getConvergeCriteria()->getFailureAfterMaximumIterations()); ROS_INFO("ICP: abs MSE : %f [x1e8]", 1e8*gicp.getConvergeCriteria()->getAbsoluteMSE()); ROS_INFO("ICP: rel MSE : %f ", gicp.getConvergeCriteria()->getRelativeMSE()); ROS_INFO("ICP: rot th : %f [rad]", acos(gicp.getConvergeCriteria()->getRotationThreshold())); ROS_INFO("ICP: trans th: %f [m]", sqrt(gicp.getConvergeCriteria()->getTranslationThreshold())); ROS_INFO("ICP: max iter: %d ", gicp.getConvergeCriteria()->getMaximumIterations()); ROS_INFO("ICP: RANSAC iter: %d ", int(gicp.getRANSACIterations())); gicp.getConvergeCriteria()->setMaximumIterationsSimilarTransforms(10); ROS_INFO("ICP: max iter sim transf: %d", gicp.getConvergeCriteria()->getMaximumIterationsSimilarTransforms()); carry_transform.setIdentity(); loop_closure_skip_count = 0; ros::spin(); return 0; }
#include "utils.hpp" #include "scanner.hpp" #include <iostream> int gicp_maximum_iterations; double gicp_maximum_correspondence_distance, gicp_transformation_epsilon, gicp_euclidean_fitness_epsilon; int loop_closure_skip; double fitness_keyframe_threshold, fitness_loop_threshold, distance_threshold, rotation_threshold; double k_disp_disp, k_rot_disp, k_rot_rot; double sigma_xy, sigma_th; ros::Publisher registration_pub; ros::Publisher pointcloud_debug_pub; ros::Publisher delta_pub; ros::ServiceClient keyframe_last_client; ros::ServiceClient keyframe_closest_client; pcl::IterativeClosestPoint<pcl::PointXYZ, pcl::PointXYZ> gicp; Eigen::Matrix4f carry_transform; unsigned int loop_closure_skip_count; using namespace scanner; Alignement gicp_register(const sensor_msgs::PointCloud2 input_1, const sensor_msgs::PointCloud2 input_2, Eigen::Matrix4f& transform){ pcl::PointCloud<pcl::PointXYZ>::Ptr pointcloud_1 = format_pointcloud(input_1); pcl::PointCloud<pcl::PointXYZ>::Ptr pointcloud_2 = format_pointcloud(input_2); gicp.setInputSource(pointcloud_1); gicp.setInputTarget(pointcloud_2); pcl::PointCloud<pcl::PointXYZ>::Ptr pointcloud_transform(new pcl::PointCloud<pcl::PointXYZ>); gicp.align(*pointcloud_transform, transform); Alignement output; output.convergence_state = gicp.getConvergeCriteria()->getConvergenceState(); output.converged = gicp.hasConverged(); output.fitness = gicp.getFitnessScore(); if (gicp.hasConverged()) { transform = gicp.getFinalTransformation(); output.transform = transform; geometry_msgs::Pose2D transform_Delta = make_Delta(transform); Eigen::MatrixXd covariance_Delta = compute_covariance(sigma_xy, sigma_th); output.Delta = create_Pose2DWithCovariance_msg(transform_Delta, covariance_Delta); } return output; } Alignement gicp_register(const sensor_msgs::PointCloud2 input_1, const sensor_msgs::PointCloud2 input_2){ Eigen::Matrix4f guess_null(Eigen::Matrix4f::Identity()); return gicp_register(input_1, input_2, guess_null); } bool vote_for_keyframe(const common::Pose2DWithCovariance Delta, const double fitness) {
void scanner_callback(const sensor_msgs::LaserScan& input) { common::Registration output; output.first_frame_flag = false; output.keyframe_flag = false; output.loop_closure_flag = false; common::LastKeyframe keyframe_last_request; bool keyframe_last_request_returned = keyframe_last_client.call(keyframe_last_request); if (!keyframe_last_request_returned) { ROS_INFO("### NO LAST KEYFRAME FOUND : ASSUME FIRST KEYFRAME ###"); output.first_frame_flag = true; output.keyframe_new.scan = input; output.keyframe_new.pointcloud = scan_to_pointcloud(input); } if (keyframe_last_request_returned) { sensor_msgs::PointCloud2 input_pointcloud = scan_to_pointcloud(input); sensor_msgs::PointCloud2 keyframe_last_pointcloud = keyframe_last_request.response.keyframe_last.pointcloud; double start = ros::Time::now().toSec(); gicp.setMaxCorrespondenceDistance(0.5); Alignement alignement_last = gicp_register(input_pointcloud, keyframe_last_pointcloud, carry_transform); double end = ros::Time::now().toSec(); output.keyframe_flag = vote_for_keyframe(alignement_last.Delta, alignement_last.fitness); output.keyframe_new.ts = input.header.stamp; output.keyframe_new.pointcloud = input_pointcloud; output.keyframe_new.scan = input; output.keyframe_last = keyframe_last_request.response.keyframe_last; output.factor_new.id_1 = keyframe_last_request.response.keyframe_last.id; output.factor_new.id_2 = output.keyframe_new.id; output.factor_new.delta = alignement_last.Delta; if (output.keyframe_flag) { ROS_INFO("RG: align time: %f; fitness: %f", end - start, alignement_last.fitness); ROS_INFO_STREAM("RG: convergence state: " << convergence_text(alignement_last.convergence_state)); ROS_INFO("RG: Delta: %f %f %f", alignement_last.Delta.pose.x, alignement_last.Delta.pose.y, alignement_last.Delta.pose.theta); carry_transform.setIdentity(); loop_closure_skip_count++; if (loop_closure_skip_count >= loop_closure_skip) { common::ClosestKeyframe keyframe_closest_request; keyframe_closest_request.request.keyframe_last = keyframe_last_request.response.keyframe_last; bool keyframe_closest_request_returned = keyframe_closest_client.call(keyframe_closest_request); if (keyframe_closest_request_returned) { Eigen::Matrix4f T_last = make_transform(keyframe_last_request.response.keyframe_last.pose_opti.pose); Eigen::Matrix4f T_loop = make_transform(keyframe_closest_request.response.keyframe_closest.pose_opti.pose); Eigen::Matrix4f loop_transform = T_last.inverse()*T_loop; sensor_msgs::PointCloud2 keyframe_closest_pointcloud = keyframe_closest_request.response.keyframe_closest.pointcloud; start = ros::Time::now().toSec(); gicp.setMaxCorrespondenceDistance(1.0); Alignement alignement_loop = gicp_register(keyframe_closest_pointcloud, keyframe_last_pointcloud, loop_transform); end = ros::Time::now().toSec(); ROS_INFO("LC: align time: %f; fitness: %f", end - start, alignement_loop.fitness); ROS_INFO_STREAM("LC: convergence state: " << convergence_text(alignement_loop.convergence_state)); ROS_INFO("LC: Delta: %f %f %f", alignement_loop.Delta.pose.x, alignement_loop.Delta.pose.y, alignement_loop.Delta.pose.theta); output.loop_closure_flag = (alignement_loop.converged && alignement_loop.fitness < fitness_loop_threshold); output.keyframe_last = keyframe_last_request.response.keyframe_last; output.keyframe_loop = keyframe_closest_request.response.keyframe_closest; output.factor_loop.id_1 = keyframe_last_request.response.keyframe_last.id; output.factor_loop.id_2 = keyframe_closest_request.response.keyframe_closest.id; output.factor_loop.delta = alignement_loop.Delta; if (output.loop_closure_flag) loop_closure_skip_count = 0; } } } } registration_pub.publish(output); } int main(int argc, char** argv) { ros::init(argc, argv, "scanner"); ros::NodeHandle n; ros::Subscriber scanner_sub = n.subscribe("/base_scan", 1, scanner_callback); delta_pub = n.advertise<geometry_msgs::Pose2D>("/scanner/delta", 1); registration_pub = n.advertise<common::Registration>("/scanner/registration", 1); pointcloud_debug_pub = n.advertise<sensor_msgs::PointCloud2>("/scanner/debug_pointcloud", 1); keyframe_last_client = n.serviceClient<common::LastKeyframe>("/graph/last_keyframe"); keyframe_closest_client = n.serviceClient<common::ClosestKeyframe>("/graph/closest_keyframe"); gicp.setUseReciprocalCorrespondences(true); if(ros::param::get("/scanner/gicp_maximum_iterations", gicp_maximum_iterations)) { gicp.setMaximumIterations(gicp_maximum_iterations); ROS_INFO("ROSPARAM: [LOADED] /scanner/gicp_maximum_iterations = %d", gicp_maximum_iterations); } else { gicp_maximum_iterations = 50; gicp.setMaximumIterations(gicp_maximum_iterations); ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/gicp_maximum_iterations = %d", gicp_maximum_iterations); } if(ros::param::get("/scanner/gicp_maximum_correspondence_distance", gicp_maximum_correspondence_distance)) { gicp.setMaxCorrespondenceDistance(gicp_maximum_correspondence_distance); ROS_INFO("ROSPARAM: [LOADED] /scanner/gicp_maximum_correspondence_distance = %f", gicp_maximum_correspondence_distance); } else { gicp_maximum_correspondence_distance = 0.05; gicp.setMaxCorrespondenceDistance(gicp_maximum_correspondence_distance); ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/gicp_maximum_correspondence_distance = %f", gicp_maximum_correspondence_distance); } gicp_transformation_epsilon = 1e-8; gicp.setTransformationEpsilon(gicp_transformation_epsilon); if(ros::param::get("/scanner/gicp_euclidean_fitness_epsilon", gicp_euclidean_fitness_epsilon)) { gicp.setEuclideanFitnessEpsilon(gicp_euclidean_fitness_epsilon); ROS_INFO("ROSPARAM: [LOADED] /scanner/gicp_euclidean_fitness_epsilon = %f", gicp_euclidean_fitness_epsilon); } else { gicp_euclidean_fitness_epsilon = 1.0; gicp.setEuclideanFitnessEpsilon(gicp_euclidean_fitness_epsilon); ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/gicp_euclidean_fitness_epsilon = %f", gicp_euclidean_fitness_epsilon); } if(ros::param::get("/scanner/fitness_keyframe_threshold", fitness_keyframe_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/fitness_keyframe_threshold = %f", fitness_keyframe_threshold); } else { fitness_keyframe_threshold = 1.5; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/fitness_keyframe_threshold = %f", fitness_keyframe_threshold); } if(ros::param::get("/scanner/fitness_loop_threshold", fitness_loop_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/fitness_loop_threshold = %f", fitness_loop_threshold); } else { fitness_loop_threshold = 4.5; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/fitness_loop_threshold = %f", fitness_loop_threshold); } if(ros::param::get("/scanner/distance_threshold", distance_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/distance_threshold = %f", distance_threshold); } else { distance_threshold = 1.0; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/distance_threshold = %f", distance_threshold); } if(ros::param::get("/scanner/rotation_threshold", rotation_threshold)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/rotation_threshold = %f", rotation_threshold); } else { rotation_threshold = 1.0; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/rotation_threshold = %f", rotation_threshold); } if(ros::param::get("/scanner/loop_closure_skip", loop_closure_skip)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/loop_closure_skip = %d", loop_closure_skip); } else { loop_closure_skip = 4; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/loop_closure_skip = %d", loop_closure_skip); } if(ros::param::get("/scanner/k_disp_disp", k_disp_disp)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/k_disp_disp = %f", k_disp_disp); } else { k_disp_disp = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/k_disp_disp = %f", k_disp_disp); } if(ros::param::get("/scanner/k_rot_disp", k_rot_disp)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/k_rot_disp = %f", k_rot_disp); } else { k_rot_disp = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/k_rot_disp = %f", k_rot_disp); } if(ros::param::get("/scanner/k_rot_rot", k_rot_rot)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/k_rot_rot = %f", k_rot_rot); } else { k_rot_rot = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/k_rot_rot = %f", k_rot_rot); } if(ros::param::get("/scanner/sigma_xy", sigma_xy)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/sigma_xy = %f", sigma_xy); } else { sigma_xy = 0.002; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/sigma_xy = %f", sigma_xy); } if(ros::param::get("/scanner/sigma_th", sigma_th)) { ROS_INFO("ROSPARAM: [LOADED] /scanner/sigma_th = %f", sigma_th); } else { sigma_th = 0.001; ROS_WARN("ROSPARAM: [NOT LOADED][DEFAULT SET] /scanner/sigma_th = %f", sigma_th); } ROS_INFO("ICP: max iter sim transf: %d", gicp.getConvergeCriteria()->getMaximumIterationsSimilarTransforms()); ROS_INFO("ICP: fail after max iter: %d ", gicp.getConvergeCriteria()->getFailureAfterMaximumIterations()); ROS_INFO("ICP: abs MSE : %f [x1e8]", 1e8*gicp.getConvergeCriteria()->getAbsoluteMSE()); ROS_INFO("ICP: rel MSE : %f ", gicp.getConvergeCriteria()->getRelativeMSE()); ROS_INFO("ICP: rot th : %f [rad]", acos(gicp.getConvergeCriteria()->getRotationThreshold())); ROS_INFO("ICP: trans th: %f [m]", sqrt(gicp.getConvergeCriteria()->getTranslationThreshold())); ROS_INFO("ICP: max iter: %d ", gicp.getConvergeCriteria()->getMaximumIterations()); ROS_INFO("ICP: RANSAC iter: %d ", int(gicp.getRANSACIterations())); gicp.getConvergeCriteria()->setMaximumIterationsSimilarTransforms(10); ROS_INFO("ICP: max iter sim transf: %d", gicp.getConvergeCriteria()->getMaximumIterationsSimilarTransforms()); carry_transform.setIdentity(); loop_closure_skip_count = 0; ros::spin(); return 0; }
if (fitness > fitness_keyframe_threshold) return true; if (fabs(Delta.pose.theta) > rotation_threshold) return true; if ((Delta.pose.x*Delta.pose.x+Delta.pose.y*Delta.pose.y) > distance_threshold*distance_threshold) return true; return false; }
function_block-function_prefix_line
[ { "content": "struct Alignement{\n\n bool converged;\n\n float fitness;\n\n pcl::registration::DefaultConvergenceCriteria<float>::ConvergenceState convergence_state;\n\n Eigen::Matrix4f transform;\n\n common::Pose2DWithCovariance Delta;\n\n};\n\n\n\n\n\n/**\n\n * \\brief Creat...
C++
Stream.cpp
chrisoldwood/WCL
608a83f9e41f4c1d2a7ac6991abbcf264d5924e0
#include "Common.hpp" #include "Stream.hpp" #include <Core/AnsiWide.hpp> CStream::CStream() : m_nMode(GENERIC_NONE) , m_nFormat(0) , m_nVersion(0) { } CStream::~CStream() { } template<typename CharT> size_t CStream::ReadLine(std::vector<CharT>& vBuffer) { if (!IsEOF()) { CharT cChar; do { Read(&cChar, sizeof(CharT)); if ( (cChar != '\r') && (cChar != '\n') ) vBuffer.push_back(cChar); } while ( (!IsEOF()) && (cChar != '\r') && (cChar != '\n') ); if ( (!IsEOF()) && (cChar == '\r') ) Read(&cChar, sizeof(CharT)); } return vBuffer.size(); } CString CStream::ReadLine(TextFormat eFormat) { CString strLine; if (eFormat == ANSI_TEXT) { std::vector<char> vBuffer; if (ReadLine(vBuffer) == 0) return TXT(""); size_t nChars = vBuffer.size(); const char* pszBegin = &vBuffer.front(); const char* pszEnd = pszBegin + nChars; strLine.BufferSize(nChars+1); #ifdef ANSI_BUILD std::copy(pszBegin, pszEnd, strLine.Buffer()); #else Core::ansiToWide(pszBegin, pszEnd, strLine.Buffer()); #endif strLine[nChars] = TXT('\0'); } else { std::vector<wchar_t> vBuffer; if (ReadLine(vBuffer) == 0) return TXT(""); size_t nChars = vBuffer.size(); const wchar_t* pszBegin = &vBuffer.front(); const wchar_t* pszEnd = pszBegin + nChars; strLine.BufferSize(nChars+1); #ifdef ANSI_BUILD Core::wideToAnsi(pszBegin, pszEnd, strLine.Buffer()); #else std::copy(pszBegin, pszEnd, strLine.Buffer()); #endif strLine[nChars] = TXT('\0'); } return strLine; } void CStream::WriteLine(const CString& str, TextFormat eFormat) { size_t nChars = str.Length(); if (eFormat == ANSI_TEXT) { #ifdef ANSI_BUILD Write(str.Buffer(), Core::numBytes<char>(nChars)); #else Write(T2A(str), Core::numBytes<char>(nChars)); #endif Write("\r\n", Core::numBytes<char>(2)); } else { #ifdef ANSI_BUILD Write(T2W(str), Core::numBytes<wchar_t>(nChars)); #else Write(str.Buffer(), Core::numBytes<wchar_t>(nChars)); #endif Write(L"\r\n", Core::numBytes<wchar_t>(2)); } } uint32 CStream::Format() const { return m_nFormat; } void CStream::SetFormat(uint32 nFormat) { m_nFormat = nFormat; } uint32 CStream::Version() const { return m_nVersion; } void CStream::SetVersion(uint32 nVersion) { m_nVersion = nVersion; }
#include "Common.hpp" #include "Stream.hpp" #include <Core/AnsiWide.hpp> CStream::CStream() : m_nMode(GENERIC_NONE) , m_nFormat(0) , m_nVersion(0) { } CStream::~CStream() { } template<typename CharT> size_t CStream::ReadLine(std::vector<CharT>& vBuffer) { if (!IsEOF()) { CharT cChar; do { Read(&cChar, sizeof(CharT)); if ( (cChar != '\r') && (cChar != '\n') ) vBuffer.push_back(cChar); } while ( (!IsEOF()) && (cChar != '\r') && (cChar != '\n') ); if ( (!IsEOF()) && (cChar == '\r') ) Read(&cChar, sizeof(CharT)); } return vBuffer.size(); } CString CStream::ReadLine(TextFormat eFormat) { CString strLine; if (eFormat == ANSI_TEXT) { std::vector<char> vBuffer; if (ReadLine(vBuffer) == 0) return TXT(""); size_t nChars = vBuffer.size(); const char* pszBegin = &vBuffer.front(); const char* pszEnd = pszBegin + nChars; strLine.BufferSize(nChars+1); #ifdef ANSI_BUILD std::copy(pszBegin, pszEnd, strLine.Buffer()); #else Core::ansiToWide(pszBegin, pszEnd, strLine.Buffer()); #endif strLine[nChars] = TXT('\0'); } else { std::vector<wchar_t> vBuffer; if (ReadLine(vBuffer) == 0) return TXT(""); size_t nChars = vBuffer.size(); const wchar_t* pszBegin = &vBuffer.front(); const wchar_t* pszEnd = pszBegin + nChars; strLine.BufferSize(nChars+1); #ifdef ANSI_BUILD Core::wideToAnsi(pszBegin, pszEnd, strLine.Buffer()); #else std::copy(pszBegin, pszEnd, strLine.Buffer()); #endif strLine[nChars] = TXT('\0'); } return strLine; }
uint32 CStream::Format() const { return m_nFormat; } void CStream::SetFormat(uint32 nFormat) { m_nFormat = nFormat; } uint32 CStream::Version() const { return m_nVersion; } void CStream::SetVersion(uint32 nVersion) { m_nVersion = nVersion; }
void CStream::WriteLine(const CString& str, TextFormat eFormat) { size_t nChars = str.Length(); if (eFormat == ANSI_TEXT) { #ifdef ANSI_BUILD Write(str.Buffer(), Core::numBytes<char>(nChars)); #else Write(T2A(str), Core::numBytes<char>(nChars)); #endif Write("\r\n", Core::numBytes<char>(2)); } else { #ifdef ANSI_BUILD Write(T2W(str), Core::numBytes<wchar_t>(nChars)); #else Write(str.Buffer(), Core::numBytes<wchar_t>(nChars)); #endif Write(L"\r\n", Core::numBytes<wchar_t>(2)); } }
function_block-full_function
[ { "content": "class CString\n\n{\n\npublic:\n\n\t//\n\n\t// Constructors/Destructor.\n\n\t//\n\n\tCString();\n\n\tCString(uint iRscID);\n\n\tCString(const tchar* pszBuffer);\n\n\tCString(const tchar* pszBuffer, size_t iChars);\n\n\tCString(const CString& strSrc);\n\n\t~CString();\n\n\n\n\tvoid BufferSize(size_t...
C++
libraries/AD520X/AD520X.cpp
AndreTeixeira1998/Arduino
16918bada3cf9dfee0f6baa72ee1de87602b84ca
#include "AD520X.h" AD520X::AD520X(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) { _pmCount = 6; _select = select; _dataOut = dataOut; _clock = clock; _reset = reset; _shutdown = shutdown; _hwSPI = (dataOut == 255) && (clock == 255); } void AD520X::begin(uint8_t value) { pinMode(_select, OUTPUT); digitalWrite(_select, HIGH); pinMode(_reset, OUTPUT); digitalWrite(_reset, LOW); pinMode(_shutdown, OUTPUT); digitalWrite(_shutdown, LOW); _spi_settings = SPISettings(_SPIspeed, MSBFIRST, SPI_MODE1); if(_hwSPI) { #if defined(ESP32) if (_useHSPI) { mySPI = new SPIClass(HSPI); mySPI->end(); mySPI->begin(14, 12, 13, _select); } else { mySPI = new SPIClass(VSPI); mySPI->end(); mySPI->begin(18, 19, 23, _select); } #else mySPI = &SPI; mySPI->end(); mySPI->begin(); #endif delay(1); } else { pinMode(_dataOut, OUTPUT); pinMode(_clock, OUTPUT); digitalWrite(_dataOut, LOW); digitalWrite(_clock, LOW); } setAll(value); } #if defined(ESP32) void AD520X::setGPIOpins(uint8_t clk, uint8_t miso, uint8_t mosi, uint8_t select) { _clock = clk; _dataOut = mosi; _select = select; pinMode(_select, OUTPUT); digitalWrite(_select, HIGH); mySPI->end(); mySPI->begin(clk, miso, mosi, select); } #endif bool AD520X::setValue(uint8_t pm, uint8_t value) { if (pm >= _pmCount) return false; _value[pm] = value; updateDevice(pm); return true; } void AD520X::setAll(uint8_t value) { for (uint8_t pm = 0; pm < _pmCount; pm++) { setValue(pm, value); } } uint8_t AD520X::getValue(uint8_t pm) { if (pm >= _pmCount) return 0; return _value[pm]; } bool AD520X::setPercentage(uint8_t pm, float percentage) { if ((percentage < 0) || (percentage > 100.0)) return false; return setValue(pm, round(percentage * (255.0 / 100.0))); } float AD520X::getPercentage(uint8_t pm) { if (pm >= _pmCount) return 0; uint8_t v = _value[pm]; if (v == 0) return 0.0; return (100.0 / 255.0) * v; } void AD520X::reset(uint8_t value) { digitalWrite(_reset, HIGH); digitalWrite(_reset, LOW); setAll(value); } void AD520X::setSPIspeed(uint32_t speed) { _SPIspeed = speed; _spi_settings = SPISettings(_SPIspeed, MSBFIRST, SPI_MODE1); }; void AD520X::updateDevice(uint8_t pm) { digitalWrite(_select, LOW); if (_hwSPI) { mySPI->beginTransaction(_spi_settings); mySPI->transfer(pm); mySPI->transfer(_value[pm]); mySPI->endTransaction(); } else { swSPI_transfer(pm); swSPI_transfer(_value[pm]); } digitalWrite(_select, HIGH); } void AD520X::swSPI_transfer(uint8_t val) { uint8_t clk = _clock; uint8_t dao = _dataOut; for (uint8_t mask = 0x80; mask; mask >>= 1) { digitalWrite(dao,(val & mask)); digitalWrite(clk, HIGH); digitalWrite(clk, LOW); } } AD5206::AD5206(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 6; } AD5204::AD5204(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 4; } AD8403::AD8403(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 4; } AD8402::AD8402(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 2; } AD8400::AD8400(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 1; }
#include "AD520X.h" AD520X::AD520X(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) { _pmCount = 6; _select = select; _dataOut = dataOut; _clock = clock; _reset = reset; _shutdown = shutdown; _hwSPI = (dataOut == 255) && (clock == 255); } void AD520X::begin(uint8_t value) { pinMode(_select, OUTPUT); digitalWrite(_select, HIGH); pinMode(_reset, OUTPUT); digitalWrite(_reset, LOW); pinMode(_shutdown, OUTPUT); digitalWrite(_shutdown, LOW); _spi_settings = SPISettings(_SPIspeed, MSBFIRST, SPI_MODE1); if(_hwSPI) { #if defined(ESP32) if (_useHSPI) { mySPI = new SPIClass(HSPI); mySPI->end(); mySPI->begin(14, 12, 13, _select); } else { mySPI = new SPIClass(VSPI); mySPI->end(); mySPI->begin(18, 19, 23, _select); } #else mySPI = &SPI; mySPI->end(); mySPI->begin(); #endif delay(1); } else { pinMode(_dataOut, OUTPUT); pinMode(_clock, OUTPUT); digitalWrite(_dataOut, LOW); digitalWrite(_clock, LOW); } setAll(value); } #if defined(ESP32)
#endif bool AD520X::setValue(uint8_t pm, uint8_t value) { if (pm >= _pmCount) return false; _value[pm] = value; updateDevice(pm); return true; } void AD520X::setAll(uint8_t value) { for (uint8_t pm = 0; pm < _pmCount; pm++) { setValue(pm, value); } } uint8_t AD520X::getValue(uint8_t pm) { if (pm >= _pmCount) return 0; return _value[pm]; } bool AD520X::setPercentage(uint8_t pm, float percentage) { if ((percentage < 0) || (percentage > 100.0)) return false; return setValue(pm, round(percentage * (255.0 / 100.0))); } float AD520X::getPercentage(uint8_t pm) { if (pm >= _pmCount) return 0; uint8_t v = _value[pm]; if (v == 0) return 0.0; return (100.0 / 255.0) * v; } void AD520X::reset(uint8_t value) { digitalWrite(_reset, HIGH); digitalWrite(_reset, LOW); setAll(value); } void AD520X::setSPIspeed(uint32_t speed) { _SPIspeed = speed; _spi_settings = SPISettings(_SPIspeed, MSBFIRST, SPI_MODE1); }; void AD520X::updateDevice(uint8_t pm) { digitalWrite(_select, LOW); if (_hwSPI) { mySPI->beginTransaction(_spi_settings); mySPI->transfer(pm); mySPI->transfer(_value[pm]); mySPI->endTransaction(); } else { swSPI_transfer(pm); swSPI_transfer(_value[pm]); } digitalWrite(_select, HIGH); } void AD520X::swSPI_transfer(uint8_t val) { uint8_t clk = _clock; uint8_t dao = _dataOut; for (uint8_t mask = 0x80; mask; mask >>= 1) { digitalWrite(dao,(val & mask)); digitalWrite(clk, HIGH); digitalWrite(clk, LOW); } } AD5206::AD5206(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 6; } AD5204::AD5204(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 4; } AD8403::AD8403(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 4; } AD8402::AD8402(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 2; } AD8400::AD8400(uint8_t select, uint8_t reset, uint8_t shutdown, uint8_t dataOut, uint8_t clock) : AD520X(select, reset, shutdown, dataOut, clock) { _pmCount = 1; }
void AD520X::setGPIOpins(uint8_t clk, uint8_t miso, uint8_t mosi, uint8_t select) { _clock = clk; _dataOut = mosi; _select = select; pinMode(_select, OUTPUT); digitalWrite(_select, HIGH); mySPI->end(); mySPI->begin(clk, miso, mosi, select); }
function_block-function_prefix_line
[ { "content": "class MS5611_SPI\n\n{\n\npublic:\n\n explicit MS5611_SPI(uint8_t select, uint8_t dataOut = 255, uint8_t dataIn = 255, uint8_t clock = 255);\n\n\n\n bool begin();\n\n\n\n // reset command + get constants\n\n // returns false if ROM constants == 0;\n\n bool reset();\n\n\n\n // the actu...
C++
src/particle_subscriber.cpp
tstellanova/particle_subscriber
175440928aaa8d9d92299787ecac352758171d2c
#include <Particle.h> #include <Adafruit_SSD1306_RK.h> #include <Adafruit_GFX_RK.h> void evt_doorbell_handler(const char *event, const char *data); int render_string(String command); int tone_test(String name); void blank_screen(); void oneshot_timer_cb(); const uint8_t SCREEN_WIDTH = 128; const uint8_t SCREEN_HEIGHT = 64; const uint16_t SPKR_PIN = D3; const unsigned int TONE_A4 = 440; const unsigned int TONE_B4 = 494; const unsigned int TONE_C4 = 262; const unsigned int TONE_D4 = 294; const unsigned int TONE_E4 = 330; const unsigned int TONE_F4 = 349; const unsigned int TONE_G4 = 392; const int NOTE_DURATION_MS = 500; static bool g_clear_screen = false; static bool g_playing_tones = false; static Timer g_screen_cleanup_timer(30000, oneshot_timer_cb, true); Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire); SystemSleepConfiguration g_sleep_config; SerialLogHandler logHandler(LOG_LEVEL_WARN, { { "app", LOG_LEVEL_INFO } }); void sync_play_tone(unsigned int frequency, int milliseconds) { if (frequency != 0) { tone(SPKR_PIN, frequency, milliseconds); } else { noTone(SPKR_PIN); } Particle.process(); delay(milliseconds); } void play_bell_tone() { if (!g_playing_tones) { g_playing_tones = true; for (int count= 0; count < 2; count++) { sync_play_tone(2*TONE_D4, NOTE_DURATION_MS); sync_play_tone(2*TONE_E4, NOTE_DURATION_MS); sync_play_tone(2*TONE_C4, NOTE_DURATION_MS); sync_play_tone(TONE_C4, NOTE_DURATION_MS); sync_play_tone(TONE_G4, 2*NOTE_DURATION_MS); sync_play_tone(0, 2*NOTE_DURATION_MS); } noTone(SPKR_PIN); g_playing_tones = false; } } void play_wakeup_tones() { sync_play_tone(TONE_C4, NOTE_DURATION_MS); sync_play_tone((2*TONE_C4), NOTE_DURATION_MS); sync_play_tone(TONE_C4, NOTE_DURATION_MS); sync_play_tone((2*TONE_C4), NOTE_DURATION_MS); noTone(SPKR_PIN); } void evt_doorbell_handler(const char *event, const char *data) { Log.info(event); render_string("DOOR"); play_bell_tone(); g_screen_cleanup_timer.reset(); g_screen_cleanup_timer.start(); } void oneshot_timer_cb() { g_clear_screen = true; } void blank_screen() { display.clearDisplay(); display.display(); } int render_string(String command) { display.clearDisplay(); display.setTextColor(WHITE); display.setCursor(4, 4); display.setTextSize(4); display.println(command); display.display(); delay(5000); return 0; } int tone_test(String name) { if (name.equalsIgnoreCase("bell")) { play_bell_tone(); } else if (name.equalsIgnoreCase("wakeup")) { play_wakeup_tones(); } return 0; } void display_setup() { delay(250); if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { Log.error("SSD1306 allocation failed"); } display.clearDisplay(); display.display(); delay(2000); } void setup() { pinMode(SPKR_PIN, OUTPUT); Particle.syncTime(); Particle.function("render",render_string); Particle.function("tone_test",tone_test); Particle.subscribe("household/frontdoor/bell01", evt_doorbell_handler); Log.info("My device ID: %s", (const char*)System.deviceID()); Particle.publishVitals(120); display_setup(); play_wakeup_tones(); } void loop() { delay(5000); Particle.process(); if (g_clear_screen) { g_clear_screen = false; blank_screen(); } }
#include <Particle.h> #include <Adafruit_SSD1306_RK.h> #include <Adafruit_GFX_RK.h> void evt_doorbell_handler(const char *event, const char *data); int render_string(String command); int tone_test(String name); void blank_screen(); void oneshot_timer_cb(); const uint8_t SCREEN_WIDTH = 128; const uint8_t SCREEN_HEIGHT = 64; const uint16_t SPKR_PIN = D3; const unsigned int TONE_A4 = 440; const unsigned int TONE_B4 = 494; const unsigned int TONE_C4 = 262; const unsigned int TONE_D4 = 294; const unsigned int TONE_E4 = 330; const unsigned int TONE_F4 = 349; const unsigned int TONE_G4 = 392; const int NOTE_DURATION_MS = 500; static bool g_clear_screen = false; static bool g_playing_tones = false; static Timer g_screen_cleanup_timer(30000, oneshot_timer_cb, true); Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire); SystemSleepConfiguration g_sleep_config; SerialLogHandler logHandler(LOG_LEVEL_WARN, { { "app", LOG_LEVEL_INFO } }); void sync_play_tone(unsigned int frequency, int milliseconds) { if (frequency != 0) { tone(SPKR_PIN, frequency, milliseconds); } else { noTone(SPKR_PIN); } Particle.process(); delay(milliseconds); } void play_bell_tone() { if (!g_playing_tones) { g_playing_tones = true; for (int count= 0; count < 2; count++) { sync_play_tone(2*TONE_D4, NOTE_DURATION_MS); sync_play_tone(2*TONE_E4, NOTE_DURATION_MS); sync_play_tone(2*TONE_C4, NOTE_DURATION_MS); sync_play_tone(TONE_C4, NOTE_DURATION_MS); sync_play_tone(TONE_G4, 2*NOTE_DURATION_MS); sync_play_tone(0, 2*NOTE_DURATION_MS); } noTone(SPKR_PIN); g_playing_tones = false; } } void play_wakeup_tones() { sync_play_tone(TONE_C4, NOTE_DURATION_MS); sync_play_tone((2*TONE_C4), NOTE_DURATION_MS); sync_play_tone(TONE_C4, NOTE_DURATION_MS); sync_play_tone((2*TONE_C4), NOTE_DURATION_MS); noTone(SPKR_PIN); } void evt_doorbell_handler(const char *event, const char *data) { Log.info(event); render_string("DOOR"); play_bell_tone(); g_screen_cleanup_timer.reset(); g_screen_cleanup_timer.start(); } void oneshot_timer_cb() { g_clear_screen = true; } void blank_screen() { display.clearDisplay(); display.display(); } int render_string(String command) { display.clearDisplay(); display.setTextColor(WHITE); display.setCursor(4, 4); display.setTextSize(4); display.println(command); display.display(); delay(5000); return 0; } int tone_test(String name) { if (name.equalsIgnoreCase("bell")) { play_bell_tone(); } else if (name.equalsIgnoreCase("wakeup")) { play_wakeup_tones(); } return 0; } void display_setup() { delay(250); if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { Log.error("SSD1306 allocation failed"); } display.clearDisplay(); display.display(); delay(2000); } void setup() { pinMode(SPKR_PIN, OUTPU
void loop() { delay(5000); Particle.process(); if (g_clear_screen) { g_clear_screen = false; blank_screen(); } }
T); Particle.syncTime(); Particle.function("render",render_string); Particle.function("tone_test",tone_test); Particle.subscribe("household/frontdoor/bell01", evt_doorbell_handler); Log.info("My device ID: %s", (const char*)System.deviceID()); Particle.publishVitals(120); display_setup(); play_wakeup_tones(); }
function_block-function_prefixed
[]
C++
src/Cropper.cpp
stippi/WonderBrush-v3
7f88c3e4fbe0bca9ef2df7a92d44789877edfe1e
#include "Cropper.h" #include <Bitmap.h> #include <BitmapStream.h> #include <Directory.h> #include <File.h> #include <Rect.h> #include <TranslationUtils.h> #include <TranslatorRoster.h> #include "RenderBuffer.h" #include "RenderEngine.h" Cropper::Cropper() : BApplication("application/x-vnd.yellowbites.Cropper") , fPrintUsage(true) , fTargetWidth(-1) , fTargetHeight(-1) , fTargetFolder("/boot/home/Desktop") , fTargetFormat(B_JPEG_FORMAT) { } void Cropper::MessageReceived(BMessage* message) { switch (message->what) { default: BApplication::MessageReceived(message); break; } } void Cropper::ReadyToRun() { if (fPrintUsage) _PrintUsage("Cropper"); PostMessage(B_QUIT_REQUESTED); } void Cropper::ArgvReceived(int32 argc, char** argv) { fPrintUsage = false; int32 i = 1; for (; i < argc; i++) { if (strcmp(argv[i], "-o") == 0) { if (i == argc - 1) break; fTargetFolder = argv[++i]; } else if (strcmp(argv[i], "-w") == 0) { if (i == argc - 1) break; fTargetWidth = atoi(argv[++i]); } else if (strcmp(argv[i], "-h") == 0) { if (i == argc - 1) break; fTargetHeight = atoi(argv[++i]); } else if (strcmp(argv[i], "-f") == 0) { if (i == argc - 1) break; const char* name = argv[++i]; bool found = false; BTranslatorRoster* roster = BTranslatorRoster::Default(); translator_id* translatorIDs; int32 idCount; roster->GetAllTranslators(&translatorIDs, &idCount); for (int32 t = 0; t < idCount; t++) { const translation_format* formats; int32 formatCount; roster->GetOutputFormats(translatorIDs[t], &formats, &formatCount); for (int32 f = 0; f < formatCount; f++) { if (formats[f].group != B_TRANSLATOR_BITMAP) continue; if (formats[f].type == B_TRANSLATOR_BITMAP) continue; if (strcmp(formats[f].name, name) == 0) { fTargetFormat = formats[f].type; found = true; break; } } if (found) break; } if (!found) { printf("Did not find translator \"%s\". Use -l to " "list available transators.\n", name); return; } delete[] translatorIDs; } else if (strcmp(argv[i], "-l") == 0) { BTranslatorRoster* roster = BTranslatorRoster::Default(); translator_id* translatorIDs; int32 idCount; roster->GetAllTranslators(&translatorIDs, &idCount); printf("Available formats:\n"); for (int32 t = 0; t < idCount; t++) { const translation_format* formats; int32 formatCount; roster->GetOutputFormats(translatorIDs[t], &formats, &formatCount); for (int32 f = 0; f < formatCount; f++) { if (formats[f].group != B_TRANSLATOR_BITMAP) continue; if (formats[f].type == B_TRANSLATOR_BITMAP) continue; printf(" \"%s\"\n", formats[f].name); } } delete[] translatorIDs; return; } else break; } if (i == argc) { _PrintUsage(argv[0]); return; } create_directory(fTargetFolder.Path(), 0777); for (; i < argc; i++) { BPath path(argv[i]); BBitmap* original = BTranslationUtils::GetBitmap(path.Path()); if (original == NULL) { fprintf(stderr, "Failed to load '%s'\n", argv[i]); continue; } int width = original->Bounds().IntegerWidth() + 1; if (fTargetWidth > 0 && fTargetWidth < width) width = fTargetWidth; int height = original->Bounds().IntegerHeight() + 1; if (fTargetHeight > 0 && fTargetWidth < height) height = fTargetHeight; _CropImage(original, width, height, fTargetFolder, argv[i]); delete original; } } void Cropper::RefsReceived(BMessage* message) { printf("Cropper::RefsReceived()\n"); } void Cropper::_PrintUsage(const char* appPath) { printf("Usage: %s -o <target folder> -f <translator> -w <width> -h <height> [image files]\n", appPath); printf(" -o - The target folder to place the resized images in.\n"); printf(" -w - The width of the resulting images. No horizontal cropping if ommited.\n"); printf(" -h - The height of the resulting images. No vertical cropping if ommited.\n"); printf(" -f - Use the specified translator.\n"); printf("Usage: %s -l\n", appPath); printf(" -l - List all available translators.\n"); } status_t Cropper::_CropImage(const BBitmap* bitmap, int width, int height, BPath path, const char* originalPath) const { BRect croppedRect(0, 0, width - 1, height - 1); BBitmap* resultBitmap = new BBitmap(croppedRect, B_BITMAP_NO_SERVER_LINK, B_RGBA32); status_t ret = resultBitmap->InitCheck(); if (ret != B_OK) { fprintf(stderr, "Failed to create bitmap: %s\n", strerror(ret)); delete bitmap; return ret; } uint8* src = (uint8*)bitmap->Bits(); uint8* dst = (uint8*)resultBitmap->Bits(); uint32 srcBPR = bitmap->BytesPerRow(); uint32 dstBPR = resultBitmap->BytesPerRow(); uint32 bytes = width * 4; for (int y = 0; y < height; y++) { memcpy(dst, src, bytes); src += srcBPR; dst += dstBPR; } BBitmapStream bitmapStream(resultBitmap); BString name(originalPath); name.Remove(0, name.FindLast('/') + 1); path.Append(name); BFile file(path.Path(), B_CREATE_FILE | B_ERASE_FILE | B_READ_WRITE); if (file.InitCheck() != B_OK) { fprintf(stderr, "Failed to create file '%s': %s\n", path.Path(), strerror(file.InitCheck())); return file.InitCheck(); } BTranslatorRoster* roster = BTranslatorRoster::Default(); ret = roster->Translate(&bitmapStream, NULL, NULL, &file, fTargetFormat); if (ret != B_OK) { fprintf(stderr, "Failed to translate file '%s': %s\n", path.Path(), strerror(ret)); return ret; } return B_OK; } int main(int argc, const char* argv[]) { Cropper app; app.Run(); return 0; }
#include "Cropper.h" #include <Bitmap.h> #include <BitmapStream.h> #include <Directory.h> #include <File.h> #include <Rect.h> #include <TranslationUtils.h> #include <TranslatorRoster.h> #include "RenderBuffer.h" #include "RenderEngine.h" Cropper::Cropper() : BApplication("application/x-vnd.yellowbites.Cropper") , f
roppedRect, B_BITMAP_NO_SERVER_LINK, B_RGBA32); status_t ret = resultBitmap->InitCheck(); if (ret != B_OK) { fprintf(stderr, "Failed to create bitmap: %s\n", strerror(ret)); delete bitmap; return ret; } uint8* src = (uint8*)bitmap->Bits(); uint8* dst = (uint8*)resultBitmap->Bits(); uint32 srcBPR = bitmap->BytesPerRow(); uint32 dstBPR = resultBitmap->BytesPerRow(); uint32 bytes = width * 4; for (int y = 0; y < height; y++) { memcpy(dst, src, bytes); src += srcBPR; dst += dstBPR; } BBitmapStream bitmapStream(resultBitmap); BString name(originalPath); name.Remove(0, name.FindLast('/') + 1); path.Append(name); BFile file(path.Path(), B_CREATE_FILE | B_ERASE_FILE | B_READ_WRITE); if (file.InitCheck() != B_OK) { fprintf(stderr, "Failed to create file '%s': %s\n", path.Path(), strerror(file.InitCheck())); return file.InitCheck(); } BTranslatorRoster* roster = BTranslatorRoster::Default(); ret = roster->Translate(&bitmapStream, NULL, NULL, &file, fTargetFormat); if (ret != B_OK) { fprintf(stderr, "Failed to translate file '%s': %s\n", path.Path(), strerror(ret)); return ret; } return B_OK; } int main(int argc, const char* argv[]) { Cropper app; app.Run(); return 0; }
PrintUsage(true) , fTargetWidth(-1) , fTargetHeight(-1) , fTargetFolder("/boot/home/Desktop") , fTargetFormat(B_JPEG_FORMAT) { } void Cropper::MessageReceived(BMessage* message) { switch (message->what) { default: BApplication::MessageReceived(message); break; } } void Cropper::ReadyToRun() { if (fPrintUsage) _PrintUsage("Cropper"); PostMessage(B_QUIT_REQUESTED); } void Cropper::ArgvReceived(int32 argc, char** argv) { fPrintUsage = false; int32 i = 1; for (; i < argc; i++) { if (strcmp(argv[i], "-o") == 0) { if (i == argc - 1) break; fTargetFolder = argv[++i]; } else if (strcmp(argv[i], "-w") == 0) { if (i == argc - 1) break; fTargetWidth = atoi(argv[++i]); } else if (strcmp(argv[i], "-h") == 0) { if (i == argc - 1) break; fTargetHeight = atoi(argv[++i]); } else if (strcmp(argv[i], "-f") == 0) { if (i == argc - 1) break; const char* name = argv[++i]; bool found = false; BTranslatorRoster* roster = BTranslatorRoster::Default(); translator_id* translatorIDs; int32 idCount; roster->GetAllTranslators(&translatorIDs, &idCount); for (int32 t = 0; t < idCount; t++) { const translation_format* formats; int32 formatCount; roster->GetOutputFormats(translatorIDs[t], &formats, &formatCount); for (int32 f = 0; f < formatCount; f++) { if (formats[f].group != B_TRANSLATOR_BITMAP) continue; if (formats[f].type == B_TRANSLATOR_BITMAP) continue; if (strcmp(formats[f].name, name) == 0) { fTargetFormat = formats[f].type; found = true; break; } } if (found) break; } if (!found) { printf("Did not find translator \"%s\". Use -l to " "list available transators.\n", name); return; } delete[] translatorIDs; } else if (strcmp(argv[i], "-l") == 0) { BTranslatorRoster* roster = BTranslatorRoster::Default(); translator_id* translatorIDs; int32 idCount; roster->GetAllTranslators(&translatorIDs, &idCount); printf("Available formats:\n"); for (int32 t = 0; t < idCount; t++) { const translation_format* formats; int32 formatCount; roster->GetOutputFormats(translatorIDs[t], &formats, &formatCount); for (int32 f = 0; f < formatCount; f++) { if (formats[f].group != B_TRANSLATOR_BITMAP) continue; if (formats[f].type == B_TRANSLATOR_BITMAP) continue; printf(" \"%s\"\n", formats[f].name); } } delete[] translatorIDs; return; } else break; } if (i == argc) { _PrintUsage(argv[0]); return; } create_directory(fTargetFolder.Path(), 0777); for (; i < argc; i++) { BPath path(argv[i]); BBitmap* original = BTranslationUtils::GetBitmap(path.Path()); if (original == NULL) { fprintf(stderr, "Failed to load '%s'\n", argv[i]); continue; } int width = original->Bounds().IntegerWidth() + 1; if (fTargetWidth > 0 && fTargetWidth < width) width = fTargetWidth; int height = original->Bounds().IntegerHeight() + 1; if (fTargetHeight > 0 && fTargetWidth < height) height = fTargetHeight; _CropImage(original, width, height, fTargetFolder, argv[i]); delete original; } } void Cropper::RefsReceived(BMessage* message) { printf("Cropper::RefsReceived()\n"); } void Cropper::_PrintUsage(const char* appPath) { printf("Usage: %s -o <target folder> -f <translator> -w <width> -h <height> [image files]\n", appPath); printf(" -o - The target folder to place the resized images in.\n"); printf(" -w - The width of the resulting images. No horizontal cropping if ommited.\n"); printf(" -h - The height of the resulting images. No vertical cropping if ommited.\n"); printf(" -f - Use the specified translator.\n"); printf("Usage: %s -l\n", appPath); printf(" -l - List all available translators.\n"); } status_t Cropper::_CropImage(const BBitmap* bitmap, int width, int height, BPath path, const char* originalPath) const { BRect croppedRect(0, 0, width - 1, height - 1); BBitmap* resultBitmap = new BBitmap(c
random
[ { "content": " class GradientF, \n", "file_path": "src/agg/include/agg_span_gradient.h", "rank": 0, "score": 99143.10744643904 }, { "content": " class ColorF>\n", "file_path": "src/agg/include/agg_span_gradient.h", "rank": 1, "score": 99143.10744643904 }...
C++
kernel/arch/amd64/mp/mp.cpp
griwes/reaveros
01cc1be330e920d45445db32e44eb4b91491f36c
#include "mp.h" #include "../../../memory/vm.h" #include "../../../scheduler/thread.h" #include "../../../time/time.h" #include "../cpu/cpu.h" #include "../cpu/lapic.h" #include "../memory/vm.h" #include <cstddef> #include <cstdint> extern "C" std::uint8_t trampoline_start[]; extern "C" std::uint8_t trampoline_end[]; extern "C" std::uint8_t trampoline_asid_slot[]; extern "C" std::uint8_t trampoline_stack_slot[]; extern "C" std::uint8_t trampoline_flag_slot[]; namespace kernel::amd64::mp { void boot() { log::println("[CPU] Booting APs..."); auto trampoline_size = trampoline_end - trampoline_start; trampoline_size += 4095; trampoline_size &= ~4095ull; auto asid_slot_offset = trampoline_asid_slot - trampoline_start; auto stack_slot_offset = trampoline_stack_slot - trampoline_start; auto flag_slot_offset = trampoline_flag_slot - trampoline_start; auto & core_count = cpu::detail_for_mp::get_core_count_ref(); auto cores = cpu::detail_for_mp::get_core_array(); for (std::size_t i = 0; i < core_count; ++i) { auto apic_id = cores[i].apic_id(); if (apic_id == cpu::get_current_core()->apic_id()) { continue; } log::println(" > Sending INIT IPI to core #{} (APIC ID: {})...", i, apic_id); lapic::ipi(apic_id, lapic::ipi_type::init, 0); } volatile bool timer_triggered = false; auto handler = +[](volatile bool * flag) { *flag = true; }; using namespace std::literals; time::get_high_precision_timer().one_shot(10ms, handler, &timer_triggered); asm volatile("sti"); while (!timer_triggered) { asm volatile("hlt"); } timer_triggered = false; auto base_raw = pmm::get_sub_1M_bottom(); base_raw = base_raw ? base_raw : 0x1000; auto top = pmm::get_sub_1M_top(); auto base = phys_ptr_t<std::uint8_t>(phys_addr_t(base_raw)); log::println(" > Using memory range from {:#010x} to {:#010x}.", base_raw, top); vm::map_physical(virt_addr_t(base_raw), virt_addr_t(top), phys_addr_t(base_raw)); auto boot_at_once = (top - base_raw) / trampoline_size; for (std::size_t booted = 0; booted < core_count; booted += boot_at_once) { for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { if (cores[i].apic_id() == cpu::get_current_core()->apic_id()) { continue; } std::memcpy((base + trampoline_size * (i - booted)).value(), trampoline_start, trampoline_size); *phys_ptr_t<std::uint64_t>(base + trampoline_size * (i - booted) + asid_slot_offset) = vm::get_asid().value(); cores[i]._boot_flag = const_cast<volatile std::uint8_t *>( (base + trampoline_size * (i - booted) + flag_slot_offset).value()); auto stack = kernel::vm::allocate_address_range(32 * 4096); for (int j = 1; j < 32; ++j) { vm::map_physical(stack + j * 4096, stack + (j + 1) * 4096, pmm::pop(0)); } *phys_ptr_t<std::uint64_t>(base + trampoline_size * (i - booted) + stack_slot_offset) = (stack + 32 * 1024).value(); } for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { auto apic_id = cores[i].apic_id(); if (apic_id == cpu::get_current_core()->apic_id()) { continue; } log::println(" > Sending Startup IPI to core #{} (APIC ID: {})...", i, apic_id); lapic::ipi(apic_id, lapic::ipi_type::sipi, (0x1000 + trampoline_size * (i - booted)) >> 12); } time::get_high_precision_timer().one_shot(500us, handler, &timer_triggered); while (!timer_triggered) { asm volatile("hlt"); } timer_triggered = false; for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { auto apic_id = cores[i].apic_id(); if (apic_id == cpu::get_current_core()->apic_id()) { continue; } if (!*(cores[i]._boot_flag)) { log::println(" > Sending secondary Startup IPI to core #{} (APIC ID: {})...", i, apic_id); lapic::ipi(apic_id, lapic::ipi_type::sipi, (0x1000 + trampoline_size * (i - booted)) >> 12); } } time::get_high_precision_timer().one_shot(500us, handler, &timer_triggered); while (!timer_triggered) { asm volatile("hlt"); } timer_triggered = false; for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { if (cores[i].apic_id() == cpu::get_current_core()->apic_id()) { continue; } if (*(cores[i]._boot_flag)) { log::println(" > CPU #{} (APIC ID: {}) started up...", i, cores[i].apic_id()); while (*cores[i]._boot_flag != 2) { asm volatile("pause"); } log::println(" > CPU #{} (APIC ID: {}) booted successfully.", i, cores[i].apic_id()); cores[i]._id = i; } else { log::println(" > CPU#{} failed to boot!", cores[i].apic_id()); for (std::size_t j = i; j < core_count - 1; ++j) { log::println( " > Moving CPU #{} (APIC ID: {}) into place of CPU #{} (APIC ID: {}).", j + 1, cores[j + 1].apic_id(), j, cores[j].apic_id()); cores[j] = cores[j + 1]; } --i; --core_count; --booted; } } } for (std::size_t i = 0; i < core_count; ++i) { if (cores[i].apic_id() == cpu::get_current_core()->apic_id()) { cores[i]._id = i; break; } } vm::unmap(virt_addr_t(base_raw), virt_addr_t(top), false); } }
#include "mp.h" #include "../../../memory/vm.h" #include "../../../scheduler/thread.h" #include "../../../time/time.h" #include "../cpu/cpu.h" #include "../cpu/lapic.h" #include "../memory/vm.h" #include <cstddef> #include <cstdint> extern "C" std::uint8_t trampoline_start[]; extern "C" std::uint8_t trampoline_end[]; extern "C" std::uint8_t trampoline_asid_slot[]; extern "C" std::uint8_t trampoline_stack_slot[]; extern "C" std::uint8_t trampoline_flag_slot[]; namespace kernel::amd64::mp { void boot() { log::println("[CPU] Booting APs..."); auto trampoline_size = trampoline_end - trampoline_start; trampoline_size += 4095; trampoline_size &= ~4095ull; auto asid_slot_offset = trampoline_asid_slot - trampoline_start; auto stack_slot_offset = trampoline_stack_slot - trampoline_start; auto flag_slot_offset = trampoline_flag_slot - trampoline_start; auto & core_count = cpu::detail_for_mp::get_core_count_ref(); auto cores = cpu::detail_for_mp::get_core_array(); for (std::size_t i = 0; i < core_count; ++i) { auto apic_id = cores[i].apic_id(); if (apic_id == cpu::get_current_core()->apic_id()) { continue; } log::println(" > Sending INIT IPI to core #{} (APIC ID: {})...", i, apic_id); lapic::ipi(apic_id, lapic::
ase_raw) / trampoline_size; for (std::size_t booted = 0; booted < core_count; booted += boot_at_once) { for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { if (cores[i].apic_id() == cpu::get_current_core()->apic_id()) { continue; } std::memcpy((base + trampoline_size * (i - booted)).value(), trampoline_start, trampoline_size); *phys_ptr_t<std::uint64_t>(base + trampoline_size * (i - booted) + asid_slot_offset) = vm::get_asid().value(); cores[i]._boot_flag = const_cast<volatile std::uint8_t *>( (base + trampoline_size * (i - booted) + flag_slot_offset).value()); auto stack = kernel::vm::allocate_address_range(32 * 4096); for (int j = 1; j < 32; ++j) { vm::map_physical(stack + j * 4096, stack + (j + 1) * 4096, pmm::pop(0)); } *phys_ptr_t<std::uint64_t>(base + trampoline_size * (i - booted) + stack_slot_offset) = (stack + 32 * 1024).value(); } for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { auto apic_id = cores[i].apic_id(); if (apic_id == cpu::get_current_core()->apic_id()) { continue; } log::println(" > Sending Startup IPI to core #{} (APIC ID: {})...", i, apic_id); lapic::ipi(apic_id, lapic::ipi_type::sipi, (0x1000 + trampoline_size * (i - booted)) >> 12); } time::get_high_precision_timer().one_shot(500us, handler, &timer_triggered); while (!timer_triggered) { asm volatile("hlt"); } timer_triggered = false; for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { auto apic_id = cores[i].apic_id(); if (apic_id == cpu::get_current_core()->apic_id()) { continue; } if (!*(cores[i]._boot_flag)) { log::println(" > Sending secondary Startup IPI to core #{} (APIC ID: {})...", i, apic_id); lapic::ipi(apic_id, lapic::ipi_type::sipi, (0x1000 + trampoline_size * (i - booted)) >> 12); } } time::get_high_precision_timer().one_shot(500us, handler, &timer_triggered); while (!timer_triggered) { asm volatile("hlt"); } timer_triggered = false; for (std::size_t i = booted; i < booted + boot_at_once && i < core_count; ++i) { if (cores[i].apic_id() == cpu::get_current_core()->apic_id()) { continue; } if (*(cores[i]._boot_flag)) { log::println(" > CPU #{} (APIC ID: {}) started up...", i, cores[i].apic_id()); while (*cores[i]._boot_flag != 2) { asm volatile("pause"); } log::println(" > CPU #{} (APIC ID: {}) booted successfully.", i, cores[i].apic_id()); cores[i]._id = i; } else { log::println(" > CPU#{} failed to boot!", cores[i].apic_id()); for (std::size_t j = i; j < core_count - 1; ++j) { log::println( " > Moving CPU #{} (APIC ID: {}) into place of CPU #{} (APIC ID: {}).", j + 1, cores[j + 1].apic_id(), j, cores[j].apic_id()); cores[j] = cores[j + 1]; } --i; --core_count; --booted; } } } for (std::size_t i = 0; i < core_count; ++i) { if (cores[i].apic_id() == cpu::get_current_core()->apic_id()) { cores[i]._id = i; break; } } vm::unmap(virt_addr_t(base_raw), virt_addr_t(top), false); } }
ipi_type::init, 0); } volatile bool timer_triggered = false; auto handler = +[](volatile bool * flag) { *flag = true; }; using namespace std::literals; time::get_high_precision_timer().one_shot(10ms, handler, &timer_triggered); asm volatile("sti"); while (!timer_triggered) { asm volatile("hlt"); } timer_triggered = false; auto base_raw = pmm::get_sub_1M_bottom(); base_raw = base_raw ? base_raw : 0x1000; auto top = pmm::get_sub_1M_top(); auto base = phys_ptr_t<std::uint8_t>(phys_addr_t(base_raw)); log::println(" > Using memory range from {:#010x} to {:#010x}.", base_raw, top); vm::map_physical(virt_addr_t(base_raw), virt_addr_t(top), phys_addr_t(base_raw)); auto boot_at_once = (top - b
random
[ { "content": "/*\n\n * Copyright © 2021 Michał 'Griwes' Dominiak\n\n *\n\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n\n * you may not use this file except in compliance with the License.\n\n * You may obtain a copy of the License at\n\n *\n\n * http://www.apache.org/licenses/LICEN...
C++
fulanghua_ekf_2d/src/pose_estimator.cpp
hoshianaaa/fulanghua_navigation
f6b5f5289c1b27ad45b6db6b6535b01ba4203001
#include <fulanghua_ekf_2d/pose_estimator.h> #include <boost/assign.hpp> #include <Eigen/LU> #include <Eigen/Dense> namespace fulanghua { double normalize_rad(double th) { while(th > M_PI) th -= 2 * M_PI; while(th < -M_PI) th += 2 * M_PI; return th; } PoseEstimator::PoseEstimator(ros::NodeHandle &node) : publish_pose_topic_(true), publish_odom_topic_(false), update_rate_(100), output_frame_("odom"), base_frame_("base_link"), world_frame_("map"), x_est_(Eigen::Vector4d::Zero()), cov_est_(Eigen::Matrix4d::Identity()) { ros::NodeHandle nh_private("~"); nh_private.param("output_frame", output_frame_, output_frame_); nh_private.param("base_frame", base_frame_, base_frame_); double motion_x_err, motion_y_err, motion_ang_err, motion_vel_err; double observation_x_err, observation_y_err, observation_ang_err, observation_vel_err; nh_private.param("motion_x_err", motion_x_err, 0.1); nh_private.param("motion_y_err", motion_y_err, 0.1); nh_private.param("motion_ang_err", motion_ang_err, 0.1); nh_private.param("motion_vel_err", motion_vel_err, 0.05); nh_private.param("observation_x_err", observation_x_err, 0.1); nh_private.param("observation_y_err", observation_y_err, 0.1); nh_private.param("observation_ang_err", observation_ang_err, 0.1); nh_private.param("observation_vel_err", observation_vel_err, 0.05); motion_cov_ << motion_x_err * motion_x_err, 0.0, 0.0, 0.0, 0.0, motion_y_err * motion_y_err, 0.0, 0.0, 0.0, 0.0, motion_ang_err * motion_ang_err, 0.0, 0.0, 0.0, 0.0, motion_vel_err * motion_vel_err; observation_cov_ << observation_x_err * observation_x_err, 0.0, 0.0, 0.0, 0.0, observation_y_err * observation_y_err, 0.0, 0.0, 0.0, 0.0, observation_ang_err * observation_ang_err, 0.0, 0.0, 0.0, 0.0, observation_vel_err * observation_vel_err; nh_private.param("publish_pose_topic", publish_pose_topic_, publish_pose_topic_); nh_private.param("publish_odom_topic", publish_odom_topic_, publish_odom_topic_); imu_sub_ = node.subscribe("imu", 10, &PoseEstimator::imu_callback, this); odom_sub_ = node.subscribe("odom", 10, &PoseEstimator::odom_callback, this); gpos_meas_sub_ = node.subscribe("meas_gpos", 10, &PoseEstimator::gpos_meas_callback, this); if(publish_odom_topic_) odom_pub_ = node.advertise<nav_msgs::Odometry>("combined_odom", 10); if(publish_pose_topic_) pose_pub_ = node.advertise<geometry_msgs::PoseWithCovarianceStamped>("self_pose", 10); } void PoseEstimator::spin() { ros::Rate rate(update_rate_); ros::Time old_filter_stamp(0); bool meas_initialized = false; while(ros::ok()) { ros::spinOnce(); rate.sleep(); if(old_filter_stamp != ros::Time(0) && imu_stamp_ != ros::Time(0) && odom_stamp_ != ros::Time(0)) { meas_initialized = true; } else { meas_initialized = false; } if(meas_initialized) { ros::Time now = ros::Time::now(); ros::Time filter_stamp = now; filter_stamp = std::min(filter_stamp, odom_stamp_); filter_stamp = std::min(filter_stamp, imu_stamp_); filter_stamp = std::min(filter_stamp, gpos_meas_stamp_); double dt = (now - old_filter_stamp).toSec(); if(fabs(dt) < 0.0001) continue; if((ros::Time::now() - filter_stamp).toSec() > 1.0) { ROS_WARN("receive data are too old!"); continue; } Eigen::Vector2d est_pos; double est_yaw; Eigen::Matrix3d est_cov; if(!estimate(est_pos, est_yaw, est_cov, filter_stamp, dt)) continue; if(publish_odom_topic_) publish_odom(filter_stamp, est_pos, est_yaw, est_cov); if(publish_pose_topic_) publish_pose(filter_stamp, est_pos, est_yaw, est_cov); geometry_msgs::TransformStamped tran; tran.header.stamp = filter_stamp; tran.header.frame_id = output_frame_; tran.child_frame_id = base_frame_; tran.transform.translation.x = est_pos.x(); tran.transform.translation.y = est_pos.y(); tran.transform.translation.z = 0.0; tran.transform.rotation = tf::createQuaternionMsgFromYaw(est_yaw); tf_broadcaster_.sendTransform(tran); old_filter_stamp = now; } else { old_filter_stamp = ros::Time::now(); if(transformer_.canTransform(world_frame_, "odom", old_filter_stamp)) { transformer_.lookupTransform("odom", world_frame_, old_filter_stamp, old_odom_meas_); } } } } bool PoseEstimator::estimate(Eigen::Vector2d &pos, double &yaw, Eigen::Matrix3d &cov_xy_th, const ros::Time &filter_stamp, double dt) { tf::StampedTransform odom_meas; if(!transformer_.canTransform(world_frame_, "odom", filter_stamp)) { ROS_WARN("Failed transform of odom data"); return false; } else { transformer_.lookupTransform("odom", world_frame_, filter_stamp, odom_meas); } double gpos_meas_x, gpos_meas_y; tf::StampedTransform gpos_meas; if(!transformer_.canTransform(world_frame_, "gpos_meas", filter_stamp)) { ROS_WARN("Failed transform of gpos_meas data"); return false; } else { transformer_.lookupTransform("gpos_meas", world_frame_, filter_stamp, gpos_meas); } gpos_meas_x = gpos_meas.getOrigin().x(); gpos_meas_y = gpos_meas.getOrigin().y(); tf::StampedTransform imu_meas; if(!transformer_.canTransform(world_frame_, "imu", filter_stamp)) { ROS_WARN("Failed transform of imu data"); return false; } else { transformer_.lookupTransform("imu", world_frame_, filter_stamp, imu_meas); } double odom_linear_x = (odom_meas.getOrigin().x() - old_odom_meas_.getOrigin().x()) / dt; double odom_angular_z; double tmp_r, tmp_p, odom_yaw; odom_meas.getBasis().getEulerYPR(odom_yaw, tmp_p, tmp_r); double tmp_old_r, tmp_old_p, old_odom_yaw; old_odom_meas_.getBasis().getEulerYPR(old_odom_yaw, tmp_old_p, tmp_old_r); odom_angular_z = (odom_yaw - old_odom_yaw) / dt; double imu_roll, imu_pitch, imu_yaw; imu_meas.getBasis().getEulerYPR(imu_yaw, imu_pitch, imu_roll); Eigen::Vector2d u(odom_linear_x, odom_angular_z); Eigen::Vector4d x_pred = motion_model(x_est_, u, dt); Eigen::Matrix4d JF = jacob_motion_model(x_pred, u, dt); Eigen::Matrix4d cov_pred = JF * cov_est_ * JF.transpose() + motion_cov_; Eigen::Vector4d x(gpos_meas_x, gpos_meas_y, imu_yaw, odom_linear_x); Eigen::Vector4d z = observation_model(x); Eigen::Matrix4d H = jacob_observation_model(x_pred); Eigen::Vector4d y = z - observation_model(x_pred); y(2) = normalize_rad(y(2)); Eigen::Matrix4d S = H * cov_pred * H.transpose() + observation_cov_; Eigen::Matrix4d K = cov_pred * H.transpose() * S.inverse(); x_est_ = x_pred + K * y; cov_est_ = (Eigen::Matrix4d::Identity() - K * H) * cov_pred; old_odom_meas_ = odom_meas; pos.x() = x_est_(0); pos.y() = x_est_(1); yaw = x_est_(2); cov_xy_th = cov_est_.block(0, 0, 3, 3); return true; } void PoseEstimator::publish_odom(const ros::Time &stamp, const Eigen::Vector2d &pos, double yaw, const Eigen::Matrix3d &cov_xy_th) { nav_msgs::Odometry est_odom; est_odom.header.stamp = stamp; est_odom.header.frame_id = output_frame_; est_odom.child_frame_id = base_frame_; est_odom.pose.pose.position.x = pos.x(); est_odom.pose.pose.position.y = pos.y(); est_odom.pose.pose.orientation = tf::createQuaternionMsgFromYaw(yaw); est_odom.pose.covariance = boost::assign::list_of (cov_xy_th(0)) (0) (0) (0) (0) (0) (0) (cov_xy_th(1)) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (0) (cov_xy_th(2)); odom_pub_.publish(est_odom); } void PoseEstimator::publish_pose(const ros::Time &stamp, const Eigen::Vector2d &pos, double yaw, const Eigen::Matrix3d &cov_xy_th) { geometry_msgs::PoseWithCovarianceStamped est_pose; est_pose.header.stamp = stamp; est_pose.header.frame_id = base_frame_; est_pose.pose.pose.position.x = pos.x(); est_pose.pose.pose.position.y = pos.y(); est_pose.pose.pose.orientation = tf::createQuaternionMsgFromYaw(yaw); est_pose.pose.covariance = boost::assign::list_of (cov_xy_th(0)) (0) (0) (0) (0) (0) (0) (cov_xy_th(1)) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (0) (cov_xy_th(2)); pose_pub_.publish(est_pose); } } int main(int argc, char *argv[]) { ros::init(argc, argv, "pose_estimator"); ros::NodeHandle nh; fulanghua::PoseEstimator estimator(nh); estimator.spin(); return 0; }
#include <fulanghua_ekf_2d/pose_estimator.h> #include <boost/assign.hpp> #include <Eigen/LU> #include <Eigen/Dense> namespace fulanghua { double normalize_rad(double th) { while(th > M_PI) th -= 2 * M_PI; while(th < -M_PI) th += 2 * M_PI; return th; } PoseEstimator::PoseEstimator(ros::NodeHandle &node) : publish_pose_topic_(true), publish_odom_topic_(false), update_rate_(100), output_frame_("odom"), base_frame_("base_link"), world_frame_("map"), x_est_(Eigen::Vector4d::Zero()), cov_est_(Eigen::Matrix4d::Identity()) { ros::NodeHandle nh_private("~"); nh_private.param("output_frame", output_frame_, output_frame_); nh_private.param("base_frame", base_frame_, base_frame_); double motion_x_err, motion_y_err, motion_ang_err, motion_vel_err; double observation_x_err, observation_y_err, observation_ang_err, observation_vel_err; nh_private.param("motion_x_err", motion_x_err, 0.1); nh_private.param("motion_y_err", motion_y_err, 0.1); nh_private.param("motion_ang_err", motion_ang_err, 0.1); nh_private.param("motion_vel_err", motion_vel_err, 0.05); nh_private.param("observation_x_err", observation_x_err, 0.1); nh_private.param("observation_y_err", observation_y_err, 0.1); nh_private.param("observation_ang_err", observation_ang_err, 0.1); nh_private.param("observation_vel_err", observation_vel_err, 0.05); motion_cov_ << motion_x_err * motion_x_err, 0.0, 0.0, 0.0, 0.0, motion_y_err * motion_y_err, 0.0, 0.0, 0.0, 0.0, motion_ang_err * motion_ang_err, 0.0, 0.0, 0.0, 0.0, motion_vel_err * motion_vel_err; observation_cov_ << observation_x_err * observation_x_err, 0.0, 0.0, 0.0, 0.0, observation_y_err * observation_y_err, 0.0, 0.0, 0.0, 0.0, observation_ang_err * observation_ang_err, 0.0, 0.0, 0.0, 0.0, observation_vel_err * observation_vel_err; nh_private.param("publish_pose_topic", publish_pose_topic_, publish_pose_topic_); nh_private.param("publish_odom_topic", publish_odom_topic_, publish_odom_topic_); imu_sub_ = node.subscribe("imu", 10, &PoseEstimator::imu_callback, this); odom_sub_ = node.subscribe("odom", 10, &PoseEstimator::odom_callback, this); gpos_meas_sub_ = node.subscribe("meas_gpos", 10, &PoseEstimator::gpos_meas_callback, this); if(publish_odom_topic_) odom_pub_ = node.advertise<nav_msgs::Odometry>("combined_odom", 10); if(publish_pose_topic_) pose_pub_ = node.advertise<geometry_msgs::PoseWithCovarianceStamped>("self_pose", 10); } void PoseEstimator::spin() { ros::Rate rate(update_rate_); ros::Time old_filter_stamp(0); bool meas_initialized = false; while(ros::ok()) { ros::spinOnce(); rate.sleep(); if(old_filter_stamp != ros::Time(0) && imu_stamp_ != ros::Time(0) && odom_stamp_ != ros::Time(0)) { meas_initialized = true; } else { meas_initialized = false; } if(meas_initialized) { ros::Time now = ros::Time::now(); ros::Time filter_stamp = now; filter_stamp = std::min(filter_stamp, odom_stamp_); filter_stamp = std::min(filter_stamp, imu_stamp_); filter_stamp = std::min(filter_stamp, gpos_meas_stamp_); double dt = (now - old_filter_stamp).toSec(); if(fabs(dt) < 0.0001) continue; if((ros::Time::now() - filter_stamp).toSec() > 1.0) { ROS_WARN("receive data are too old!"); continue; } Eigen::Vector2d est_pos; double est_yaw; Eigen::Matrix3d est_cov; if(!estimate(est_pos, est_yaw, est_cov, filter_stamp, dt)) continue; if(publish_odom_topic_) publish_odom(filter_stamp, est_pos, est_yaw, est_cov); if(publish_pose_topic_) publish_pose(filter_stamp, est_pos, est_yaw, est_cov); geometry_msgs::TransformStamped tran; tran.header.stamp = filter_stamp; tran.header.frame_id = output_frame_; tran.child_frame_id = base_frame_; tran.transform.translation.x = est_pos.x(); tran.transform.translation.y = est_pos.y(); tran.transform.translation.z = 0.0; tran.transform.rotation = tf::createQuaternionMsgFromYaw(est_yaw); tf_broadcaster_.sendTransform(tran); old_filter_stamp = now; } else { old_filter_stamp = ros::Time::now(); if(transformer_.canTransform(world_frame_, "odom", old_filter_stamp)) { transformer_.lookupTransform("odom", world_frame_, old_filter_stamp, old_odom_meas_); } } } } bool PoseEstimator::estimate(Eigen::Vector2d &pos, double &yaw, Eigen::Matrix3d &cov_xy_th, const ros::Time &filter_stamp, double dt) { tf::StampedTransform odom_meas; if(!transformer_.canTransform(world_frame_, "odom", filter_stamp)) { ROS_WARN("Failed transform of odom data"); return false; } else { transformer_.lookupTransform("odom", world_frame_, filter_stamp, odom_meas); } double gpos_meas_x, gpos_meas_y; tf::StampedTransform gpos_meas; if(!transformer_.canTransform(world_frame_, "gpos_meas", filter_stamp)) { ROS_WARN("Failed transform of gpos_meas data"); return false; } else { transformer_.lookupTransform("gpos_meas", world_frame_, filter_stamp, gpos_meas); } gpos_meas_x = gpos_meas.getOrigin().x(); gpos_meas_y = gpos_meas.getOrigin().y(); tf::StampedTransform imu_meas; if(!transformer_.canTransform(world_frame_, "imu", filter_stamp)) { ROS_WARN("Failed transform of imu data"); return false; } else { transformer_.lookupTransform("imu", world_frame_, filter_stamp, imu_meas); } double odom_linear_x = (odom_meas.getOrigin().x() - old_odom_meas_.getOrigin().x()) / dt; double odom_angular_z; double tmp_r, tmp_p, odom_yaw; odom_meas.getBasis().getEulerYPR(odom_yaw, tmp_p, tmp_r); double tmp_old_r, tmp_old_p, old_odom_yaw; old_odom_meas_.getBasis().getEulerYPR(old_odom_yaw, tmp_old_p, tmp_old_r); odom_angular_z = (odom_yaw - old_odom_yaw) / dt; double imu_roll, imu_pitch, imu_yaw; imu_meas.getBasis().getEulerYPR(imu_yaw, imu_pitch, imu_roll); Eigen::Vector2d u(odom_linear_x, odom_angular_z); Eigen::Vector4d x_pred = motion_model(x_est_, u, dt); Eigen::Matrix4d JF = jacob_motion_model(x_pred, u, dt); Eigen::Matrix4d cov_pred = JF * cov_est_ * JF.transpose() + motion_cov_; Eigen::Vector4d x(gpos_meas_x, gpos_meas_y, imu_yaw, odom_linear_x); Eigen::Vector4d z = observation_model(x); Eigen::Matrix4d H = jacob_observation_model(x_pred); Eigen::Vector4d y = z - observation_model(x_pred); y(2) = normalize_rad(y(2)); Eigen::Matrix4d S = H * cov_pred * H.transpose() + observation_cov_; Eigen::Matrix4d K = cov_pred * H.transpose() * S.inverse(); x_est_ = x_pred + K * y; cov_est_ = (Eigen::Matrix4d::Identity() - K * H) * cov_pred; old_odom_meas_ = odom_meas; pos.x() = x_est_(0); pos.y() = x_est_(1); yaw = x_est_(2); cov_xy_th = cov_est_.block(0, 0, 3, 3); return true; } void PoseEstimator::publish_odom(const ros::Time &stamp, const Eigen::Vector2d &pos, double yaw, const Eigen::Matrix3d &cov_xy_th) { nav_msgs::Odometry est_odom; est_odom.header.stamp = stamp; est_odom.header.frame_id = output_frame_; est_odom.child_frame_id = base_frame_; est_odom.pose.pose.position.x = pos.x(); est_odom.pose.pose.position.y = pos.y(); est_odom.pose.pose.orientation = tf::createQuaternionMsgFromYaw(yaw); est_odom.pose.covariance = boost::assign::list_of (cov_xy_th(0)) (0) (0) (0) (0) (0) (0) (cov_xy_th(1)) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (0) (cov_xy_th(2)); odom_pub_.publish(est_odom); } void PoseEstimator::publish_pose(const ros::Time &stamp, const Eigen::Vector2d &pos, double yaw, const Eigen::Matrix3d &cov_xy_th) { geometry_msgs::PoseWithCovarianceStamped est_pose; est_pose.header.stamp = stamp; est_pose.header.frame_id = base_frame_; est_pose.pose.pose.position.x = pos.x(); est_pose.pose.pose.position.y = pos.y(); est_pose.pose.pose.orientation = tf::createQuaternionMsgFromYaw(yaw);
} int main(int argc, char *argv[]) { ros::init(argc, argv, "pose_estimator"); ros::NodeHandle nh; fulanghua::PoseEstimator estimator(nh); estimator.spin(); return 0; }
est_pose.pose.covariance = boost::assign::list_of (cov_xy_th(0)) (0) (0) (0) (0) (0) (0) (cov_xy_th(1)) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (999999.9) (0) (0) (0) (0) (0) (0) (0) (cov_xy_th(2)); pose_pub_.publish(est_pose); }
function_block-function_prefix_line
[ { "content": " Eigen::Matrix4d motion_cov_;\n\n Eigen::Matrix4d observation_cov_;\n\n\n\n tf::StampedTransform old_odom_meas_;\n\n tf::Transformer transformer_;\n\n tf::TransformBroadcaster tf_broadcaster_;\n\n \n\n bool publish_odom_topic_;\n\n bool publish_pose_topic_;\n\n double up...
C++
drone_controller/src/proportional_rotate.cpp
MikeS96/autonomous_landing_uav
c402bc38119dfc1e9c09746e8376356ddabde07e
#include <ros/ros.h> #include <stdio.h> #include <math.h> #include "mavros_msgs/PositionTarget.h" #include "object_detector/States.h" #include "drone_controller/Error.h" #define FACTORX 0.0015625 // Vx proportional gain #define FACTORY 0.0020833 // Vy proportional gain #define FACTORTH 0.0055 // Theta proportional gain #define FACTORZ 0.05 // Descend Factor #define MAXV 0.5 // Max Vx and Vy speed #define MINV -0.5 // Min Vx and Vy speed #define MAXR 0.5 // Max Yaw rate #define MINR -0.5 // Min Yaw rate class Controller { private: ros::NodeHandle po_nh; ros::Subscriber sub; ros::Publisher pub; ros::Publisher pub1; ros::Time lastTime; float imageW; float imageH; float zini; public: Controller(ros::NodeHandle ao_nh) : po_nh(ao_nh) { pub = po_nh.advertise<mavros_msgs::PositionTarget>("/mavros/setpoint_raw/local",10) ; pub1 = po_nh.advertise<drone_controller::Error>("/error",10) ; sub = po_nh.subscribe("/predicted_states", 10, &Controller::controllerCallBack, this); lastTime = ros::Time::now(); imageW = 640/2; imageH = 480/2; } void controllerCallBack(const object_detector::States& msg) { float ErX = imageW - msg.Xc; float ErY = imageH - msg.Yc; float ErTheta = msg.Theta; drone_controller::Error er; er.errorX = ErX; er.errorY = ErY; er.errorT = ErTheta; er.errorS = 0; float vx = 0; float vy = 0; float vthe = 0; vy = ErX * FACTORX; vx = ErY * FACTORY; vthe = ErTheta * FACTORTH; max_output(MAXV, MINV, vx); max_output(MAXV, MINV, vy); max_output(MAXR, MINR, vthe); mavros_msgs::PositionTarget pos; pos.coordinate_frame = mavros_msgs::PositionTarget::FRAME_BODY_NED; pos.header.stamp = ros::Time::now(); pos.header.frame_id = "base_link"; pos.type_mask = 1987; pos.position.z = 2.0; pos.velocity.x = vx; pos.velocity.y = vy; pos.yaw_rate = vthe; printf("Dany Vx, Vy, Vthe values at (%f,%f,%f) \n", vx, vy, vthe); pub.publish(pos); printf("Error at Vx, Vy and Theta (%f,%f,%f) \n", ErX, ErY, ErTheta); pub1.publish(er); } void max_output(const float& max_v, const float& min_v, float& out) { if (out > max_v) { out = max_v; } else if (out < min_v) { out = min_v; } } }; int main(int argc, char** argv) { ros::init(argc, argv, "trejos_controller_node"); ros::NodeHandle n; Controller cont(n); ros::spin(); return 0; }
#include <ros/ros.h> #include <stdio.h> #include <math.h> #include "mavros_msgs/PositionTarget.h" #include "object_detector/States.h" #include "drone_controller/Error.h" #define FACTORX 0.0015625 // Vx proportional gain #define FACTORY 0.0020833 // Vy proportional gain #define FACTORTH 0.0055 // Theta proportional gain #define FACTORZ 0.05 // Descend Factor #define MAXV 0.5 // Max Vx and Vy speed #define MINV -0.5 // Min Vx and Vy speed #define MAXR 0.5 // Max Yaw rate #define MINR -0.5 // Min Yaw rate class Controller { private: ros::NodeHandle po_nh; ros::Subscriber sub; ros::Publisher pub; ros::Publisher pub1; ros::Time lastTime; float imageW; float imageH; float zini; public: Controller(ros::NodeHandle ao_nh) : po_nh(ao_nh) {
void controllerCallBack(const object_detector::States& msg) { float ErX = imageW - msg.Xc; float ErY = imageH - msg.Yc; float ErTheta = msg.Theta; drone_controller::Error er; er.errorX = ErX; er.errorY = ErY; er.errorT = ErTheta; er.errorS = 0; float vx = 0; float vy = 0; float vthe = 0; vy = ErX * FACTORX; vx = ErY * FACTORY; vthe = ErTheta * FACTORTH; max_output(MAXV, MINV, vx); max_output(MAXV, MINV, vy); max_output(MAXR, MINR, vthe); mavros_msgs::PositionTarget pos; pos.coordinate_frame = mavros_msgs::PositionTarget::FRAME_BODY_NED; pos.header.stamp = ros::Time::now(); pos.header.frame_id = "base_link"; pos.type_mask = 1987; pos.position.z = 2.0; pos.velocity.x = vx; pos.velocity.y = vy; pos.yaw_rate = vthe; printf("Dany Vx, Vy, Vthe values at (%f,%f,%f) \n", vx, vy, vthe); pub.publish(pos); printf("Error at Vx, Vy and Theta (%f,%f,%f) \n", ErX, ErY, ErTheta); pub1.publish(er); } void max_output(const float& max_v, const float& min_v, float& out) { if (out > max_v) { out = max_v; } else if (out < min_v) { out = min_v; } } }; int main(int argc, char** argv) { ros::init(argc, argv, "trejos_controller_node"); ros::NodeHandle n; Controller cont(n); ros::spin(); return 0; }
pub = po_nh.advertise<mavros_msgs::PositionTarget>("/mavros/setpoint_raw/local",10) ; pub1 = po_nh.advertise<drone_controller::Error>("/error",10) ; sub = po_nh.subscribe("/predicted_states", 10, &Controller::controllerCallBack, this); lastTime = ros::Time::now(); imageW = 640/2; imageH = 480/2; }
function_block-function_prefix_line
[ { "content": "class Controller // Controller class\n\n{\n\n private: \n\n //Private class atributes\n\n ros::NodeHandle po_nh;\n\n ros::Subscriber sub;\n\n ros::Publisher pub;\n\n ros::Publisher pub1;\n\n ros::Time lastTime;\n\n float imageW; // Image Width\n\...
C++
cppcache/src/ThinClientLocatorHelper.cpp
rhoughton-pivot/geode-native
ab6fe7d996e5ec23832f90663d03f1d66b9f5fbd
#include "ThinClientLocatorHelper.hpp" #include <algorithm> #include <set> #include <boost/thread/lock_types.hpp> #include <geode/DataInput.hpp> #include <geode/DataOutput.hpp> #include <geode/SystemProperties.hpp> #include "CacheImpl.hpp" #include "ClientConnectionRequest.hpp" #include "ClientConnectionResponse.hpp" #include "ClientReplacementRequest.hpp" #include "LocatorListRequest.hpp" #include "LocatorListResponse.hpp" #include "QueueConnectionRequest.hpp" #include "QueueConnectionResponse.hpp" #include "TcpConn.hpp" #include "TcpSslConn.hpp" #include "TcrConnectionManager.hpp" #include "ThinClientPoolDM.hpp" #include "Version.hpp" namespace apache { namespace geode { namespace client { const size_t BUFF_SIZE = 3000; const size_t DEFAULT_CONNECTION_RETRIES = 3; ThinClientLocatorHelper::ThinClientLocatorHelper( const std::vector<std::string>& locators, const ThinClientPoolDM* poolDM) : locators_(locators.begin(), locators.end()), m_poolDM(poolDM), m_sniProxyHost(""), m_sniProxyPort(0) {} ThinClientLocatorHelper::ThinClientLocatorHelper( const std::vector<std::string>& locators, const std::string& sniProxyHost, int sniProxyPort, const ThinClientPoolDM* poolDM) : locators_(locators.begin(), locators.end()), m_poolDM(poolDM), m_sniProxyHost(sniProxyHost), m_sniProxyPort(sniProxyPort) {} size_t ThinClientLocatorHelper::getConnRetries() const { auto retries = m_poolDM->getRetryAttempts(); return retries <= 0 ? DEFAULT_CONNECTION_RETRIES : retries; } std::vector<ServerLocation> ThinClientLocatorHelper::getLocators() const { decltype(locators_) locators; { boost::shared_lock<decltype(mutex_)> guard{mutex_}; if (locators_.empty()) { return {}; } locators = locators_; } RandGen randGen; std::random_shuffle(locators.begin(), locators.end(), randGen); return locators; } std::unique_ptr<Connector> ThinClientLocatorHelper::createConnection( const ServerLocation& location) const { auto& sys_prop = m_poolDM->getConnectionManager() .getCacheImpl() ->getDistributedSystem() .getSystemProperties(); const auto port = location.getPort(); auto timeout = sys_prop.connectTimeout(); const auto& hostname = location.getServerName(); auto buffer_size = m_poolDM->getSocketBufferSize(); if (sys_prop.sslEnabled()) { if (m_sniProxyHost.empty()) { return std::unique_ptr<Connector>(new TcpSslConn( hostname, static_cast<uint16_t>(port), timeout, buffer_size, sys_prop.sslTrustStore(), sys_prop.sslKeyStore(), sys_prop.sslKeystorePassword())); } else { return std::unique_ptr<Connector>(new TcpSslConn( hostname, static_cast<uint16_t>(port), m_sniProxyHost, m_sniProxyPort, timeout, buffer_size, sys_prop.sslTrustStore(), sys_prop.sslKeyStore(), sys_prop.sslKeystorePassword())); } } else { return std::unique_ptr<Connector>(new TcpConn( hostname, static_cast<uint16_t>(port), timeout, buffer_size)); } } static constexpr int32_t kGossipVersion = 1002; std::shared_ptr<Serializable> ThinClientLocatorHelper::sendRequest( const ServerLocation& location, const std::shared_ptr<Serializable>& request) const { auto& sys_prop = m_poolDM->getConnectionManager() .getCacheImpl() ->getDistributedSystem() .getSystemProperties(); try { auto conn = createConnection(location); auto data = m_poolDM->getConnectionManager().getCacheImpl()->createDataOutput(); data.writeInt(kGossipVersion); data.writeInt(Version::current().getOrdinal()); data.writeObject(request); auto sentLength = conn->send( reinterpret_cast<char*>(const_cast<uint8_t*>(data.getBuffer())), data.getBufferLength(), m_poolDM->getReadTimeout()); if (sentLength <= 0) { return nullptr; } char buff[BUFF_SIZE]; const auto receivedLength = conn->receive(buff, m_poolDM->getReadTimeout()); if (!receivedLength) { return nullptr; } auto di = m_poolDM->getConnectionManager().getCacheImpl()->createDataInput( reinterpret_cast<uint8_t*>(buff), receivedLength); if (di.read() == REPLY_SSL_ENABLED && !sys_prop.sslEnabled()) { LOGERROR("SSL is enabled on locator, enable SSL in client as well"); throw AuthenticationRequiredException( "SSL is enabled on locator, enable SSL in client as well"); } di.rewindCursor(1); return di.readObject(); } catch (const AuthenticationRequiredException& excp) { throw excp; } catch (const Exception& excp) { LOGFINE("Exception while querying locator: %s: %s", excp.getName().c_str(), excp.what()); } catch (...) { LOGFINE("Exception while querying locator"); } return nullptr; } GfErrType ThinClientLocatorHelper::getAllServers( std::vector<std::shared_ptr<ServerLocation> >& servers, const std::string& serverGrp) const { for (const auto& loc : getLocators()) { LOGDEBUG("getAllServers getting servers from server = %s ", loc.getServerName().c_str()); auto request = std::make_shared<GetAllServersRequest>(serverGrp); auto response = std::dynamic_pointer_cast<GetAllServersResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } servers = response->getServers(); return GF_NOERR; } return GF_NOERR; } GfErrType ThinClientLocatorHelper::getEndpointForNewCallBackConn( ClientProxyMembershipID& memId, std::list<ServerLocation>& outEndpoint, std::string&, int redundancy, const std::set<ServerLocation>& exclEndPts, const std::string& serverGrp) const { auto locators = getLocators(); auto locatorsSize = locators.size(); auto maxAttempts = getConnRetries(); LOGFINER( "ThinClientLocatorHelper::getEndpointForNewCallBackConn maxAttempts = " "%zu", maxAttempts); for (auto attempt = 0ULL; attempt < maxAttempts;) { const auto& loc = locators[attempt++ % locatorsSize]; LOGFINER("Querying locator at [%s:%d] for queue server from group [%s]", loc.getServerName().c_str(), loc.getPort(), serverGrp.c_str()); auto request = std::make_shared<QueueConnectionRequest>( memId, exclEndPts, redundancy, false, serverGrp); auto response = std::dynamic_pointer_cast<QueueConnectionResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } outEndpoint = response->getServers(); return GF_NOERR; } throw NoAvailableLocatorsException("Unable to query any locators"); } GfErrType ThinClientLocatorHelper::getEndpointForNewFwdConn( ServerLocation& outEndpoint, std::string&, const std::set<ServerLocation>& exclEndPts, const std::string& serverGrp, const TcrConnection* currentServer) const { bool locatorFound = false; auto locators = getLocators(); auto locatorsSize = locators.size(); auto maxAttempts = getConnRetries(); LOGFINER( "ThinClientLocatorHelper::getEndpointForNewFwdConn maxAttempts = %zu", maxAttempts); for (auto attempt = 0ULL; attempt < maxAttempts;) { const auto& loc = locators[attempt++ % locatorsSize]; LOGFINE("Querying locator at [%s:%d] for server from group [%s]", loc.getServerName().c_str(), loc.getPort(), serverGrp.c_str()); std::shared_ptr<Serializable> request; if (currentServer == nullptr) { LOGDEBUG("Creating ClientConnectionRequest"); request = std::make_shared<ClientConnectionRequest>(exclEndPts, serverGrp); } else { LOGDEBUG("Creating ClientReplacementRequest for connection: %s", currentServer->getEndpointObject()->name().c_str()); request = std::make_shared<ClientReplacementRequest>( currentServer->getEndpointObject()->name(), exclEndPts, serverGrp); } auto response = std::dynamic_pointer_cast<ClientConnectionResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } response->printInfo(); if (!response->serverFound()) { LOGFINE("Server not found"); locatorFound = true; continue; } outEndpoint = response->getServerLocation(); LOGFINE("Server found at [%s:%d]", outEndpoint.getServerName().c_str(), outEndpoint.getPort()); return GF_NOERR; } if (locatorFound) { throw NotConnectedException("No servers found"); } else { throw NoAvailableLocatorsException("Unable to query any locators"); } } GfErrType ThinClientLocatorHelper::updateLocators( const std::string& serverGrp) { auto locators = getLocators(); for (const auto& loc : locators) { LOGFINER("Querying locator list at: [%s:%d] for update from group [%s]", loc.getServerName().c_str(), loc.getPort(), serverGrp.c_str()); auto request = std::make_shared<LocatorListRequest>(serverGrp); auto response = std::dynamic_pointer_cast<LocatorListResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } auto new_locators = response->getLocators(); for (const auto& old_loc : locators) { auto iter = std::find(new_locators.begin(), new_locators.end(), old_loc); if (iter == new_locators.end()) { new_locators.push_back(old_loc); } } { boost::unique_lock<decltype(mutex_)> lock(mutex_); locators_.swap(new_locators); } return GF_NOERR; } return GF_NOTCON; } } } }
#include "ThinClientLocatorHelper.hpp" #include <algorithm> #include <set> #include <boost/thread/lock_types.hpp> #include <geode/DataInput.hpp> #include <geode/DataOutput.hpp> #include <geode/SystemProperties.hpp> #include "CacheImpl.hpp" #include "ClientConnectionRequest.hpp" #include "ClientConnectionResponse.hpp" #include "ClientReplacementRequest.hpp" #include "LocatorListRequest.hpp" #include "LocatorListResponse.hpp" #include "QueueConnectionRequest.hpp" #include "QueueConnectionResponse.hpp" #include "TcpConn.hpp" #include "TcpSslConn.hpp" #include "TcrConnectionManager.hpp" #include "ThinClientPoolDM.hpp" #include "Version.hpp" namespace apache { namespace geode { namespace client { const size_t BUFF_SIZE = 3000; const size_t DEFAULT_CONNECTION_RETRIES = 3; ThinClientLocatorHelper::ThinClientLocatorHelper( const std::vector<std::string>& locators, const ThinClientPoolDM* poolDM) : locators_(locators.begin(), locators.end()), m_poolDM(poolDM), m_sniProxyHost(""), m_sniProxyPort(0) {} ThinClientLocatorHelper::ThinClientLocatorHelper( const std::vector<std::string>& locators, const std::string& sniProxyHost, int sniProxyPort, const ThinClientPoolDM* poolDM) : locators_(locators.begin(), locators.end()), m_poolDM(poolDM), m_sniProxyHost(sniProxyHost), m_sniProxyPort(sniProxyPort) {} size_t ThinClientLocatorHelper::getConnRetries() const { auto retries = m_poolDM->getRetryAttempts(); return retries <= 0 ? DEFAULT_CONNECTION_RETRIES : retries; } std::vector<ServerLocation> ThinClientLocatorHelper::getLocators() const { decltype(locators_) locators; { boost::shared_lock<decltype(mutex_)> guard{mutex_}; if (locators_.empty()) { return {}; } locators = locators_; } RandGen randGen; std::random_shuffle(locators.begin(), locators.end(), randGen); return locators; } std::unique_ptr<Connector> ThinClientLocatorHelper::createConnection( const ServerLocation& location) const { auto& sys_prop = m_poolDM->getConnectionManager() .getCacheImpl() ->getDistributedSystem() .getSystemProperties(); const auto port = location.getPort(); auto timeout = sys_prop.connectTimeout(); const auto& hostname = location.getServerName(); auto buffer_size = m_poolDM->getSocketBufferSize(); if (sys_prop.sslEnabled()) { if (m_sniProxyHost.empty()) { return std::unique_ptr<Connector>(new TcpSslConn( hostname, static_cast<uint16_t>(port), timeout, buffer_size, sys_prop.sslTrustStore(), sys_prop.sslKeyStore(), sys_prop.sslKeystorePassword())); } else { return
; } } else { return std::unique_ptr<Connector>(new TcpConn( hostname, static_cast<uint16_t>(port), timeout, buffer_size)); } } static constexpr int32_t kGossipVersion = 1002; std::shared_ptr<Serializable> ThinClientLocatorHelper::sendRequest( const ServerLocation& location, const std::shared_ptr<Serializable>& request) const { auto& sys_prop = m_poolDM->getConnectionManager() .getCacheImpl() ->getDistributedSystem() .getSystemProperties(); try { auto conn = createConnection(location); auto data = m_poolDM->getConnectionManager().getCacheImpl()->createDataOutput(); data.writeInt(kGossipVersion); data.writeInt(Version::current().getOrdinal()); data.writeObject(request); auto sentLength = conn->send( reinterpret_cast<char*>(const_cast<uint8_t*>(data.getBuffer())), data.getBufferLength(), m_poolDM->getReadTimeout()); if (sentLength <= 0) { return nullptr; } char buff[BUFF_SIZE]; const auto receivedLength = conn->receive(buff, m_poolDM->getReadTimeout()); if (!receivedLength) { return nullptr; } auto di = m_poolDM->getConnectionManager().getCacheImpl()->createDataInput( reinterpret_cast<uint8_t*>(buff), receivedLength); if (di.read() == REPLY_SSL_ENABLED && !sys_prop.sslEnabled()) { LOGERROR("SSL is enabled on locator, enable SSL in client as well"); throw AuthenticationRequiredException( "SSL is enabled on locator, enable SSL in client as well"); } di.rewindCursor(1); return di.readObject(); } catch (const AuthenticationRequiredException& excp) { throw excp; } catch (const Exception& excp) { LOGFINE("Exception while querying locator: %s: %s", excp.getName().c_str(), excp.what()); } catch (...) { LOGFINE("Exception while querying locator"); } return nullptr; } GfErrType ThinClientLocatorHelper::getAllServers( std::vector<std::shared_ptr<ServerLocation> >& servers, const std::string& serverGrp) const { for (const auto& loc : getLocators()) { LOGDEBUG("getAllServers getting servers from server = %s ", loc.getServerName().c_str()); auto request = std::make_shared<GetAllServersRequest>(serverGrp); auto response = std::dynamic_pointer_cast<GetAllServersResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } servers = response->getServers(); return GF_NOERR; } return GF_NOERR; } GfErrType ThinClientLocatorHelper::getEndpointForNewCallBackConn( ClientProxyMembershipID& memId, std::list<ServerLocation>& outEndpoint, std::string&, int redundancy, const std::set<ServerLocation>& exclEndPts, const std::string& serverGrp) const { auto locators = getLocators(); auto locatorsSize = locators.size(); auto maxAttempts = getConnRetries(); LOGFINER( "ThinClientLocatorHelper::getEndpointForNewCallBackConn maxAttempts = " "%zu", maxAttempts); for (auto attempt = 0ULL; attempt < maxAttempts;) { const auto& loc = locators[attempt++ % locatorsSize]; LOGFINER("Querying locator at [%s:%d] for queue server from group [%s]", loc.getServerName().c_str(), loc.getPort(), serverGrp.c_str()); auto request = std::make_shared<QueueConnectionRequest>( memId, exclEndPts, redundancy, false, serverGrp); auto response = std::dynamic_pointer_cast<QueueConnectionResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } outEndpoint = response->getServers(); return GF_NOERR; } throw NoAvailableLocatorsException("Unable to query any locators"); } GfErrType ThinClientLocatorHelper::getEndpointForNewFwdConn( ServerLocation& outEndpoint, std::string&, const std::set<ServerLocation>& exclEndPts, const std::string& serverGrp, const TcrConnection* currentServer) const { bool locatorFound = false; auto locators = getLocators(); auto locatorsSize = locators.size(); auto maxAttempts = getConnRetries(); LOGFINER( "ThinClientLocatorHelper::getEndpointForNewFwdConn maxAttempts = %zu", maxAttempts); for (auto attempt = 0ULL; attempt < maxAttempts;) { const auto& loc = locators[attempt++ % locatorsSize]; LOGFINE("Querying locator at [%s:%d] for server from group [%s]", loc.getServerName().c_str(), loc.getPort(), serverGrp.c_str()); std::shared_ptr<Serializable> request; if (currentServer == nullptr) { LOGDEBUG("Creating ClientConnectionRequest"); request = std::make_shared<ClientConnectionRequest>(exclEndPts, serverGrp); } else { LOGDEBUG("Creating ClientReplacementRequest for connection: %s", currentServer->getEndpointObject()->name().c_str()); request = std::make_shared<ClientReplacementRequest>( currentServer->getEndpointObject()->name(), exclEndPts, serverGrp); } auto response = std::dynamic_pointer_cast<ClientConnectionResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } response->printInfo(); if (!response->serverFound()) { LOGFINE("Server not found"); locatorFound = true; continue; } outEndpoint = response->getServerLocation(); LOGFINE("Server found at [%s:%d]", outEndpoint.getServerName().c_str(), outEndpoint.getPort()); return GF_NOERR; } if (locatorFound) { throw NotConnectedException("No servers found"); } else { throw NoAvailableLocatorsException("Unable to query any locators"); } } GfErrType ThinClientLocatorHelper::updateLocators( const std::string& serverGrp) { auto locators = getLocators(); for (const auto& loc : locators) { LOGFINER("Querying locator list at: [%s:%d] for update from group [%s]", loc.getServerName().c_str(), loc.getPort(), serverGrp.c_str()); auto request = std::make_shared<LocatorListRequest>(serverGrp); auto response = std::dynamic_pointer_cast<LocatorListResponse>( sendRequest(loc, request)); if (response == nullptr) { continue; } auto new_locators = response->getLocators(); for (const auto& old_loc : locators) { auto iter = std::find(new_locators.begin(), new_locators.end(), old_loc); if (iter == new_locators.end()) { new_locators.push_back(old_loc); } } { boost::unique_lock<decltype(mutex_)> lock(mutex_); locators_.swap(new_locators); } return GF_NOERR; } return GF_NOTCON; } } } }
std::unique_ptr<Connector>(new TcpSslConn( hostname, static_cast<uint16_t>(port), m_sniProxyHost, m_sniProxyPort, timeout, buffer_size, sys_prop.sslTrustStore(), sys_prop.sslKeyStore(), sys_prop.sslKeystorePassword()))
call_expression
[ { "content": "struct hash<apache::geode::client::ServerLocation> {\n\n typedef apache::geode::client::ServerLocation argument_type;\n\n typedef size_t result_type;\n\n size_t operator()(const apache::geode::client::ServerLocation& val) const {\n\n return val.hashcode();\n\n }\n\n};\n\n\n\n} // namespace...
C++
content/renderer/history_controller.cc
kjthegod/chromium
cf940f7f418436b77e15b1ea23e6fa100ca1c91a
#include "content/renderer/history_controller.h" #include "content/renderer/render_frame_impl.h" #include "content/renderer/render_view_impl.h" #include "third_party/WebKit/public/web/WebLocalFrame.h" using blink::WebFrame; using blink::WebHistoryCommitType; using blink::WebHistoryItem; using blink::WebURLRequest; namespace content { HistoryController::HistoryController(RenderViewImpl* render_view) : render_view_(render_view) { } HistoryController::~HistoryController() { } void HistoryController::GoToEntry(scoped_ptr<HistoryEntry> target_entry, WebURLRequest::CachePolicy cache_policy) { HistoryFrameLoadVector same_document_loads; HistoryFrameLoadVector different_document_loads; provisional_entry_ = target_entry.Pass(); WebFrame* main_frame = render_view_->GetMainRenderFrame()->GetWebFrame(); if (current_entry_) { RecursiveGoToEntry( main_frame, same_document_loads, different_document_loads); } if (same_document_loads.empty() && different_document_loads.empty()) { different_document_loads.push_back( std::make_pair(main_frame, provisional_entry_->root())); } for (size_t i = 0; i < same_document_loads.size(); ++i) { WebFrame* frame = same_document_loads[i].first; if (!RenderFrameImpl::FromWebFrame(frame)) continue; frame->loadHistoryItem(same_document_loads[i].second, blink::WebHistorySameDocumentLoad, cache_policy); } for (size_t i = 0; i < different_document_loads.size(); ++i) { WebFrame* frame = different_document_loads[i].first; if (!RenderFrameImpl::FromWebFrame(frame)) continue; frame->loadHistoryItem(different_document_loads[i].second, blink::WebHistoryDifferentDocumentLoad, cache_policy); } } void HistoryController::RecursiveGoToEntry( WebFrame* frame, HistoryFrameLoadVector& same_document_loads, HistoryFrameLoadVector& different_document_loads) { DCHECK(provisional_entry_); DCHECK(current_entry_); RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(frame); const WebHistoryItem& new_item = provisional_entry_->GetItemForFrame(render_frame); const WebHistoryItem& old_item = current_entry_->GetItemForFrame(render_frame); if (new_item.isNull()) return; if (old_item.isNull() || new_item.itemSequenceNumber() != old_item.itemSequenceNumber()) { if (!old_item.isNull() && new_item.documentSequenceNumber() == old_item.documentSequenceNumber()) same_document_loads.push_back(std::make_pair(frame, new_item)); else different_document_loads.push_back(std::make_pair(frame, new_item)); return; } for (WebFrame* child = frame->firstChild(); child; child = child->nextSibling()) { RecursiveGoToEntry(child, same_document_loads, different_document_loads); } } void HistoryController::UpdateForInitialLoadInChildFrame( RenderFrameImpl* frame, const WebHistoryItem& item) { DCHECK_NE(frame->GetWebFrame()->top(), frame->GetWebFrame()); if (!current_entry_) return; if (HistoryEntry::HistoryNode* existing_node = current_entry_->GetHistoryNodeForFrame(frame)) { existing_node->set_item(item); return; } RenderFrameImpl* parent = RenderFrameImpl::FromWebFrame(frame->GetWebFrame()->parent()); if (HistoryEntry::HistoryNode* parent_history_node = current_entry_->GetHistoryNodeForFrame(parent)) { parent_history_node->AddChild(item, frame->GetRoutingID()); } } void HistoryController::UpdateForCommit(RenderFrameImpl* frame, const WebHistoryItem& item, WebHistoryCommitType commit_type, bool navigation_within_page) { if (commit_type == blink::WebBackForwardCommit) { if (!provisional_entry_) return; current_entry_.reset(provisional_entry_.release()); } else if (commit_type == blink::WebStandardCommit) { CreateNewBackForwardItem(frame, item, navigation_within_page); } else if (commit_type == blink::WebInitialCommitInChildFrame) { UpdateForInitialLoadInChildFrame(frame, item); } } HistoryEntry* HistoryController::GetCurrentEntry() { return current_entry_.get(); } WebHistoryItem HistoryController::GetItemForNewChildFrame( RenderFrameImpl* frame) const { if (!current_entry_) return WebHistoryItem(); return current_entry_->GetItemForFrame(frame); } void HistoryController::RemoveChildrenForRedirect(RenderFrameImpl* frame) { if (!provisional_entry_) return; if (HistoryEntry::HistoryNode* node = provisional_entry_->GetHistoryNodeForFrame(frame)) node->RemoveChildren(); } void HistoryController::CreateNewBackForwardItem( RenderFrameImpl* target_frame, const WebHistoryItem& new_item, bool clone_children_of_target) { if (!current_entry_) { current_entry_.reset( new HistoryEntry(new_item, target_frame->GetRoutingID())); } else { current_entry_.reset(current_entry_->CloneAndReplace( new_item, clone_children_of_target, target_frame, render_view_)); } } }
#include "content/renderer/history_controller.h" #include "content/renderer/render_frame_impl.h" #include "content/renderer/render_view_impl.h" #include "third_party/WebKit/public/web/WebLocalFrame.h" using blink::WebFrame; using blink::WebHistoryCommitType; using blink::WebHistoryItem; using blink::WebURLRequest; namespace content { HistoryController::HistoryController(RenderViewImpl* render_view) : render_view_(render_view
new_item.isNull()) return; if (old_item.isNull() || new_item.itemSequenceNumber() != old_item.itemSequenceNumber()) { if (!old_item.isNull() && new_item.documentSequenceNumber() == old_item.documentSequenceNumber()) same_document_loads.push_back(std::make_pair(frame, new_item)); else different_document_loads.push_back(std::make_pair(frame, new_item)); return; } for (WebFrame* child = frame->firstChild(); child; child = child->nextSibling()) { RecursiveGoToEntry(child, same_document_loads, different_document_loads); } } void HistoryController::UpdateForInitialLoadInChildFrame( RenderFrameImpl* frame, const WebHistoryItem& item) { DCHECK_NE(frame->GetWebFrame()->top(), frame->GetWebFrame()); if (!current_entry_) return; if (HistoryEntry::HistoryNode* existing_node = current_entry_->GetHistoryNodeForFrame(frame)) { existing_node->set_item(item); return; } RenderFrameImpl* parent = RenderFrameImpl::FromWebFrame(frame->GetWebFrame()->parent()); if (HistoryEntry::HistoryNode* parent_history_node = current_entry_->GetHistoryNodeForFrame(parent)) { parent_history_node->AddChild(item, frame->GetRoutingID()); } } void HistoryController::UpdateForCommit(RenderFrameImpl* frame, const WebHistoryItem& item, WebHistoryCommitType commit_type, bool navigation_within_page) { if (commit_type == blink::WebBackForwardCommit) { if (!provisional_entry_) return; current_entry_.reset(provisional_entry_.release()); } else if (commit_type == blink::WebStandardCommit) { CreateNewBackForwardItem(frame, item, navigation_within_page); } else if (commit_type == blink::WebInitialCommitInChildFrame) { UpdateForInitialLoadInChildFrame(frame, item); } } HistoryEntry* HistoryController::GetCurrentEntry() { return current_entry_.get(); } WebHistoryItem HistoryController::GetItemForNewChildFrame( RenderFrameImpl* frame) const { if (!current_entry_) return WebHistoryItem(); return current_entry_->GetItemForFrame(frame); } void HistoryController::RemoveChildrenForRedirect(RenderFrameImpl* frame) { if (!provisional_entry_) return; if (HistoryEntry::HistoryNode* node = provisional_entry_->GetHistoryNodeForFrame(frame)) node->RemoveChildren(); } void HistoryController::CreateNewBackForwardItem( RenderFrameImpl* target_frame, const WebHistoryItem& new_item, bool clone_children_of_target) { if (!current_entry_) { current_entry_.reset( new HistoryEntry(new_item, target_frame->GetRoutingID())); } else { current_entry_.reset(current_entry_->CloneAndReplace( new_item, clone_children_of_target, target_frame, render_view_)); } } }
) { } HistoryController::~HistoryController() { } void HistoryController::GoToEntry(scoped_ptr<HistoryEntry> target_entry, WebURLRequest::CachePolicy cache_policy) { HistoryFrameLoadVector same_document_loads; HistoryFrameLoadVector different_document_loads; provisional_entry_ = target_entry.Pass(); WebFrame* main_frame = render_view_->GetMainRenderFrame()->GetWebFrame(); if (current_entry_) { RecursiveGoToEntry( main_frame, same_document_loads, different_document_loads); } if (same_document_loads.empty() && different_document_loads.empty()) { different_document_loads.push_back( std::make_pair(main_frame, provisional_entry_->root())); } for (size_t i = 0; i < same_document_loads.size(); ++i) { WebFrame* frame = same_document_loads[i].first; if (!RenderFrameImpl::FromWebFrame(frame)) continue; frame->loadHistoryItem(same_document_loads[i].second, blink::WebHistorySameDocumentLoad, cache_policy); } for (size_t i = 0; i < different_document_loads.size(); ++i) { WebFrame* frame = different_document_loads[i].first; if (!RenderFrameImpl::FromWebFrame(frame)) continue; frame->loadHistoryItem(different_document_loads[i].second, blink::WebHistoryDifferentDocumentLoad, cache_policy); } } void HistoryController::RecursiveGoToEntry( WebFrame* frame, HistoryFrameLoadVector& same_document_loads, HistoryFrameLoadVector& different_document_loads) { DCHECK(provisional_entry_); DCHECK(current_entry_); RenderFrameImpl* render_frame = RenderFrameImpl::FromWebFrame(frame); const WebHistoryItem& new_item = provisional_entry_->GetItemForFrame(render_frame); const WebHistoryItem& old_item = current_entry_->GetItemForFrame(render_frame); if (
random
[]
C++
agent/src/beerocks/monitor/beerocks_monitor_main.cpp
ydx-coder/prplMesh
6401b15c31c563f9e00ce6ff1b5513df3d39f157
#include "monitor_thread.h" #include <bcl/beerocks_logging.h> #include <bcl/beerocks_os_utils.h> #include <bcl/beerocks_version.h> #include <easylogging++.h> BEEROCKS_INIT_BEEROCKS_VERSION static bool g_running = true; static int s_signal = 0; static std::string monitor_iface; static beerocks::logging *s_pLogger = nullptr; static void handle_signal() { if (!s_signal) return; switch (s_signal) { case SIGTERM: case SIGINT: LOG(INFO) << "Caught signal '" << strsignal(s_signal) << "' Exiting..."; g_running = false; break; case SIGUSR1: { LOG(INFO) << "LOG Roll Signal!"; if (!s_pLogger) { LOG(ERROR) << "Invalid logger pointer!"; return; } s_pLogger->apply_settings(); LOG(INFO) << "--- Start of file after roll ---"; break; } default: LOG(WARNING) << "Unhandled Signal: '" << strsignal(s_signal) << "' Ignoring..."; break; } s_signal = 0; } static void init_signals() { auto signal_handler = [](int signum) { s_signal = signum; }; struct sigaction sigterm_action; sigterm_action.sa_handler = signal_handler; sigemptyset(&sigterm_action.sa_mask); sigterm_action.sa_flags = 0; sigaction(SIGTERM, &sigterm_action, NULL); struct sigaction sigint_action; sigint_action.sa_handler = signal_handler; sigemptyset(&sigint_action.sa_mask); sigint_action.sa_flags = 0; sigaction(SIGINT, &sigint_action, NULL); struct sigaction sigusr1_action; sigusr1_action.sa_handler = signal_handler; sigemptyset(&sigusr1_action.sa_mask); sigusr1_action.sa_flags = 0; sigaction(SIGUSR1, &sigusr1_action, NULL); } static bool parse_arguments(int argc, char *argv[]) { int opt; while ((opt = getopt(argc, argv, "i:")) != -1) { switch (opt) { case 'i': { monitor_iface.assign(optarg); break; } case '?': { if (isprint(optopt)) { LOG(ERROR) << "Unknown option -" << optopt << "!"; return false; } else { LOG(ERROR) << "Unknown character " << optopt << "!"; return false; } break; } } } return true; } int main(int argc, char *argv[]) { init_signals(); int openFds = sysconf(_SC_OPEN_MAX); for (int fd = 0; fd < openFds; fd++) { if ((fd != STDOUT_FILENO) && (fd != STDIN_FILENO) && (fd != STDERR_FILENO)) { close(fd); } } std::string module_description; if (beerocks::version::handle_version_query(argc, argv, module_description)) { return 0; } if (!parse_arguments(argc, argv)) { std::cout << "Usage: " << argv[0] << " -i <monitor iface>" << std::endl; return 0; } std::string slave_config_file_path = "./" + std::string(BEEROCKS_AGENT) + ".conf"; beerocks::config_file::sConfigSlave beerocks_slave_conf; if (!beerocks::config_file::read_slave_config_file(slave_config_file_path, beerocks_slave_conf)) { slave_config_file_path = BEEROCKS_CONF_PATH + std::string(BEEROCKS_AGENT) + ".conf"; if (!beerocks::config_file::read_slave_config_file(slave_config_file_path, beerocks_slave_conf)) { std::cout << "config file '" << slave_config_file_path << "' args error." << std::endl; return 1; } } std::string base_monitor_name = std::string(BEEROCKS_MONITOR) + "_" + monitor_iface; beerocks::logging logger(beerocks_slave_conf.sLog, base_monitor_name); s_pLogger = &logger; logger.apply_settings(); LOG(INFO) << std::endl << "Running " << base_monitor_name << " Version " << BEEROCKS_VERSION << " Build date " << BEEROCKS_BUILD_DATE << std::endl << std::endl; beerocks::version::log_version(argc, argv); if (logger.get_log_files_enabled()) { beerocks::os_utils::redirect_console_std(beerocks_slave_conf.sLog.files_path + base_monitor_name + "_std.log"); } beerocks::os_utils::kill_pid(beerocks_slave_conf.temp_path, base_monitor_name); beerocks::os_utils::write_pid_file(beerocks_slave_conf.temp_path, base_monitor_name); std::string pid_file_path = beerocks_slave_conf.temp_path + "pid/" + base_monitor_name; std::string slave_uds = beerocks_slave_conf.temp_path + std::string(BEEROCKS_SLAVE_UDS) + "_" + monitor_iface; son::monitor_thread monitor(slave_uds, monitor_iface, beerocks_slave_conf, logger); if (monitor.init()) { auto touch_time_stamp_timeout = std::chrono::steady_clock::now(); while (g_running) { if (s_signal) { handle_signal(); continue; } if (std::chrono::steady_clock::now() > touch_time_stamp_timeout) { beerocks::os_utils::touch_pid_file(pid_file_path); touch_time_stamp_timeout = std::chrono::steady_clock::now() + std::chrono::seconds(beerocks::TOUCH_PID_TIMEOUT_SECONDS); } if (!monitor.work()) { break; } } monitor.stop(); } else { LOG(ERROR) << "monitor.init(), iface=" << monitor_iface << " slave_uds=" << slave_uds; } s_pLogger = nullptr; return 0; }
#include "monitor_thread.h" #include <bcl/beerocks_logging.h> #include <bcl/beerocks_os_utils.h> #include <bcl/beerocks_version.h> #include <easylogging++.h> BEEROCKS_INIT_BEEROCKS_VERSION static bool g_running = true; static int s_signal = 0; static std::string monitor_iface; static beerocks::logging *s_pLogger = nullptr; static void handle_signal() { if (!s_signal) return; switch (s_signal) { case SIGTERM: case SIGINT: LOG(INFO) << "Caught signal '" << strsignal(s_signal) << "' Exiting..."; g_running = false; break; case SIGUSR1: { LOG(INFO) << "LOG Roll Signal!"; if (!s_pLogger) { LOG(ERROR) << "Invalid logger pointer!"; return; } s_pLogger->apply_settings(); LOG(INFO) << "--- Start of file after roll ---"; break; } default: LOG(WARNING) << "Unhandled Signal: '" << strsignal(s_signal) << "' Ignoring..."; break; } s_signal = 0; } static void init_signals() { auto signal_handler = [](int signum) { s_signal = signum; }; struct sigaction sigterm_action; sigterm_action.sa_handler = signal_handler; sigemptyset(&sigterm_action.sa_mask); sigterm_action.sa_flags = 0; sigaction(SIGTERM, &sigterm_action, NULL); struct sigaction sigint_action; sigint_action.sa_handler = signal_handler; sigemptyset(&sigint_action.sa_mask); sigint_action.sa_flags = 0; sigaction(SIGINT, &sigint_action, NULL); struct sigaction sigusr1_action; sigusr1_action.sa_handler = signal_handler; sigemptyset(&sigusr1_action.sa_mask); sigusr1_action.sa_flags = 0; sigaction(SIGUSR1, &sigusr1_action, NULL); } static bool parse_arguments(int argc, char *argv[]) { int opt; while ((opt = getopt(argc, argv, "i:")) != -1) { switch (opt) { case 'i': { monitor_iface.assign(optarg); break; } case '?': { if (isprint(optopt)) { LOG(ERROR) << "Unknown option -" << optopt << "!"; return false; } else { LOG(ERROR) << "Unknown character " << optopt << "!"; return false; } break; } } } return true; } int main(int argc, char *argv[]) { init_signals(); int openFds = sysconf(_SC_OPEN_MAX); for (int fd = 0; fd < openFds; fd++) { if ((fd != STDOUT_FILENO) && (fd != STDIN_FILENO) && (fd != STDERR_FILENO)) { close(fd); } } std::string module_description; if (beerocks::version::handle_version_query(argc, argv, module_description)) { return 0; }
std::string slave_config_file_path = "./" + std::string(BEEROCKS_AGENT) + ".conf"; beerocks::config_file::sConfigSlave beerocks_slave_conf; if (!beerocks::config_file::read_slave_config_file(slave_config_file_path, beerocks_slave_conf)) { slave_config_file_path = BEEROCKS_CONF_PATH + std::string(BEEROCKS_AGENT) + ".conf"; if (!beerocks::config_file::read_slave_config_file(slave_config_file_path, beerocks_slave_conf)) { std::cout << "config file '" << slave_config_file_path << "' args error." << std::endl; return 1; } } std::string base_monitor_name = std::string(BEEROCKS_MONITOR) + "_" + monitor_iface; beerocks::logging logger(beerocks_slave_conf.sLog, base_monitor_name); s_pLogger = &logger; logger.apply_settings(); LOG(INFO) << std::endl << "Running " << base_monitor_name << " Version " << BEEROCKS_VERSION << " Build date " << BEEROCKS_BUILD_DATE << std::endl << std::endl; beerocks::version::log_version(argc, argv); if (logger.get_log_files_enabled()) { beerocks::os_utils::redirect_console_std(beerocks_slave_conf.sLog.files_path + base_monitor_name + "_std.log"); } beerocks::os_utils::kill_pid(beerocks_slave_conf.temp_path, base_monitor_name); beerocks::os_utils::write_pid_file(beerocks_slave_conf.temp_path, base_monitor_name); std::string pid_file_path = beerocks_slave_conf.temp_path + "pid/" + base_monitor_name; std::string slave_uds = beerocks_slave_conf.temp_path + std::string(BEEROCKS_SLAVE_UDS) + "_" + monitor_iface; son::monitor_thread monitor(slave_uds, monitor_iface, beerocks_slave_conf, logger); if (monitor.init()) { auto touch_time_stamp_timeout = std::chrono::steady_clock::now(); while (g_running) { if (s_signal) { handle_signal(); continue; } if (std::chrono::steady_clock::now() > touch_time_stamp_timeout) { beerocks::os_utils::touch_pid_file(pid_file_path); touch_time_stamp_timeout = std::chrono::steady_clock::now() + std::chrono::seconds(beerocks::TOUCH_PID_TIMEOUT_SECONDS); } if (!monitor.work()) { break; } } monitor.stop(); } else { LOG(ERROR) << "monitor.init(), iface=" << monitor_iface << " slave_uds=" << slave_uds; } s_pLogger = nullptr; return 0; }
if (!parse_arguments(argc, argv)) { std::cout << "Usage: " << argv[0] << " -i <monitor iface>" << std::endl; return 0; }
if_condition
[ { "content": "struct json_object;\n\nnamespace mapf {\n", "file_path": "framework/common/include/mapf/common/logger.h", "rank": 0, "score": 203256.10839559737 }, { "content": "class Logger {\n\npublic:\n", "file_path": "framework/common/include/mapf/common/logger.h", "rank": 1, "...
C++
LinkedLists/lab2-1.cpp
eva-rubio/Data-Structures-and-Algorithms
97467f89a9a0dc928fd1f19301067dd565114470
#include<iostream> using namespace std; struct node { int num; node * next; }; void print(node * first); void prependNode(int userNum, node * & first); void deleteFirst(node * & first); void findMax(node * & first); int main() { node * first; node * last; char more_nodes = 'y'; int choice; int userNum; first = new node; cout << "What's the first number: "; cin >> first -> num; first -> next = NULL; last = first; while(more_nodes == 'y') { last -> next = new node; last = last -> next; cout << "What value do you want to put in the new box: "; cin >> last -> num; last -> next = NULL; print(first); cout << "Do you have more numbers to enter?"; cin >> more_nodes; } do { cout << "1. Print the list\n" << "2. Print the biggest number in the list\n" << "3. Prepend (add) a node to the beginning of the list\n" << "4. Delete the first node\n" << "5. Quit\n\n" << "What do you want to do: "; cin >> choice; if (choice == 1) { print(first); } else if (choice == 2) { findMax(first); } else if (choice == 3) { cout << "Please introduce the number to prepend to the list: " << endl; cin >> userNum; prependNode(userNum, first); } else if (choice == 4) { deleteFirst(first); } } while (choice != 5); return 0; } void print(node * first) { node * temp; temp = first; while(temp != NULL) { cout << temp -> num << endl; temp = temp -> next; } } void prependNode(int userNum, node * & first){ node * nodeToAdd; nodeToAdd = new node; nodeToAdd -> num = userNum; if (first != NULL){ nodeToAdd -> next = first; first = nodeToAdd; }else{ nodeToAdd -> next = NULL; first = nodeToAdd; print(first); } print(first); } void deleteFirst(node * & first){ if(first != NULL){ node * temp; temp = first; first = first -> next; delete temp; print(first); }else{ cout << "The list is already empty, cant delete anything!"; } } void findMax(node * & first){ int biggest = -1; while (first != NULL) { if (biggest < first->num) biggest = first->num; first = first->next; } cout << "The largest value in the list is: " << biggest << endl; }
#include<iostream> using namespace std; struct node { int num; node * next; }; void print(node * first); void prependNode(int userNum, node * & first); void deleteFirst(node * & first); void findMax(node * & first); int main() { node * first; node * last; char more_nodes = 'y'; int choice; int userNum; first = new node; cout << "What's the first number: "; cin >> first -> num; first -> next = NULL; last = first; while(more_nodes == 'y') { last -> next = new node; last = last -> next; cout << "What value do you want to put in the new box: "; cin >> last -> num; last -> next = NULL; print(first); cout << "Do you have more numbers to enter?"; cin >> more_nodes; } do { cout << "1. Print the list\n" << "2. Print the biggest number in the list\n" << "3. Prepend (add) a node to the beginning of the list\n" << "4. Delete the first node\n" << "5. Quit\n\n" << "What do you want to do: "; cin >> choice; if (choice == 1) { print(first); } else if (choice == 2) { findMax(first); } else if (choice == 3) { cout << "Please introduce the number to prepend to the list: " << endl; cin >> userNum; prependNode(userNum, first); } else if (choice == 4) { deleteFirst(first); } } while (choice != 5); return 0; } void print(node * first) { node * temp; temp = first; while(temp != NULL) { cout << temp -> num << endl; temp = temp -> next; } } void prependNode(int userNum, node * & first){ node * nodeToAdd; nodeToAdd = new node; nodeToAdd -> num = userNum; if (first != NULL){ nodeToAdd -> next = first; first = nodeToAdd; }else{ nodeToAdd -> next = NULL; first = nodeToAdd; print(first); } print(first); } void deleteFirst(node * & first){
} void findMax(node * & first){ int biggest = -1; while (first != NULL) { if (biggest < first->num) biggest = first->num; first = first->next; } cout << "The largest value in the list is: " << biggest << endl; }
if(first != NULL){ node * temp; temp = first; first = first -> next; delete temp; print(first); }else{ cout << "The list is already empty, cant delete anything!"; }
if_condition
[ { "content": "struct node {\n\n\tint numID;\t\t\t// A single integer field (called numID)\n\n\tstring name;\t\t// A single string field (called name)\n\n\tnode * next;\t\t// A pointer to the next node in the list\n\n};\n\n\n\nvoid print(node * first);\n\nvoid prepend(int userNum, string userName, node * & first...
C++
tumor2d/src/matrix.ipp
ICB-DCM/lookahead-study
b9849ce2b0cebbe55d6c9f7a248a5f4dff191007
#ifndef MATRIX_IPP #include <stdio.h> #include <stdlib.h> #include <math.h> #define SINGULAR 1e-16 template <class T> T **allocMatrix( int n, int m) { T **A = (T**) malloc( n*sizeof(T*)); for( int i=0; i<n; i++){ A[i] = (T*) malloc( m*sizeof(T)); for( int j=0; j<m; j++) A[i][j] = 0.; } return A; } template <class T> void freeMatrix( T** &A, int n) { for( int i=0; i<n; i++) free(A[i]); free(A); } template <class T> void vectorMatrixProduct( T* &v, T** &A, T* &u, int m, int n) { for( int j=0; j<n; j++){ u[j] = 0; for( int i=0; i<m; i++) u[j] += v[i] * A[i][j]; } } template <class T> void matrixVectorProduct( T** &A, T* &v, T* &u, int m, int n) { for( int i=0; i<m; i++){ u[i] = 0; for( int j=0; j<n; j++) u[i] += A[i][j] * v[j]; } } template <class T> T dotProduct( T* &v1, T* &v2, int n) { T dotProd = 0; for( int i=0; i<n; i++){ dotProd += v1[i] * v2[i]; } return dotProd; } template <class T> void decomposeGaussJordan( T** &A, T** &LR, int n) { for( int i=0; i<n; n++){ for( int j=i; j<n; j++){ for( int k=0; k<i-1; k++){ A[i][j] -= A[i][k] * A[k][j]; } } for( int j=i+1; j<n; j++){ for( int k=0; k<i-1; k++){ A[j][i] -= A[j][k] * A[k][i]; } A[j][i] /= A[i][i]; } } } template <class T> void decompCholeskyOwn( T** &A, T** &L, int n) { for( int i=0; i<n; i++) for( int j=0; j<=i; j++){ double Summe = A[i][j]; for( int k=0; k<=j-1; k++) Summe = Summe - L[i][k] * L[j][k]; if( i > j){ L[i][j] = Summe / L[j][j]; L[j][i] = 0.; } else if( Summe > 0) L[i][i] = sqrt( Summe); else fprintf( stderr, "Matrix not positive definite\n"); } } template <class T> void invertGaussJordan( T** &a, T** &ainv, int n) { int i, j; int s; int pzeile; int fehler = 0; double f; const double Epsilon = 0.01; double Maximum; FILE *fout = stdout; int pivot = 1; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { ainv[i][j] = 0.0; if (i == j) ainv[i][j] = 1.0; } } #if DEBUG MatOut (stdout, a, n, 2*n); #endif s = 0; do { Maximum = fabs(a[s][s]); if (pivot) { pzeile = s; for (i = s + 1; i < n; i++) if (fabs(a[i][s]) > Maximum) { Maximum = fabs(a[i][s]); pzeile = i; } } fehler = (Maximum < Epsilon); if (fehler) break; if (pivot) { if (pzeile != s) { double h; for (j = s; j < n; j++) { h = a[s][j]; a[s][j] = a[pzeile][j]; a[pzeile][j] = h; } for (j = 0; j < n; j++) { h = ainv[s][j]; ainv[s][j] = ainv[pzeile][j]; ainv[pzeile][j] = h; } } } f = a[s][s]; for (j = s; j < n; j++) a[s][j] = a[s][j] / f; for (j = 0; j < n; j++) ainv[s][j] = ainv[s][j] / f; for (i = 0; i < n; i++) { if (i != s) { f = -a[i][s]; for (j = s; j < n; j++) a[i][j] += f * a[s][j]; for (j = 0; j < n; j++) ainv[i][j] += f * ainv[s][j]; } } #if DEBUG fprintf(stdout, "Nach %1i-tem Eliminationschritt:\n", s+1); MatOut (stdout, a, n, 2*n); #endif s++; } while (s < n); if (fehler) { fprintf(fout, "Inverse: Matrix ist singulaer\n"); } } template <class T> void invertGaussJordan( T* &a, T* &ainv, int n) { int i, j; int s; int pzeile; int fehler = 0; double f; const double Epsilon = 0.01; double Maximum; FILE *fout = stdout; int pivot = 1; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { ainv[i*n+j] = 0.0; if (i == j) ainv[i*n+j] = 1.0; } } #if DEBUG MatOut (stdout, a, n, 2*n); #endif s = 0; do { Maximum = fabs(a[s*n+s]); if (pivot) { pzeile = s; for (i = s + 1; i < n; i++) if (fabs(a[i*n+s]) > Maximum) { Maximum = fabs(a[i*n+s]); pzeile = i; } } fehler = (Maximum < Epsilon); if (fehler) break; if (pivot) { if (pzeile != s) { double h; for (j = s; j < n; j++) { h = a[s*n+j]; a[s*n+j] = a[pzeile*n+j]; a[pzeile*n+j] = h; } for (j = 0; j < n; j++) { h = ainv[s*n+j]; ainv[s*n+j] = ainv[pzeile*n+j]; ainv[pzeile*n+j] = h; } } } f = a[s*n+s]; for (j = s; j < n; j++) a[s*n+j] = a[s*n+j] / f; for (j = 0; j < n; j++) ainv[s*n+j] = ainv[s*n+j] / f; for (i = 0; i < n; i++) { if (i != s) { f = -a[i*n+s]; for (j = s; j < n; j++) a[i*n+j] += f * a[s*n+j]; for (j = 0; j < n; j++) ainv[i*n+j] += f * ainv[s*n+j]; } } #if DEBUG fprintf(stdout, "Nach %1i-tem Eliminationschritt:\n", s+1); MatOut (stdout, a, n, 2*n); #endif s++; } while (s < n); if (fehler) { fprintf(fout, "Inverse: Matrix ist singulaer\n"); } } template <class T> void solveLinearSystemB( T **A, T *b, T *x, int dim, T **B) { int i, j; int k; for( i=0; i<dim; i++){ for( j=0; j<dim; j++){ B[i][j] = A[i][j]; } } for( k=0; k<dim; k++){ if(B[k][k]==0){ for( i=k+1; i<dim && B[i][k]==0; i++); if(i<dim && B[i][k]!=0){ T temp; for( j=k; j<dim; j++){ temp = B[i][j]; B[i][j] = B[k][j]; B[k][j] = temp; } temp = b[i]; b[i] = b[k]; b[k] = temp; } } if(B[k][k]!=0){ for( j=k+1; j<dim; j++) B[k][j]=B[k][j]/B[k][k]; b[k]=b[k]/B[k][k]; B[k][k]=1.; for( i=k+1; i<dim; i++){ for( j=k+1; j<dim; j++) B[i][j]=B[i][j]-B[i][k]*B[k][j]; b[i]=b[i]+b[k]*-B[i][k]; B[i][k]=0; } } } for( k=dim-1; k>=0; k--){ if( B[k][k]!=0) for( i=0; i<k; i++){ b[i]=b[i]+b[k]*-B[i][k]; B[i][k]=0; } } for( i=0; i<dim; i++) x[i] = b[i]; } template <class T> void solveLinearSystem( T **A, T *b, T *x, int dim) { T **B = allocMatrix<T>( dim, dim); if( B == NULL){ exit( 0); } solveLinearSystemB<T>( A, b, x, dim, B); freeMatrix( B, dim); } template <class T> void normalizeVector( T *x, int m){ T sum = 0; for( int j=0; j<m; j++) sum += x[j]; for( int j=0; j<m; j++) x[j] /= sum; } template <class T> T norm( T *x, int dim, int order = 0) { if( order == 0){ T max = 0; for( int i=0; i<dim; i++) max = fmax( fabs(x[i]), max); return max; }else{ T sum = 0; for( int i=0; i<dim; i++) sum += pow( x[i], order); return pow( sum, 1./order); } } template <class T> T norm_diff( T *x1, T *x2, int dim, int order = 0) { if( order == 0){ T max = 0; for( int i=0; i<dim; i++) max = fmax( fabs(x1[i]-x2[i]), max); return max; }else{ T sum = 0; for( int i=0; i<dim; i++) sum += pow( x1[i]-x2[i], order); return pow( sum, 1./order); } } template <class T> bool inbound( T *x, T *lb, T *ub, int d) { for( int i=0; i<d; i++) if( x[i] < lb[i] || x[i] > ub[i]) return false; return true; } template <class T> bool inbound( T *x, T lb, T ub, int d) { for( int i=0; i<d; i++) if( x[i] < lb || x[i] > ub) return false; return true; } template <class T> bool inbound( T *x, T lb, T ub, int d, char mode) { if( mode == 0){ for( int i=0; i<d; i++) if( x[i] < lb || x[i] > ub) return false; return true; } if( mode == 1){ for( int i=0; i<d; i++) if( x[i] >= lb && x[i] <= ub) return true; return false; } } #define MATRIX_IPP #endif
#ifndef MATRIX_IPP #include <stdio.h> #include <stdlib.h> #include <math.h> #define SINGULAR 1e-16 template <class T> T **allocMatrix( int n, int m) { T **A = (T**) malloc( n*sizeof(T*)); for( int i=0; i<n; i++){ A[i] = (T*) malloc( m*sizeof(T)); for( int j=0; j<m; j++) A[i][j] = 0.; } return A; } template <class T> void freeMatrix( T** &A, int n) { for( int i=0; i<n; i++) free(A[i]); free(A); } template <class T> void vectorMatrixProduct( T* &v, T** &A, T* &u, int m, int n) { for( int j=0; j<n; j++){ u[j] = 0; for( int i=0; i<m; i++) u[j] += v[i] * A[i][j]; } } template <class T> void matrixVectorProduct( T** &A, T* &v, T* &u, int m, int n) { for( int i=0; i<m; i++){ u[i] = 0; for( int j=0; j<n; j++) u[i] += A[i][j] * v[j]; } } template <class T> T dotProduct( T* &v1, T* &v2, int n) { T dotProd = 0; for( int i=0; i<n; i++){ dotProd += v1[i] * v2[i]; } return dotProd; } template <class T> void decomposeGaussJordan( T** &A, T** &LR, int n) { for( int i=0; i<n; n++){ for( int j=i; j<n; j++){ for( int k=0; k<i-1; k++){ A[i][j] -= A[i][k] * A[k][j]; } } for( int j=i+1; j<n; j++){ for( int k=0; k<i-1; k++){ A[j][i] -= A[j][k] * A[k][i]; } A[j][i] /= A[i][i]; } } } template <class T> void decompCholeskyOwn( T** &A, T** &L, int n) { for( int i=0; i<n; i++) for( int j=0; j<=i; j++){ double Summe = A[i][j]; for( int k=0; k<=j-1; k++) Summe = Summe - L[i][k] * L[j][k]; if( i > j){ L[i][j] = Summe / L[j][j]; L[j][i] = 0.; } else if( Summe > 0) L[i][i] = sqrt( Summe); else fprintf( stderr, "Matrix not positive definite\n"); } } template <class T> void invertGaussJordan( T** &a, T** &ainv, int n) { int i, j; int s; int pzeile; int fehler = 0; double f; const double Epsilon = 0.01; double Maximum; FILE *fout = stdout; int pivot = 1; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { ainv[i][j] = 0.0; if (i == j) ainv[i][j] = 1.0; } } #if DEBUG MatOut (stdout, a, n, 2*n); #endif s = 0; d
%1i-tem Eliminationschritt:\n", s+1); MatOut (stdout, a, n, 2*n); #endif s++; } while (s < n); if (fehler) { fprintf(fout, "Inverse: Matrix ist singulaer\n"); } } template <class T> void solveLinearSystemB( T **A, T *b, T *x, int dim, T **B) { int i, j; int k; for( i=0; i<dim; i++){ for( j=0; j<dim; j++){ B[i][j] = A[i][j]; } } for( k=0; k<dim; k++){ if(B[k][k]==0){ for( i=k+1; i<dim && B[i][k]==0; i++); if(i<dim && B[i][k]!=0){ T temp; for( j=k; j<dim; j++){ temp = B[i][j]; B[i][j] = B[k][j]; B[k][j] = temp; } temp = b[i]; b[i] = b[k]; b[k] = temp; } } if(B[k][k]!=0){ for( j=k+1; j<dim; j++) B[k][j]=B[k][j]/B[k][k]; b[k]=b[k]/B[k][k]; B[k][k]=1.; for( i=k+1; i<dim; i++){ for( j=k+1; j<dim; j++) B[i][j]=B[i][j]-B[i][k]*B[k][j]; b[i]=b[i]+b[k]*-B[i][k]; B[i][k]=0; } } } for( k=dim-1; k>=0; k--){ if( B[k][k]!=0) for( i=0; i<k; i++){ b[i]=b[i]+b[k]*-B[i][k]; B[i][k]=0; } } for( i=0; i<dim; i++) x[i] = b[i]; } template <class T> void solveLinearSystem( T **A, T *b, T *x, int dim) { T **B = allocMatrix<T>( dim, dim); if( B == NULL){ exit( 0); } solveLinearSystemB<T>( A, b, x, dim, B); freeMatrix( B, dim); } template <class T> void normalizeVector( T *x, int m){ T sum = 0; for( int j=0; j<m; j++) sum += x[j]; for( int j=0; j<m; j++) x[j] /= sum; } template <class T> T norm( T *x, int dim, int order = 0) { if( order == 0){ T max = 0; for( int i=0; i<dim; i++) max = fmax( fabs(x[i]), max); return max; }else{ T sum = 0; for( int i=0; i<dim; i++) sum += pow( x[i], order); return pow( sum, 1./order); } } template <class T> T norm_diff( T *x1, T *x2, int dim, int order = 0) { if( order == 0){ T max = 0; for( int i=0; i<dim; i++) max = fmax( fabs(x1[i]-x2[i]), max); return max; }else{ T sum = 0; for( int i=0; i<dim; i++) sum += pow( x1[i]-x2[i], order); return pow( sum, 1./order); } } template <class T> bool inbound( T *x, T *lb, T *ub, int d) { for( int i=0; i<d; i++) if( x[i] < lb[i] || x[i] > ub[i]) return false; return true; } template <class T> bool inbound( T *x, T lb, T ub, int d) { for( int i=0; i<d; i++) if( x[i] < lb || x[i] > ub) return false; return true; } template <class T> bool inbound( T *x, T lb, T ub, int d, char mode) { if( mode == 0){ for( int i=0; i<d; i++) if( x[i] < lb || x[i] > ub) return false; return true; } if( mode == 1){ for( int i=0; i<d; i++) if( x[i] >= lb && x[i] <= ub) return true; return false; } } #define MATRIX_IPP #endif
o { Maximum = fabs(a[s][s]); if (pivot) { pzeile = s; for (i = s + 1; i < n; i++) if (fabs(a[i][s]) > Maximum) { Maximum = fabs(a[i][s]); pzeile = i; } } fehler = (Maximum < Epsilon); if (fehler) break; if (pivot) { if (pzeile != s) { double h; for (j = s; j < n; j++) { h = a[s][j]; a[s][j] = a[pzeile][j]; a[pzeile][j] = h; } for (j = 0; j < n; j++) { h = ainv[s][j]; ainv[s][j] = ainv[pzeile][j]; ainv[pzeile][j] = h; } } } f = a[s][s]; for (j = s; j < n; j++) a[s][j] = a[s][j] / f; for (j = 0; j < n; j++) ainv[s][j] = ainv[s][j] / f; for (i = 0; i < n; i++) { if (i != s) { f = -a[i][s]; for (j = s; j < n; j++) a[i][j] += f * a[s][j]; for (j = 0; j < n; j++) ainv[i][j] += f * ainv[s][j]; } } #if DEBUG fprintf(stdout, "Nach %1i-tem Eliminationschritt:\n", s+1); MatOut (stdout, a, n, 2*n); #endif s++; } while (s < n); if (fehler) { fprintf(fout, "Inverse: Matrix ist singulaer\n"); } } template <class T> void invertGaussJordan( T* &a, T* &ainv, int n) { int i, j; int s; int pzeile; int fehler = 0; double f; const double Epsilon = 0.01; double Maximum; FILE *fout = stdout; int pivot = 1; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { ainv[i*n+j] = 0.0; if (i == j) ainv[i*n+j] = 1.0; } } #if DEBUG MatOut (stdout, a, n, 2*n); #endif s = 0; do { Maximum = fabs(a[s*n+s]); if (pivot) { pzeile = s; for (i = s + 1; i < n; i++) if (fabs(a[i*n+s]) > Maximum) { Maximum = fabs(a[i*n+s]); pzeile = i; } } fehler = (Maximum < Epsilon); if (fehler) break; if (pivot) { if (pzeile != s) { double h; for (j = s; j < n; j++) { h = a[s*n+j]; a[s*n+j] = a[pzeile*n+j]; a[pzeile*n+j] = h; } for (j = 0; j < n; j++) { h = ainv[s*n+j]; ainv[s*n+j] = ainv[pzeile*n+j]; ainv[pzeile*n+j] = h; } } } f = a[s*n+s]; for (j = s; j < n; j++) a[s*n+j] = a[s*n+j] / f; for (j = 0; j < n; j++) ainv[s*n+j] = ainv[s*n+j] / f; for (i = 0; i < n; i++) { if (i != s) { f = -a[i*n+s]; for (j = s; j < n; j++) a[i*n+j] += f * a[s*n+j]; for (j = 0; j < n; j++) ainv[i*n+j] += f * ainv[s*n+j]; } } #if DEBUG fprintf(stdout, "Nach
random
[ { "content": "extern SparseMatrix *J;\n", "file_path": "tumor2d/src/SparseMatrix.h", "rank": 0, "score": 140394.67320057453 }, { "content": "extern float *v1;\n", "file_path": "tumor2d/src/SparseMatrix.h", "rank": 1, "score": 140394.67320057453 }, { "content": "extern flo...
C++
gpAux/extensions/gps3ext/test/s3utils_test.cpp
chrishajas/gpdb
564b9235a46e2ead1650b753b2d070796cced6f6
#include "s3utils.cpp" #include "gtest/gtest.h" #define __STDC_FORMAT_MACROS #include <inttypes.h> TEST(Utils, simplecurl) { CURL *c = CreateCurlHandler(NULL); EXPECT_EQ(c, (void *)NULL); c = CreateCurlHandler("www.google.com"); EXPECT_NE(c, (void *)NULL); curl_easy_cleanup(c); } TEST(Utils, nth) { const char *teststr = "aaabbbcccaaatttaaa"; EXPECT_EQ(find_Nth(teststr, 0, "aaa"), -1); EXPECT_EQ(find_Nth(teststr, 1, "aaa"), 0); EXPECT_EQ(find_Nth(teststr, 2, "aaa"), 9); EXPECT_EQ(find_Nth(teststr, 3, "aaa"), 15); EXPECT_EQ(find_Nth(teststr, 1, "abc"), -1); EXPECT_EQ(find_Nth(teststr, 1, ""), 0); } #define MD5TESTBUF "abcdefghijklmnopqrstuvwxyz\n" TEST(Utils, md5) { MD5Calc m; m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); EXPECT_STREQ("e302f9ecd2d189fa80aac1c3392e9b9c", m.Get()); m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); EXPECT_STREQ("3f8c2c6e2579e864071c33919fac61ee", m.Get()); } #define TEST_STRING "The quick brown fox jumps over the lazy dog" TEST(Utils, sha256) { char hash_str[65] = {0}; EXPECT_TRUE(sha256_hex(TEST_STRING, hash_str)); EXPECT_STREQ("d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592", hash_str); } TEST(Utils, sha1hmac) { char hash_hex[41] = {0}; EXPECT_TRUE(sha1hmac_hex(TEST_STRING, (char *)hash_hex, "key", 3)); EXPECT_STREQ("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9", hash_hex); } TEST(Utils, sha256hmac) { char hash_str[65] = {0}; EXPECT_TRUE(sha256hmac_hex(TEST_STRING, hash_str, "key", 3)); EXPECT_STREQ("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8", hash_str); } TEST(Utils, ConfigNull) { Config c1(NULL); uint64_t value = 0; EXPECT_FALSE(c1.Scan("configtest", "config7", "%" PRIu64, &value)); Config c2(""); EXPECT_FALSE(c2.Scan("configtest", "config7", "%" PRIu64, &value)); string str; Config c3(str); EXPECT_FALSE(c3.Scan("configtest", "config7", "%" PRIu64, &value)); } TEST(Utils, Config) { Config c("data/s3test.conf"); EXPECT_EQ(c.Get("configtest", "config1", "aaaaaa"), "abcdefg"); EXPECT_EQ(c.Get("configtest", "config2", "tttt"), "12345"); EXPECT_EQ(c.Get("configtest", "config3", "tttt"), "aaaaa"); EXPECT_EQ(c.Get("configtest", "config4", "tttt"), "123"); EXPECT_EQ(c.Get("configtest", "config5", "tttt"), "tttt"); EXPECT_EQ(c.Get("configtest", "config6", "tttt"), "tttt"); EXPECT_EQ(c.Get("configtest", "config7", "xx"), "xx"); EXPECT_EQ(c.Get("configtest", "", "xx"), "xx"); EXPECT_EQ(c.Get("configtest", "config7", ""), ""); EXPECT_EQ(c.Get("configtest", "", "xx"), "xx"); uint64_t value = 0; EXPECT_TRUE(c.Scan("configtest", "config2", "%" PRIu64, &value)); EXPECT_EQ(value, 12345); EXPECT_TRUE(c.Scan("configtest", "config4", "%" PRIu64, &value)); EXPECT_EQ(value, 123); EXPECT_FALSE(c.Scan("configtest", "config7", "%" PRIu64, &value)); EXPECT_FALSE(c.Scan("", "config7", "%" PRIu64, &value)); EXPECT_FALSE(c.Scan("configtest", "", "%" PRIu64, &value)); EXPECT_FALSE(c.Scan("configtest", "config5", "%" PRIu64, &value)); char str[128]; EXPECT_TRUE(c.Scan("configtest", "config3", "%s", str)); EXPECT_STREQ(str, "aaaaa"); } TEST(Utils, UriCoding) { string src1 = "This is a simple & short test."; string src2 = "$ & < > ? ; # : = , \" ' ~ + %-_"; string src3 = "! * ' ( ) ; : @ & = + $ , / ? % # [ ]"; string src4 = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i " "j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 - _ . ~"; string dst1 = "This%20is%20a%20simple%20%26%20short%20test."; string dst2 = "%24%20%26%20%3C%20%3E%20%3F%20%3B%20%23%20%3A%20%3D%20%2C%20%22%20%27%" "20~%20%2B%20%25-_"; string dst3 = "%21%20%2A%20%27%20%28%20%29%20%3B%20%3A%20%40%20%26%20%3D%20%2B%20%24%" "20%2C%20%2F%20%3F%20%25%20%23%20%5B%20%5D"; string dst4 = "A%20B%20C%20D%20E%20F%20G%20H%20I%20J%20K%20L%20M%20N%20O%20P%20Q%20R%" "20S%20T%20U%20V%20W%20X%20Y%20Z%20a%20b%20c%20d%20e%20f%20g%20h%20i%" "20j%20k%20l%20m%20n%20o%20p%20q%20r%20s%20t%20u%20v%20w%20x%20y%20z%" "200%201%202%203%204%205%206%207%208%209%20-%20_%20.%20~"; EXPECT_EQ(dst1, uri_encode(src1)); EXPECT_EQ(dst2, uri_encode(src2)); EXPECT_EQ(dst3, uri_encode(src3)); EXPECT_EQ(dst4, uri_encode(src4)); EXPECT_EQ(src1, uri_decode(dst1)); EXPECT_EQ(src2, uri_decode(dst2)); EXPECT_EQ(src3, uri_decode(dst3)); EXPECT_EQ(src4, uri_decode(dst4)); } TEST(Utils, find_replace) { string str1 = "This is a simple & short test."; find_replace(str1, "simple", ""); EXPECT_EQ("This is a & short test.", str1); find_replace(str1, "short ", ""); EXPECT_EQ("This is a & test.", str1); find_replace(str1, "test.", ""); EXPECT_EQ("This is a & ", str1); find_replace(str1, "This", ""); EXPECT_EQ(" is a & ", str1); find_replace(str1, "is a", "abcdefghijklmn"); EXPECT_EQ(" abcdefghijklmn & ", str1); find_replace(str1, " a", "a"); EXPECT_EQ("abcdefghijklmn & ", str1); find_replace(str1, "abc", "abcabc"); EXPECT_EQ("abcabcdefghijklmn & ", str1); }
#include "s3utils.cpp" #include "gtest/gtest.h" #define __STDC_FORMAT_MACROS #include <inttypes.h> TEST(Utils, simplecurl) { CURL *c = CreateCurlHandler(NULL); EXPECT_EQ(c, (void *)NULL); c = CreateCurlHandler("www.google.com"); EXPECT_NE(c, (void *)NULL); curl_easy_cleanup(c); } TEST(Utils, nth) { const char *teststr = "aaabbbcccaaatttaaa"; EXPECT_EQ(find_Nth(teststr, 0, "aaa"), -1); EXPECT_EQ(find_Nth(teststr, 1, "aaa"), 0); EXPECT_EQ(find_Nth(teststr, 2, "aaa"), 9); EXPECT_EQ(find_Nth(teststr, 3, "aaa"), 15); EXPECT_EQ(find_Nth(teststr, 1, "abc"), -1); EXPECT_EQ(find_Nth(teststr, 1, ""), 0); } #define MD5TESTBUF "abcdefghijklmnopqrstuvwxyz\n" TEST(Utils, md5) { MD5Calc m; m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); EXPECT_STREQ("e302f9ecd2d189fa80aac1c3392e9b9c", m.Get()); m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); m.Update(MD5TESTBUF, strlen(MD5TESTBUF)); EXPECT_STREQ("3f8c2c6e2579e864071c33919fac61ee", m.Get()); } #define TEST_STRING "The quick brown fox jumps over the lazy dog" TEST(Utils, sha256) { char hash_str[65] = {0}; EXPECT_TRUE(sha256_hex(TEST_STRING, hash_str)); EXPECT_STREQ("d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592", hash_str); } TEST(Utils, sha1hmac) { char hash_hex[41] = {0}; EXPECT_TRUE(sha1hmac_hex(TEST_STRING, (char *)hash_hex, "key", 3)); EXPECT_STREQ("de7c9b85b8b78aa6bc8a7a36f70a90701c9db4d9", hash_hex); } TEST(Utils, sha256hmac) { char hash_str[65] = {0}; EXPECT_TRUE(sha256hmac_hex(TEST_STRING, hash_str, "key", 3)); EXPECT_STREQ("f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8", hash_str); } TEST(Utils, ConfigNull) { Config c1(NULL); uint64_t value = 0; EXPECT_FALSE(c1.Scan("configtest", "config7", "%" PRIu64, &value)); Config c2(""); EXPECT_FALSE(c2.Scan("configtest", "config7", "%" PRIu64, &value)); string str; Config c3(str); EXPECT_FALSE(c3.Scan("configtest", "config7", "%" PRIu64, &value)); } TEST(Utils, Config) { Config c("data/s3test.conf"); EXPECT_EQ(c.Get("configtest", "config1", "aaaaaa"), "abcdefg"); EXPECT_EQ(c.Get("configtest", "config2", "tttt"), "12345"); EXPECT_EQ(c.Get("configtest", "config3", "tttt"), "aaaaa"); EXPECT_EQ(c.Get("configtest", "config4", "tttt"), "123"); EXPECT_EQ(c.Get("configtest", "config5", "tttt"), "tttt"); EXPECT_EQ(c.Get("configtest", "config6", "tttt"), "tttt"); EXPECT_EQ(c.Get("configtest", "config7", "xx"), "xx"); EXPECT_EQ(c.Get("configtest", "", "xx"), "xx"); EXPECT_EQ(c.Get("configtest", "config7", ""), ""); EXPECT_EQ(c.Get("configtest", "", "xx"), "xx"); uint64_t value = 0; EXPECT_TRUE(c.Scan("configtest", "config2", "%" PRIu64, &value)); EXPECT_EQ(value, 12345); EXPECT_TRUE(c.Scan("configtest", "config4", "%" PRIu64, &value)); EXPECT_EQ(value, 123); EXPECT_FALSE(c.Scan("configtest", "config7", "%" PRIu64, &value)); EXPECT_FALSE(c.Scan("", "config7", "%" PRIu64, &value)); EXPECT_FALSE(c.Scan("configtest", "", "%" PRIu64, &value)); EXPECT_FALSE(c.Scan("configtest", "config5", "%" PRIu64, &value)); char str[128]; EXPECT_TRUE(c.Scan("configtest", "config3", "%s", str)); EXPECT_STREQ(str, "aaaaa"); } TEST(Utils, UriCoding) { string src1 = "This is a simple & short test."; string src2 = "$ & < > ? ; # : = , \" ' ~ + %-_"; string src3 = "! * ' ( ) ; : @ & = + $ , / ? % # [ ]"; string src4 = "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i " "j k l m n o p q r s t u v w x y z 0 1 2 3 4 5 6 7 8 9 - _ . ~"; string dst1 = "This%20is%20a%20simple%20%26%20short%20test."; string dst2 = "%24%20%26%20%3C%20%3E%20%3F%20%3B%20%23%20%3A%20%3D%20%2C%20%22%20%27%" "20~%20%2B%20%25-_"; string dst3 = "%21%20%2A%20%27%20%28%20%29%20%3B%20%3A%20%40%20%26%20%3D%20%2B%20%24%" "20%2C%20%2F%20%3F%20%25%20%23%20%5B%20%5D"; string dst4 = "A%20B%20C%20D%20E%20F%20G%20H%20I%20J%20K%20L%20M%20N%20O%20P%20Q%20R%" "20S%20T%20U%20V%20W%20X%20Y%20Z%20a%20b%20c%20d%20e%20f%20g%20h%20i%" "20j%20k%20l%20m%20n%20o%20p%20q%20r%20s%20t%20u%20v%20w%20x%20y%20z%" "200%201%202%203%204%205%206%207%208%209%20-%20_%20.%20~"; EXPECT_EQ(dst1, uri_encode(src1)); EXPECT_EQ(dst2, uri_encode(src2)); EXPECT_EQ(dst3, uri_encode(src3)); EXPECT_EQ(dst4, uri_encode(src4)); EXPECT_EQ(src1, uri_decode(dst1)); EXPECT_EQ(src2, uri_decode(dst2)); EXPECT_EQ(src3, uri_decode(dst3)
"); EXPECT_EQ("This is a & ", str1); find_replace(str1, "This", ""); EXPECT_EQ(" is a & ", str1); find_replace(str1, "is a", "abcdefghijklmn"); EXPECT_EQ(" abcdefghijklmn & ", str1); find_replace(str1, " a", "a"); EXPECT_EQ("abcdefghijklmn & ", str1); find_replace(str1, "abc", "abcabc"); EXPECT_EQ("abcabcdefghijklmn & ", str1); }
); EXPECT_EQ(src4, uri_decode(dst4)); } TEST(Utils, find_replace) { string str1 = "This is a simple & short test."; find_replace(str1, "simple", ""); EXPECT_EQ("This is a & short test.", str1); find_replace(str1, "short ", ""); EXPECT_EQ("This is a & test.", str1); find_replace(str1, "test.", "
random
[ { "content": "SELECT regexp_split_to_array('the quick brown fox jumped over the lazy dog', '');\n", "file_path": "src/test/regress/sql/strings.sql", "rank": 0, "score": 651884.2648369842 }, { "content": "SELECT regexp_split_to_array('the quick brown fox jumped over the lazy dog', 'nomatch');...
C++
toolsrc/src/vcpkg/parse.cpp
TheScarfix/vcpkg
8db6db5dac70c25b04cd4dd84392484dee822fbe
#include "pch.h" #include <utility> #include <vcpkg/base/system.print.h> #include <vcpkg/base/util.h> #include <vcpkg/packagespec.h> #include <vcpkg/paragraphparser.h> #include <vcpkg/parse.h> using namespace vcpkg; namespace vcpkg::Parse { std::string ParseError::format() const { return Strings::concat("Error: ", origin, ":", row, ":", column, ": ", message, "\n" " on expression: \"", line, "\"\n", " ", std::string(column - 1, ' '), "^\n"); } void ParserBase::add_error(std::string message, const ParserBase::SourceLoc& loc) { if (!m_err) { auto linestart = loc.it; while (linestart != m_text.c_str()) { if (linestart[-1] == '\n') break; --linestart; } auto lineend = loc.it; while (*lineend != '\n' && *lineend != '\r' && *lineend != '\0') ++lineend; m_err.reset( new ParseError(m_origin.c_str(), loc.row, loc.column, {linestart, lineend}, std::move(message))); } skip_to_eof(); } static Optional<std::string> remove_field(RawParagraph* fields, const std::string& fieldname) { auto it = fields->find(fieldname); if (it == fields->end()) { return nullopt; } const std::string value = std::move(it->second); fields->erase(it); return value; } void ParagraphParser::required_field(const std::string& fieldname, std::string& out) { auto maybe_field = remove_field(&fields, fieldname); if (const auto field = maybe_field.get()) out = std::move(*field); else missing_fields.push_back(fieldname); } std::string ParagraphParser::optional_field(const std::string& fieldname) const { return remove_field(&fields, fieldname).value_or(""); } std::unique_ptr<ParseControlErrorInfo> ParagraphParser::error_info(const std::string& name) const { if (!fields.empty() || !missing_fields.empty()) { auto err = std::make_unique<ParseControlErrorInfo>(); err->name = name; err->extra_fields = Util::extract_keys(fields); err->missing_fields = std::move(missing_fields); return err; } return nullptr; } template<class T, class F> static Optional<std::vector<T>> parse_list_until_eof(StringLiteral plural_item_name, Parse::ParserBase& parser, F f) { std::vector<T> ret; parser.skip_whitespace(); if (parser.at_eof()) return std::vector<T>{}; do { auto item = f(parser); if (!item) return nullopt; ret.push_back(std::move(item).value_or_exit(VCPKG_LINE_INFO)); parser.skip_whitespace(); if (parser.at_eof()) return {std::move(ret)}; if (parser.cur() != ',') { parser.add_error(Strings::concat("expected ',' or end of text in ", plural_item_name, " list")); return nullopt; } parser.next(); parser.skip_whitespace(); } while (true); } ExpectedS<std::vector<std::string>> parse_default_features_list(const std::string& str, CStringView origin) { Parse::ParserBase parser; parser.init(str, origin); auto opt = parse_list_until_eof<std::string>("default features", parser, &parse_feature_name); if (!opt) return {parser.get_error()->format(), expected_right_tag}; return {std::move(opt).value_or_exit(VCPKG_LINE_INFO), expected_left_tag}; } ExpectedS<std::vector<ParsedQualifiedSpecifier>> parse_qualified_specifier_list(const std::string& str, CStringView origin) { Parse::ParserBase parser; parser.init(str, origin); auto opt = parse_list_until_eof<ParsedQualifiedSpecifier>( "dependencies", parser, [](ParserBase& parser) { return parse_qualified_specifier(parser); }); if (!opt) return {parser.get_error()->format(), expected_right_tag}; return {std::move(opt).value_or_exit(VCPKG_LINE_INFO), expected_left_tag}; } ExpectedS<std::vector<Dependency>> parse_dependencies_list(const std::string& str, CStringView origin) { Parse::ParserBase parser; parser.init(str, origin); auto opt = parse_list_until_eof<Dependency>("dependencies", parser, [](ParserBase& parser) { auto loc = parser.cur_loc(); return parse_qualified_specifier(parser).then([&](ParsedQualifiedSpecifier&& pqs) -> Optional<Dependency> { if (pqs.triplet) { parser.add_error("triplet specifier not allowed in this context", loc); return nullopt; } return Dependency{{pqs.name, pqs.features.value_or({})}, pqs.qualifier.value_or({})}; }); }); if (!opt) return {parser.get_error()->format(), expected_right_tag}; return {std::move(opt).value_or_exit(VCPKG_LINE_INFO), expected_left_tag}; } }
#include "pch.h" #include <utility> #include <vcpkg/base/system.print.h> #include <vcpkg/base/util.h> #include <vcpkg/packagespec.h> #include <vcpkg/paragraphparser.h> #include <vcpkg/parse.h> using namespace vcpkg; namespace vcpkg::Parse { std::string ParseError::format() const { return Strings::concat("Error: ", origin, ":", row, ":", column, ": ", message, "\n" " on expression: \"
_whitespace(); } while (true); } ExpectedS<std::vector<std::string>> parse_default_features_list(const std::string& str, CStringView origin) { Parse::ParserBase parser; parser.init(str, origin); auto opt = parse_list_until_eof<std::string>("default features", parser, &parse_feature_name); if (!opt) return {parser.get_error()->format(), expected_right_tag}; return {std::move(opt).value_or_exit(VCPKG_LINE_INFO), expected_left_tag}; } ExpectedS<std::vector<ParsedQualifiedSpecifier>> parse_qualified_specifier_list(const std::string& str, CStringView origin) { Parse::ParserBase parser; parser.init(str, origin); auto opt = parse_list_until_eof<ParsedQualifiedSpecifier>( "dependencies", parser, [](ParserBase& parser) { return parse_qualified_specifier(parser); }); if (!opt) return {parser.get_error()->format(), expected_right_tag}; return {std::move(opt).value_or_exit(VCPKG_LINE_INFO), expected_left_tag}; } ExpectedS<std::vector<Dependency>> parse_dependencies_list(const std::string& str, CStringView origin) { Parse::ParserBase parser; parser.init(str, origin); auto opt = parse_list_until_eof<Dependency>("dependencies", parser, [](ParserBase& parser) { auto loc = parser.cur_loc(); return parse_qualified_specifier(parser).then([&](ParsedQualifiedSpecifier&& pqs) -> Optional<Dependency> { if (pqs.triplet) { parser.add_error("triplet specifier not allowed in this context", loc); return nullopt; } return Dependency{{pqs.name, pqs.features.value_or({})}, pqs.qualifier.value_or({})}; }); }); if (!opt) return {parser.get_error()->format(), expected_right_tag}; return {std::move(opt).value_or_exit(VCPKG_LINE_INFO), expected_left_tag}; } }
", line, "\"\n", " ", std::string(column - 1, ' '), "^\n"); } void ParserBase::add_error(std::string message, const ParserBase::SourceLoc& loc) { if (!m_err) { auto linestart = loc.it; while (linestart != m_text.c_str()) { if (linestart[-1] == '\n') break; --linestart; } auto lineend = loc.it; while (*lineend != '\n' && *lineend != '\r' && *lineend != '\0') ++lineend; m_err.reset( new ParseError(m_origin.c_str(), loc.row, loc.column, {linestart, lineend}, std::move(message))); } skip_to_eof(); } static Optional<std::string> remove_field(RawParagraph* fields, const std::string& fieldname) { auto it = fields->find(fieldname); if (it == fields->end()) { return nullopt; } const std::string value = std::move(it->second); fields->erase(it); return value; } void ParagraphParser::required_field(const std::string& fieldname, std::string& out) { auto maybe_field = remove_field(&fields, fieldname); if (const auto field = maybe_field.get()) out = std::move(*field); else missing_fields.push_back(fieldname); } std::string ParagraphParser::optional_field(const std::string& fieldname) const { return remove_field(&fields, fieldname).value_or(""); } std::unique_ptr<ParseControlErrorInfo> ParagraphParser::error_info(const std::string& name) const { if (!fields.empty() || !missing_fields.empty()) { auto err = std::make_unique<ParseControlErrorInfo>(); err->name = name; err->extra_fields = Util::extract_keys(fields); err->missing_fields = std::move(missing_fields); return err; } return nullptr; } template<class T, class F> static Optional<std::vector<T>> parse_list_until_eof(StringLiteral plural_item_name, Parse::ParserBase& parser, F f) { std::vector<T> ret; parser.skip_whitespace(); if (parser.at_eof()) return std::vector<T>{}; do { auto item = f(parser); if (!item) return nullopt; ret.push_back(std::move(item).value_or_exit(VCPKG_LINE_INFO)); parser.skip_whitespace(); if (parser.at_eof()) return {std::move(ret)}; if (parser.cur() != ',') { parser.add_error(Strings::concat("expected ',' or end of text in ", plural_item_name, " list")); return nullopt; } parser.next(); parser.skip
random
[ { "content": "namespace vcpkg::Util\n\n{\n\n template<class Container>\n\n using ElementT =\n\n std::remove_reference_t<decltype(*std::declval<typename std::remove_reference_t<Container>::iterator>())>;\n\n\n\n namespace Vectors\n\n {\n\n template<class Container, class T = ElementT<Co...
C++
fly/logger/detail/win/styler_proxy_impl.cpp
ExternalRepositories/libfly
5acfc424a68031c0004b3c1cb5bef9d76dd129fb
#include "fly/logger/detail/win/styler_proxy_impl.hpp" namespace fly::logger::detail { StylerProxyImpl::StylerProxyImpl( std::ostream &stream, std::stack<fly::logger::Style> &&styles, std::stack<fly::logger::Color> &&colors, std::stack<fly::logger::Cursor> &&cursors) noexcept : StylerProxy(stream) { if (m_stream_is_stdout) { m_handle = ::GetStdHandle(STD_OUTPUT_HANDLE); } else if (m_stream_is_stderr) { m_handle = ::GetStdHandle(STD_ERROR_HANDLE); } if (m_handle == INVALID_HANDLE_VALUE) { return; } CONSOLE_SCREEN_BUFFER_INFO console_info; if (!::GetConsoleScreenBufferInfo(m_handle, &console_info)) { m_handle = INVALID_HANDLE_VALUE; return; } if (!styles.empty() || !colors.empty()) { apply_styles_and_colors(console_info, std::move(styles), std::move(colors)); } if (!cursors.empty()) { apply_cursors(console_info, std::move(cursors)); } } StylerProxyImpl::~StylerProxyImpl() { if (m_did_apply_style_or_color) { ::SetConsoleTextAttribute(m_handle, m_original_attributes); } } template <> void StylerProxyImpl::apply_value<WORD, fly::logger::Style>( WORD &attributes, const fly::logger::Style &modifier) { switch (modifier) { case fly::logger::Style::Bold: attributes |= FOREGROUND_INTENSITY; break; case fly::logger::Style::Underline: attributes |= COMMON_LVB_UNDERSCORE; break; default: break; } } template <> void StylerProxyImpl::apply_value<WORD, fly::logger::Color>( WORD &attributes, const fly::logger::Color &modifier) { auto apply_color = [&attributes, &modifier](bool red, bool green, bool blue) { if (modifier.m_plane == fly::logger::Color::Foreground) { attributes = red ? (attributes | FOREGROUND_RED) : (attributes & ~FOREGROUND_RED); attributes = green ? (attributes | FOREGROUND_GREEN) : (attributes & ~FOREGROUND_GREEN); attributes = blue ? (attributes | FOREGROUND_BLUE) : (attributes & ~FOREGROUND_BLUE); } else { attributes = red ? (attributes | BACKGROUND_RED) : (attributes & ~BACKGROUND_RED); attributes = green ? (attributes | BACKGROUND_GREEN) : (attributes & ~BACKGROUND_GREEN); attributes = blue ? (attributes | BACKGROUND_BLUE) : (attributes & ~BACKGROUND_BLUE); } }; switch (modifier.m_color) { case fly::logger::Color::Black: apply_color(false, false, false); break; case fly::logger::Color::Red: apply_color(true, false, false); break; case fly::logger::Color::Green: apply_color(false, true, false); break; case fly::logger::Color::Blue: apply_color(false, false, true); break; case fly::logger::Color::Yellow: apply_color(true, true, false); break; case fly::logger::Color::Magenta: apply_color(true, false, true); break; case fly::logger::Color::Cyan: apply_color(false, true, true); break; case fly::logger::Color::White: apply_color(true, true, true); break; } } template <> void StylerProxyImpl::apply_value<COORD, fly::logger::Cursor>( COORD &attributes, const fly::logger::Cursor &modifier) { const std::uint8_t &distance = modifier.m_distance; switch (modifier.m_direction) { case fly::logger::Cursor::Up: attributes.Y = (attributes.Y > distance) ? (attributes.Y - distance) : 0; break; case fly::logger::Cursor::Down: attributes.Y += distance; break; case fly::logger::Cursor::Forward: attributes.X += distance; break; case fly::logger::Cursor::Backward: attributes.X = (attributes.X > distance) ? (attributes.X - distance) : 0; break; } } void StylerProxyImpl::apply_styles_and_colors( const CONSOLE_SCREEN_BUFFER_INFO &console_info, std::stack<fly::logger::Style> &&styles, std::stack<fly::logger::Color> &&colors) { m_original_attributes = console_info.wAttributes; WORD attributes = m_original_attributes; for (; !styles.empty(); styles.pop()) { apply_value(attributes, styles.top()); } for (; !colors.empty(); colors.pop()) { apply_value(attributes, colors.top()); } m_did_apply_style_or_color = ::SetConsoleTextAttribute(m_handle, attributes); } void StylerProxyImpl::apply_cursors( const CONSOLE_SCREEN_BUFFER_INFO &console_info, std::stack<fly::logger::Cursor> &&cursors) { COORD cursor_position = console_info.dwCursorPosition; for (; !cursors.empty(); cursors.pop()) { apply_value(cursor_position, cursors.top()); } ::SetConsoleCursorPosition(m_handle, cursor_position); } }
#include "fly/logger/detail/win/styler_proxy_impl.hpp" namespace fly::logger::detail { StylerProxyImpl::StylerProxyImpl( std::ostream &stream, std::stack<fly::logger::Style> &&styles, std::stack<fly::logger::Color> &&colors, std::stack<fly::logger::Cursor> &&cursors) noexcept : StylerProxy(stream) {
if (m_handle == INVALID_HANDLE_VALUE) { return; } CONSOLE_SCREEN_BUFFER_INFO console_info; if (!::GetConsoleScreenBufferInfo(m_handle, &console_info)) { m_handle = INVALID_HANDLE_VALUE; return; } if (!styles.empty() || !colors.empty()) { apply_styles_and_colors(console_info, std::move(styles), std::move(colors)); } if (!cursors.empty()) { apply_cursors(console_info, std::move(cursors)); } } StylerProxyImpl::~StylerProxyImpl() { if (m_did_apply_style_or_color) { ::SetConsoleTextAttribute(m_handle, m_original_attributes); } } template <> void StylerProxyImpl::apply_value<WORD, fly::logger::Style>( WORD &attributes, const fly::logger::Style &modifier) { switch (modifier) { case fly::logger::Style::Bold: attributes |= FOREGROUND_INTENSITY; break; case fly::logger::Style::Underline: attributes |= COMMON_LVB_UNDERSCORE; break; default: break; } } template <> void StylerProxyImpl::apply_value<WORD, fly::logger::Color>( WORD &attributes, const fly::logger::Color &modifier) { auto apply_color = [&attributes, &modifier](bool red, bool green, bool blue) { if (modifier.m_plane == fly::logger::Color::Foreground) { attributes = red ? (attributes | FOREGROUND_RED) : (attributes & ~FOREGROUND_RED); attributes = green ? (attributes | FOREGROUND_GREEN) : (attributes & ~FOREGROUND_GREEN); attributes = blue ? (attributes | FOREGROUND_BLUE) : (attributes & ~FOREGROUND_BLUE); } else { attributes = red ? (attributes | BACKGROUND_RED) : (attributes & ~BACKGROUND_RED); attributes = green ? (attributes | BACKGROUND_GREEN) : (attributes & ~BACKGROUND_GREEN); attributes = blue ? (attributes | BACKGROUND_BLUE) : (attributes & ~BACKGROUND_BLUE); } }; switch (modifier.m_color) { case fly::logger::Color::Black: apply_color(false, false, false); break; case fly::logger::Color::Red: apply_color(true, false, false); break; case fly::logger::Color::Green: apply_color(false, true, false); break; case fly::logger::Color::Blue: apply_color(false, false, true); break; case fly::logger::Color::Yellow: apply_color(true, true, false); break; case fly::logger::Color::Magenta: apply_color(true, false, true); break; case fly::logger::Color::Cyan: apply_color(false, true, true); break; case fly::logger::Color::White: apply_color(true, true, true); break; } } template <> void StylerProxyImpl::apply_value<COORD, fly::logger::Cursor>( COORD &attributes, const fly::logger::Cursor &modifier) { const std::uint8_t &distance = modifier.m_distance; switch (modifier.m_direction) { case fly::logger::Cursor::Up: attributes.Y = (attributes.Y > distance) ? (attributes.Y - distance) : 0; break; case fly::logger::Cursor::Down: attributes.Y += distance; break; case fly::logger::Cursor::Forward: attributes.X += distance; break; case fly::logger::Cursor::Backward: attributes.X = (attributes.X > distance) ? (attributes.X - distance) : 0; break; } } void StylerProxyImpl::apply_styles_and_colors( const CONSOLE_SCREEN_BUFFER_INFO &console_info, std::stack<fly::logger::Style> &&styles, std::stack<fly::logger::Color> &&colors) { m_original_attributes = console_info.wAttributes; WORD attributes = m_original_attributes; for (; !styles.empty(); styles.pop()) { apply_value(attributes, styles.top()); } for (; !colors.empty(); colors.pop()) { apply_value(attributes, colors.top()); } m_did_apply_style_or_color = ::SetConsoleTextAttribute(m_handle, attributes); } void StylerProxyImpl::apply_cursors( const CONSOLE_SCREEN_BUFFER_INFO &console_info, std::stack<fly::logger::Cursor> &&cursors) { COORD cursor_position = console_info.dwCursorPosition; for (; !cursors.empty(); cursors.pop()) { apply_value(cursor_position, cursors.top()); } ::SetConsoleCursorPosition(m_handle, cursor_position); } }
if (m_stream_is_stdout) { m_handle = ::GetStdHandle(STD_OUTPUT_HANDLE); } else if (m_stream_is_stderr) { m_handle = ::GetStdHandle(STD_ERROR_HANDLE); }
if_condition
[ { "content": "struct Color\n\n{\n\n /**\n\n * Constants for standard colors.\n\n *\n\n * On Linux and macOS, a color may be any value in the range [0, 255]. While only the 8 standard\n\n * colors are listed here, any 8-bit integer value may be cast to a color. The color values\n\n * corre...
C++
hoomd/dem/DEMEvaluator.cc
schwendp/hoomd-blue
df7970121b19bc4f8674348ab3241055ac87153b
#ifndef __DEMEVALUATOR_CC__ #define __DEMEVALUATOR_CC__ #include "DEMEvaluator.h" #include "WCAPotential.h" #include <assert.h> template<typename Real> DEVICE inline Real clip(const Real &x) { return (x >= 0)*(x + (x > 1)*(1 - x)); } template<typename Real, typename Real4, typename Potential> template<typename Vec, typename Torque> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::comCOM( const Vec &rij, Real &potential, Vec &force_i, Torque &torque_i, Vec &force_j, Torque &torque_j) const { m_potential.evaluate(rij, Vec(), rij, potential, force_i, torque_i, force_j, torque_j); } template<typename Real, typename Real4, typename Potential> template<typename Vec, typename Torque> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::vertexVertex( const Vec &rij, const Vec &r0, const Vec &r1, Real &potential, Vec &force_i, Torque &torque_i, Vec &force_j, Torque &torque_j, float modFactor) const { m_potential.evaluate(rij, r0, r1, potential, force_i, torque_i, force_j, torque_j, modFactor); } template<typename Real, typename Real4, typename Potential> template<typename Vec, typename Torque> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::vertexEdge( const Vec &rij, const Vec &r0, const Vec &r1, const Vec &r2, Real &potential, Vec &force_i, Torque &torque_i, Vec &force_j, Torque &torque_j, float modFactor) const { const Vec r10(r0 - (r1 + rij)); const Vec r12(r2 - r1); Real lambda(dot(r10, r12)/dot(r12, r12)); lambda = clip(lambda); const Vec rPrime(r1 + rij + lambda*r12); m_potential.evaluate(rij, r0, rPrime, potential, force_i, torque_i, force_j, torque_j, modFactor); } template<typename Real, typename Real4, typename Potential> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::vertexFace( const vec3<Real> &rij, const vec3<Real> &r0, const quat<Real> quatj, const Real4 *verticesj, const unsigned int *realIndicesj, const unsigned int *facesj, const unsigned int vertex0Index, Real &potential, vec3<Real> &force_i, vec3<Real> &torque_i, vec3<Real> &force_j, vec3<Real> &torque_j) const { Real distsq(0); const vec3<Real> r0j(r0 - rij); vec3<Real> rPrime; const vec3<Real> vertex0(rotate(quatj, vec3<Real>(verticesj[realIndicesj[vertex0Index]]))); const vec3<Real> r0r0(r0j - vertex0); const vec3<Real> secondVertex(rotate(quatj, vec3<Real>(verticesj[realIndicesj[facesj[vertex0Index]]]))); const vec3<Real> rsec(secondVertex - vertex0); Real lambda(dot(r0r0, rsec)/dot(rsec, rsec)); lambda = clip(lambda); vec3<Real> closest(vertex0 + lambda*rsec); vec3<Real> closestr0(closest - r0j); Real closestDistsq(dot(closestr0, closestr0)); distsq = closestDistsq; rPrime = closest; vec3<Real> p1, p2(secondVertex), p01, p02(secondVertex - vertex0); unsigned int i(facesj[vertex0Index]); for(; facesj[i] != vertex0Index; i = facesj[i]) { Real alpha(0), beta(0); p1 = p2; p2 = rotate(quatj, vec3<Real>(verticesj[realIndicesj[facesj[i]]])); p01 = p02; p02 = p2 - vertex0; const vec3<Real> pc(cross(p01, p02)); Real magA(p01.x*(p02.y*pc.z - pc.y*p02.z) - p02.x*(p01.y*pc.z - pc.y*p01.z) + pc.x*(p01.y*p02.z - p02.y*p01.z)); alpha = ((p02.y*pc.z - pc.y*p02.z)*r0r0.x + (pc.x*p02.z - p02.x*pc.z)*r0r0.y + (p02.x*pc.y - pc.x*p02.y)*r0r0.z)/magA; beta = ((pc.y*p01.z - p01.y*pc.z)*r0r0.x + (p01.x*pc.z - pc.x*p01.z)*r0r0.y + (pc.x*p01.y - p01.x*pc.y)*r0r0.z)/magA; alpha = clip(alpha); beta = clip(beta); const Real k(alpha + beta); if(k > 1) { alpha /= k; beta /= k; } const vec3<Real> p12(p2 - p1); Real lambda(dot(r0j - p1, p12)/dot(p12, p12)); lambda = clip(lambda); vec3<Real> closest(p1 + lambda*p12); vec3<Real> closestr0(closest - r0j); Real closestDistsq(dot(closestr0, closestr0)); if(closestDistsq < distsq) { distsq = closestDistsq; rPrime = closest; } closest = vertex0 + alpha*p01 + beta*p02; closestr0 = closest - r0j; closestDistsq = dot(closestr0, closestr0); if(closestDistsq < distsq) { distsq = closestDistsq; rPrime = closest; } } const vec3<Real> rlast(p2 - vertex0); lambda = dot(r0r0, rlast)/dot(rlast, rlast); lambda = clip(lambda); closest = vertex0 + lambda*rlast; closestr0 = closest - r0j; closestDistsq = dot(closestr0, closestr0); if(closestDistsq < distsq) { distsq = closestDistsq; rPrime = closest; } if(distsq > 0) m_potential.evaluate(rij, r0, rPrime + rij, potential, force_i, torque_i, force_j, torque_j); } template<typename Real> DEVICE inline Real detp(const vec3<Real> &m, const vec3<Real> &n, const vec3<Real> o, const vec3<Real> p) { return dot(m - n, o - p); } template<typename Real, typename Real4, typename Potential> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::edgeEdge( const vec3<Real> &rij, const vec3<Real> &p00, const vec3<Real> &p01, const vec3<Real> &p10, const vec3<Real> &p11, Real &potential, vec3<Real> &force_i, vec3<Real> &torque_i, vec3<Real> &force_j, vec3<Real> &torque_j) const { Real denominator(detp(p01, p00, p01, p00)*detp(p11, p10, p11, p10) - detp(p11, p10, p01, p00)*detp(p11, p10, p01, p00)); Real lambda0((detp(p00, p10, p11, p10)*detp(p11, p10, p01, p00) - detp(p00, p10, p01, p00)*detp(p11, p10, p11, p10))/denominator); Real lambda1((detp(p00, p10, p11, p10) + lambda0*detp(p11, p10, p01, p00))/detp(p11, p10, p11, p10)); lambda0 = clip(lambda0); lambda1 = clip(lambda1); const vec3<Real> r0(p01 - p00); const Real r0sq(dot(r0, r0)); const vec3<Real> r1(p11 - p10); const Real r1sq(dot(r1, r1)); vec3<Real> closestI(p00 + lambda0*r0); vec3<Real> closestJ(p10 + lambda1*r1); vec3<Real> rContact(closestJ - closestI); Real closestDistsq(dot(rContact, rContact)); Real lambda(clip(dot(p10 - p00, r0)/r0sq)); vec3<Real> candidateI(p00 + lambda*r0); vec3<Real> candidateJ(p10); rContact = candidateJ - candidateI; Real distsq(dot(rContact, rContact)); if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; } lambda = clip(dot(p11 - p00, r0)/r0sq); candidateI = p00 + lambda*r0; candidateJ = p11; rContact = candidateJ - candidateI; distsq = dot(rContact, rContact); if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; } lambda = clip(dot(p00 - p10, r1)/r1sq); candidateI = p00; candidateJ = p10 + lambda*r1; rContact = candidateJ - candidateI; distsq = dot(rContact, rContact); if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; } lambda = clip(dot(p01 - p10, r1)/r1sq); candidateI = p01; candidateJ = p10 + lambda*r1; rContact = candidateJ - candidateI; distsq = dot(rContact, rContact); if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; } if(fabs(1 - dot(r0, r1)*dot(r0, r1)/r0sq/r1sq) < 1e-6) { const Real lambda00(clip(dot(p10 - p00, r0)/r0sq)); const Real lambda01(clip(dot(p11 - p00, r0)/r0sq)); const Real lambda10(clip(dot(p00 - p10, r1)/r1sq)); const Real lambda11(clip(dot(p01 - p10, r1)/r1sq)); lambda0 = Real(.5)*(lambda00 + lambda01); lambda1 = Real(.5)*(lambda10 + lambda11); closestI = p00 + lambda0*r0; closestJ = p10 + lambda1*r1; } m_potential.evaluate(rij, closestI, closestJ, potential, force_i, torque_i, force_j, torque_j); } #endif
#ifndef __DEMEVALUATOR_CC__ #define __DEMEVALUATOR_CC__ #include "DEMEvaluator.h" #include "WCAPotential.h" #include <assert.h> template<typename Real> DEVICE inline Real clip(const Real &x) { return (x >= 0)*(x + (x > 1)*(1 - x)); } template<typename Real, typename Real4, typename Potential> template<typename Vec, typename Torque> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::comCOM( const Vec &rij, Real &potential, Vec &force_i, Torque &torque_i, Vec &force_j, Torque &torque_j) const { m_potential.evaluate(rij, Vec(), rij, potential, force_i, torque_i, force_j, torque_j); } template<typename Real, typename Real4, typename Potential> template<typename Vec, typename Torque> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::vertexVertex( const Vec &rij, const Vec &r0, const Vec &r1, Real &potential, Vec &force_i, Torque &torque_i, Vec &force_j, Torque &torque_j, float modFactor) const { m_potential.evaluate(rij, r0, r1, potential, force_i, torque_i, force_j, torque_j, modFactor); } template<typename Real, typename Real4, typename Potential> template<typename Vec, typename Torque> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::vertexEdge( const Vec &rij, const Vec &r0, const Vec &r1, const Vec &r2, Real &potential, Vec &force_i, Torque &torque_i, Vec &force_j, Torque &torque_j, float modFactor) const { const Vec r10(r0 - (r1 + rij)); const Vec r12(r2 - r1); Real lambda(dot(r10, r12)/dot(r12, r12)); lambda = clip(lambda); const Vec rPrime(r1 + rij + lambda*r12); m_potential.evaluate(rij, r0, rPrime, potential, force_i, torque_i, force_j, torque_j, modFactor); } template<typename Real, typename Real4, typename Potential> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::vertexFace( const vec3<Real> &rij, const vec3<Real> &r0, const quat<Real> quatj, const Real4 *verticesj, const unsigned int *realIndicesj, const unsigned int *facesj, const unsigned int vertex0Index, Real &potential, vec3<Real> &force_i, vec3<Real> &torque_i, vec3<Real> &force_j, vec3<Real> &torque_j) const { Real distsq(0); const vec3<Real> r0j(r0 - rij); vec3<Real> rPrime; const vec3<Real> vertex0(rotate(quatj, vec3<Real>(verticesj[realIndicesj[vertex0Index]]))); const vec3<Real> r0r0(r0j - vertex0); const vec3<Real> secondVertex(rotate(quatj, vec3<Real>(verticesj[realIndicesj[facesj[vertex0Index]]]))); const vec3<Real> rsec(secondVertex - vertex0); Real lambda(dot(r0r0, rsec)/dot(rsec, rsec)); lambda = clip(lambda); vec3<Real> closest(vertex0 + lambda*rsec); vec3<Real> closestr0(closest - r0j); Real closestDistsq(dot(closestr0, closestr0)); distsq = closestDistsq; rPrime = closest; vec3<Real> p1, p2(secondVertex), p01, p02(secondVertex - vertex0); unsigned int i(facesj[vertex0Index]); for(; facesj[i] != vertex0Index; i = facesj[i]) { Real alpha(0), beta(0); p1 = p2; p2 = rotate(quatj, vec3<Real>(verticesj[realIndicesj[facesj[i]]])); p01 = p02; p02 = p2 - vertex0; const vec3<Real> pc(cross(p01, p02)); Real magA(p01.x*(p02.y*pc.z - pc.y*p02.z) - p02.x*(p01.y*pc.z - pc.y*p01.z) + pc.x*(p01.y*p02.z - p02.y*p01.z)); alpha = ((p02.y*pc.z - pc.y*p02.z)*r0r0.x + (pc.x*p02.z - p02.x*pc.z)*r0r0.y + (p02.x*pc.y - pc.x*p02.y)*r0r0.z)/magA; beta = ((pc.y*p01.z - p01.y*pc.z)*r0r0.x + (p01.x*pc.z - pc.x*p01.z)*r0r0.y + (pc.x*p01.y - p01.x*pc.y)*r0r0.z)/magA; alpha = clip(alpha); beta = clip(beta); const Real k(alpha + beta); if(k > 1) { alpha /= k; beta /= k; } const vec3<Real> p12(p2 - p1); Real lambda(dot(r0j - p1, p12)/dot(p12, p12)); lambda = clip(lambda); vec3<Real> closest(p1 + lambda*p12); vec3<Real> closestr0(closest - r0j); Real closestDistsq(dot(closestr0, closestr0)); if(closestDistsq < distsq) { distsq = closestDistsq; rPrime = closest; } closest = vertex0 + alpha*p01 + beta*p02; closestr0 = closest - r0j; closestDistsq = dot(closestr0, closestr0); if(closestDistsq < distsq) { distsq = closestDistsq; rPrime = closest; } } const vec3<Real> rlast(p2 - vertex0); lambda = dot(r0r0, rlast)/dot(rlast, rlast); lambda = clip(lambda); closest = vertex0 + lambda*rlast; closestr0 = closest - r0j; closestDistsq = dot(closestr0, closestr0); if(closestDistsq < distsq) { distsq = closestDistsq; rPrime = closest; } if(distsq > 0) m_potential.evaluate(rij, r0, rPrime + rij, potential, force_i, torque_i, force_j, torque_j); } template<typename Real> DEVICE inline Real detp(const vec3<Real> &m, const vec3<Real> &n, const vec3<Real> o, const vec3<Real> p) { return dot(m - n, o - p); } template<typename Real, typename Real4, typename Potential> DEVICE inline void DEMEvaluator<Real, Real4, Potential>::edgeEdge( const vec3<Real> &rij, const vec3<Real> &p00, const vec3<Real> &p01, const vec3<Real> &p10, const vec3<Real> &p11, Real &potential, vec3<Real> &force_i, vec3<Real> &torque_i, vec3<Real> &force_j, vec3<Real> &torque_j) const { Real denominator(detp(p01, p00, p01, p00)*detp(p11, p10, p11, p10) - detp(p11, p10, p01, p00)*detp(p11, p10, p01, p00)); Real lambda0((detp(p00, p10, p11, p10)*detp(p11, p10, p01, p00) - detp(p00, p10, p01, p00)*detp(p11, p10, p11, p10))/denominator); Real lambda1((detp(p00, p10, p11, p10) + lambda0*detp(p11, p10, p01, p00))/detp(p11, p10, p11, p10)); lambda0 = clip(lambda0); lambda1 = clip(lambda1); const vec3<Real> r0(p01 - p00); const Real r0sq(dot(r0, r0)); const vec3<Real> r1(p11 - p10); const Real r1sq(dot(r1, r1)); vec3<Real> closestI(p00 + lambda0*r0); vec3<Real> closestJ(p10 + lambda1*r1); vec3<Real> rContact(closestJ - closestI); Real closestDistsq(dot(rContact, rContact)); Real lambda(clip(dot(p10 - p00, r0)/r0sq)); vec3<Real> candidateI(p00 + lambda*r0); vec3<Real> candidateJ(p10); rContact = candidateJ - candidateI; Real distsq(dot(rContact, rContact));
lambda = clip(dot(p11 - p00, r0)/r0sq); candidateI = p00 + lambda*r0; candidateJ = p11; rContact = candidateJ - candidateI; distsq = dot(rContact, rContact); if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; } lambda = clip(dot(p00 - p10, r1)/r1sq); candidateI = p00; candidateJ = p10 + lambda*r1; rContact = candidateJ - candidateI; distsq = dot(rContact, rContact); if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; } lambda = clip(dot(p01 - p10, r1)/r1sq); candidateI = p01; candidateJ = p10 + lambda*r1; rContact = candidateJ - candidateI; distsq = dot(rContact, rContact); if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; } if(fabs(1 - dot(r0, r1)*dot(r0, r1)/r0sq/r1sq) < 1e-6) { const Real lambda00(clip(dot(p10 - p00, r0)/r0sq)); const Real lambda01(clip(dot(p11 - p00, r0)/r0sq)); const Real lambda10(clip(dot(p00 - p10, r1)/r1sq)); const Real lambda11(clip(dot(p01 - p10, r1)/r1sq)); lambda0 = Real(.5)*(lambda00 + lambda01); lambda1 = Real(.5)*(lambda10 + lambda11); closestI = p00 + lambda0*r0; closestJ = p10 + lambda1*r1; } m_potential.evaluate(rij, closestI, closestJ, potential, force_i, torque_i, force_j, torque_j); } #endif
if(distsq < closestDistsq) { closestI = candidateI; closestJ = candidateJ; closestDistsq = distsq; }
if_condition
[]
C++
src/multi_index_array/kennytm/vtmp.hpp
extragoya/LibNT
60372bf4e3c5d6665185358c4756da4fe547f093
#ifndef VTMP_HPP_KFLYEISDKHB #define VTMP_HPP_KFLYEISDKHB 1 #include <cstdlib> #include <type_traits> #include <utility> #include <array> #include "traits.hpp" namespace utils { namespace vtmp { template <size_t... ns> struct integers { template <size_t n> using push_back = integers<ns..., n>; }; namespace xx_impl { template <size_t n> struct iota_impl { typedef typename iota_impl<n-1>::type::template push_back<n-1> type; }; template <> struct iota_impl<0> { typedef integers<> type; }; } template <size_t n> using iota = typename xx_impl::iota_impl<n>::type; } namespace xx_impl { template <typename Source, typename Target> struct copy_cr { typedef Target type; }; template <typename Source, typename Target> struct copy_cr<Source&, Target> { typedef Target& type; }; template <typename Source, typename Target> struct copy_cr<Source&&, Target> { typedef Target&& type; }; template <typename Source, typename Target> struct copy_cr<const Source&, Target> { typedef const Target& type; }; template <typename Source, typename Target> struct copy_cr<const Source&&, Target> { typedef const Target&& type; }; template <typename... T, typename F, typename G, size_t... ns, typename Tuple> auto tuple_funcs(F&& reduce, G&& map, const vtmp::integers<ns...>&, Tuple&& tup) -> decltype(reduce(map(std::declval<typename copy_cr<Tuple, T>::type>())...)) { return reduce(map(std::get<ns>(tup))...); } struct no_op_func { template <typename T> T&& operator()(T&& value) const noexcept { return std::forward<T>(value); } }; struct make_tuple_func { template <typename... T> auto operator()(T&&... values) const -> decltype(std::make_tuple(std::declval<T>()...)) { return std::make_tuple(std::forward<T>(values)...); } }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmissing-braces" template <typename C> struct constructor_func { template <typename... T> C operator()(T&&... values) const { return C{std::forward<T>(values)...}; } }; #pragma GCC diagnostic pop } template <typename F, typename... T> auto tuple_apply(std::tuple<T...>& tup, F&& func) -> decltype(func(std::declval<T&>()...)) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(std::forward<F>(func), xx_impl::no_op_func(), instance, tup); } template <typename F, typename... T> auto tuple_apply(std::tuple<T...>&& tup, F&& func) -> decltype(func(std::declval<T&&>()...)) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(std::forward<F>(func), xx_impl::no_op_func(), instance, std::move(tup)); } template <typename F, typename... T> auto tuple_apply(const std::tuple<T...>& tup, F&& func) -> decltype(func(std::declval<const T&>()...)) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(std::forward<F>(func), xx_impl::no_op_func(), instance, tup); } template <typename F, typename... T> auto tuple_map(std::tuple<T...>&& tup, F&& func) -> std::tuple<decltype(func(std::declval<T>()))...> { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::make_tuple_func(), std::forward<F>(func), instance, std::move(tup)); } template <typename F, typename... T> auto tuple_map(const std::tuple<T...>& tup, F&& func) -> std::tuple<decltype(func(std::declval<T>()))...> { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::make_tuple_func(), std::forward<F>(func), instance, tup); } template <typename C, typename... T> C tuple_construct(std::tuple<T...>&& tup) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::constructor_func<C>(), xx_impl::no_op_func(), instance, std::move(tup)); } template <typename C, typename... T> C tuple_construct(const std::tuple<T...>& tup) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::constructor_func<C>(), xx_impl::no_op_func(), instance, tup); } } #endif
#ifndef VTMP_HPP_KFLYEISDKHB #define VTMP_HPP_KFLYEISDKHB 1 #include <cstdlib> #include <type_traits> #include <utility> #include <array> #include "traits.hpp" namespace utils { namespace vtmp { template <size_t... ns> struct integers { template <size_t n> using push_back = integers<ns..., n>; }; namespace xx_impl { template <size_t n> struct iota_impl { typedef typename iota_impl<n-1>::type::template push_back<n-1> type; }; template <> struct iota_impl<0> { typedef integers<> type; }; } template <size_t n> using iota = typename xx_impl::iota_impl<n>::type; } namespace xx_impl { template <typename Source, typename Target> struct copy_cr { typedef Target type; }; template <typename Source, typename Target> struct copy_cr<Source&, Target> { typedef Target& type; }; template <typename Source, typename Target> struct copy_cr<Source&&, Target> { typedef Target&& type; }; template <typename Source, typename Target> struct copy_cr<const Source&, Target> { typedef const Target& type; }; template <typename Source, typename Target> struct copy_cr<const Source&&, Target> { typedef const Target&& type; }; template <typename... T, typename F, typename G, size_t... ns, typename Tuple> auto tuple_funcs(F&& reduce, G&& map, const vtmp::integers<ns...>&, Tuple&& tup) -> decltype(reduce(map(std::declval<typename copy_cr<Tuple, T>::type>())...)) { return reduce(map(std::get<ns>(tup))...); } struct no_op_func { template <typename T> T&& operator()(T&& value) const noexcept { return std::forward<T>(value); } }; struct make_tuple_func { template <typename... T> auto operator()(T&&... values) const -> decltype(std::make_tuple(std::declval<T>()...)) { return std::make_tuple(std::forward<T>(values)...); } }; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wmissing-braces" template <typename C> struct constructor_func { template <typename... T> C operator()(T&&... values) const { return C{std::forward<T>(values)...}; } }; #pragma GCC diagnostic pop } template <typename F, typename... T> auto tuple_apply(std::tuple<T...>& tup, F&& func) -> decltype(func(std::declval<T&>()...)) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(std::forward<F>(func), xx_impl::no_op_func(), instance, tup); } template <typename F, typename... T> auto tuple_apply(std::tuple<T...>&& tup, F&& func) -> decltype(func(std::declval<T&&>()...)) { vtm
template <typename F, typename... T> auto tuple_apply(const std::tuple<T...>& tup, F&& func) -> decltype(func(std::declval<const T&>()...)) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(std::forward<F>(func), xx_impl::no_op_func(), instance, tup); } template <typename F, typename... T> auto tuple_map(std::tuple<T...>&& tup, F&& func) -> std::tuple<decltype(func(std::declval<T>()))...> { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::make_tuple_func(), std::forward<F>(func), instance, std::move(tup)); } template <typename F, typename... T> auto tuple_map(const std::tuple<T...>& tup, F&& func) -> std::tuple<decltype(func(std::declval<T>()))...> { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::make_tuple_func(), std::forward<F>(func), instance, tup); } template <typename C, typename... T> C tuple_construct(std::tuple<T...>&& tup) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::constructor_func<C>(), xx_impl::no_op_func(), instance, std::move(tup)); } template <typename C, typename... T> C tuple_construct(const std::tuple<T...>& tup) { vtmp::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(xx_impl::constructor_func<C>(), xx_impl::no_op_func(), instance, tup); } } #endif
p::template iota<sizeof...(T)> instance; return xx_impl::tuple_funcs<T...>(std::forward<F>(func), xx_impl::no_op_func(), instance, std::move(tup)); }
function_block-function_prefixed
[ { "content": "struct MIANonlinearFuncType<MIA,typename boost::enable_if<internal::is_DenseMIA<typename std::remove_const<MIA>::type>>::type>{\n\n typedef typename std::remove_const<MIA>::type MIA_type;\n\n typedef DenseMIA<typename internal::data_type<MIA_type>::type,internal::order<MIA_type>::value> type...
C++
PROX/FOUNDATION/DIKUCL/DIKUCL/include/dikucl_context_manager.hpp
diku-dk/PROX
c6be72cc253ff75589a1cac28e4e91e788376900
#ifndef DIKUCL_CONTEXT_MANAGER_HPP #define DIKUCL_CONTEXT_MANAGER_HPP #include <iostream> #include <map> #include <utility> #include <vector> #include <dikucl.hpp> #include <dikucl_device_manager.hpp> namespace dikucl { namespace details { inline void opencl_notify( const char * error_info , const void * , size_t , void * ) { std::cerr << "OpenCL Error Information: " << error_info << std::endl; } } class ContextHandle { public: DeviceHandle device_handle; cl::Context context; ContextHandle( DeviceHandle device_handle, cl::Context context) : device_handle(device_handle), context(context) { } friend bool operator<(const ContextHandle& ch1, const ContextHandle& ch2) { return ch1.device_handle < ch2.device_handle; } friend bool operator>(const ContextHandle& ch1, const ContextHandle& ch2) { return ch1.device_handle > ch2.device_handle; } friend bool operator==(const ContextHandle& ch1, const ContextHandle& ch2) { return ch1.device_handle == ch2.device_handle; } }; class ContextManager { private: std::map< DeviceHandle, ContextHandle > contexts; ContextManager() { } ContextManager(ContextManager const&); void operator=(ContextManager const&); public: static ContextManager& get_instance() { static ContextManager instance; return instance; } ContextHandle* get_context( cl_int *err = NULL, DeviceHandle *device_handle = DeviceManager::get_instance().get_device(), cl_context_properties *properties = NULL, void (CL_CALLBACK * notifyFptr)(const char*, const void*, size_t, void*) = details::opencl_notify, void* data = NULL) { cl_int error = CL_SUCCESS; if(device_handle == NULL) { return NULL; } if(contexts.count(*device_handle) == 0) { std::vector< cl::Device > device_vector(1, device_handle->device); cl::Context context(device_vector, properties, notifyFptr, data, &error); if(error == CL_SUCCESS) { contexts.insert(std::pair< DeviceHandle, ContextHandle >( *device_handle, ContextHandle(*device_handle, context))); } else { if(err != NULL) { *err = error; } return NULL; } } std::map< DeviceHandle, ContextHandle >::iterator it = contexts.find(*device_handle); if(it != contexts.end()) { return &(it->second); } return NULL; } void reset() { contexts.clear(); } }; } #endif
#ifndef DIKUCL_CONTEXT_MANAGER_HPP #define DIKUCL_CONTEXT_MANAGER_HPP #include <iostream> #include <map> #include <utility> #include <vector> #include <dikucl.hpp> #include <dikucl_device_manager.hpp> namespace dikucl { namespace details { inline void opencl_notify( const char * error_info , const void * , size_t , void * ) { std::cerr << "OpenCL Error Information: " << error_info << std::endl; } } class ContextHandle { public: DeviceHandle device_handle; cl::Context context; ContextHandle( DeviceHandle device_handle, cl::Context context) : device_handle(device_handle), context(context) { } friend bool operator<(const ContextHandle& ch1, const ContextHandle& ch2) { return ch1.device_handle < ch2.device_handle; } friend bool operator>(const ContextHandle& ch1, const ContextHandle& ch2) { return ch1.device_handle > ch2.device_handle; } friend bool
ager(ContextManager const&); void operator=(ContextManager const&); public: static ContextManager& get_instance() { static ContextManager instance; return instance; } ContextHandle* get_context( cl_int *err = NULL, DeviceHandle *device_handle = DeviceManager::get_instance().get_device(), cl_context_properties *properties = NULL, void (CL_CALLBACK * notifyFptr)(const char*, const void*, size_t, void*) = details::opencl_notify, void* data = NULL) { cl_int error = CL_SUCCESS; if(device_handle == NULL) { return NULL; } if(contexts.count(*device_handle) == 0) { std::vector< cl::Device > device_vector(1, device_handle->device); cl::Context context(device_vector, properties, notifyFptr, data, &error); if(error == CL_SUCCESS) { contexts.insert(std::pair< DeviceHandle, ContextHandle >( *device_handle, ContextHandle(*device_handle, context))); } else { if(err != NULL) { *err = error; } return NULL; } } std::map< DeviceHandle, ContextHandle >::iterator it = contexts.find(*device_handle); if(it != contexts.end()) { return &(it->second); } return NULL; } void reset() { contexts.clear(); } }; } #endif
operator==(const ContextHandle& ch1, const ContextHandle& ch2) { return ch1.device_handle == ch2.device_handle; } }; class ContextManager { private: std::map< DeviceHandle, ContextHandle > contexts; ContextManager() { } ContextMan
random
[ { "content": "class Context : public detail::Wrapper<cl_context>\n\n{\n\npublic:\n\n Context(\n\n const VECTOR_CLASS<Device>& devices,\n\n cl_context_properties* properties = NULL,\n\n void (CL_CALLBACK * notifyFptr)(\n\n const char *,\n\n const void *,\n\n ...
C++
vislib/src/sys/MemoryFile.cpp
xge/megamol
1e298dd3d8b153d7468ed446f6b2ed3ac49f0d5b
#include "vislib/sys/MemoryFile.h" using namespace vislib::sys; MemoryFile::MemoryFile(void) : File(), accessMode(READ_ONLY), buffer(NULL), bufferLen(0), pos(0), storage(NULL) {} MemoryFile::~MemoryFile(void) { this->Close(); } void MemoryFile::Close(void) { this->accessMode = READ_ONLY; this->buffer = NULL; this->bufferLen = 0; this->pos = 0; this->storage = NULL; } void MemoryFile::Flush(void) { } File::FileSize MemoryFile::GetSize(void) const { return (this->storage != NULL) ? static_cast<File::FileSize>(this->storage->GetSize()) : ((this->buffer != NULL) ? this->bufferLen : 0); } bool MemoryFile::IsOpen(void) const { return (this->storage != NULL) || (this->buffer != NULL); } bool MemoryFile::Open(void* buffer, SIZE_T bufferLength, File::AccessMode accessMode) { if (buffer == NULL) return false; this->Close(); this->accessMode = accessMode; this->buffer = static_cast<unsigned char*>(buffer); this->bufferLen = bufferLength; this->pos = 0; this->storage = NULL; return true; } bool MemoryFile::Open(vislib::RawStorage& storage, File::AccessMode accessMode) { this->Close(); this->accessMode = accessMode; this->buffer = NULL; this->bufferLen = 0; this->pos = 0; this->storage = &storage; return true; } bool MemoryFile::Open(const char* filename, const File::AccessMode accessMode, const File::ShareMode shareMode, const File::CreationMode creationMode) { return false; } bool MemoryFile::Open(const wchar_t* filename, const File::AccessMode accessMode, const File::ShareMode shareMode, const File::CreationMode creationMode) { return false; } File::FileSize MemoryFile::Read(void* outBuf, const File::FileSize bufSize) { FileSize s = bufSize; FileSize l = this->GetSize(); if (this->accessMode == WRITE_ONLY) return 0; if (this->pos > l) { this->pos = l; } if (this->pos + s > l) { s = l - this->pos; } if (!this->IsOpen()) { s = 0; } if (s > 0) { ::memcpy(outBuf, (this->storage != NULL) ? this->storage->At(static_cast<SIZE_T>(this->pos)) : (this->buffer + this->pos), static_cast<SIZE_T>(s)); this->pos += s; } return s; } File::FileSize MemoryFile::Seek(const File::FileOffset offset, const File::SeekStartPoint from) { FileSize np = this->pos; switch (from) { case BEGIN: if (offset >= 0) { np = offset; } break; case CURRENT: if (offset < 0) { if (static_cast<FileSize>(-offset) > this->pos) { np = 0; } else { np = this->pos + offset; } } else { np = this->pos + offset; } break; case END: np = this->GetSize(); if (offset < 0) { if (static_cast<FileSize>(-offset) > np) { np = 0; } else { np += offset; } } break; } if (np > this->GetSize()) { np = this->GetSize(); } this->pos = np; return this->pos; } File::FileSize MemoryFile::Tell(void) const { return this->pos; } File::FileSize MemoryFile::Write(const void* buf, const File::FileSize bufSize) { FileSize s = 0; if (this->accessMode == READ_ONLY) return 0; if (this->buffer != NULL) { s = bufSize; if (this->pos + s > this->bufferLen) { if (this->pos > this->bufferLen) { this->pos = this->bufferLen; } s = this->bufferLen - this->pos; } ::memcpy(this->buffer + this->pos, buf, static_cast<SIZE_T>(s)); this->pos += s; } else if (this->storage != NULL) { s = bufSize; if (this->storage->GetSize() < this->pos + s) { this->storage->AssertSize(static_cast<SIZE_T>(this->pos + s), true); if (this->pos > this->storage->GetSize()) { this->pos = this->storage->GetSize(); } s = this->storage->GetSize() - this->pos; } ::memcpy(this->storage->At(static_cast<SIZE_T>(this->pos)), buf, static_cast<SIZE_T>(s)); this->pos += s; } else { s = 0; } return s; }
#include "vislib/sys/MemoryFile.h" using namespace vislib::sys; MemoryFile::MemoryFile(void) : File(), accessMode(READ_ONLY), buffer(NULL), bufferLen(0), pos(0), storage(NULL) {} MemoryFile::~MemoryFile(void) { this->Close(); } void MemoryFile::Close(void) { this->accessMode = READ_ONLY; this->buffer = NULL; this->bufferLen = 0; this->pos = 0; this->storage = NULL; } void MemoryFile::Flush(void) { } File::FileSize MemoryFile::GetSize(void) const { return (this->storage != NULL) ? static_cast<File::FileSize>(this->storage->GetSize()) : ((this->buffer != NULL) ? this->bufferLen : 0); } bool MemoryFile::IsOpen(void) const { return (this->storage != NULL) || (this->buffer != NULL); } bool MemoryFile::Open(void* buffer, SIZE_T bufferLength, File::AccessMode accessMode) { if (buffer == NULL) return false; this->Close(); this->accessMode = accessMode; this->buffer = static_cast<unsigned char*>(buffer); this->bufferLen = bufferLength; this->pos = 0; this->storage = NULL; return true; } bool MemoryFile::Open(vislib::RawStorage& storage, File::AccessMode accessMode) { this->Close(); this->accessMode = accessMode; this->buffer = NULL; this->bufferLen = 0; this->pos = 0; this->storage = &storage; return true; } bool MemoryFile::Open(const char* filename, const File::AccessMode accessMode, const File::ShareMode shareMode, const File::CreationMode creationMode) { return false; } bool MemoryFile::Open(const wchar_t* filename, const File::AccessMode accessMode, const File::ShareMode shareMode, const File::CreationMode creationMode) { return false; } File::FileSize MemoryFile::Read(void* outBuf, const File::FileSize bufSize) { FileSize s = bufSize; FileSize l = this->GetSize(); if (this->accessMode == WRITE_ONLY) return 0; if (this->pos > l) { this->pos = l; } if (this->pos + s > l) { s = l - this->pos; } if (!this->IsOpen()) { s = 0; } if (s > 0) {
; this->pos += s; } return s; } File::FileSize MemoryFile::Seek(const File::FileOffset offset, const File::SeekStartPoint from) { FileSize np = this->pos; switch (from) { case BEGIN: if (offset >= 0) { np = offset; } break; case CURRENT: if (offset < 0) { if (static_cast<FileSize>(-offset) > this->pos) { np = 0; } else { np = this->pos + offset; } } else { np = this->pos + offset; } break; case END: np = this->GetSize(); if (offset < 0) { if (static_cast<FileSize>(-offset) > np) { np = 0; } else { np += offset; } } break; } if (np > this->GetSize()) { np = this->GetSize(); } this->pos = np; return this->pos; } File::FileSize MemoryFile::Tell(void) const { return this->pos; } File::FileSize MemoryFile::Write(const void* buf, const File::FileSize bufSize) { FileSize s = 0; if (this->accessMode == READ_ONLY) return 0; if (this->buffer != NULL) { s = bufSize; if (this->pos + s > this->bufferLen) { if (this->pos > this->bufferLen) { this->pos = this->bufferLen; } s = this->bufferLen - this->pos; } ::memcpy(this->buffer + this->pos, buf, static_cast<SIZE_T>(s)); this->pos += s; } else if (this->storage != NULL) { s = bufSize; if (this->storage->GetSize() < this->pos + s) { this->storage->AssertSize(static_cast<SIZE_T>(this->pos + s), true); if (this->pos > this->storage->GetSize()) { this->pos = this->storage->GetSize(); } s = this->storage->GetSize() - this->pos; } ::memcpy(this->storage->At(static_cast<SIZE_T>(this->pos)), buf, static_cast<SIZE_T>(s)); this->pos += s; } else { s = 0; } return s; }
::memcpy(outBuf, (this->storage != NULL) ? this->storage->At(static_cast<SIZE_T>(this->pos)) : (this->buffer + this->pos), static_cast<SIZE_T>(s))
call_expression
[ { "content": "class BufferedFile : public File {\n\npublic:\n\n /**\n\n * Answers the default size used when creating new BufferedFile objects\n\n *\n\n * @return size in bytes used when creating new buffers\n\n */\n\n inline static File::FileSize GetDefaultBufferSize(void) {\n\n re...
C++
external/include/mapnik/rule.hpp
Wujingli/OpenWebGlobeDataProcessing
932eaa00c81fc0571122bc618ade010fa255735e
#ifndef MAPNIK_RULE_HPP #define MAPNIK_RULE_HPP #include <mapnik/building_symbolizer.hpp> #include <mapnik/line_symbolizer.hpp> #include <mapnik/line_pattern_symbolizer.hpp> #include <mapnik/polygon_symbolizer.hpp> #include <mapnik/polygon_pattern_symbolizer.hpp> #include <mapnik/point_symbolizer.hpp> #include <mapnik/raster_symbolizer.hpp> #include <mapnik/shield_symbolizer.hpp> #include <mapnik/text_symbolizer.hpp> #include <mapnik/markers_symbolizer.hpp> #include <mapnik/debug_symbolizer.hpp> #include <mapnik/feature.hpp> #include <mapnik/expression.hpp> #include <mapnik/expression_string.hpp> #include <mapnik/config.hpp> #include <boost/variant/variant_fwd.hpp> #include <string> #include <vector> #include <limits> namespace mapnik { inline bool operator==(point_symbolizer const& lhs, point_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(line_symbolizer const& lhs, line_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(line_pattern_symbolizer const& lhs, line_pattern_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(polygon_symbolizer const& lhs, polygon_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(polygon_pattern_symbolizer const& lhs, polygon_pattern_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(raster_symbolizer const& lhs, raster_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(text_symbolizer const& lhs, text_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(shield_symbolizer const& lhs, shield_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(building_symbolizer const& lhs, building_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(markers_symbolizer const& lhs, markers_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(debug_symbolizer const& lhs, debug_symbolizer const& rhs) { return (&lhs == &rhs); } typedef boost::variant<point_symbolizer, line_symbolizer, line_pattern_symbolizer, polygon_symbolizer, polygon_pattern_symbolizer, raster_symbolizer, shield_symbolizer, text_symbolizer, building_symbolizer, markers_symbolizer, debug_symbolizer> symbolizer; class MAPNIK_DECL rule { public: typedef std::vector<symbolizer> symbolizers; private: std::string name_; double min_scale_; double max_scale_; symbolizers syms_; expression_ptr filter_; bool else_filter_; bool also_filter_; public: rule(); rule(std::string const& name, double min_scale_denominator = 0, double max_scale_denominator = std::numeric_limits<double>::infinity()); rule(const rule& rhs, bool deep_copy = false); rule& operator=(rule const& rhs); bool operator==(rule const& other); void set_max_scale(double scale); double get_max_scale() const; void set_min_scale(double scale); double get_min_scale() const; void set_name(std::string const& name); std::string const& get_name() const; void append(symbolizer const& sym); void remove_at(size_t index); const symbolizers& get_symbolizers() const; symbolizers::const_iterator begin() const; symbolizers::const_iterator end() const; symbolizers::iterator begin(); symbolizers::iterator end(); void set_filter(expression_ptr const& filter); expression_ptr const& get_filter() const; void set_else(bool else_filter); bool has_else_filter() const; void set_also(bool also_filter); bool has_also_filter() const; bool active(double scale) const; private: void swap(rule& rhs) throw(); }; } #endif
#ifndef MAPNIK_RULE_HPP #define MAPNIK_RULE_HPP #include <mapnik/building_symbolizer.hpp> #include <mapnik/line_sy
hield_symbolizer.hpp> #include <mapnik/text_symbolizer.hpp> #include <mapnik/markers_symbolizer.hpp> #include <mapnik/debug_symbolizer.hpp> #include <mapnik/feature.hpp> #include <mapnik/expression.hpp> #include <mapnik/expression_string.hpp> #include <mapnik/config.hpp> #include <boost/variant/variant_fwd.hpp> #include <string> #include <vector> #include <limits> namespace mapnik { inline bool operator==(point_symbolizer const& lhs, point_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(line_symbolizer const& lhs, line_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(line_pattern_symbolizer const& lhs, line_pattern_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(polygon_symbolizer const& lhs, polygon_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(polygon_pattern_symbolizer const& lhs, polygon_pattern_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(raster_symbolizer const& lhs, raster_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(text_symbolizer const& lhs, text_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(shield_symbolizer const& lhs, shield_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(building_symbolizer const& lhs, building_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(markers_symbolizer const& lhs, markers_symbolizer const& rhs) { return (&lhs == &rhs); } inline bool operator==(debug_symbolizer const& lhs, debug_symbolizer const& rhs) { return (&lhs == &rhs); } typedef boost::variant<point_symbolizer, line_symbolizer, line_pattern_symbolizer, polygon_symbolizer, polygon_pattern_symbolizer, raster_symbolizer, shield_symbolizer, text_symbolizer, building_symbolizer, markers_symbolizer, debug_symbolizer> symbolizer; class MAPNIK_DECL rule { public: typedef std::vector<symbolizer> symbolizers; private: std::string name_; double min_scale_; double max_scale_; symbolizers syms_; expression_ptr filter_; bool else_filter_; bool also_filter_; public: rule(); rule(std::string const& name, double min_scale_denominator = 0, double max_scale_denominator = std::numeric_limits<double>::infinity()); rule(const rule& rhs, bool deep_copy = false); rule& operator=(rule const& rhs); bool operator==(rule const& other); void set_max_scale(double scale); double get_max_scale() const; void set_min_scale(double scale); double get_min_scale() const; void set_name(std::string const& name); std::string const& get_name() const; void append(symbolizer const& sym); void remove_at(size_t index); const symbolizers& get_symbolizers() const; symbolizers::const_iterator begin() const; symbolizers::const_iterator end() const; symbolizers::iterator begin(); symbolizers::iterator end(); void set_filter(expression_ptr const& filter); expression_ptr const& get_filter() const; void set_else(bool else_filter); bool has_else_filter() const; void set_also(bool also_filter); bool has_also_filter() const; bool active(double scale) const; private: void swap(rule& rhs) throw(); }; } #endif
mbolizer.hpp> #include <mapnik/line_pattern_symbolizer.hpp> #include <mapnik/polygon_symbolizer.hpp> #include <mapnik/polygon_pattern_symbolizer.hpp> #include <mapnik/point_symbolizer.hpp> #include <mapnik/raster_symbolizer.hpp> #include <mapnik/s
random
[]
C++
include/ensmallen_bits/problems/logistic_regression_function_impl.hpp
kilasuelika/ensmallen-eigen
d9df7ca4d0e519974d56441c132fb9326da4ea3d
#ifndef ENSMALLEN_PROBLEMS_LOGISTIC_REGRESSION_FUNCTION_IMPL_HPP #define ENSMALLEN_PROBLEMS_LOGISTIC_REGRESSION_FUNCTION_IMPL_HPP #include "logistic_regression_function.hpp" namespace ens { namespace test { template<typename MatType> LogisticRegressionFunction<MatType>::LogisticRegressionFunction( MatType& predictors, arma::Row<size_t>& responses, const double lambda) : predictors(predictors), responses(responses), lambda(lambda) { initialPoint = arma::Row<typename MatType::Scalar>(predictors.n_rows + 1, arma::fill::zeros); if (responses.n_elem != predictors.n_cols) { std::ostringstream oss; oss << "LogisticRegressionFunction::LogisticRegressionFunction(): " << "predictors matrix has " << predictors.n_cols << " points, but " << "responses vector has " << responses.n_elem << " elements (should be" << " " << predictors.n_cols << ")!" << std::endl; throw std::logic_error(oss.str()); } } template<typename MatType> LogisticRegressionFunction<MatType>::LogisticRegressionFunction( MatType& predictors, arma::Row<size_t>& responses, MatType& initialPoint, const double lambda) : initialPoint(initialPoint), predictors(predictors), responses(responses), lambda(lambda) { if (initialPoint.n_rows != (predictors.n_rows + 1) || initialPoint.n_cols != 1) this->initialPoint = arma::Row<typename MatType::Scalar>( predictors.n_rows + 1, arma::fill::zeros); } template<typename MatType> void LogisticRegressionFunction<MatType>::Shuffle() { MatType newPredictors; arma::Row<size_t> newResponses; arma::uvec ordering = arma::shuffle(arma::linspace<arma::uvec>(0, predictors.n_cols - 1, predictors.n_cols)); newPredictors.set_size(predictors.n_rows, predictors.n_cols); for (size_t i = 0; i < predictors.n_cols; ++i) newPredictors.col(i) = predictors.col(ordering[i]); newResponses = responses.cols(ordering); predictors = std::move(newPredictors); responses = std::move(newResponses); } template<typename MatType> typename MatType::Scalar LogisticRegressionFunction<MatType>::Evaluate( const MatType& parameters) const { typedef typename MatType::Scalar ElemType; const ElemType regularization = 0.5 * lambda * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoid = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors))); const ElemType result = arma::accu(arma::log(1.0 - arma::conv_to<arma::Row<ElemType>>::from(responses) + sigmoid % (2 * arma::conv_to<arma::Row<ElemType>>::from(responses) - 1.0))); return regularization - result; } template<typename MatType> typename MatType::Scalar LogisticRegressionFunction<MatType>::Evaluate( const MatType& parameters, const size_t begin, const size_t batchSize) const { typedef typename MatType::Scalar ElemType; const ElemType regularization = lambda * (batchSize / (2.0 * predictors.n_cols)) * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoid = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors.cols(begin, begin + batchSize - 1)))); arma::Row<ElemType> respD = arma::conv_to<arma::Row<ElemType>>::from( responses.subvec(begin, begin + batchSize - 1)); const ElemType result = arma::accu(arma::log(1.0 - respD + sigmoid % (2 * respD - 1.0))); return regularization - result; } template<typename MatType> template<typename GradType> void LogisticRegressionFunction<MatType>::Gradient( const MatType& parameters, GradType& gradient) const { typedef typename MatType::Scalar ElemType; MatType regularization; regularization = lambda * parameters.tail_cols(parameters.n_elem - 1); const arma::Row<ElemType> sigmoids = (1 / (1 + arma::exp(-parameters(0, 0) - parameters.tail_cols(parameters.n_elem - 1) * predictors))); gradient.set_size(arma::size(parameters)); gradient[0] = -arma::accu(responses - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses) * predictors.t() + regularization; } template<typename MatType> template<typename GradType> void LogisticRegressionFunction<MatType>::Gradient( const MatType& parameters, const size_t begin, GradType& gradient, const size_t batchSize) const { typedef typename MatType::Scalar ElemType; MatType regularization; regularization = lambda * parameters.tail_cols(parameters.n_elem - 1) / predictors.n_cols * batchSize; const arma::Row<ElemType> exponents = parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors.cols(begin, begin + batchSize - 1); const arma::Row<ElemType> sigmoids = 1.0 / (1.0 + arma::exp(-exponents)); gradient.set_size(parameters.n_rows, parameters.n_cols); gradient[0] = -arma::accu(responses.subvec(begin, begin + batchSize - 1) - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses.subvec(begin, begin + batchSize - 1)) * predictors.cols(begin, begin + batchSize - 1).t() + regularization; } template <typename MatType> void LogisticRegressionFunction<MatType>::PartialGradient( const MatType& parameters, const size_t j, arma::sp_mat& gradient) const { const arma::Row<typename MatType::Scalar> diffs = responses - (1 / (1 + arma::exp(-parameters(0, 0) - parameters.tail_cols(parameters.n_elem - 1) * predictors))); gradient.set_size(arma::size(parameters)); if (j == 0) { gradient[j] = -arma::accu(diffs); } else { gradient[j] = arma::dot(-predictors.row(j - 1), diffs) + lambda * parameters(0, j); } } template<typename MatType> template<typename GradType> typename MatType::Scalar LogisticRegressionFunction<MatType>::EvaluateWithGradient( const MatType& parameters, GradType& gradient) const { typedef typename MatType::Scalar ElemType; MatType regularization = lambda * parameters.tail_cols(parameters.n_elem - 1); const ElemType objectiveRegularization = lambda / 2.0 * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoids = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors))); gradient.set_size(arma::size(parameters)); gradient[0] = -arma::accu(responses - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses) * predictors.t() + regularization; ElemType result = arma::accu(arma::log(1.0 - arma::conv_to<arma::Row<ElemType>>::from(responses) + sigmoids % (2 * arma::conv_to<arma::Row<ElemType>>::from(responses) - 1.0))); return objectiveRegularization - result; } template<typename MatType> template<typename GradType> typename MatType::Scalar LogisticRegressionFunction<MatType>::EvaluateWithGradient( const MatType& parameters, const size_t begin, GradType& gradient, const size_t batchSize) const { typedef typename MatType::Scalar ElemType; MatType regularization = lambda * parameters.tail_cols(parameters.n_elem - 1) / predictors.n_cols * batchSize; const ElemType objectiveRegularization = lambda * (batchSize / (2.0 * predictors.n_cols)) * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoids = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors.cols(begin, begin + batchSize - 1)))); gradient.set_size(parameters.n_rows, parameters.n_cols); gradient[0] = -arma::accu(responses.subvec(begin, begin + batchSize - 1) - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses.subvec(begin, begin + batchSize - 1)) * predictors.cols(begin, begin + batchSize - 1).t() + regularization; arma::Row<ElemType> respD = arma::conv_to<arma::Row<ElemType>>::from( responses.subvec(begin, begin + batchSize - 1)); const ElemType result = arma::accu(arma::log(1.0 - respD + sigmoids % (2 * respD - 1.0))); return objectiveRegularization - result; } template<typename MatType> void LogisticRegressionFunction<MatType>::Classify( const MatType& dataset, arma::Row<size_t>& labels, const MatType& parameters, const double decisionBoundary) const { labels = arma::conv_to<arma::Row<size_t>>::from((1.0 / (1.0 + arma::exp(-parameters(0) - parameters.tail_cols(parameters.n_elem - 1) * dataset))) + (1.0 - decisionBoundary)); } template<typename MatType> double LogisticRegressionFunction<MatType>::ComputeAccuracy( const MatType& predictors, const arma::Row<size_t>& responses, const MatType& parameters, const double decisionBoundary) const { arma::Row<size_t> tempResponses; Classify(predictors, tempResponses, parameters, decisionBoundary); size_t count = 0; for (size_t i = 0; i < responses.n_elem; i++) { if (responses(i) == tempResponses(i)) count++; } return (double) (count * 100) / responses.n_elem; } } } #endif
#ifndef ENSMALLEN_PROBLEMS_LOGISTIC_REGRESSION_FUNCTION_IMPL_HPP #define ENSMALLEN_PROBLEMS_LOGISTIC_REGRESSION_FUNCTION_IMPL_HPP #include "logistic_regression_function.hpp" namespace ens { namespace test { template<typename MatType> LogisticRegressionFunction<MatType>::LogisticRegressionFunction( MatType& predictors, arma::Row<size_t>& responses, const double lambda) : predictors(predictors), responses(responses), lambda(lambda) { initialPoint = arma::Row<typename MatType::Scalar>(predictors.n_rows + 1, arma::fill::zeros); if (responses.n_elem != predictors.n_cols) { std::ostringstream oss; oss << "LogisticRegressionFunction::LogisticRegressionFunction(): " << "predictors matrix has " << predictors.n_cols << " points, but " << "responses vector has " << responses.n_elem << " elements (should be" << " " << predictors.n_cols << ")!" << std::endl; throw std::logic_error(oss.str()); } } template<typename MatType> LogisticRegressionFunction<MatType>::LogisticRegressionFunction( MatType& predictors, arma::Row<size_t>& responses, MatType& initialPoint, const double lambda) : initialPoint(initialPoint), predictors(predictors), responses(responses), lambda(lambda) { if (initialPoint.n_rows != (predictors.n_rows + 1) || initialPoint.n_cols != 1) this->initialPoint = arma::Row<typename MatType::Scalar>( predictors.n_rows + 1, arma::fill::zeros); } template<typename MatType> void LogisticRegressionFunction<MatType>::Shuffle() { MatType newPredictors; arma::Row<size_t> newResponses; arma::uvec ordering = arma::shuffle(arma::linspace<arma::uvec>(0, predictors.n_cols - 1, predictors.n_cols)); newPredictors.set_size(predictors.n_rows, predictors.n_cols); for (size_t i = 0; i < predictors.n_cols; ++i) newPredictors.col(i) = predictors.col(ordering[i]); newResponses = responses.cols(ordering); predictors = std::move(newPredictors); responses = std::move(newResponses); } template<typename MatType> typename MatType::Scalar LogisticRegressionFunction<MatType>::Evaluate( const MatType& parameters) const { typedef typename MatType::Scalar ElemType; const ElemType regularization = 0.5 * lambda * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoid = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors))); const ElemType result = arma::accu(arma::log(1.0 - arma::conv_to<arma::Row<ElemType>>::from(responses) + sigmoid % (2 * arma::conv_to<arma::Row<ElemType>>::from(responses) - 1.0))); return regularization - result; } template<typename MatType> typename MatType::Scalar LogisticRegressionFunction<MatType>::Evaluate( const MatType& parameters, const size_t begin, const size_t batchSize) const { typedef typename MatType::Scalar ElemType; const ElemType regularization = lambda * (batchSize / (2.0 * predictors.n_cols)) * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoid = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors.cols(begin, begin + batchSize - 1)))); arma::Row<ElemType> respD = arma::conv_to<arma::Row<ElemType>>::from( responses.subvec(begin, begin + batchSize - 1)); const ElemType result = arma::accu(arma::log(1.0 - respD + sigmoid % (2 * respD - 1.0))); return regularization - result; } template<typename MatType> template<typename GradType> void LogisticRegressionFunction<MatType>::Gradient( const MatType& parameters, GradType& gradient) const { typedef typename MatType::Scalar ElemType; MatType regularization; regularization = lambda * parameters.tail_cols(parameters.n_elem - 1); const arma::Row<ElemType> sigmoids = (1 / (1 + arma::exp(-parameters(0, 0) - parameters.tail_cols(parameters.n_elem - 1) * predictors))); gradient.set_size(arma::size(parameters)); gradient[0] = -arma::accu(responses - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses) * predictors.t() + regularization; } template<typename MatType> template<typename GradType> void LogisticRegressionFunction<MatType>::Gradient( const MatType& parameters, const size_t begin, GradType& gradient, const size_t batchSize) const { typedef typename MatType::Scalar ElemType; MatType regularization; regularization = lambda * parameters.tail_cols(parameters.n_elem - 1) / predictors.n_cols * batchSize; const arma::Row<ElemType> exponents = parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors.cols(begin, begin + batchSize - 1); const arma::Row<ElemType> sigmoids = 1.0 / (1.0 + arma::exp(-exponents)); gradient.set_size(parameters.n_rows, parameters.n_cols); gradient[0] = -arma::accu(responses.subvec(begin, begin + batchSize - 1) - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses.subvec(begin, begin + batchSize - 1)) * predictors.cols(begin, begin + batchSize - 1).t() + regularization; } template <typename MatType> void LogisticRegressionFunction<MatType>::PartialGradient( const MatType& parameters, const size_t j, arma::sp_mat& gradient) const { const arma::Row<typename MatType::Scalar> diffs = responses - (1 / (1 + arma::exp(-parameters(0, 0) - parameters.tail_cols(parameters.n_elem - 1) * predictors))); gradient.set_size(arma::size(parameters)); if (j == 0) { gradient[j] = -arma::accu(diffs); } else { gradient[j] = arma::dot(-predictors.row(j - 1), diffs) + lambda * parameters(0, j); } } template<typename MatType> template<typename GradType> typename MatType::Scalar LogisticRegressionFunction<MatType>::EvaluateWithGradient( const MatType& parameters, GradType& gradient) const { typedef typename MatType::Scalar ElemType; MatType regularization = lambda * parameters.tail_cols(parameters.n_elem - 1); const ElemType objectiveRegularization = lambda / 2.0 * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoids = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors))); gradient.set_size(arma::size(parameters)); gradient[0] = -arma::accu(responses - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses) * predictors.t() + regularization; ElemType result =
; return objectiveRegularization - result; } template<typename MatType> template<typename GradType> typename MatType::Scalar LogisticRegressionFunction<MatType>::EvaluateWithGradient( const MatType& parameters, const size_t begin, GradType& gradient, const size_t batchSize) const { typedef typename MatType::Scalar ElemType; MatType regularization = lambda * parameters.tail_cols(parameters.n_elem - 1) / predictors.n_cols * batchSize; const ElemType objectiveRegularization = lambda * (batchSize / (2.0 * predictors.n_cols)) * arma::dot(parameters.tail_cols(parameters.n_elem - 1), parameters.tail_cols(parameters.n_elem - 1)); const arma::Row<ElemType> sigmoids = 1.0 / (1.0 + arma::exp(-(parameters(0, 0) + parameters.tail_cols(parameters.n_elem - 1) * predictors.cols(begin, begin + batchSize - 1)))); gradient.set_size(parameters.n_rows, parameters.n_cols); gradient[0] = -arma::accu(responses.subvec(begin, begin + batchSize - 1) - sigmoids); gradient.tail_cols(parameters.n_elem - 1) = (sigmoids - responses.subvec(begin, begin + batchSize - 1)) * predictors.cols(begin, begin + batchSize - 1).t() + regularization; arma::Row<ElemType> respD = arma::conv_to<arma::Row<ElemType>>::from( responses.subvec(begin, begin + batchSize - 1)); const ElemType result = arma::accu(arma::log(1.0 - respD + sigmoids % (2 * respD - 1.0))); return objectiveRegularization - result; } template<typename MatType> void LogisticRegressionFunction<MatType>::Classify( const MatType& dataset, arma::Row<size_t>& labels, const MatType& parameters, const double decisionBoundary) const { labels = arma::conv_to<arma::Row<size_t>>::from((1.0 / (1.0 + arma::exp(-parameters(0) - parameters.tail_cols(parameters.n_elem - 1) * dataset))) + (1.0 - decisionBoundary)); } template<typename MatType> double LogisticRegressionFunction<MatType>::ComputeAccuracy( const MatType& predictors, const arma::Row<size_t>& responses, const MatType& parameters, const double decisionBoundary) const { arma::Row<size_t> tempResponses; Classify(predictors, tempResponses, parameters, decisionBoundary); size_t count = 0; for (size_t i = 0; i < responses.n_elem; i++) { if (responses(i) == tempResponses(i)) count++; } return (double) (count * 100) / responses.n_elem; } } } #endif
arma::accu(arma::log(1.0 - arma::conv_to<arma::Row<ElemType>>::from(responses) + sigmoids % (2 * arma::conv_to<arma::Row<ElemType>>::from(responses) - 1.0)))
call_expression
[ { "content": "//! Very, very simple test function which is the composite of three other\n\n//! functions. The gradient is not very steep far away from the optimum, so a\n\n//! larger step size may be required to optimize it in a reasonable number of\n\n//! iterations.\n\nclass GDTestFunction\n\n{\n\n public:\n...
C++
snake3d/wyShaderFunctions.cpp
wysaid/snake3d
54e167c3b1f73a3c9890f8f0e0678ec68e2ffd0c
 #include "wyShaderFunctions.h" #define GETUNIFORM(uniform, programID, name) \ GLint uniform = glGetUniformLocation(programID, name);\ if(uniform < 0) \ {\ LOG_ERROR("uniform name %s does not exist!\n", name);\ return ;\ }\ ShaderObject::ShaderObject() : m_shaderID(0) { m_shaderType = GL_FALSE; } ShaderObject::~ShaderObject() { clear(); } bool ShaderObject::init(GLenum shaderType) { LOG_INFO("Init %s \n", (shaderType == GL_VERTEX_SHADER) ? "VertexShader" : "FragmentShader"); m_shaderType = shaderType; if(m_shaderID != 0) glDeleteShader(m_shaderID); m_shaderID = glCreateShader(m_shaderType); if(m_shaderID == 0) return false; return true; } void ShaderObject::clear() { if(m_shaderID == 0) return; glDeleteShader(m_shaderID); LOG_INFO("%s Shader release\n", m_shaderType == GL_VERTEX_SHADER ? "Vertex" : "Fragment"); m_shaderID = 0; m_shaderType = GL_FALSE; } bool ShaderObject::loadShaderSourceFromString(const char* shaderString) { if(m_shaderID == 0) m_shaderID = glCreateShader(m_shaderType); if(m_shaderID == 0) { LOG_ERROR("glCreateShader Failed!"); return false; } glShaderSource(m_shaderID, 1, (const GLchar**)&shaderString, NULL); glCompileShader(m_shaderID); GLint compiled = 0; glGetShaderiv(m_shaderID, GL_COMPILE_STATUS, &compiled); if(compiled == GL_TRUE) return true; GLint logLen; glGetShaderiv(m_shaderID, GL_INFO_LOG_LENGTH, &logLen); if(logLen > 0) { char *buf = new char[logLen]; if(buf != NULL) { glGetShaderInfoLog(m_shaderID, logLen, &logLen, buf); LOG_ERROR("Shader %d compile faild: \n%s\n", m_shaderID, buf); delete [] buf; } glDeleteShader(m_shaderID); m_shaderID = 0; } return false; } ProgramObject::ProgramObject() { m_programID = glCreateProgram(); LOG_INFO("CREATE PROGRAM!!!! --> %d\n", m_programID); } ProgramObject::~ProgramObject() { GLuint attachedShaders[32]; int numAttachedShaders; glGetAttachedShaders(m_programID, 32, &numAttachedShaders, attachedShaders); for(int i = 0; i < numAttachedShaders; ++i) { glDetachShader(m_programID, attachedShaders[i]); } htCheckGLError("Detach Shaders in useProgram"); glDeleteProgram(m_programID); LOG_INFO("ProgramObject release\n"); } bool ProgramObject::initFragmentShaderSourceFromString(const char* fragShader) { return m_programID != 0 && m_fragObj.init(GL_FRAGMENT_SHADER) && m_fragObj.loadShaderSourceFromString(fragShader); } bool ProgramObject::initVertexShaderSourceFromString(const char* vertShader) { return m_programID != 0 && m_vertObj.init(GL_VERTEX_SHADER) && m_vertObj.loadShaderSourceFromString(vertShader); } bool ProgramObject::link() { LOG_INFO("COMPILE PROGRAM!!!!\n"); GLuint attachedShaders[32]; int numAttachedShaders, programStatus; glGetAttachedShaders(m_programID, 32, &numAttachedShaders, attachedShaders); for(int i = 0; i < numAttachedShaders; ++i) { glDetachShader(m_programID, attachedShaders[i]); } htCheckGLError("Detach Shaders in useProgram"); glAttachShader(m_programID, m_vertObj.getShaderID()); glAttachShader(m_programID, m_fragObj.getShaderID()); htCheckGLError("Attach Shaders in useProgram"); glLinkProgram(m_programID); glGetProgramiv(m_programID, GL_LINK_STATUS, &programStatus); m_vertObj.clear(); m_fragObj.clear(); if(programStatus != GL_TRUE) { GLint logLen = 0; glGetProgramiv(m_programID, GL_INFO_LOG_LENGTH, &logLen); if(logLen != 0) { char *buf = new char[logLen]; if(buf != NULL) { glGetProgramInfoLog(m_programID, logLen, &logLen, buf); LOG_ERROR("Failed to link the program!\n%s", buf); delete [] buf; } } LOG_INFO("LINK %d Failed\n", m_programID); return false; } LOG_INFO("LINK %d OK\n", m_programID); htCheckGLError("Link Program"); return true; } void ProgramObject::bind() { glUseProgram(m_programID); } void ProgramObject::sendUniformf(const char* name, GLfloat x) { GETUNIFORM(uniform, m_programID, name); glUniform1f(uniform, x); } void ProgramObject::sendUniformf(const char* name, GLfloat x, GLfloat y) { GETUNIFORM(uniform, m_programID, name); glUniform2f(uniform, x, y); } void ProgramObject::sendUniformf(const char* name, GLfloat x, GLfloat y, GLfloat z) { GETUNIFORM(uniform, m_programID, name); glUniform3f(uniform, x, y, z); } void ProgramObject::sendUniformf(const char* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { GETUNIFORM(uniform, m_programID, name); glUniform4f(uniform, x, y, z, w); } void ProgramObject::sendUniformi(const char* name, GLint x) { GETUNIFORM(uniform, m_programID, name); glUniform1i(uniform, x); } void ProgramObject::sendUniformi(const char* name, GLint x, GLint y) { GETUNIFORM(uniform, m_programID, name); glUniform2i(uniform, x, y); } void ProgramObject::sendUniformi(const char* name, GLint x, GLint y, GLint z) { GETUNIFORM(uniform, m_programID, name); glUniform3i(uniform, x, y, z); } void ProgramObject::sendUniformi(const char* name, GLint x, GLint y, GLint z, GLint w) { GETUNIFORM(uniform, m_programID, name); glUniform4i(uniform, x, y, z, w); } void ProgramObject::sendUniformMat2x2(const char* name, int count, GLboolean transpose, const GLfloat* matrix) { GETUNIFORM(uniform, m_programID, name); glUniformMatrix2fv(uniform, count, transpose, matrix); } void ProgramObject::sendUniformMat3x3(const char* name, GLsizei count, GLboolean transpose, const GLfloat* matrix) { GETUNIFORM(uniform, m_programID, name); glUniformMatrix3fv(uniform, count, transpose, matrix); } void ProgramObject::sendUniformMat4x4(const char* name, GLsizei count, GLboolean transpose, const GLfloat* matrix) { GETUNIFORM(uniform, m_programID, name); glUniformMatrix4fv(uniform, count, transpose, matrix); }
 #include "wyShaderFunctions.h" #define GETUNIFORM(uniform, programID, name) \ GLint uniform = glGetUniformLocation(programID, name);\ if(uniform < 0) \ {\ LOG_ERROR("uniform name %s does not exist!\n", name);\ return ;\ }\ ShaderObject::ShaderObject() : m_shaderID(0) { m_shaderType = GL_FALSE; } ShaderObject::~ShaderObject() { clear(); } bool ShaderObject::init(GLenum shaderType) { LOG_INFO("Init %s \n", (shaderType == GL_VERTEX_SHADER) ? "VertexShader" : "FragmentShader"); m_shaderType = shaderType; if(m_shaderID != 0) glDeleteShader(m_shaderID); m_shaderID = glCreateShader(m_shaderType); if(m_shaderID == 0) return false; return true; } void ShaderObject::clear() { if(m_shaderID == 0) return; glDeleteShader(m_shaderID); LOG_INFO("%s Shader release\n", m_shaderType == GL_VERTEX_SHADER ? "Vertex" : "Fragment"); m_shaderID = 0; m_shaderType = GL_FALSE; } bool ShaderObject::loadShaderSourceFromString(const char* shaderString) { if(m_shaderID == 0) m_shaderID = glCreateShader(m_shaderType); if(m_shaderID == 0) { LOG_ERROR("glCreateShader Failed!"); return false; } glShaderSource(m_shaderID, 1, (const GLchar**)&shaderString, NULL); glCompileShader(m_shaderID); GLint compiled = 0; glGetShaderiv(m_shaderID, GL_COMPILE_STATUS, &compiled); if(compiled == GL_TRUE) return true; GLint logLen; glGetShaderiv(m_shaderID, GL_INFO_LOG_LENGTH, &logLen); if(logLen > 0) { char *buf = new char[logLen]; if(buf != NULL) { glGetShaderInfoLog(m_shaderID, logLen, &logLen, buf); LOG_ERROR("Shader %d compile faild: \n%s\n", m_shaderID, buf); delete [] buf; } glDeleteShader(m_shaderID); m_shaderID = 0; } return false; } ProgramObject::ProgramObject() { m_programID = glCreateProgram(); LOG_INFO("CREATE PROGRAM!!!! --> %d\n", m_programID); } ProgramObject::~ProgramObject() { GLuint attachedShaders[32]; int numAttachedShaders; glGetAttachedShaders(m_programID, 32, &numAttachedShaders, attachedShaders); for(int i = 0; i < numAttachedShaders; ++i) { glDetachShader(m_programID, attachedShaders[i]); } htCheckGLError("Detach Shaders in useProgram"); glDeleteProgram(m_programID); LOG_INFO("ProgramObject release\n"); } bool ProgramObject::initFragmentShaderSourceFromString(const char* fragShader) { return m_programID != 0 && m_fragObj.init(GL_FRAGMENT_SHADER) && m_fragObj.loadShaderSourceFromString(fragShader); } bool ProgramObject::initVertexShaderSourceFromString(const char* vertShader) { return m_programID != 0 && m_vertObj.init(GL_VERTEX_SHADER) && m_vertObj.loadShaderSourceFromString(vertShader); } bool ProgramObject::link() { LOG_INFO("COMPILE PROGRAM!!!!\n"); GLuint attachedShaders[32]; int numAttachedShaders, programStatus; glGetAttachedShaders(m_programID, 32, &numAttachedShaders, attachedShaders); for(int i = 0; i < numAttachedShaders; ++i) { glDetachShader(m_programID, attachedShaders[i]); } htCheckGLError("Detach Shaders in useProgram"); glAttachShader(m_programID, m_vertObj.getShaderID()); glAttachShader(m_programID, m_fragObj.getShaderID()); htCheckGLError("Attach Shaders in useProgram"); glLinkProgram(m_programID); glGetProgramiv(m_programID, GL_LINK_STATUS, &programStatus); m_vertObj.clear(); m_fragObj.clear();
LOG_INFO("LINK %d OK\n", m_programID); htCheckGLError("Link Program"); return true; } void ProgramObject::bind() { glUseProgram(m_programID); } void ProgramObject::sendUniformf(const char* name, GLfloat x) { GETUNIFORM(uniform, m_programID, name); glUniform1f(uniform, x); } void ProgramObject::sendUniformf(const char* name, GLfloat x, GLfloat y) { GETUNIFORM(uniform, m_programID, name); glUniform2f(uniform, x, y); } void ProgramObject::sendUniformf(const char* name, GLfloat x, GLfloat y, GLfloat z) { GETUNIFORM(uniform, m_programID, name); glUniform3f(uniform, x, y, z); } void ProgramObject::sendUniformf(const char* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w) { GETUNIFORM(uniform, m_programID, name); glUniform4f(uniform, x, y, z, w); } void ProgramObject::sendUniformi(const char* name, GLint x) { GETUNIFORM(uniform, m_programID, name); glUniform1i(uniform, x); } void ProgramObject::sendUniformi(const char* name, GLint x, GLint y) { GETUNIFORM(uniform, m_programID, name); glUniform2i(uniform, x, y); } void ProgramObject::sendUniformi(const char* name, GLint x, GLint y, GLint z) { GETUNIFORM(uniform, m_programID, name); glUniform3i(uniform, x, y, z); } void ProgramObject::sendUniformi(const char* name, GLint x, GLint y, GLint z, GLint w) { GETUNIFORM(uniform, m_programID, name); glUniform4i(uniform, x, y, z, w); } void ProgramObject::sendUniformMat2x2(const char* name, int count, GLboolean transpose, const GLfloat* matrix) { GETUNIFORM(uniform, m_programID, name); glUniformMatrix2fv(uniform, count, transpose, matrix); } void ProgramObject::sendUniformMat3x3(const char* name, GLsizei count, GLboolean transpose, const GLfloat* matrix) { GETUNIFORM(uniform, m_programID, name); glUniformMatrix3fv(uniform, count, transpose, matrix); } void ProgramObject::sendUniformMat4x4(const char* name, GLsizei count, GLboolean transpose, const GLfloat* matrix) { GETUNIFORM(uniform, m_programID, name); glUniformMatrix4fv(uniform, count, transpose, matrix); }
if(programStatus != GL_TRUE) { GLint logLen = 0; glGetProgramiv(m_programID, GL_INFO_LOG_LENGTH, &logLen); if(logLen != 0) { char *buf = new char[logLen]; if(buf != NULL) { glGetProgramInfoLog(m_programID, logLen, &logLen, buf); LOG_ERROR("Failed to link the program!\n%s", buf); delete [] buf; } } LOG_INFO("LINK %d Failed\n", m_programID); return false; }
if_condition
[ { "content": "class ProgramObject\n\n{\n\npublic:\n\n\tProgramObject();\n\n\t~ProgramObject();\n\n\n\n\tbool initFragmentShaderSourceFromString(const char* fragShader);\n\n\tbool initVertexShaderSourceFromString(const char* vertShader);\n\n\n\n\tbool link();\n\n\tvoid bind();\n\n\n\n\t// For usage convenience, ...
C++
src/lookup/PerfectCount.cc
adigenova/discovarexp-51885
f827bab9bd0e328fee3dd57b7fefebfeebd92be4
#include "Basevector.h" #include "CoreTools.h" #include "PackAlign.h" #include "lookup/LookupTable.h" #include "lookup/PerfectCount.h" #include "random/RandomSampleFromStream.h" void GetBestKmers( const vecbasevector query, const AlignDir direction, const lookup_table& look, vec<int>& best_pos, vec<unsigned int>& best_index ) { unsigned int K = look.K( ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); best_pos.resize( nqueries * 2 ); best_index.resize( nqueries * 2 ); for ( int id = 0; id < nqueries; id++ ) { const basevector& s = query[id]; if ( s.size( ) < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); int pos = -1; unsigned int min_freq = 0, mindex = 0; int length = S.isize() - (int) K; unsigned int index = Index( S, 0, K ); unsigned int freq = look.Freq(index); if ( freq != 0 ) { mindex = index; pos = 0; if (freq != 1) { min_freq = freq; for ( int j = 1; j <= length; j++ ) { NextIndex( index, S, j, K ); freq = look.Freq(index); if ( freq == 1 ) { mindex = index; pos = j; break; } if ( freq == 0 ) { pos = -1; break; } if ( pos < 0 || freq < min_freq ) { min_freq = freq; mindex = index; pos = j; } } } } best_pos[ 2*id + pass ] = pos; best_index[ 2*id + pass ] = mindex; } } } int PerfectCount( const vecbasevector& query, const String& lookup_file, const AlignDir direction ) { vec<Bool> perfect; PerfectMark( query, lookup_file, direction, perfect ); return Sum(perfect); } void PerfectMark( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<Bool>& perfect ) { perfect.resize_and_set( query.size( ), False ); if ( query.empty( ) ) return; lookup_table look(lookup_file); unsigned int K = look.K( ); vec<int> best_pos; vec<unsigned int> best_index; GetBestKmers( query, direction, look, best_pos, best_index ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); const unsigned int max_query_size = 200 * 1000 * 1000; for ( unsigned int i = 0; i < look.NChunks( ); i++ ) { look.ReadChunk(i); for ( int id = 0; id < nqueries; id++ ) { if ( perfect[id] ) continue; const basevector& s = query[id]; unsigned int query_length = s.size(); if ( query_length < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { if ( perfect[id] ) break; int r = best_pos[ 2*id + pass ]; if ( r < 0 ) continue; static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); unsigned int index = best_index[ 2*id + pass ]; unsigned int start = look.StartLocs(index); unsigned int stop = look.StopLocs(index); for ( unsigned int l = start; l < stop; l++ ) { unsigned int offset = look.Locs(l) + ( max_query_size - r ); unsigned int tig, rpos; look.GetContigPos( look.Locs(l), tig, rpos ); unsigned int startx; unsigned int q_start; unsigned int t_start; unsigned int length = query_length; if ( offset < look.ContigStart(tig) + max_query_size) { q_start = r - rpos; t_start = 0; length -= q_start; startx = look.ContigStart(tig); } else { q_start = 0; t_start = rpos - r; startx = offset - max_query_size; } if (startx + length > look.ContigStop(tig) ) { length = look.ContigSize(tig) - t_start; } if ( length != query_length ) continue; if ( startx < look.BasesStart( ) ) continue; Bool mismatch = False; unsigned int start_of_kmer = r - q_start; for ( unsigned int y = 0; y < start_of_kmer; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; for ( unsigned int y = start_of_kmer + K; y < length; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; perfect[id] = True; break; } } } } } void PerfectPick( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<placement_mark>& places, vec< pair<placement_mark,int> >& places_plus, const int mode, vec<Bool> & queryHasPerfect) { if ( mode == 1 ) places.clear( ); else places_plus.clear( ); if ( query.empty( ) ) return; vec< RandomSampleFromStreamN1<placement_mark> > placesi( query.size( ) ); queryHasPerfect.resize(query.size(), false); lookup_table look(lookup_file); unsigned int K = look.K( ); vec<int> best_pos; vec<unsigned int> best_index; GetBestKmers( query, direction, look, best_pos, best_index ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); const unsigned int max_query_size = 200 * 1000 * 1000; for ( unsigned int i = 0; i < look.NChunks( ); i++ ) { look.ReadChunk(i); for ( int id = 0; id < nqueries; id++ ) { const basevector& s = query[id]; unsigned int query_length = s.size(); if ( query_length < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { int r = best_pos[ 2*id + pass ]; if ( r < 0 ) continue; static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); unsigned int index = best_index[ 2*id + pass ]; unsigned int start = look.StartLocs(index); unsigned int stop = look.StopLocs(index); for ( unsigned int l = start; l < stop; l++ ) { unsigned int offset = look.Locs(l) + ( max_query_size - r ); unsigned int tig, rpos; look.GetContigPos( look.Locs(l), tig, rpos ); unsigned int startx; unsigned int q_start; unsigned int t_start; unsigned int length = query_length; if ( offset < look.ContigStart(tig) + max_query_size) { q_start = r - rpos; t_start = 0; length -= q_start; startx = look.ContigStart(tig); } else { q_start = 0; t_start = rpos - r; startx = offset - max_query_size; } if (startx + length > look.ContigStop(tig) ) { length = look.ContigSize(tig) - t_start; } if ( length != query_length ) continue; if ( startx < look.BasesStart( ) ) continue; Bool mismatch = False; unsigned int start_of_kmer = r - q_start; for ( unsigned int y = 0; y < start_of_kmer; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; for ( unsigned int y = start_of_kmer + K; y < length; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; queryHasPerfect[id] = true; static placement_mark P; P.Set( tig, pass == 0, t_start ); placesi[id](P); } } } } int count = 0; for ( int id = 0; id < nqueries; id++ ) if ( placesi[id].Exists( ) ) ++count; if ( mode == 1 ) places.reserve(count); else places_plus.reserve(count); for ( int id = 0; id < nqueries; id++ ) { if ( placesi[id].Exists( ) ) { if ( mode == 1 ) places.push_back( placesi[id].Sample( ) ); else { places_plus.push_back( make_pair( placesi[id].Sample( ), id ) ); } } } } void PerfectPick( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<placement_mark>& places, vec<Bool> & queryHasPerfect) { vec< pair<placement_mark,int> > places_plus; PerfectPick( query, lookup_file, direction, places, places_plus, 1, queryHasPerfect ); } void PerfectPick( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec< pair<placement_mark,int> >& places_plus, vec<Bool> & queryHasPerfect ) { vec<placement_mark> places; PerfectPick( query, lookup_file, direction, places, places_plus, 2, queryHasPerfect ); } void PerfectCountPlaces( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<int>& places ) { places.resize_and_set( query.size( ), 0 ); if ( query.empty( ) ) return; lookup_table look(lookup_file); unsigned int K = look.K( ); vec<int> best_pos; vec<unsigned int> best_index; GetBestKmers( query, direction, look, best_pos, best_index ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); const unsigned int max_query_size = 200 * 1000 * 1000; for ( unsigned int i = 0; i < look.NChunks( ); i++ ) { look.ReadChunk(i); for ( int id = 0; id < nqueries; id++ ) { const basevector& s = query[id]; unsigned int query_length = s.size(); if ( query_length < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { int r = best_pos[ 2*id + pass ]; if ( r < 0 ) continue; static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); unsigned int index = best_index[ 2*id + pass ]; unsigned int start = look.StartLocs(index); unsigned int stop = look.StopLocs(index); for ( unsigned int l = start; l < stop; l++ ) { unsigned int offset = look.Locs(l) + ( max_query_size - r ); unsigned int tig, rpos; look.GetContigPos( look.Locs(l), tig, rpos ); unsigned int startx; unsigned int q_start; unsigned int t_start; unsigned int length = query_length; if ( offset < look.ContigStart(tig) + max_query_size) { q_start = r - rpos; t_start = 0; length -= q_start; startx = look.ContigStart(tig); } else { q_start = 0; t_start = rpos - r; startx = offset - max_query_size; } if (startx + length > look.ContigStop(tig) ) { length = look.ContigSize(tig) - t_start; } if ( length != query_length ) continue; if ( startx < look.BasesStart( ) ) continue; Bool mismatch = False; unsigned int start_of_kmer = r - q_start; for ( unsigned int y = 0; y < start_of_kmer; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; for ( unsigned int y = start_of_kmer + K; y < length; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; ++places[id]; } } } } }
#include "Basevector.h" #include "CoreTools.h" #include "PackAlign.h" #include "lookup/LookupTable.h" #include "lookup/PerfectCount.h" #include "random/RandomSampleFromStream.h" void GetBestKmers( const vecbasevector query, const AlignDir direction, const lookup_table& look, vec<int>& best_pos, vec<unsigned int>& best_index ) { unsigned int K = look.K( ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); best_pos.resize( nqueries * 2 ); best_index.resize( nqueries * 2 ); for ( int id = 0; id < nqueries; id++ ) { const basevector& s = query[id]; if ( s.size( ) < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); int pos = -1; unsigned int min_freq = 0, mindex = 0; int length = S.isize() - (int) K; unsigned int index = Index( S, 0, K ); unsigned int freq = look.Freq(index); if ( freq != 0 ) { mindex = index; pos = 0; if (freq != 1) { min_freq = freq; for ( int j = 1; j <= length; j++ ) { NextIndex( index, S, j, K ); freq = look.Freq(index); if ( freq == 1 ) { mindex = index; pos = j; break; } if ( freq == 0 ) { pos = -1; break; } if ( pos < 0 || freq < min_freq ) { min_freq = freq; mindex = index; pos = j; } } } } best_pos[ 2*id + pass ] = pos; best_index[ 2*id + pass ] = mindex; } } } int PerfectCount( const vecbasevector& query, const String& lookup_file, const AlignDir direction ) { vec<Bool> perfect; PerfectMark( query, lookup_file, direction, perfect ); return Sum(perfect); } void PerfectMark( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<Bool>& perfect ) { perfect.resize_and_set( query.size( ), False ); if ( query.empty( ) ) return; lookup_table look(lookup_file); unsigned int K = look.K( ); vec<int> best_pos; vec<unsigned int> best_index; GetBestKmers( query, direction, look, best_pos, best_index ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); const unsigned int max_query_size = 200 * 1000 * 1000; for ( unsigned int i = 0; i < look.NChunks( ); i++ ) { look.ReadChunk(i); for ( int id = 0; id < nqueries; id++ ) { if ( perfect[id] ) continue; const basevector& s = query[id]; unsigned int query_length = s.size(); if ( query_length < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { if ( perfect[id] ) break; int r = best_pos[ 2*id + pass ]; if ( r < 0 ) continue; static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); unsigned int index = best_index[ 2*id + pass ]; unsigned int start = look.StartLocs(index); unsigned int stop = look.StopLocs(index); for ( unsigned int l = start; l < stop; l++ ) { unsigned int offset = look.Locs(l) + ( max_query_size - r ); unsigned int tig, rpos; look.GetContigPos( look.Locs(l), tig, rpos ); unsigned int startx; unsigned int q_start; unsigned int t_start; unsigned int length = query_length; if ( offset < look.ContigStart(tig) + max_query_size) { q_start = r - rpos; t_start = 0; length -= q_start; startx = look.ContigStart(tig); } else { q_start = 0; t_start = rpos - r; startx = offset - max_query_size; } if (startx + length > look.ContigStop(tig) ) { length = look.ContigSize(tig) - t_start; } if ( length != query_length ) continue; if ( startx < look.BasesStart( ) ) continue; Bool mismatch = False; unsigned int start_of_kmer = r - q_start; for ( unsigned int y = 0; y < start_of_kmer; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; for ( unsigned int y = start_of_kmer + K; y < length; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; perfect[id] = True; break; } } } } } void PerfectPick( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<placement_mark>& places, vec< pair<placement_mark,int> >& places_plus, const int mode, vec<Bool> & queryHasPerfect) { if ( mode == 1 ) places.clear( ); else places_plus.clear( ); if ( query.empty( ) ) return; vec< RandomSampleFromStreamN1<placement_mark> > placesi( query.size( ) ); queryHasPerfect.resize(query.size(), false); lookup_table look(lookup_file); unsigned int K = look.K( ); vec<int> best_pos; vec<unsigned int> best_index; GetBestKmers( query, direction, look, best_pos, best_index ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); const unsigned int max_query_size = 200 * 1000 * 1000; for ( unsigned int i = 0; i < look.NChunks( ); i++ ) { look.ReadChunk(i); for ( int id = 0; id < nqueries; id++ ) { const basevector& s = query[id]; unsigned int query_length = s.size(); if ( query_length < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { int r = best_pos[ 2*id + pass ]; if ( r < 0 ) continue; static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); unsigned int index = best_index[ 2*id + pass ]; unsigned int start = look.StartLocs(index); unsigned int stop = look.StopLocs(index); for ( unsigned int l = start; l < stop; l++ ) { unsigned int offset = look.Locs(l) + ( max_query_size - r ); unsigned int tig, rpos; look.GetContigPos( look.Locs(l), tig, rpos ); unsigned int startx; unsigned int q_start; unsigned int t_start; unsigned int length = query_length; if ( offset < look.ContigStart(tig) + max_query_size) { q_start = r - rpos; t_start = 0; length -= q_start; startx = look.ContigStart(tig); } else { q_start = 0; t_start = rpos - r; startx = offset - max_query_size; } if (startx + length > look.ContigStop(tig) ) { length = look.ContigSize(tig) - t_start; } if ( length != query_length ) continue; if ( startx < look.BasesStart( ) ) continue; Bool mismatch = False; unsigned int start_of_kmer = r - q_start; for ( unsigned int y = 0; y < start_of_kmer; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; for ( unsigned int y = start_of_kmer + K; y < length; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; queryHasPerfect[id] = true; static placement_mark P; P.Set( tig, pass == 0, t_start ); placesi[id](P); } } } } int count = 0; for ( int id = 0; id < nqueries; id++ ) if ( placesi[id].Exists( ) ) ++count; if ( mode == 1 ) places.reserve(count); else places_plus.reserve(count); for ( int id = 0; id < nqueries; id++ ) { if ( placesi[id].Exists( ) ) { if ( mode == 1 ) places.push_back( placesi[id].Sample( ) ); else { places_plus.push_back( make_pair( placesi[id].Sample( ), id ) ); } } } } void PerfectPick( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<placement_mark>& places, vec<Bool> & queryHasPerfect) { vec< pair<placement_mark,int> > places_plus; PerfectPick( query, lookup_file, direction, places, places_plus, 1, queryHasPerfect ); } void PerfectPick( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec< pair<placement_mark,int> >& places_plus, vec<Bool> & queryHasPerfect ) { vec<placement_mark> places; PerfectPick( query, lookup_file, direction, places, places_plus, 2, queryHasPerfect ); }
void PerfectCountPlaces( const vecbasevector& query, const String& lookup_file, const AlignDir direction, vec<int>& places ) { places.resize_and_set( query.size( ), 0 ); if ( query.empty( ) ) return; lookup_table look(lookup_file); unsigned int K = look.K( ); vec<int> best_pos; vec<unsigned int> best_index; GetBestKmers( query, direction, look, best_pos, best_index ); const int npasses = ( direction == FW ? 1 : 2 ); const int nqueries = query.size( ); const unsigned int max_query_size = 200 * 1000 * 1000; for ( unsigned int i = 0; i < look.NChunks( ); i++ ) { look.ReadChunk(i); for ( int id = 0; id < nqueries; id++ ) { const basevector& s = query[id]; unsigned int query_length = s.size(); if ( query_length < K ) continue; for ( int pass = 0; pass < npasses; pass++ ) { int r = best_pos[ 2*id + pass ]; if ( r < 0 ) continue; static basevector src; if ( pass == 1 ) src.ReverseComplement(s); const basevector& S = ( pass == 0 ? s : src ); unsigned int index = best_index[ 2*id + pass ]; unsigned int start = look.StartLocs(index); unsigned int stop = look.StopLocs(index); for ( unsigned int l = start; l < stop; l++ ) { unsigned int offset = look.Locs(l) + ( max_query_size - r ); unsigned int tig, rpos; look.GetContigPos( look.Locs(l), tig, rpos ); unsigned int startx; unsigned int q_start; unsigned int t_start; unsigned int length = query_length; if ( offset < look.ContigStart(tig) + max_query_size) { q_start = r - rpos; t_start = 0; length -= q_start; startx = look.ContigStart(tig); } else { q_start = 0; t_start = rpos - r; startx = offset - max_query_size; } if (startx + length > look.ContigStop(tig) ) { length = look.ContigSize(tig) - t_start; } if ( length != query_length ) continue; if ( startx < look.BasesStart( ) ) continue; Bool mismatch = False; unsigned int start_of_kmer = r - q_start; for ( unsigned int y = 0; y < start_of_kmer; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; for ( unsigned int y = start_of_kmer + K; y < length; y++ ) { if ( S[q_start + y] != look.Base( startx + y ) ) { mismatch = True; break; } } if (mismatch) continue; ++places[id]; } } } } }
function_block-full_function
[ { "content": "/// Orders look aligns by 1) query id, then 2) complete position/structure of the target region(s)\n\n/// the query aligns to: first by target id, then start on target, then end on target, then number\n\n/// of gaps, then starts/ends of all blocks, and finally by number of mismatches.\n\nstruct or...
C++
silo-scripts/myscripts/replay-file-27.cpp
shenweihai1/rolis-eurosys2022
59b3fd58144496a9b13415e30b41617b34924323
#include <iostream> #include <string> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <fstream> #include <string.h> #include <chrono> #include <vector> #include <map> #include <cstring> #include <algorithm> #include <stdlib.h> using namespace std; std::map<long, std::string> table_map = {}; int OFFSET_CID = 0; int OFFSET_K = 8 ; int OFFSET_V = 16 ; int OFFSET_TABLE_ID = 24; int OFFSET_DELETE_TRUE = 26 ; long get_file_size(std::string filename) { struct stat *stat_buf=new struct stat(); int rc = stat(filename.c_str(), stat_buf); auto ans = rc == 0 ? stat_buf->st_size : -1; delete stat_buf; return ans; } inline std::vector<std::string> split_util2( std::string const& original, char separator) { std::vector<std::string> results; results.reserve(32); std::string::const_iterator start = original.begin(); std::string::const_iterator end = original.end(); std::string::const_iterator next = std::find( start, end, separator ); while ( next != end ) { results.emplace_back( start, next ); start = next + 1; next = std::find( start, end, separator ); } results.emplace_back( start, next ); return results; } bool fileToMap(const std::string &filename,std::map<long, std::string> &fileMap) { ifstream ifile; ifile.open(filename.c_str()); if(!ifile) { std::cout << "File " << filename << " Can't be read successfully " << '\n'; return false; } string line; string key; vector<string> v_str; while(ifile>>line) { v_str = split_util2(line,','); fileMap[stoul(v_str[1])] = v_str[0]; } return true; } namespace hopman_fast { struct itostr_helper { static unsigned out[10000]; itostr_helper() { for (int i = 0; i < 10000; i++) { unsigned v = i; char * o = (char*)(out + i); o[3] = v % 10 + '0'; o[2] = (v % 100) / 10 + '0'; o[1] = static_cast<char>((v % 1000) / 100) + '0'; o[0] = static_cast<char>((v % 10000) / 1000); if (o[0]) o[0] |= 0x30; else if (o[1] != '0') o[0] |= 0x20; else if (o[2] != '0') o[0] |= 0x10; else o[0] |= 0x00; } } }; unsigned itostr_helper::out[10000]; itostr_helper hlp_init; template <typename T> void itostr(T o, std::string& out) { typedef itostr_helper hlp; unsigned blocks[3], *b = blocks + 2; blocks[0] = o < 0 ? ~o + 1 : o; blocks[2] = blocks[0] % 10000; blocks[0] /= 10000; blocks[2] = hlp::out[blocks[2]]; if (blocks[0]) { blocks[1] = blocks[0] % 10000; blocks[0] /= 10000; blocks[1] = hlp::out[blocks[1]]; blocks[2] |= 0x30303030; b--; } if (blocks[0]) { blocks[0] = hlp::out[blocks[0] % 10000]; blocks[1] |= 0x30303030; b--; } char* f = ((char*)b); f += 3 - (*f >> 4); char* str = (char*)blocks; if (o < 0) *--f = '-'; out.assign(f, (str + 12) - f); } template <typename T> std::string itostr(T o) { std::string result; itostr(o,result); return result; } } void readOneFile(std::string file_name) { size_t sz = get_file_size(file_name); int fd = open (file_name.c_str (), O_RDONLY); size_t ret = 0; void *ptr = NULL; char *buffer; ptr = (void *) malloc (sz); buffer = (char *) ptr; ret = read (fd, buffer, sz); if (ret == -1 || ret == 0) { std::cout << "[mymain] file is empty " << ret << std::endl; } unsigned long long int *cid = 0; unsigned long long int *k = 0; unsigned long long int *v = 0; unsigned short int *table_id = 0; unsigned char *delete_true = 0; const unsigned char true_flag = 0x1; std::ofstream file(file_name + ".log"); size_t chunk = ret / 27 ; for (size_t i=0; i < chunk; ++i) { cid = reinterpret_cast<unsigned long long int *>(buffer + i * 27 + OFFSET_CID); k = reinterpret_cast<unsigned long long int *>(buffer + i * 27 + OFFSET_K); v = reinterpret_cast<unsigned long long int *>(buffer + i * 27 + OFFSET_V); table_id = reinterpret_cast<unsigned short int *>(buffer + i * 27 + OFFSET_TABLE_ID); delete_true = reinterpret_cast<unsigned char *>(buffer + i * 27 + OFFSET_DELETE_TRUE); bool isDeleted = false; if(*delete_true & true_flag) { isDeleted = true ; } if (*table_id == 0 || *table_id > 20000) { std::cout << "table_id " << *table_id << ":" << i << ":" << ret << std::endl; exit(1); } auto str_key = hopman_fast::itostr(*k); std::string row = to_string(*cid) + "," + str_key + "," + to_string(*v) + "," + to_string(*table_id) + "," + table_map[*table_id] + "," + to_string(isDeleted) + "\n"; file << row ; } } namespace so { std::string& itostr(int n, std::string& s) { if (n == 0) { s = "0"; return s; } int sign = -(n < 0); unsigned int val = (n ^ sign) - sign; int size; if (val >= 10000) { if (val >= 10000000) { if (val >= 1000000000) size = 10; else if (val >= 100000000) size = 9; else size = 8; } else { if (val >= 1000000) size = 7; else if (val >= 100000) size = 6; else size = 5; } } else { if (val >= 100) { if (val >= 1000) size = 4; else size = 3; } else { if (val>=10) size = 2; else size = 1; } } s.resize(-sign + size); char* c = &s[0]; if (sign) *c++='-'; char* d = c + size - 1; while(val > 0) { *d-- = '0' + (val % 10); val /= 10; } return s; } template <typename T> std::string itostr(T o) { std::string result; itostr(o,result); return result; } } namespace cppx { using std::numeric_limits; using std::reverse; typedef numeric_limits<long> Long_info; int const long_digits = Long_info::max_digits10; int const long_bufsize = long_digits + 2; inline void unsigned_to_decimal( unsigned long number, char* buffer ) { if( number == 0 ) { *buffer++ = '0'; } else { char* p_first = buffer; while( number != 0 ) { *buffer++ = '0' + number % 10; number /= 10; } reverse( p_first, buffer ); } *buffer = '\0'; } inline auto decimal_from_unsigned( unsigned long number, char* buffer ) -> char const* { unsigned_to_decimal( number, buffer ); return buffer; } inline void to_decimal( long number, char* buffer ) { if( number < 0 ) { buffer[0] = '-'; unsigned_to_decimal( -number, buffer + 1 ); } else { unsigned_to_decimal( number, buffer ); } } inline auto decimal_from( long number, char* buffer ) -> char const* { to_decimal( number, buffer ); return buffer; } } int main() { unsigned long long int k = 10232314212323; std::string s = hopman_fast::itostr(k) ; std::cout << s << " : " << std::to_string(k) << " : " << so::itostr(k) << std::endl; std::cout << sizeof(unsigned long long int) << " : " << sizeof(unsigned long) << " : " << sizeof(uint64_t) << " : " << sizeof(unsigned)<< std::endl; }
#include <iostream> #include <string> #include <sys/stat.h> #include <fcntl.h> #include <unistd.h> #include <fstream> #include <string.h> #include <chrono> #include <vector> #include <map> #include <cstring> #include <algorithm> #include <stdlib.h> using namespace std; std::map<long, std::string> table_map = {}; int OFFSET_CID = 0; int OFFSET_K = 8 ; int OFFSET_V = 16 ; int OFFSET_TABLE_ID = 24; int OFFSET_DELETE_TRUE = 26 ; long get_file_size(std::string filename) { struct stat *stat_buf=new struct stat(); int rc = stat(filename.c_str(), stat_buf); auto ans = rc == 0 ? stat_buf->st_size : -1; delete stat_buf; return ans; } inline std::vector<std::string> split_util2( std::string const& original, char separator) { std::vector<std::string> results; results.reserve(32); std::string::const_iterator start = original.begin(); std::string::const_iterator end = original.end(); std::string::const_iterator next = std::find( start, end, separator ); while ( next != end ) { results.emplace_back( start, next ); start = next + 1; next = std::find( start, end, separator ); } results.emplace_back( start, next ); return results; } bool fileToMap(const std::string &filename,std::map<long, std::string> &fileMap) { ifstream ifile; ifile.open(filename.c_str()); if(!ifile) { std::cout << "File " << filename << " Can't be read successfully " << '\n'; return false; } string line; string key; vector<string> v_str; while(ifile>>line) { v_str = split_util2(line,','); fileMap[stoul(v_str[1])] = v_str[0]; } return true; } namespace hopman_fast { struct itostr_helper { static unsigned out[10000]; itostr_helper() { for (int i = 0; i < 10000; i++) { unsigned v = i; char * o = (char*)(out + i); o[3] = v % 10 + '0'; o[2] = (v % 100) / 10 + '0'; o[1] = static_cast<char>((v % 1000) / 100) + '0'; o[0] = static_cast<char>((v % 10000) / 1000); if (o[0]) o[0] |= 0x30; else if (o[1] != '0') o[0] |= 0x20; else if (o[2] != '0') o[0] |= 0x10; else o[0] |= 0x00; } } }; unsigned itostr_helper::out[10000]; itostr_helper hlp_init; template <typename T> void itostr(T o, std::string& out) { typedef itostr_helper hlp; unsigned blocks[3], *b = blocks + 2; blocks[0] = o < 0 ? ~o + 1 : o; blocks[2] = blocks[0] % 10000; blocks[0] /= 10000; blocks[2] = hlp::out[blocks[2]]; if (blocks[0]) { blocks[1] = blocks[0] % 10000; blocks[0] /= 10000; blocks[1] = hlp::out[blocks[1]]; blocks[2] |= 0x30303030; b--; } if (blocks[0]) { blocks[0] = hlp::out[blocks[0] % 10000]; blocks[1] |= 0x30303030; b--; } char* f = ((char*)b); f += 3 - (*f >> 4); char* str = (char*)blocks; if (o < 0) *--f = '-'; out.assign(f, (str + 12) - f); } template <typename T> std::string itostr(T o) { std::string result; itostr(o,result); return result; } } void readOneFile(std::string file_name) { size_t sz = get_file_size(file_name); int fd = open (file_name.c_str (), O_RDONLY); size_t ret = 0; void *ptr = NULL; char *buffer; ptr = (void *) malloc (sz); buffer = (char *) ptr; ret = read (fd, buffer, sz); if (ret == -1 || ret == 0) { std::cout << "[mymain] file is empty " << ret << std::endl; } unsigned long long int *cid = 0; unsigned long long int *k = 0; unsigned long long int *v = 0; unsigned short int *table_id = 0; unsigned char *delete_true = 0; const unsigned char true_flag = 0x1; std::ofstream file(file_name + ".log"); size_t chunk = ret / 27 ; for (size_t i=0; i < chunk; ++i) { cid = reinterpret_cast<unsigned long long int *>(buffer + i * 27 + OFFSET_CID); k = reinterpret_cast<unsigned long long int *>(buffer + i * 27 + OFFSET_K); v = reinterpret_cast<unsigned long long int *>(buffer + i * 27 + OFFSET_V); table_id = reinterpret_cast<unsigned short int *>(buffer + i * 27 + OFFSET_TABLE_ID); delete_true = reinterpret_cast<unsigned char *>(buffer + i * 27 + OFFSET_DELETE_TRUE); bool isDeleted = false; if(*delete_true & true_flag) { isDeleted = true ; } if (*table_id == 0 || *table_id > 20000) { std::cout << "table_id " << *table_id << ":" << i << ":" << ret << std::endl; exit(1); } auto str_key = hopman_fast::itostr(*k); std::string row = to_string(*cid) + "," + str_key + "," + to_string(*v) + "," + to_string(*table_id) + "," + table_map[*table_id] + "," + to_string(isDeleted) + "\n"; file << row ; } } namespace so { std::string& itostr(int n, std::string& s) { if (n == 0) { s = "0"; return s; } int sign = -(n < 0); unsigned int val = (n ^ sign) - sign; int size; if (val >= 10000) { if (val >= 10000000) { if (val >= 1000000000) size = 10; else if (val >= 100000000) size = 9; else size = 8; } else { if (val >= 1000000) size = 7; else if (val >= 100000) size = 6; else size = 5
unsigned long number, char* buffer ) { if( number == 0 ) { *buffer++ = '0'; } else { char* p_first = buffer; while( number != 0 ) { *buffer++ = '0' + number % 10; number /= 10; } reverse( p_first, buffer ); } *buffer = '\0'; } inline auto decimal_from_unsigned( unsigned long number, char* buffer ) -> char const* { unsigned_to_decimal( number, buffer ); return buffer; } inline void to_decimal( long number, char* buffer ) { if( number < 0 ) { buffer[0] = '-'; unsigned_to_decimal( -number, buffer + 1 ); } else { unsigned_to_decimal( number, buffer ); } } inline auto decimal_from( long number, char* buffer ) -> char const* { to_decimal( number, buffer ); return buffer; } } int main() { unsigned long long int k = 10232314212323; std::string s = hopman_fast::itostr(k) ; std::cout << s << " : " << std::to_string(k) << " : " << so::itostr(k) << std::endl; std::cout << sizeof(unsigned long long int) << " : " << sizeof(unsigned long) << " : " << sizeof(uint64_t) << " : " << sizeof(unsigned)<< std::endl; }
; } } else { if (val >= 100) { if (val >= 1000) size = 4; else size = 3; } else { if (val>=10) size = 2; else size = 1; } } s.resize(-sign + size); char* c = &s[0]; if (sign) *c++='-'; char* d = c + size - 1; while(val > 0) { *d-- = '0' + (val % 10); val /= 10; } return s; } template <typename T> std::string itostr(T o) { std::string result; itostr(o,result); return result; } } namespace cppx { using std::numeric_limits; using std::reverse; typedef numeric_limits<long> Long_info; int const long_digits = Long_info::max_digits10; int const long_bufsize = long_digits + 2; inline void unsigned_to_decimal(
random
[ { "content": "struct RemoveConstFromKey<std::pair<const K, V> > {\n\n typedef std::pair<K, V> type;\n\n};\n\n\n\n// Mapping from booleans to types. Similar to boost::bool_<kValue> and\n\n// std::integral_constant<bool, kValue>.\n\ntemplate <bool kValue>\n", "file_path": "third-party/paxos/dependencies/yaml...
C++
stereo_egomotion/base/evaluator.cc
bartn8/stereo-vision
1180045fe560478e5c441e75202cc899fe90ec3d
#include "evaluator.h" #include <iostream> #include <fstream> #include <stdio.h> #include <math.h> #include <tuple> #include <limits> #include <algorithm> #include <iomanip> #include <dirent.h> #include <sys/stat.h> namespace egomotion { typedef std::tuple<std::string,double,double> ResultTuple; using namespace std; using namespace libviso; namespace { float lengths[] = {100,200,300,400,500,600,700,800}; int32_t num_lengths = 8; struct errors { int32_t first_frame; float r_err; float t_err; float len; float speed; errors (int32_t first_frame,float r_err,float t_err,float len,float speed) : first_frame(first_frame),r_err(r_err),t_err(t_err),len(len),speed(speed) {} }; vector<Matrix> loadPoses(string file_name) { vector<Matrix> poses; FILE *fp = fopen(file_name.c_str(),"r"); if (!fp) return poses; while (!feof(fp)) { Matrix P = Matrix::eye(4); if (fscanf(fp, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf", &P.val[0][0], &P.val[0][1], &P.val[0][2], &P.val[0][3], &P.val[1][0], &P.val[1][1], &P.val[1][2], &P.val[1][3], &P.val[2][0], &P.val[2][1], &P.val[2][2], &P.val[2][3] )==12) { poses.push_back(P); } } fclose(fp); return poses; } vector<float> trajectoryDistances(const std::vector<Matrix>& poses) { vector<float> dist; dist.push_back(0); for (int32_t i=1; i<poses.size(); i++) { Matrix P1 = poses[i-1]; Matrix P2 = poses[i]; float dx = P1.val[0][3]-P2.val[0][3]; float dy = P1.val[1][3]-P2.val[1][3]; float dz = P1.val[2][3]-P2.val[2][3]; dist.push_back(dist[i-1]+sqrt(dx*dx+dy*dy+dz*dz)); } return dist; } int32_t lastFrameFromSegmentLength(vector<float> &dist,int32_t first_frame,float len) { for (int32_t i=first_frame; i<dist.size(); i++) if (dist[i]>dist[first_frame]+len) return i; return -1; } inline float rotationError(const Matrix& pose_error) { float a = pose_error.val[0][0]; float b = pose_error.val[1][1]; float c = pose_error.val[2][2]; float d = 0.5*(a+b+c-1.0); return acos(max(min(d,1.0f),-1.0f)); } inline float translationError(const Matrix& pose_error) { float dx = pose_error.val[0][3]; float dy = pose_error.val[1][3]; float dz = pose_error.val[2][3]; return sqrt(dx*dx+dy*dy+dz*dz); } std::vector<errors> CalcSequenceErrors(const std::vector<Matrix>& poses_gt, const std::vector<Matrix>& poses_result) { std::vector<errors> err; int32_t step_size = 10; vector<float> dist = trajectoryDistances(poses_gt); for (int32_t first_frame=0; first_frame<poses_gt.size(); first_frame+=step_size) { for (int32_t i=0; i<num_lengths; i++) { float len = lengths[i]; int32_t last_frame = lastFrameFromSegmentLength(dist,first_frame,len); if (last_frame==-1) continue; Matrix pose_delta_gt = Matrix::inv(poses_gt[first_frame])*poses_gt[last_frame]; Matrix pose_delta_result = Matrix::inv(poses_result[first_frame])*poses_result[last_frame]; Matrix pose_error = Matrix::inv(pose_delta_result)*pose_delta_gt; float r_err = rotationError(pose_error); float t_err = translationError(pose_error); float num_frames = (float)(last_frame-first_frame+1); float speed = len/(0.1*num_frames); err.push_back(errors(first_frame,r_err/len,t_err/len,len,speed)); } } return err; } void GetStats(std::vector<errors> errors, double& t_error, double& r_error) { double t_err = 0; double r_err = 0; for (const auto& e : errors) { t_err += e.t_err; r_err += e.r_err; } double num = errors.size(); t_error = 100.0 * t_err / num; r_error = 100.0 * r_err / num; } } void Evaluator::Eval(const std::string& gt_fname, const std::vector<libviso::Matrix>& egomotion_poses, double& trans_error, double& rot_error) { std::vector<Matrix> poses_gt = loadPoses(gt_fname); if(poses_gt.size() == 0 || egomotion_poses.size() != poses_gt.size()) throw 1; std::vector<errors> errors = CalcSequenceErrors(poses_gt, egomotion_poses); if(errors.size() > 0) GetStats(errors, trans_error, rot_error); else throw 1; } libviso::Matrix Evaluator::EigenMatrixToLibvisoMatrix(const Eigen::Matrix4d& mat1) { libviso::Matrix mat2 = libviso::Matrix(mat1.rows(), mat1.cols()); for (int i = 0; i < mat1.rows(); i++) for (int j = 0; j < mat1.cols(); j++) mat2.val[i][j] = mat1(i,j); return mat2; } void Evaluator::EigenVectorToLibvisoVector(const std::vector<Eigen::Matrix4d>& vec1, std::vector<libviso::Matrix>& vec2) { vec2.clear(); for (const auto& rt : vec1) vec2.push_back(EigenMatrixToLibvisoMatrix(rt)); } void Evaluator::Eval(const std::string& gt_fname, const std::vector<Eigen::Matrix4d>& egomotion_poses, double& trans_error, double& rot_error) { std::vector<libviso::Matrix> libviso_poses; EigenVectorToLibvisoVector(egomotion_poses, libviso_poses); Eval(gt_fname, libviso_poses, trans_error, rot_error); } }
#include "evaluator.h" #include <iostream> #include <fstream> #include <stdio.h> #include <math.h> #include <tuple> #include <limits> #include <algorithm> #include <iomanip> #include <dirent.h> #include <sys/stat.h> namespace egomotion { typedef std::tuple<std::string,double,double> ResultTuple; using namespace std; using namespace libviso; namespace { float lengths[] = {100,200,300,400,500,600,700,800}; int32_t num_lengths = 8; struct errors { int32_t first_frame; float r_err; float t_err; float len; float speed; errors (int32_t first_frame,float r_err,float t_err,float len,float speed) : first_frame(first_frame),r_err(r_err),t_err(t_err),len(len),speed(speed) {} }; vector<Matrix> loadPoses(string file_name) { vector<Matrix> poses; FILE *fp = fopen(file_name.c_str(),"r"); if (!fp) return poses; while (!feof(fp)) { Matrix P = Matrix::eye(4); if (fscanf(fp, "%lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf %lf", &P.val[0][0], &P.val[0][1], &P.val[0][2], &P.val[0][3], &P.val[1][0], &P.val[1][1], &P.val[1][2], &P.val[1][3], &P.val[2][0], &P.val[2][1], &P.val[2][2], &P.val[2][3] )==12) { poses.push_back(P); } } fclose(fp); return poses; } vector<float> trajectoryDistances(const std::vector<Matrix>& poses) { vector<float> dist; dist.push_back(0); for (int32_t i=1; i<poses.size(); i++) { Matrix P1 = poses[i-1]; Matrix P2 = poses[i]; float dx = P1.val[0][3]-P2.val[0][3]; float dy = P1.val[1][3]-P2.val[1][3]; float dz = P1.val[2][3]-P2.val[2][3]; dist.push_back(dist[i-1]+sqrt(dx*dx+dy*dy+dz*dz)); } return dist; } int32_t lastFrameFromSegmentLength(vector<float> &dist,int32_t first_frame,float len) { for (int32_t i=first_frame; i<dist.size(); i++) if (dist[i]>dist[first_frame]+len) return i; return -1; } inline float rotationError(const Matrix& pose_error) { float a = pose_error.val[0][0]; float b = pose_error.val[1][1]; float c = pose_error.val[2][2]; float d = 0.5*(a+b+c-1.0); return acos(max(min(d,1.0f),-1.0f)); } inline float translationError(const Matrix& pose_error) { float dx = pose_error.val[0][3]; float dy = pose_error.val[1][3]; float dz = pose_error.val[2][3]; return sqrt(dx*dx+dy*dy+dz*dz); } std::vector<errors> CalcSequenceErrors(const std::vector<Matrix>& poses_gt, const std::vector<Matrix>& poses_result) { std::vector<errors> err; int32_t step_size = 10; vector<float> dist = trajectoryDistances(poses_gt); for (int32_t first_frame=0; first_frame<poses_gt.size(); first_frame+=step_size) { for (int32_t i=0; i<num_lengths; i++) { float len = lengths[i]; int32_t last_frame = lastFrameFromSegmentLength(dist,first_frame,len); if (last_frame==-1) continue; Matrix pose_delta_gt = Matrix::inv(poses_gt[first_frame])*poses_gt[last_frame]; Matrix pose_delta_result = Matrix::inv(poses_result[first_frame])*poses_result[last_frame]; Matrix pose_error = Matrix::inv(pose_delta_result)*pose_delta_gt; float r_err = rotationError(pose_error); float t_err = translationError(pose_error); float num_frames = (float)(last_frame-first_frame+1); float speed = len/(0.1*num_frames); err.push_back(errors(first_frame,r_err/len,t_err/len,len,speed)); } } return err; } void GetStats(std::vector<errors> errors, double& t_error, double& r_error) { double t_err = 0; double r_err = 0; for (const auto& e : errors) { t_err += e.t_err; r_err += e.r_err; } double num = errors.size(); t_error = 100.0 * t_err / num; r_error = 100.0 * r_err / num; } } void Evaluator::Eval(const std::string& gt_fname, const std::vector<libviso::Matrix>& egomotion_poses, double& trans_error, double& rot_error) { std::vector<Matrix> poses_gt = loadPoses(gt_fname); if(poses_gt.size() == 0 || egomotion_poses.size() != poses_gt.size()) throw 1; std::vector<errors> errors = CalcSequenceErrors(poses_gt, egomotion_poses); if(errors.size() > 0) GetStats(errors, trans_error, rot_error); else throw 1; } libviso::Matrix Evaluator::EigenMatrixToLibvisoMatrix(const Eigen::Matrix4d& mat1) { libviso::Matrix mat2 = libviso::Matrix(mat1.rows(), mat1.cols()); for (int i = 0; i < mat1.rows(); i++) for (int j = 0; j < mat1.cols(); j++) mat2.val[i][j] = mat1(i,j); return mat2; }
void Evaluator::Eval(const std::string& gt_fname, const std::vector<Eigen::Matrix4d>& egomotion_poses, double& trans_error, double& rot_error) { std::vector<libviso::Matrix> libviso_poses; EigenVectorToLibvisoVector(egomotion_poses, libviso_poses); Eval(gt_fname, libviso_poses, trans_error, rot_error); } }
void Evaluator::EigenVectorToLibvisoVector(const std::vector<Eigen::Matrix4d>& vec1, std::vector<libviso::Matrix>& vec2) { vec2.clear(); for (const auto& rt : vec1) vec2.push_back(EigenMatrixToLibvisoMatrix(rt)); }
function_block-full_function
[ { "content": "struct greaterThanPtr : public std::binary_function<const float*, const float*, bool>\n\n{\n\n bool operator () (const float* a, const float* b) const\n\n { return *a > *b; }\n\n};\n\n\n\n}\n\n\n\nnamespace track {\n\n\n\nFeatureDetectorHarrisCV::FeatureDetectorHarrisCV(int block_size, int k...
C++
Source/Tools/Game/zmq/src/tcp_listener.cpp
299299/tesla_hmi
d5f2ad158d1b69d46d7fc99898ec90e19f1ae419
#include "precompiled.hpp" #include <new> #include <string> #include <stdio.h> #include "tcp_listener.hpp" #include "io_thread.hpp" #include "config.hpp" #include "err.hpp" #include "ip.hpp" #include "tcp.hpp" #include "socket_base.hpp" #include "address.hpp" #ifndef ZMQ_HAVE_WINDOWS #include <unistd.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/tcp.h> #include <netinet/in.h> #include <netdb.h> #include <fcntl.h> #ifdef ZMQ_HAVE_VXWORKS #include <sockLib.h> #endif #endif #ifdef ZMQ_HAVE_OPENVMS #include <ioctl.h> #endif zmq::tcp_listener_t::tcp_listener_t (io_thread_t *io_thread_, socket_base_t *socket_, const options_t &options_) : stream_listener_base_t (io_thread_, socket_, options_) { } void zmq::tcp_listener_t::in_event () { fd_t fd = accept (); if (fd == retired_fd) { _socket->event_accept_failed ( make_unconnected_bind_endpoint_pair (_endpoint), zmq_errno ()); return; } int rc = tune_tcp_socket (fd); rc = rc | tune_tcp_keepalives ( fd, options.tcp_keepalive, options.tcp_keepalive_cnt, options.tcp_keepalive_idle, options.tcp_keepalive_intvl); rc = rc | tune_tcp_maxrt (fd, options.tcp_maxrt); if (rc != 0) { _socket->event_accept_failed ( make_unconnected_bind_endpoint_pair (_endpoint), zmq_errno ()); return; } create_engine (fd); } std::string zmq::tcp_listener_t::get_socket_name (zmq::fd_t fd_, socket_end_t socket_end_) const { return zmq::get_socket_name<tcp_address_t> (fd_, socket_end_); } int zmq::tcp_listener_t::create_socket (const char *addr_) { _s = tcp_open_socket (addr_, options, true, true, &_address); if (_s == retired_fd) { return -1; } make_socket_noninheritable (_s); int flag = 1; int rc; #ifdef ZMQ_HAVE_WINDOWS rc = setsockopt (_s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, reinterpret_cast<const char *> (&flag), sizeof (int)); wsa_assert (rc != SOCKET_ERROR); #elif defined ZMQ_HAVE_VXWORKS rc = setsockopt (_s, SOL_SOCKET, SO_REUSEADDR, (char *) &flag, sizeof (int)); errno_assert (rc == 0); #else rc = setsockopt (_s, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof (int)); errno_assert (rc == 0); #endif #if defined ZMQ_HAVE_VXWORKS rc = bind (_s, (sockaddr *) _address.addr (), _address.addrlen ()); #else rc = bind (_s, _address.addr (), _address.addrlen ()); #endif #ifdef ZMQ_HAVE_WINDOWS if (rc == SOCKET_ERROR) { errno = wsa_error_to_errno (WSAGetLastError ()); goto error; } #else if (rc != 0) goto error; #endif rc = listen (_s, options.backlog); #ifdef ZMQ_HAVE_WINDOWS if (rc == SOCKET_ERROR) { errno = wsa_error_to_errno (WSAGetLastError ()); goto error; } #else if (rc != 0) goto error; #endif return 0; error: int err = errno; close (); errno = err; return -1; } int zmq::tcp_listener_t::set_local_address (const char *addr_) { if (options.use_fd != -1) { _s = options.use_fd; } else { if (create_socket (addr_) == -1) return -1; } _endpoint = get_socket_name (_s, socket_end_local); _socket->event_listening (make_unconnected_bind_endpoint_pair (_endpoint), _s); return 0; } zmq::fd_t zmq::tcp_listener_t::accept () { zmq_assert (_s != retired_fd); struct sockaddr_storage ss; memset (&ss, 0, sizeof (ss)); #if defined ZMQ_HAVE_HPUX || defined ZMQ_HAVE_VXWORKS int ss_len = sizeof (ss); #else socklen_t ss_len = sizeof (ss); #endif #if defined ZMQ_HAVE_SOCK_CLOEXEC && defined HAVE_ACCEPT4 fd_t sock = ::accept4 (_s, reinterpret_cast<struct sockaddr *> (&ss), &ss_len, SOCK_CLOEXEC); #else fd_t sock = ::accept (_s, reinterpret_cast<struct sockaddr *> (&ss), &ss_len); #endif if (sock == retired_fd) { #if defined ZMQ_HAVE_WINDOWS const int last_error = WSAGetLastError (); wsa_assert (last_error == WSAEWOULDBLOCK || last_error == WSAECONNRESET || last_error == WSAEMFILE || last_error == WSAENOBUFS); #elif defined ZMQ_HAVE_ANDROID errno_assert (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR || errno == ECONNABORTED || errno == EPROTO || errno == ENOBUFS || errno == ENOMEM || errno == EMFILE || errno == ENFILE || errno == EINVAL); #else errno_assert (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR || errno == ECONNABORTED || errno == EPROTO || errno == ENOBUFS || errno == ENOMEM || errno == EMFILE || errno == ENFILE); #endif return retired_fd; } make_socket_noninheritable (sock); if (!options.tcp_accept_filters.empty ()) { bool matched = false; for (options_t::tcp_accept_filters_t::size_type i = 0; i != options.tcp_accept_filters.size (); ++i) { if (options.tcp_accept_filters[i].match_address ( reinterpret_cast<struct sockaddr *> (&ss), ss_len)) { matched = true; break; } } if (!matched) { #ifdef ZMQ_HAVE_WINDOWS int rc = closesocket (sock); wsa_assert (rc != SOCKET_ERROR); #else int rc = ::close (sock); errno_assert (rc == 0); #endif return retired_fd; } } if (zmq::set_nosigpipe (sock)) { #ifdef ZMQ_HAVE_WINDOWS int rc = closesocket (sock); wsa_assert (rc != SOCKET_ERROR); #else int rc = ::close (sock); errno_assert (rc == 0); #endif return retired_fd; } if (options.tos != 0) set_ip_type_of_service (sock, options.tos); return sock; }
#include "precompiled.hpp" #include <new> #include <string> #include <stdio.h> #include "tcp_listener.hpp" #include "io_thread.hpp" #include "config.hpp" #include "err.hpp" #include "ip.hpp" #include "tcp.hpp" #include "socket_base.hpp" #include "address.hpp" #ifndef ZMQ_HAVE_WINDOWS #include <unistd.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/tcp.h> #include <netinet/in.h> #include <netdb.h> #include <fcntl.h> #ifdef ZMQ_HAVE_VXWORKS #include <sockLib.h> #endif #endif #ifdef ZMQ_HAVE_OPENVMS #include <ioctl.h> #endif zmq::tcp_listener_t::tcp_listener_t (
_socket->event_accept_failed ( make_unconnected_bind_endpoint_pair (_endpoint), zmq_errno ()); return; } create_engine (fd); } std::string zmq::tcp_listener_t::get_socket_name (zmq::fd_t fd_, socket_end_t socket_end_) const { return zmq::get_socket_name<tcp_address_t> (fd_, socket_end_); } int zmq::tcp_listener_t::create_socket (const char *addr_) { _s = tcp_open_socket (addr_, options, true, true, &_address); if (_s == retired_fd) { return -1; } make_socket_noninheritable (_s); int flag = 1; int rc; #ifdef ZMQ_HAVE_WINDOWS rc = setsockopt (_s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, reinterpret_cast<const char *> (&flag), sizeof (int)); wsa_assert (rc != SOCKET_ERROR); #elif defined ZMQ_HAVE_VXWORKS rc = setsockopt (_s, SOL_SOCKET, SO_REUSEADDR, (char *) &flag, sizeof (int)); errno_assert (rc == 0); #else rc = setsockopt (_s, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof (int)); errno_assert (rc == 0); #endif #if defined ZMQ_HAVE_VXWORKS rc = bind (_s, (sockaddr *) _address.addr (), _address.addrlen ()); #else rc = bind (_s, _address.addr (), _address.addrlen ()); #endif #ifdef ZMQ_HAVE_WINDOWS if (rc == SOCKET_ERROR) { errno = wsa_error_to_errno (WSAGetLastError ()); goto error; } #else if (rc != 0) goto error; #endif rc = listen (_s, options.backlog); #ifdef ZMQ_HAVE_WINDOWS if (rc == SOCKET_ERROR) { errno = wsa_error_to_errno (WSAGetLastError ()); goto error; } #else if (rc != 0) goto error; #endif return 0; error: int err = errno; close (); errno = err; return -1; } int zmq::tcp_listener_t::set_local_address (const char *addr_) { if (options.use_fd != -1) { _s = options.use_fd; } else { if (create_socket (addr_) == -1) return -1; } _endpoint = get_socket_name (_s, socket_end_local); _socket->event_listening (make_unconnected_bind_endpoint_pair (_endpoint), _s); return 0; } zmq::fd_t zmq::tcp_listener_t::accept () { zmq_assert (_s != retired_fd); struct sockaddr_storage ss; memset (&ss, 0, sizeof (ss)); #if defined ZMQ_HAVE_HPUX || defined ZMQ_HAVE_VXWORKS int ss_len = sizeof (ss); #else socklen_t ss_len = sizeof (ss); #endif #if defined ZMQ_HAVE_SOCK_CLOEXEC && defined HAVE_ACCEPT4 fd_t sock = ::accept4 (_s, reinterpret_cast<struct sockaddr *> (&ss), &ss_len, SOCK_CLOEXEC); #else fd_t sock = ::accept (_s, reinterpret_cast<struct sockaddr *> (&ss), &ss_len); #endif if (sock == retired_fd) { #if defined ZMQ_HAVE_WINDOWS const int last_error = WSAGetLastError (); wsa_assert (last_error == WSAEWOULDBLOCK || last_error == WSAECONNRESET || last_error == WSAEMFILE || last_error == WSAENOBUFS); #elif defined ZMQ_HAVE_ANDROID errno_assert (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR || errno == ECONNABORTED || errno == EPROTO || errno == ENOBUFS || errno == ENOMEM || errno == EMFILE || errno == ENFILE || errno == EINVAL); #else errno_assert (errno == EAGAIN || errno == EWOULDBLOCK || errno == EINTR || errno == ECONNABORTED || errno == EPROTO || errno == ENOBUFS || errno == ENOMEM || errno == EMFILE || errno == ENFILE); #endif return retired_fd; } make_socket_noninheritable (sock); if (!options.tcp_accept_filters.empty ()) { bool matched = false; for (options_t::tcp_accept_filters_t::size_type i = 0; i != options.tcp_accept_filters.size (); ++i) { if (options.tcp_accept_filters[i].match_address ( reinterpret_cast<struct sockaddr *> (&ss), ss_len)) { matched = true; break; } } if (!matched) { #ifdef ZMQ_HAVE_WINDOWS int rc = closesocket (sock); wsa_assert (rc != SOCKET_ERROR); #else int rc = ::close (sock); errno_assert (rc == 0); #endif return retired_fd; } } if (zmq::set_nosigpipe (sock)) { #ifdef ZMQ_HAVE_WINDOWS int rc = closesocket (sock); wsa_assert (rc != SOCKET_ERROR); #else int rc = ::close (sock); errno_assert (rc == 0); #endif return retired_fd; } if (options.tos != 0) set_ip_type_of_service (sock, options.tos); return sock; }
io_thread_t *io_thread_, socket_base_t *socket_, const options_t &options_) : stream_listener_base_t (io_thread_, socket_, options_) { } void zmq::tcp_listener_t::in_event () { fd_t fd = accept (); if (fd == retired_fd) { _socket->event_accept_failed ( make_unconnected_bind_endpoint_pair (_endpoint), zmq_errno ()); return; } int rc = tune_tcp_socket (fd); rc = rc | tune_tcp_keepalives ( fd, options.tcp_keepalive, options.tcp_keepalive_cnt, options.tcp_keepalive_idle, options.tcp_keepalive_intvl); rc = rc | tune_tcp_maxrt (fd, options.tcp_maxrt); if (rc != 0) {
random
[ { "content": " FT_Byte* string; /* this string is *not* null-terminated! */\n", "file_path": "Source/ThirdParty/FreeType/include/freetype/ftsnames.h", "rank": 0, "score": 203889.44645226406 }, { "content": " FT_Byte* string;\n", "file_path": "Source/ThirdParty/FreeType/inclu...
C++
framework/frontend/fsa/fsa_transition.hpp
aamshukov/frontend
6be5fea43b7776691034f3b4f56d318d7cdf18f8
 #ifndef __FSA_TRANSITION_H__ #define __FSA_TRANSITION_H__ #pragma once BEGIN_NAMESPACE(frontend) USINGNAMESPACE(core) #define MAX_TRANSITION_RANK (5) class fsa_transition { public: using datum_type = text::datum_type; using predicate_type = string_type; using predicates_type = std::set<predicate_type>; private: uint32_t my_id; uint32_t my_start_state; uint32_t my_end_state; predicate_type my_predicate; datum_type my_switch_predicate; int16_t my_rank; public: fsa_transition(); fsa_transition(uint32_t start_state, uint32_t end_state, const predicate_type& predicate); fsa_transition(uint32_t start_state, uint32_t end_state, datum_type switch_predicate); fsa_transition(const fsa_transition& other); fsa_transition(fsa_transition&& other); const fsa_transition& operator = (const fsa_transition& other); fsa_transition& operator = (fsa_transition&& other); uint32_t id() const; uint32_t& id(); uint32_t start_state() const; uint32_t& start_state(); uint32_t end_state() const; uint32_t& end_state(); const predicate_type& predicate() const; predicate_type& predicate(); datum_type switch_char() const; datum_type& switch_char(); int16_t rank() const; int16_t& rank(); bool is_epsilon_transition() const; static const predicate_type& empty_predicate(); static const predicate_type& epsilon_predicate(); }; inline uint32_t fsa_transition::id() const { return my_id; } inline uint32_t& fsa_transition::id() { return my_id; } inline uint32_t fsa_transition::start_state() const { return my_start_state; } inline uint32_t& fsa_transition::start_state() { return my_start_state; } inline uint32_t fsa_transition::end_state() const { return my_end_state; } inline uint32_t& fsa_transition::end_state() { return my_end_state; } inline const typename fsa_transition::predicate_type& fsa_transition::predicate() const { return my_predicate; } inline typename fsa_transition::predicate_type& fsa_transition::predicate() { return const_cast<typename fsa_transition::predicate_type&>(static_cast<const fsa_transition&>(*this).predicate()); } inline typename fsa_transition::datum_type fsa_transition::switch_char() const { return my_switch_predicate; } inline typename fsa_transition::datum_type& fsa_transition::switch_char() { return my_switch_predicate; } inline int16_t fsa_transition::rank() const { return my_rank; } inline int16_t& fsa_transition::rank() { return my_rank; } inline bool fsa_transition::is_epsilon_transition() const { return my_predicate.compare(epsilon_predicate()) == 0 || my_switch_predicate == text::epsilon_codepoint(); } inline typename fsa_transition::predicate_type const& fsa_transition::empty_predicate() { static typename fsa_transition::predicate_type result; return result; } inline string_type const& fsa_transition::epsilon_predicate() { static string_type result(L"ε"); return result; } END_NAMESPACE #endif
 #ifndef __FSA_TRANSITION_H__ #define __FSA_TRANSITION_H__ #pragma once BEGIN_NAMESPACE(frontend) USINGNAMESPACE(core) #define MAX_TRANSITION_RANK (5) class fsa_transition { public: using datum_type = text::datum_type; using predicate_type = string_type; using predicates_type = std::set<predicate_type>; private: uint32_t my_id; uint32_t my_start_state; uint32_t my_end_state; predicate_type
public: fsa_transition(); fsa_transition(uint32_t start_state, uint32_t end_state, const predicate_type& predicate); fsa_transition(uint32_t start_state, uint32_t end_state, datum_type switch_predicate); fsa_transition(const fsa_transition& other); fsa_transition(fsa_transition&& other); const fsa_transition& operator = (const fsa_transition& other); fsa_transition& operator = (fsa_transition&& other); uint32_t id() const; uint32_t& id(); uint32_t start_state() const; uint32_t& start_state(); uint32_t end_state() const; uint32_t& end_state(); const predicate_type& predicate() const; predicate_type& predicate(); datum_type switch_char() const; datum_type& switch_char(); int16_t rank() const; int16_t& rank(); bool is_epsilon_transition() const; static const predicate_type& empty_predicate(); static const predicate_type& epsilon_predicate(); }; inline uint32_t fsa_transition::id() const { return my_id; } inline uint32_t& fsa_transition::id() { return my_id; } inline uint32_t fsa_transition::start_state() const { return my_start_state; } inline uint32_t& fsa_transition::start_state() { return my_start_state; } inline uint32_t fsa_transition::end_state() const { return my_end_state; } inline uint32_t& fsa_transition::end_state() { return my_end_state; } inline const typename fsa_transition::predicate_type& fsa_transition::predicate() const { return my_predicate; } inline typename fsa_transition::predicate_type& fsa_transition::predicate() { return const_cast<typename fsa_transition::predicate_type&>(static_cast<const fsa_transition&>(*this).predicate()); } inline typename fsa_transition::datum_type fsa_transition::switch_char() const { return my_switch_predicate; } inline typename fsa_transition::datum_type& fsa_transition::switch_char() { return my_switch_predicate; } inline int16_t fsa_transition::rank() const { return my_rank; } inline int16_t& fsa_transition::rank() { return my_rank; } inline bool fsa_transition::is_epsilon_transition() const { return my_predicate.compare(epsilon_predicate()) == 0 || my_switch_predicate == text::epsilon_codepoint(); } inline typename fsa_transition::predicate_type const& fsa_transition::empty_predicate() { static typename fsa_transition::predicate_type result; return result; } inline string_type const& fsa_transition::epsilon_predicate() { static string_type result(L"ε"); return result; } END_NAMESPACE #endif
my_predicate; datum_type my_switch_predicate; int16_t my_rank;
random
[ { "content": "class string_data_provider : public data_provider, private noncopyable\n\n{\n\n public:\n\n using datum_type = data_provider::datum_type;\n\n\n\n private:\n\n string_type my_data_content;\n\n\n\n public:\n\n string_data_provider(const strin...
C++
spline_planner/src/eigen_spline.cpp
Veilkrand/drone_race
7391f1a94bfe354aab3e24be61b76e1595481ad9
#include <boost/python.hpp> #include <boost/assert.hpp> #include <vector> #include <Eigen/Dense> #include "eigen_spline.hpp" using namespace spline_planner; namespace py = boost::python; py::list ColumnMajorMatrixToRowMajorPython2DList(const Eigen::MatrixXd& mat) { py::list result; const size_t cols = mat.cols(); const size_t rows = mat.rows(); for (size_t i = 0; i < cols; ++i) { py::list vec; for (size_t j = 0; j < rows; ++j) { vec.append(mat(j, i)); } result.append(vec); } return result; } Eigen::MatrixXd RowMajorPython2DListToColumnMajorMatrix(py::list list) { const size_t rows = py::len(list); const size_t cols = py::len(list[0]); Eigen::MatrixXd mat(rows, cols); for (size_t r = 0; r < rows; ++r) { py::list row = static_cast<py::list>(list[r]); for (size_t c = 0; c < cols; ++c) { mat(c, r) = py::extract<double>(row[c]); } } return mat; } struct SplineSamplingCallback { void operator()(double t, double s, const Eigen::MatrixXd& derivatives) { py::list point; point.append(t); point.append(s); point.append(ColumnMajorMatrixToRowMajorPython2DList(derivatives)); result.append(point); } py::list result; }; typedef spline_planner::Spline3D<3> CubicSpline3D; struct CubicSpline3DWrapper { CubicSpline3DWrapper(py::list points) : spline_(nullptr) { const int num_pts = py::len(points); Eigen::MatrixXd mat(3, num_pts); for (size_t i = 0; i < num_pts; ++i) { mat(0, i) = py::extract<double>(points[i][0]); mat(1, i) = py::extract<double>(points[i][1]); mat(2, i) = py::extract<double>(points[i][2]); } spline_ = new CubicSpline3D(mat); } CubicSpline3DWrapper(py::list points, py::list derivatives, py::list index) : spline_(nullptr) { const int num_pts = py::len(points); Eigen::MatrixXd mat(3, num_pts); for (size_t i = 0; i < num_pts; ++i) { mat(0, i) = py::extract<double>(points[i][0]); mat(1, i) = py::extract<double>(points[i][1]); mat(2, i) = py::extract<double>(points[i][2]); } const int num_derivs = py::len(derivatives); Eigen::MatrixXd mat_derivs(3, num_derivs); for (size_t i = 0; i < num_derivs; ++i) { mat_derivs(0, i) = py::extract<double>(derivatives[i][0]); mat_derivs(1, i) = py::extract<double>(derivatives[i][1]); mat_derivs(2, i) = py::extract<double>(derivatives[i][2]); } Eigen::VectorXi vec_index(num_derivs); for (size_t i = 0; i < num_derivs; ++i) { vec_index(i) = py::extract<int>(index[i]); } spline_ = new CubicSpline3D(mat, mat_derivs, vec_index); } py::list SampleAndCollect0() { return SampleAndCollect(); } py::list SampleAndCollect1(double sample_ds) { return SampleAndCollect(sample_ds); } py::list SampleAndCollect2(double sample_ds, double s_limit) { return SampleAndCollect(sample_ds, s_limit); } py::list SampleAndCollect(double sample_ds = 0.1, double s_limit=100.0, double dt = 0.01) { SplineSamplingCallback callback; spline_->Sample(callback, sample_ds, s_limit, 2, dt); return callback.result; } ~CubicSpline3DWrapper() { if (spline_) { delete spline_; } } CubicSpline3D* spline_; }; BOOST_PYTHON_MODULE(eigen_spline) { py::class_<CubicSpline3DWrapper>("CubicSpline3DWrapper", py::init<py::list>()) .def(py::init<py::list, py::list, py::list>()) .def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect0) .def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect1) .def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect2) .def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect); }
#include <boost/python.hpp> #include <boost/assert.hpp> #include <vector> #include <Eigen/Dense> #include "eigen_spline.hpp" using namespace spline_planner; namespace py = boost::python; py::list ColumnMajorMatrixToRowMajorPython2DList(const Eigen::MatrixXd& mat) { py::list result; const size_t cols = mat.cols(); const size_t rows = mat.rows(); for (size_t i = 0; i < cols; ++i) { py::list vec; for (size_t j = 0; j < rows; ++j) { vec.append(mat(j, i)); } result.append(vec); } return result; } Eigen::MatrixXd RowMajorPython2DListToColumnMajorMatrix(py::list list) { const size_t rows = py::len(list); const size_t cols = py::len(list[0]); Eigen::MatrixXd mat(rows, cols); for (size_t r = 0; r < rows; ++r) { py::list row = static_cast<py::list>(list[r]); for (size_t c = 0; c < cols; ++c) { mat(c, r) = py::extract<double>(row[c]); } } return mat; } struct SplineSamplingCallback { void operator()(double t, double s, const Eigen::MatrixXd& derivatives) { py::list point; point.append(t); point.append(s); point.append(ColumnMajorMatrixToRowMajorPython2DList(derivatives)); result.append(point); } py::list result; }; typedef spline_planner::Spline3D<3> CubicSpline3D; struct CubicSpline3DWrapper { CubicSpline3DWrapper(py::list points) : spline_(nullptr) { const int num_pts = py::len(points); Eigen::MatrixXd mat(3, num_pts); for (size_t i = 0; i < num_pts; ++i) { mat(0, i) = py::extract<double>(points[i][0]); mat(1, i) = py::extract<double>(points[i][1]); mat(2, i) = py::extract<double>(points[i][2]); } spline_ = new CubicSpline3D(mat); } CubicSpline3DWrapper(py::list points, py::list derivatives, py::list index) : spline_(nullptr) { const int num_pts = py::len(points); Eigen::MatrixXd mat(3, num_pts); for (size_t i = 0; i < num_pts; ++i) { mat(0, i) = py::extract<double>(points[i][0]); mat(1, i) = py::extract<double>(points[i][1]); mat(2, i) = py::extract<double>(points[i][2]); } const int num_derivs = py::len(derivatives); Eigen::MatrixXd mat_derivs(3, num_derivs); for (size_t i = 0; i < num_derivs; ++i) { mat_derivs(0, i) = py::extract<double>(derivatives[i][0]); mat_derivs(1, i) = py::extract<double>(derivatives[i][1]); mat_derivs(2, i) = py::extract<double>(derivatives[i][2]); } Eigen::VectorXi vec_index(num_derivs); for (size_t i = 0; i < num_derivs; ++i) { vec_index(i) = py::extract<int>(index[i]); } spline_ = new CubicSpline3D(mat, mat_derivs, vec_index); } py::list SampleAndCollect0() { return SampleAndCollect(); } py::list SampleAndCollect1(double sample_ds) { return SampleAndCollect(sample_ds); } py::list SampleAndCollect2(double sample_ds, double s_limit) { return SampleAndCollect(sample_ds, s_limit); } py::list SampleAndCollect(double sample_ds = 0.1, double s_limit=100.0, double dt = 0.01) { SplineSamplingCallback callback; spline_->Sample(callback, sample_ds, s_limit, 2, dt); return callback.result; } ~CubicSpline3DWrapper() { if (spline_) { delete spline_; } } CubicSpline3D* spline_; }; BOOST_PYTHON_MODULE(eigen_spline) {
.def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect1) .def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect2) .def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect); }
py::class_<CubicSpline3DWrapper>("CubicSpline3DWrapper", py::init<py::list>()) .def(py::init<py::list, py::list, py::list>()) .def("sampleAndCollect", &CubicSpline3DWrapper::SampleAndCollect0)
call_expression
[ { "content": "def vector_to_list(vec):\n", "file_path": "spline_planner/scripts/ros_geometry.py", "rank": 1, "score": 85291.53639601504 }, { "content": "def vec_to_quat(vec):\n\n \"\"\"To fully determine the orientation represented by the resulting quaternion, this method will assume the ...
C++
ThirdParty-mod/java2cpp/java/io/LineNumberInputStream.hpp
kakashidinho/HQEngine
8125b290afa7c62db6cc6eac14e964d8138c7fd0
#ifndef J2CPP_INCLUDE_IMPLEMENTATION #ifndef J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_DECL #define J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_DECL namespace j2cpp { namespace java { namespace io { class FilterInputStream; } } } namespace j2cpp { namespace java { namespace io { class InputStream; } } } #include <java/io/FilterInputStream.hpp> #include <java/io/InputStream.hpp> namespace j2cpp { namespace java { namespace io { class LineNumberInputStream; class LineNumberInputStream : public object<LineNumberInputStream> { public: J2CPP_DECLARE_CLASS J2CPP_DECLARE_METHOD(0) J2CPP_DECLARE_METHOD(1) J2CPP_DECLARE_METHOD(2) J2CPP_DECLARE_METHOD(3) J2CPP_DECLARE_METHOD(4) J2CPP_DECLARE_METHOD(5) J2CPP_DECLARE_METHOD(6) J2CPP_DECLARE_METHOD(7) J2CPP_DECLARE_METHOD(8) explicit LineNumberInputStream(jobject jobj) : object<LineNumberInputStream>(jobj) { } operator local_ref<java::io::FilterInputStream>() const; LineNumberInputStream(local_ref< java::io::InputStream > const&); jint available(); jint getLineNumber(); void mark(jint); jint read(); jint read(local_ref< array<jbyte,1> > const&, jint, jint); void reset(); void setLineNumber(jint); jlong skip(jlong); }; } } } #endif #else #ifndef J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_IMPL #define J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_IMPL namespace j2cpp { java::io::LineNumberInputStream::operator local_ref<java::io::FilterInputStream>() const { return local_ref<java::io::FilterInputStream>(get_jobject()); } java::io::LineNumberInputStream::LineNumberInputStream(local_ref< java::io::InputStream > const &a0) : object<java::io::LineNumberInputStream>( call_new_object< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(0), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(0) >(a0) ) { } jint java::io::LineNumberInputStream::available() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(1), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(1), jint >(get_jobject()); } jint java::io::LineNumberInputStream::getLineNumber() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(2), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(2), jint >(get_jobject()); } void java::io::LineNumberInputStream::mark(jint a0) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(3), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(3), void >(get_jobject(), a0); } jint java::io::LineNumberInputStream::read() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(4), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(4), jint >(get_jobject()); } jint java::io::LineNumberInputStream::read(local_ref< array<jbyte,1> > const &a0, jint a1, jint a2) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(5), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(5), jint >(get_jobject(), a0, a1, a2); } void java::io::LineNumberInputStream::reset() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(6), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(6), void >(get_jobject()); } void java::io::LineNumberInputStream::setLineNumber(jint a0) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(7), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(7), void >(get_jobject(), a0); } jlong java::io::LineNumberInputStream::skip(jlong a0) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(8), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(8), jlong >(get_jobject(), a0); } J2CPP_DEFINE_CLASS(java::io::LineNumberInputStream,"java/io/LineNumberInputStream") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,0,"<init>","(Ljava/io/InputStream;)V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,1,"available","()I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,2,"getLineNumber","()I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,3,"mark","(I)V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,4,"read","()I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,5,"read","([BII)I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,6,"reset","()V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,7,"setLineNumber","(I)V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,8,"skip","(J)J") } #endif #endif
#ifndef J2CPP_INCLUDE_IMPLEMENTATION #ifndef J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_DECL #define J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_DECL namespace j2cpp { namespace java { namespace io { class FilterInputStream; } } } namespace j2cpp { namespace java { namespace io { class InputStream; } } } #include <java/io/FilterInputStream.hpp> #include <java/io/InputStream.hpp> namespace j2cpp { namespace java { namespace io { class LineNumberInputStream; class LineNumberInputStream : public object<LineNumberInputStream> { public: J2CPP_DECLARE_CLASS J2CPP_DECLARE_METHOD(0) J2CPP_DECLARE_METHOD(1) J2CPP_DECLARE_METHOD(2) J2CPP_DECLARE_METHOD(3) J2CPP_DECLARE_METHOD(4) J2CPP_DECLARE_METHOD(5) J2CPP_DECLARE_METHOD(6) J2CPP_DECLARE_METHOD(7) J2CPP_DECLARE_METHOD(8) explicit LineNumberInputStream(jobject jobj) : object<LineNumberInputStream>(jobj) { } operator local_ref<java::io::FilterInputStream>() const; LineNumberInputStream(local_ref< java::io::InputStream > const&); jint available(); jint getLineNumber(); void mark(jint); jint read(); jint read(local_ref< array<jbyte,1> > const&, jint, jint); void reset(); void setLineNumber(jint); jlong skip(jlong); }; } } } #endif #else #ifndef J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_IMPL #define J2CPP_JAVA_IO_LINENUMBERINPUTSTREAM_HPP_IMPL namespace j2cpp { java::io::LineNumberInputStream::operator local_ref<java::io::FilterInputStream>() const { return local_ref<java::io::FilterInputStream>(get_jobject()); } java::io::LineNumberInputStream::LineNumberInputStream(local_ref< java::io::InputStream > const &a0) : object<java::io::LineNumberInputStream>( call_new_object< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(0), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(0) >(a0) ) { } jint java::io::LineNumberInputStream::available() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(1), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(1), jint >(get_jobject()); } jint java::io::LineNumberInputStream::getLineNumber() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(2), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(2), jint >(get_jobject()); } void java::io::LineNumberInputStrea
jint java::io::LineNumberInputStream::read() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(4), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(4), jint >(get_jobject()); } jint java::io::LineNumberInputStream::read(local_ref< array<jbyte,1> > const &a0, jint a1, jint a2) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(5), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(5), jint >(get_jobject(), a0, a1, a2); } void java::io::LineNumberInputStream::reset() { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(6), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(6), void >(get_jobject()); } void java::io::LineNumberInputStream::setLineNumber(jint a0) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(7), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(7), void >(get_jobject(), a0); } jlong java::io::LineNumberInputStream::skip(jlong a0) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(8), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(8), jlong >(get_jobject(), a0); } J2CPP_DEFINE_CLASS(java::io::LineNumberInputStream,"java/io/LineNumberInputStream") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,0,"<init>","(Ljava/io/InputStream;)V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,1,"available","()I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,2,"getLineNumber","()I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,3,"mark","(I)V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,4,"read","()I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,5,"read","([BII)I") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,6,"reset","()V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,7,"setLineNumber","(I)V") J2CPP_DEFINE_METHOD(java::io::LineNumberInputStream,8,"skip","(J)J") } #endif #endif
m::mark(jint a0) { return call_method< java::io::LineNumberInputStream::J2CPP_CLASS_NAME, java::io::LineNumberInputStream::J2CPP_METHOD_NAME(3), java::io::LineNumberInputStream::J2CPP_METHOD_SIGNATURE(3), void >(get_jobject(), a0); }
function_block-function_prefixed
[ { "content": "\tclass Void;\n", "file_path": "ThirdParty-mod/java2cpp/java/lang/Void.hpp", "rank": 0, "score": 307452.9692886499 }, { "content": "\tclass Void\n\n\t\t: public object<Void>\n\n\t{\n\n\tpublic:\n\n\n\n\t\tJ2CPP_DECLARE_CLASS\n\n\n\n\t\tJ2CPP_DECLARE_METHOD(0)\n\n\t\tJ2CPP_DECLA...
C++
Funambol/source/common/http/DigestAuthentication.cpp
wbitos/funambol
29f76caf9cee51d51ddf5318613411cb1cfb8e4e
#include <Funambol/base/Log.h> #include <Funambol/base/messages.h> #include <Funambol/base/util/utils.h> #include <Funambol/http/constants.h> #include <Funambol/http/errors.h> #include <Funambol/http/DigestAuthentication.h> #include <Funambol/event/FireEvent.h> USE_NAMESPACE DigestAuthentication::DigestAuthentication(const StringBuffer& user, const StringBuffer& pass) : HttpAuthentication(Digest, user, pass) { } StringBuffer DigestAuthentication::getAuthenticationHeaders(const char* authstr, URL url, const HashProvider *hashProvider) { processAuthInfo(authstr); return generateAuthResponseString(url, hashProvider); } StringBuffer DigestAuthentication::extractDigestProp(const char* authstr, const char* prop) { StringBuffer result = ""; const char* start; const char* end; const char* ptr; char * temp = new char[100]; sprintf(temp, "%s=\"", prop); start = strstr(authstr, temp); if (start == NULL) { return ""; } start = start + strlen(temp); end = start; delete [] temp; while ((ptr = strstr(end, "\"")) != NULL) { if (*(ptr-1) != '\\') { end = ptr; break; } } if (ptr == NULL) { end = start + strlen(start); } int len = (int)(end - start); result = ""; result.append(start); return result.substr(0, len); } void DigestAuthentication::processAuthInfo(const char* authstr) { if (strstr(authstr, "Digest") != authstr) { return; } this->realm = extractDigestProp(authstr, "realm"); this->qop = extractDigestProp(authstr, "qop"); this->nonce = extractDigestProp(authstr, "nonce"); this->opaque = extractDigestProp(authstr, "opaque"); } StringBuffer DigestAuthentication::generateAuthResponseString(URL url, const HashProvider *hashProvider) { if (!hashProvider) { return NULL; } StringBuffer nc = "00000001"; StringBuffer cnonce; StringBuffer ha1; StringBuffer ha2; StringBuffer finalhash; StringBuffer key = ""; key.sprintf("%d:%d", rand(), rand()); cnonce = hashProvider->getHash(key.c_str()); StringBuffer temp = ""; temp.append(this->username.c_str()).append(":") .append(this->realm).append(":") .append(this->password.c_str()); ha1 = hashProvider->getHash(temp.c_str()); temp = "POST:"; temp.append(url.resource); ha2 = hashProvider->getHash(temp.c_str()); StringBuffer tohash = ""; tohash.append(ha1).append(":") .append(this->nonce).append(":") .append(nc).append(":") .append(cnonce).append(":") .append(this->qop).append(":") .append(ha2); finalhash = hashProvider->getHash(tohash); StringBuffer response = ""; response.sprintf("Digest username=\"%s\", realm=\"%s\", " "nonce=\"%s\", uri=\"%s\", qop=\"%s\", nc=\"%s\", " "cnonce=\"%s\", response=\"%s\", opaque=\"%s\"", this->username.c_str(), this->realm.c_str(), this->nonce.c_str(), url.resource, this->qop.c_str(), nc.c_str(), cnonce.c_str(), finalhash.c_str(), this->opaque.c_str()); return response; }
#include <Funambol/base/Log.h> #include <Funambol/base/messages.h> #include <Funambol/base/util/utils.h> #include <Funambol/http/constants.h> #include <Funambol/http/errors.h> #include <Funambol/http/DigestAuthentication.h> #include <Funambol/event/FireEvent.h> USE_NAMESPACE DigestAuthentication::DigestAuthentication(const StringBuffer& user, const StringBuffer& pass) : HttpAuthentication(Digest, user, pass) { } StringBuffer DigestAuthentication::getAuthenticationHeaders(const char* authstr, URL url, const HashProvider *hashProvider) { processAuthInfo(authstr); return generateAuthResponseString(url, hashProvider); }
void DigestAuthentication::processAuthInfo(const char* authstr) { if (strstr(authstr, "Digest") != authstr) { return; } this->realm = extractDigestProp(authstr, "realm"); this->qop = extractDigestProp(authstr, "qop"); this->nonce = extractDigestProp(authstr, "nonce"); this->opaque = extractDigestProp(authstr, "opaque"); } StringBuffer DigestAuthentication::generateAuthResponseString(URL url, const HashProvider *hashProvider) { if (!hashProvider) { return NULL; } StringBuffer nc = "00000001"; StringBuffer cnonce; StringBuffer ha1; StringBuffer ha2; StringBuffer finalhash; StringBuffer key = ""; key.sprintf("%d:%d", rand(), rand()); cnonce = hashProvider->getHash(key.c_str()); StringBuffer temp = ""; temp.append(this->username.c_str()).append(":") .append(this->realm).append(":") .append(this->password.c_str()); ha1 = hashProvider->getHash(temp.c_str()); temp = "POST:"; temp.append(url.resource); ha2 = hashProvider->getHash(temp.c_str()); StringBuffer tohash = ""; tohash.append(ha1).append(":") .append(this->nonce).append(":") .append(nc).append(":") .append(cnonce).append(":") .append(this->qop).append(":") .append(ha2); finalhash = hashProvider->getHash(tohash); StringBuffer response = ""; response.sprintf("Digest username=\"%s\", realm=\"%s\", " "nonce=\"%s\", uri=\"%s\", qop=\"%s\", nc=\"%s\", " "cnonce=\"%s\", response=\"%s\", opaque=\"%s\"", this->username.c_str(), this->realm.c_str(), this->nonce.c_str(), url.resource, this->qop.c_str(), nc.c_str(), cnonce.c_str(), finalhash.c_str(), this->opaque.c_str()); return response; }
StringBuffer DigestAuthentication::extractDigestProp(const char* authstr, const char* prop) { StringBuffer result = ""; const char* start; const char* end; const char* ptr; char * temp = new char[100]; sprintf(temp, "%s=\"", prop); start = strstr(authstr, temp); if (start == NULL) { return ""; } start = start + strlen(temp); end = start; delete [] temp; while ((ptr = strstr(end, "\"")) != NULL) { if (*(ptr-1) != '\\') { end = ptr; break; } } if (ptr == NULL) { end = start + strlen(start); } int len = (int)(end - start); result = ""; result.append(start); return result.substr(0, len); }
function_block-full_function
[ { "content": " class URL {\n\n\n\n public:\n\n char* fullURL ;\n\n char* protocol;\n\n char* host ;\n\n char* resource;\n\n int port ;\n\n\n\n URL();\n\n URL(const URL &url);\n\n URL(const char* url);\n\n ~URL();\n\n\n\n vo...
C++
bus/map_test.cpp
UndefeatedSunny/sc-platform
5897c460bf7a4b9694324f09d2492f5e157a3955
#include "bus/memory_map.hpp" #include "report/report.hpp" #include "report/summary.hpp" #include "common/common.hpp" #include <string> #include <list> #include <vector> #include <map> using namespace std; using namespace sc_core; namespace { const char * const MSGID{ "/Doulos/Example/map_test" }; } Port_t decode_address ( Addr_t address, Addr_t& masked_address ); uint64_t reconstruct_address ( Addr_t address, Port_t port, bool bias_upwards ); void build_port_map ( void ); void dump_port_map ( int level ); void check_port_map_and_update_configuration( void ); string name( string name = "" ) { static string m_name{ "top.cpu" }; if( name.length() > 0 ) m_name = name; return m_name; } string kind( string kind = "" ) { static string m_kind{ "Cpu_name" }; if( kind.length() > 0 ) m_kind = kind; return m_kind; } struct Command { string m_initiator; string m_bus; string m_target; string m_yaml; Addr_t m_addr; bool m_processing{ true }; list<string> m_cmds; Address_map m_addr_map; bool processing( void ) const { return not m_processing; } void process( void ); void add( initializer_list<string> cmds ) { m_cmds.splice( m_cmds.end(), cmds ); } size_t size( void ) const { return m_cmds.size(); } } command; void Command::process( void ) { while( not m_cmds.empty() ) { string cmd = m_cmds.front(); string arg; if( cmd == "yaml" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); } else if( cmd == "init" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "targ" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "bus" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "findaddr" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "decode" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "quit" ) { m_cmds.pop_front(); m_processing = false; break; } else if( m_cmds.size() == 1 ) { break; } } } int sc_main( int argc, char* argv[]) { Addr_t address = 0x1000ull; if( sc_argc() < 2 ) { command.add( { "yaml", "memory_map.yaml" , "init", "top.cpu" , "targ", "top.ram" , "bus", "top.bus" , "findaddr", "top.ram" , "decode", "0x1000" , "quit" }); } for( int i=1; i<sc_argc(); ++i ) { string arg( sc_argv()[i] ); if( arg == "-yaml" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"yaml", arg}); } else if( arg == "-init" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"init", arg}); } else if( arg == "-bus" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"bus", arg}); } else if( arg == "-targ" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"targ", arg}); } else if( arg == "-kind" and (i+1) < sc_argc() ) { arg = kind(sc_argv()[++i]); } } if( command.size() ) { command.process(); } while( command.processing() ) { char line[256]; std::cin.getline(line,256); istringstream is(line); string word; while( not is.eof() ) { is >> word; command.add({word}); } command.process(); } return Summary::report(); } Addr_t find_address ( string path ) { INFO( DEBUG, "Searching for address from " << name() << " to " << path ); list<string> device_path = { name(), path }; auto target_info = Memory_map::get_target_path_info( device_path ); sc_assert( target_info.base != BAD_ADDR ); MESSAGE( "Found address " << STREAM_HEX << target_info.base ); MESSAGE( " from " << name() << " to " << path ); MEND( DEBUG ); return target_info.base; } Port_t decode_address ( Addr_t address, Addr_t& masked_address ) { if( address == BAD_ADDR ) { REPORT( ERROR, "Unable to decode BAD_ADDR" ); return BAD_PORT; } INFO( DEBUG, "Decoding address " << STREAM_HEX << address ); Addr_t base = BAD_ADDR; masked_address = BAD_ADDR; auto lookup = m_addr_map.lower_bound( address ); if( lookup == m_addr_map.end() ) { REPORT( WARNING, "No address => port match found!" ); return BAD_PORT; } base = lookup->first; if( base == MAX_ADDR || base == BAD_ADDR ) { REPORT( WARNING, "No address => port match found! Unintialized entry." ); return BAD_PORT; } if( address > lookup->second.last ) { REPORT( WARNING, "No address => port match found. Goes beyond closest port's maximum." ); return BAD_PORT; } masked_address = address - base; return lookup->second.port; } Addr_t reconstruct_address( Addr_t address, Port_t port, bool bias_upwards ) { Addr_t base{ BAD_ADDR }; Addr_t last; Addr_t min_address{ MAX_ADDR}; Addr_t max_address{ 0 }; Addr_t reconstructed{ BAD_ADDR }; for( const auto& mapping : m_addr_map ) { if( mapping.second.port != port ) continue; base = mapping.second.base; last = mapping.second.last; if( base < min_address ) min_address = base; if( last > max_address ) max_address = last; if( base <= address and address <= last ) { reconstructed = base + address; break; } } if( reconstructed == BAD_ADDR ) { if( address < max_address ) address = max_address; if( bias_upwards ) { } else { } } return reconstructed; } void build_port_map( void ) { string config_name; string config_kind; Depth_t config_size; INFO( DEBUG, "Mapping port " << port << " " << config_name ); size_t matches{ 0 }; for( auto& mapping : m_addr_map ) { Addr_t addr{ mapping.first }; Target_info& mapped{ mapping.second }; INFO( DEBUG, "Target mapped: " << mapped ); if( mapped.name == config_name ) { ++matches; INFO( DEBUG, "Found port match at " << STREAM_HEX << addr ); mapped.port = port; mapped.kind = config_kind; if( config_size == UNASSIGNED ) { config_size = mapped.size; } else { mapped.size = config_size; } if( config_size == 0 ) { REPORT( ERROR, "Configured size of " << config_name << " is zero!" ); } mapped.last = mapped.base + config_size - 1; } } if( matches == 0 ) { REPORT( ERROR, "No matches on port " << config_name << " => connectivity mismatch!" ); } } void dump_port_map( int level ) { MESSAGE( "Port map for " << name() << ":\n" ); for( auto rit = m_addr_map.rbegin(); rit!=m_addr_map.rend(); ++rit ) { const Addr_t& addr{ rit->first }; const Target_info& info{ rit->second }; MESSAGE( STREAM_HEX << " - {" << " base: " << setw(10) << info.base << " last: " << setw(10) << info.last << " size: " << setw(6) << info.size << " port: " << setw(2) << STREAM_DEC << info.port << " name: " << info.name << " kind: " << info.kind << " }\n"; ); } MEND( NONE + level ); } void check_port_map_and_update_configuration( void ) { dump_port_map( SC_DEBUG ); INFO( MEDIUM, "Checking port map for " << name() ); Addr_t min_address{ MAX_ADDR }; Addr_t max_address{ 0 }; size_t mapping_errors { 0 }; for( const auto& mapping : m_addr_map ) { const Addr_t addr{ mapping.first }; const Target_info& info{ mapping.second }; if( info.base == BAD_ADDR ) { if( mapping_errors++ == 0 ) { MESSAGE( "Port map errors detected:" ); } MESSAGE( "\n - Address " << addr << " from " << info.kind << " " << info.name << " " << "doesn't match contained address" ); continue; } if( info.last < info.base ) { if( mapping_errors++ == 0 ) { MESSAGE( "Port map errors detected:" ); } MESSAGE( "\n - Address " << addr << " from " << info.kind << " " << info.name << " " << "address range wraps around 64 bits!" ); continue; } if( info.base < min_address ) { min_address = info.base; } if( info.last > max_address ) { max_address = info.last; } for( const auto& next_mapping : m_addr_map ) { const Addr_t next_addr{ next_mapping.first }; const Target_info& next_info{ next_mapping.second }; if( next_addr <= addr ) { continue; } if( next_addr <= info.last ) { if( mapping_errors++ == 0 ) { MESSAGE( "Port map errors detected:" ); } MESSAGE( "\n - Overlapping regions in Bus address map: " << STREAM_HEX << info.kind << " " << info.name << " " << addr << ".." << info.last << " and " << next_info.kind << " " << next_info.name << " " << next_info.base << ".." << next_info.last ); } } } if( mapping_errors > 0 ) { REPORT( ERROR, "\n\nTotal of " << mapping_errors << " mapping errors detected for " << name()); } else { INFO( MEDIUM, "Port map valid for " << name() ); } m_configuration.set( "name", string( name() ) ); m_configuration.set( "kind", string( kind() ) ); m_configuration.set( "object_ptr", uintptr_t( this ) ); m_configuration.set( "target_base", min_address ); m_configuration.set( "target_size", Depth_t( max_address - min_address ) ); INFO( DEBUG, "Bus configuration:\n" << m_configuration ); }
#include "bus/memory_map.hpp" #include "report/report.hpp" #include "report/summary.hpp" #include "common/common.hpp" #include <string> #include <list> #include <vector> #include <map> using namespace std; using namespace sc_core; namespace { const char * const MSGID{ "/Doulos/Example/map_test" }; } Port_t decode_address ( Addr_t address, Addr_t& masked_address ); uint64_t reconstruct_address ( Addr_t address, Port_t port, bool bias_upwards ); void build_port_map ( void ); void dump_port_map ( int level ); void check_port_map_and_update_configuration( void ); string name( string name = "" ) { static string m_name{ "top.cpu" }; if( name.length() > 0 ) m_name = name; return m_name; } string kind( string kind = "" ) { static string m_kind{ "Cpu_name" }; if( kind.length() > 0 ) m_kind = kind; return m_kind; } struct Command { string m_initiator; string m_bus; string m_target; string m_yaml; Addr_t m_addr; bool m_processing{ true }; list<string> m_cmds; Address_map m_addr_map; bool processing( void ) const { return not m_processing; } void process( void ); void add( initializer_list<string> cmds ) { m_cmds.splice( m_cmds.end(), cmds ); } size_t size( void ) const { return m_cmds.size(); } } command; void Command::process( void ) { while( not m_cmds.empty() ) { string cmd = m_cmds.front(); string arg; if( cmd == "yaml" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); } else if( cmd == "init" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "targ" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "bus" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "findaddr" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "decode" and m_cmds.size() > 1 ) { m_cmds.pop_front(); arg = m_cmds.front(); m_cmds.pop_front(); NOT_YET_IMPLEMENTED(); } else if( cmd == "quit" ) { m_cmds.pop_front(); m_processing = false; break; } else if( m_cmds.size() == 1 ) { break; } } } int sc_main( int argc, char* argv[]) { Addr_t address = 0x1000ull; if( sc_argc() < 2 ) { command.add( { "yaml", "memory_map.yaml" , "init", "top.cpu" , "targ", "top.ram" , "bus", "top.bus" , "findaddr", "top.ram" , "decode", "0x1000" , "quit" }); } for( int i=1; i<sc_argc(); ++i ) { string arg( sc_argv()[i] ); if( arg == "-yaml" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"yaml", arg}); } else if( arg == "-init" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"init", arg}); } else if( arg == "-bus" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"bus", arg}); } else if( arg == "-targ" and (i+1) < sc_argc() ) { arg = name(sc_argv()[++i]); command.add({"targ", arg}); } else if( arg == "-kind" and (i+1) < sc_argc() ) { arg = kind(sc_argv()[++i]); } } if( command.size() ) { command.process(); } while( command.processing() ) { char line[256]; std::cin.getline(line,256); istringstream is(line); string word; while( not is.eof() ) { is >> word; command.add({word}); } command.process(); } return Summary::report(); } Addr_t find_address ( string path ) { INFO( DEBUG, "Searching for address from " << name() << " to " << path ); list<string> device_path = { name(), path }; auto target_info = Memory_map::get_target_path_info( device_path ); sc_assert( target_info.base != BAD_ADDR ); MESSAGE( "Found address " << STREAM_HEX << target_info.base ); MESSAGE( " from " << name() << " to " << path ); MEND( DEBUG ); return target_info.base; } Port_t decode_address ( Addr_t address, Addr_t& masked_address ) { if( address == BAD_ADDR ) { REPORT( ERROR, "Unable to decode BAD_ADDR" ); return BAD_PORT; } INFO( DEBUG, "Decoding address " << STREAM_HEX << address ); Addr_t base = BAD_ADDR; masked_address = BAD_ADDR; auto lookup = m_addr_map.lower_bound( address ); if( lookup == m_addr_map.end() ) { REPORT( WARNING, "No address => port match found!" ); return BAD_PORT; } base = lookup->first; if( base == MAX_ADDR || base == BAD_ADDR ) { REPORT( WARNING, "No address => port match found! Unintialized entry." ); return BAD_PORT; } if( address > lookup->second.last ) { REPORT( WARNING, "No address => port match found. Goes beyond closest port's maximum." ); return BAD_PORT; } masked_address = address - base; return lookup->second.port; }
void build_port_map( void ) { string config_name; string config_kind; Depth_t config_size; INFO( DEBUG, "Mapping port " << port << " " << config_name ); size_t matches{ 0 }; for( auto& mapping : m_addr_map ) { Addr_t addr{ mapping.first }; Target_info& mapped{ mapping.second }; INFO( DEBUG, "Target mapped: " << mapped ); if( mapped.name == config_name ) { ++matches; INFO( DEBUG, "Found port match at " << STREAM_HEX << addr ); mapped.port = port; mapped.kind = config_kind; if( config_size == UNASSIGNED ) { config_size = mapped.size; } else { mapped.size = config_size; } if( config_size == 0 ) { REPORT( ERROR, "Configured size of " << config_name << " is zero!" ); } mapped.last = mapped.base + config_size - 1; } } if( matches == 0 ) { REPORT( ERROR, "No matches on port " << config_name << " => connectivity mismatch!" ); } } void dump_port_map( int level ) { MESSAGE( "Port map for " << name() << ":\n" ); for( auto rit = m_addr_map.rbegin(); rit!=m_addr_map.rend(); ++rit ) { const Addr_t& addr{ rit->first }; const Target_info& info{ rit->second }; MESSAGE( STREAM_HEX << " - {" << " base: " << setw(10) << info.base << " last: " << setw(10) << info.last << " size: " << setw(6) << info.size << " port: " << setw(2) << STREAM_DEC << info.port << " name: " << info.name << " kind: " << info.kind << " }\n"; ); } MEND( NONE + level ); } void check_port_map_and_update_configuration( void ) { dump_port_map( SC_DEBUG ); INFO( MEDIUM, "Checking port map for " << name() ); Addr_t min_address{ MAX_ADDR }; Addr_t max_address{ 0 }; size_t mapping_errors { 0 }; for( const auto& mapping : m_addr_map ) { const Addr_t addr{ mapping.first }; const Target_info& info{ mapping.second }; if( info.base == BAD_ADDR ) { if( mapping_errors++ == 0 ) { MESSAGE( "Port map errors detected:" ); } MESSAGE( "\n - Address " << addr << " from " << info.kind << " " << info.name << " " << "doesn't match contained address" ); continue; } if( info.last < info.base ) { if( mapping_errors++ == 0 ) { MESSAGE( "Port map errors detected:" ); } MESSAGE( "\n - Address " << addr << " from " << info.kind << " " << info.name << " " << "address range wraps around 64 bits!" ); continue; } if( info.base < min_address ) { min_address = info.base; } if( info.last > max_address ) { max_address = info.last; } for( const auto& next_mapping : m_addr_map ) { const Addr_t next_addr{ next_mapping.first }; const Target_info& next_info{ next_mapping.second }; if( next_addr <= addr ) { continue; } if( next_addr <= info.last ) { if( mapping_errors++ == 0 ) { MESSAGE( "Port map errors detected:" ); } MESSAGE( "\n - Overlapping regions in Bus address map: " << STREAM_HEX << info.kind << " " << info.name << " " << addr << ".." << info.last << " and " << next_info.kind << " " << next_info.name << " " << next_info.base << ".." << next_info.last ); } } } if( mapping_errors > 0 ) { REPORT( ERROR, "\n\nTotal of " << mapping_errors << " mapping errors detected for " << name()); } else { INFO( MEDIUM, "Port map valid for " << name() ); } m_configuration.set( "name", string( name() ) ); m_configuration.set( "kind", string( kind() ) ); m_configuration.set( "object_ptr", uintptr_t( this ) ); m_configuration.set( "target_base", min_address ); m_configuration.set( "target_size", Depth_t( max_address - min_address ) ); INFO( DEBUG, "Bus configuration:\n" << m_configuration ); }
Addr_t reconstruct_address( Addr_t address, Port_t port, bool bias_upwards ) { Addr_t base{ BAD_ADDR }; Addr_t last; Addr_t min_address{ MAX_ADDR}; Addr_t max_address{ 0 }; Addr_t reconstructed{ BAD_ADDR }; for( const auto& mapping : m_addr_map ) { if( mapping.second.port != port ) continue; base = mapping.second.base; last = mapping.second.last; if( base < min_address ) min_address = base; if( last > max_address ) max_address = last; if( base <= address and address <= last ) { reconstructed = base + address; break; } } if( reconstructed == BAD_ADDR ) { if( address < max_address ) address = max_address; if( bias_upwards ) { } else { } } return reconstructed; }
function_block-full_function
[ { "content": "#define UNASSIGNED 0\n\n#define UNLIMITED 0\n\nstruct Target_info {\n\n // Initial values chosen to force initialization discovery if need be\n\n Port_t port { BAD_PORT }; // get from probe\n\n Addr_t base { BAD_ADDR }; // get from YAML\n\n Addr_t last { 0 }; //...
C++
code/BDataPersonName.cpp
omerdagan84/neomem
7d2f782bb37f1ab0ac6580d00672e114605afab7
#include "precompiled.h" #include "BDataPersonName.h" #include "ConstantsDatabase.h" #include "BDoc.h" #include "UI.h" #include "NeoMem.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif IMPLEMENT_SERIAL(BDataPersonName, BData, VERSIONABLE_SCHEMA | versionFileStructure) BDataPersonName::BDataPersonName() : m_bCacheValid (FALSE) { } BDataPersonName::~BDataPersonName() { } BOOL BDataPersonName::SetBDataText(const CString& str, BObject* pobjPropertyDef , BOOL bShowErrorMessage ) { ASSERT_VALID(this); m_strTitle.Empty(); m_strFirst.Empty(); m_strMiddle.Empty(); m_strLast.Empty(); m_strNickname.Empty(); m_strSuffix.Empty(); int n = str.Find(','); if (n != -1) { m_strLast = str.Left(n); m_strFirst = str.Mid(n+1); m_strFirst.TrimLeft(); } else { int n = str.ReverseFind(' '); if (n == -1) { m_strLast = str; } else { m_strFirst = str.Left(n); m_strLast = str.Mid(n+1); } } m_bCacheValid = FALSE; return TRUE; } CString BDataPersonName::GetBDataText(BDoc* pDoc, ULONG lngPropertyID, BOOL bMachineVersion) { ASSERT_VALID(this); ASSERT_VALID(pDoc); if (m_bCacheValid) return m_strText; m_strText.Empty(); switch (app.m_nNameFormat) { case nfLastFirst: { LPCTSTR pszGap = ""; if (!m_strLast.IsEmpty()) { m_strText = m_strLast; pszGap = g_strCommaSpace; } if (!m_strTitle.IsEmpty()) { m_strText += pszGap + m_strTitle + g_strSpace; pszGap = "";} if (!m_strFirst.IsEmpty()) { m_strText += pszGap + m_strFirst + g_strSpace; pszGap = "";} if (!m_strMiddle.IsEmpty()) { m_strText += pszGap + m_strMiddle + g_strSpace; pszGap = "";} if (!m_strNickname.IsEmpty()) { m_strText += pszGap + g_strQuote + m_strNickname + g_strQuoteSpace; pszGap = "";} if (!m_strSuffix.IsEmpty()) { m_strText += pszGap + m_strSuffix; pszGap = "";} break; } case nfFirstLast: default: if (!m_strTitle.IsEmpty()) m_strText = m_strTitle + g_strSpace; if (!m_strFirst.IsEmpty()) m_strText += m_strFirst + g_strSpace; if (!m_strMiddle.IsEmpty()) m_strText += m_strMiddle + g_strSpace; if (!m_strNickname.IsEmpty()) m_strText += g_strQuote + m_strNickname + g_strQuoteSpace; if (!m_strLast.IsEmpty()) m_strText += m_strLast; if (!m_strSuffix.IsEmpty()) m_strText += g_strCommaSpace + m_strSuffix; break; } m_strText.TrimRight(); m_bCacheValid = TRUE; return m_strText; } BOOL BDataPersonName::UIEditValue(CUI& ui, BObject* pobj, BObject* pobjPropertyDef) { ASSERT_VALID(this); if (ui.EditName(m_strTitle, m_strFirst, m_strMiddle, m_strNickname, m_strLast, m_strSuffix)) { m_bCacheValid = FALSE; return TRUE; } return FALSE; } void BDataPersonName::Serialize(CArchive& ar) { BData::Serialize(ar); if (ar.IsStoring()) { ar << m_strTitle; ar << m_strFirst; ar << m_strMiddle; ar << m_strLast; ar << m_strNickname; ar << m_strSuffix; } else { ar >> m_strTitle; ar >> m_strFirst; ar >> m_strMiddle; ar >> m_strLast; ar >> m_strNickname; ar >> m_strSuffix; } } BData* BDataPersonName::CreateCopy() { ASSERT_VALID(this); BDataPersonName* pdatCopy = new BDataPersonName(); ASSERT_VALID(pdatCopy); pdatCopy->m_strTitle = m_strTitle; pdatCopy->m_strFirst = m_strFirst; pdatCopy->m_strLast = m_strLast; pdatCopy->m_strMiddle = m_strMiddle; pdatCopy->m_strNickname = m_strNickname; pdatCopy->m_strSuffix = m_strSuffix; return pdatCopy; } BOOL BDataPersonName::FindReferences(BObject* pobjFind) { return FALSE; } ULONG BDataPersonName::GetMemoryUsed(BOOL bRecursive) { ASSERT_VALID(this); ULONG nBytes = sizeof(BDataPersonName); nBytes += m_strTitle.GetLength() * sizeof(TCHAR); nBytes += m_strFirst.GetLength() * sizeof(TCHAR); nBytes += m_strLast.GetLength() * sizeof(TCHAR); nBytes += m_strMiddle.GetLength() * sizeof(TCHAR); nBytes += m_strNickname.GetLength() * sizeof(TCHAR); nBytes += m_strSuffix.GetLength() * sizeof(TCHAR); return nBytes; } void BDataPersonName::ResetData() { m_bCacheValid = FALSE; }
#include "precompiled.h" #include "BDataPersonName.h" #include "ConstantsDatabase.h" #include "BDoc.h" #include "UI.h" #include "NeoMem.h" #ifdef _DEBUG #undef THIS_FILE static char THIS_FILE[]=__FILE__; #define new DEBUG_NEW #endif IMPLEMENT_SERIAL(BDataPersonName, BData, VERSIONABLE_SCHEMA | versionFileStructure) BDataPersonName::BDataPersonName() : m_bCacheValid (FALSE) { } BDataPersonName::~BDataPersonName() { } BOOL BDataPersonName::SetBDataText(const CString& str, BObject* pobjPropertyDef , BOOL bShowErrorMessage ) { ASSERT_VALI
rFirst = str.Mid(n+1); m_strFirst.TrimLeft(); } else { int n = str.ReverseFind(' '); if (n == -1) { m_strLast = str; } else { m_strFirst = str.Left(n); m_strLast = str.Mid(n+1); } } m_bCacheValid = FALSE; return TRUE; } CString BDataPersonName::GetBDataText(BDoc* pDoc, ULONG lngPropertyID, BOOL bMachineVersion) { ASSERT_VALID(this); ASSERT_VALID(pDoc); if (m_bCacheValid) return m_strText; m_strText.Empty(); switch (app.m_nNameFormat) { case nfLastFirst: { LPCTSTR pszGap = ""; if (!m_strLast.IsEmpty()) { m_strText = m_strLast; pszGap = g_strCommaSpace; } if (!m_strTitle.IsEmpty()) { m_strText += pszGap + m_strTitle + g_strSpace; pszGap = "";} if (!m_strFirst.IsEmpty()) { m_strText += pszGap + m_strFirst + g_strSpace; pszGap = "";} if (!m_strMiddle.IsEmpty()) { m_strText += pszGap + m_strMiddle + g_strSpace; pszGap = "";} if (!m_strNickname.IsEmpty()) { m_strText += pszGap + g_strQuote + m_strNickname + g_strQuoteSpace; pszGap = "";} if (!m_strSuffix.IsEmpty()) { m_strText += pszGap + m_strSuffix; pszGap = "";} break; } case nfFirstLast: default: if (!m_strTitle.IsEmpty()) m_strText = m_strTitle + g_strSpace; if (!m_strFirst.IsEmpty()) m_strText += m_strFirst + g_strSpace; if (!m_strMiddle.IsEmpty()) m_strText += m_strMiddle + g_strSpace; if (!m_strNickname.IsEmpty()) m_strText += g_strQuote + m_strNickname + g_strQuoteSpace; if (!m_strLast.IsEmpty()) m_strText += m_strLast; if (!m_strSuffix.IsEmpty()) m_strText += g_strCommaSpace + m_strSuffix; break; } m_strText.TrimRight(); m_bCacheValid = TRUE; return m_strText; } BOOL BDataPersonName::UIEditValue(CUI& ui, BObject* pobj, BObject* pobjPropertyDef) { ASSERT_VALID(this); if (ui.EditName(m_strTitle, m_strFirst, m_strMiddle, m_strNickname, m_strLast, m_strSuffix)) { m_bCacheValid = FALSE; return TRUE; } return FALSE; } void BDataPersonName::Serialize(CArchive& ar) { BData::Serialize(ar); if (ar.IsStoring()) { ar << m_strTitle; ar << m_strFirst; ar << m_strMiddle; ar << m_strLast; ar << m_strNickname; ar << m_strSuffix; } else { ar >> m_strTitle; ar >> m_strFirst; ar >> m_strMiddle; ar >> m_strLast; ar >> m_strNickname; ar >> m_strSuffix; } } BData* BDataPersonName::CreateCopy() { ASSERT_VALID(this); BDataPersonName* pdatCopy = new BDataPersonName(); ASSERT_VALID(pdatCopy); pdatCopy->m_strTitle = m_strTitle; pdatCopy->m_strFirst = m_strFirst; pdatCopy->m_strLast = m_strLast; pdatCopy->m_strMiddle = m_strMiddle; pdatCopy->m_strNickname = m_strNickname; pdatCopy->m_strSuffix = m_strSuffix; return pdatCopy; } BOOL BDataPersonName::FindReferences(BObject* pobjFind) { return FALSE; } ULONG BDataPersonName::GetMemoryUsed(BOOL bRecursive) { ASSERT_VALID(this); ULONG nBytes = sizeof(BDataPersonName); nBytes += m_strTitle.GetLength() * sizeof(TCHAR); nBytes += m_strFirst.GetLength() * sizeof(TCHAR); nBytes += m_strLast.GetLength() * sizeof(TCHAR); nBytes += m_strMiddle.GetLength() * sizeof(TCHAR); nBytes += m_strNickname.GetLength() * sizeof(TCHAR); nBytes += m_strSuffix.GetLength() * sizeof(TCHAR); return nBytes; } void BDataPersonName::ResetData() { m_bCacheValid = FALSE; }
D(this); m_strTitle.Empty(); m_strFirst.Empty(); m_strMiddle.Empty(); m_strLast.Empty(); m_strNickname.Empty(); m_strSuffix.Empty(); int n = str.Find(','); if (n != -1) { m_strLast = str.Left(n); m_st
function_block-random_span
[ { "content": "#define HID_STATIC 0x1FFFF\n", "file_path": "help/HTMLDefines.h", "rank": 0, "score": 83671.20184086818 }, { "content": "#define HIDD_NEW_FILE 0x2031E\n", "file_path": "help/HTMLDefines.h", "rank": 1, "score": 8...
C++
examples/fft2d/fft2d.cpp
brycelelbach/upcxx
9a3f3b18a631d8e924298e621729ef302636908d
#include <upcxx.h> #include <forkjoin.h> #include "myfft.h" #include <cstdlib> #include <iostream> #include <vector> #include <cassert> #include <time.h> #include <sys/time.h> #define VERIFY using namespace upcxx; #include <cstdlib> size_t NX_default = 1024; size_t NY_default = 1024; global_ptr<complex_t> *Input, *Output; double mysecond() { struct timeval tv; gettimeofday(&tv, 0); return tv.tv_sec + ((double) tv.tv_usec / 1000000); } template<typename T> static inline void print_matrix(std::ostream &out, T *A, size_t nrows, size_t ncols) { size_t i,j; for (i=0; i<nrows; i++) { for (j=0; j<ncols; j++) { out << "(" << A[i*ncols+j].real << " + " << A[i*ncols+j].imag << "i)\t "; } out << "\n"; } } void init_array(complex_t *A, size_t sz, double val=0.0) { assert(A != NULL); for (size_t i = 0; i < sz; i++) { A[i].real = (double)i + val; A[i].imag = 0; } } static inline double random_double(void) { long long tmp; tmp = rand(); tmp = (tmp << 32) | rand(); return (double)tmp; } static inline complex_t random_complex(void) { complex_t tmp; tmp.real = random_double(); tmp.real = random_double(); return tmp; } template<typename T> void alltoall(global_ptr<T> src[], global_ptr<T> dst[], size_t count[], int np) { int i; int myid = myrank(); for (i=0; i<np; i++) { int j = (myid+i) % np; #ifdef DEBUG fprintf(stderr, "myid %d: i %d, j %d ", myid, i, j); cerr << "src[j] " << src[j] << " dst[j] " << dst[j] << " count[j] " << count[j] << "\n"; #endif async_copy(src[j], dst[j], count[j]); } async_copy_fence(); barrier(); } template<typename T> static inline void local_transpose(T *A, size_t N, size_t row_stride, size_t col_stride) { size_t i, j; T tmp; for (i=0; i<N; i++) { for (j=i+1; j<N; j++) { tmp = A[i*row_stride + j*col_stride]; A[i*row_stride + j*col_stride] = A[j*row_stride + i*col_stride]; A[j*row_stride + i*col_stride] = tmp; } } } template<typename T> static inline void local_transpose1(T *A, size_t N) { size_t i, j; T tmp; for (i=0; i<N; i++) { for (j=i+1; j<N; j++) { tmp = A[i*N+j]; A[i*N+j] = A[j*N+i]; A[j*N+i] = tmp; } } } template<typename T> static inline void local_transpose2(T *A, T *B, size_t n, size_t m) { size_t i, j; T tmp; #ifdef DEBUG int myid = my_cpu_place.id(); cerr << "myid " << myid << " A: " << A << " B: " << B << "\n"; #endif for (i=0; i<n; i++) { for (j=0; j<m; j++) { B[j*n+i] = A[i*m+j]; } } } template<typename T> void blockize(T *in, T *out, size_t nx, size_t ny, size_t blk_nx, size_t blk_ny) { size_t x, y, row_major_offset, blk_cyclic_offset; size_t blk_offset_x, blk_offset_y, blk_grid_x, blk_grid_y; assert(in != out); assert(in != NULL); assert(out != NULL); for (x = 0; x < nx; x++) { for (y = 0; y < ny; y++) { blk_offset_x = x % blk_nx; blk_offset_y = y % blk_ny; blk_grid_x = x / blk_nx; blk_grid_y = y / blk_ny; row_major_offset = x * ny + y; blk_cyclic_offset = blk_grid_x * (blk_nx * ny) + blk_grid_y * (blk_nx * blk_ny) + blk_offset_x * blk_ny + blk_offset_y; out[blk_cyclic_offset] = in[row_major_offset]; } } } template<typename T> static inline void transpose(T *in, T *out, global_ptr< global_ptr<T> > all_Ws, size_t nx, size_t ny, int nprocs) { global_ptr<T> *src = new global_ptr<T> [nprocs]; assert(src != NULL); global_ptr<T> *dst = new global_ptr<T> [nprocs]; assert(dst != NULL); size_t count[nprocs]; int i; size_t msgsz_per_p = (nx/nprocs) * (ny/nprocs); size_t nx_per_p = nx / nprocs; int myid = myrank(); global_ptr<T> tmp_in; global_ptr<T> *W = new global_ptr<T> [nprocs]; assert(W != NULL); assert(nx == ny); upcxx::copy(all_Ws, global_ptr< global_ptr<T> >(W), nprocs); #ifdef DEBUG for (int i=0; i<nprocs; i++) { fprintf(stderr, "transpose: myid %d, W[%d] ", myid, i); cerr << W[i] << "\n"; } #endif tmp_in = allocate<T>(myid, nx_per_p * ny); assert(tmp_in.raw_ptr() != NULL); #ifdef DEBUG printf("P%d transpose: Before local_transpose2 (row-major storage):\n", myid); print_matrix<T>(cout, in, nx_per_p, ny); #endif local_transpose2<T>(in, tmp_in.raw_ptr(), nx_per_p, ny); #ifdef DEBUG printf("P%d transpose: After local_transpose2 (should be column-major):\n", myid); print_matrix<T>(cout, (T *)tmp_in.raw_ptr(), ny, nx_per_p); #endif for (i = 0; i < nprocs; i++) { local_transpose1<T>((tmp_in + msgsz_per_p * i).raw_ptr(), nx_per_p); } #ifdef DEBUG printf("P%d transpose: After local_transpose1 (should be block-cyclic):\n", myid); print_matrix<T>(cout, (T *)tmp_in.raw_ptr(), ny, nx_per_p); #endif for (i=0; i<nprocs; i++) { src[i] = tmp_in + (i*msgsz_per_p) ; dst[i] = W[i] + (myid*msgsz_per_p); count[i] = msgsz_per_p; #ifdef DEBUG fprintf(stderr, "transpose: myid %d, i %d ", myid, i); cerr << "W[i] " << W[i] << " src[i] "<< src[i] << " dst[i] " << dst[i] << "\n"; #endif } alltoall(src, dst, count, nprocs); #ifdef DEBUG for (i=0; i<nprocs; i++) { if (myid == i) { printf("P%d transpose: After alltoall:\n", myid); print_matrix<T>(cout, (T *)W[myid].raw_ptr(), ny, nx_per_p); } barrier(); } #endif local_transpose2<T>((T *)W[myid].raw_ptr(), out, ny, nx_per_p); #ifdef DEBUG for (i=0; i<nprocs; i++) { if (myid == i) { printf("P%d transpose: After the second local_transpose2:\n", myid); print_matrix<T>(cout, out, nx_per_p, ny); } barrier(); } #endif delete [] src; delete [] dst; } void verify(complex_t *X, complex_t *Z, int nx, int ny) { complex_t *Y, *tmp; size_t failed = 0; double epsilon = 1e-7; Y = (complex_t *)malloc(nx * ny * sizeof(complex_t)); assert(Y != NULL); tmp = (complex_t *)malloc(nx * ny * sizeof(complex_t)); assert(tmp != NULL); fft2(tmp, X, nx, ny); local_transpose2(tmp, Y, nx, ny); #ifdef DEBUG1 printf("verify: X: \n"); print_matrix(cout, X, nx, ny); printf("verify: Y: \n"); print_matrix(cout, Y, nx, ny); printf("verify: Z: \n"); print_matrix(cout, Z, nx, ny); #endif double max_diff = 0.0; for (size_t i = 0; i < nx*ny; i++) { double diff_real = Y[i].real - Z[i].real; double diff_imag = Y[i].imag - Z[i].imag; double abs_diff = sqrt(diff_real * diff_real + diff_imag * diff_imag); double abs_y = sqrt(Y[i].real * Y[i].real + Y[i].real * Y[i].real); if (abs_diff / abs_y > epsilon * log((double)nx*ny)) { failed++; if (abs_diff > max_diff) { max_diff = abs_diff; } } } free(Y); free(tmp); if (failed) { printf("FFT2D verification failed: %lu elements are different, max_diff: %g.\n", failed, max_diff); } else { printf("FFT2D verification passed.\n"); } } void fft2d(complex_t *my_A, complex_t *my_Z, complex_t *my_W, size_t nx, size_t ny, global_ptr<global_ptr<complex_t> > all_Ws) { int nprocs = ranks(); complex_t *tmp; fft_plan_t planX, planY; int myid = myrank(); size_t nx_per_p = nx / nprocs; size_t ny_per_p = ny / nprocs; size_t size_per_p = nx_per_p * ny; assert(nx == ny); fft_init(); std::generate(my_A, &my_A[nx_per_p * ny], random_complex); init_array(my_A, size_per_p, myid * size_per_p); complex_t *pIn = my_A; complex_t *pOut = my_W; fft_plan_1d(FFT_FORWARD, ny, nx_per_p, pOut, 1, ny, pIn, 1, ny, &planY); fft_plan_1d(FFT_FORWARD, nx, ny_per_p, pOut, 1, nx, pIn, 1, nx, &planX); run_1d_fft(my_Z, my_A, &planY); tmp = (complex_t *)malloc(sizeof(complex_t) * (nx*ny/nprocs)); assert(tmp != NULL); transpose<complex_t>(my_Z, tmp, all_Ws, nx, ny, nprocs); run_1d_fft(my_Z, tmp, &planY); free(tmp); #ifdef DEBUG for (int i=0; i<nprocs; i++) { if (myid == i) { printf("myid %d: A: \n", myid); print_matrix(cout, (complex_t *)my_A, nx_per_p, ny); printf("myid %d: Z: \n", myid); print_matrix(cout, (complex_t *)my_Z, nx_per_p, ny); } barrier(); } #endif #ifdef VERIFY if (myid == 0) { global_ptr<complex_t> all_in, all_out; all_in = allocate<complex_t>(myid, nx * ny); all_out = allocate<complex_t>(myid, nx * ny); for (int i = 0; i < nprocs; i++) { async_copy(Input[i], all_in + i * size_per_p, size_per_p); async_copy(Output[i], all_out + i * size_per_p, size_per_p); } async_copy_fence(); verify(all_in.raw_ptr(), all_out.raw_ptr(), (int)nx, (int)ny); } barrier(); #endif } int main(int argc, char **argv) { double starttime; int i; int nprocs = ranks(); Input = new global_ptr<complex_t> [nprocs]; Output = new global_ptr<complex_t> [nprocs]; size_t nx, ny; global_ptr<global_ptr<complex_t> > all_Ws; all_Ws = allocate< global_ptr<complex_t> > (myrank(), nprocs); global_ptr<complex_t> *W = (global_ptr<complex_t> *)all_Ws.raw_ptr(); int tmp = 0; if (argc > 1) { tmp = atoi(argv[1]); } nx = (tmp < 2) ? NX_default : tmp; ny = nx; size_t nx_per_p = nx / nprocs; for (i=0; i<nprocs; i++) { Input[i] = allocate<complex_t>(i, nx_per_p * ny); Output[i] = allocate<complex_t>(i, nx_per_p * ny); W[i] = allocate<complex_t>(i, nx_per_p * ny); } #ifdef DEBUG for (i=0; i<nprocs; i++) { fprintf(stderr, "W[%d] ", i); cerr << W[i] << "\n"; } #endif starttime = mysecond(); for (i=0; i<nprocs; i++) { async(i)(fft2d, Input[i].raw_ptr(), Output[i].raw_ptr(), W[i].raw_ptr(), nx, ny, all_Ws); } upcxx::async_wait(); double elapsedtime = mysecond() - starttime; printf("fft2d (nx %lu, ny %lu), np %d, time = %f s\n", nx, ny, nprocs, elapsedtime); for (i=0; i<nprocs; i++) { upcxx::deallocate(Input[i]); upcxx::deallocate(Output[i]); upcxx::deallocate(W[i]); } delete [] Input; delete [] Output; return 0; }
#include <upcxx.h> #include <forkjoin.h> #include "myfft.h" #include <cstdlib> #include <iostream> #include <vector> #include <cassert> #include <time.h> #include <sys/time.h> #define VERIFY using namespace upcxx; #include <cstdlib> size_t NX_default = 1024; size_t NY_default = 1024; global_ptr<complex_t> *Input, *Output; double mysecond() { struct timeval tv; gettimeofday(&tv, 0); return tv.tv_sec + ((double) tv.tv_usec / 1000000); } template<typename T> static inline void print_matrix(std::ostream &out, T *A, size_t nrows, size_t ncols) { size_t i,j; for (i=0; i<nrows; i++) { for (j=0; j<ncols; j++) { out << "(" << A[i*ncols+j].real << " + " << A[i*ncols+j].imag << "i)\t "; } out << "\n"; } } void init_array(complex_t *A, size_t sz, double val=0.0) { assert(A != NULL); for (size_t i = 0; i < sz; i++) { A[i].real = (double)i + val; A[i].imag = 0; } } static inline double random_double(void) { long long tmp; tmp = rand(); tmp = (tmp << 32) | rand(); return (double)tmp; } static inline complex_t random_complex(void) { complex_t tmp; tmp.real = random_double(); tmp.real = random_double(); return tmp; } template<typename T> void alltoall(global_ptr<T> src[], global_ptr<T> dst[], size_t count[], int np) { int i; int myid = myrank(); for (i=0; i<np; i++) { int j = (myid+i) % np; #ifdef DEBUG fprintf(stderr, "myid %d: i %d, j %d ", myid, i, j); cerr << "src[j] " << src[j] << " dst[j] " << dst[j] << " count[j] " << count[j] << "\n"; #endif async_copy(src[j], dst[j], count[j]); } async_copy_fence(); barrier(); } template<typename T> static inline void local_transpose(T *A, size_t N, size_t row_stride, size_t col_stride) { size_t i, j; T tmp; for (i=0; i<N; i++) { for (j=i+1; j<N; j++) { tmp = A[i*row_stride + j*col_stride]; A[i*row_stride + j*col_stride] = A[j*row_stride + i*col_stride]; A[j*row_stride + i*col_stride] = tmp; } } } template<typename T> static inline void local_transpose1(T *A, size_t N) { size_t i, j; T tmp; for (i=0; i<N; i++) { for (j=i+1; j<N; j++) { tmp = A[i*N+j]; A[i*N+j] = A[j*N+i]; A[j*N+i] = tmp; } } } template<typename T> static inline void local_transpose2(T *A, T *B, size_t n, size_t m) { size_t i, j; T tmp; #ifdef DEBUG int myid = my_cpu_place.id(); cerr << "myid " << myid << " A: " << A << " B: " << B << "\n"; #endif for (i=0; i<n; i++) { for (j=0; j<m; j++) { B[j*n+i] = A[i*m+j]; } } } template<typename T> void blockize(T *in, T *out, size_t nx, size_t ny, size_t blk_nx, size_t blk_ny) { size_t x, y, row_major_offset, blk_cyclic_offset; size_t blk_offset_x, blk_offset_y, blk_grid_x, blk_grid_y; assert(in != out); assert(in != NULL); assert(out != NULL); for (x = 0; x < nx; x++) { for (y = 0; y < ny; y++) { blk_offset_x = x % blk_nx; blk_offset_y = y % blk_ny; blk_grid_x = x / blk_nx; blk_grid_y = y / blk_ny; row_major_offset = x * ny + y; blk_cyclic_offset = blk_grid_x * (blk_nx * ny) + blk_grid_y * (blk_nx * blk_ny) + blk_offset_x * blk_ny + blk_offset_y; out[blk_cyclic_offset] = in[row_major_offset]; } } } template<typename T> static inline void transpose(T *in, T *out, global_ptr< global_ptr<T> > all_Ws, size_t nx, size_t ny, int nprocs) { global_ptr<T> *src = new global_ptr<T> [nprocs]; assert(src != NULL); global_ptr<T> *dst = new global_ptr<T> [nprocs]; assert(dst != NULL); size_t count[nprocs]; int i; size_t msgsz_per_p = (nx/nprocs) * (ny/nprocs); size_t nx_per_p = nx / nprocs; int myid = myrank(); global_ptr<T> tmp_in; global_ptr<T> *W = new global_ptr<T> [nprocs]; assert(W != NULL); assert(nx == ny); upcx
nx_per_p); } barrier(); } #endif local_transpose2<T>((T *)W[myid].raw_ptr(), out, ny, nx_per_p); #ifdef DEBUG for (i=0; i<nprocs; i++) { if (myid == i) { printf("P%d transpose: After the second local_transpose2:\n", myid); print_matrix<T>(cout, out, nx_per_p, ny); } barrier(); } #endif delete [] src; delete [] dst; } void verify(complex_t *X, complex_t *Z, int nx, int ny) { complex_t *Y, *tmp; size_t failed = 0; double epsilon = 1e-7; Y = (complex_t *)malloc(nx * ny * sizeof(complex_t)); assert(Y != NULL); tmp = (complex_t *)malloc(nx * ny * sizeof(complex_t)); assert(tmp != NULL); fft2(tmp, X, nx, ny); local_transpose2(tmp, Y, nx, ny); #ifdef DEBUG1 printf("verify: X: \n"); print_matrix(cout, X, nx, ny); printf("verify: Y: \n"); print_matrix(cout, Y, nx, ny); printf("verify: Z: \n"); print_matrix(cout, Z, nx, ny); #endif double max_diff = 0.0; for (size_t i = 0; i < nx*ny; i++) { double diff_real = Y[i].real - Z[i].real; double diff_imag = Y[i].imag - Z[i].imag; double abs_diff = sqrt(diff_real * diff_real + diff_imag * diff_imag); double abs_y = sqrt(Y[i].real * Y[i].real + Y[i].real * Y[i].real); if (abs_diff / abs_y > epsilon * log((double)nx*ny)) { failed++; if (abs_diff > max_diff) { max_diff = abs_diff; } } } free(Y); free(tmp); if (failed) { printf("FFT2D verification failed: %lu elements are different, max_diff: %g.\n", failed, max_diff); } else { printf("FFT2D verification passed.\n"); } } void fft2d(complex_t *my_A, complex_t *my_Z, complex_t *my_W, size_t nx, size_t ny, global_ptr<global_ptr<complex_t> > all_Ws) { int nprocs = ranks(); complex_t *tmp; fft_plan_t planX, planY; int myid = myrank(); size_t nx_per_p = nx / nprocs; size_t ny_per_p = ny / nprocs; size_t size_per_p = nx_per_p * ny; assert(nx == ny); fft_init(); std::generate(my_A, &my_A[nx_per_p * ny], random_complex); init_array(my_A, size_per_p, myid * size_per_p); complex_t *pIn = my_A; complex_t *pOut = my_W; fft_plan_1d(FFT_FORWARD, ny, nx_per_p, pOut, 1, ny, pIn, 1, ny, &planY); fft_plan_1d(FFT_FORWARD, nx, ny_per_p, pOut, 1, nx, pIn, 1, nx, &planX); run_1d_fft(my_Z, my_A, &planY); tmp = (complex_t *)malloc(sizeof(complex_t) * (nx*ny/nprocs)); assert(tmp != NULL); transpose<complex_t>(my_Z, tmp, all_Ws, nx, ny, nprocs); run_1d_fft(my_Z, tmp, &planY); free(tmp); #ifdef DEBUG for (int i=0; i<nprocs; i++) { if (myid == i) { printf("myid %d: A: \n", myid); print_matrix(cout, (complex_t *)my_A, nx_per_p, ny); printf("myid %d: Z: \n", myid); print_matrix(cout, (complex_t *)my_Z, nx_per_p, ny); } barrier(); } #endif #ifdef VERIFY if (myid == 0) { global_ptr<complex_t> all_in, all_out; all_in = allocate<complex_t>(myid, nx * ny); all_out = allocate<complex_t>(myid, nx * ny); for (int i = 0; i < nprocs; i++) { async_copy(Input[i], all_in + i * size_per_p, size_per_p); async_copy(Output[i], all_out + i * size_per_p, size_per_p); } async_copy_fence(); verify(all_in.raw_ptr(), all_out.raw_ptr(), (int)nx, (int)ny); } barrier(); #endif } int main(int argc, char **argv) { double starttime; int i; int nprocs = ranks(); Input = new global_ptr<complex_t> [nprocs]; Output = new global_ptr<complex_t> [nprocs]; size_t nx, ny; global_ptr<global_ptr<complex_t> > all_Ws; all_Ws = allocate< global_ptr<complex_t> > (myrank(), nprocs); global_ptr<complex_t> *W = (global_ptr<complex_t> *)all_Ws.raw_ptr(); int tmp = 0; if (argc > 1) { tmp = atoi(argv[1]); } nx = (tmp < 2) ? NX_default : tmp; ny = nx; size_t nx_per_p = nx / nprocs; for (i=0; i<nprocs; i++) { Input[i] = allocate<complex_t>(i, nx_per_p * ny); Output[i] = allocate<complex_t>(i, nx_per_p * ny); W[i] = allocate<complex_t>(i, nx_per_p * ny); } #ifdef DEBUG for (i=0; i<nprocs; i++) { fprintf(stderr, "W[%d] ", i); cerr << W[i] << "\n"; } #endif starttime = mysecond(); for (i=0; i<nprocs; i++) { async(i)(fft2d, Input[i].raw_ptr(), Output[i].raw_ptr(), W[i].raw_ptr(), nx, ny, all_Ws); } upcxx::async_wait(); double elapsedtime = mysecond() - starttime; printf("fft2d (nx %lu, ny %lu), np %d, time = %f s\n", nx, ny, nprocs, elapsedtime); for (i=0; i<nprocs; i++) { upcxx::deallocate(Input[i]); upcxx::deallocate(Output[i]); upcxx::deallocate(W[i]); } delete [] Input; delete [] Output; return 0; }
x::copy(all_Ws, global_ptr< global_ptr<T> >(W), nprocs); #ifdef DEBUG for (int i=0; i<nprocs; i++) { fprintf(stderr, "transpose: myid %d, W[%d] ", myid, i); cerr << W[i] << "\n"; } #endif tmp_in = allocate<T>(myid, nx_per_p * ny); assert(tmp_in.raw_ptr() != NULL); #ifdef DEBUG printf("P%d transpose: Before local_transpose2 (row-major storage):\n", myid); print_matrix<T>(cout, in, nx_per_p, ny); #endif local_transpose2<T>(in, tmp_in.raw_ptr(), nx_per_p, ny); #ifdef DEBUG printf("P%d transpose: After local_transpose2 (should be column-major):\n", myid); print_matrix<T>(cout, (T *)tmp_in.raw_ptr(), ny, nx_per_p); #endif for (i = 0; i < nprocs; i++) { local_transpose1<T>((tmp_in + msgsz_per_p * i).raw_ptr(), nx_per_p); } #ifdef DEBUG printf("P%d transpose: After local_transpose1 (should be block-cyclic):\n", myid); print_matrix<T>(cout, (T *)tmp_in.raw_ptr(), ny, nx_per_p); #endif for (i=0; i<nprocs; i++) { src[i] = tmp_in + (i*msgsz_per_p) ; dst[i] = W[i] + (myid*msgsz_per_p); count[i] = msgsz_per_p; #ifdef DEBUG fprintf(stderr, "transpose: myid %d, i %d ", myid, i); cerr << "W[i] " << W[i] << " src[i] "<< src[i] << " dst[i] " << dst[i] << "\n"; #endif } alltoall(src, dst, count, nprocs); #ifdef DEBUG for (i=0; i<nprocs; i++) { if (myid == i) { printf("P%d transpose: After alltoall:\n", myid); print_matrix<T>(cout, (T *)W[myid].raw_ptr(), ny,
random
[ { "content": " int barrier();\n", "file_path": "include/upcxx/upcxx_runtime.h", "rank": 0, "score": 169134.43952992093 }, { "content": " static inline uint32_t myrank() {\n\n if (is_init() == false) return 0xFFFFFFFF; // return a special value if not inited\n\n return team::current_t...
C++
BlackVision/Test/Tools/TestLibCore/Source/Conversions/String2Integer.cpp
black-vision-engine/bv-engine
85089d41bb22afeaa9de070646e12aa1777ecedf
#include "gtest/gtest.h" #include "Serialization/SerializationHelper.h" using namespace bv; template< class Type > class LibCore_String2T_Integer : public testing::Test { protected: LibCore_String2T_Integer() {}; }; template< class Type > class LibCore_String2T_IntegerSigned : public testing::Test { protected: LibCore_String2T_IntegerSigned() {}; }; template< class Type > class LibCore_String2T_IntegerUnsigned : public testing::Test { protected: LibCore_String2T_IntegerUnsigned() {}; }; typedef testing::Types< UInt64, Int64, UInt32, Int32, UInt16, Int16, UInt8, Int8 > IntegerTypesList; typedef testing::Types< Int64, Int32, Int16, Int8 > SignedIntegerTypesList; typedef testing::Types< UInt64, UInt32, UInt16, UInt8 > UnsignedIntegerTypesList; TYPED_TEST_CASE( LibCore_String2T_Integer, IntegerTypesList ); TYPED_TEST_CASE( LibCore_String2T_IntegerSigned, SignedIntegerTypesList ); TYPED_TEST_CASE( LibCore_String2T_IntegerUnsigned, UnsignedIntegerTypesList ); TYPED_TEST( LibCore_String2T_Integer, ValidInput ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "123" ); TypeParam intDef = Convert::String2T< TypeParam >( "123", 5 ); EXPECT_TRUE( intExp.IsValid() ); EXPECT_EQ( intExp.GetVal(), 123 ); EXPECT_EQ( intDef, 123 ); } TYPED_TEST( LibCore_String2T_IntegerSigned, NegativeInput ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "-123" ); TypeParam intDef = Convert::String2T< TypeParam >( "-123", 5 ); EXPECT_TRUE( intExp.IsValid() ); EXPECT_EQ( intExp.GetVal(), -123 ); EXPECT_EQ( intDef, -123 ); } TYPED_TEST( LibCore_String2T_IntegerUnsigned, NegativeInput ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "-123" ); TypeParam intDef = Convert::String2T< TypeParam >( "-123", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConvertFromFloatStr ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "1.0434" ); TypeParam intDef = Convert::String2T< TypeParam >( "1.0434", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConvertOverflowing ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "48446744073709551615" ); TypeParam intDef = Convert::String2T< TypeParam >( "48446744073709551615", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConvertUnderflowing ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "-48446744073709551615" ); TypeParam intDef = Convert::String2T< TypeParam >( "-48446744073709551615", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, TextBeforeNumber ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "bla13" ); TypeParam intDef = Convert::String2T< TypeParam >( "bla13", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, TextAfterNumber ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "13bla" ); TypeParam intDef = Convert::String2T< TypeParam >( "13bla", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, TextInTheMiddleOfNumber ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "13bla234" ); TypeParam intDef = Convert::String2T< TypeParam >( "13bla234", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConversionReversibility ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( Convert::T2String( 123 ) ); EXPECT_TRUE( intExp.IsValid() ); EXPECT_EQ( intExp.GetVal(), 123 ); }
#include "gtest/gtest.h" #include "Serialization/SerializationHelper.h" using namespace bv; template< class Type > class LibCore_String2T_Integer : public testing::Test { protected: LibCore_String2T_Integer() {}; }; template< class Type > class LibCore_String2T_IntegerSigned : public testing::Test { protected: LibCore_String2T_IntegerSigned() {}; }; template< class Type > class LibCore_String2T_IntegerUnsigned : public testing::Test { protected: LibCore_String2T_IntegerUnsigned
mFloatStr ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "1.0434" ); TypeParam intDef = Convert::String2T< TypeParam >( "1.0434", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConvertOverflowing ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "48446744073709551615" ); TypeParam intDef = Convert::String2T< TypeParam >( "48446744073709551615", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConvertUnderflowing ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "-48446744073709551615" ); TypeParam intDef = Convert::String2T< TypeParam >( "-48446744073709551615", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, TextBeforeNumber ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "bla13" ); TypeParam intDef = Convert::String2T< TypeParam >( "bla13", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, TextAfterNumber ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "13bla" ); TypeParam intDef = Convert::String2T< TypeParam >( "13bla", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, TextInTheMiddleOfNumber ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "13bla234" ); TypeParam intDef = Convert::String2T< TypeParam >( "13bla234", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConversionReversibility ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( Convert::T2String( 123 ) ); EXPECT_TRUE( intExp.IsValid() ); EXPECT_EQ( intExp.GetVal(), 123 ); }
() {}; }; typedef testing::Types< UInt64, Int64, UInt32, Int32, UInt16, Int16, UInt8, Int8 > IntegerTypesList; typedef testing::Types< Int64, Int32, Int16, Int8 > SignedIntegerTypesList; typedef testing::Types< UInt64, UInt32, UInt16, UInt8 > UnsignedIntegerTypesList; TYPED_TEST_CASE( LibCore_String2T_Integer, IntegerTypesList ); TYPED_TEST_CASE( LibCore_String2T_IntegerSigned, SignedIntegerTypesList ); TYPED_TEST_CASE( LibCore_String2T_IntegerUnsigned, UnsignedIntegerTypesList ); TYPED_TEST( LibCore_String2T_Integer, ValidInput ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "123" ); TypeParam intDef = Convert::String2T< TypeParam >( "123", 5 ); EXPECT_TRUE( intExp.IsValid() ); EXPECT_EQ( intExp.GetVal(), 123 ); EXPECT_EQ( intDef, 123 ); } TYPED_TEST( LibCore_String2T_IntegerSigned, NegativeInput ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "-123" ); TypeParam intDef = Convert::String2T< TypeParam >( "-123", 5 ); EXPECT_TRUE( intExp.IsValid() ); EXPECT_EQ( intExp.GetVal(), -123 ); EXPECT_EQ( intDef, -123 ); } TYPED_TEST( LibCore_String2T_IntegerUnsigned, NegativeInput ) { Expected< TypeParam > intExp = Convert::String2T< TypeParam >( "-123" ); TypeParam intDef = Convert::String2T< TypeParam >( "-123", 5 ); EXPECT_FALSE( intExp.IsValid() ); EXPECT_EQ( intDef, 5 ); } TYPED_TEST( LibCore_String2T_Integer, ConvertFro
random
[ { "content": " class TestName : public CaseName<gtest_TypeParam_> { \\\n\n private: \\\n\n typedef CaseName<gtest_TypeParam_> TestFixture; \\\n\n typedef gtest_TypeParam_ TypeParam; \\\n\n virtual void TestBody(); \\\n\n }; \\\n\n static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \...
C++
Xenakios/FloatingInspector.cpp
lorenzopistolesi/sws
6963f7563851c8dd919db426bae825843939077f
#include "stdafx.h" #include "../SnM/SnM_Dlg.h" using namespace std; HWND g_hItemInspector=NULL; bool g_ItemInspectorVisible=false; WDL_DLGRET MyItemInspectorDlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam) { static HMENU g_hItemInspCtxMenu=0; static int g_InspshowMode=1; if (INT_PTR r = SNM_HookThemeColorsMessage(hwnd, Message, wParam, lParam)) return r; switch(Message) { case WM_INITDIALOG: g_hItemInspCtxMenu = CreatePopupMenu(); AddToMenu(g_hItemInspCtxMenu, "Show number of selected items/tracks", 666); AddToMenu(g_hItemInspCtxMenu, "Show item properties", 667); break; case WM_RBUTTONUP: { POINT pieru; pieru.x=GET_X_LPARAM(lParam); pieru.y=GET_Y_LPARAM(lParam); ClientToScreen(hwnd,&pieru); int ContextResult = TrackPopupMenu(g_hItemInspCtxMenu,TPM_LEFTALIGN|TPM_RETURNCMD,pieru.x,pieru.y,0,hwnd,NULL); if (ContextResult == 666) g_InspshowMode = 0; else if (ContextResult == 667) g_InspshowMode = 1; break; } case WM_COMMAND: if (LOWORD(wParam)==IDCANCEL) { KillTimer(g_hItemInspector, 1); ShowWindow(g_hItemInspector, SW_HIDE); g_ItemInspectorVisible=false; } break; case WM_TIMER: { ostringstream infoText; const int NumSelItems=CountSelectedMediaItems(NULL); if (g_InspshowMode==0) { if (NumSelItems>0) { if (NumSelItems>1) infoText << NumSelItems << " items selected "; else infoText << "1 item selected "; } else infoText << "No items selected"; int i; MediaTrack *CurTrack; int n=0; for (i=0;i<GetNumTracks();i++) { CurTrack=CSurf_TrackFromID(i+1,false); int isSel=*(int*)GetSetMediaTrackInfo(CurTrack,"I_SELECTED",NULL); if (isSel==1) n++; } if (n>0) { if (n>1) infoText << "\t" << n << " tracks selected"; else infoText << "\t1 track selected"; } else infoText << "\tNo tracks selected"; SetDlgItemText(hwnd,IDC_IISTATIC1,infoText.str().c_str()); } if (g_InspshowMode==1) { vector<MediaItem_Take*> TheTakes; XenGetProjectTakes(TheTakes,true,true); if (TheTakes.size()>0) { infoText << (char*)GetSetMediaItemTakeInfo(TheTakes[0],"P_NAME",NULL) << " Pitch : "; infoText << std::setprecision(3) << *(double*)GetSetMediaItemTakeInfo(TheTakes[0],"D_PITCH",NULL); infoText << "\tPlayrate : " << *(double*)GetSetMediaItemTakeInfo(TheTakes[0],"D_PLAYRATE",NULL); MediaItem* CurItem=(MediaItem*)GetSetMediaItemTakeInfo(TheTakes[0],"P_ITEM",NULL); if (CurItem) { int curTakeInd=666; curTakeInd= *(int*)GetSetMediaItemInfo(CurItem,"I_CURTAKE",NULL); infoText << " Take " << curTakeInd+1; infoText << " / " << GetMediaItemNumTakes(CurItem); } SetDlgItemText(hwnd,IDC_IISTATIC1,infoText.str().c_str()); } else SetDlgItemText(hwnd,IDC_IISTATIC1,"No item selected"); } break; } case WM_DESTROY: g_hItemInspector = NULL; DestroyMenu(g_hItemInspCtxMenu); break; } return 0; } void DoTglFltItemInspector(COMMAND_T*) { if (g_ItemInspectorVisible) { g_ItemInspectorVisible = false; KillTimer(g_hItemInspector, 1); ShowWindow(g_hItemInspector, SW_HIDE); } else { g_ItemInspectorVisible = true; SetTimer(g_hItemInspector, 1, 200, NULL); ShowWindow(g_hItemInspector, SW_SHOW); } }
#include "stdafx.h" #include "../SnM/SnM_Dlg.h" using namespace std; HWND g_hItemInspector=NULL; bool g_ItemInspectorVisible=false; WDL_DLGRET MyItemInspectorDlgProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam) { static HMENU g_hItemInspCtxMenu=0; static int g_InspshowMode=1; if (INT_PTR r = SNM_HookThemeColorsMessage(hwnd, Message, wParam, lParam)) return r; switch(Message) { case WM_INITDIALOG: g_hItemInspCtxMenu = CreatePopupMenu(); AddToMenu(g_hItemInspCtxMenu, "Show number of selected items/tracks", 666); AddToMenu(g_hItemInspCtxMenu, "Show item properties", 667); break; case WM_RBUTTONUP: { POINT pieru; pieru.x=GET_X_LPARAM(lParam); pieru.y=GET_Y_LPARAM(lParam); ClientToScreen(hwnd,&pieru); int ContextResult = TrackPopupMenu(g_hItemInspCtxMenu,TPM_LEFTALIGN|TPM_RETURNCMD,pieru.x,pieru.y,0,hwnd,NULL); if (ContextResult == 666) g_InspshowMode = 0; else if (ContextResult == 667) g_InspshowMode = 1; break; } case WM_COMMAND: if (LOWORD(wParam)==IDCANCEL) { KillTimer(g_hItemInspector, 1); ShowWindow(g_hItemInspector, SW_HIDE); g_ItemInspectorVisible=false; } break; case WM_TIMER: { ostringstream infoText; const int NumSelItems=CountSelectedMediaItems(NULL); if (g_InspshowMode==0) { if (NumSelItems>0) { if (NumSelItems>1) infoText << NumSelItems << " items selected "; else infoText << "1 item selected "; } else infoText << "No items selected"; int i; MediaTrack *CurTrack; int n=0; for (i=0;i<GetNumTracks();i++) { CurTrack=CSurf_TrackFromID(i+1,false); int isSel=*(int*)GetSetMediaTrackInfo(CurTrack,"I_SELECTED",NULL); if (isSel==1) n++; } if (n>0) { if (n>1) infoText << "\t" << n << " tracks selected"; else infoText << "\t1 track selected"; } else infoText << "\tNo tracks selected"; SetDlgItemText(hwnd,IDC_IISTATIC1,infoText.str().c_str()); } if (g_InspshowMode==1) { vector<MediaItem_Take*> TheTakes; XenGetProjectTakes(TheTakes,true,true); if (TheTakes.size()>0) { infoText << (char*)GetSetMediaItemTakeInfo(TheTakes[0],"P_NAME",NULL) << " Pitch : "; infoText << std::setprecision(3) << *(double*)GetSetMediaItemTakeInfo(TheTakes[0],"D_PITCH",NULL); infoText << "\tPlayrate : " << *(double*)GetSetMediaItemTakeInfo(TheTakes[0],"D_PLAYRATE",NULL); MediaItem* CurItem=(MediaItem*)GetSetMediaItemTakeInfo(TheTakes[0],"P_ITEM",NULL); if (CurItem) { int curTakeInd=666; curTakeInd= *(int*)GetSetMediaItemInfo(CurItem,"I_CURTAKE",NULL); infoText << " Take " << curTakeInd+1; infoText << " / " << GetMediaItemNumTakes(CurItem); } SetDlgItemText(hwnd,IDC_IISTATIC1,infoText.str().c_str()); } else SetDlgItemText(hwnd,IDC_IISTATIC1,"No item selected"); } break; } case WM_DESTROY: g_hItemInspector = NULL; DestroyMenu(g_hItemInspCtxMenu); break; } return 0; }
void DoTglFltItemInspector(COMMAND_T*) { if (g_ItemInspectorVisible) { g_ItemInspectorVisible = false; KillTimer(g_hItemInspector, 1); ShowWindow(g_hItemInspector, SW_HIDE); } else { g_ItemInspectorVisible = true; SetTimer(g_hItemInspector, 1, 200, NULL); ShowWindow(g_hItemInspector, SW_SHOW); } }
function_block-full_function
[ { "content": "class CmdSelectAllItemsOnTrackBetweenLoopPoints: public RprCommand\n\n{\n\npublic:\n\n\tCmdSelectAllItemsOnTrackBetweenLoopPoints(bool allInLoop) {m_allInLoop = allInLoop;}\n\nprivate:\n\n\tvirtual void doCommand(int flag);\n\n\tbool m_allInLoop;\n\n};\n\n\n", "file_path": "Fingers/MediaItemCo...
C++
Library/Source/Nanites/CoreFoundation/NCoreFoundation.cpp
refnum/Nano
dceb0907061f7845d8a3c662f309ca164e932e6f
#include "NCoreFoundation.h" NCFType ToCF(const NAny& theValue) { NNumber theNumber; NCFType cfObject; if (theValue.IsBool()) { cfObject.Set(theValue.GetBool() ? kCFBooleanTrue : kCFBooleanFalse); } else if (theValue.IsArray()) { cfObject.Set(ToCF(theValue.GetArray())); } else if (theValue.IsData()) { cfObject.Set(ToCF(theValue.GetData())); } else if (theValue.Is<NDate>()) { cfObject.Set(ToCF(theValue.Get<NDate>())); } else if (theValue.IsDictionary()) { cfObject.Set(ToCF(theValue.GetDictionary())); } else if (theValue.IsString()) { cfObject.Set(ToCF(theValue.GetString())); } else if (theValue.IsTime()) { cfObject.Set(ToCF(theValue.GetTime())); } else if (theValue.Is<NURL>()) { cfObject.Set(ToCF(theValue.Get<NURL>())); } else if (theNumber.SetValue(theValue)) { cfObject.Set(ToCF(theNumber)); } else { NN_LOG_ERROR("Unable to convert Nano object to CF!"); } return cfObject; } NAny ToNN(CFTypeRef cfObject) { NAny theObject; if (cfObject != nullptr) { CFTypeID cfType = CFGetTypeID(cfObject); if (cfType == CFBooleanGetTypeID()) { theObject = CFBooleanGetValue(CFBooleanRef(cfObject)) ? true : false; } else if (cfType == CFArrayGetTypeID()) { NCFArray cfArray; cfArray.Set(CFArrayRef(cfObject)); theObject = cfArray.GetArray(); } else if (cfType == CFDataGetTypeID()) { NCFData cfData; cfData.Set(CFDataRef(cfObject)); theObject = cfData.GetData(); } else if (cfType == CFDateGetTypeID()) { NCFDate cfDate; cfDate.Set(CFDateRef(cfObject)); theObject = cfDate.GetDate(); } else if (cfType == CFDictionaryGetTypeID()) { NCFDictionary cfDictionary; cfDictionary.Set(CFDictionaryRef(cfObject)); theObject = cfDictionary.GetDictionary(); } else if (cfType == CFNumberGetTypeID()) { NCFNumber cfNumber; cfNumber.Set(CFNumberRef(cfObject)); theObject = cfNumber.GetNumber(); } else if (cfType == CFStringGetTypeID()) { NCFString cfString; cfString.Set(CFStringRef(cfObject)); theObject = cfString.GetString(); } else if (cfType == CFURLGetTypeID()) { NCFURL cfURL; cfURL.Set(CFURLRef(cfObject)); theObject = cfURL.GetURL(); } else { NN_LOG_ERROR("Unable to convert CF object to Nano!"); } } return theObject; }
#include "NCoreFoundation.h" NCFType ToCF(const NAny& theValue) { NNumber theNumber; NCFType cfObject; if (theValue.IsBool()) { cfObject.Set(theValue.GetBool() ? kCFBooleanTrue : kCFBooleanFalse); } else if (theValue.IsArray()) { cfObject.Set(ToCF(theValue.GetArray())); } else if (theValue.IsData()) { cfObject.Set(ToCF(theValue.GetData())); } else if (theValue.Is<NDate>()) { cfObject.Set(ToCF(theValue.Get<NDate>())); } else if (theValue.IsDictionary()) { cfObject.Set(ToCF(theValue.GetDictionary())); } else if (theValue.IsString()) { cfObject.Set(ToCF(theValue.GetString())); } else if (theValue.IsTime()) { cfObject.Set(ToCF(theValue.GetTime())); } else if (theValue.Is<NURL>()) { cfObject.Set(ToCF(theValue.Get<NURL>())); } else
return cfObject; } NAny ToNN(CFTypeRef cfObject) { NAny theObject; if (cfObject != nullptr) { CFTypeID cfType = CFGetTypeID(cfObject); if (cfType == CFBooleanGetTypeID()) { theObject = CFBooleanGetValue(CFBooleanRef(cfObject)) ? true : false; } else if (cfType == CFArrayGetTypeID()) { NCFArray cfArray; cfArray.Set(CFArrayRef(cfObject)); theObject = cfArray.GetArray(); } else if (cfType == CFDataGetTypeID()) { NCFData cfData; cfData.Set(CFDataRef(cfObject)); theObject = cfData.GetData(); } else if (cfType == CFDateGetTypeID()) { NCFDate cfDate; cfDate.Set(CFDateRef(cfObject)); theObject = cfDate.GetDate(); } else if (cfType == CFDictionaryGetTypeID()) { NCFDictionary cfDictionary; cfDictionary.Set(CFDictionaryRef(cfObject)); theObject = cfDictionary.GetDictionary(); } else if (cfType == CFNumberGetTypeID()) { NCFNumber cfNumber; cfNumber.Set(CFNumberRef(cfObject)); theObject = cfNumber.GetNumber(); } else if (cfType == CFStringGetTypeID()) { NCFString cfString; cfString.Set(CFStringRef(cfObject)); theObject = cfString.GetString(); } else if (cfType == CFURLGetTypeID()) { NCFURL cfURL; cfURL.Set(CFURLRef(cfObject)); theObject = cfURL.GetURL(); } else { NN_LOG_ERROR("Unable to convert CF object to Nano!"); } } return theObject; }
if (theNumber.SetValue(theValue)) { cfObject.Set(ToCF(theNumber)); } else { NN_LOG_ERROR("Unable to convert Nano object to CF!"); }
if_condition
[ { "content": " ExprList *pReturnEL; /* List of expressions to return */\n", "file_path": "Library/Source/Nano/Internal/Components/sqlite-3.36.0/sqlite3.36.0.c", "rank": 0, "score": 52241.32236349526 }, { "content": "static const char KW_INCLUDE[]\n", "file_path": "Library/Source/Nano/I...
C++
tests/server.test.cpp
lineCode/webrtc-datachannels
0f814632361c829c3aff1764cb662bd6290d54d9
#include "algo/StringUtils.hpp" #include "config/ServerConfig.hpp" #include "log/Logger.hpp" #include "storage/path.hpp" #include <algorithm> #include <boost/asio.hpp> #include <boost/asio/bind_executor.hpp> #include <boost/asio/buffer.hpp> #include <boost/asio/ip/tcp.hpp> #include <boost/asio/ssl.hpp> #include <boost/asio/ssl/context.hpp> #include <boost/asio/ssl/stream.hpp> #include <boost/asio/strand.hpp> #include <boost/beast/core.hpp> #include <boost/beast/http.hpp> #include <boost/beast/websocket.hpp> #include <boost/beast/websocket/ssl.hpp> #include <cstddef> #include <cstdlib> #include <fstream> #include <functional> #include <iostream> #include <memory> #include <net/core.hpp> #include <sstream> #include <streambuf> #include <string> #include <thread> #include <vector> #ifndef __has_include static_assert(false, "__has_include not supported"); #else # if __has_include(<filesystem>) # include <filesystem> namespace fs = std::filesystem; # elif __has_include(<experimental/filesystem>) # include <experimental/filesystem> namespace fs = std::experimental::filesystem; # elif __has_include(<boost/filesystem.hpp>) # include <boost/filesystem.hpp> namespace fs = boost::filesystem; # endif #endif #include "testsCommon.h" inline void load_server_certificate(boost::asio::ssl::context& ctx) { const fs::path workDir = gloer::storage::getThisBinaryDirectoryPath(); const fs::path assetsDir = (workDir / gloer::config::ASSETS_DIR); std::string const cert = gloer::storage::getFileContents( workDir / fs::path{"../gloer/assets/certs/server.crt"}); std::string const key = gloer::storage::getFileContents( workDir / fs::path{"../gloer/assets/certs/server.key"}); std::string const dh = gloer::storage::getFileContents( workDir / fs::path{"../gloer/assets/certs/dh.pem"}); ctx.set_password_callback( [](std::size_t, boost::asio::ssl::context_base::password_purpose) { return "1234"; }); ctx.set_options(boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use); boost::system::error_code ec; ctx.use_certificate_chain(boost::asio::buffer(cert.data(), cert.size()), ec); if (ec) { LOG(WARNING) << "use_certificate_chain error: " << ec.message(); } LOG(WARNING) << "cert: " << cert; ctx.use_private_key(boost::asio::buffer(key.data(), key.size()), boost::asio::ssl::context::file_format::pem, ec); if (ec) { LOG(WARNING) << "use_private_key error: " << ec.message(); } ctx.use_tmp_dh(boost::asio::buffer(dh.data(), dh.size()), ec); if (ec) { LOG(WARNING) << "use_tmp_dh error: " << ec.message(); } } void fail(beast::error_code ec, char const* what) { } class session : public std::enable_shared_from_this<session> { ::tcp::socket socket_; websocket::stream<boost::asio::ssl::stream<::tcp::socket&>> ws_; ::net::strand<::net::io_context::executor_type> strand_; beast::multi_buffer buffer_; public: session(::tcp::socket socket, boost::asio::ssl::context& ctx) : socket_(std::move(socket)), ws_(socket_, ctx), strand_(ws_.get_executor()) {} void run() { LOG(WARNING) << "session run"; ws_.next_layer().async_handshake( boost::asio::ssl::stream_base::server, ::net::bind_executor( strand_, std::bind(&session::on_handshake, shared_from_this(), std::placeholders::_1))); } void on_handshake(beast::error_code ec) { LOG(WARNING) << "on_handshake"; if (ec) return fail(ec, "handshake"); ws_.async_accept(::net::bind_executor( strand_, std::bind(&session::on_accept, shared_from_this(), std::placeholders::_1))); } void on_accept(beast::error_code ec) { LOG(WARNING) << "on_accept"; if (ec) return fail(ec, "accept"); do_read(); } void do_read() { ws_.async_read(buffer_, ::net::bind_executor( strand_, std::bind(&session::on_read, shared_from_this(), std::placeholders::_1, std::placeholders::_2))); } void on_read(beast::error_code ec, std::size_t bytes_transferred) { LOG(WARNING) << "on_read"; boost::ignore_unused(bytes_transferred); if (ec == websocket::error::closed) return; if (ec) fail(ec, "read"); ws_.text(ws_.got_text()); ws_.async_write( buffer_.data(), ::net::bind_executor(strand_, std::bind(&session::on_write, shared_from_this(), std::placeholders::_1, std::placeholders::_2))); } void on_write(beast::error_code ec, std::size_t bytes_transferred) { boost::ignore_unused(bytes_transferred); if (ec) return fail(ec, "write"); buffer_.consume(buffer_.size()); do_read(); } }; class listener : public std::enable_shared_from_this<listener> { boost::asio::ssl::context& ctx_; ::tcp::acceptor acceptor_; ::tcp::socket socket_; public: listener(::net::io_context& ioc, boost::asio::ssl::context& ctx, ::tcp::endpoint endpoint) : ctx_(ctx), acceptor_(ioc), socket_(ioc) { beast::error_code ec; acceptor_.open(endpoint.protocol(), ec); if (ec) { fail(ec, "open"); return; } acceptor_.set_option(::net::socket_base::reuse_address(true), ec); if (ec) { fail(ec, "set_option"); return; } acceptor_.bind(endpoint, ec); if (ec) { fail(ec, "bind"); return; } acceptor_.listen(::net::socket_base::max_listen_connections, ec); if (ec) { fail(ec, "listen"); return; } } void run() { if (!acceptor_.is_open()) return; do_accept(); } void do_accept() { acceptor_.async_accept( socket_, std::bind(&listener::on_accept, shared_from_this(), std::placeholders::_1)); } void on_accept(beast::error_code ec) { if (ec) { fail(ec, "accept"); } else { std::make_shared<session>(std::move(socket_), ctx_)->run(); } do_accept(); } }; SCENARIO("ssltest", "[ssltest]") { auto const address = ::net::ip::make_address("0.0.0.0"); unsigned short const port = 8085; int const threads = 1; ::net::io_context ioc{threads}; boost::asio::ssl::context ctx{boost::asio::ssl::context::sslv23}; load_server_certificate(ctx); std::make_shared<listener>(ioc, ctx, ::tcp::endpoint{address, port})->run(); } SCENARIO("matchers", "[matchers]") { REQUIRE_THAT("Hello olleH", Predicate<std::string>( [](std::string const& str) -> bool { return str.front() == str.back(); }, "First and last character should be equal")); } SCENARIO("vectors can be sized and resized", "[vector]") { GIVEN("A vector with some items") { std::vector<int> v(5); REQUIRE(v.size() == 5); REQUIRE(v.capacity() >= 5); WHEN("the size is increased") { v.resize(10); THEN("the size and capacity change") { REQUIRE(v.size() == 10); REQUIRE(v.capacity() >= 10); } } WHEN("the size is reduced") { v.resize(0); THEN("the size changes but not capacity") { REQUIRE(v.size() == 0); REQUIRE(v.capacity() >= 5); } } WHEN("more capacity is reserved") { v.reserve(10); THEN("the capacity changes but not the size") { REQUIRE(v.size() == 5); REQUIRE(v.capacity() >= 10); } } WHEN("less capacity is reserved") { v.reserve(0); THEN("neither size nor capacity are changed") { REQUIRE(v.size() == 5); REQUIRE(v.capacity() >= 5); } } } }
#include "algo/StringUtils.hpp" #include "config/ServerConfig.hpp" #include "log/Logger.hpp" #include "storage/path.hpp" #include <algorithm> #include <boost/asio.hpp> #include <boost/asio/bind_executor.hpp> #include <boost/asio/buffer.hpp> #include <boost/asio/ip/tcp.hpp> #include <boost/asio/ssl.hpp> #include <boost/asio/ssl/context.hpp> #include <boost/asio/ssl/stream.hpp> #include <boost/asio/strand.hpp> #include <boost/beast/core.hpp> #include <boost/beast/http.hpp> #include <boost/beast/websocket.hpp> #include <boost/beast/websocket/ssl.hpp> #include <cstddef> #include <cstdlib> #include <fstream> #include <functional> #include <iostream> #include <memory> #include <net/core.hpp> #include <sstream> #include <streambuf> #include <string> #include <thread> #include <vector> #ifndef __has_include static_assert(false, "__has_include not supported"); #else # if __has_include(<filesystem>) # include <filesystem> namespace fs = std::filesystem; # elif __has_include(<experimental/filesystem>) # include <experimental/filesystem> namespace fs = std::experimental::filesystem; # elif __has_include(<boost/filesystem.hpp>) # include <boost/filesystem.hpp> namespace fs = boost::filesystem; # endif #endif #include "testsCommon.h" inline void load_server_certificate(boost::asio::ssl::context& ctx) { const fs::path workDir = gloer::storage::getThisBinaryDirectoryPath(); const fs::path assetsDir = (workDir / gloer::config::ASSETS_DIR); std::string const cert = gloer::storage::getFileContents( workDir / fs::path{"../gloer/assets/certs/server.crt"}); std::string const key = gloer::storage::getFileContents( workDir / fs::path{"../gloer/assets/certs/server.key"}); std::string const dh = gloer::storage::getFileContents( workDir / fs::path{"../gloer/assets/certs/dh.pem"}); ctx.set_password_callback( [](std::size_t, boost::asio::ssl::context_base::password_purpose) { return "1234"; }); ctx.set_options(boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::single_dh_use); boost::system::error_code ec; ctx.use_certificate_chain(boost::asio::buffer(cert.data(), cert.size()), ec); if (ec) { LOG(WARNING) << "use_certificate_chain error: " << ec.message(); } LOG(WARNING) << "cert: " << cert; ctx.use_private_key(boost::asio::buffer(key.data(), key.size()), boost::asio::ssl::context::file_format::pem, ec); if (ec) { LOG(WARNING) << "use_private_key error: " << ec.message(); } ctx.use_tmp_dh(boost::asio::buffer(dh.data(), dh.size()), ec); if (ec) { LOG(WARNING) << "use_tmp_dh error: " << ec.message(); } } void fail(beast::error_code ec, char const* what) { } class session : public std::enable_shared_from_this<session> { ::tcp::socket socket_; websocket::stream<boost::asio::ssl::stream<::tcp::socket&>> ws_; ::net::strand<::net::io_context::executor_type> strand_; beast::multi_buffer buffer_; public: session(::tcp::socket socket, boost::asio::ssl::context& ctx) : socket_(std::move(socket)), ws_(socket_, ctx), strand_(ws_.get_executor()) {} void run() { LOG(WARNING) << "session run"; ws_.next_layer().async_handshake( boost::asio::ssl::stream_base::server, ::net::bind_executor( strand_, std::bind(&session::on_handshake, shared_from_this(), std::placeholders::_1))); } void on_handshake(beast::error_code ec) { LOG(WARNING) << "on_handshake"; if (ec) return fail(ec, "handshake"); ws_.async_accept(::net::bind_executor( strand_, std::bind(&session::on_accept, shared_from_this(), std::placeholders::_1))); } void on_accept(beast::error_code ec) { LOG(WARNING) << "on_accept"; if (ec) return fail(ec, "accept"); do_read(); } void do_read() { ws_.async_read(buffer_, ::net::bind_executor( strand_, std::bind(&session::on_read, shared_from_this(), std::placeholders::_1, std::placeholders::_2))); } void on_read(beast::error_code ec, std::size_t bytes_transferred) { LOG(WARNING) << "on_read"; boost::ignore_unused(bytes_transferred); if (ec == websocket::error::closed) return; if (ec) fail(ec, "read"); ws_.text(ws_.got_text()); ws_.async_write( buffer_.data(), ::net::bind_executor(strand_, std::bind(&session::on_write, shared_from_this(), std::placeholders::_1, std::placeholders::_2))); } void on_write(beast::error_code ec, std::size_t bytes_transferred) { boost::ignore_unused(bytes_transferred); if (ec) return fail(ec, "write"); buffer_.consume(buffer_.size()); do_read(); } }; class listener : public std::enable_shared_from_this<listener> { boost::asio::ssl::context& ctx_; ::tcp::acceptor acceptor_; ::tcp::socket socket_; public: listener(::net::io_context& ioc, boost::asio::ssl::context& ctx, ::tcp::endpoint endpoint) : ctx_(ctx), acceptor_(ioc), socket_(ioc) { beast::error_code ec; acceptor_.open(endpoint.protocol(), ec); if (ec) { fail(ec, "open"); return; } acceptor_.set_option(::net::socket_base::reuse_address(true), ec); if (ec) { fail(ec, "set_option"); return; } acceptor_.bind(endpoint, ec); if (ec) { fail(ec, "bind"); return; } acceptor_.listen(::net::socket_base::max_listen_connections, ec); if (ec) { fail(ec, "listen"); return; } } void run() { if (!acceptor_.is_open()) return; do_accept(); } void do_accept() { acceptor_.async_accept( socket_, std::bind(&listener::on_accept, shared_from_this(), std::placeholders::_1)); } void on_accept(beast::error_code ec) { if (ec) { fail(ec, "accept"); } else { std::make_shared<session>(std::move(socket_), ctx_)->run(); } do_accept(); } }; SCENARIO("ssltest", "[ssltest]") { auto const address = ::net::ip::make_address("0.0.0.0"); unsigned short const port = 8085; int const threads = 1; ::net::io_context ioc{threads}; boost::asio::ssl::context ctx{boost::asio::ssl::context::sslv23}; load_server_certificate(ctx); std::make_shared<listener>(ioc, ctx, ::tcp::endpoint{address, port})->run(); } SCENARIO("matchers", "[matchers]") { REQUIRE_THAT("Hello olleH", Predicate<std::string>( [](std::string const& str) -> bool { return str.front() == str.back(); }, "First and last character should be equal")); } SCENARIO("vectors can be sized and resized", "[vector]") { GIVEN("A vector with some items") { std::vector<int> v(5); REQUIRE(v.size(
{ REQUIRE(v.size() == 10); REQUIRE(v.capacity() >= 10); } } WHEN("the size is reduced") { v.resize(0); THEN("the size changes but not capacity") { REQUIRE(v.size() == 0); REQUIRE(v.capacity() >= 5); } } WHEN("more capacity is reserved") { v.reserve(10); THEN("the capacity changes but not the size") { REQUIRE(v.size() == 5); REQUIRE(v.capacity() >= 10); } } WHEN("less capacity is reserved") { v.reserve(0); THEN("neither size nor capacity are changed") { REQUIRE(v.size() == 5); REQUIRE(v.capacity() >= 5); } } } }
) == 5); REQUIRE(v.capacity() >= 5); WHEN("the size is increased") { v.resize(10); THEN("the size and capacity change")
random
[ { "content": "// Sends a WebSocket message and prints the response\n\nclass session : public std::enable_shared_from_this<session>\n\n{\n\n tcp::resolver resolver_;\n\n websocket::stream<beast::tcp_stream> ws_;\n\n beast::flat_buffer buffer_;\n\n std::string host_;\n\n std::string text_;\n\n\n\np...
C++
Chapter-5-Loops-and-Files/Review Questions and Exercises/Programming Challenges/016.cpp
jesushilarioh/C-Plus-Plus
bbff921460ac4267af48558f040c7d82ccf42d5e
#include <iostream> #include <iomanip> using namespace std; int main() { const int MONTHS = 12; float starting_balance, annual_interest_rate, amount_deposited, amount_withdrawn, interest_rate, monthly_interest_rate, balance, total_deposits, total_withdrawn, total_interest_earned; int months_since_established; cout << "\nEnter annual interest rate: "; while (!(cin >> annual_interest_rate)) { cout << "Error: a number must be entered... "; cin.clear(); cin.ignore(123, '\n'); } cout << "Enter starting balance: "; while (!(cin >> starting_balance)) { cout << "Error: a number must be entered... "; cin.clear(); cin.ignore(123, '\n'); } balance = starting_balance; cout << "Enter # of months passed since account was established: "; while (!(cin >> months_since_established)) { cout << "Error: a number must be entered... "; cin.clear(); cin.ignore(123, '\n'); } monthly_interest_rate = annual_interest_rate / MONTHS; for (int i = 0; i < months_since_established; i++) { cout << "Enter the amount deposited for month " << (i + 1) << ": "; while (!(cin >> amount_deposited) || amount_deposited < 0) { cout << "Error: a positive number must be entered." << endl; cout << "Enter the amount deposited for month " << (i + 1) << ": "; cin.clear(); cin.ignore(123, '\n'); } total_deposits += amount_deposited; balance += amount_deposited; if (balance < 0) break; cout << "Enter the amount withdrawn for month " << (i + 1) << ": "; while (!(cin >> amount_withdrawn) || amount_withdrawn < 0) { cout << "Error: a positive number must be entered." << endl; cout << "Enter the amount withdrawn for month " << (i + 1) << ": "; cin.clear(); cin.ignore(123, '\n'); } total_withdrawn += amount_withdrawn; balance -= amount_withdrawn; if (balance < 0) break; interest_rate = (monthly_interest_rate * balance); balance += interest_rate; if (balance < 0) break; total_interest_earned += (interest_rate); } if (balance < 0) { cout << "I'm sorry, your account has been closed" << endl; cout << "due to having a negative balance." << endl; } else { cout << setprecision(2) << fixed << endl; cout << "Starting balance = $" << starting_balance << endl; cout << "Ending balance = $" << balance << endl; cout << "Total amount in deposits = $" << total_deposits << endl; cout << "Total amount in withdrawals = $" << total_withdrawn << endl; cout << "Total interest earned = $" << total_interest_earned; cout << endl << endl; } return 0; }
#include <iostream> #include <iomanip> using namespace std; int main() { const int MONTHS = 12; float starting_balance, annual_interest_rate, amount_deposited, amount_withdrawn, interest_rate, monthly_interest_rate, balance, total_deposits, total_withdrawn, total_interest_earned; int months_since_established; cout << "\nEnter annual interest rate: "; while (!(cin >> annual_interest_rate)) { cout << "Error: a number must be entered... "; cin.clear(); cin.ignore(123, '\n'); } cout << "Enter starting balance: "; while (!(cin >> starting_balance)) { cout << "Error: a number must be entered... "; cin.clear(); cin.ignore(123, '\n'); } balance = starting_balance; cout << "Enter # of months passed since account was established: "; while (!(cin >> months_since_established)) { cout << "Error: a number must be entered... "; cin.clear(); cin.ignore(123, '\n'); } monthly_interest_rate = annual_interest_rate / MONTHS; for (int i = 0; i < months_since_established; i++) { cout << "Enter the amount deposited for month " << (i + 1) << ": "; while (!(cin >> amount_deposited) || amount_deposited < 0) { cout << "Error: a positive number must be entered." << endl; cout << "Enter the amount deposited for month " << (i + 1) << ": "; cin.clear(); cin.ignore(123, '\n'); } total_deposits += amount_deposited; balance += amount_deposited; if (balance < 0) break; cout << "Enter the amount withdrawn for month " << (i + 1) << ": "; while (!(cin >> amount_withdrawn) || amount_withdrawn < 0) { cout << "Error: a positive number must be entered." << endl; cout << "Enter the amount withdrawn for month " << (i + 1) << ": "; cin.clear(); cin.ignore(123, '\n'); } total_withdrawn += amount_withdrawn; balance -= amount_withdrawn; if (balance < 0) break; interest_rate = (monthly_interest_rate * balance);
balance += interest_rate; if (balance < 0) break; total_interest_earned += (interest_rate); } if (balance < 0) { cout << "I'm sorry, your account has been closed" << endl; cout << "due to having a negative balance." << endl; } else { cout << setprecision(2) << fixed << endl; cout << "Starting balance = $" << starting_balance << endl; cout << "Ending balance = $" << balance << endl; cout << "Total amount in deposits = $" << total_deposits << endl; cout << "Total amount in withdrawals = $" << total_withdrawn << endl; cout << "Total interest earned = $" << total_interest_earned; cout << endl << endl; } return 0; }
function_block-function_prefix_line
[ { "content": "//********************************************************************\n\n// This program displays a list of numbers and\n\n// their squares.\n\n//\n\n// JESUS HILARIO HERNANDEZ\n\n// Last updated: October 5, 2016\n\n//\n\n//********************************************************************\n\n\...
C++
lib/stages/pulsarNetworkProcess.cpp
james-s-willis/kotekan
155e874bb039702cec72c1785362a017548aa00a
#include <arpa/inet.h> #include <assert.h> #include <chrono> #include <cmath> #include <cstdlib> #include <cstring> #include <fstream> #include <functional> #include <iostream> #include <math.h> #include <netinet/in.h> #include <signal.h> #include <stdlib.h> #include <string.h> #include <string> #include <sys/socket.h> #include <unistd.h> using std::string; #include "Config.hpp" #include "buffer.h" #include "chimeMetadata.h" #include "errors.h" #include "fpga_header_functions.h" #include "pulsarNetworkProcess.hpp" #include "tx_utils.hpp" #include "util.h" #include "vdif_functions.h" using kotekan::bufferContainer; using kotekan::Config; using kotekan::Stage; REGISTER_KOTEKAN_STAGE(pulsarNetworkProcess); pulsarNetworkProcess::pulsarNetworkProcess(Config& config_, const string& unique_name, bufferContainer& buffer_container) : Stage(config_, unique_name, buffer_container, std::bind(&pulsarNetworkProcess::main_thread, this)) { in_buf = get_buffer("pulsar_out_buf"); register_consumer(in_buf, unique_name.c_str()); udp_pulsar_packet_size = config.get<int>(unique_name, "udp_pulsar_packet_size"); udp_pulsar_port_number = config.get<int>(unique_name, "udp_pulsar_port_number"); number_of_nodes = config.get<int>(unique_name, "number_of_nodes"); number_of_subnets = config.get<int>(unique_name, "number_of_subnets"); timesamples_per_pulsar_packet = config.get_default<int>(unique_name, "timesamples_per_pulsar_packet", 625); num_packet_per_stream = config.get_default<int>(unique_name, "num_packet_per_stream", 80); my_host_name = (char*)malloc(sizeof(char) * 100); CHECK_MEM(my_host_name); } pulsarNetworkProcess::~pulsarNetworkProcess() { free(my_host_name); for (int i = 0; i < number_of_subnets; i++) free(my_ip_address[i]); free(my_ip_address); free(socket_ids); free(myaddr); free(server_address); free(sock_fd); } void pulsarNetworkProcess::main_thread() { int rack, node, nos, my_node_id; std::vector<std::string> link_ip = config.get<std::vector<std::string>>(unique_name, "pulsar_node_ips"); int number_of_pulsar_links = link_ip.size(); INFO("number_of_pulsar_links: {:d}", number_of_pulsar_links); sock_fd = (int*)malloc(sizeof(int) * number_of_subnets); server_address = (sockaddr_in*)malloc(sizeof(sockaddr_in) * number_of_pulsar_links); myaddr = (sockaddr_in*)malloc(sizeof(sockaddr_in) * number_of_pulsar_links); socket_ids = (int*)malloc(sizeof(int) * number_of_pulsar_links); my_ip_address = (char**)malloc(sizeof(char*) * number_of_subnets); for (int i = 0; i < number_of_subnets; i++) my_ip_address[i] = (char*)malloc(sizeof(char) * 100); INFO("number of subnets {:d}\n", number_of_subnets); parse_chime_host_name(rack, node, nos, my_node_id); for (int i = 0; i < number_of_subnets; i++) { if (std::snprintf(my_ip_address[i], 100, "10.%d.%d.1%d", i + 15, nos + rack, node) > 100) { FATAL_ERROR("buffer spill over "); return; } INFO("{:s} ", my_ip_address[i]); } int frame_id = 0; uint8_t* packet_buffer = NULL; for (int i = 0; i < number_of_subnets; i++) { sock_fd[i] = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sock_fd[i] < 0) { FATAL_ERROR("network thread: socket() failed: "); return; } } for (int i = 0; i < number_of_subnets; i++) { std::memset((char*)&myaddr[i], 0, sizeof(myaddr[i])); myaddr[i].sin_family = AF_INET; inet_pton(AF_INET, my_ip_address[i], &myaddr[i].sin_addr); myaddr[i].sin_port = htons(udp_pulsar_port_number); if (bind(sock_fd[i], (struct sockaddr*)&myaddr[i], sizeof(myaddr[i])) < 0) { FATAL_ERROR("port binding failed "); return; } } for (int i = 0; i < number_of_pulsar_links; i++) { memset(&server_address[i], 0, sizeof(server_address[i])); server_address[i].sin_family = AF_INET; inet_pton(AF_INET, link_ip[i].c_str(), &server_address[i].sin_addr); server_address[i].sin_port = htons(udp_pulsar_port_number); socket_ids[i] = get_vlan_from_ip(link_ip[i].c_str()) - 15; } int n = 256 * 1024 * 1024; for (int i = 0; i < number_of_subnets; i++) { if (setsockopt(sock_fd[i], SOL_SOCKET, SO_SNDBUF, (void*)&n, sizeof(n)) < 0) { FATAL_ERROR("network thread: setsockopt() failed "); return; } } struct timespec t0, t1; t0.tv_sec = 0; t0.tv_nsec = 0; unsigned long time_interval = num_packet_per_stream * timesamples_per_pulsar_packet * 2560; int my_sequence_id = (int)(my_node_id / 128) + 2 * ((my_node_id % 128) / 8) + 32 * (my_node_id % 8); packet_buffer = wait_for_full_frame(in_buf, unique_name.c_str(), frame_id); if (packet_buffer == NULL) return; mark_frame_empty(in_buf, unique_name.c_str(), frame_id); frame_id = (frame_id + 1) % in_buf->num_frames; clock_gettime(CLOCK_REALTIME, &t0); unsigned long abs_ns = t0.tv_sec * 1e9 + t0.tv_nsec; unsigned long reminder = (abs_ns % time_interval); unsigned long wait_ns = time_interval - reminder + my_sequence_id * 600; add_nsec(t0, wait_ns); CLOCK_ABS_NANOSLEEP(CLOCK_REALTIME, t0); clock_gettime(CLOCK_MONOTONIC, &t0); VDIFHeader* header = reinterpret_cast<VDIFHeader*>(packet_buffer); int64_t vdif_last_seconds = header->seconds; int64_t vdif_last_frame = header->data_frame; while (!stop_thread) { packet_buffer = wait_for_full_frame(in_buf, unique_name.c_str(), frame_id); if (packet_buffer == NULL) break; header = reinterpret_cast<VDIFHeader*>(packet_buffer); time_interval = 2560 * (390625 * (header->seconds - vdif_last_seconds) + 625 * (header->data_frame - vdif_last_frame)); add_nsec(t0, time_interval); t1.tv_sec = t0.tv_sec; t1.tv_nsec = t0.tv_nsec; vdif_last_seconds = header->seconds; vdif_last_frame = header->data_frame; for (int frame = 0; frame < 80; frame++) { for (int beam = 0; beam < 10; beam++) { int e_beam = my_sequence_id + beam; e_beam = e_beam % 10; CLOCK_ABS_NANOSLEEP(CLOCK_MONOTONIC, t1); if (e_beam < number_of_pulsar_links) { sendto(sock_fd[socket_ids[e_beam]], &packet_buffer[(e_beam)*80 * udp_pulsar_packet_size + frame * udp_pulsar_packet_size], udp_pulsar_packet_size, 0, (struct sockaddr*)&server_address[e_beam], sizeof(server_address[e_beam])); } long wait_per_packet = (long)(153600); add_nsec(t1, wait_per_packet); } } mark_frame_empty(in_buf, unique_name.c_str(), frame_id); frame_id = (frame_id + 1) % in_buf->num_frames; } return; }
#include <arpa/inet.h> #include <assert.h> #include <chrono> #include <cmath> #include <cstdlib> #include <cstring> #include <fstream> #include <functional> #include <iostream> #include <math.h> #include <netinet/in.h> #include <signal.h> #include <stdlib.h> #include <string.h> #include <string> #include <sys/socket.h> #include <unistd.h> using std::string; #include "Config.hpp" #include "buffer.h" #include "chimeMetadata.h" #include "errors.h" #include "fpga_header_functions.h" #include "pulsarNetworkProcess.hpp" #include "tx_utils.hpp" #include "util.h" #include "vdif_functions.h" using kotekan::bufferContainer; using kotekan::Config; using kotekan::Stage; REGISTER_KOTEKAN_STAGE(pulsarNetworkProcess); pulsarNetworkProcess::pulsarNetworkProcess(Config& config_, const string& unique_name, bufferContainer& buffer_container) : Stage(config_, unique_name, buffer_container, std::bind(&pulsarNetworkProcess::main_thread, this)) { in_buf = get_buffer("pulsar_out_buf"); register_consumer(in_buf, unique_name.c_str()); udp_pulsar_packet_size = config.get<int>(unique_name, "udp_pulsar_packet_size"); udp_pulsar_port_number = config.get<int>(unique_name, "udp_pulsar_port_number"); number_of_nodes = config.get<int>(unique_name, "number_of_nodes"); number_of_subnets = config.get<int>(unique_name, "number_of_subnets"); timesamples_per_pulsar_packet = config.get_default<int>(unique_name, "timesamples_per_pulsar_packet", 625); num_packet_per_stream = config.get_default<int>(unique_name, "num_packet_per_stream", 80); my_host_name = (char*)malloc(sizeof(char) * 100); CHECK_MEM(my_host_name); } pulsarNetworkProcess::~pulsarNetworkProcess() { free(my_host_name); for (int i = 0; i < number_of_subnets; i++) free(my_ip_address[i]); free(my_ip_address); free(socket_ids); free(myaddr); free(server_address); free(sock_fd); } void pulsarNetworkProcess::main_thread() { int rack, node, nos, my_node_id; std::vector<std::string> link_ip = config.get<std::vector<std::string>>(unique_name, "pulsar_node_ips"); int number_of_pulsar_links = link_ip.size(); INFO("number_of_pulsar_links: {:d}", number_of_pulsar_links); sock_fd = (int*)malloc(sizeof(int) * number_of_subnets); server_address = (sockaddr_in*)malloc(sizeof(sockaddr_in) * number_of_pulsar_links); myaddr = (sockaddr_in*)malloc(sizeof(sockaddr_in) * number_of_pulsar_links); socket_ids = (int*)malloc(sizeof(int) * number_of_pulsar_links); my_ip_address = (char**)malloc(sizeof(char*) * number_of_subnets); for (int i = 0; i < number_of_subnets; i++) my_ip_address[i] = (char*)malloc(sizeof(char) * 100); INFO("number of subnets {:d}\n", number_of_subnets); parse_chime_host_name(rack, node, nos, my_node_id); for (int i = 0; i < number_of_subnets; i++) {
INFO("{:s} ", my_ip_address[i]); } int frame_id = 0; uint8_t* packet_buffer = NULL; for (int i = 0; i < number_of_subnets; i++) { sock_fd[i] = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); if (sock_fd[i] < 0) { FATAL_ERROR("network thread: socket() failed: "); return; } } for (int i = 0; i < number_of_subnets; i++) { std::memset((char*)&myaddr[i], 0, sizeof(myaddr[i])); myaddr[i].sin_family = AF_INET; inet_pton(AF_INET, my_ip_address[i], &myaddr[i].sin_addr); myaddr[i].sin_port = htons(udp_pulsar_port_number); if (bind(sock_fd[i], (struct sockaddr*)&myaddr[i], sizeof(myaddr[i])) < 0) { FATAL_ERROR("port binding failed "); return; } } for (int i = 0; i < number_of_pulsar_links; i++) { memset(&server_address[i], 0, sizeof(server_address[i])); server_address[i].sin_family = AF_INET; inet_pton(AF_INET, link_ip[i].c_str(), &server_address[i].sin_addr); server_address[i].sin_port = htons(udp_pulsar_port_number); socket_ids[i] = get_vlan_from_ip(link_ip[i].c_str()) - 15; } int n = 256 * 1024 * 1024; for (int i = 0; i < number_of_subnets; i++) { if (setsockopt(sock_fd[i], SOL_SOCKET, SO_SNDBUF, (void*)&n, sizeof(n)) < 0) { FATAL_ERROR("network thread: setsockopt() failed "); return; } } struct timespec t0, t1; t0.tv_sec = 0; t0.tv_nsec = 0; unsigned long time_interval = num_packet_per_stream * timesamples_per_pulsar_packet * 2560; int my_sequence_id = (int)(my_node_id / 128) + 2 * ((my_node_id % 128) / 8) + 32 * (my_node_id % 8); packet_buffer = wait_for_full_frame(in_buf, unique_name.c_str(), frame_id); if (packet_buffer == NULL) return; mark_frame_empty(in_buf, unique_name.c_str(), frame_id); frame_id = (frame_id + 1) % in_buf->num_frames; clock_gettime(CLOCK_REALTIME, &t0); unsigned long abs_ns = t0.tv_sec * 1e9 + t0.tv_nsec; unsigned long reminder = (abs_ns % time_interval); unsigned long wait_ns = time_interval - reminder + my_sequence_id * 600; add_nsec(t0, wait_ns); CLOCK_ABS_NANOSLEEP(CLOCK_REALTIME, t0); clock_gettime(CLOCK_MONOTONIC, &t0); VDIFHeader* header = reinterpret_cast<VDIFHeader*>(packet_buffer); int64_t vdif_last_seconds = header->seconds; int64_t vdif_last_frame = header->data_frame; while (!stop_thread) { packet_buffer = wait_for_full_frame(in_buf, unique_name.c_str(), frame_id); if (packet_buffer == NULL) break; header = reinterpret_cast<VDIFHeader*>(packet_buffer); time_interval = 2560 * (390625 * (header->seconds - vdif_last_seconds) + 625 * (header->data_frame - vdif_last_frame)); add_nsec(t0, time_interval); t1.tv_sec = t0.tv_sec; t1.tv_nsec = t0.tv_nsec; vdif_last_seconds = header->seconds; vdif_last_frame = header->data_frame; for (int frame = 0; frame < 80; frame++) { for (int beam = 0; beam < 10; beam++) { int e_beam = my_sequence_id + beam; e_beam = e_beam % 10; CLOCK_ABS_NANOSLEEP(CLOCK_MONOTONIC, t1); if (e_beam < number_of_pulsar_links) { sendto(sock_fd[socket_ids[e_beam]], &packet_buffer[(e_beam)*80 * udp_pulsar_packet_size + frame * udp_pulsar_packet_size], udp_pulsar_packet_size, 0, (struct sockaddr*)&server_address[e_beam], sizeof(server_address[e_beam])); } long wait_per_packet = (long)(153600); add_nsec(t1, wait_per_packet); } } mark_frame_empty(in_buf, unique_name.c_str(), frame_id); frame_id = (frame_id + 1) % in_buf->num_frames; } return; }
if (std::snprintf(my_ip_address[i], 100, "10.%d.%d.1%d", i + 15, nos + rack, node) > 100) { FATAL_ERROR("buffer spill over "); return; }
if_condition
[]
C++
chrome/browser/chromeos/cros_settings.cc
SlimKatLegacy/android_external_chromium
bc611cda58cc18d0dbaa8a7aee05eb3c0742e573
#include "chrome/browser/chromeos/cros_settings.h" #include "base/lazy_instance.h" #include "base/string_util.h" #include "base/values.h" #include "chrome/browser/chromeos/cros_settings_provider.h" #include "chrome/browser/chromeos/user_cros_settings_provider.h" #include "content/common/notification_details.h" #include "content/common/notification_source.h" #include "content/common/notification_type.h" namespace chromeos { static base::LazyInstance<CrosSettings> g_cros_settings( base::LINKER_INITIALIZED); CrosSettings* CrosSettings::Get() { return g_cros_settings.Pointer(); } bool CrosSettings::IsCrosSettings(const std::string& path) { return StartsWithASCII(path, kCrosSettingsPrefix, true); } void CrosSettings::FireObservers(const char* path) { DCHECK(CalledOnValidThread()); std::string path_str(path); SettingsObserverMap::iterator observer_iterator = settings_observers_.find(path_str); if (observer_iterator == settings_observers_.end()) return; NotificationObserverList::Iterator it(*(observer_iterator->second)); NotificationObserver* observer; while ((observer = it.GetNext()) != NULL) { observer->Observe(NotificationType::SYSTEM_SETTING_CHANGED, Source<CrosSettings>(this), Details<std::string>(&path_str)); } } void CrosSettings::Set(const std::string& path, Value* in_value) { DCHECK(CalledOnValidThread()); CrosSettingsProvider* provider; provider = GetProvider(path); if (provider) { provider->Set(path, in_value); } } void CrosSettings::SetBoolean(const std::string& path, bool in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateBooleanValue(in_value)); } void CrosSettings::SetInteger(const std::string& path, int in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateIntegerValue(in_value)); } void CrosSettings::SetDouble(const std::string& path, double in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateDoubleValue(in_value)); } void CrosSettings::SetString(const std::string& path, const std::string& in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateStringValue(in_value)); } bool CrosSettings::AddSettingsProvider(CrosSettingsProvider* provider) { DCHECK(CalledOnValidThread()); providers_.push_back(provider); return true; } bool CrosSettings::RemoveSettingsProvider(CrosSettingsProvider* provider) { DCHECK(CalledOnValidThread()); std::vector<CrosSettingsProvider*>::iterator it = std::find(providers_.begin(), providers_.end(), provider); if (it != providers_.end()) { providers_.erase(it); return true; } return false; } void CrosSettings::AddSettingsObserver(const char* path, NotificationObserver* obs) { DCHECK(path); DCHECK(obs); DCHECK(CalledOnValidThread()); if (!GetProvider(std::string(path))) { NOTREACHED() << "Trying to add an observer for an unregistered setting: " << path; return; } NotificationObserverList* observer_list = NULL; SettingsObserverMap::iterator observer_iterator = settings_observers_.find(path); if (observer_iterator == settings_observers_.end()) { observer_list = new NotificationObserverList; settings_observers_[path] = observer_list; } else { observer_list = observer_iterator->second; } NotificationObserverList::Iterator it(*observer_list); NotificationObserver* existing_obs; while ((existing_obs = it.GetNext()) != NULL) { DCHECK(existing_obs != obs) << path << " observer already registered"; if (existing_obs == obs) return; } observer_list->AddObserver(obs); } void CrosSettings::RemoveSettingsObserver(const char* path, NotificationObserver* obs) { DCHECK(CalledOnValidThread()); SettingsObserverMap::iterator observer_iterator = settings_observers_.find(path); if (observer_iterator == settings_observers_.end()) { return; } NotificationObserverList* observer_list = observer_iterator->second; observer_list->RemoveObserver(obs); } CrosSettingsProvider* CrosSettings::GetProvider( const std::string& path) const { for (size_t i = 0; i < providers_.size(); ++i) { if (providers_[i]->HandlesSetting(path)) { return providers_[i]; } } return NULL; } bool CrosSettings::Get(const std::string& path, Value** out_value) const { DCHECK(CalledOnValidThread()); CrosSettingsProvider* provider; provider = GetProvider(path); if (provider) { return provider->Get(path, out_value); } return false; } bool CrosSettings::GetBoolean(const std::string& path, bool* bool_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsBoolean(bool_value); } bool CrosSettings::GetInteger(const std::string& path, int* out_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsInteger(out_value); } bool CrosSettings::GetDouble(const std::string& path, double* out_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsDouble(out_value); } bool CrosSettings::GetString(const std::string& path, std::string* out_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsString(out_value); } CrosSettings::CrosSettings() { } CrosSettings::~CrosSettings() { DCHECK(providers_.empty()); } }
#include "chrome/browser/chromeos/cros_settings.h" #include "base/lazy_instance.h" #include "base/string_util.h" #include "base/values.h" #include "chrome/browser/chromeos/cros_settings_provider.h" #include "chrome/browser/chromeos/user_cros_settings_provider.h" #include "content/common/notification_details.h" #include "content/common/notification_source.h" #include "content/common/notification_type.h" namespace chromeos { static base::LazyInstance<CrosSettings> g_cros_settings( base::LINKER_INITIALIZED); CrosSettings* CrosSettings::Get() { return g_cros_settings.Pointer(); } bool CrosSettings::IsCrosSettings(const std::string& path) { return StartsWithASCII(path, kCrosSettingsPrefix, true); } void CrosSettings::FireObservers(const char* path) { DCHECK(CalledOnValidThread()); std::string path_str(path); SettingsObserverMap::iterator observer_iterator = settings_observers_.find(path_str); if (observer_iterator == settings_observers_.end()) return; NotificationObserverList::Iterator it(*(observer_iterator->second)); NotificationObserver* observer; while ((observer = it.GetNext()) != NULL) { observer->Observe(NotificationType::SYSTEM_SETTING_CHANGED, Source<CrosSettings>(this), Details<std::string>(&path_str)); } } void CrosSettings::Set(const std::string& path, Value* in_value) { DCHECK(CalledOnValidThread()); CrosSettingsProvider* provider; provider = GetProvider(path); if (provider) { provider->Set(path, in_value); } } void CrosSettings::SetBoolean(const std::string& path, bool in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateBooleanValue(in_value)); } void CrosSettings::SetInteger(const std::string& path, int in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateIntegerValue(in_value)); } void CrosSettings::SetDouble(const std::string& path, double in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateDoubleValue(in_value)); } void CrosSettings::SetString(const std::string& path, const std::string& in_value) { DCHECK(CalledOnValidThread()); Set(path, Value::CreateStringValue(in_value)); } bool CrosSettings::AddSettingsProvider(CrosSettingsProvider* provider) { DCHECK(CalledOnValidThread()); providers_.push_back(provider); return true; } bool CrosSettings::RemoveSettingsProvider(CrosSettingsProvider* provider) { DCHECK(CalledOnValidThread()); std::vector<CrosSettingsProvider*>::iterator it = std::find(providers_.begin(), providers_.end(), provider); if (it != providers_.end()) { providers_.erase(it); return true; } return false; } void CrosSettings::AddSettingsObserver(const char* path, NotificationObserver* obs) { DCHECK(path); DCHECK(obs); DCHECK(CalledOnValidThread()); if (!GetProvider(std::string(path))) { NOTREACHED() << "Trying to add an observer for an unregistered setting: " << path; return; } NotificationObserverList* observer_list = NULL; SettingsObserverMap::iterator observer_iterator = settings_observers_.find(path); if (observer_iterator == settings_observers_.end()) { observer_list = new NotificationObserverList; settings_observers_[path] = observer_list; } else { observer_list = observer_iterator->second; } NotificationObserverList::Iterator it(*observer_list); NotificationObserver* existing_obs; while ((existing_obs = it.GetNext()) != NULL) { DCHECK(existing_obs != obs) << path << " observer already registered"; if (existing_obs == obs) return; } observer_list->AddObserver(obs); } void CrosSettings::RemoveSettingsObserver(const char* path, NotificationObserver* obs) { DCHECK(CalledOnValidThread()); SettingsObserverMap::iterator observer_iterator = settings_observers_.find(path); if (observer_iterator == settings_observers_.end()) { return; } NotificationObserverList* observer_list = observer_iterator->second; observer_list->RemoveObserver(obs); } CrosSettingsProvider* CrosSettings::GetProvider( const std::string& path) const { for (size_t i = 0; i < providers_.size(); ++i) { if (providers_[i]->HandlesSetting(path)) { return providers_[i]; } } return NULL; } bool
bool CrosSettings::GetBoolean(const std::string& path, bool* bool_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsBoolean(bool_value); } bool CrosSettings::GetInteger(const std::string& path, int* out_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsInteger(out_value); } bool CrosSettings::GetDouble(const std::string& path, double* out_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsDouble(out_value); } bool CrosSettings::GetString(const std::string& path, std::string* out_value) const { DCHECK(CalledOnValidThread()); Value* value; if (!Get(path, &value)) return false; return value->GetAsString(out_value); } CrosSettings::CrosSettings() { } CrosSettings::~CrosSettings() { DCHECK(providers_.empty()); } }
CrosSettings::Get(const std::string& path, Value** out_value) const { DCHECK(CalledOnValidThread()); CrosSettingsProvider* provider; provider = GetProvider(path); if (provider) { return provider->Get(path, out_value); } return false; }
function_block-function_prefixed
[ { "content": "struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; };\n\n\n\ntemplate <GTEST_1_TYPENAMES_(T)>\n", "file_path": "testing/gtest/include/gtest/internal/gtest-tuple.h", "rank": 0, "score": 425778.8998875817 }, { "content": "struct tuple_size<GTEST_3_TUPLE_(T)> { sta...
C++
aha/main.cpp
dlarudgus20/newly-aha
4d80bf992af3d8e7a6ddcca3c38d5959059ec66f
#include <iostream> #include <string> #include <type_traits> #include <variant> #include <locale> #include <boost/program_options.hpp> #include <boost/iterator/transform_iterator.hpp> namespace bpo = boost::program_options; #include "../libahafront/aha/front/source.hpp" #include "../libahafront/aha/front/lexer.hpp" #include "../libahafront/aha/front/parser.hpp" using namespace aha::front; inline std::string utf32narrow(std::u32string_view str) { auto fn = [](char32_t ch) { return static_cast<char>(ch); }; auto tbeg = boost::iterators::make_transform_iterator(str.begin(), fn); auto tend = boost::iterators::make_transform_iterator(str.end(), fn); return std::string(tbeg, tend); }; int main(int argc, char* argv[]) { repl_source src; lexer ll; parser yy; auto get_input = [&src] (bool fresh) { std::string str; std::cout << (fresh ? ">> " : "-- "); if (!getline(std::cin, str)) { src.feedEof(); } else { if (fresh && str == ":{") { while (true) { std::cout << "-- "; if (!getline(std::cin, str)) { src.feedEof(); break; } else if (str == ":}") { break; } else { src.feedString(str + "\n"); } } } else { src.feedString(str + "\n"); } } }; bool interpolated = false; auto print_error = [](source_positional_error& ex) { auto pos = ex.getPosition(); std::cerr << ex.getSource().getName() << ":" << (pos.line + 1) << ":" << (pos.col + 1) << ": " << ex.what() << std::endl; }; while (true) { try { bool fresh = true; std::optional<token> tok; while (true) { tok = ll.lex(src); if (tok) break; auto rs = ll.getLastResult(); if (rs == lex_result::exhausted) { get_input(fresh); fresh = false; } else { ll.clearAll(); src.clearAll(); std::cin.clear(); fresh = true; } } if (std::holds_alternative<token_indent>(tok->data)) { auto t = std::get<token_indent>(tok->data); std::cout << "indent { " << t.level << " }\n"; } else if (std::holds_alternative<token_newline>(tok->data)) { auto t = std::get<token_newline>(tok->data); std::cout << "newline {}\n"; } else if (std::holds_alternative<token_punct>(tok->data)) { auto t = std::get<token_punct>(tok->data); auto str = utf32narrow(t.str); std::cout << "punct { '" << str << "' }\n"; } else if (std::holds_alternative<token_keyword>(tok->data)) { auto t = std::get<token_keyword>(tok->data); auto str = utf32narrow(t.str); std::cout << "keyword { '" << str << "' }\n"; } else if (std::holds_alternative<token_contextual_keyword>(tok->data)) { auto t = std::get<token_contextual_keyword>(tok->data); auto str = utf32narrow(t.str); std::cout << "contextual keyword { '" << str << "' }\n"; } else if (std::holds_alternative<token_identifier>(tok->data)) { auto t = std::get<token_identifier>(tok->data); auto str = utf32narrow(t.str); std::cout << "identifier { '" << str << "' }\n"; } else if (std::holds_alternative<token_number>(tok->data)) { auto t = std::get<token_number>(tok->data); if (!t.is_float) { std::cout << "integer [radix:" << t.radix << "] { " << t.integer << t.postfix << " }\n"; } else { std::cout << "float [radix:" << t.radix << "] { " << t.integer; if (!t.fraction.empty()) std::cout << "." << t.fraction; if (!t.exponent.empty()) std::cout << (t.radix == 10 ? "e" : "p") << t.exponent; std::cout << t.postfix << " }\n"; } } else if (std::holds_alternative<token_normal_string>(tok->data)) { auto t = std::get<token_normal_string>(tok->data); auto str = utf32narrow(t.str); auto deli = static_cast<char>(t.delimiter); std::cout << "normal string { " << deli << str << deli << " }\n"; } else if (std::holds_alternative<token_raw_string>(tok->data)) { auto t = std::get<token_raw_string>(tok->data); auto str = utf32narrow(t.str); auto deli = static_cast<char>(t.delimiter); std::cout << "raw string { " << deli << str << deli << " }\n"; } else if (std::holds_alternative<token_interpol_string_start>(tok->data)) { auto t = std::get<token_interpol_string_start>(tok->data); auto str = utf32narrow(t.str); std::cout << "interpolated string (start) { `" << str << "{ }\n"; interpolated = true; } else if (std::holds_alternative<token_interpol_string_mid>(tok->data)) { auto t = std::get<token_interpol_string_mid>(tok->data); auto str = utf32narrow(t.str); std::cout << "interpolated string (mid) { }" << str << "${ }\n"; } else if (std::holds_alternative<token_interpol_string_end>(tok->data)) { auto t = std::get<token_interpol_string_end>(tok->data); auto str = utf32narrow(t.str); std::cout << "interpolated string (end) { " << (interpolated ? '}' : '`') << str << "` }\n"; interpolated = false; } else { throw std::logic_error("add handler ..."); } } catch (lexer_error& ex) { print_error(ex); ll.clearBuffer(); } catch (invalid_byteseq& ex) { print_error(ex); src.clearBuffer(); } } return 0; }
#include <iostream> #include <string> #include <type_traits> #include <variant> #include <locale> #include <boost/program_options.hpp> #include <boost/iterator/transform_iterator.hpp> namespace bpo = boost::program_options; #include "../libahafront/aha/front/source.hpp" #include "../libahafront/aha/front/lexer.hpp" #include "../libahafront/aha/front/parser.hpp" using namespace aha::front;
; int main(int argc, char* argv[]) { repl_source src; lexer ll; parser yy; auto get_input = [&src] (bool fresh) { std::string str; std::cout << (fresh ? ">> " : "-- "); if (!getline(std::cin, str)) { src.feedEof(); } else { if (fresh && str == ":{") { while (true) { std::cout << "-- "; if (!getline(std::cin, str)) { src.feedEof(); break; } else if (str == ":}") { break; } else { src.feedString(str + "\n"); } } } else { src.feedString(str + "\n"); } } }; bool interpolated = false; auto print_error = [](source_positional_error& ex) { auto pos = ex.getPosition(); std::cerr << ex.getSource().getName() << ":" << (pos.line + 1) << ":" << (pos.col + 1) << ": " << ex.what() << std::endl; }; while (true) { try { bool fresh = true; std::optional<token> tok; while (true) { tok = ll.lex(src); if (tok) break; auto rs = ll.getLastResult(); if (rs == lex_result::exhausted) { get_input(fresh); fresh = false; } else { ll.clearAll(); src.clearAll(); std::cin.clear(); fresh = true; } } if (std::holds_alternative<token_indent>(tok->data)) { auto t = std::get<token_indent>(tok->data); std::cout << "indent { " << t.level << " }\n"; } else if (std::holds_alternative<token_newline>(tok->data)) { auto t = std::get<token_newline>(tok->data); std::cout << "newline {}\n"; } else if (std::holds_alternative<token_punct>(tok->data)) { auto t = std::get<token_punct>(tok->data); auto str = utf32narrow(t.str); std::cout << "punct { '" << str << "' }\n"; } else if (std::holds_alternative<token_keyword>(tok->data)) { auto t = std::get<token_keyword>(tok->data); auto str = utf32narrow(t.str); std::cout << "keyword { '" << str << "' }\n"; } else if (std::holds_alternative<token_contextual_keyword>(tok->data)) { auto t = std::get<token_contextual_keyword>(tok->data); auto str = utf32narrow(t.str); std::cout << "contextual keyword { '" << str << "' }\n"; } else if (std::holds_alternative<token_identifier>(tok->data)) { auto t = std::get<token_identifier>(tok->data); auto str = utf32narrow(t.str); std::cout << "identifier { '" << str << "' }\n"; } else if (std::holds_alternative<token_number>(tok->data)) { auto t = std::get<token_number>(tok->data); if (!t.is_float) { std::cout << "integer [radix:" << t.radix << "] { " << t.integer << t.postfix << " }\n"; } else { std::cout << "float [radix:" << t.radix << "] { " << t.integer; if (!t.fraction.empty()) std::cout << "." << t.fraction; if (!t.exponent.empty()) std::cout << (t.radix == 10 ? "e" : "p") << t.exponent; std::cout << t.postfix << " }\n"; } } else if (std::holds_alternative<token_normal_string>(tok->data)) { auto t = std::get<token_normal_string>(tok->data); auto str = utf32narrow(t.str); auto deli = static_cast<char>(t.delimiter); std::cout << "normal string { " << deli << str << deli << " }\n"; } else if (std::holds_alternative<token_raw_string>(tok->data)) { auto t = std::get<token_raw_string>(tok->data); auto str = utf32narrow(t.str); auto deli = static_cast<char>(t.delimiter); std::cout << "raw string { " << deli << str << deli << " }\n"; } else if (std::holds_alternative<token_interpol_string_start>(tok->data)) { auto t = std::get<token_interpol_string_start>(tok->data); auto str = utf32narrow(t.str); std::cout << "interpolated string (start) { `" << str << "{ }\n"; interpolated = true; } else if (std::holds_alternative<token_interpol_string_mid>(tok->data)) { auto t = std::get<token_interpol_string_mid>(tok->data); auto str = utf32narrow(t.str); std::cout << "interpolated string (mid) { }" << str << "${ }\n"; } else if (std::holds_alternative<token_interpol_string_end>(tok->data)) { auto t = std::get<token_interpol_string_end>(tok->data); auto str = utf32narrow(t.str); std::cout << "interpolated string (end) { " << (interpolated ? '}' : '`') << str << "` }\n"; interpolated = false; } else { throw std::logic_error("add handler ..."); } } catch (lexer_error& ex) { print_error(ex); ll.clearBuffer(); } catch (invalid_byteseq& ex) { print_error(ex); src.clearBuffer(); } } return 0; }
inline std::string utf32narrow(std::u32string_view str) { auto fn = [](char32_t ch) { return static_cast<char>(ch); }; auto tbeg = boost::iterators::make_transform_iterator(str.begin(), fn); auto tend = boost::iterators::make_transform_iterator(str.end(), fn); return std::string(tbeg, tend); }
function_block-full_function
[ { "content": "// SOFTWARE.\n\n\n\n#pragma once\n\n\n\n#include <string>\n\n#include <string_view>\n\n#include <vector>\n\n#include <deque>\n\n#include <optional>\n\n#include <stdexcept>\n\n\n\nnamespace aha::front\n\n{\n", "file_path": "libahafront/aha/front/source.hpp", "rank": 1, "score": 9.501183...
C++
cornellbox/Eyeo2012/Shockwaves/src/ShockwavesApp.cpp
eighteight/CinderEigh
d9dfc6a0ad9a9e6c5b82624971127f0335d91639
#include "cinder/app/AppBasic.h" #include "cinder/gl/gl.h" #include "cinder/gl/Texture.h" #include "cinder/Text.h" #include "cinder/gl/Fbo.h" #include "cinder/gl/Vbo.h" #include "cinder/gl/GlslProg.h" #include "cinder/ImageIo.h" #include "cinder/Utilities.h" #include "cinder/Camera.h" #include "cinder/Rand.h" #include "Resources.h" #include "CubeMap.h" #include "Controller.h" #include "Room.h" #include "SpringCam.h" using namespace ci; using namespace ci::app; using namespace std; #define APP_WIDTH 1280 #define APP_HEIGHT 720 #define ROOM_FBO_RES 2 #define GRID_DIM 45 class ShockwavesApp : public AppBasic { public: virtual void prepareSettings( Settings *settings ); virtual void setup(); void initVbo(); virtual void mouseDown( MouseEvent event ); virtual void mouseUp( MouseEvent event ); virtual void mouseMove( MouseEvent event ); virtual void mouseDrag( MouseEvent event ); virtual void mouseWheel( MouseEvent event ); virtual void keyDown( KeyEvent event ); virtual void update(); void drawIntoRoomFbo(); virtual void draw(); void drawInfoPanel(); SpringCam mSpringCam; gl::GlslProg mRoomShader; gl::GlslProg mShockwaveShader; gl::GlslProg mNodeShader; gl::Texture mSmokeTex; gl::Texture mGlowTex; gl::Texture mIconTex; CubeMap mCubeMap; Room mRoom; gl::Fbo mRoomFbo; Controller mController; gl::VboMesh mVboMesh; Vec2f mMousePos, mMouseDownPos, mMouseOffset; bool mMousePressed; }; void ShockwavesApp::prepareSettings( Settings *settings ) { settings->setWindowSize( APP_WIDTH, APP_HEIGHT ); settings->setBorderless(); } void ShockwavesApp::setup() { mSpringCam = SpringCam( -450.0f, getWindowAspectRatio() ); try { mRoomShader = gl::GlslProg( loadResource( "room.vert" ), loadResource( "room.frag" ) ); mShockwaveShader = gl::GlslProg( loadResource( "shockwave.vert" ), loadResource( "shockwave.frag" ) ); mNodeShader = gl::GlslProg( loadResource( "node.vert" ), loadResource( "node.frag" ) ); } catch( gl::GlslProgCompileExc e ) { std::cout << e.what() << std::endl; quit(); } gl::Texture::Format mipFmt; mipFmt.enableMipmapping( true ); mipFmt.setMinFilter( GL_LINEAR_MIPMAP_LINEAR ); mipFmt.setMagFilter( GL_LINEAR ); mIconTex = gl::Texture( loadImage( loadResource( "iconShockwaves.png" ) ), mipFmt ); mSmokeTex = gl::Texture( loadImage( loadResource( "smoke.png" ) ), mipFmt ); mGlowTex = gl::Texture( loadImage( loadResource( "glow.png" ) ), mipFmt ); mCubeMap = CubeMap( GLsizei(512), GLsizei(512), Surface8u( loadImage( loadResource( RES_CUBE1_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE2_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE3_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE4_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE5_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE6_ID ) ) ) ); gl::Fbo::Format roomFormat; roomFormat.setColorInternalFormat( GL_RGB ); mRoomFbo = gl::Fbo( APP_WIDTH/ROOM_FBO_RES, APP_HEIGHT/ROOM_FBO_RES, roomFormat ); bool isPowerOn = true; bool isGravityOn = true; mRoom = Room( Vec3f( 350.0f, 200.0f, 350.0f ), isPowerOn, isGravityOn ); mRoom.init(); mMousePos = Vec2f::zero(); mMouseDownPos = Vec2f::zero(); mMouseOffset = Vec2f::zero(); mMousePressed = false; mController.init( &mRoom, GRID_DIM ); } void ShockwavesApp::initVbo() { gl::VboMesh::Layout layout; layout.setStaticPositions(); layout.setStaticNormals(); int numVertices = GRID_DIM * GRID_DIM; mVboMesh = gl::VboMesh( numVertices * 8 * 3, 0, layout, GL_TRIANGLES ); float s = 10.0f; Vec3f p0( 0.0f, s, 0.0f ); Vec3f p1( -s, 0.0f, 0.0f ); Vec3f p2( 0.0f, 0.0f, s ); Vec3f p3( s, 0.0f, 0.0f ); Vec3f p4( 0.0f, 0.0f, -s ); Vec3f p5( 0.0f, -s, 0.0f ); Vec3f n; Vec3f n0 = Vec3f( 0.0f, 0.0f, 1.0f ); Vec3f n1 = Vec3f(-1.0f,-1.0f, 0.0f ); Vec3f n2 = Vec3f(-1.0f, 1.0f, 0.0f ); Vec3f n3 = Vec3f( 1.0f, 1.0f, 0.0f ); Vec3f n4 = Vec3f( 1.0f,-1.0f, 0.0f ); Vec3f n5 = Vec3f( 0.0f, 0.0f,-1.0f ); vector<Vec3f> positions; vector<Vec3f> normals; for( int x = 0; x < GRID_DIM; ++x ) { for( int y = 0; y < GRID_DIM; ++y ) { positions.push_back( p0 ); positions.push_back( p1 ); positions.push_back( p2 ); n = ( p0 + p1 + p2 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p0 ); positions.push_back( p2 ); positions.push_back( p3 ); n = ( p0 + p2 + p3 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p0 ); positions.push_back( p3 ); positions.push_back( p4 ); n = ( p0 + p3 + p4 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p0 ); positions.push_back( p4 ); positions.push_back( p1 ); n = ( p0 + p4 + p1 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p1 ); positions.push_back( p4 ); n = ( p5 + p1 + p4 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p2 ); positions.push_back( p1 ); n = ( p5 + p2 + p1 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p3 ); positions.push_back( p2 ); n = ( p5 + p3 + p2 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p4 ); positions.push_back( p3 ); n = ( p5 + p4 + p3 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); } } mVboMesh.bufferPositions( positions ); mVboMesh.bufferNormals( normals ); mVboMesh.unbindBuffers(); } void ShockwavesApp::mouseDown( MouseEvent event ) { mMouseDownPos = event.getPos(); mMousePressed = true; mMouseOffset = Vec2f::zero(); } void ShockwavesApp::mouseUp( MouseEvent event ) { mMousePressed = false; mMouseOffset = Vec2f::zero(); } void ShockwavesApp::mouseMove( MouseEvent event ) { mMousePos = event.getPos(); } void ShockwavesApp::mouseDrag( MouseEvent event ) { mouseMove( event ); mMouseOffset = ( mMousePos - mMouseDownPos ) * 0.4f; } void ShockwavesApp::mouseWheel( MouseEvent event ) { float dWheel = event.getWheelIncrement(); mRoom.adjustTimeMulti( dWheel ); } void ShockwavesApp::keyDown( KeyEvent event ) { switch( event.getChar() ){ case '1': mController.preset( 1 ); break; case '2': mController.preset( 2 ); break; case ' ': mRoom.togglePower(); break; case 's': mController.explode(); break; default: break; } switch( event.getCode() ){ case KeyEvent::KEY_UP: mSpringCam.setEye( mRoom.getCornerCeilingPos() ); break; case KeyEvent::KEY_DOWN: mSpringCam.setEye( mRoom.getCornerFloorPos() ); break; case KeyEvent::KEY_RIGHT: mSpringCam.resetEye(); break; default: break; } } void ShockwavesApp::update() { if( mMousePressed ) mSpringCam.dragCam( ( mMouseOffset ) * 0.02f, ( mMouseOffset ).length() * 0.02f ); mSpringCam.update( 0.5f ); mRoom.update(); mController.update( mRoom.getTimeDelta(), mRoom.getTick() ); drawIntoRoomFbo(); } void ShockwavesApp::drawIntoRoomFbo() { mRoomFbo.bindFramebuffer(); gl::clear( ColorA( 0.0f, 0.0f, 0.0f, 0.0f ), true ); gl::setMatricesWindow( mRoomFbo.getSize(), false ); gl::setViewport( mRoomFbo.getBounds() ); gl::disableAlphaBlending(); gl::enable( GL_TEXTURE_2D ); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK ); Matrix44f m; m.setToIdentity(); m.scale( mRoom.getDims() ); mCubeMap.bind(); mRoomShader.bind(); mRoomShader.uniform( "cubeMap", 0 ); mRoomShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix ); mRoomShader.uniform( "mMatrix", m ); mRoomShader.uniform( "eyePos", mSpringCam.mEye ); mRoomShader.uniform( "roomDims", mRoom.getDims() ); mRoomShader.uniform( "power", mRoom.getPower() ); mRoomShader.uniform( "lightPower", mRoom.getLightPower() ); mRoomShader.uniform( "timePer", mRoom.getTimePer() * 1.5f + 0.5f ); mRoom.draw(); mRoomShader.unbind(); mRoomFbo.unbindFramebuffer(); glDisable( GL_CULL_FACE ); } void ShockwavesApp::draw() { gl::clear( ColorA( 0.1f, 0.1f, 0.1f, 0.0f ), true ); gl::setMatricesWindow( getWindowSize(), false ); gl::setViewport( getWindowBounds() ); gl::disableDepthRead(); gl::disableDepthWrite(); gl::enableAlphaBlending(); gl::enable( GL_TEXTURE_2D ); gl::color( ColorA( 1.0f, 1.0f, 1.0f, 1.0f ) ); mRoomFbo.bindTexture(); gl::drawSolidRect( getWindowBounds() ); gl::setMatrices( mSpringCam.getCam() ); drawInfoPanel(); gl::disable( GL_TEXTURE_2D ); gl::enableDepthRead(); gl::enableDepthWrite(); mNodeShader.bind(); mNodeShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix ); mNodeShader.uniform( "eyePos", mSpringCam.getEye() ); mNodeShader.uniform( "power", mRoom.getPower() ); mNodeShader.uniform( "roomDims", mRoom.getDims() ); mController.drawNodes( &mNodeShader ); mNodeShader.unbind(); gl::color( ColorA( 0.0f, 0.0f, 0.0f, 0.4f ) ); mController.drawConnections(); gl::disableDepthWrite(); gl::color( ColorA( 1.0f, 1.0f, 1.0f, 1.0f ) ); gl::enable( GL_CULL_FACE ); glCullFace( GL_FRONT ); mShockwaveShader.bind(); mShockwaveShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix ); mShockwaveShader.uniform( "eyePos", mSpringCam.getEye() ); mShockwaveShader.uniform( "power", mRoom.getPower() ); mShockwaveShader.uniform( "roomDims", mRoom.getDims() ); mController.drawShockwaves( &mShockwaveShader ); mShockwaveShader.unbind(); gl::disable( GL_CULL_FACE ); gl::enable( GL_TEXTURE_2D ); Vec3f right, up; mSpringCam.mCam.getBillboardVectors( &right, &up ); mSmokeTex.bind(); mController.drawSmokes( right, up ); gl::enableAdditiveBlending(); mGlowTex.bind(); mController.drawGlows( right, up ); if( getElapsedFrames()%60 == 59 ) std::cout << "FPS: " << getAverageFps() << std::endl; } void ShockwavesApp::drawInfoPanel() { gl::pushMatrices(); gl::translate( mRoom.getDims() ); gl::scale( Vec3f( -1.0f, -1.0f, 1.0f ) ); gl::color( Color( 1.0f, 1.0f, 1.0f ) * ( 1.0 - mRoom.getPower() ) ); gl::enableAlphaBlending(); float iconWidth = 50.0f; float X0 = 15.0f; float X1 = X0 + iconWidth; float Y0 = 50.0f; float Y1 = Y0 + iconWidth; float c = mRoom.getPower() * 0.5f + 0.5f; gl::color( ColorA( c, c, c, 0.5f ) ); gl::draw( mIconTex, Rectf( X0, Y0, X1, Y1 ) ); c = mRoom.getPower(); gl::color( ColorA( c, c, c, 0.5f ) ); gl::disable( GL_TEXTURE_2D ); float timePer = mRoom.getTimePer(); gl::drawSolidRect( Rectf( Vec2f( X0, Y1 + 2.0f ), Vec2f( X0 + timePer * ( iconWidth ), Y1 + 2.0f + 4.0f ) ) ); float fpsPer = getAverageFps()/60.0f; gl::drawSolidRect( Rectf( Vec2f( X0, Y1 + 4.0f + 4.0f ), Vec2f( X0 + fpsPer * ( iconWidth ), Y1 + 4.0f + 6.0f ) ) ); gl::popMatrices(); } CINDER_APP_BASIC( ShockwavesApp, RendererGl )
#include "cinder/app/AppBasic.h" #include "cinder/gl/gl.h" #include "cinder/gl/Texture.h" #include "cinder/Text.h" #include "cinder/gl/Fbo.h" #include "cinder/gl/Vbo.h" #include "cinder/gl/GlslProg.h" #include "cinder/ImageIo.h" #include "cinder/Utilities.h" #include "cinder/Camera.h" #include "cinder/Rand.h" #include "Resources.h" #include "CubeMap.h" #include "Controller.h" #include "Room.h" #include "SpringCam.h" using namespace ci; using namespace ci::app; using namespace std; #define APP_WIDTH 1280 #define APP_HEIGHT 720 #define ROOM_FBO_RES 2 #define GRID_DIM 45 class ShockwavesApp : public AppBasic { public: virtual void prepareSettings( Settings *settings ); virtual void setup(); void initVbo(); virtual void mouseDown( MouseEvent event ); virtual void mouseUp( MouseEvent event ); virtual void mouseMove( MouseEvent event ); virtual void mouseDrag( MouseEvent event ); virtual void mouseWheel( MouseEvent event ); virtual void keyDown( KeyEvent event ); virtual void update(); void drawIntoRoomFbo(); virtual void draw(); void drawInfoPanel(); SpringCam mSpringCam; gl::GlslProg mRoomShader; gl::GlslProg mShockwaveShader; gl::GlslProg mNodeShader; gl::Texture mSmokeTex; gl::Texture mGlowTex; gl::Texture mIconTex; CubeMap mCubeMap; Room mRoom; gl::Fbo mRoomFbo; Controller mController; gl::VboMesh mVboMesh; Vec2f mMousePos, mMouseDownPos, mMouseOffset; bool mMousePressed; }; void ShockwavesApp::prepareSettings( Settings *settings ) { settings->setWindowSize( APP_WIDTH, APP_HEIGHT ); settings->setBorderless(); } void ShockwavesApp::setup() { mSpringCam = SpringCam( -450.0f, getWindowAspectRatio() ); try { mRoomShader = gl::GlslProg( loadResource( "room.vert" ), loadResource( "room.frag" ) ); mShockwaveShader = gl::GlslProg( loadResource( "shockwave.vert" ), loadResource( "shockwave.frag" ) ); mNodeShader = gl::GlslProg( loadResource( "node.vert" ), loadResource( "node.frag" ) ); } catch( gl::GlslProgCompileExc e ) { std::cout << e.what() << std::endl; quit(); } gl::Texture::Format mipFmt; mipFmt.enableMipmapping( true ); mipFmt.setMinFilter( GL_LINEAR_MIPMAP_LINEAR ); mipFmt.setMagFilter( GL_LINEAR ); mIconTex = gl::Texture( loadImage( loadResource( "iconShockwaves.png" ) ), mipFmt ); mSmokeTex = gl::Texture( loadImage( loadResource( "smoke.png" ) ), mipFmt ); mGlowTex = gl::Texture( loadImage( loadResource( "glow.png" ) ), mipFmt ); mCubeMap = CubeMap( GLsizei(512), GLsizei(512), Surface8u( loadImage( loadResource( RES_CUBE1_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE2_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE3_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE4_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE5_ID ) ) ), Surface8u( loadImage( loadResource( RES_CUBE6_ID ) ) ) ); gl::Fbo::Format roomFormat; roomFormat.setColorInternalFormat( GL_RGB ); mRoomFbo = gl::Fbo( APP_WIDTH/ROOM_FBO_RES, APP_HEIGHT/ROOM_FBO_RES, roomFormat ); bool isPowerOn = true; bool isGravityOn = true; mRoom = Room( Vec3f( 350.0f, 200.0f, 350.0f ), isPowerOn, isGravityOn ); mRoom.init(); mMousePos = Vec2f::zero(); mMouseDownPos = Vec2f::zero(); mMouseOffset = Vec2f::zero(); mMousePressed = false; mController.init( &mRoom, GRID_DIM ); } void ShockwavesApp::initVbo() { gl::VboMesh::Layout layout; layout.setStaticPositions(); layout.setStaticNormals(); int numVertices = GRID_DIM * GRID
oid ShockwavesApp::keyDown( KeyEvent event ) { switch( event.getChar() ){ case '1': mController.preset( 1 ); break; case '2': mController.preset( 2 ); break; case ' ': mRoom.togglePower(); break; case 's': mController.explode(); break; default: break; } switch( event.getCode() ){ case KeyEvent::KEY_UP: mSpringCam.setEye( mRoom.getCornerCeilingPos() ); break; case KeyEvent::KEY_DOWN: mSpringCam.setEye( mRoom.getCornerFloorPos() ); break; case KeyEvent::KEY_RIGHT: mSpringCam.resetEye(); break; default: break; } } void ShockwavesApp::update() { if( mMousePressed ) mSpringCam.dragCam( ( mMouseOffset ) * 0.02f, ( mMouseOffset ).length() * 0.02f ); mSpringCam.update( 0.5f ); mRoom.update(); mController.update( mRoom.getTimeDelta(), mRoom.getTick() ); drawIntoRoomFbo(); } void ShockwavesApp::drawIntoRoomFbo() { mRoomFbo.bindFramebuffer(); gl::clear( ColorA( 0.0f, 0.0f, 0.0f, 0.0f ), true ); gl::setMatricesWindow( mRoomFbo.getSize(), false ); gl::setViewport( mRoomFbo.getBounds() ); gl::disableAlphaBlending(); gl::enable( GL_TEXTURE_2D ); glEnable( GL_CULL_FACE ); glCullFace( GL_BACK ); Matrix44f m; m.setToIdentity(); m.scale( mRoom.getDims() ); mCubeMap.bind(); mRoomShader.bind(); mRoomShader.uniform( "cubeMap", 0 ); mRoomShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix ); mRoomShader.uniform( "mMatrix", m ); mRoomShader.uniform( "eyePos", mSpringCam.mEye ); mRoomShader.uniform( "roomDims", mRoom.getDims() ); mRoomShader.uniform( "power", mRoom.getPower() ); mRoomShader.uniform( "lightPower", mRoom.getLightPower() ); mRoomShader.uniform( "timePer", mRoom.getTimePer() * 1.5f + 0.5f ); mRoom.draw(); mRoomShader.unbind(); mRoomFbo.unbindFramebuffer(); glDisable( GL_CULL_FACE ); } void ShockwavesApp::draw() { gl::clear( ColorA( 0.1f, 0.1f, 0.1f, 0.0f ), true ); gl::setMatricesWindow( getWindowSize(), false ); gl::setViewport( getWindowBounds() ); gl::disableDepthRead(); gl::disableDepthWrite(); gl::enableAlphaBlending(); gl::enable( GL_TEXTURE_2D ); gl::color( ColorA( 1.0f, 1.0f, 1.0f, 1.0f ) ); mRoomFbo.bindTexture(); gl::drawSolidRect( getWindowBounds() ); gl::setMatrices( mSpringCam.getCam() ); drawInfoPanel(); gl::disable( GL_TEXTURE_2D ); gl::enableDepthRead(); gl::enableDepthWrite(); mNodeShader.bind(); mNodeShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix ); mNodeShader.uniform( "eyePos", mSpringCam.getEye() ); mNodeShader.uniform( "power", mRoom.getPower() ); mNodeShader.uniform( "roomDims", mRoom.getDims() ); mController.drawNodes( &mNodeShader ); mNodeShader.unbind(); gl::color( ColorA( 0.0f, 0.0f, 0.0f, 0.4f ) ); mController.drawConnections(); gl::disableDepthWrite(); gl::color( ColorA( 1.0f, 1.0f, 1.0f, 1.0f ) ); gl::enable( GL_CULL_FACE ); glCullFace( GL_FRONT ); mShockwaveShader.bind(); mShockwaveShader.uniform( "mvpMatrix", mSpringCam.mMvpMatrix ); mShockwaveShader.uniform( "eyePos", mSpringCam.getEye() ); mShockwaveShader.uniform( "power", mRoom.getPower() ); mShockwaveShader.uniform( "roomDims", mRoom.getDims() ); mController.drawShockwaves( &mShockwaveShader ); mShockwaveShader.unbind(); gl::disable( GL_CULL_FACE ); gl::enable( GL_TEXTURE_2D ); Vec3f right, up; mSpringCam.mCam.getBillboardVectors( &right, &up ); mSmokeTex.bind(); mController.drawSmokes( right, up ); gl::enableAdditiveBlending(); mGlowTex.bind(); mController.drawGlows( right, up ); if( getElapsedFrames()%60 == 59 ) std::cout << "FPS: " << getAverageFps() << std::endl; } void ShockwavesApp::drawInfoPanel() { gl::pushMatrices(); gl::translate( mRoom.getDims() ); gl::scale( Vec3f( -1.0f, -1.0f, 1.0f ) ); gl::color( Color( 1.0f, 1.0f, 1.0f ) * ( 1.0 - mRoom.getPower() ) ); gl::enableAlphaBlending(); float iconWidth = 50.0f; float X0 = 15.0f; float X1 = X0 + iconWidth; float Y0 = 50.0f; float Y1 = Y0 + iconWidth; float c = mRoom.getPower() * 0.5f + 0.5f; gl::color( ColorA( c, c, c, 0.5f ) ); gl::draw( mIconTex, Rectf( X0, Y0, X1, Y1 ) ); c = mRoom.getPower(); gl::color( ColorA( c, c, c, 0.5f ) ); gl::disable( GL_TEXTURE_2D ); float timePer = mRoom.getTimePer(); gl::drawSolidRect( Rectf( Vec2f( X0, Y1 + 2.0f ), Vec2f( X0 + timePer * ( iconWidth ), Y1 + 2.0f + 4.0f ) ) ); float fpsPer = getAverageFps()/60.0f; gl::drawSolidRect( Rectf( Vec2f( X0, Y1 + 4.0f + 4.0f ), Vec2f( X0 + fpsPer * ( iconWidth ), Y1 + 4.0f + 6.0f ) ) ); gl::popMatrices(); } CINDER_APP_BASIC( ShockwavesApp, RendererGl )
_DIM; mVboMesh = gl::VboMesh( numVertices * 8 * 3, 0, layout, GL_TRIANGLES ); float s = 10.0f; Vec3f p0( 0.0f, s, 0.0f ); Vec3f p1( -s, 0.0f, 0.0f ); Vec3f p2( 0.0f, 0.0f, s ); Vec3f p3( s, 0.0f, 0.0f ); Vec3f p4( 0.0f, 0.0f, -s ); Vec3f p5( 0.0f, -s, 0.0f ); Vec3f n; Vec3f n0 = Vec3f( 0.0f, 0.0f, 1.0f ); Vec3f n1 = Vec3f(-1.0f,-1.0f, 0.0f ); Vec3f n2 = Vec3f(-1.0f, 1.0f, 0.0f ); Vec3f n3 = Vec3f( 1.0f, 1.0f, 0.0f ); Vec3f n4 = Vec3f( 1.0f,-1.0f, 0.0f ); Vec3f n5 = Vec3f( 0.0f, 0.0f,-1.0f ); vector<Vec3f> positions; vector<Vec3f> normals; for( int x = 0; x < GRID_DIM; ++x ) { for( int y = 0; y < GRID_DIM; ++y ) { positions.push_back( p0 ); positions.push_back( p1 ); positions.push_back( p2 ); n = ( p0 + p1 + p2 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p0 ); positions.push_back( p2 ); positions.push_back( p3 ); n = ( p0 + p2 + p3 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p0 ); positions.push_back( p3 ); positions.push_back( p4 ); n = ( p0 + p3 + p4 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p0 ); positions.push_back( p4 ); positions.push_back( p1 ); n = ( p0 + p4 + p1 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p1 ); positions.push_back( p4 ); n = ( p5 + p1 + p4 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p2 ); positions.push_back( p1 ); n = ( p5 + p2 + p1 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p3 ); positions.push_back( p2 ); n = ( p5 + p3 + p2 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); positions.push_back( p5 ); positions.push_back( p4 ); positions.push_back( p3 ); n = ( p5 + p4 + p3 ).normalized(); normals.push_back( n ); normals.push_back( n ); normals.push_back( n ); } } mVboMesh.bufferPositions( positions ); mVboMesh.bufferNormals( normals ); mVboMesh.unbindBuffers(); } void ShockwavesApp::mouseDown( MouseEvent event ) { mMouseDownPos = event.getPos(); mMousePressed = true; mMouseOffset = Vec2f::zero(); } void ShockwavesApp::mouseUp( MouseEvent event ) { mMousePressed = false; mMouseOffset = Vec2f::zero(); } void ShockwavesApp::mouseMove( MouseEvent event ) { mMousePos = event.getPos(); } void ShockwavesApp::mouseDrag( MouseEvent event ) { mouseMove( event ); mMouseOffset = ( mMousePos - mMouseDownPos ) * 0.4f; } void ShockwavesApp::mouseWheel( MouseEvent event ) { float dWheel = event.getWheelIncrement(); mRoom.adjustTimeMulti( dWheel ); } v
random
[]
C++
Core/GraphicsView.cpp
devonchenc/NovaImage
3d17166f9705ba23b89f1aefd31ac2db97385b1c
#include "GraphicsView.h" #include <QtMath> #include <QMimeData> #include <QDebug> #include "View.h" #include "MouseHandler.h" #include "GlobalFunc.h" #include "mainwindow.h" #include "../Image/BaseImage.h" #include "../Widget/MagnifierWidget.h" GraphicsView::GraphicsView(View* view, QGraphicsScene* scene, QWidget* parent) : QGraphicsView(scene, parent) , _view(view) , _zoomFactor(MAX_ZOOM / 2) , _showAnnotation(true) , _showCrossLine(false) , _showThreeViewAxes(false) , _showLineScale(true) , _magnifier(new MagnifierWidget(this)) { setDragMode(QGraphicsView::NoDrag); _magnifier->installEventFilter(this); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setMouseTracking(true); } QPointF GraphicsView::mapImagePointToScene(qreal x, qreal y) const { QGraphicsPixmapItem* pixmapItem = _view->getPixmapItem(); return pixmapItem->mapToScene(x, y); } void GraphicsView::setZoomValue(int value) { _zoomFactor = value; applyZoomValue(); } void GraphicsView::setZoomValueOffset(int offset) { _zoomFactor += offset; setZoomValue(_zoomFactor); } void GraphicsView::showAnnotation(bool show) { _showAnnotation = show; update(); } void GraphicsView::showCrossLine(bool show) { _showCrossLine = show; update(); } void GraphicsView::showThreeViewAxes(bool show) { _showThreeViewAxes = show; update(); } void GraphicsView::showLineScale(bool show) { _showLineScale = show; update(); } void GraphicsView::showMagnifier() { _magnifier->show(); } void GraphicsView::zoomNormal() { _zoomFactor = MAX_ZOOM / 2; setZoomValue(_zoomFactor); } void GraphicsView::zoom2x() { _zoomFactor = MAX_ZOOM / 2 + ZOOM_STEP; setZoomValue(_zoomFactor); } void GraphicsView::zoom4x() { _zoomFactor = MAX_ZOOM / 2 + ZOOM_STEP * 2; setZoomValue(_zoomFactor); } void GraphicsView::zoom8x() { _zoomFactor = MAX_ZOOM / 2 + ZOOM_STEP * 3; setZoomValue(_zoomFactor); } void GraphicsView::zoomIn() { _zoomFactor += ZOOM_STEP / 10; _zoomFactor = qMin(_zoomFactor, MAX_ZOOM); setZoomValue(_zoomFactor); } void GraphicsView::zoomOut() { _zoomFactor -= ZOOM_STEP / 10; _zoomFactor = qMax(0, _zoomFactor); setZoomValue(_zoomFactor); } void GraphicsView::applyZoomValue() { _zoomFactor = qMax(0, _zoomFactor); _zoomFactor = qMin(_zoomFactor, MAX_ZOOM); qreal ratio = qPow(qreal(2), (_zoomFactor - MAX_ZOOM / 2) / qreal(ZOOM_STEP)); QTransform transform; transform.scale(ratio, ratio); setTransform(transform); } void GraphicsView::mousePressEvent(QMouseEvent* event) { getGlobalWindow()->setActiveView(_view); MouseHandler::handlePress(event); QGraphicsView::mousePressEvent(event); } void GraphicsView::mouseMoveEvent(QMouseEvent* event) { QPoint mousePoint = mapFromGlobal(event->globalPos()) - QPoint(1, 1); QGraphicsPixmapItem* pixmapItem = _view->getPixmapItem(); if (pixmapItem) { QPointF pointScene = mapToScene(mousePoint); QPointF pointPixmap = pixmapItem->mapFromScene(pointScene); QImage image = pixmapItem->pixmap().toImage(); if (pointPixmap.x() >= 0 && pointPixmap.x() < image.width() && pointPixmap.y() >= 0 && pointPixmap.y() < image.height()) { float value = _view->getImageValue(pointPixmap.x(), pointPixmap.y()); int decimal = 4; if (abs(value) > 10.0f) { decimal = 1; } else if (abs(value) > 1.0f) { decimal = 2; } else if (abs(value) > 0.1f) { decimal = 3; } _strCoord = QString(tr("X: %1, Y: %2, Val: %3")).arg(QString::number(pointPixmap.x(), 'f', 0)).arg(QString::number(pointPixmap.y(), 'f', 0)).arg(QString::number(value, 'f', decimal)); QRgb rgbValue = image.pixel(QPoint(pointPixmap.x(), pointPixmap.y())); _strValue = QString("R:%1, G:%2, B:%3").arg(qRed(rgbValue), 3).arg(qGreen(rgbValue), 3).arg(qBlue(rgbValue), 3); } else { _strCoord.clear(); _strValue.clear(); } update(); } MouseHandler::handleMove(event); QGraphicsView::mouseMoveEvent(event); } void GraphicsView::mouseReleaseEvent(QMouseEvent* event) { MouseHandler::handleRelease(event); QGraphicsView::mouseReleaseEvent(event); } void GraphicsView::mouseDoubleClickEvent(QMouseEvent* event) { getGlobalWindow()->singleView(); QGraphicsView::mouseDoubleClickEvent(event); } void GraphicsView::wheelEvent(QWheelEvent* event) { if (event->modifiers() & Qt::ControlModifier) { if (event->angleDelta().y() > 0) getGlobalWindow()->zoomIn(); else getGlobalWindow()->zoomOut(); event->accept(); } else { BaseImage* image = getGlobalImage(); if (image) { if (event->angleDelta().y() > 0) _view->sliceMinusOne(); else _view->slicePlusOne(); } } } void GraphicsView::dragEnterEvent(QDragEnterEvent* event) { event->ignore(); } void GraphicsView::drawForeground(QPainter*, const QRectF&) { BaseImage* image = getGlobalImage(); if (image == nullptr) return; if (_showAnnotation) { drawAnnotation(); } if (_showCrossLine) { drawCrossLine(); } if (_showThreeViewAxes) { drawThreeViewAxes(); } if (_showLineScale) { drawLineScale(); } } bool GraphicsView::eventFilter(QObject* obj, QEvent* event) { if (obj == _magnifier && event->type() == QEvent::MouseMove) { QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event); mouseMoveEvent(mouseEvent); return false; } else { return QGraphicsView::eventFilter(obj, event); } } void GraphicsView::focusInEvent(QFocusEvent*) { _view->update(); } void GraphicsView::focusOutEvent(QFocusEvent*) { _view->update(); } void GraphicsView::drawAnnotation() { int fontHeight = 16; if (rect().height() < 400) { fontHeight = 8; } else if (rect().height() < 600) { fontHeight = 10; } else if (rect().height() < 800) { fontHeight = 12; } QFont font("Arial", fontHeight); QPainter painter(viewport()); painter.setFont(font); painter.setPen(QPen(qRgb(255, 255, 150))); int pixelsHigh = painter.fontMetrics().height() * 1.1; int y = rect().bottom() - 10; const int textAreaWidth = 350; qreal scale = qPow(qreal(2), (_zoomFactor - MAX_ZOOM / 2) / qreal(ZOOM_STEP)); QString str = QString(tr("Zoom: %1%")).arg(QString::number(scale * 100.0, 'f', 2)); painter.drawText(QRect(0, 0, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); str = QString(tr("Size: %1%2%3")).arg(_view->imageWidth()).arg(QString(QChar(0x00D7))).arg(_view->imageHeight()); painter.drawText(QRect(0, pixelsHigh, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); str = QString(tr("Slice: %1/%2")).arg(_view->imageCurrentSlice() + 1).arg(_view->imageSlice()); painter.drawText(QRect(0, pixelsHigh * 2, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); float windowLevel = _view->windowLevel(); float windowWidth = _view->windowWidth(); int decimal = 4; if (abs(windowLevel) > 10.0f) { decimal = 1; } else if (abs(windowLevel) > 1.0f) { decimal = 2; } else if (abs(windowLevel) > 0.1f) { decimal = 3; } str = QString(tr("WL: %1 WW: %2")).arg(QString::number(windowLevel, 'f', decimal)).arg(QString::number(windowWidth, 'f', decimal)); painter.drawText(QRect(0, y - pixelsHigh, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); painter.drawText(QRect(rect().width() - textAreaWidth, 0, textAreaWidth - 5, pixelsHigh), Qt::AlignRight, _view->imageDescription()); painter.setPen(QPen(qRgb(255, 100, 100))); painter.drawText(QRect(0, y - pixelsHigh * 2, 600, pixelsHigh), Qt::AlignLeft, _strValue); painter.drawText(QRect(0, y - pixelsHigh * 3, 600, pixelsHigh), Qt::AlignLeft, _strCoord); } void GraphicsView::drawCrossLine() { QRectF rect = _view->getPixmapItem()->sceneBoundingRect(); QPoint topLeft = mapFromScene(rect.topLeft()); QPoint center = mapFromScene(rect.center()); QPoint bottomRight = mapFromScene(rect.bottomRight()); QPainter painter(viewport()); painter.setPen(QPen(QBrush(qRgb(255, 50, 50)), 1, Qt::DotLine)); painter.drawLine(topLeft.x(), center.y(), bottomRight.x(), center.y()); painter.drawLine(center.x(), topLeft.y(), center.x(), bottomRight.y()); } void GraphicsView::drawThreeViewAxes() { QRectF pixmapRect = _view->getPixmapItem()->sceneBoundingRect(); QPainter painter(viewport()); QRect viewRect = rect(); BaseImage* image = getGlobalImage(); int xOffset, yOffset; QColor horzColor, vertColor; if (_view->viewType() == AXIAL_VIEW) { xOffset = image->currentSlice(SAGITTAL_VIEW); yOffset = image->currentSlice(CORONAL_VIEW); horzColor = qRgb(255, 60, 135); vertColor = qRgb(50, 185, 255); } else if (_view->viewType() == CORONAL_VIEW) { xOffset = image->currentSlice(SAGITTAL_VIEW); yOffset = image->currentSlice(AXIAL_VIEW); horzColor = qRgb(255, 225, 15); vertColor = qRgb(50, 185, 255); } else if (_view->viewType() == SAGITTAL_VIEW) { xOffset = image->currentSlice(CORONAL_VIEW); yOffset = image->currentSlice(AXIAL_VIEW); horzColor = qRgb(255, 225, 15); vertColor = qRgb(255, 60, 135); } QPoint center = mapFromScene(pixmapRect.left() + xOffset, pixmapRect.top() + yOffset); painter.setPen(QPen(horzColor)); painter.drawLine(viewRect.left(), center.y(), viewRect.right(), center.y()); painter.setPen(QPen(vertColor)); painter.drawLine(center.x(), viewRect.top(), center.x(), viewRect.bottom()); } void GraphicsView::drawLineScale() { BaseImage* image = getGlobalImage(); if (!image->hasPixelSpacing()) return; float horzPixelSpacing = image->horzPixelSpacing(); float vertPixelSpacing = image->vertPixelSpacing(); float horzDistance = calcScale(horzPixelSpacing); float vertDistance = calcScale(vertPixelSpacing); qreal scale = qPow(qreal(2), (_zoomFactor - MAX_ZOOM / 2) / qreal(ZOOM_STEP)); float horzInterval = horzDistance * scale / horzPixelSpacing; float vertInterval = vertDistance * scale / vertPixelSpacing; int margin = 5; int x = rect().right() - margin; int y = rect().bottom() - margin; QPainter painter(viewport()); painter.setPen(QPen(qRgb(255, 255, 100))); painter.drawLine(rect().center().x() - 5 * horzInterval, y, rect().center().x() + 5 * horzInterval, y); painter.drawLine(x, rect().center().y() - 5 * vertInterval, x, rect().center().y() + 5 * vertInterval); painter.setPen(QPen(qRgb(255, 255, 0))); for (int i = 0; i <= 10; i++) { painter.drawLine(rect().center().x() + (i - 5) * horzInterval, y, rect().center().x() + (i - 5) * horzInterval, y - 5); if (i % 5 == 0) { painter.drawLine(rect().center().x() + (i - 5) * horzInterval, y, rect().center().x() + (i - 5) * horzInterval, y - 10); } painter.drawLine(x, rect().center().y() + (i - 5) * vertInterval, x - 5, rect().center().y() + (i - 5) * vertInterval); if (i % 5 == 0) { painter.drawLine(x, rect().center().y() + (i - 5) * vertInterval, x - 10, rect().center().y() + (i - 5) * vertInterval); } } QString str = QString::number(horzDistance, 'f', 2) + " mm"; painter.drawText(QRect(rect().center().x(), y - 23, 9 * horzInterval, 20), Qt::AlignCenter, str); painter.rotate(-90); str = QString::number(vertDistance, 'f', 2) + " mm"; painter.drawText(QRect(-rect().center().y(), rect().width() - 23 - margin, 9 * horzInterval, 20), Qt::AlignCenter, str); } float GraphicsView::calcScale(float pixelSpacing) { float distance = 20.0f; int flag = 0; while (distance / pixelSpacing > 60) { if (flag == 0) { distance /= 2; } else if (flag == 1) { distance /= 2; } else if (flag == 2) { distance /= 2.5; } flag = (flag + 1) % 3; } return distance; }
#include "GraphicsView.h" #include <QtMath> #include <QMimeData> #include <QDebug> #include "View.h" #include "MouseHandler.h" #include "GlobalFunc.h" #include "mainwindow.h" #include "../Image/BaseImage.h" #include "../Widget/MagnifierWidget.h" GraphicsView::GraphicsView(View* view, QGraphicsScene* scene, QWidget* parent) : QGraphicsView(scene, parent) , _view(view) , _zoomFactor(MAX_ZOOM / 2) , _showAnnotation(true) , _showCrossLine(false) , _showThreeViewAxes(false) , _showLineScale(true) , _magnifier(new MagnifierWidget(this)) { setDragMode(QGraphicsView::NoDrag); _magnifier->installEventFilter(this); setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff); setMouseTracking(true); } QPointF GraphicsView::mapImagePointToScene(qreal x, qreal y) const { QGraphicsPixmapItem* pixmapItem = _view->getPixmapItem(); return pixmapItem->mapToScene(x, y); } void GraphicsView::setZoomValue(int value) { _zoomFactor = value; applyZoomValue(); } void GraphicsView::setZoomValueOffset(int offset) { _zoomFactor += offset; setZoomValue(_zoomFactor); } void GraphicsView::showAnnotation(bool show) { _showAnnotation = show; update(); } void GraphicsView::showCrossLine(bool show) { _showCrossLine = show; update(); } void GraphicsView::showThreeViewAxes(bool show) { _showThreeViewAxes = show; update(); } void GraphicsView::showLineScale(bool show) { _showLineScale = show; update(); } void GraphicsView::showMagnifier() { _magnifier->show(); } void GraphicsView::zoomNormal() { _zoomFactor = MAX_ZOOM / 2; setZoomValue(_zoomFactor); } void GraphicsView::zoom2x() { _zoomFactor = MAX_ZOOM / 2 + ZOOM_STEP; setZoomValue(_zoomFactor); } void GraphicsView::zoom4x() { _zoomFactor = MAX_ZOOM / 2 + ZOOM_STEP * 2; setZoomValue(_zoomFactor); } void GraphicsView::zoom8x() { _zoomFactor = MAX_ZOOM / 2 + ZOOM_STEP * 3; setZoomValue(_zoomFactor); } void GraphicsView::zoomIn() { _zoomFactor += ZOOM_STEP / 10; _zoomFactor = qMin(_zoomFactor, MAX_ZOOM); setZoomValue(_zoomFactor); } void GraphicsView::zoomOut() { _zoomFactor -= ZOOM_STEP / 10; _zoomFactor = qMax(0, _zoomFactor); setZoomValue(_zoomFactor); } void GraphicsView::applyZoomValue() { _zoomFactor = qMax(0, _zoomFactor); _zoomFactor = qMin(_zoomFactor, MAX_ZOOM); qreal ratio = qPow(qreal(2), (_zoomFactor - MAX_ZOOM / 2) / qreal(ZOOM_STEP)); QTransform transform; transform.scale(ratio, ratio); setTransform(transform); } void GraphicsView::mousePressEvent(QMouseEvent* event) { getGlobalWindow()->setActiveView(_view); MouseHandler::handlePress(event); QGraphicsView::mousePressEvent(event); } void GraphicsView::mouseMoveEvent(QMouseEvent* event) { QPoint mousePoint = mapFromGlobal(event->globalPos()) - QPoint(1, 1); QGraphicsPixmapItem* pixmapItem = _view->getPixmapItem(); if (pixmapItem) { QPointF pointScene = mapToScene(mousePoint); QPointF pointPixmap = pixmapItem->mapFromScene(pointScene); QImage image = pixmapItem->pixmap().toImage(); if (pointPixmap.x() >= 0 && pointPixmap.x() < image.width() && pointPixmap.y() >= 0 && pointPixmap.y() < image.height()) { float value = _view->getImageValue(pointPixmap.x(), pointPixmap.y()); int decimal = 4; if (abs(value) > 10.0f) { decimal = 1; } else if (abs(value) > 1.0f) { decimal = 2; } else if (abs(value) > 0.1f) { decimal = 3; } _strCoord = QString(tr("X: %1, Y: %2, Val: %3")).arg(QString::number(pointPixmap.x(), 'f', 0)).arg(QString::number(pointPixmap.y(), 'f', 0)).arg(QString::number(value, 'f', decimal)); QRgb rgbValue = image.pixel(QPoint(pointPixmap.x(), pointPixmap.y())); _strValue = QString("R:%1, G:%2, B:%3").arg(qRed(rgbValue), 3).arg(qGreen(rgbValue), 3).arg(qBlue(rgbValue), 3); } else { _strCoord.clear(); _strValue.clear(); } update(); } MouseHandler::handleMove(event); QGraphicsView::mouseMoveEvent(event); } void GraphicsView::mouseReleaseEvent(QMouseEvent* event) { MouseHandler::handleRelease(event); QGraphicsView::mouseReleaseEvent(event); } void GraphicsView::mouseDoubleClickEvent(QMouseEvent* event) { getGlobalWindow()->singleView(); QGraphicsView::mouseDoubleClickEvent(event); } void GraphicsView::wheelEvent(QWheelEvent* event) { if (event->modifiers() & Qt::ControlModifier) { if (event->angleDelta().y() > 0) getGlobalWindow()->zoomIn(); else getGlobalWindow()->zoomOut(); event->accept(); } else { BaseImage* image = getGlobalImage(); if (image) { if (event->angleDelta().y() > 0) _view->sliceMinusOne(); else _view->slicePlusOne(); } } } void GraphicsView::dragEnterEvent(QDragEnterEvent* event) { event->ignore(); } void GraphicsView::drawForeground(QPainter*, const QRectF&) { BaseImage* image = getGlobalImage(); if (image == nullptr) return; if (_showAnnotation) { drawAnnotation(); } if (_showCrossLine) { drawCrossLine(); } if (_showThreeViewAxes) { drawThreeViewAxes(); } if (_showLineScale) { drawLineScale(); } } bool GraphicsView::eventFilter(QObject* obj, QEvent* event) { if (obj == _magnifier && event->type() == QEvent::MouseMove) { QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event); mouseMoveEvent(mouseEvent); return false; } else { return QGraphicsView::eventFilter(obj, event); } } void GraphicsView::focusInEvent(QFocusEvent*) { _view->update(); } void GraphicsView::focusOutEvent(QFocusEvent*) { _view->update(); } void GraphicsView::drawAnnotation() { int fontHeight = 16; if (rect().height() < 400) { fontHeight = 8; } else if (rect().height() < 600) { fontHeight = 10; } else if (rect().height() < 800) { fontHeight = 12; } QFont font("Arial", fontHeight); QPainter painter(viewport()); painter.setFont(font); painter.setPen(QPen(qRgb(255, 255, 150))); int pixelsHigh = painter.fontMetrics().height() * 1.1; int y = rect().bottom() - 10; const int textAreaWidth = 350; qreal scale = qPow(qreal(2), (_zoomFactor - MAX_ZOOM / 2) / qreal(ZOOM_STEP)); QString str = QString(tr("Zoom: %1%")).arg(QString::number(scale * 100.0, 'f', 2)); painter.drawText(QRect(0, 0, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); str = QString(tr("Size: %1%2%3")).arg(_view->imageWidth()).arg(QString(QChar(0x00D7))).arg(_view->imageHeight()); painter.drawText(QRect(0, pixelsHigh, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); str = QString(tr("Slice: %1/%2")).arg(_view->imageCurrentSlice() + 1).arg(_view->imageSlice()); painter.drawText(QRect(0, pixelsHigh * 2, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); float windowLevel = _view->windowLevel(); float windowWidth = _view->windowWidth(); int decimal = 4; if (abs(windowLevel) > 10.0f) { decimal = 1; } else if (abs(windowLevel) > 1.0f) { decimal = 2; } else if (abs(windowLevel) > 0.1f) { decimal = 3; } str = QString(tr("WL: %1 WW: %2")).arg(QString::number(windowLevel, 'f', decimal)).arg(QString::number(windowWidth, 'f', decimal)); painter.drawText(QRect(0, y - pixelsHigh, textAreaWidth, pixelsHigh), Qt::AlignLeft, str); painter.drawText(QRect(rect().width() - textAreaWidth, 0, textAreaWidth - 5, pixelsHigh), Qt::AlignRight, _view->imageDescription()); painter.setPen(QPen(qRgb(255, 100, 100))); painter.drawText(QRect(0, y - pixelsHigh * 2, 600, pixelsHigh), Qt::AlignLeft, _strValue); painter.drawText(QRect(0, y - pixelsHigh * 3, 600, pixelsHigh), Qt::AlignLeft, _strCoord); } void GraphicsView::drawCrossLine() { QRectF rect = _view->getPixmapItem()->sceneBoundingRect(); QPoint topLeft = mapFromScene(rect.topLeft()); QPoint center = mapFromScene(rect.center()); QPoint bottomRight = mapFromScene(rect.bottomRight()); QPainter painter(viewport()); painter.setPen(QPen(QBrush(qRgb(255, 50, 50)), 1, Qt::DotLine)); painter.drawLine(topLeft.x(), center.y(), bottomRight.x(), center.y()); painter.drawLine(center.x(), topLeft.y(), center.x(), bottomRight.y()); } void GraphicsView::drawThreeViewAxes() { QRectF pixmapRect = _view->getPixmapItem()->sceneBoundingRect(); QPainter painter(viewport()); QRect viewRect = rect(); BaseImage* image = getGlobalImage(); int xOffset, yOffset; QColor horzColor, vertColor; if (_view->viewType() == AXIAL_VIEW) { xOffset = image->currentSlice(SAGITTAL_VIEW); yOffset = image->currentSlice(CORONAL_VIEW); horzColor = qRgb(255, 60, 135); vertColor = qRgb(50, 185, 255); } else if (_view->viewType() == CORONAL_VIEW) { xOffset = image->currentSlice(SAGITTAL_VIEW); yOffset = image->currentSlice(AXIAL_VIEW); horzColor = qRgb(255, 225, 15); vertColor = qRgb(50, 185, 255); } else if (_view->viewType() == SAGITTAL_VIEW) { xOffset = image->currentSlice(CORONAL_VIEW); yOffset = image->currentSlice(AXIAL_VIEW); horzColor = qRgb(255, 225, 15); vertColor = qRgb(255, 60, 135); } QPoint center = mapFromScene(pixmapRect.left() + xOffset, pixmapRect.top() + yOffset); painter.setPen(QPen(horzColor)); painter.drawLine(viewRect.left(), center.y(), viewRect.right(), center.y()); painter.setPen(QPen(vertColor)); painter.drawLine(center.x(), viewRect.top(), center.x(), viewRect.bottom()); } void GraphicsView::drawLineScale() { BaseImage* image = getGlobalImage(); if (!image->hasPixelSpacing()) return; float horzPixelSpacing = image->horzPixelSpacing(); float vertPixelSpacing = image->vertPixelSpacing(); float horzDistance = calcScale(horzPixelSpacing); float vertDistance = calcScale(vertPixelSpacing); qreal scale = qPow(qreal(2), (_zoomFactor - MAX_ZOOM / 2) / qreal(ZOOM_STEP)); float horzInterval = horzDistance * scale / horzPixelSpacing; float vertInterval = vertDistance * scale / vertPixelSpacing; int margin = 5; int x = rect().right() - margin; int y = rect().bottom() - margin; QPainter painter(viewport()); painter.setPen(QPen(qRgb(255, 255, 100))); painter.drawLine(rect().center().x() - 5 * horzInterval, y, rect().center().x() + 5 * horzInterval, y); painter.drawLine(x, rect().center().y() - 5 * vertInterval, x, rect().center().y() + 5 * vertInterval); painter.setPen(QPen(qRgb(255, 255, 0))); for (int i = 0; i <= 10; i++) { painter.drawLine(rect().center().x() + (i - 5) * horzInterval, y, rect().center().x() + (i - 5) * horzInterval, y - 5); if (i % 5 == 0) { painter.drawLine(rect().center().x() + (i - 5) * horzInterval, y, rect().center().x() + (i - 5) * horzInterval, y - 10); } painter.drawLine(x, rect().center().y() + (i - 5) * vertInterval, x - 5, rect().center().y() + (i - 5) * vertInterval); if (i % 5 == 0) { painter.drawLine(x, rect().center().y() + (i - 5) * vertInterval, x - 10, rect().center().y() + (i - 5) * vertInterval); } }
float GraphicsView::calcScale(float pixelSpacing) { float distance = 20.0f; int flag = 0; while (distance / pixelSpacing > 60) { if (flag == 0) { distance /= 2; } else if (flag == 1) { distance /= 2; } else if (flag == 2) { distance /= 2.5; } flag = (flag + 1) % 3; } return distance; }
QString str = QString::number(horzDistance, 'f', 2) + " mm"; painter.drawText(QRect(rect().center().x(), y - 23, 9 * horzInterval, 20), Qt::AlignCenter, str); painter.rotate(-90); str = QString::number(vertDistance, 'f', 2) + " mm"; painter.drawText(QRect(-rect().center().y(), rect().width() - 23 - margin, 9 * horzInterval, 20), Qt::AlignCenter, str); }
function_block-function_prefix_line
[ { "content": "class View;\n", "file_path": "Core/GraphicsScene.h", "rank": 0, "score": 120366.99674812447 }, { "content": "class ImageQualityChartView : public ChartView\n\n{\n\n Q_OBJECT\n\n\n\npublic:\n\n ImageQualityChartView(QWidget* parent = nullptr);\n\n\n\n void setData(const...
C++
targets/TARGET_NORDIC/TARGET_NRF5x/TARGET_NRF52/TARGET_MCU_NRF52832/TARGET_RIOT_MICRO_MODULE/ONBOARD_RM1000_AT.cpp
yogpan01/mbed
1fb9dd7ddd94239f788683e864f2dac664f33a48
#if MBED_CONF_NSAPI_PRESENT #include "ONBOARD_RM1000_AT.h" #include "UARTSerial.h" #include "mbed-trace/mbed_trace.h" #ifndef TRACE_GROUP #define TRACE_GROUP "RIOTMICRO" #endif #include "gpio_api.h" #include "PinNames.h" #include "hal/serial_api.h" #include "platform/mbed_thread.h" using namespace mbed; ONBOARD_RM1000_AT::ONBOARD_RM1000_AT(FileHandle *fh) : RM1000_AT(fh) { } nsapi_error_t ONBOARD_RM1000_AT::hard_power_on() { tr_debug("Calling ONBOARD_RM1000_AT::hard_power_on"); return NSAPI_ERROR_OK; } nsapi_error_t ONBOARD_RM1000_AT::hard_power_off() { tr_debug("Calling ONBOARD_RM1000_AT::hard_power_off"); return NSAPI_ERROR_OK; } nsapi_error_t ONBOARD_RM1000_AT::soft_power_on() { tr_debug("Calling ONBOARD_RM1000_AT::soft_power_on"); onboard_modem_init(); return NSAPI_ERROR_OK; } nsapi_error_t ONBOARD_RM1000_AT::soft_power_off() { tr_debug("Calling ONBOARD_RM1000_AT::soft_power_off"); onboard_modem_deinit(); return NSAPI_ERROR_OK; } void ONBOARD_RM1000_AT::onboard_modem_init() { char promptEnd; tr_debug("onboard_modem_init"); gpio_t gpio; gpio_init_out_ex(&gpio, MDMCHEN, 0); gpio_init_out_ex(&gpio, MDMREMAP, 0); gpio_init_out_ex(&gpio, MDMRST, 0); thread_sleep_for(100); gpio_write(&gpio, 1); gpio_init_in_ex(&gpio, MDM_UART1_TXD, PullNone); gpio_init_in_ex(&gpio, MDM_UART1_RXD, PullNone); serial_t bootrom_uart; serial_init(&bootrom_uart, MDM_UART0_TXD, MDM_UART0_RXD); serial_baud(&bootrom_uart, 115200); tr_debug("%s: MODEM RESET", __func__); serial_getc(&bootrom_uart); tr_debug("%s: MODEM first activity after reset", __func__); for (int i = 0; i < 3; i++) { do { promptEnd = serial_getc(&bootrom_uart); } while ('.' != promptEnd); } serial_putc(&bootrom_uart, ' '); for (int i = 0; i < 2; i++) { do { promptEnd = serial_getc(&bootrom_uart); } while ('>' != promptEnd); } serial_putc(&bootrom_uart, '6'); serial_free(&bootrom_uart); tr_debug("%s: Wait for stack prompt", __func__); thread_sleep_for(100); serial_t cli_uart; serial_init(&cli_uart, MDM_UART3_TXD, MDM_UART3_RXD); serial_baud(&cli_uart, 230400); do { promptEnd = serial_getc(&cli_uart); } while ('>' != promptEnd); serial_free(&cli_uart); tr_debug("%s: MODEM CLI prompt reached", __func__); tr_debug("Reset RM1000 completed"); } void ONBOARD_RM1000_AT::onboard_modem_deinit() { tr_debug("onboard_modem_deinit"); gpio_t gpio; gpio_init_out_ex(&gpio, MDMRST, 0); } CellularDevice *CellularDevice::get_target_default_instance() { tr_debug("Calling CellularDevice::get_target_default_instance from ONBOARD_RM1000_AT"); static UARTSerial serial(MDM_UART3_TXD, MDM_UART3_RXD, 230400); #if DEVICE_SERIAL_FC if (MDM_UART3_RTS != NC && MDM_UART3_CTS != NC) { tr_debug("Modem flow control: RTS %d CTS %d", MDM_UART3_RTS, MDM_UART3_CTS); serial.set_flow_control(SerialBase::RTSCTS, MDM_UART3_RTS, MDM_UART3_CTS); } #endif static ONBOARD_RM1000_AT device(&serial); return &device; } #endif
#if MBED_CONF_NSAPI_PRESENT #include "ONBOARD_RM1000_AT.h" #include "UARTSerial.h" #include "mbed-trace/mbed_trace.h" #ifndef TRACE_GROUP #define TRACE_GROUP "RIOTMICRO" #endif #include "gpio_api.h" #include "PinNames.h" #include "hal/serial_api.h" #include "platform/mbed_thread.h" using namespace mbed; ONBOARD_RM1000_AT::ONBOARD_RM1000_AT(FileHandle *fh) : RM1000_AT(fh) { } nsapi_error_t ONBOARD_RM1000_AT::hard_power_on() { tr_debug("Calling ONBOARD_RM1000_AT::hard_power_on"); return NSAPI_ERROR_OK; } nsapi_error_t ONBOARD_RM1000_AT::hard_power_off() { tr_debug("Calling ONBOARD_RM1000_AT::hard_power_off"); return NSAPI_ERROR_OK; } nsapi_error_t ONBOARD_RM1000_AT::soft_power_on() { tr_debug("Calling ONBOARD_RM1000_AT::soft_power_on"); onboard_modem_init(); return NSAPI_ERROR_OK; } nsapi_error_t ONBOARD_RM1000_AT::soft_power_off() { tr_debug("Calling ONBOARD_RM1000_AT::soft_power_off"); onboard_modem_deinit(); return NSAPI_ERROR_OK; } void ONBOARD_RM1000_AT::onboard_modem_init() { char promptEnd; tr_debug("onboard_modem_init"); gpio_t gpio; gpio_init_out_ex(&gpio, MDMCHEN, 0); gpio_init_out_ex(&gpio, MDMREMAP, 0); gpio_init_out_ex(&gpio, MDMRST, 0); thread_sleep_for(100); gpio_write(&gpio, 1); gpio_init_in_ex(&gpio, MDM_UART1_TXD, PullNone); gpio_init_in_ex(&gpio, MDM_UART1_RXD, PullNone); serial_t bootrom_uart; serial_init(&bootrom_uart, MDM_UART0_TXD, MDM_UART0_RXD); serial_baud(&bootrom_uart, 115200); tr_debug("%s: MODEM RESET", __f
void ONBOARD_RM1000_AT::onboard_modem_deinit() { tr_debug("onboard_modem_deinit"); gpio_t gpio; gpio_init_out_ex(&gpio, MDMRST, 0); } CellularDevice *CellularDevice::get_target_default_instance() { tr_debug("Calling CellularDevice::get_target_default_instance from ONBOARD_RM1000_AT"); static UARTSerial serial(MDM_UART3_TXD, MDM_UART3_RXD, 230400); #if DEVICE_SERIAL_FC if (MDM_UART3_RTS != NC && MDM_UART3_CTS != NC) { tr_debug("Modem flow control: RTS %d CTS %d", MDM_UART3_RTS, MDM_UART3_CTS); serial.set_flow_control(SerialBase::RTSCTS, MDM_UART3_RTS, MDM_UART3_CTS); } #endif static ONBOARD_RM1000_AT device(&serial); return &device; } #endif
unc__); serial_getc(&bootrom_uart); tr_debug("%s: MODEM first activity after reset", __func__); for (int i = 0; i < 3; i++) { do { promptEnd = serial_getc(&bootrom_uart); } while ('.' != promptEnd); } serial_putc(&bootrom_uart, ' '); for (int i = 0; i < 2; i++) { do { promptEnd = serial_getc(&bootrom_uart); } while ('>' != promptEnd); } serial_putc(&bootrom_uart, '6'); serial_free(&bootrom_uart); tr_debug("%s: Wait for stack prompt", __func__); thread_sleep_for(100); serial_t cli_uart; serial_init(&cli_uart, MDM_UART3_TXD, MDM_UART3_RXD); serial_baud(&cli_uart, 230400); do { promptEnd = serial_getc(&cli_uart); } while ('>' != promptEnd); serial_free(&cli_uart); tr_debug("%s: MODEM CLI prompt reached", __func__); tr_debug("Reset RM1000 completed"); }
function_block-function_prefixed
[]
C++
rexec/RexecShell/Environment.cpp
RWTH-OS/MP-MPICH
f2ae296477bb9d812fda587221b3419c09f85b4a
#include <vcl\vcl.h> #pragma hdrstop #include "Environment.h" #include "..\mpirun\plugins\Plugin.h" #if ((BCBVER > 1)) #include <stdio.h> #endif extern "C" { __declspec(dllexport) char* GetEnvString(HostData *Proc,char *Name,char *value,DWORD *BufSize) { char *act, *pos; int res; DWORD lenAll,lenStName,lenGName,lenValue; if(!Proc || !Proc->ProcData) return 0; act=Proc->ProcData->Environment; if(value) *value=0; if(!Name) { return 0; } while(act&&*act) { lenAll=strlen(act); pos=strchr(act+1,'='); if(! pos) { act+=(lenAll+1); continue; } lenStName=(DWORD)(pos-act); lenGName=strlen(Name); res=strnicmp(act,Name,min(lenStName,lenGName)); if(!res) { if(lenStName > lenGName) res = 1; else if(lenStName < lenGName) res = -1; else { lenValue = strlen(pos+1)+1; if(value && lenValue<=*BufSize) strcpy(value,pos+1); *BufSize = lenValue; return act; } } if(res>0) { *BufSize = 0; return act; } act+=(lenAll+1); } *BufSize = 0; return act; } __declspec(dllexport) void PutEnvString(HostData *Proc,char *Name,char *value) { char *OldPos; DWORD oldLen,newLen,OldIndex,oldSize,namelen; if(!value) value=""; namelen = strlen(Name); newLen=namelen+strlen(value)+2; oldLen = 0; if(!Proc->ProcData) { Proc->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(Proc->ProcData,0,sizeof(TProcessData)); } if(!Proc->ProcData->Environment) { Proc->ProcData->Environment = (char*)malloc(128); Proc->ProcData->EnvAllocSize=128; *Proc->ProcData->Environment=0; Proc->ProcData->EnvSize=1; } OldPos=GetEnvString(Proc,Name,0,&oldLen); if(!OldPos) { return; } if(oldLen) oldLen += namelen+1; OldIndex=(DWORD)(OldPos-Proc->ProcData->Environment); if(oldLen>=newLen) { memmove(OldPos+newLen,OldPos+oldLen,Proc->ProcData->EnvSize-(OldIndex+oldLen)); Proc->ProcData->EnvSize-=(oldLen-newLen); } else { oldSize=Proc->ProcData->EnvSize; Proc->ProcData->EnvSize+=(newLen-oldLen); if(Proc->ProcData->EnvAllocSize<Proc->ProcData->EnvSize) { Proc->ProcData->EnvAllocSize= max(Proc->ProcData->EnvSize,2*Proc->ProcData->EnvAllocSize); Proc->ProcData->Environment= (char*)realloc(Proc->ProcData->Environment,Proc->ProcData->EnvAllocSize); OldPos=Proc->ProcData->Environment+OldIndex; } memmove(OldPos+newLen,OldPos+oldLen,oldSize-OldIndex-oldLen); } sprintf(OldPos,"%s=%s",Name,value); } __declspec(dllexport) void *GetContext(HostData *Host,DWORD size) { if(!Host) return 0; if(!Host->ProcData) { if(!size) return 0; Host->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(Host->ProcData,0,sizeof(TProcessData)); } if(Host->ProcData->ContextSize<size) { Host->ProcData->Context = realloc(Host->ProcData->Context,size); Host->ProcData->ContextSize = size; } return Host->ProcData->Context; } void EmptyEnvironment(HostData *Proc) { if(Proc && Proc->ProcData && Proc->ProcData->Environment) { *Proc->ProcData->Environment = 0; Proc->ProcData->EnvSize=1; } } void FreeEnvironment(HostData * Proc) { if(!Proc || !Proc->ProcData) return; if(Proc->ProcData->Environment) { free(Proc->ProcData->Environment); } Proc->ProcData->Environment = 0; Proc->ProcData->EnvSize=0; Proc->ProcData->EnvAllocSize=0; } void ProcSetString(char **str,const char *val,DWORD *size) { DWORD len; if(!val) { ProcStrRemove(str,size); return; } len = strlen(val)+1; if(*size<len) { *str = (char*)realloc(*str,len); *size = len; } strcpy(*str,val); } void ProcStrRemove(char **str,DWORD *size) { if(*str) { free(*str); *str = 0; } *size = 0; } __declspec(dllexport) void FreeContext(HostData *Host) { if(!Host || !Host->ProcData||!Host->ProcData->Context) return; free(Host->ProcData->Context); Host->ProcData->Context = 0; Host->ProcData->ContextSize = 0; } void FreeProcData(HostData *Proc) { if(!Proc || !Proc->ProcData) return; FreeContext(Proc); FreeEnvironment(Proc); ProcStrRemove(&Proc->ProcData->Commandline,&Proc->ProcData->CmdSize); ProcStrRemove(&Proc->ProcData->Executable,&Proc->ProcData->ExeSize); ProcStrRemove(&Proc->ProcData->WorkingDir,&Proc->ProcData->WDSize); ProcStrRemove(&Proc->ProcData->UserOptions,&Proc->ProcData->OptSize); ProcStrRemove(&Proc->ProcData->PluginOptions,&Proc->ProcData->PluginOptSize); free(Proc->ProcData); Proc->ProcData = 0; } void CopyProcData(HostData *dest,HostData *src) { TProcessData *d,*s; if(!src || !src->ProcData) { if(dest && dest->ProcData) FreeProcData(dest); return; } if(!dest->ProcData) { dest->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(dest->ProcData,0,sizeof(TProcessData)); } d = dest->ProcData; s = src->ProcData; d->LockIt = s->LockIt; d->PriorityClass = s->PriorityClass; d->LoadProfile = s->LoadProfile; ProcSetString(&d->Executable,s->Executable,&d->ExeSize); ProcSetString(&d->WorkingDir,s->WorkingDir,&d->WDSize); ProcSetString(&d->UserOptions,s->UserOptions,&d->OptSize); ProcSetString(&d->PluginOptions,s->PluginOptions,&d->PluginOptSize); if(s->Environment) { if(d->EnvAllocSize<s->EnvSize) { d->Environment=(char*)realloc(d->Environment,s->EnvSize); d->EnvAllocSize = s->EnvSize; } memcpy(d->Environment,s->Environment,s->EnvSize); d->EnvSize=s->EnvSize; } else if(d->Environment) FreeEnvironment(src); if(s->Context) { if(d->ContextSize!=s->ContextSize) { d->Context = realloc(d->Context,s->ContextSize); d->ContextSize = s->ContextSize; } memcpy(d->Context,s->Context,s->ContextSize); } else if(d->Context) FreeContext(dest); } __declspec(dllexport) void SetCommandline(HostData *Proc,char *commandline) { if(!Proc) return; if(!Proc->ProcData) { Proc->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(Proc->ProcData,0,sizeof(TProcessData)); } ProcSetString(&Proc->ProcData->Commandline,commandline,&Proc->ProcData->CmdSize); } }
#include <vcl\vcl.h> #pragma hdrstop #include "Environment.h" #include "..\mpirun\plugins\Plugin.h" #if ((BCBVER > 1)) #include <stdio.h> #endif extern "C" {
__declspec(dllexport) void PutEnvString(HostData *Proc,char *Name,char *value) { char *OldPos; DWORD oldLen,newLen,OldIndex,oldSize,namelen; if(!value) value=""; namelen = strlen(Name); newLen=namelen+strlen(value)+2; oldLen = 0; if(!Proc->ProcData) { Proc->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(Proc->ProcData,0,sizeof(TProcessData)); } if(!Proc->ProcData->Environment) { Proc->ProcData->Environment = (char*)malloc(128); Proc->ProcData->EnvAllocSize=128; *Proc->ProcData->Environment=0; Proc->ProcData->EnvSize=1; } OldPos=GetEnvString(Proc,Name,0,&oldLen); if(!OldPos) { return; } if(oldLen) oldLen += namelen+1; OldIndex=(DWORD)(OldPos-Proc->ProcData->Environment); if(oldLen>=newLen) { memmove(OldPos+newLen,OldPos+oldLen,Proc->ProcData->EnvSize-(OldIndex+oldLen)); Proc->ProcData->EnvSize-=(oldLen-newLen); } else { oldSize=Proc->ProcData->EnvSize; Proc->ProcData->EnvSize+=(newLen-oldLen); if(Proc->ProcData->EnvAllocSize<Proc->ProcData->EnvSize) { Proc->ProcData->EnvAllocSize= max(Proc->ProcData->EnvSize,2*Proc->ProcData->EnvAllocSize); Proc->ProcData->Environment= (char*)realloc(Proc->ProcData->Environment,Proc->ProcData->EnvAllocSize); OldPos=Proc->ProcData->Environment+OldIndex; } memmove(OldPos+newLen,OldPos+oldLen,oldSize-OldIndex-oldLen); } sprintf(OldPos,"%s=%s",Name,value); } __declspec(dllexport) void *GetContext(HostData *Host,DWORD size) { if(!Host) return 0; if(!Host->ProcData) { if(!size) return 0; Host->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(Host->ProcData,0,sizeof(TProcessData)); } if(Host->ProcData->ContextSize<size) { Host->ProcData->Context = realloc(Host->ProcData->Context,size); Host->ProcData->ContextSize = size; } return Host->ProcData->Context; } void EmptyEnvironment(HostData *Proc) { if(Proc && Proc->ProcData && Proc->ProcData->Environment) { *Proc->ProcData->Environment = 0; Proc->ProcData->EnvSize=1; } } void FreeEnvironment(HostData * Proc) { if(!Proc || !Proc->ProcData) return; if(Proc->ProcData->Environment) { free(Proc->ProcData->Environment); } Proc->ProcData->Environment = 0; Proc->ProcData->EnvSize=0; Proc->ProcData->EnvAllocSize=0; } void ProcSetString(char **str,const char *val,DWORD *size) { DWORD len; if(!val) { ProcStrRemove(str,size); return; } len = strlen(val)+1; if(*size<len) { *str = (char*)realloc(*str,len); *size = len; } strcpy(*str,val); } void ProcStrRemove(char **str,DWORD *size) { if(*str) { free(*str); *str = 0; } *size = 0; } __declspec(dllexport) void FreeContext(HostData *Host) { if(!Host || !Host->ProcData||!Host->ProcData->Context) return; free(Host->ProcData->Context); Host->ProcData->Context = 0; Host->ProcData->ContextSize = 0; } void FreeProcData(HostData *Proc) { if(!Proc || !Proc->ProcData) return; FreeContext(Proc); FreeEnvironment(Proc); ProcStrRemove(&Proc->ProcData->Commandline,&Proc->ProcData->CmdSize); ProcStrRemove(&Proc->ProcData->Executable,&Proc->ProcData->ExeSize); ProcStrRemove(&Proc->ProcData->WorkingDir,&Proc->ProcData->WDSize); ProcStrRemove(&Proc->ProcData->UserOptions,&Proc->ProcData->OptSize); ProcStrRemove(&Proc->ProcData->PluginOptions,&Proc->ProcData->PluginOptSize); free(Proc->ProcData); Proc->ProcData = 0; } void CopyProcData(HostData *dest,HostData *src) { TProcessData *d,*s; if(!src || !src->ProcData) { if(dest && dest->ProcData) FreeProcData(dest); return; } if(!dest->ProcData) { dest->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(dest->ProcData,0,sizeof(TProcessData)); } d = dest->ProcData; s = src->ProcData; d->LockIt = s->LockIt; d->PriorityClass = s->PriorityClass; d->LoadProfile = s->LoadProfile; ProcSetString(&d->Executable,s->Executable,&d->ExeSize); ProcSetString(&d->WorkingDir,s->WorkingDir,&d->WDSize); ProcSetString(&d->UserOptions,s->UserOptions,&d->OptSize); ProcSetString(&d->PluginOptions,s->PluginOptions,&d->PluginOptSize); if(s->Environment) { if(d->EnvAllocSize<s->EnvSize) { d->Environment=(char*)realloc(d->Environment,s->EnvSize); d->EnvAllocSize = s->EnvSize; } memcpy(d->Environment,s->Environment,s->EnvSize); d->EnvSize=s->EnvSize; } else if(d->Environment) FreeEnvironment(src); if(s->Context) { if(d->ContextSize!=s->ContextSize) { d->Context = realloc(d->Context,s->ContextSize); d->ContextSize = s->ContextSize; } memcpy(d->Context,s->Context,s->ContextSize); } else if(d->Context) FreeContext(dest); } __declspec(dllexport) void SetCommandline(HostData *Proc,char *commandline) { if(!Proc) return; if(!Proc->ProcData) { Proc->ProcData = (TProcessData*)malloc(sizeof(TProcessData)); memset(Proc->ProcData,0,sizeof(TProcessData)); } ProcSetString(&Proc->ProcData->Commandline,commandline,&Proc->ProcData->CmdSize); } }
__declspec(dllexport) char* GetEnvString(HostData *Proc,char *Name,char *value,DWORD *BufSize) { char *act, *pos; int res; DWORD lenAll,lenStName,lenGName,lenValue; if(!Proc || !Proc->ProcData) return 0; act=Proc->ProcData->Environment; if(value) *value=0; if(!Name) { return 0; } while(act&&*act) { lenAll=strlen(act); pos=strchr(act+1,'='); if(! pos) { act+=(lenAll+1); continue; } lenStName=(DWORD)(pos-act); lenGName=strlen(Name); res=strnicmp(act,Name,min(lenStName,lenGName)); if(!res) { if(lenStName > lenGName) res = 1; else if(lenStName < lenGName) res = -1; else { lenValue = strlen(pos+1)+1; if(value && lenValue<=*BufSize) strcpy(value,pos+1); *BufSize = lenValue; return act; } } if(res>0) { *BufSize = 0; return act; } act+=(lenAll+1); } *BufSize = 0; return act; }
function_block-full_function
[ { "content": "extern ADIOI_Flatlist_node *ADIOI_Flatlist;\n", "file_path": "romio/adio/include/adio_extern.h", "rank": 0, "score": 127407.15731490849 }, { "content": "extern MPI_Info *MPIR_Infotable;\n", "file_path": "romio/adio/include/adio_extern.h", "rank": 1, "score": 127396....
C++
image_processing/toolbox/classify/private/multiclassQuantizedTreeTrain1.cpp
bruceli-rw0/edge2pic-generation
e9ee6f89361d1a12b044c0ab665a09fca4a47089
#include <string.h> #include <stdint.h> #include <math.h> #include <mex.h> #include <iostream> #include <vector> #ifdef USEOMP #include <omp.h> #endif typedef unsigned char uint8; typedef unsigned int uint32; #define gini(p) p*p void constructCdfPerClass( uint8* data, uint32 *hs, float *wts, int nBins, int N, uint32 *dids, std::vector<std::vector<double> >& cdfs ) { for(int i=0; i<N; i++) { cdfs[hs[dids[i]]-1][data[dids[i]]] += wts[dids[i]]; } for (int h=0; h<cdfs.size(); h++) for(int i=1; i<nBins; i++) cdfs[h][i] += cdfs[h][i-1]; } void constructCdf( uint8* data, float *wts, int nBins, int N, uint32 *dids, std::vector<double>& cdf ) { for(int i=0; i<N; i++) cdf[data[dids[i]]] += wts[dids[i]]; for(int i=1; i<nBins; i++) cdf[i] += cdf[i-1]; } void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int H, N, N1, F1, F, split; uint8 *data; uint32* fids, *dids; float *wts, thr; double gain; uint32 *hs; double cfactor, *costs_factor; int nBins, nThreads; data = (uint8*) mxGetData(prhs[0]); hs = (uint32*) mxGetData(prhs[1]); wts = (float*) mxGetData(prhs[2]); nBins = (int) mxGetScalar(prhs[3]); dids = (uint32*) mxGetData(prhs[4]); fids = (uint32*) mxGetData(prhs[5]); H = (int) mxGetScalar(prhs[6]); split = (int) mxGetScalar(prhs[7]); costs_factor = (double*) mxGetData(prhs[8]); nThreads = (int) mxGetScalar(prhs[9]); N = (int) mxGetM(prhs[0]); F = (int) mxGetN(prhs[0]); N1 = (int) mxGetNumberOfElements(prhs[4]); F1 = (int) mxGetNumberOfElements(prhs[5]); plhs[0] = mxCreateNumericMatrix(1,F1,mxDOUBLE_CLASS,mxREAL); plhs[1] = mxCreateNumericMatrix(1,F1,mxDOUBLE_CLASS,mxREAL); plhs[2] = mxCreateNumericMatrix(1,F1,mxDOUBLE_CLASS,mxREAL); double *split_val = (double*) mxGetData(plhs[0]); double *thrs = (double*) mxGetData(plhs[1]); double *gains = (double*) mxGetData(plhs[2]); double vInit, w, g; std::vector<double> W(H, 0.0); vInit = 0; g = 0; w = 0; for(int j=0; j<N1; j++ ) { w+=wts[dids[j]]; W[hs[dids[j]]-1]+=wts[dids[j]]; } for(int i=0; i<H; i++ ) g+=gini((W[i]*costs_factor[i])/w); vInit=(1.-g); #ifdef USEOMP nThreads = std::min(nThreads,omp_get_max_threads()); #pragma omp parallel for num_threads(nThreads) #endif for(int i=0; i<F1; i++ ) { double wl, wr, gl, gr, v, pl, pr; double best = vInit; uint8* data1 = (uint8*)(data + (fids[i]*size_t(N))); std::vector<double> cdf(nBins, 0.0); std::vector<std::vector<double> > cdfs(H, cdf); constructCdfPerClass(data1,hs,wts,nBins,N1,dids,cdfs); constructCdf(data1,wts,nBins,N1,dids,cdf); for(int j=0; j<nBins-1; j++) { gl = 0.; gr = 0.; wl = cdf[j]; wr = cdf[nBins-1] - cdf[j]; for (int h=0; h<H; h++) { cfactor = costs_factor[h]; pl = (cdfs[h][j]); pl *= cfactor; pr = ((cdfs[h][nBins-1]-cdfs[h][j])); pr *= cfactor; gl += gini(pl); gr += gini(pr); } v = (wl-(gl/wl))/w + (wr-(gr/wr))/w; if( v<best ) { best = v; split_val[i] = best; gains[i] = vInit - best; thrs[i] = j; } } } }
#include <string.h> #include <stdint.h> #include <math.h> #include <mex.h> #include <iostream> #include <vector> #ifdef USEOMP #include <omp.h> #endif typedef unsigned char uint8; typedef unsigned int uint32; #define gini(p) p*p void constructCdfPerClass( uint8* data, uint32 *hs, float *wts, int nBins, int N, uint32 *dids, std::vector<std::vector<double> >& cdfs ) { for(int i=0; i<N; i++) { cdfs[hs[dids[i]]-1][data[dids[i]]] += wts[dids[i]]; } for (int h=0; h<cdfs.size(); h++) for(int i=1; i<nBins; i++) cdfs[h][i] += cdfs[h][i-1]; }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { int H, N, N1, F1, F, split; uint8 *data; uint32* fids, *dids; float *wts, thr; double gain; uint32 *hs; double cfactor, *costs_factor; int nBins, nThreads; data = (uint8*) mxGetData(prhs[0]); hs = (uint32*) mxGetData(prhs[1]); wts = (float*) mxGetData(prhs[2]); nBins = (int) mxGetScalar(prhs[3]); dids = (uint32*) mxGetData(prhs[4]); fids = (uint32*) mxGetData(prhs[5]); H = (int) mxGetScalar(prhs[6]); split = (int) mxGetScalar(prhs[7]); costs_factor = (double*) mxGetData(prhs[8]); nThreads = (int) mxGetScalar(prhs[9]); N = (int) mxGetM(prhs[0]); F = (int) mxGetN(prhs[0]); N1 = (int) mxGetNumberOfElements(prhs[4]); F1 = (int) mxGetNumberOfElements(prhs[5]); plhs[0] = mxCreateNumericMatrix(1,F1,mxDOUBLE_CLASS,mxREAL); plhs[1] = mxCreateNumericMatrix(1,F1,mxDOUBLE_CLASS,mxREAL); plhs[2] = mxCreateNumericMatrix(1,F1,mxDOUBLE_CLASS,mxREAL); double *split_val = (double*) mxGetData(plhs[0]); double *thrs = (double*) mxGetData(plhs[1]); double *gains = (double*) mxGetData(plhs[2]); double vInit, w, g; std::vector<double> W(H, 0.0); vInit = 0; g = 0; w = 0; for(int j=0; j<N1; j++ ) { w+=wts[dids[j]]; W[hs[dids[j]]-1]+=wts[dids[j]]; } for(int i=0; i<H; i++ ) g+=gini((W[i]*costs_factor[i])/w); vInit=(1.-g); #ifdef USEOMP nThreads = std::min(nThreads,omp_get_max_threads()); #pragma omp parallel for num_threads(nThreads) #endif for(int i=0; i<F1; i++ ) { double wl, wr, gl, gr, v, pl, pr; double best = vInit; uint8* data1 = (uint8*)(data + (fids[i]*size_t(N))); std::vector<double> cdf(nBins, 0.0); std::vector<std::vector<double> > cdfs(H, cdf); constructCdfPerClass(data1,hs,wts,nBins,N1,dids,cdfs); constructCdf(data1,wts,nBins,N1,dids,cdf); for(int j=0; j<nBins-1; j++) { gl = 0.; gr = 0.; wl = cdf[j]; wr = cdf[nBins-1] - cdf[j]; for (int h=0; h<H; h++) { cfactor = costs_factor[h]; pl = (cdfs[h][j]); pl *= cfactor; pr = ((cdfs[h][nBins-1]-cdfs[h][j])); pr *= cfactor; gl += gini(pl); gr += gini(pr); } v = (wl-(gl/wl))/w + (wr-(gr/wr))/w; if( v<best ) { best = v; split_val[i] = best; gains[i] = vInit - best; thrs[i] = j; } } } }
void constructCdf( uint8* data, float *wts, int nBins, int N, uint32 *dids, std::vector<double>& cdf ) { for(int i=0; i<N; i++) cdf[data[dids[i]]] += wts[dids[i]]; for(int i=1; i<nBins; i++) cdf[i] += cdf[i-1]; }
function_block-full_function
[ { "content": "/*******************************************************************************\n\n* Piotr's Computer Vision Matlab Toolbox Version 3.01\n\n* Copyright 2014 Piotr Dollar. [pdollar-at-gmail.com]\n\n* Licensed under the Simplified BSD License [see external/bsd.txt]\n\n************************...
C++
cpp/src/simulator.cpp
mamariomiamo/online_dmpc
63a135ce6bf6f1c3a0970129a23e569797801b6c
#include "iostream" #include "simulator.h" using namespace Eigen; using namespace std; using namespace std::chrono; using json = nlohmann::json; Simulator::Simulator(std::ifstream& config_file) { Generator::Params p = parseJSON(config_file); _generator = std::make_unique<Generator>(p); _sim_model = std::make_unique<DoubleIntegrator3D>(p.mpc_params.Ts, p.model_params); _h = p.mpc_params.h; _Ts = p.mpc_params.Ts; _po = p.po; _pf = p.pf; _pmin = p.mpc_params.limits.pmin; _pmax = p.mpc_params.limits.pmax; _current_states.reserve(_Ncmd); _trajectories.reserve(_Ncmd); _ellipses = _generator->getEllipses(); for (int i = 0; i < _Ncmd; i++) { State3D agent_i = {_po.col(i), VectorXd::Zero(_po.rows())}; _current_states.push_back(addRandomNoise(agent_i)); } } Generator::Params Simulator::parseJSON(std::ifstream& config_file) { json j; config_file >> j; _N = j["N"]; _Ncmd = j["Ncmd"]; std::string solver_name = j["solver"]; Solver qp_solver; if (!solver_name.compare("qpoases")) qp_solver = kQpoases; else throw std::invalid_argument("Invalid solver '" + solver_name + " '"); _bezier_params = {j["d"], j["num_segments"], j["dim"], j["deg_poly"], j["t_segment"]}; _model_params = {j["zeta_xy"], j["tau_xy"], j["zeta_z"], j["tau_z"]}; VectorXd energy_weights = VectorXd::Zero(static_cast<int>(j["d"]) + 1); energy_weights(2) = j["acc_cost"]; TuningParams tune = {j["s_free"], j["s_obs"], j["s_repel"], j["spd_f"], j["spd_o"], j["spd_r"], j["lin_coll"], j["quad_coll"], energy_weights}; vector<double> pmin_vec = j["pmin"]; vector<double> pmax_vec = j["pmax"]; vector<double> amin_vec = j["amin"]; vector<double> amax_vec = j["amax"]; Vector3d pmin(pmin_vec.data()); Vector3d pmax(pmax_vec.data()); Vector3d amin(amin_vec.data()); Vector3d amax(amax_vec.data()); PhysicalLimits limits = {pmax, pmin, amax, amin}; _mpc_params = {j["h"], j["ts"], j["k_hor"], tune, limits}; EllipseParams ellipse_params; ellipse_params.order = j["order"]; ellipse_params.rmin = j["rmin"]; ellipse_params.c = (Eigen::Vector3d() << 1.0, 1.0, j["height_scaling"]).finished(); std::vector<EllipseParams> ellipse_vec(_Ncmd, ellipse_params); EllipseParams ellipse_params_obs; ellipse_params_obs.order = j["order_obs"]; ellipse_params_obs.rmin = j["rmin_obs"]; ellipse_params_obs.c = (Eigen::Vector3d() << 1.0, 1.0, j["height_scaling_obs"]).finished(); std::vector<EllipseParams> ellipse_vec_obs(_N - _Ncmd, ellipse_params_obs); ellipse_vec.insert(ellipse_vec.end(), ellipse_vec_obs.begin(), ellipse_vec_obs.end()); _pos_std = j["std_position"]; _vel_std = j["std_velocity"]; std::string test_type = j["test"]; if (!test_type.compare("default")) { vector<vector<double>> po_vec = j["po"]; _po = MatrixXd::Zero(j["dim"], _N); for (int i = 0; i < _N; i++) { Vector3d poi(po_vec[i].data()); _po.col(i) = poi; } vector<vector<double>> pf_vec = j["pf"]; _pf = MatrixXd::Zero(j["dim"], _Ncmd); for (int i = 0; i < _Ncmd; i++) { Vector3d pfi(pf_vec[i].data()); _pf.col(i) = pfi; } } else if (!test_type.compare("random")) { _po = generateRandomPoints(_N, limits.pmin.array() + 0.3, limits.pmax.array() - 0.3, ellipse_params.rmin + 0.2); _pf = generateRandomPoints(_Ncmd, limits.pmin.array() + 0.3, limits.pmax.array() - 0.3, ellipse_params.rmin + 0.2); } else throw std::invalid_argument("Invalid test type '" + test_type + " '"); Generator::Params p = {_bezier_params, _model_params, ellipse_vec, _mpc_params, _po, _pf, qp_solver}; return p; } void Simulator::run(int duration) { auto K = static_cast<int>(floor(duration / _Ts)); for (int i = 0; i < _Ncmd; i++) { _trajectories.push_back(MatrixXd::Zero(_po.rows(), K)); } auto max_count = static_cast<int>(_h / _Ts); int count = max_count; high_resolution_clock::time_point t1, t2; for (int k = 0; k < K; k++) { if (count == max_count) { t1 = high_resolution_clock::now(); _inputs = _generator->getNextInputs(_current_states); t2 = high_resolution_clock::now(); auto mpc_duration = duration_cast<microseconds>( t2 - t1 ).count(); cout << "Solving frequency = " << 1000000.0 / mpc_duration << " Hz" << endl; count = 0; } for (int i = 0; i < _Ncmd; i++) { State3D sim_states = _sim_model->applyInput(_current_states[i], _inputs[i].col(count)); _current_states[i] = addRandomNoise(sim_states); _trajectories[i].col(k) = _current_states[i].pos; } count++; } collisionCheck(_trajectories); goalCheck(_current_states); } bool Simulator::collisionCheck(const std::vector<Eigen::MatrixXd> &trajectories) { float rmin_check = 0.15; int order = 2; VectorXd c_check = (Eigen::Vector3d() << 1.0, 1.0, 3.0).finished(); MatrixXd E_check = c_check.asDiagonal(); MatrixXd E1_check = E_check.inverse(); MatrixXd differ; VectorXd dist; bool violation = false; double min_dist; int pos; for (int i = 0; i < _Ncmd; i++) { for (int j = i + 1; j < _Ncmd; j++) { if (i != j) { differ = E1_check * (trajectories[i] - trajectories[j]); dist = pow(((differ.array().pow(order)).colwise().sum()),1.0 / order); min_dist = dist.minCoeff(&pos); if (min_dist < rmin_check) { violation = true; cout << "Collision constraint violation: "; cout << "Vehicles " << i << " and " << j; cout << " will be " << min_dist << "m"; cout << " apart @ t = " << (float)pos * _Ts << "s" << endl; } } } } if (!violation) cout << "No collisions found!" << endl; return violation; } bool Simulator::goalCheck(const std::vector<State3D> &states) { Vector3d diff; double dist; bool reached_goal = true; float goal_tolerance = 0.1; for (int i = 0; i < _Ncmd; i++) { diff = states[i].pos - _pf.col(i); dist = pow(((diff.array().pow(2)).sum()),1.0 / 2); if (dist > goal_tolerance){ cout << "Vehicle " << i << " did not reached its goal by " << dist << " m" << endl; reached_goal = false; } } if (reached_goal) cout << "All the vehicles reached their goals!" << endl; return reached_goal; } State3D Simulator::addRandomNoise(const State3D &states) { std::random_device rd; std::mt19937 gen(rd()); VectorXd state_vector = VectorXd::Zero(6); state_vector << states.pos, states.vel; double sample = 0.0; std::normal_distribution<double> distribution_position(0.0, _pos_std); std::normal_distribution<double> distribution_velocity(0.0, _vel_std); for (int i = 0; i < 6; i++) { if (i < 3) sample = distribution_position(gen); else sample = distribution_velocity(gen); state_vector[i] += sample; } State3D result = {state_vector.segment(0, 3), state_vector.segment(3, 3)}; return result; } void Simulator::saveDataToFile(char const *pathAndName) { ofstream file(pathAndName, ios::out | ios::trunc); if(file) { cout << "Writing solution to text file..." << endl; file << _N << " " << _Ncmd << " " << _pmin.transpose() << " " << _pmax.transpose() << endl; file << _po << endl; file << _pf << endl; for(int i=0; i < _Ncmd; ++i) file << _trajectories[i] << endl; file.close(); } else { cerr << "Error while trying to open file" << endl; } } MatrixXd Simulator::generateRandomPoints(int N, const Vector3d &pmin, const Vector3d &pmax, float rmin) { MatrixXd pts = MatrixXd::Zero(3, N); Vector3d candidate = MatrixXd::Zero(3, 1); VectorXd dist; bool pass = false; pts.col(0) = pmin.array() + (pmax - pmin).array() * ((MatrixXd::Random(3, 1).array() + 1) / 2); for (int n = 1; n < N; ++n) { while (!pass) { candidate = pmin.array() + (pmax - pmin).array() * ((MatrixXd::Random(3, 1).array() + 1) / 2); dist = ((((pts.leftCols(n)).colwise() - candidate).array().square()).colwise().sum()).array().sqrt(); for (int k = 0; k < n; ++k) { pass = dist[k] > rmin; if (!pass) break; } if (pass) pts.col(n) = candidate.array(); } pass = false; } return pts; }
#include "iostream" #include "simulator.h" using namespace Eigen; using namespace std; using namespace std::chrono; using json = nlohmann::json; Simulator::Simulator(std::ifstream& config_file) { Generator::Params p = parseJSON(config_file); _generator = std::make_unique<Generator>(p); _sim_model = std::make_unique<DoubleIntegrator3D>(p.mpc_params.Ts, p.model_params); _h = p.mpc_params.h; _Ts = p.mpc_params.Ts; _po = p.po; _pf = p.pf; _pmin = p.mpc_params.limits.pmin; _pmax = p.mpc_params.limits.pmax; _current_states.reserve(_Ncmd); _trajectories.reserve(_Ncmd); _ellipses = _generator->getEllipses(); for (int i = 0; i < _Ncmd; i++) { State3D agent_i = {_po.col(i), VectorXd::Zero(_po.rows())}; _current_states.push_back(addRandomNoise(agent_i)); } } Generator::Params Simulator::parseJSON(std::ifstream& config_file) { json j; config_file >> j; _N = j["N"]; _Ncmd = j["Ncmd"]; std::string solver_name = j["solver"]; Solver qp_solver; if (!solver_name.compare("qpoases")) qp_solver = kQpoases; else throw std::invalid_argument("Invalid solver '" + solver_name + " '"); _bezier_params = {j["d"], j["num_segments"], j["dim"], j["deg_poly"], j["t_segment"]}; _model_params = {j["zeta_xy"], j["tau_xy"], j["zeta_z"], j["tau_z"]}; VectorXd energy_weights = VectorXd::Zero(static_cast<int>(j["d"]) + 1); energy_weights(2) = j["acc_cost"]; TuningParams tune = {j["s_free"], j["s_obs"], j["s_repel"], j["spd_f"], j["spd_o"], j["spd_r"], j["lin_coll"], j["quad_coll"], energy_weights}; vector<double> pmin_vec = j["pmin"]; vector<double> pmax_vec = j["pmax"]; vector<double> amin_vec = j["amin"]; vector<double> amax_vec = j["amax"]; Vector3d pmin(pmin_vec.data()); Vector3d pmax(pmax_vec.data()); Vector3d amin(amin_vec.data()); Vector3d amax(amax_vec.data()); PhysicalLimits limits = {pmax, pmin, amax, amin}; _mpc_params = {j["h"], j["ts"], j["k_hor"], tune, limits}; EllipseParams ellipse_params; ellipse_params.order = j["order"]; ellipse_params.rmin = j["rmin"]; ellipse_params.c = (Eigen::Vector3d() << 1.0, 1.0, j["height_scaling"]).finished(); std::vector<EllipseParams> ellipse_vec(_Ncmd, ellipse_params); EllipseParams ellipse_params_obs; ellipse_params_obs.order = j["order_obs"]; ellipse_params_obs.rmin = j["rmin_obs"]; ellipse_params_obs.c = (Eigen::Vector3d() << 1.0, 1.0, j["height_scaling_obs"]).finished(); std::vector<EllipseParams> ellipse_vec_obs(_N - _Ncmd, ellipse_params_obs); ellipse_vec.insert(ellipse_vec.end(), ellipse_vec_obs.begin(), ellipse_vec_obs.end()); _pos_std = j["std_position"]; _vel_std = j["std_velocity"]; std::string test_type = j["test"]; if (!test_type.compare("default")) { vector<vector<double>> po_vec = j["po"]; _po = MatrixXd::Zero(j["dim"], _N); for (int i = 0; i < _N; i++) { Vector3d poi(po_vec[i].data()); _po.col(i) = poi; } vector<vector<double>> pf_vec = j["pf"]; _pf = MatrixXd::Zero(j["dim"], _Ncmd); for (int i = 0; i < _Ncmd; i++) { Vector3d pfi(pf_vec[i].data()); _pf.col(i) = pfi; } } else if (!test_type.compare("random")) { _po = generateRandomPoints(_N, limits.pmin.array() + 0.3, limits.pmax.array() - 0.3, ellipse_params.rmin + 0.2); _pf = generateRandomPoints(_Ncmd, limits.pmin.array() + 0.3, limits.pmax.array() - 0.3, ellipse_params.rmin + 0.2); } else throw std::invalid_argument("Invalid test type '" + test_type + " '"); Generator::Params p = {_bezier_params, _model_params, ellipse_vec, _mpc_params, _po, _pf, qp_solver}; return p; } void Simulator::run(int duration) { auto K = static_cast<int>(floor(duration / _Ts)); for (int i = 0; i < _Ncmd; i++) { _trajectories.push_back(MatrixXd::Zero(_po.rows(), K)); } auto max_count = static_cast<int>(_h / _Ts); int count = max_count; high_resolution_clock::time_point t1, t2; for (int k = 0; k < K; k++) { if (count == max_count) { t1 = high_resolution_clock::now(); _inputs = _generator->getNextInputs(_current_states); t2 = high_resolution_clock::now(); auto mpc_duration = duration_cast<microseconds>( t2 - t1 ).count(); cout << "Solving frequency = " << 1000000.0 / mpc_duration << " Hz" << endl; count = 0; } for (int i = 0; i < _Ncmd; i++) { State3D sim_states = _sim_model->applyInput(_current_states[i], _inputs[i].col(count)); _current_states[i] = addRandomNoise(sim_states); _trajectories[i].col(k) = _current_states[i].pos; } count++; } collisionCheck(_trajectories); goalCheck(_current_states); } bool Simulator::collisionCheck(const std::vector<Eigen::MatrixXd> &trajectories) { float rmin_check = 0.15; int order = 2; VectorXd c_check = (Eigen::Vector3d() << 1.0, 1.0, 3.0).finished(); MatrixXd E_check = c_check.asDiagonal(); MatrixXd E1_check = E_check.inverse(); MatrixXd differ; VectorXd dist; bool violation = false; double min_dist; int pos; for (int i = 0; i < _Ncmd; i++) { for (int j = i + 1; j < _Ncmd; j++) { if (i != j) { differ = E1_check * (trajectories[i] - trajectories[j]); dist = pow(((differ.array().pow(order)).colwise().sum()),1.0 / order); min_dist = dist.minCoeff(&pos); if (min_dist < rmin_check) { violation = true; cout << "Collision constraint violation: "; cout << "Vehicles " << i << " and " << j; cout << " will be " << min_dist << "m"; cout << " apart @ t = " << (float)pos * _Ts << "s" << endl; } } } } if (!violation) cout << "No collisions found!" << endl; return violation; } bool Simulator::goalCheck(const std::vector<State3D> &states) { Vector3d diff; double dist; bool reached_goal = true; float goal_tolerance = 0.1; for (int i = 0; i < _Ncmd; i++) { diff = states[i].pos - _pf.col(i); dist = pow(((diff.array().pow(2)).sum()),1.0 / 2); if (dist > goal_tolerance){ cout << "Vehicle " << i << " did not reached its goal by " << dist << " m" << endl; reached_goal = false; } } if (reached_goal) cout << "All the vehicles reached their goals!" << endl; return reached_goal; } State3D Simulator::addRandomNoise(const State3D &states) { std::random_device rd; std::mt19937 gen(rd()); VectorXd state_vector = VectorXd::Zero(6); state_vector << states.pos, states.vel; double sample = 0.0; std::normal_distribution<double> distribution_position(0.0, _pos_std); std::normal_distribution<double> distribution_velocity(0.0, _vel_std); for (int i = 0; i < 6; i++) { if (i < 3) sample = distribution_position(gen); else sample = distribution_velocity(gen); state_vector[i] += sample; } State3D result = {state_vector.segment(0, 3), state_vector.segment(3, 3)}; return result; } void Simulator::saveDataToFile(char const *pathAndName) { ofstream file(pathAndName, ios::out | ios::trunc); if(file) { cout << "Writing solution to text file..." << endl; file << _N << " " << _Ncmd << " " << _pmin.transpose() << " " << _pmax.transpose() << endl;
MatrixXd Simulator::generateRandomPoints(int N, const Vector3d &pmin, const Vector3d &pmax, float rmin) { MatrixXd pts = MatrixXd::Zero(3, N); Vector3d candidate = MatrixXd::Zero(3, 1); VectorXd dist; bool pass = false; pts.col(0) = pmin.array() + (pmax - pmin).array() * ((MatrixXd::Random(3, 1).array() + 1) / 2); for (int n = 1; n < N; ++n) { while (!pass) { candidate = pmin.array() + (pmax - pmin).array() * ((MatrixXd::Random(3, 1).array() + 1) / 2); dist = ((((pts.leftCols(n)).colwise() - candidate).array().square()).colwise().sum()).array().sqrt(); for (int k = 0; k < n; ++k) { pass = dist[k] > rmin; if (!pass) break; } if (pass) pts.col(n) = candidate.array(); } pass = false; } return pts; }
file << _po << endl; file << _pf << endl; for(int i=0; i < _Ncmd; ++i) file << _trajectories[i] << endl; file.close(); } else { cerr << "Error while trying to open file" << endl; } }
function_block-function_prefix_line
[ { "content": "struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};\n\n\n\ntemplate <typename BasicJsonType, typename CompatibleObjectType,\n\n typename = void>\n", "file_path": "cpp/include/json.hpp", "rank": 0, "score": 123715.87774488093 }, { "content": " ...
C++
net/ias/mmc/nap/logcompd.cpp
npocmaka/Windows-Server-2003
5c6fe3db626b63a384230a1aa6b92ac416b0765f
#include "Precompiled.h" #include "LogCompD.h" #include "LogMacNd.h" #include "LocalFileLoggingNode.h" #include "LoggingMethodsNode.h" #include "LogComp.h" #include <stdio.h> #include "ChangeNotification.h" CLoggingComponentData::CLoggingComponentData() { ATLTRACE(_T("+NAPMMC+:# +++ CLoggingComponentData::CLoggingComponentData\n")); m_pComponentData = this; } CLoggingComponentData::~CLoggingComponentData() { ATLTRACE(_T("+NAPMMC+:# --- CLoggingComponentData::~CLoggingComponentData\n")); } STDMETHODIMP CLoggingComponentData::Initialize (LPUNKNOWN pUnknown) { ATLTRACE(_T("+NAPMMC+:# CLoggingComponentData::Initialize\n")); m_CLoggingMachineNode.m_pComponentData = this; HRESULT hr = IComponentDataImpl<CLoggingComponentData, CLoggingComponent >::Initialize(pUnknown); if (FAILED(hr)) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- Base class initialization\n")); return hr; } CComPtr<IImageList> spImageList; if (m_spConsole->QueryScopeImageList(&spImageList) != S_OK) { ATLTRACE(_T("+NAPMMC+:***FAILED***: IConsole::QueryScopeImageList failed\n")); return E_UNEXPECTED; } HBITMAP hBitmap16 = LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_NAPSNAPIN_16)); if (hBitmap16 == NULL) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- LoadBitmap\n")); return S_OK; } HBITMAP hBitmap32 = LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_NAPSNAPIN_32)); if (hBitmap32 == NULL) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- LoadBitmap\n")); return S_OK; } if (spImageList->ImageListSetStrip((LONG_PTR*)hBitmap16, (LONG_PTR*)hBitmap32, 0, RGB(255, 0, 255)) != S_OK) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- ImageListSetStrip\n")); return E_UNEXPECTED; } INITCOMMONCONTROLSEX initCommCtrlsEx; initCommCtrlsEx.dwSize = sizeof(INITCOMMONCONTROLSEX); initCommCtrlsEx.dwICC = ICC_WIN95_CLASSES ; if (!InitCommonControlsEx(&initCommCtrlsEx)) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- InitCommonControlsEx()\n")); return E_UNEXPECTED; } return S_OK; } STDMETHODIMP CLoggingComponentData::CompareObjects( LPDATAOBJECT lpDataObjectA , LPDATAOBJECT lpDataObjectB ) { ATLTRACE(_T("+NAPMMC+:# CLoggingComponentData::CompareObjects\n")); HRESULT hr; CSnapInItem *pDataA, *pDataB; DATA_OBJECT_TYPES typeA, typeB; hr = GetDataClass(lpDataObjectA, &pDataA, &typeA); if ( FAILED( hr ) ) { return hr; } hr = GetDataClass(lpDataObjectB, &pDataB, &typeB); if ( FAILED( hr ) ) { return hr; } if( pDataA == pDataB ) { return S_OK; } else { return S_FALSE; } } STDMETHODIMP CLoggingComponentData::CreateComponent(LPCOMPONENT *ppComponent) { ATLTRACE(_T("# CLoggingComponentData::CreateComponent\n")); HRESULT hr = E_POINTER; ATLASSERT(ppComponent != NULL); if (ppComponent == NULL) ATLTRACE(_T("# IComponentData::CreateComponent called with ppComponent == NULL\n")); else { *ppComponent = NULL; CComObject< CLoggingComponent >* pComponent; hr = CComObject< CLoggingComponent >::CreateInstance(&pComponent); ATLASSERT(SUCCEEDED(hr)); if (FAILED(hr)) ATLTRACE(_T("# IComponentData::CreateComponent : Could not create IComponent object\n")); else { hr = pComponent->QueryInterface(IID_IComponent, (void**)ppComponent); pComponent->m_pComponentData = this; } } return hr; } STDMETHODIMP CLoggingComponentData::Notify ( LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param) { ATLTRACE(_T("# CLoggingComponentData::Notify\n")); HRESULT hr; if ( NULL == lpDataObject ) { switch( event ) { case MMCN_PROPERTY_CHANGE: hr = OnPropertyChange( arg, param ); break; default: ATLTRACE(_T("# CLoggingComponent::Notify - called with lpDataObject == NULL and no event handler\n")); hr = E_NOTIMPL; break; } return hr; } CSnapInItem* pItem; DATA_OBJECT_TYPES type; hr = m_pComponentData->GetDataClass(lpDataObject, &pItem, &type); ATLASSERT(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { hr = pItem->Notify( event, arg, param, this, NULL, type ); } return hr; } HRESULT CLoggingComponentData::OnPropertyChange( LPARAM arg , LPARAM lParam ) { ATLTRACE(_T("# CLoggingComponentData::OnPropertyChange\n")); _ASSERTE( m_spConsole != NULL ); HRESULT hr = S_FALSE; if( lParam != NULL ) { CChangeNotification * pChangeNotification = (CChangeNotification *) lParam; hr = pChangeNotification->m_pNode->Notify( MMCN_PROPERTY_CHANGE , NULL , NULL , NULL , NULL , (DATA_OBJECT_TYPES) 0 ); hr = m_spConsole->UpdateAllViews( NULL, lParam, 0); pChangeNotification->Release(); } return hr; }
#include "Precompiled.h" #include "LogCompD.h" #include "LogMacNd.h" #include "LocalFileLoggingNode.h" #include "LoggingMethodsNode.h" #include "LogComp.h" #include <stdio.h> #include "ChangeNotification.h" CLoggingComponentData::CLoggingComponentData() { ATLTRACE(_T("+NAPMMC+:# +++ CLoggingComponentData::CLoggingComponentData\n")); m_pComponentData = this; } CLoggingComponentData::~CLoggingComponentData() { ATLTRACE(_T("+NAPMMC+:# --- CLoggingComponentData::~CLoggingComponentData\n")); } STDMETHODIMP CLoggingComponentData::Initialize (LPUNKNOWN pUnknown) { ATLTRACE(_T("+NAPMMC+:# CLoggingComponentData::Initialize\n")); m_CLoggingMachineNode.m_pComponentData = this; HRESULT hr = IComponentDataImpl<CLoggingComponentData, CLoggingComponent >::Initialize(pUnknown); if (FAILED(hr)) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- Base class initialization\n")); return hr; } CComPtr<IImageList> spImageList; if (m_spConsole->QueryScopeImageList(&spImageList) != S_OK) { ATLTRACE(_T("+NAPMMC+:***FAILED***: IConsole::QueryScopeImageList failed\n")); return E_UNEXPECTED; } HBITMAP hBitmap16 = LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_NAPSNAPIN_16)); if (hBitmap16 == NULL) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- LoadBitmap\n")); return S_OK; } HBITMAP hBitmap32 = LoadBitmap(_Module.GetResourceInstance(), MAKEINTRESOURCE(IDB_NAPSNAPIN_32)); if (hBitmap32 == NULL) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- LoadBitmap\n")); return S_OK; } if (spImageList->ImageListSetStrip((LONG_PTR*)hBitmap16, (LONG_PTR*)hBitmap32, 0, RGB(255, 0, 255)) != S_OK) { ATLTRACE(_T("+NAPMMC+:*
, LPARAM lParam ) { ATLTRACE(_T("# CLoggingComponentData::OnPropertyChange\n")); _ASSERTE( m_spConsole != NULL ); HRESULT hr = S_FALSE; if( lParam != NULL ) { CChangeNotification * pChangeNotification = (CChangeNotification *) lParam; hr = pChangeNotification->m_pNode->Notify( MMCN_PROPERTY_CHANGE , NULL , NULL , NULL , NULL , (DATA_OBJECT_TYPES) 0 ); hr = m_spConsole->UpdateAllViews( NULL, lParam, 0); pChangeNotification->Release(); } return hr; }
**FAILED***: CLoggingComponentData::Initialize -- ImageListSetStrip\n")); return E_UNEXPECTED; } INITCOMMONCONTROLSEX initCommCtrlsEx; initCommCtrlsEx.dwSize = sizeof(INITCOMMONCONTROLSEX); initCommCtrlsEx.dwICC = ICC_WIN95_CLASSES ; if (!InitCommonControlsEx(&initCommCtrlsEx)) { ATLTRACE(_T("+NAPMMC+:***FAILED***: CLoggingComponentData::Initialize -- InitCommonControlsEx()\n")); return E_UNEXPECTED; } return S_OK; } STDMETHODIMP CLoggingComponentData::CompareObjects( LPDATAOBJECT lpDataObjectA , LPDATAOBJECT lpDataObjectB ) { ATLTRACE(_T("+NAPMMC+:# CLoggingComponentData::CompareObjects\n")); HRESULT hr; CSnapInItem *pDataA, *pDataB; DATA_OBJECT_TYPES typeA, typeB; hr = GetDataClass(lpDataObjectA, &pDataA, &typeA); if ( FAILED( hr ) ) { return hr; } hr = GetDataClass(lpDataObjectB, &pDataB, &typeB); if ( FAILED( hr ) ) { return hr; } if( pDataA == pDataB ) { return S_OK; } else { return S_FALSE; } } STDMETHODIMP CLoggingComponentData::CreateComponent(LPCOMPONENT *ppComponent) { ATLTRACE(_T("# CLoggingComponentData::CreateComponent\n")); HRESULT hr = E_POINTER; ATLASSERT(ppComponent != NULL); if (ppComponent == NULL) ATLTRACE(_T("# IComponentData::CreateComponent called with ppComponent == NULL\n")); else { *ppComponent = NULL; CComObject< CLoggingComponent >* pComponent; hr = CComObject< CLoggingComponent >::CreateInstance(&pComponent); ATLASSERT(SUCCEEDED(hr)); if (FAILED(hr)) ATLTRACE(_T("# IComponentData::CreateComponent : Could not create IComponent object\n")); else { hr = pComponent->QueryInterface(IID_IComponent, (void**)ppComponent); pComponent->m_pComponentData = this; } } return hr; } STDMETHODIMP CLoggingComponentData::Notify ( LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param) { ATLTRACE(_T("# CLoggingComponentData::Notify\n")); HRESULT hr; if ( NULL == lpDataObject ) { switch( event ) { case MMCN_PROPERTY_CHANGE: hr = OnPropertyChange( arg, param ); break; default: ATLTRACE(_T("# CLoggingComponent::Notify - called with lpDataObject == NULL and no event handler\n")); hr = E_NOTIMPL; break; } return hr; } CSnapInItem* pItem; DATA_OBJECT_TYPES type; hr = m_pComponentData->GetDataClass(lpDataObject, &pItem, &type); ATLASSERT(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { hr = pItem->Notify( event, arg, param, this, NULL, type ); } return hr; } HRESULT CLoggingComponentData::OnPropertyChange( LPARAM arg
random
[]
C++
include/El/core/Grid.hpp
pjt1988/Elemental
71d3e2b98829594e9f52980a8b1ef7c1e99c724b
#ifndef EL_GRID_HPP #define EL_GRID_HPP namespace El { class Grid { public: explicit Grid ( mpi::Comm comm=mpi::COMM_WORLD, GridOrder order=COLUMN_MAJOR ); explicit Grid( mpi::Comm comm, int height, GridOrder order=COLUMN_MAJOR ); ~Grid(); int Row() const EL_NO_RELEASE_EXCEPT; int Col() const EL_NO_RELEASE_EXCEPT; int Height() const EL_NO_EXCEPT; int Width() const EL_NO_EXCEPT; int Size() const EL_NO_EXCEPT; int Rank() const EL_NO_RELEASE_EXCEPT; GridOrder Order() const EL_NO_EXCEPT; mpi::Comm ColComm() const EL_NO_EXCEPT; mpi::Comm RowComm() const EL_NO_EXCEPT; mpi::Comm Comm() const EL_NO_EXCEPT; int MCRank() const EL_NO_RELEASE_EXCEPT; int MRRank() const EL_NO_RELEASE_EXCEPT; int MDRank() const EL_NO_RELEASE_EXCEPT; int MDPerpRank() const EL_NO_RELEASE_EXCEPT; int VCRank() const EL_NO_RELEASE_EXCEPT; int VRRank() const EL_NO_RELEASE_EXCEPT; int MCSize() const EL_NO_EXCEPT; int MRSize() const EL_NO_EXCEPT; int MDSize() const EL_NO_EXCEPT; int MDPerpSize() const EL_NO_EXCEPT; int VCSize() const EL_NO_EXCEPT; int VRSize() const EL_NO_EXCEPT; mpi::Comm MCComm() const EL_NO_EXCEPT; mpi::Comm MRComm() const EL_NO_EXCEPT; mpi::Comm VCComm() const EL_NO_EXCEPT; mpi::Comm VRComm() const EL_NO_EXCEPT; mpi::Comm MDComm() const EL_NO_EXCEPT; mpi::Comm MDPerpComm() const EL_NO_EXCEPT; explicit Grid ( mpi::Comm viewers, mpi::Group owners, int height, GridOrder order=COLUMN_MAJOR ); int GCD() const EL_NO_EXCEPT; int LCM() const EL_NO_EXCEPT; bool InGrid() const EL_NO_RELEASE_EXCEPT; bool HaveViewers() const EL_NO_EXCEPT; int OwningRank() const EL_NO_RELEASE_EXCEPT; int ViewingRank() const EL_NO_RELEASE_EXCEPT; mpi::Group OwningGroup() const EL_NO_EXCEPT; mpi::Comm OwningComm() const EL_NO_EXCEPT; mpi::Comm ViewingComm() const EL_NO_EXCEPT; int Diag() const EL_NO_RELEASE_EXCEPT; int Diag( int vcRank ) const EL_NO_EXCEPT; int DiagRank() const EL_NO_RELEASE_EXCEPT; int DiagRank( int vcRank ) const EL_NO_EXCEPT; int VCToVR( int vcRank ) const EL_NO_EXCEPT; int VRToVC( int vrRank ) const EL_NO_EXCEPT; int CoordsToVC ( Dist colDist, Dist rowDist, int distRank, int crossRank=0, int redundant=0 ) const EL_NO_RELEASE_EXCEPT; int VCToViewing( int VCRank ) const EL_NO_EXCEPT; #ifdef EL_HAVE_SCALAPACK int BlacsVCHandle() const; int BlacsVRHandle() const; int BlacsMCMRContext() const; #endif static int DefaultHeight( int gridSize ) EL_NO_EXCEPT; static void InitializeDefault(); static void InitializeTrivial(); static void FinalizeDefault(); static void FinalizeTrivial(); static const Grid& Default() EL_NO_RELEASE_EXCEPT; static const Grid& Trivial() EL_NO_RELEASE_EXCEPT; private: bool haveViewers_; int height_, size_, gcd_; bool inGrid_; GridOrder order_; static Grid* defaultGrid; static Grid* trivialGrid; vector<int> diagsAndRanks_; vector<int> vcToViewing_; mpi::Group viewingGroup_, owningGroup_; mpi::Comm viewingComm_, owningComm_, cartComm_, mcComm_, mrComm_, mdComm_, mdPerpComm_, vcComm_, vrComm_; int viewingRank_, owningRank_, mcRank_, mrRank_, mdRank_, mdPerpRank_, vcRank_, vrRank_; #ifdef EL_HAVE_SCALAPACK int blacsVCHandle_, blacsVRHandle_; int blacsMCMRContext_; #endif void SetUpGrid(); const Grid& operator=( Grid& ); Grid( const Grid& ); }; bool operator==( const Grid& A, const Grid& B ) EL_NO_EXCEPT; bool operator!=( const Grid& A, const Grid& B ) EL_NO_EXCEPT; inline void AssertSameGrids( const Grid& ) { } inline void AssertSameGrids( const Grid& g1, const Grid& g2 ) { if( g1 != g2 ) LogicError("Grids did not match"); } template<typename... Args> inline void AssertSameGrids( const Grid& g1, const Grid& g2, Args&... args ) { if( g1 != g2 ) LogicError("Grids did not match"); AssertSameGrids( g2, args... ); } inline bool GridCompare ( const Grid & g1, const Grid & g2 ) { if( g1.Height() != g2.Height() ) return false; if( g1.Order() != g2.Order() ) return false; if( !Congruent( g1.ViewingComm(), g2.ViewingComm() ) ) return false; if( !Congruent( g1.OwningGroup(), g2.OwningGroup() ) ) return false; return true; } } #endif
#ifndef EL_GRID_HPP #define EL_GRID_HPP namespace El { class Grid { public: explicit Grid ( mpi::Comm comm=mpi::COMM_WORLD, GridOrder order=COLUMN_MAJOR ); explicit Grid( mpi::Comm comm, int height, GridOrder order=COLUMN_MAJOR ); ~Grid(); int Row() const EL_NO_RELEASE_EXCEPT; int Col() const EL_NO_RELEASE_EXCEPT; int Height() const EL_NO_EXCEPT; int Width() const EL_NO_EXCEPT; int Size() const EL_NO_EXCEPT; int Rank() const EL_NO_RELEASE_EXCEPT; GridOrder Order() const EL_NO_EXCEPT; mpi::Comm ColComm() const EL_NO_EXCEPT; mpi::Comm RowComm() const EL_NO_EXCEPT; mpi::Comm Comm() const EL_NO_EXCEPT; int MCRank() const EL_NO_RELEASE_EXCEPT; int MRRank() const EL_NO_RELEASE_EXCEPT; int MDRank() const EL_NO_RELEASE_EXCEPT; int MDPerpRank() const EL_NO_RELEASE_EXCEPT; int VCRank() const EL_NO_RELEASE_EXCEPT; int VRRank() const EL_NO_RELEASE_EXCEPT; int MCSize() const EL_NO_EXCEPT; int MRSize() const EL_NO_EXCEPT; int MDSize() const EL_NO_EXCEPT; int MDPerpSize() const EL_NO_EXCEPT; int VCSize() const EL_NO_EXCEPT; int VRSize() const EL_NO_EXCEPT; mpi::Comm MCComm() const EL_NO_EXCEPT; mpi::Comm MRComm() const EL_NO_EXCEPT; mpi::Comm VCComm() const EL_NO_EXCEPT; mpi::Comm VRComm() const EL_NO_EXCEPT; mpi::Comm MDComm() const EL_NO_EXCEPT; mpi::Comm MDPerpComm() const EL_NO_EXCEPT; explicit Grid ( mpi::Comm viewers, mpi::Group owners, int height, GridOrder order=COLUMN_MAJOR ); int GCD() const EL_NO_EXCEPT; int LCM() const EL_NO_EXCEPT; bool InGrid() const EL_NO_RELEASE_EXCEPT; bool HaveViewers() const EL_NO_EXCEPT; int OwningRank() const EL_NO_RELEASE_EXCEPT; int ViewingRank() const EL_NO_RELEASE_EXCEPT; mpi::Group OwningGroup() const EL_NO_EXCEPT; mpi::Comm OwningComm() const EL_NO_EXCEPT; mpi::Comm ViewingComm() const EL_NO_EXCEPT; int Diag() const EL_NO_RELEASE_EXCEPT; int Diag( int vcRank ) const EL_NO_EXCEPT; int DiagRank() const EL_NO_RELEASE_EXCEPT; int DiagRank( int vcRank ) const EL_NO_EXCEPT; int VCToVR( int vcRank ) const EL_NO_EXCEPT; int VRToVC( int vrRank ) const EL_NO_EXCEPT; int CoordsToVC ( Dist colDist, Dist rowDist, int distRank, int crossRank=0, int redundant=0 ) const EL_NO_RELEASE_EXCEPT; int VCToViewing( int VCRank ) const EL_NO_EXCEPT; #ifdef EL_HAVE_SCALAPACK int BlacsVCHandle() const; int BlacsVRHandle() const; int BlacsMCMRContext() const; #endif static int DefaultHeight( int gridSize ) EL_NO_EXCEPT; static void InitializeDefault(); static void InitializeTrivial(); static void FinalizeDefault(); static void FinalizeTrivial(); static const Grid& Default() EL_NO_RELEASE_EXCEPT; static const Grid& Trivial() EL_NO_RELEASE_EXCEPT; private: bool haveViewers_; int height_, size_, gcd_; bool inGrid_; GridOrder order_; static Grid* defaultGrid; static Grid* trivialGrid; vector<int> diagsAndRanks_; vector<int> vcToViewing_; mpi::Group viewingGroup_, owningGroup_; mpi::Comm viewingComm_, owningComm_, cartComm_, mcComm_, mrComm_, mdComm_, mdPerpComm_, vcComm_, vrComm_; int viewingRank_, owningRank_, mcRank_, mrRank_, mdRank_, mdPerpRank_, vcRank_, vrRank_; #ifdef EL_HAVE_SCALAPACK int blacsVCHandle_, blacsVRHandle_; int blacsMCMRContext_; #endif void SetUpGrid(); const Grid& operator=( Grid& ); Grid( const Grid& ); }; bool operator==( const Grid& A, const Grid& B ) EL_NO_EXCEPT; bool operator!=( const Grid& A, const Grid& B ) EL_NO_EXCEPT; inline void AssertSameGrids( const Grid& ) { } inline void AssertSameGrids( const Grid& g1, const Grid& g2 ) { if( g1 != g2 ) LogicError("Grids did not match"); } template<typename... Args> inline void AssertSameGrids( const Grid& g1, const Grid& g2, Args&... args ) { if( g1 != g2 ) LogicError("Grids did not match"); AssertSameGrids( g2, args... ); }
} #endif
inline bool GridCompare ( const Grid & g1, const Grid & g2 ) { if( g1.Height() != g2.Height() ) return false; if( g1.Order() != g2.Order() ) return false; if( !Congruent( g1.ViewingComm(), g2.ViewingComm() ) ) return false; if( !Congruent( g1.OwningGroup(), g2.OwningGroup() ) ) return false; return true; }
function_block-full_function
[ { "content": "struct IsIntegral<BigInt> { static const bool value = true; };\n\n#endif\n\n\n\n// For querying whether an element's type is a scalar\n\n// --------------------------------------------------\n\ntemplate<typename T> struct IsScalar\n\n{ static const bool value=false; };\n\ntemplate<> struct IsScala...
C++
packages/utility/stats/src/Utility_SampleMoment.hpp
bam241/FRENSIE
e1760cd792928699c84f2bdce70ff54228e88094
#ifndef UTILITY_SAMPLE_MOMENT_HPP #define UTILITY_SAMPLE_MOMENT_HPP #include <type_traits> #include "Utility_QuantityTraits.hpp" namespace Utility{ template<size_t N, typename T, typename Enabled = void> class SampleMoment { }; template<size_t N, typename T> class SampleMoment<N,T,typename std::enable_if<(N>0) && std::is_floating_point<typename QuantityTraits<T>::RawType>::value>::type> { public: typedef typename QuantityTraits<T>::template GetQuantityToPowerType<N>::type ValueType; static ValueType processRawScore( const T& raw_score ); SampleMoment(); SampleMoment( const ValueType& starting_score ); SampleMoment( const SampleMoment& other_moment ); SampleMoment& operator=( const SampleMoment& other_moment ); ~SampleMoment() { } const ValueType& getCurrentScore() const; ValueType get( const size_t number_of_samples ) const; void addRawScore( const T& raw_score ); void addProcessedScore( const ValueType& processed_score ); private: ValueType d_current_score; }; template<typename T> T calculateMean( const SampleMoment<1,T>& first_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::template GetQuantityToPowerType<2>::type calculateVariance( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> T calculateStdDev( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::template GetQuantityToPowerType<2>::type calculateVarianceOfMean( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> T calculateStdDevOfMean( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::RawType calculateRelativeError( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::RawType calculateRelativeVOV( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const SampleMoment<3,T>& third_moment, const SampleMoment<4,T>& fourth_moment, const size_t number_of_samples ); template<typename T> typename std::enable_if<std::is_floating_point<T>::value,T>::type calculateFOM( const T relative_error, const T time ); } #include "Utility_SampleMoment_def.hpp" #endif
#ifndef UTILITY_SAMPLE_MOMENT_HPP #define UTILITY_SAMPLE_MOMENT_HPP #include <type_traits> #include "Utility_QuantityTraits.hpp" namespace Utility{ template<size_t N, typename T, typename Enabled = void> class SampleMoment { }; template<size_t N, typename T> class SampleMoment<N,T,typename std::enable_if<(N>0) && std::is_floating_point<typename QuantityTraits<T>::RawType>::value>::type> { public: typedef typ
t<1,T>& first_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::template GetQuantityToPowerType<2>::type calculateVariance( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> T calculateStdDev( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::template GetQuantityToPowerType<2>::type calculateVarianceOfMean( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> T calculateStdDevOfMean( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::RawType calculateRelativeError( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const size_t number_of_samples ); template<typename T> typename QuantityTraits<T>::RawType calculateRelativeVOV( const SampleMoment<1,T>& first_moment, const SampleMoment<2,T>& second_moment, const SampleMoment<3,T>& third_moment, const SampleMoment<4,T>& fourth_moment, const size_t number_of_samples ); template<typename T> typename std::enable_if<std::is_floating_point<T>::value,T>::type calculateFOM( const T relative_error, const T time ); } #include "Utility_SampleMoment_def.hpp" #endif
ename QuantityTraits<T>::template GetQuantityToPowerType<N>::type ValueType; static ValueType processRawScore( const T& raw_score ); SampleMoment(); SampleMoment( const ValueType& starting_score ); SampleMoment( const SampleMoment& other_moment ); SampleMoment& operator=( const SampleMoment& other_moment ); ~SampleMoment() { } const ValueType& getCurrentScore() const; ValueType get( const size_t number_of_samples ) const; void addRawScore( const T& raw_score ); void addProcessedScore( const ValueType& processed_score ); private: ValueType d_current_score; }; template<typename T> T calculateMean( const SampleMomen
random
[ { "content": "struct RawRationalPowerHelper<N,D,T,typename std::enable_if<N<0 && D<0 && N!=D>::type> : public RawRationalPowerHelper<-N,-D,T>\n\n{ /* ... */ };\n\n\n\n/*! The true or false type\n\n * \\ingroup quantity_traits\n\n */\n\ntemplate<bool is_true>\n", "file_path": "packages/utility/core/src/Utili...
C++
src/csapex_remote/src/io/protocol/core_requests.cpp
betwo/csapex
f2c896002cf6bd4eb7fba2903ebeea4a1e811191
#include <csapex/io/protcol/core_requests.h> #include <csapex/serialization/request_serializer.h> #include <csapex/serialization/io/std_io.h> #include <csapex/io/feedback.h> #include <csapex/utility/uuid_provider.h> #include <csapex/model/graph_facade_impl.h> #include <csapex/serialization/parameter_serializer.h> #include <csapex/serialization/snippet.h> #include <iostream> CSAPEX_REGISTER_REQUEST_SERIALIZER(CoreRequests) using namespace csapex; CoreRequests::CoreRequest::CoreRequest(CoreRequestType request_type) : RequestImplementation(0), request_type_(request_type) { } CoreRequests::CoreRequest::CoreRequest(uint8_t request_id) : RequestImplementation(request_id) { } ResponsePtr CoreRequests::CoreRequest::execute(const SessionPtr& session, CsApexCore& core) const { switch (request_type_) { case CoreRequestType::SettingsSavePersistent: core.getSettings().savePersistent(); break; case CoreRequestType::SettingsLoadPersistent: core.getSettings().loadPersistent(); break; case CoreRequestType::CoreSave: { int args = parameters_.size(); if (args == 0) { core.saveAs(core.getSettings().get<std::string>("config")); } else if (args == 1) { core.saveAs(std::any_cast<std::string>(parameters_.at(0))); } else { core.saveAs(std::any_cast<std::string>(parameters_.at(0)), std::any_cast<bool>(parameters_.at(1))); } } break; case CoreRequestType::CoreLoad: { int args = parameters_.size(); if (args == 0) { core.load(core.getSettings().get<std::string>("config")); } else { core.load(std::any_cast<std::string>(parameters_.at(0))); } } break; case CoreRequestType::CoreSerialize: { int args = parameters_.size(); if (args == 2) { SnippetPtr snippet = core.serializeNodes(std::any_cast<AUUID>(parameters_.at(0)), std::any_cast<std::vector<UUID>>(parameters_.at(1))); return std::make_shared<CoreResponse>(request_type_, snippet, getRequestID()); } } break; case CoreRequestType::CoreStep: core.step(); break; case CoreRequestType::CoreShutdown: core.shutdown(); break; case CoreRequestType::CoreResetActivity: core.getRoot()->resetActivity(); break; case CoreRequestType::CoreClearBlock: core.getRoot()->clearBlock(); break; case CoreRequestType::CoreReset: core.reset(); break; case CoreRequestType::CoreSetSteppingMode: core.setSteppingMode(std::any_cast<bool>(parameters_.at(0))); break; case CoreRequestType::CoreSetPause: core.setPause(std::any_cast<bool>(parameters_.at(0))); break; case CoreRequestType::CoreSendNotification: core.sendNotification(std::any_cast<std::string>(parameters_.at(0)), static_cast<ErrorState::ErrorLevel>(std::any_cast<uint8_t>(parameters_.at(1)))); break; case CoreRequestType::CoreGetSteppingMode: return std::make_shared<CoreResponse>(request_type_, core.isSteppingMode(), getRequestID()); case CoreRequestType::CoreGetPause: return std::make_shared<CoreResponse>(request_type_, core.isPaused(), getRequestID()); default: return std::make_shared<Feedback>(std::string("unknown core request type ") + std::to_string((int)request_type_), getRequestID()); } return std::make_shared<CoreResponse>(request_type_, getRequestID()); } void CoreRequests::CoreRequest::serialize(SerializationBuffer& data, SemanticVersion& version) const { data << request_type_; data << parameters_; } void CoreRequests::CoreRequest::deserialize(const SerializationBuffer& data, const SemanticVersion& version) { data >> request_type_; data >> parameters_; } CoreRequests::CoreResponse::CoreResponse(CoreRequestType request_type, uint8_t request_id) : ResponseImplementation(request_id), request_type_(request_type) { } CoreRequests::CoreResponse::CoreResponse(CoreRequestType request_type, std::any result, uint8_t request_id) : ResponseImplementation(request_id), request_type_(request_type), result_(result) { } CoreRequests::CoreResponse::CoreResponse(uint8_t request_id) : ResponseImplementation(request_id) { } void CoreRequests::CoreResponse::serialize(SerializationBuffer& data, SemanticVersion& version) const { data << request_type_; data << result_; } void CoreRequests::CoreResponse::deserialize(const SerializationBuffer& data, const SemanticVersion& version) { data >> request_type_; data >> result_; }
#include <csapex/io/protcol/core_requests.h> #include <csapex/serialization/request_serializer.h> #include <csapex/serialization/io/std_io.h> #include <csapex/io/feedback.h> #include <csapex/utility/uuid_provider.h> #include <csapex/model/graph_facade_impl.h> #include <csapex/serialization/parameter_serializer.h> #include <csapex/serialization/snippet.h> #include <iostream> CSAPEX_REGISTER_REQUEST_SERIALIZER(CoreRequests) using namespace csapex; CoreRequests::CoreRequest::CoreRequest(CoreRequestType request_type) : RequestImplementation(0), request_type_(request_type) { } CoreRequests::CoreRequest::CoreRequest(uint8_t request_id) : RequestImplementation(request_id) { } ResponsePtr CoreRequests::CoreRequest::execute(const SessionPtr& session, CsApexCore& core) const { switch (request_type_) { case CoreRequestType::SettingsSavePersistent: core.getSettings().savePersistent(); break; case CoreRequestType::SettingsLoadPersistent: core.getSettings().loadPersistent(); break; case CoreRequestType::CoreSave: { int args = parameters_.size(); if (args == 0) { core.saveAs(core.getSettings().get<std::string>("config")); } else
} break; case CoreRequestType::CoreLoad: { int args = parameters_.size(); if (args == 0) { core.load(core.getSettings().get<std::string>("config")); } else { core.load(std::any_cast<std::string>(parameters_.at(0))); } } break; case CoreRequestType::CoreSerialize: { int args = parameters_.size(); if (args == 2) { SnippetPtr snippet = core.serializeNodes(std::any_cast<AUUID>(parameters_.at(0)), std::any_cast<std::vector<UUID>>(parameters_.at(1))); return std::make_shared<CoreResponse>(request_type_, snippet, getRequestID()); } } break; case CoreRequestType::CoreStep: core.step(); break; case CoreRequestType::CoreShutdown: core.shutdown(); break; case CoreRequestType::CoreResetActivity: core.getRoot()->resetActivity(); break; case CoreRequestType::CoreClearBlock: core.getRoot()->clearBlock(); break; case CoreRequestType::CoreReset: core.reset(); break; case CoreRequestType::CoreSetSteppingMode: core.setSteppingMode(std::any_cast<bool>(parameters_.at(0))); break; case CoreRequestType::CoreSetPause: core.setPause(std::any_cast<bool>(parameters_.at(0))); break; case CoreRequestType::CoreSendNotification: core.sendNotification(std::any_cast<std::string>(parameters_.at(0)), static_cast<ErrorState::ErrorLevel>(std::any_cast<uint8_t>(parameters_.at(1)))); break; case CoreRequestType::CoreGetSteppingMode: return std::make_shared<CoreResponse>(request_type_, core.isSteppingMode(), getRequestID()); case CoreRequestType::CoreGetPause: return std::make_shared<CoreResponse>(request_type_, core.isPaused(), getRequestID()); default: return std::make_shared<Feedback>(std::string("unknown core request type ") + std::to_string((int)request_type_), getRequestID()); } return std::make_shared<CoreResponse>(request_type_, getRequestID()); } void CoreRequests::CoreRequest::serialize(SerializationBuffer& data, SemanticVersion& version) const { data << request_type_; data << parameters_; } void CoreRequests::CoreRequest::deserialize(const SerializationBuffer& data, const SemanticVersion& version) { data >> request_type_; data >> parameters_; } CoreRequests::CoreResponse::CoreResponse(CoreRequestType request_type, uint8_t request_id) : ResponseImplementation(request_id), request_type_(request_type) { } CoreRequests::CoreResponse::CoreResponse(CoreRequestType request_type, std::any result, uint8_t request_id) : ResponseImplementation(request_id), request_type_(request_type), result_(result) { } CoreRequests::CoreResponse::CoreResponse(uint8_t request_id) : ResponseImplementation(request_id) { } void CoreRequests::CoreResponse::serialize(SerializationBuffer& data, SemanticVersion& version) const { data << request_type_; data << result_; } void CoreRequests::CoreResponse::deserialize(const SerializationBuffer& data, const SemanticVersion& version) { data >> request_type_; data >> result_; }
if (args == 1) { core.saveAs(std::any_cast<std::string>(parameters_.at(0))); } else { core.saveAs(std::any_cast<std::string>(parameters_.at(0)), std::any_cast<bool>(parameters_.at(1))); }
if_condition
[ { "content": "struct ArgumentExtractor<0, Arg, Args...>\n\n{\n\n using type = Arg;\n\n};\n\n\n\ntemplate <int pos, typename Signature>\n", "file_path": "src/csapex_util/include/csapex/utility/slim_signal_invoker.hpp", "rank": 0, "score": 173639.98887121578 }, { "content": "struct function...
C++
src/demo/hellocpp/main.cpp
rochus-keller/nappgui_src
394875dfc11c9c73cd7995d56f77dcd4629d70b5
#include "nappgui.h" class App; class MainWindow : public IListener { public: MainWindow(App *app); ~MainWindow(); void *operator new(size_t size) { return (void*)heap_malloc((uint32_t)size, "MainWindow"); } void operator delete(void *ptr, size_t size) { heap_free((byte_t**)&ptr, (uint32_t)size, "MainWindow"); } private: void i_OnButton(Event *e); Panel *i_panel(void); Window *window; TextView *text; uint32_t clicks; }; class App : public IListener { public: App(); ~App(); void i_OnClose(Event *e); void *operator new(size_t size) { return (void*)heap_malloc((uint32_t)size, "App"); } void operator delete(void *ptr, size_t size) { heap_free((byte_t**)&ptr, (uint32_t)size, "App"); } private: MainWindow *main_window; }; void MainWindow::i_OnButton(Event *e) { String *msg = str_printf("Button click (%d)\n", this->clicks); textview_writef(this->text, tc(msg)); str_destroy(&msg); this->clicks += 1; unref(e); } Panel *MainWindow::i_panel(void) { Panel *panel = panel_create(); Layout *layout = layout_create(1, 3); Label *label = label_create(); Button *button = button_push(); TextView *textv = textview_create(); this->text = textv; label_text(label, "Hello!, I'm a label"); button_text(button, "Click Me!"); button_OnClick(button, IListen(this, MainWindow, i_OnButton)); layout_label(layout, label, 0, 0); layout_button(layout, button, 0, 1); layout_textview(layout, textv, 0, 2); layout_hsize(layout, 0, 250); layout_vsize(layout, 2, 100); layout_margin(layout, 5); layout_vmargin(layout, 0, 5); layout_vmargin(layout, 1, 5); panel_layout(panel, layout); return panel; } void App::i_OnClose(Event *e) { osapp_finish(); unref(e); } MainWindow::MainWindow(App *app) { Panel *panel = i_panel(); this->window = window_create(ekWNSTD); this->clicks = 0; window_panel(this->window, panel); window_title(this->window, "Hello, C++!"); window_origin(this->window, v2df(500, 200)); window_OnClose(this->window, IListen(app, App, i_OnClose)); window_show(this->window); } MainWindow::~MainWindow() { window_destroy(&this->window); } App::App(void) { this->main_window = new MainWindow(this); } App::~App() { delete this->main_window; } static App *i_create(void) { return new App(); } static void i_destroy(App **app) { delete *app; *app = NULL; } #include "osmain.h" osmain(i_create, i_destroy, "", App)
#include "nappgui.h" class App; class MainWindow : public IListener { public: MainWindow(App *app); ~MainWindow(); void *operator new(size_t size) { return (void*)heap_malloc((uint32_t)size, "MainWindow"); } void operator delete(void *ptr, size_t size) { heap_free((byte_t**)&ptr, (uint32_t)size, "MainWindow"); } private: void i_OnButton(Event *e); Panel *i_panel(void); Window *window; TextView *text; uint32_t clicks; }; class App : public IListener { public: App(); ~App(); void i_OnClose(Event *e); void *operator new(size_t size) { return (void*)heap_malloc((uint32_t)size, "App"); } void operator delete(void *ptr, size_t size) { heap_free((byte_t**)&ptr, (uint32_t)size, "App"); } private: MainWindow *main_window; }; void MainWindow::i_OnButton(Event *e) { String *msg = str_printf("Button click (%d)\n", this->clicks); textview_writef(this->text, tc(msg)); str_destroy(&msg); this->clicks += 1; unref(e); } Panel *MainWindow::i_panel(void) { Panel *panel = panel_create(); Layout *layout = layout_create(1, 3); Label *label = label_create(); Button *button = button_push(); TextView *textv = textview_create(); this->text = textv; label_text(label, "Hello!, I'm a label"); button_text(button, "Click Me!"); button_OnClick(button, IListen(this, MainWindow, i_OnButton)); layout_label(layout, label, 0, 0); layout_button(layout, button, 0, 1); layout_textview(layout, textv, 0, 2); layout_hsize(layout, 0, 250); layout_vsize(layout, 2, 100); layout_margin(layout, 5); layout_vmargin(layout, 0, 5); layout_vmargin(layout, 1, 5); panel_layout(panel, layout); return panel; } void App::i_OnClose(Event *e) { osapp_finish(); unref(e); } MainWindow::MainWindow(App *app) { Panel *panel = i_panel(); this->window = window_create(ekWNST
MainWindow::~MainWindow() { window_destroy(&this->window); } App::App(void) { this->main_window = new MainWindow(this); } App::~App() { delete this->main_window; } static App *i_create(void) { return new App(); } static void i_destroy(App **app) { delete *app; *app = NULL; } #include "osmain.h" osmain(i_create, i_destroy, "", App)
D); this->clicks = 0; window_panel(this->window, panel); window_title(this->window, "Hello, C++!"); window_origin(this->window, v2df(500, 200)); window_OnClose(this->window, IListen(app, App, i_OnClose)); window_show(this->window); }
function_block-function_prefixed
[ { "content": " String *text;\n", "file_path": "src/gui/label.c", "rank": 3, "score": 145566.12840869065 }, { "content": " String *text;\n", "file_path": "src/gui/button.c", "rank": 4, "score": 145561.48196416028 }, { "content": " Window *window;\n", "file_pat...
C++
src/projects/fea/test_FEA_ancf_cable.cpp
rserban/chrono
bee5e30b2ce3b4ac62324799d1366b6db295830e
#include <assert.h> #include <iostream> #include <string> #include <vector> #include "chrono/ChConfig.h" #include "chrono/physics/ChSystemSMC.h" #include "chrono/solver/ChIterativeSolverLS.h" #include "chrono/utils/ChUtilsInputOutput.h" #include "chrono_irrlicht/ChIrrApp.h" #include "chrono_mkl/ChSolverMKL.h" #include "chrono/fea/ChBuilderBeam.h" #include "chrono/fea/ChElementCableANCF.h" #include "chrono/fea/ChLinkDirFrame.h" #include "chrono/fea/ChLinkPointFrame.h" #include "chrono/fea/ChMesh.h" #include "chrono/fea/ChVisualizationFEAmesh.h" #include "chrono_thirdparty/filesystem/path.h" #include "chrono_thirdparty/filesystem/resolver.h" using namespace chrono; using namespace chrono::irrlicht; using std::cout; using std::endl; int main(int argc, char* argv[]) { bool use_MKL = true; bool use_HHT = true; ChSystemSMC mphysicalSystem; mphysicalSystem.Set_G_acc(ChVector<>(0.01, 0.0, 0.0)); auto ground = chrono_types::make_shared<ChBody>(); ground->SetIdentifier(-1); ground->SetBodyFixed(true); mphysicalSystem.Add(ground); auto msection_cable = chrono_types::make_shared<fea::ChBeamSectionCable>(); msection_cable->SetDiameter(0.002); msection_cable->SetYoungModulus(5e3); msection_cable->SetDensity(2000); msection_cable->SetBeamRaleyghDamping(0.2); int N_x = 2; int N_y = 2; int num_elements = 4; double delta = 0.1; auto my_mesh = chrono_types::make_shared<fea::ChMesh>(); fea::ChBuilderCableANCF builder; std::vector<std::shared_ptr<fea::ChNodeFEAxyzD>> base_nodes; std::vector<std::shared_ptr<fea::ChNodeFEAxyzD>> tip_nodes; for (int j = 0; j < N_y; j++) { for (int i = 0; i < N_x; i++) { double loc_x = i * delta; double loc_y = j * delta; builder.BuildBeam( my_mesh, msection_cable, num_elements, ChVector<>(loc_x, loc_y, 0.0), ChVector<>(loc_x, loc_y, 0.1) ); base_nodes.push_back(builder.GetLastBeamNodes().front()); tip_nodes.push_back(builder.GetLastBeamNodes().back()); } } for (auto node : base_nodes) { node->SetFixed(true); } mphysicalSystem.Add(my_mesh); auto mvisualizebeamA = chrono_types::make_shared<fea::ChVisualizationFEAmesh>(*my_mesh); mvisualizebeamA->SetFEMdataType(fea::ChVisualizationFEAmesh::E_PLOT_ANCF_BEAM_BD); mvisualizebeamA->SetColorscaleMinMax(-20, 20); mvisualizebeamA->SetSmoothFaces(true); mvisualizebeamA->SetWireframe(false); my_mesh->AddAsset(mvisualizebeamA); ChIrrApp application(&mphysicalSystem, L"Test ANCF Cables", irr::core::dimension2d<irr::u32>(1600, 1200), false, true); application.AddTypicalLogo(); application.AddTypicalSky(); application.AddTypicalLights(irr::core::vector3df(30.f, -100.f, 30.f), irr::core::vector3df(30.f, -80.f, -30.f)); application.AddTypicalCamera(irr::core::vector3df(0.05f, -0.3f, 0.05f), irr::core::vector3df(0.05f, 0.0f, 0.0f)); application.AssetBindAll(); application.AssetUpdateAll(); if (use_MKL) { auto mkl_solver = chrono_types::make_shared<ChSolverMKL>(); mkl_solver->LockSparsityPattern(true); mphysicalSystem.SetSolver(mkl_solver); } else { auto minres_solver = chrono_types::make_shared<ChSolverMINRES>(); minres_solver->SetMaxIterations(400); minres_solver->SetTolerance(1e-12); minres_solver->EnableWarmStart(true); mphysicalSystem.SetSolver(minres_solver); } if (use_HHT) { mphysicalSystem.SetTimestepperType(ChTimestepper::Type::HHT); auto mystepper = std::dynamic_pointer_cast<ChTimestepperHHT>(mphysicalSystem.GetTimestepper()); mystepper->SetAlpha(-0.1); mystepper->SetMaxiters(100); mystepper->SetAbsTolerances(1e-10, 1e-10); mystepper->SetMode(ChTimestepperHHT::ACCELERATION); mystepper->SetScaling(true); mystepper->SetVerbose(false); } else { mphysicalSystem.SetTimestepperType(ChTimestepper::Type::EULER_IMPLICIT); } std::string out_dir = "../TEST_ancf_cable"; if (filesystem::path(out_dir).exists()) { cout << "Output directory already exists" << endl; } else if (filesystem::create_directory(filesystem::path(out_dir))) { cout << "Create directory = " << filesystem::path(out_dir).make_absolute() << endl; } else { cout << "Error creating output directory" << endl; return 1; } utils::CSV_writer csv(" "); csv.stream().setf(std::ios::scientific | std::ios::showpos); csv.stream().precision(18); int step_number = 0; double dt = 0.01; application.SetTimestep(dt); while (application.GetDevice()->run()) { application.BeginScene(); application.DrawAll(); ChIrrTools::drawAllCOGs(mphysicalSystem, application.GetVideoDriver(), 0.05); application.DoStep(); application.EndScene(); step_number++; if (step_number == 1) { for (auto node : my_mesh->GetNodes()) { cout << node->GetIndex() << " " << node->NodeGetOffset_x() << " " << node->NodeGetOffset_w() << endl; } } csv << mphysicalSystem.GetChTime(); for (auto node : tip_nodes) { csv << node->GetPos(); } csv << endl; csv.write_to_file(out_dir + "/results.dat"); } return 0; }
#include <assert.h> #include <iostream> #include <string> #include <vector> #include "chrono/ChConfig.h" #include "chrono/physics/ChSystemSMC.h" #include "chrono/solver/ChIterativeSolverLS.h" #include "chrono/utils/ChUtilsInputOutput.h" #include "chrono_irrlicht/ChIrrApp.h" #include "chrono_mkl/ChSolverMKL.h" #include "chrono/fea/ChBuilderBeam.h" #include "chrono/fea/ChElementCableANCF.h" #include "chrono/fea/ChLinkDirFrame.h" #include "chrono/fea/ChLinkPointFrame.h" #include "chrono/fea/ChMesh.h" #include "chrono/fea/ChVisualizationFEAmesh.h" #include "chrono_thirdparty/filesystem/path.h" #include "chrono_thirdparty/filesystem/resolver.h" using namespace chrono; using namespace chrono::irrlicht; using std::cout; using std::endl;
int main(int argc, char* argv[]) { bool use_MKL = true; bool use_HHT = true; ChSystemSMC mphysicalSystem; mphysicalSystem.Set_G_acc(ChVector<>(0.01, 0.0, 0.0)); auto ground = chrono_types::make_shared<ChBody>(); ground->SetIdentifier(-1); ground->SetBodyFixed(true); mphysicalSystem.Add(ground); auto msection_cable = chrono_types::make_shared<fea::ChBeamSectionCable>(); msection_cable->SetDiameter(0.002); msection_cable->SetYoungModulus(5e3); msection_cable->SetDensity(2000); msection_cable->SetBeamRaleyghDamping(0.2); int N_x = 2; int N_y = 2; int num_elements = 4; double delta = 0.1; auto my_mesh = chrono_types::make_shared<fea::ChMesh>(); fea::ChBuilderCableANCF builder; std::vector<std::shared_ptr<fea::ChNodeFEAxyzD>> base_nodes; std::vector<std::shared_ptr<fea::ChNodeFEAxyzD>> tip_nodes; for (int j = 0; j < N_y; j++) { for (int i = 0; i < N_x; i++) { double loc_x = i * delta; double loc_y = j * delta; builder.BuildBeam( my_mesh, msection_cable, num_elements, ChVector<>(loc_x, loc_y, 0.0), ChVector<>(loc_x, loc_y, 0.1) ); base_nodes.push_back(builder.GetLastBeamNodes().front()); tip_nodes.push_back(builder.GetLastBeamNodes().back()); } } for (auto node : base_nodes) { node->SetFixed(true); } mphysicalSystem.Add(my_mesh); auto mvisualizebeamA = chrono_types::make_shared<fea::ChVisualizationFEAmesh>(*my_mesh); mvisualizebeamA->SetFEMdataType(fea::ChVisualizationFEAmesh::E_PLOT_ANCF_BEAM_BD); mvisualizebeamA->SetColorscaleMinMax(-20, 20); mvisualizebeamA->SetSmoothFaces(true); mvisualizebeamA->SetWireframe(false); my_mesh->AddAsset(mvisualizebeamA); ChIrrApp application(&mphysicalSystem, L"Test ANCF Cables", irr::core::dimension2d<irr::u32>(1600, 1200), false, true); application.AddTypicalLogo(); application.AddTypicalSky(); application.AddTypicalLights(irr::core::vector3df(30.f, -100.f, 30.f), irr::core::vector3df(30.f, -80.f, -30.f)); application.AddTypicalCamera(irr::core::vector3df(0.05f, -0.3f, 0.05f), irr::core::vector3df(0.05f, 0.0f, 0.0f)); application.AssetBindAll(); application.AssetUpdateAll(); if (use_MKL) { auto mkl_solver = chrono_types::make_shared<ChSolverMKL>(); mkl_solver->LockSparsityPattern(true); mphysicalSystem.SetSolver(mkl_solver); } else { auto minres_solver = chrono_types::make_shared<ChSolverMINRES>(); minres_solver->SetMaxIterations(400); minres_solver->SetTolerance(1e-12); minres_solver->EnableWarmStart(true); mphysicalSystem.SetSolver(minres_solver); } if (use_HHT) { mphysicalSystem.SetTimestepperType(ChTimestepper::Type::HHT); auto mystepper = std::dynamic_pointer_cast<ChTimestepperHHT>(mphysicalSystem.GetTimestepper()); mystepper->SetAlpha(-0.1); mystepper->SetMaxiters(100); mystepper->SetAbsTolerances(1e-10, 1e-10); mystepper->SetMode(ChTimestepperHHT::ACCELERATION); mystepper->SetScaling(true); mystepper->SetVerbose(false); } else { mphysicalSystem.SetTimestepperType(ChTimestepper::Type::EULER_IMPLICIT); } std::string out_dir = "../TEST_ancf_cable"; if (filesystem::path(out_dir).exists()) { cout << "Output directory already exists" << endl; } else if (filesystem::create_directory(filesystem::path(out_dir))) { cout << "Create directory = " << filesystem::path(out_dir).make_absolute() << endl; } else { cout << "Error creating output directory" << endl; return 1; } utils::CSV_writer csv(" "); csv.stream().setf(std::ios::scientific | std::ios::showpos); csv.stream().precision(18); int step_number = 0; double dt = 0.01; application.SetTimestep(dt); while (application.GetDevice()->run()) { application.BeginScene(); application.DrawAll(); ChIrrTools::drawAllCOGs(mphysicalSystem, application.GetVideoDriver(), 0.05); application.DoStep(); application.EndScene(); step_number++; if (step_number == 1) { for (auto node : my_mesh->GetNodes()) { cout << node->GetIndex() << " " << node->NodeGetOffset_x() << " " << node->NodeGetOffset_w() << endl; } } csv << mphysicalSystem.GetChTime(); for (auto node : tip_nodes) { csv << node->GetPos(); } csv << endl; csv.write_to_file(out_dir + "/results.dat"); } return 0; }
function_block-full_function
[]
C++
Qt/Components/pqDisplayColorWidget.cxx
certik/paraview
973d37b466552ce770ac0674f30040bb7e31d7fe
#include "pqDisplayColorWidget.h" #include "vtkEventQtSlotConnect.h" #include "vtkPVArrayInformation.h" #include "vtkPVDataSetAttributesInformation.h" #include "vtkPVGeometryInformation.h" #include "vtkSMIntVectorProperty.h" #include "vtkSMPVRepresentationProxy.h" #include "vtkSMStringVectorProperty.h" #include <QComboBox> #include <QHBoxLayout> #include <QIcon> #include <QList> #include <QRegExp> #include <QtDebug> #include <QTimer> #include "pqApplicationCore.h" #include "pqPipelineRepresentation.h" #include "pqUndoStack.h" pqDisplayColorWidget::pqDisplayColorWidget( QWidget *p ) : QWidget( p ), BlockEmission(false) { this->CellDataIcon = new QIcon(":/pqWidgets/Icons/pqCellData16.png"); this->PointDataIcon = new QIcon(":/pqWidgets/Icons/pqPointData16.png"); this->SolidColorIcon = new QIcon(":/pqWidgets/Icons/pqSolidColor16.png"); this->Layout = new QHBoxLayout( this ); this->Layout->setMargin(0); this->Layout->setSpacing(6); this->Variables = new QComboBox( this ); this->Variables->setMaxVisibleItems(60); this->Variables->setObjectName("Variables"); this->Variables->setMinimumSize( QSize( 150, 0 ) ); this->Layout->setMargin( 0 ); this->Layout->setSpacing( 1 ); this->Layout->addWidget(this->Variables); QObject::connect(this->Variables, SIGNAL(currentIndexChanged(int)), SLOT(onVariableActivated(int))); QObject::connect(this, SIGNAL(variableChanged(pqVariableType, const QString&)), this, SLOT(onVariableChanged(pqVariableType, const QString&))); this->VTKConnect = vtkEventQtSlotConnect::New(); pqUndoStack* stack = pqApplicationCore::instance()->getUndoStack(); if (stack) { QObject::connect(this, SIGNAL(begin(const QString&)), stack, SLOT(beginUndoSet(const QString&))); QObject::connect(this, SIGNAL(end()), stack, SLOT(endUndoSet())); } } pqDisplayColorWidget::~pqDisplayColorWidget() { delete this->Layout; delete this->Variables; delete this->CellDataIcon; delete this->PointDataIcon; delete this->SolidColorIcon; this->Layout = 0; this->Variables = 0; this->VTKConnect->Delete(); } QString pqDisplayColorWidget::getCurrentText() const { return this->Variables->currentText(); } void pqDisplayColorWidget::clear() { this->BlockEmission = true; this->Variables->clear(); this->BlockEmission = false; } void pqDisplayColorWidget::addVariable(pqVariableType type, const QString& name) { if(-1 != this->Variables->findData(this->variableData(type, name))) { return; } bool old_value = this->BlockEmission; this->BlockEmission = true; switch(type) { case VARIABLE_TYPE_NONE: this->Variables->addItem(*this->SolidColorIcon, "Solid Color", this->variableData(type, name)); break; case VARIABLE_TYPE_NODE: this->Variables->addItem(*this->PointDataIcon, name, this->variableData(type, name)); break; case VARIABLE_TYPE_CELL: this->Variables->addItem(*this->CellDataIcon, name, this->variableData(type, name)); break; } this->BlockEmission = old_value; } void pqDisplayColorWidget::chooseVariable(pqVariableType type, const QString& name) { const int row = this->Variables->findData(variableData(type, name)); if(row != -1) { this->Variables->setCurrentIndex(row); } } void pqDisplayColorWidget::onVariableActivated(int row) { if(this->BlockEmission) { return; } const QStringList d = this->Variables->itemData(row).toString().split("|"); if(d.size() != 2) return; pqVariableType type = VARIABLE_TYPE_NONE; if(d[1] == "cell") { type = VARIABLE_TYPE_CELL; } else if(d[1] == "point") { type = VARIABLE_TYPE_NODE; } const QString name = d[0]; emit variableChanged(type, name); emit this->modified(); } const QString pqDisplayColorWidget::variableData(pqVariableType type, const QString& name) { switch(type) { case VARIABLE_TYPE_NONE: return name + "|none"; case VARIABLE_TYPE_NODE: return name + "|point"; case VARIABLE_TYPE_CELL: return name + "|cell"; } return QString(); } void pqDisplayColorWidget::onVariableChanged(pqVariableType type, const QString& name) { pqPipelineRepresentation* display = this->getRepresentation(); if (display) { emit this->begin("Color Change"); switch(type) { case VARIABLE_TYPE_NONE: display->colorByArray(NULL, 0); break; case VARIABLE_TYPE_NODE: display->colorByArray(name.toAscii().data(), vtkSMDataRepresentationProxy::POINT_DATA); break; case VARIABLE_TYPE_CELL: display->colorByArray(name.toAscii().data(), vtkSMDataRepresentationProxy::CELL_DATA); break; } emit this->end(); display->renderViewEventually(); } } void pqDisplayColorWidget::updateGUI() { this->BlockEmission = true; pqPipelineRepresentation* display = this->getRepresentation(); if (display) { int index = this->AvailableArrays.indexOf(display->getColorField()); if (index < 0) { index = 0; } this->Variables->setCurrentIndex(index); } this->BlockEmission = false; } void pqDisplayColorWidget::setRepresentation(pqDataRepresentation* display) { if(display == this->Display) { return; } if (this->Display) { QObject::disconnect(this->Display, 0, this, 0); } this->VTKConnect->Disconnect(); this->Display = qobject_cast<pqPipelineRepresentation*>(display); if(this->Display) { vtkSMProxy* repr = this->Display->getProxy(); this->VTKConnect->Connect(repr->GetProperty("ColorAttributeType"), vtkCommand::ModifiedEvent, this, SLOT(reloadGUI()), NULL, 0.0, Qt::QueuedConnection); this->VTKConnect->Connect(repr->GetProperty("ColorArrayName"), vtkCommand::ModifiedEvent, this, SLOT(reloadGUI()), NULL, 0.0, Qt::QueuedConnection); this->VTKConnect->Connect( repr->GetProperty("Representation"), vtkCommand::ModifiedEvent, this, SLOT(reloadGUI()), NULL, 0.0, Qt::QueuedConnection); QObject::connect(this->Display, SIGNAL(updated()), this, SLOT(reloadGUI()), Qt::QueuedConnection); } QTimer::singleShot(0, this, SLOT(reloadGUI())); } pqPipelineRepresentation* pqDisplayColorWidget::getRepresentation() const { return this->Display; } void pqDisplayColorWidget::reloadGUI() { this->BlockEmission = true; this->clear(); pqPipelineRepresentation* display = this->getRepresentation(); if (!display) { this->addVariable(VARIABLE_TYPE_NONE, "Solid Color"); this->BlockEmission = false; this->setEnabled(false); return; } this->setEnabled(true); this->AvailableArrays = display->getColorFields(); QRegExp regExpCell(" \\(cell\\)\\w*$"); QRegExp regExpPoint(" \\(point\\)\\w*$"); foreach(QString arrayName, this->AvailableArrays) { if (arrayName == "Solid Color") { this->addVariable(VARIABLE_TYPE_NONE, arrayName); } else if (regExpCell.indexIn(arrayName) != -1) { arrayName = arrayName.replace(regExpCell, ""); this->addVariable(VARIABLE_TYPE_CELL, arrayName); } else if (regExpPoint.indexIn(arrayName) != -1) { arrayName = arrayName.replace(regExpPoint, ""); this->addVariable(VARIABLE_TYPE_NODE, arrayName); } } this->BlockEmission = false; this->updateGUI(); emit this->modified(); }
#include "pqDisplayColorWidget.h" #include "vtkEventQtSlotConnect.h" #include "vtkPVArrayInformation.h" #include "vtkPVDataSetAttributesInformation.h" #include "vtkPVGeometryInformation.h" #include "vtkSMIntVectorProperty.h" #include "vtkSMPVRepresentationProxy.h" #include "vtkSMStringVectorProperty.h" #include <QComboBox> #include <QHBoxLayout> #include <QIcon> #include <QList> #include <QRegExp> #include <QtDebug> #include <QTimer> #include "pqApplicationCore.h" #include "pqPipelineRepresentation.h" #include "pqUndoStack.h" pqDisplayColorWidget::pqDisplayColorWidget( QWidget *p ) : QWidget( p ), BlockEmission(false) { this->CellDataIcon = new QIcon(":/pqWidgets/Icons/pqCellData16.png"); this->PointDataIcon = new QIcon(":/pqWidgets/Icons/pqPointData16.png"); this->SolidColorIcon = new QIcon(":/pqWidgets/Icons/pqSolidColor16.png"); this->Layout = new QHBoxLayout( this ); this->Layout->setMargin(0); this->Layout->setSpacing(6); this->Variables = new QComboBox( this ); this->Variables->setMaxVisibleItems(60); this->Variables->setObjectName("Variables"); this->Variables->setMinimumSize( QSize( 150, 0 ) ); this->Layout->setMargin( 0 ); this->Layout->setSpacing( 1 ); this->Layout->addWidget(this->Variables); QObject::connect(this->Variables, SIGNAL(currentIndexChanged(int)), SLOT(onVariableActivated(int))); QObject::connect(this, SIGNAL(variableChanged(pqVariableType, const QString&)), this, SLOT(onVariableChanged(pqVariableType, const QString&))); this->VTKConnect = vtkEventQtSlotConnect::New(); pqUndoStack* stack = pqApplicationCore::instance()->getUndoStack(); if (stack) { QObject::connect(this, SIGNAL(begin(const QString&)), stack, SLOT(beginUndoSet(const QString&))); QObject::connect(this, SIGNAL(end()), stack, SLOT(endUndoSet())); } } pqDisplayColorWidget::~pqDisplayColorWidget() { delete this->Layout; delete this->Variables; delete this->CellDataIcon; delete this->PointDataIcon; delete this->SolidColorIcon; this->Layout = 0; this->Variables = 0; this->VTKConnect->Delete(); } QString pqDisplayColorWidget::getCurrentText() const { return this->Variables->currentText(); } void pqDisplayColorWidget::clear() { this->BlockEmission = true; this->Variables->clear(); this->BlockEmission = false; } void pqDisplayColorWidget::addVariable(pqVariableType type, const QString& name) { if(-1 != this->Variables->findData(this->variableData(type, name))) { return; } bool old_value = this->BlockEmission; this->BlockEmission = true; switch(type) { case VARIABLE_TYPE_NONE: this->Variables->addItem(*this->SolidColorIcon, "Solid Color", this->variableData(type, name)); break; case VARIABLE_TYPE_NODE: this->Variables->addItem(*this->PointDataIcon, name, this->variableData(type, name)); break; case VARIABLE_TYPE_CELL: this->Variables->addItem(*this->CellDataIcon, name, this->variableData(type, name)); break; } this->BlockEmission = old_value; } void pqDisplayColorWidget::chooseVariable(pqVariableType type, const QString& name) { const int row = this->Variables->findData(variableData(type, name)); if(row != -1) { this->Variables->setCurrentIndex(row); } } void pqDisplayColorWidget::onVariableActivated(int row) { if(this->BlockEmission) { return; } const QStringList d = this->Variables->itemData(row).toString().split("|"); if(d.size() != 2) return; pqVariableType type = VARIABLE_TYPE_NONE; if(d[1] == "cell") { type = VARIABLE_TYPE_CELL; } else if(d[1] == "point") { type = VARIABLE_TYPE_NODE; } const QString name = d[0]; emit variableChanged(type, name); emit this->modified(); } const QString pqDisplayColorWidget::variableData(pqVariableType type, const QString& name) { switch(type) { case VARIABLE_TYPE_NONE: return name + "|none"; case VARIABLE_TYPE_NODE: return name + "|point"; case VARIABLE_TYPE_CELL: return name + "|cell"; } return QString(); } void pqDisplayColorWidget::onVariableChanged(pqVariableType type, const QString& name) { pqPipelineRepresentation* display = this->getRepresentation(); if (display) { emit this->begin("Color Change"); switch(type) { case VARIABLE_TYPE_NONE: display->colorByArray(NULL, 0); break; case VARIABLE_TYPE_NODE: display->colorByArray(name.toAscii().data(), vtkSMDataRepresentationProxy::POINT_DATA); break; case VARIABLE_TYPE_CELL: display->colorByArray(name.toAscii().data(), vtkSMDataRepresentationProxy::CELL_DATA); break; } emit this->end(); display->renderViewEventually(); } } void pqDisplayColorWidget::updateGUI() { this->BlockEmission = true; pqPipelineRepresentation* display = this->getRepresentation(); if (display) { int index = this->AvailableArrays.indexOf(display->getColorField()); if (index < 0) { index = 0; } this->Variables->setCurrentIndex(index); } this->BlockEmission = false; } void pqDisplayColorWidget::setRepresentation(pqDataRepresentation* display) { if(display == this->Display) { return; } if (this->Display) { QObject::disconnect(this->Display, 0, this, 0); } this->VTKConnect->Disconnect(); this->Display = qobject_cast<pqPipelineRepresentation*>(display); if(this->Display) { vtkSMProxy* repr = this->Display->getProxy(); this->VTKConnect->Connect(repr->GetProperty("ColorAttributeType"), vtkCommand::ModifiedEvent, this, SLOT(reloadGUI()), NULL, 0.0, Qt::QueuedConnection); this->VTKConnect->Connect(repr->GetProperty("ColorArrayName"), vtkCommand::ModifiedEvent, this, SLOT(reloadGUI()), NULL, 0.0, Qt::QueuedConnection);
; QObject::connect(this->Display, SIGNAL(updated()), this, SLOT(reloadGUI()), Qt::QueuedConnection); } QTimer::singleShot(0, this, SLOT(reloadGUI())); } pqPipelineRepresentation* pqDisplayColorWidget::getRepresentation() const { return this->Display; } void pqDisplayColorWidget::reloadGUI() { this->BlockEmission = true; this->clear(); pqPipelineRepresentation* display = this->getRepresentation(); if (!display) { this->addVariable(VARIABLE_TYPE_NONE, "Solid Color"); this->BlockEmission = false; this->setEnabled(false); return; } this->setEnabled(true); this->AvailableArrays = display->getColorFields(); QRegExp regExpCell(" \\(cell\\)\\w*$"); QRegExp regExpPoint(" \\(point\\)\\w*$"); foreach(QString arrayName, this->AvailableArrays) { if (arrayName == "Solid Color") { this->addVariable(VARIABLE_TYPE_NONE, arrayName); } else if (regExpCell.indexIn(arrayName) != -1) { arrayName = arrayName.replace(regExpCell, ""); this->addVariable(VARIABLE_TYPE_CELL, arrayName); } else if (regExpPoint.indexIn(arrayName) != -1) { arrayName = arrayName.replace(regExpPoint, ""); this->addVariable(VARIABLE_TYPE_NODE, arrayName); } } this->BlockEmission = false; this->updateGUI(); emit this->modified(); }
this->VTKConnect->Connect( repr->GetProperty("Representation"), vtkCommand::ModifiedEvent, this, SLOT(reloadGUI()), NULL, 0.0, Qt::QueuedConnection)
call_expression
[ { "content": "extern struct obj_stats* els;\n", "file_path": "VTK/Utilities/vtkexodus2/include/exodusII_int.h", "rank": 0, "score": 239731.76580513327 }, { "content": "class VTK_PARALLEL_EXPORT vtkPCellDataToPointData : public vtkCellDataToPointData\n\n{\n\npublic:\n\n vtkTypeRevisionMacro(...
C++
src/ellipse.cpp
DavidR86/mxd
bf0a72305701dd5c76c2b3daa4bdba14d638b29d
#include "ellipse.hpp" #include <cmath> #include <iostream> #include <memory> #include "program.hpp" #include "shader.hpp" #include "time_point.hpp" #include "utilities.hpp" #include <GL/glew.h> #include <GLFW/glfw3.h> #include <glm/glm.hpp> namespace { nzl::Program create_program() { const std::string vertex_shader_source = nzl::slurp(nzl::get_env_var("SHADERS_PATH") + "/simple_shader.vert"); const std::string fragment_shader_source = nzl::slurp(nzl::get_env_var("SHADERS_PATH") + "/simple_shader.frag"); nzl::Shader vert_shader(nzl::Shader::Stage::Vertex, vertex_shader_source); vert_shader.compile(); nzl::Shader frag_shader(nzl::Shader::Stage::Fragment, fragment_shader_source); frag_shader.compile(); std::vector<nzl::Shader> vec; vec.push_back(vert_shader); vec.push_back(frag_shader); nzl::Program program{vec}; program.compile(); return program; } std::vector<glm::vec3> gen_points(float rX, float rY, float number_of_points) { float step_size = 2.0f * 3.14159265358979f / number_of_points; std::vector<glm::vec3> points; for (int i = 0; i < number_of_points; i++) { float x = rX * cos(i * step_size); float y = rY * sin(i * step_size); points.emplace_back(x, y, 0.0f); } return points; } } namespace nzl { struct Ellipse::IDContainer { glm::vec3 m_color; unsigned int m_vao_id; unsigned int m_vbo_id; int m_number_of_points{0}; nzl::Program m_program; IDContainer(glm::vec3 color, float rX, float rY, float number_of_points) : m_color{color}, m_program{create_program()} { glGenVertexArrays(1, &m_vao_id); glBindVertexArray(m_vao_id); glGenBuffers(1, &m_vbo_id); glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); std::vector<glm::vec3> points{gen_points(rX, rY, number_of_points)}; points.push_back(points.front()); m_number_of_points = points.size(); glBufferData(GL_ARRAY_BUFFER, points.size() * 3 * sizeof(float), points.data(), GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); glDisableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); } ~IDContainer() { glDeleteVertexArrays(1, &m_vao_id); glDeleteBuffers(1, &m_vbo_id); } }; Ellipse::Ellipse(float rX, float rY, int number_of_points, glm::vec3 color) noexcept : m_id_container{ std::make_shared<IDContainer>(color, rX, rY, number_of_points)} {} glm::vec3 Ellipse::color() const noexcept { return m_id_container->m_color; } void Ellipse::set_color(glm::vec3 color) noexcept { m_id_container->m_color = color; } nzl::Program Ellipse::get_program() const noexcept { return m_id_container->m_program; } void Ellipse::do_render(TimePoint t [[maybe_unused]]) { m_id_container->m_program.use(); m_id_container->m_program.set("color", m_id_container->m_color); glBindVertexArray(m_id_container->m_vao_id); glEnableVertexAttribArray(0); glDrawArrays(GL_LINE_STRIP, 0, m_id_container->m_number_of_points); glDisableVertexAttribArray(0); glBindVertexArray(0); } }
#include "ellipse.hpp" #include <cmath> #include <iostream> #include <memory> #include "program.hpp" #include "shader.hpp" #include "time_point.hpp" #include "utilities.hpp" #include <GL/glew.h> #include <GLFW/glfw3.h> #include <glm/glm.hpp> namespace { nzl::Program create_program() { const std::string vertex_shader_source = nzl::slurp(nzl::get_env_var("SHADERS_PATH") + "/simple_shader.vert"); const std::string fragment_shader_source = nzl::slurp(nzl::get_env_var("SHADERS_PATH") + "/simple_shader.frag"); nzl::Shader vert_shader(nzl::Shader::Stage::Vertex, vertex_shader_source); vert_shader.compile(); nzl::Shader frag_shader(nzl::Shader::Stage::Fragment, fragment_shader_source); frag_shader.compile(); std::vector<nzl::Shader> vec; vec.push_back(vert_shader); vec.push_back(frag_shader); nzl::Program program{vec}; program.compile(); return program; } std::vector<glm::vec3> gen_points(float rX, float rY, float number_of_points) { float step_size = 2.0f * 3.14159265358979f / number_of_points; std::vector<glm::vec3> points; for (int i = 0;
} namespace nzl { struct Ellipse::IDContainer { glm::vec3 m_color; unsigned int m_vao_id; unsigned int m_vbo_id; int m_number_of_points{0}; nzl::Program m_program; IDContainer(glm::vec3 color, float rX, float rY, float number_of_points) : m_color{color}, m_program{create_program()} { glGenVertexArrays(1, &m_vao_id); glBindVertexArray(m_vao_id); glGenBuffers(1, &m_vbo_id); glBindBuffer(GL_ARRAY_BUFFER, m_vbo_id); std::vector<glm::vec3> points{gen_points(rX, rY, number_of_points)}; points.push_back(points.front()); m_number_of_points = points.size(); glBufferData(GL_ARRAY_BUFFER, points.size() * 3 * sizeof(float), points.data(), GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0); glDisableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindVertexArray(0); } ~IDContainer() { glDeleteVertexArrays(1, &m_vao_id); glDeleteBuffers(1, &m_vbo_id); } }; Ellipse::Ellipse(float rX, float rY, int number_of_points, glm::vec3 color) noexcept : m_id_container{ std::make_shared<IDContainer>(color, rX, rY, number_of_points)} {} glm::vec3 Ellipse::color() const noexcept { return m_id_container->m_color; } void Ellipse::set_color(glm::vec3 color) noexcept { m_id_container->m_color = color; } nzl::Program Ellipse::get_program() const noexcept { return m_id_container->m_program; } void Ellipse::do_render(TimePoint t [[maybe_unused]]) { m_id_container->m_program.use(); m_id_container->m_program.set("color", m_id_container->m_color); glBindVertexArray(m_id_container->m_vao_id); glEnableVertexAttribArray(0); glDrawArrays(GL_LINE_STRIP, 0, m_id_container->m_number_of_points); glDisableVertexAttribArray(0); glBindVertexArray(0); } }
i < number_of_points; i++) { float x = rX * cos(i * step_size); float y = rY * sin(i * step_size); points.emplace_back(x, y, 0.0f); } return points; }
function_block-function_prefixed
[ { "content": "class Program {\n\n public:\n\n /// @brief Create a Program from the given @link Shader Shaders@endlink.\n\n /// @param shaders Shaders to be used to create this Program.\n\n Program(std::vector<nzl::Shader> shaders);\n\n\n\n /// @brief Creates a Program with an empty @link Shader@endlink vect...
C++
Ai.cpp
NicoSchumann/TicTacToe
df7349ebd82dfbc2561b4dc1b4627917d4067845
#include "Ai.hpp" #include <ctime> #include <climits> Ai::Ai(Mark aiPlayer) : m_aiPlayer(aiPlayer) , m_pointsAtLost(-1) , m_pointsAtWin(1) , m_pointsAtDraw(0) {} Ai::Ai() : Ai(Mark::empty) {} RandomAi::RandomAi(const Mark aiPlayer) : Ai::Ai(aiPlayer) , m_randomRounds(100) { std::srand(std::time(0)); } RandomAi::RandomAi() : RandomAi(Mark::empty) {} void RandomAi::playRandomField(Board & board, Mark currPlayer) { int emptyFields = 0; for (int i = 0; i < 9; ++i) { if (board.getMark(i) == Mark::empty) { ++ emptyFields; } } int r = rand() % emptyFields; for (int i = 0; i < 9; ++i ) { if (board.getMark(i) != Mark::empty) { continue; } if (r == 0) { board.setMark(currPlayer, i); break; } --r; } } int RandomAi::getSuggestedField(const Board & board, const Mark currPlayer) { if (board.evaluate() != State::inProgress) { return -1; } std::array<int, 9> fieldVals; for (int i = 0; i < 9; ++i) { if (board.getMark(i) == Mark::empty) { fieldVals[i] = 0; } else { fieldVals[i] = (m_randomRounds * m_pointsAtLost) - 1; } } for (int i = 0; i < 9; ++i) { if (board.getMark(i) != Mark::empty) { continue; } Board * bo = new Board(board); bo->setMark(currPlayer, i); if (bo->evaluate() != State::inProgress) { return i; } for (int k = 0; k < m_randomRounds; ++k) { Mark cp = (currPlayer == Mark::cross ? Mark::ring : Mark::cross); Board * b = new Board(*bo); State state = State::inProgress; do { playRandomField( *b, cp); cp = (cp == Mark::cross ? Mark::ring : Mark::cross); state = b->evaluate(); } while (state == State::inProgress); delete b; if (state == State::draw) { fieldVals[i] += m_pointsAtDraw; } else if ((state == State::cross && currPlayer == Mark::cross) ||(state == State::ring && currPlayer == Mark::ring)) { fieldVals[i] += m_pointsAtWin; } else { fieldVals[i] += m_pointsAtLost; } } delete bo; } int suggestedField = -1; int maxFieldVal = m_randomRounds * m_pointsAtLost -1; for (int i = 0; i < 9; ++i) { if (fieldVals[i] > maxFieldVal) { maxFieldVal = fieldVals[i]; suggestedField = i; } } for (int i = 0; i < fieldVals.size(); ++i) { std::cerr << "fieldVals["<<i<<"]:"<<fieldVals[i]<<"\n"; } return suggestedField; } MinimaxAi::MinimaxAi(const Mark aiPlayer) : Ai::Ai(aiPlayer) {} MinimaxAi::MinimaxAi() : MinimaxAi(Mark::empty) {} int MinimaxAi::getSuggestedField(const Board & board, const Mark currPlayer) { if (board.evaluate() != State::inProgress) { return -1; } int fieldNo = -1; int fieldVal; if(currPlayer == Mark::cross) { fieldVal = INT_MIN; } else if (currPlayer == Mark::ring) { fieldVal = INT_MAX; } Mark changedPlayer = (currPlayer == Mark::cross ? Mark::ring : Mark::cross); for (int i = 0; i < 9; ++i) { if (board.getMark(i) != Mark::empty) { continue; } Board * b = new Board(board); b->setMark(currPlayer, i); int val = minimax(*b, changedPlayer ); delete b; if (currPlayer == Mark::cross && val > fieldVal) { fieldVal = val; fieldNo = i; } else if (currPlayer == Mark::ring && val < fieldVal) { fieldVal = val; fieldNo = i; } } return fieldNo; } int MinimaxAi::minimax(const Board & board, const Mark currPlayer) { State state = board.evaluate(); if (state == State::cross) return m_pointsAtWin; if (state == State::ring) return m_pointsAtLost; if (state == State::draw) return m_pointsAtDraw; int bestVal; if (currPlayer == Mark::cross) bestVal = INT_MIN; else if (currPlayer == Mark::ring) bestVal = INT_MAX; Mark changedPlayer = (currPlayer == Mark::cross ? Mark::ring : Mark::cross); for (int i = 0; i < 9; ++i) { if (board.getMark(i) != Mark::empty) { continue; } Board * b = new Board(board); b->setMark(currPlayer,i); int val = minimax(*b,changedPlayer); delete b; if (currPlayer == Mark::cross && val > bestVal) { bestVal = std::max(val,bestVal); } else if (currPlayer == Mark::ring && val < bestVal) { bestVal = std::min(val,bestVal); } } return bestVal; }
#include "Ai.hpp" #include <ctime> #include <climits> Ai::Ai(Mark aiPlayer) : m_aiPlayer(aiPlayer) , m_pointsAtLost(-1) , m_pointsAtWin(1) , m_pointsAtDraw(0) {} Ai::Ai() : Ai(Mark::empty) {} RandomAi::RandomAi(const Mark aiPlayer) : Ai::Ai(aiPlayer) , m_randomRounds(100) { std::srand(std::time(0)); } RandomAi::RandomAi() : RandomAi(Mark::empty) {} void RandomAi::playRandomField(Board & board, Mark currPlayer) { int emptyFields = 0; for (int i = 0; i < 9; ++i) { if (board.getMark(i) == Mark::empty) { ++ emptyFields; } } int r = rand() % emptyFields; for (int i = 0; i < 9; ++i ) { if (board.getMark(i) != Mark::empty) { continue; } if (r == 0) { board.setMark(currPlayer, i); break; } --r; } } int RandomAi::getSuggestedField(const Board & board, const Mark currPlayer) { if (board.evaluate() != State::inProgress) { return -1; } std::array<int, 9> fieldVals; for (int i = 0; i < 9; ++i) { if (board.getMark(i) == Mark::empty) { fieldVals[i] = 0; } else { fieldVals[i] = (m_randomRounds * m_pointsAtLost) - 1; } } for (int i = 0; i < 9; ++i) { if (board.getMark(i) != Mark::empty) { continue; } Board * bo = new Board(board); bo->setMark(currPlayer, i); if (bo->evaluate() != State::inProgress) { return i; } for (int k = 0; k < m_randomRounds; ++k) { Mark cp = (currPlayer == Mark::cross ? Mark::ring : Mark::cross); Board * b = new Board(*bo); State state = State::inProgress; do { playRandomField( *b, cp); cp = (cp == Mark::cross ? Mark::ring : Mark::cross); state = b->evaluate(); } while (state == State::inProgress); delete b; if (state == State::draw) { fieldVals[i] += m_pointsAtDraw; } else if ((state == State::cross && currPlayer == Mark::cross) ||(state == State::ring && currPlayer == Mark::ring)) { fieldVals[i] += m_pointsAtWin; } else { fieldVals[i] += m_pointsAtLost; } } delete bo; } int suggestedField = -1; int maxFieldVal = m_randomRounds * m_pointsAtLost -1; for (int i = 0; i < 9; ++i) { if (fieldVals[i] > maxFieldVal) { maxFieldVal = fieldVals[i]; suggestedField = i; } } for (int i = 0; i < fieldVals.size(); ++i) { std::cerr << "fieldVals["<<i<<"]:"<<fieldVals[i]<<"\n"; } return suggestedF
No = -1; int fieldVal; if(currPlayer == Mark::cross) { fieldVal = INT_MIN; } else if (currPlayer == Mark::ring) { fieldVal = INT_MAX; } Mark changedPlayer = (currPlayer == Mark::cross ? Mark::ring : Mark::cross); for (int i = 0; i < 9; ++i) { if (board.getMark(i) != Mark::empty) { continue; } Board * b = new Board(board); b->setMark(currPlayer, i); int val = minimax(*b, changedPlayer ); delete b; if (currPlayer == Mark::cross && val > fieldVal) { fieldVal = val; fieldNo = i; } else if (currPlayer == Mark::ring && val < fieldVal) { fieldVal = val; fieldNo = i; } } return fieldNo; } int MinimaxAi::minimax(const Board & board, const Mark currPlayer) { State state = board.evaluate(); if (state == State::cross) return m_pointsAtWin; if (state == State::ring) return m_pointsAtLost; if (state == State::draw) return m_pointsAtDraw; int bestVal; if (currPlayer == Mark::cross) bestVal = INT_MIN; else if (currPlayer == Mark::ring) bestVal = INT_MAX; Mark changedPlayer = (currPlayer == Mark::cross ? Mark::ring : Mark::cross); for (int i = 0; i < 9; ++i) { if (board.getMark(i) != Mark::empty) { continue; } Board * b = new Board(board); b->setMark(currPlayer,i); int val = minimax(*b,changedPlayer); delete b; if (currPlayer == Mark::cross && val > bestVal) { bestVal = std::max(val,bestVal); } else if (currPlayer == Mark::ring && val < bestVal) { bestVal = std::min(val,bestVal); } } return bestVal; }
ield; } MinimaxAi::MinimaxAi(const Mark aiPlayer) : Ai::Ai(aiPlayer) {} MinimaxAi::MinimaxAi() : MinimaxAi(Mark::empty) {} int MinimaxAi::getSuggestedField(const Board & board, const Mark currPlayer) { if (board.evaluate() != State::inProgress) { return -1; } int field
random
[ { "content": "class Board\n\n{\n\npublic:\n\n Board();\n\n Board(const Board &);\n\n\n\n /** Sets all fields of Board to Mark::empty */\n\n void reset();\n\n\n\n /** Sets a field of the Board class */\n\n void setMark( Mark mark, std::size_t field);\n\n\n\n /** Returns a Board's field value...
C++
hxalignmicrotubules/mtalign/matchingGreedy.cpp
zibamira/microtubulestitching
8322b71701e33fde0400715cd5b4e855779e4eda
#include <hxalignmicrotubules/mtalign/matchingGreedy.h> #include <mclib/internal/McComparators.h> #include <mclib/McDArray.h> #include <mclib/McMath.h> #include <mclib/McPlane.h> #include <mclib/internal/McSorter.h> #include <mclib/McVec3.h> #include <hxalignmicrotubules/mtalign/NullPointRepresentation.h> #include <hxalignmicrotubules/mtalign/data.h> #include <hxalignmicrotubules/mtalign/PGMPairWeights.h> #include <pointmatching/GreedyPointMatchingAlgorithm.h> #include <pointmatching/PointMatchingScoringFunction.h> #include <pointmatching/Transformation.h> #include <pointmatching/PointMatchingDataStruct.h> class CacheObject; namespace ma = mtalign; namespace { class Cache { public: void setCoordsAndDirections(const McDArray<McVec3f>& coordinates, const McDArray<McVec3f>& directions, const McMat4f& transform) { assert(coordinates.size() == directions.size()); mCoords.resize(coordinates.size()); mDirections.resize(directions.size()); for (int i = 0; i < coordinates.size(); i++) { McVec3f dir = coordinates[i] + directions[i]; McVec3f newDir; transform.multVecMatrix(dir, newDir); transform.multVecMatrix(coordinates[i], mCoords[i]); newDir = newDir - mCoords[i]; newDir.normalize(); mDirections[i] = newDir; } } const McDArray<McVec3f>& getCoords() const { return mCoords; } const McDArray<McVec3f>& getDirections() const { return mDirections; } void computeDistancesAndSort(ma::PGMPairWeights weightComputation) { pointSet1IsMatched.resize(weightComputation.mCoords1.size()); pointSet1IsMatched.unsetAll(); pointSet2IsMatched.resize(weightComputation.mCoords2.size()); pointSet2IsMatched.unsetAll(); currListIndex = 0; pointCorrespondence.clear(); pointDist2.clear(); double dist2; for (int i = 0; i < weightComputation.mCoords1.size(); ++i) { for (int j = 0; j < weightComputation.mCoords2.size(); ++j) { if (weightComputation.canPointsBeAPair(i, j)) { dist2 = 1.0 - weightComputation.getWeight(i, j); pointCorrespondence.append(McVec2i(i, j)); pointDist2.append(dist2); } } } sortedDist2List.resize(pointCorrespondence.size()); for (int i = 0; i < sortedDist2List.size(); ++i) { sortedDist2List[i] = i; } if (pointDist2.size() > 0) { McIndexByValueComparator<double> comparator(&pointDist2[0]); sort(&(sortedDist2List[0]), sortedDist2List.size(), comparator); } } bool getNextMatchingPair(int& set1PointIx, int& set2PointIx, double& dist2) { if (currListIndex < sortedDist2List.size()) { int ix1, ix2; do { ix1 = pointCorrespondence[sortedDist2List[currListIndex]][0]; if (pointSet1IsMatched[ix1]) { currListIndex++; } else { ix2 = pointCorrespondence[sortedDist2List[currListIndex]][1]; if (pointSet2IsMatched[ix2]) { currListIndex++; } else { set1PointIx = ix1; set2PointIx = ix2; dist2 = pointDist2[sortedDist2List[currListIndex]]; pointSet1IsMatched.set(ix1); pointSet2IsMatched.set(ix2); return true; } } } while (currListIndex < sortedDist2List.size()); } return false; } protected: McDArray<McVec3f> mCoords; McDArray<McVec3f> mDirections; private: McDArray<McVec2i> pointCorrespondence; McDArray<double> pointDist2; McDArray<int> sortedDist2List; McBitfield pointSet1IsMatched; McBitfield pointSet2IsMatched; int currListIndex; }; class RefRepr : public ma::NullPointRepresentation { public: RefRepr(const ma::FacingPointSets& pts, const McMat4f& startTransformation, ma::PGMPairWeights weightComputation) : mNRef(pts.ref.positions.size()), mNTrans(pts.trans.positions.size()) { mCache.setCoordsAndDirections(pts.trans.positions, pts.trans.directions, startTransformation); ma::PGMPairWeights newComp( weightComputation.mCoords1, mCache.getCoords(), weightComputation.mDirections1, mCache.getDirections(), weightComputation.mConfig); mCache.computeDistancesAndSort(newComp); } virtual int getNumPoints() const { return mNRef; } private: virtual void setScoreDivisor(const PointRepresentation* pointSet2, PointMatchingScoringFunction* scoringFunction) const { scoringFunction->setScoreDivisor(mNRef, mNTrans); } virtual CacheObject* startGreedyPointMatching( const PointRepresentation* pointSet2, const Transformation* pointSet2StartTransform) const { return 0; } virtual bool getNextMatchingPair(CacheObject* cacheObject, int& refPointIx, int& queryPointIx, double& dist2) const { return mCache.getNextMatchingPair(refPointIx, queryPointIx, dist2); } virtual void finishGreedyPointMatching() const {} private: int mNRef; int mNTrans; mutable Cache mCache; }; class TransRepr : public ma::NullPointRepresentation { public: TransRepr(int n) : mN(n) {} private: virtual int getNumPoints() const { return mN; } int mN; }; } ma::Matching ma::matchingGreedy(const ma::FacingPointSets& pts, McMat4f startTransformation, const ma::PGMPairWeightsParams& weightConfig) { McHandle<PointMatchingScoringFunction> scoringFunction = new PointMatchingScoringFunction(); scoringFunction->setRMSDScaleFactor(1.e-15); GreedyPointMatchingAlgorithm pmAlg; pmAlg.setMinPointMatchingSize(3); pmAlg.setScoringFunction(scoringFunction.ptr()); Transformation st; st.setTransformation3d(startTransformation); const ma::PGMPairWeights weightComputation( pts.ref.positions, pts.trans.positions, pts.ref.directions, pts.trans.directions, weightConfig); const RefRepr refRepresentation(pts, startTransformation, weightComputation); const TransRepr transRepresentation(pts.trans.positions.size()); PointMatchingDataStruct pointMatching; pmAlg.computePointMatching(&refRepresentation, &transRepresentation, &st, &pointMatching); Matching matching; matching.matchedRefPointIds = pointMatching.getRefPoints(); matching.matchedTransPointIds = pointMatching.getQueryPoints(); return matching; }
#include <hxalignmicrotubules/mtalign/matchingGreedy.h> #include <mclib/internal/McComparators.h> #include <mclib/McDArray.h> #include <mclib/McMath.h> #include <mclib/McPlane.h> #include <mclib/internal/McSorter.h> #include <mclib/McVec3.h> #include <hxalignmicrotubules/mtalign/NullPointRepresentation.h> #include <hxalignmicrotubules/mtalign/data.h> #include <hxalignmicrotubules/mtalign/PGMPairWeights.h> #include <pointmatching/GreedyPointMatchingAlgorithm.h> #include <pointmatching/PointMatchingScoringFunction.h> #include <pointmatching/Transformation.h> #include <pointmatching/PointMatchingDataStruct.h> class CacheObject; namespace ma = mtalign; namespace { class Cache { public: void setCoordsAndDirections(const McDArray<McVec3f>& coordinates, const McDArray<McVec3f>& directions, const McMat4f& transform) { assert(coordinates.size() == directions.size()); mCoords.resize(coordinates.size()); mDirections.resize(directions.size()); for (int i = 0; i < coordinates.size(); i++) { McVec3f dir = coordinates[i] + directions[i]; McVec3f newDir; transform.multVecMatrix(dir, newDir); transform.multVecMatrix(coordinates[i], mCoords[i]); newDir = newDir - mCoords[i]; newDir.normalize(); mDirections[i] = newDir; } } const McDArray<McVec3f>& getCoords() const { return mCoords; } const McDArray<McVec3f>& getDirections() const { return mDirections; } void computeDistancesAndSort(ma::PGMPairWeights weightComputation) { pointSet1IsMatched.resize(weightComputation.mCoords1.size()); pointSet1IsMatched.unsetAll(); pointSet2IsMatched.resize(weightComputation.mCoords2.size()); pointSet2IsMatched.unsetAll(); currListIndex = 0; pointCorrespondence.clear(); pointDist2.clear(); double dist2; for (int i = 0; i < weightComputation.mCoords1.size(); ++i) { for (int j = 0; j < weightComputation.mCoords2.size(); ++j) { if (weightComputation.canPointsBeAPair(i, j)) { dist2 = 1.0 - weightComputation.getWeight(i, j); pointCorrespondence.append(McVec2i(i, j)); pointDist2.append(dist2); } } } sortedDist2List.resize(pointCorrespondence.size()); for (int i = 0; i < sortedDist2List.size(); ++i) { sortedDist2List[i] = i; }
} bool getNextMatchingPair(int& set1PointIx, int& set2PointIx, double& dist2) { if (currListIndex < sortedDist2List.size()) { int ix1, ix2; do { ix1 = pointCorrespondence[sortedDist2List[currListIndex]][0]; if (pointSet1IsMatched[ix1]) { currListIndex++; } else { ix2 = pointCorrespondence[sortedDist2List[currListIndex]][1]; if (pointSet2IsMatched[ix2]) { currListIndex++; } else { set1PointIx = ix1; set2PointIx = ix2; dist2 = pointDist2[sortedDist2List[currListIndex]]; pointSet1IsMatched.set(ix1); pointSet2IsMatched.set(ix2); return true; } } } while (currListIndex < sortedDist2List.size()); } return false; } protected: McDArray<McVec3f> mCoords; McDArray<McVec3f> mDirections; private: McDArray<McVec2i> pointCorrespondence; McDArray<double> pointDist2; McDArray<int> sortedDist2List; McBitfield pointSet1IsMatched; McBitfield pointSet2IsMatched; int currListIndex; }; class RefRepr : public ma::NullPointRepresentation { public: RefRepr(const ma::FacingPointSets& pts, const McMat4f& startTransformation, ma::PGMPairWeights weightComputation) : mNRef(pts.ref.positions.size()), mNTrans(pts.trans.positions.size()) { mCache.setCoordsAndDirections(pts.trans.positions, pts.trans.directions, startTransformation); ma::PGMPairWeights newComp( weightComputation.mCoords1, mCache.getCoords(), weightComputation.mDirections1, mCache.getDirections(), weightComputation.mConfig); mCache.computeDistancesAndSort(newComp); } virtual int getNumPoints() const { return mNRef; } private: virtual void setScoreDivisor(const PointRepresentation* pointSet2, PointMatchingScoringFunction* scoringFunction) const { scoringFunction->setScoreDivisor(mNRef, mNTrans); } virtual CacheObject* startGreedyPointMatching( const PointRepresentation* pointSet2, const Transformation* pointSet2StartTransform) const { return 0; } virtual bool getNextMatchingPair(CacheObject* cacheObject, int& refPointIx, int& queryPointIx, double& dist2) const { return mCache.getNextMatchingPair(refPointIx, queryPointIx, dist2); } virtual void finishGreedyPointMatching() const {} private: int mNRef; int mNTrans; mutable Cache mCache; }; class TransRepr : public ma::NullPointRepresentation { public: TransRepr(int n) : mN(n) {} private: virtual int getNumPoints() const { return mN; } int mN; }; } ma::Matching ma::matchingGreedy(const ma::FacingPointSets& pts, McMat4f startTransformation, const ma::PGMPairWeightsParams& weightConfig) { McHandle<PointMatchingScoringFunction> scoringFunction = new PointMatchingScoringFunction(); scoringFunction->setRMSDScaleFactor(1.e-15); GreedyPointMatchingAlgorithm pmAlg; pmAlg.setMinPointMatchingSize(3); pmAlg.setScoringFunction(scoringFunction.ptr()); Transformation st; st.setTransformation3d(startTransformation); const ma::PGMPairWeights weightComputation( pts.ref.positions, pts.trans.positions, pts.ref.directions, pts.trans.directions, weightConfig); const RefRepr refRepresentation(pts, startTransformation, weightComputation); const TransRepr transRepresentation(pts.trans.positions.size()); PointMatchingDataStruct pointMatching; pmAlg.computePointMatching(&refRepresentation, &transRepresentation, &st, &pointMatching); Matching matching; matching.matchedRefPointIds = pointMatching.getRefPoints(); matching.matchedTransPointIds = pointMatching.getQueryPoints(); return matching; }
if (pointDist2.size() > 0) { McIndexByValueComparator<double> comparator(&pointDist2[0]); sort(&(sortedDist2List[0]), sortedDist2List.size(), comparator); }
if_condition
[ { "content": "/// Approximate inference algorithm \"Tree Expectation Propagation\" [\\ref MiQ04]\n\nclass TreeEP : public JTree {\n\n private:\n\n /// Maximum difference encountered so far\n\n Real _maxdiff;\n\n /// Number of iterations needed\n\n size_t ...
C++
net/ias/mmc/nap/machineenumtask.cpp
npocmaka/Windows-Server-2003
5c6fe3db626b63a384230a1aa6b92ac416b0765f
#include "Precompiled.h" #include "MachineEnumTask.h" #include "MachineNode.h" CMachineEnumTask::CMachineEnumTask( CMachineNode * pMachineNode ) { TRACE_FUNCTION("CMachineEnumTask::CMachineEnumTask"); _ASSERTE( pMachineNode != NULL ); m_pMachineNode = pMachineNode; } CMachineEnumTask::CMachineEnumTask() { TRACE_FUNCTION("CMachineEnumTask::CMachineEnumTask"); } STDMETHODIMP CMachineEnumTask::Init (IDataObject * pdo, LPOLESTR szTaskGroup) { TRACE_FUNCTION("CMachineEnumTask::Init"); if( !lstrcmp(szTaskGroup, L"CMTP1") ) { m_type = 1; } else { _ASSERTE(FALSE); } return S_OK; } STDMETHODIMP CMachineEnumTask::Next (ULONG celt, MMC_TASK *rgelt, ULONG *pceltFetched) { TRACE_FUNCTION("CMachineEnumTask::Next"); if ((rgelt == NULL) || (pceltFetched == NULL)) { return E_INVALIDARG; } _ASSERTE(!IsBadWritePtr (rgelt, celt*sizeof(MMC_TASK))); _ASSERTE(!IsBadWritePtr (pceltFetched, sizeof(ULONG))); _ASSERTE( m_type == 1 ); _ASSERTE( m_pMachineNode != NULL ); UINT uintTextResourceID; UINT uintHelpTextResourceID; TCHAR lpszTemp[IAS_MAX_STRING]; int nLoadStringResult; OLECHAR szMouseOverBuffer[MAX_PATH*2]; lstrcpy (szMouseOverBuffer, L"res://"); HINSTANCE hInstance = _Module.GetModuleInstance(); ::GetModuleFileName (hInstance, szMouseOverBuffer + lstrlen(szMouseOverBuffer), MAX_PATH); OLECHAR * szMouseOverBufferAfterFileName = szMouseOverBuffer + lstrlen(szMouseOverBuffer); OLECHAR szMouseOffBuffer[MAX_PATH*2]; lstrcpy( szMouseOffBuffer, szMouseOverBuffer ); OLECHAR * szMouseOffBufferAfterFileName = szMouseOffBuffer + lstrlen(szMouseOffBuffer); for (ULONG i=0; i<celt; i++) { MMC_TASK * task = &rgelt[i]; task->eActionType = MMC_ACTION_ID; task->sDisplayObject.eDisplayType = MMC_TASK_DISPLAY_TYPE_BITMAP; switch( m_index ) { case 0: lstrcpy (szMouseOverBufferAfterFileName , L"/img\\TaskDefineNAPMouseOver.gif"); lstrcpy (szMouseOffBufferAfterFileName , L"/img\\TaskDefineNAP.gif"); uintTextResourceID = IDS_TASKPAD_TEXT__DEFINE_NETWORK_ACCCESS_POLICY; uintHelpTextResourceID = IDS_TASKPAD_HELP_TEXT__DEFINE_NETWORK_ACCCESS_POLICY; task->nCommandID = MACHINE_TASK__DEFINE_NETWORK_ACCESS_POLICY; break; default: if (pceltFetched) { *pceltFetched = i; } return S_FALSE; break; } task->sDisplayObject.uBitmap.szMouseOverBitmap = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(szMouseOverBuffer)+1) ); if( task->sDisplayObject.uBitmap.szMouseOverBitmap ) { lstrcpy( task->sDisplayObject.uBitmap.szMouseOverBitmap, szMouseOverBuffer ); task->sDisplayObject.uBitmap.szMouseOffBitmap = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(szMouseOffBuffer)+1) ); if( task->sDisplayObject.uBitmap.szMouseOffBitmap ) { lstrcpy( task->sDisplayObject.uBitmap.szMouseOffBitmap, szMouseOffBuffer); nLoadStringResult = LoadString( _Module.GetResourceInstance(), uintTextResourceID, lpszTemp, IAS_MAX_STRING ); _ASSERT( nLoadStringResult > 0 ); task->szText = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(lpszTemp)+1) ); if (task->szText) { lstrcpy( task->szText, lpszTemp ); nLoadStringResult = LoadString( _Module.GetResourceInstance(), uintHelpTextResourceID, lpszTemp, IAS_MAX_STRING ); _ASSERT( nLoadStringResult > 0 ); task->szHelpString = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(lpszTemp)+1) ); if (task->szHelpString) { lstrcpy( task->szHelpString, lpszTemp ); m_index++; continue; } CoTaskMemFree(task->szText); } CoTaskMemFree(task->sDisplayObject.uBitmap.szMouseOffBitmap); } CoTaskMemFree(task->sDisplayObject.uBitmap.szMouseOverBitmap); } if ( NULL != pceltFetched) { *pceltFetched = i; } return S_FALSE; } if (pceltFetched) *pceltFetched = celt; return S_OK; } STDMETHODIMP CMachineEnumTask::CopyState( CMachineEnumTask * pSourceMachineEnumTask ) { TRACE_FUNCTION("CMachineEnumTask::CopyState"); m_pMachineNode = pSourceMachineEnumTask->m_pMachineNode; m_index = pSourceMachineEnumTask->m_index; m_type = pSourceMachineEnumTask->m_type; return S_OK; }
#include "Precompiled.h" #include "MachineEnumTask.h" #include "MachineNode.h" CMachineEnumTask::CMachineEnumTask( CMachineNode * pMachineNode ) { TRACE_FUNCTION("CMachineEnumTask::CMachineEnumTask"); _ASSERTE( pMachineNode != NULL ); m_pMachineNode = pMachineNode; } CMachineEnumTask::CMachineEnumTask() { TRACE_FUNCTION("CMachineEnumTask::CMachineEnumTask"); } STDMETHODIMP CMachineEnumTask::Init (IDataObject * pdo, LPOLESTR szTaskGroup) { TRACE_FUNCTION("CMachineEnumTask::Init"); if( !lstrcmp(szTaskGroup, L"CMTP1") ) { m_type = 1; } else { _ASSERTE(FALSE); } return S_OK; }
STDMETHODIMP CMachineEnumTask::CopyState( CMachineEnumTask * pSourceMachineEnumTask ) { TRACE_FUNCTION("CMachineEnumTask::CopyState"); m_pMachineNode = pSourceMachineEnumTask->m_pMachineNode; m_index = pSourceMachineEnumTask->m_index; m_type = pSourceMachineEnumTask->m_type; return S_OK; }
STDMETHODIMP CMachineEnumTask::Next (ULONG celt, MMC_TASK *rgelt, ULONG *pceltFetched) { TRACE_FUNCTION("CMachineEnumTask::Next"); if ((rgelt == NULL) || (pceltFetched == NULL)) { return E_INVALIDARG; } _ASSERTE(!IsBadWritePtr (rgelt, celt*sizeof(MMC_TASK))); _ASSERTE(!IsBadWritePtr (pceltFetched, sizeof(ULONG))); _ASSERTE( m_type == 1 ); _ASSERTE( m_pMachineNode != NULL ); UINT uintTextResourceID; UINT uintHelpTextResourceID; TCHAR lpszTemp[IAS_MAX_STRING]; int nLoadStringResult; OLECHAR szMouseOverBuffer[MAX_PATH*2]; lstrcpy (szMouseOverBuffer, L"res://"); HINSTANCE hInstance = _Module.GetModuleInstance(); ::GetModuleFileName (hInstance, szMouseOverBuffer + lstrlen(szMouseOverBuffer), MAX_PATH); OLECHAR * szMouseOverBufferAfterFileName = szMouseOverBuffer + lstrlen(szMouseOverBuffer); OLECHAR szMouseOffBuffer[MAX_PATH*2]; lstrcpy( szMouseOffBuffer, szMouseOverBuffer ); OLECHAR * szMouseOffBufferAfterFileName = szMouseOffBuffer + lstrlen(szMouseOffBuffer); for (ULONG i=0; i<celt; i++) { MMC_TASK * task = &rgelt[i]; task->eActionType = MMC_ACTION_ID; task->sDisplayObject.eDisplayType = MMC_TASK_DISPLAY_TYPE_BITMAP; switch( m_index ) { case 0: lstrcpy (szMouseOverBufferAfterFileName , L"/img\\TaskDefineNAPMouseOver.gif"); lstrcpy (szMouseOffBufferAfterFileName , L"/img\\TaskDefineNAP.gif"); uintTextResourceID = IDS_TASKPAD_TEXT__DEFINE_NETWORK_ACCCESS_POLICY; uintHelpTextResourceID = IDS_TASKPAD_HELP_TEXT__DEFINE_NETWORK_ACCCESS_POLICY; task->nCommandID = MACHINE_TASK__DEFINE_NETWORK_ACCESS_POLICY; break; default: if (pceltFetched) { *pceltFetched = i; } return S_FALSE; break; } task->sDisplayObject.uBitmap.szMouseOverBitmap = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(szMouseOverBuffer)+1) ); if( task->sDisplayObject.uBitmap.szMouseOverBitmap ) { lstrcpy( task->sDisplayObject.uBitmap.szMouseOverBitmap, szMouseOverBuffer ); task->sDisplayObject.uBitmap.szMouseOffBitmap = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(szMouseOffBuffer)+1) ); if( task->sDisplayObject.uBitmap.szMouseOffBitmap ) { lstrcpy( task->sDisplayObject.uBitmap.szMouseOffBitmap, szMouseOffBuffer); nLoadStringResult = LoadString( _Module.GetResourceInstance(), uintTextResourceID, lpszTemp, IAS_MAX_STRING ); _ASSERT( nLoadStringResult > 0 ); task->szText = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(lpszTemp)+1) ); if (task->szText) { lstrcpy( task->szText, lpszTemp ); nLoadStringResult = LoadString( _Module.GetResourceInstance(), uintHelpTextResourceID, lpszTemp, IAS_MAX_STRING ); _ASSERT( nLoadStringResult > 0 ); task->szHelpString = (LPOLESTR) CoTaskMemAlloc( sizeof(OLECHAR)*(lstrlen(lpszTemp)+1) ); if (task->szHelpString) { lstrcpy( task->szHelpString, lpszTemp ); m_index++; continue; } CoTaskMemFree(task->szText); } CoTaskMemFree(task->sDisplayObject.uBitmap.szMouseOffBitmap); } CoTaskMemFree(task->sDisplayObject.uBitmap.szMouseOverBitmap); } if ( NULL != pceltFetched) { *pceltFetched = i; } return S_FALSE; } if (pceltFetched) *pceltFetched = celt; return S_OK; }
function_block-full_function
[]
C++
Analysis/AnalysisOrg/IO/CaptureImageState.cpp
konradotto/TS
bf088bd8432b1e3f4b8c8c083650a30d9ef2ae2e
#include "CaptureImageState.h" #include "IonH5File.h" #include "IonH5Arma.h" #include "ImageTransformer.h" #include "Vecs.h" #include <malloc.h> CaptureImageState::CaptureImageState(std::string _h5File) { h5file = _h5File; } void CaptureImageState::CleanUpOldFile() { if (isFile (h5file.c_str())) remove(h5file.c_str()); } void CaptureImageState::WriteImageGainCorrection(int rows, int cols) { for (int row = 0;row < rows;row++) { for (int col = 0;col < cols;col++) { assert ( !isnan(ImageTransformer::gain_correction[row*cols + col]) ); } } std::string h5_name = h5file + ":/imgGain/gain_corr"; assert(ImageTransformer::gain_correction != NULL); std::vector<float> gain(ImageTransformer::gain_correction, ImageTransformer::gain_correction + rows*cols); printf("[CaptureImageState] Writing Image gain correction to %s\n",h5file.c_str()); H5File::WriteVector (h5_name, gain, false); } void CaptureImageState::LoadImageGainCorrection(int rows, int cols) { std::string h5_name = h5file + ":/imgGain/gain_corr"; std::vector<float> gain; printf("[CaptureImageState] Loading Image gain correction from %s\n",h5file.c_str()); H5File::ReadVector (h5_name, gain); if (ImageTransformer::gain_correction == NULL) { ImageTransformer::gain_correction = (float *)memalign(VEC8F_SIZE_B,sizeof(float)*rows*cols); } std::fill(ImageTransformer::gain_correction, ImageTransformer::gain_correction + rows * cols, 0); std::copy(gain.begin(), gain.end(), ImageTransformer::gain_correction); for (int row = 0;row < rows;row++) { for (int col = 0;col < cols;col++) { if ( isnan(ImageTransformer::gain_correction[row*cols + col]) ) ImageTransformer::gain_correction[row*cols + col] = 1.0f; } } } void CaptureImageState::WriteXTCorrection() { std::string h5_name = h5file + ":/XTalk_corr/"; if ( ImageTransformer::custom_correction_data != NULL ){ ChannelXTCorrectionDescriptor xt_vectors = ImageTransformer::custom_correction_data->GetCorrectionDescriptor(); if ( xt_vectors.xt_vector_ptrs != NULL ){ printf("[CaptureImageState] Writing electrical XeTalk correction to %s\n",h5file.c_str()); float **vects = xt_vectors.xt_vector_ptrs; int nvects = xt_vectors.num_vectors; int *col_offset = xt_vectors.vector_indicies; int vector_len = xt_vectors.vector_len; int num_and_len[] = {nvects, vector_len}; std::vector<int> H5num_and_len(num_and_len, num_and_len+2); H5File::WriteVector (h5_name+"num_and_length", H5num_and_len); std::vector<int> H5col_offset(col_offset, col_offset+nvects-1); H5File::WriteVector (h5_name+"vector_indicies", H5col_offset); arma::Mat<float> H5vectors; H5vectors.set_size (nvects, vector_len); for ( int vndx=0; vndx < nvects; vndx++ ) { for ( int vn=0; vn < vector_len; vn++ ) H5vectors.at (vndx, vn) = vects[vndx][vn]; } H5Arma::WriteMatrix (h5_name+"xt_vectors", H5vectors, false); } } } void CaptureImageState::LoadXTCorrection() { std::string h5_name = h5file + ":/XTalk_corr/"; if (H5File::DatasetExist<std::string> (h5_name+"xt_vectors")){ printf("[CaptureImageState] Loading electrical XeTalk correction from %s\n",h5file.c_str()); std::vector<int> H5num_and_len; H5File::ReadVector (h5_name+"num_and_length", H5num_and_len); int nvects = H5num_and_len[0]; int vector_len = H5num_and_len[1]; std::vector<int> H5col_offset; H5File::ReadVector (h5_name+"vector_indicies",H5col_offset); arma::Mat<float> H5vectors; H5Arma::ReadMatrix (h5_name+"xt_vectors", H5vectors); ChannelXTCorrection *xtptr = new ChannelXTCorrection(); float *pvects = xtptr->AllocateVectorStorage(nvects,vector_len); float **vect_ptrs = xtptr->AllocateVectorPointerStorage(nvects); xtptr->SetVectorIndicies(&H5col_offset[0],vector_len); for ( int vndx=0; vndx < nvects; vndx++ ) { vect_ptrs[vndx] = pvects+vector_len*vndx; for ( int vn=0; vn < vector_len; vn++ ) vect_ptrs[vndx][vn] = H5vectors.at (vndx, vn); } ImageTransformer::custom_correction_data = xtptr; ImageTransformer::selected_chip_xt_vectors = ImageTransformer::custom_correction_data->GetCorrectionDescriptor(); } else{ printf("[CaptureImageState] No electrical XeTalk correction found\n"); } } void CaptureImageState::WriteImageSpec(ImageSpecClass &my_image_spec, int frames) { std::string h5_name = h5file + ":/imgSpec/"; std::vector<int> tstamp(my_image_spec.timestamps, my_image_spec.timestamps + frames); printf("[CaptureImageState] Writing Image Spec to %s\n",h5file.c_str()); H5File::WriteVector (h5_name + "timestamps", tstamp, false); std::vector<int> H5frames(1,frames); H5File::WriteVector (h5_name + "frames", H5frames, false); } void CaptureImageState::LoadImageSpec(ImageSpecClass &my_image_spec) { std::string h5_name = h5file + ":/imgSpec/"; std::vector<int> frames; std::vector<int> tstamp; printf("[CaptureImageState] Loading Image Spec from %s\n",h5file.c_str()); H5File::ReadVector (h5_name + "timestamps", tstamp); H5File::ReadVector (h5_name + "frames", frames); if (my_image_spec.timestamps == NULL) my_image_spec.timestamps = new int[frames[0]]; std::copy(tstamp.begin(), tstamp.end(), my_image_spec.timestamps); }
#include "CaptureImageState.h" #include "IonH5File.h" #include "IonH5Arma.h" #include "ImageTransformer.h" #include "Vecs.h" #include <malloc.h> CaptureImageState::CaptureImageState(std::string _h5File) { h5file = _h5File; } void CaptureImageState::CleanUpOldFile() { if (isFile (h5file.c_str())) remove(h5file.c_str()); } void CaptureImageState::WriteImageGainCorrection(int rows, int cols) { for (int row = 0;row < rows;row++) { for (int col = 0;col < cols;col++) {
void CaptureImageState::LoadImageGainCorrection(int rows, int cols) { std::string h5_name = h5file + ":/imgGain/gain_corr"; std::vector<float> gain; printf("[CaptureImageState] Loading Image gain correction from %s\n",h5file.c_str()); H5File::ReadVector (h5_name, gain); if (ImageTransformer::gain_correction == NULL) { ImageTransformer::gain_correction = (float *)memalign(VEC8F_SIZE_B,sizeof(float)*rows*cols); } std::fill(ImageTransformer::gain_correction, ImageTransformer::gain_correction + rows * cols, 0); std::copy(gain.begin(), gain.end(), ImageTransformer::gain_correction); for (int row = 0;row < rows;row++) { for (int col = 0;col < cols;col++) { if ( isnan(ImageTransformer::gain_correction[row*cols + col]) ) ImageTransformer::gain_correction[row*cols + col] = 1.0f; } } } void CaptureImageState::WriteXTCorrection() { std::string h5_name = h5file + ":/XTalk_corr/"; if ( ImageTransformer::custom_correction_data != NULL ){ ChannelXTCorrectionDescriptor xt_vectors = ImageTransformer::custom_correction_data->GetCorrectionDescriptor(); if ( xt_vectors.xt_vector_ptrs != NULL ){ printf("[CaptureImageState] Writing electrical XeTalk correction to %s\n",h5file.c_str()); float **vects = xt_vectors.xt_vector_ptrs; int nvects = xt_vectors.num_vectors; int *col_offset = xt_vectors.vector_indicies; int vector_len = xt_vectors.vector_len; int num_and_len[] = {nvects, vector_len}; std::vector<int> H5num_and_len(num_and_len, num_and_len+2); H5File::WriteVector (h5_name+"num_and_length", H5num_and_len); std::vector<int> H5col_offset(col_offset, col_offset+nvects-1); H5File::WriteVector (h5_name+"vector_indicies", H5col_offset); arma::Mat<float> H5vectors; H5vectors.set_size (nvects, vector_len); for ( int vndx=0; vndx < nvects; vndx++ ) { for ( int vn=0; vn < vector_len; vn++ ) H5vectors.at (vndx, vn) = vects[vndx][vn]; } H5Arma::WriteMatrix (h5_name+"xt_vectors", H5vectors, false); } } } void CaptureImageState::LoadXTCorrection() { std::string h5_name = h5file + ":/XTalk_corr/"; if (H5File::DatasetExist<std::string> (h5_name+"xt_vectors")){ printf("[CaptureImageState] Loading electrical XeTalk correction from %s\n",h5file.c_str()); std::vector<int> H5num_and_len; H5File::ReadVector (h5_name+"num_and_length", H5num_and_len); int nvects = H5num_and_len[0]; int vector_len = H5num_and_len[1]; std::vector<int> H5col_offset; H5File::ReadVector (h5_name+"vector_indicies",H5col_offset); arma::Mat<float> H5vectors; H5Arma::ReadMatrix (h5_name+"xt_vectors", H5vectors); ChannelXTCorrection *xtptr = new ChannelXTCorrection(); float *pvects = xtptr->AllocateVectorStorage(nvects,vector_len); float **vect_ptrs = xtptr->AllocateVectorPointerStorage(nvects); xtptr->SetVectorIndicies(&H5col_offset[0],vector_len); for ( int vndx=0; vndx < nvects; vndx++ ) { vect_ptrs[vndx] = pvects+vector_len*vndx; for ( int vn=0; vn < vector_len; vn++ ) vect_ptrs[vndx][vn] = H5vectors.at (vndx, vn); } ImageTransformer::custom_correction_data = xtptr; ImageTransformer::selected_chip_xt_vectors = ImageTransformer::custom_correction_data->GetCorrectionDescriptor(); } else{ printf("[CaptureImageState] No electrical XeTalk correction found\n"); } } void CaptureImageState::WriteImageSpec(ImageSpecClass &my_image_spec, int frames) { std::string h5_name = h5file + ":/imgSpec/"; std::vector<int> tstamp(my_image_spec.timestamps, my_image_spec.timestamps + frames); printf("[CaptureImageState] Writing Image Spec to %s\n",h5file.c_str()); H5File::WriteVector (h5_name + "timestamps", tstamp, false); std::vector<int> H5frames(1,frames); H5File::WriteVector (h5_name + "frames", H5frames, false); } void CaptureImageState::LoadImageSpec(ImageSpecClass &my_image_spec) { std::string h5_name = h5file + ":/imgSpec/"; std::vector<int> frames; std::vector<int> tstamp; printf("[CaptureImageState] Loading Image Spec from %s\n",h5file.c_str()); H5File::ReadVector (h5_name + "timestamps", tstamp); H5File::ReadVector (h5_name + "frames", frames); if (my_image_spec.timestamps == NULL) my_image_spec.timestamps = new int[frames[0]]; std::copy(tstamp.begin(), tstamp.end(), my_image_spec.timestamps); }
assert ( !isnan(ImageTransformer::gain_correction[row*cols + col]) ); } } std::string h5_name = h5file + ":/imgGain/gain_corr"; assert(ImageTransformer::gain_correction != NULL); std::vector<float> gain(ImageTransformer::gain_correction, ImageTransformer::gain_correction + rows*cols); printf("[CaptureImageState] Writing Image gain correction to %s\n",h5file.c_str()); H5File::WriteVector (h5_name, gain, false); }
function_block-function_prefix_line
[ { "content": " int row, col; //upper left corner Row and Column\n", "file_path": "Analysis/Region.h", "rank": 0, "score": 125457.39546282355 }, { "content": "__device__\n", "file_path": "Analysis/BkgModel/CUDA/CudaUtils.h", "rank": 1, "score": 119857.84740344397 }, { "co...
C++
modules/audio_processing/aec3/aec_state_unittest.cc
imxiangpeng/webrtc
8078c53c2f8ed487b1c6bbdf3d541f7a5884ed70
#include "webrtc/modules/audio_processing/aec3/aec_state.h" #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h" #include "webrtc/test/gtest.h" namespace webrtc { TEST(AecState, NormalUsage) { ApmDataDumper data_dumper(42); AecState state; FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; EchoPathVariability echo_path_variability(false, false); x.fill(0.f); std::vector<std::array<float, kFftLengthBy2Plus1>> converged_filter_frequency_response(10); for (auto& v : converged_filter_frequency_response) { v.fill(0.01f); } std::vector<std::array<float, kFftLengthBy2Plus1>> diverged_filter_frequency_response = converged_filter_frequency_response; converged_filter_frequency_response[2].fill(100.f); state.Update(diverged_filter_frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.ModelBasedAecFeasible()); EXPECT_FALSE(state.UsableLinearEstimate()); state.Update(diverged_filter_frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.ModelBasedAecFeasible()); for (int k = 0; k < 50; ++k) { state.Update(diverged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } EXPECT_TRUE(state.ModelBasedAecFeasible()); EXPECT_FALSE(state.UsableLinearEstimate()); for (int k = 0; k < 50; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } EXPECT_TRUE(state.UsableLinearEstimate()); echo_path_variability = EchoPathVariability(true, false); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.UsableLinearEstimate()); x.fill(101.f); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_TRUE(state.ActiveRender()); x.fill(0.f); for (int k = 0; k < 200; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } EXPECT_FALSE(state.ActiveRender()); x.fill(101.f); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_TRUE(state.ActiveRender()); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.EchoLeakageDetected()); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, true); EXPECT_TRUE(state.EchoLeakageDetected()); echo_path_variability = EchoPathVariability(false, false); for (int k = 0; k < 200; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } FftData X; X.re.fill(10000.f); X.im.fill(0.f); for (size_t k = 0; k < X_buffer.Buffer().size(); ++k) { X_buffer.Insert(X); } Y2.fill(10.f * 1000.f * 1000.f); E2_main.fill(100.f * Y2[0]); E2_shadow.fill(100.f * Y2[0]); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); E2_main.fill(0.1f * Y2[0]); E2_shadow.fill(E2_main[0]); for (size_t k = 0; k < Y2.size(); k += 2) { E2_main[k] = Y2[k]; E2_shadow[k] = Y2[k]; } state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); const std::array<bool, kFftLengthBy2Plus1>& reliable_bands = state.BandsWithReliableFilter(); EXPECT_EQ(reliable_bands[0], reliable_bands[1]); for (size_t k = 1; k < kFftLengthBy2 - 5; ++k) { EXPECT_TRUE(reliable_bands[k]); } for (size_t k = kFftLengthBy2 - 5; k < reliable_bands.size(); ++k) { EXPECT_EQ(reliable_bands[kFftLengthBy2 - 6], reliable_bands[k]); } Y2.fill(10.f * X.re[0] * X.re[0]); for (size_t k = 0; k < 100000; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } ASSERT_TRUE(state.UsableLinearEstimate()); const std::array<float, kFftLengthBy2Plus1>& erl = state.Erl(); std::for_each(erl.begin(), erl.end(), [](float a) { EXPECT_NEAR(10.f, a, 0.1); }); E2_main.fill(1.f * X.re[0] * X.re[0]); Y2.fill(10.f * E2_main[0]); for (size_t k = 0; k < 10000; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } ASSERT_TRUE(state.UsableLinearEstimate()); std::for_each(state.Erle().begin(), state.Erle().end(), [](float a) { EXPECT_NEAR(8.f, a, 0.1); }); E2_main.fill(1.f * X.re[0] * X.re[0]); Y2.fill(5.f * E2_main[0]); for (size_t k = 0; k < 10000; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } ASSERT_TRUE(state.UsableLinearEstimate()); std::for_each(state.Erle().begin(), state.Erle().end(), [](float a) { EXPECT_NEAR(5.f, a, 0.1); }); } TEST(AecState, NonSignificantDelay) { AecState state; FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; EchoPathVariability echo_path_variability(false, false); x.fill(0.f); std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(30); for (auto& v : frequency_response) { v.fill(0.01f); } state.Update(frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.FilterDelay()); } TEST(AecState, ConvergedFilterDelay) { constexpr int kFilterLength = 10; AecState state; FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; EchoPathVariability echo_path_variability(false, false); x.fill(0.f); std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response( kFilterLength); for (int k = 0; k < kFilterLength; ++k) { for (auto& v : frequency_response) { v.fill(0.01f); } frequency_response[k].fill(100.f); state.Update(frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_TRUE(k == (kFilterLength - 1) || state.FilterDelay()); if (k != (kFilterLength - 1)) { EXPECT_EQ(k, state.FilterDelay()); } } } TEST(AecState, ExternalDelay) { AecState state; std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; E2_main.fill(0.f); E2_shadow.fill(0.f); Y2.fill(0.f); x.fill(0.f); FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(30); for (auto& v : frequency_response) { v.fill(0.01f); } for (size_t k = 0; k < frequency_response.size() - 1; ++k) { state.Update(frequency_response, rtc::Optional<size_t>(k * kBlockSize + 5), X_buffer, E2_main, E2_shadow, Y2, x, EchoPathVariability(false, false), false); EXPECT_TRUE(state.ExternalDelay()); EXPECT_EQ(k, state.ExternalDelay()); } state.Update(frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, EchoPathVariability(false, false), false); EXPECT_FALSE(state.ExternalDelay()); } }
#include "webrtc/modules/audio_processing/aec3/aec_state.h" #include "webrtc/modules/audio_processing/logging/apm_data_dumper.h" #include "webrtc/test/gtest.h" namespace webrtc { TEST(AecState, NormalUsage) { ApmDataDumper data_dumper(42); AecState state; FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; EchoPathVariability echo_path_variability(false, false); x.fill(0.f); std::vector<std::array<float, kFftLengthBy2Plus1>> converged_filter_frequency_response(10); for (auto& v : converged_filter_frequency_response) { v.fill(0.01f); } std::vector<std::array<float, kFftLengthBy2Plus1>> diverged_filter_frequency_response = converged_filter_frequency_response; converged_filter_frequency_response[2].fill(100.f); state.Update(diverged_filter_frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.ModelBasedAecFeasible()); EXPECT_FALSE(state.UsableLinearEstimate()); state.Update(diverged_filter_frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.ModelBasedAecFeasible()); for (int k = 0; k < 50; ++k) { state.Update(diverged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } EXPECT_TRUE(state.ModelBasedAecFeasible()); EXPECT_FALSE(state.UsableLinearEstimate()); for (int k = 0; k < 50; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } EXPECT_TRUE(state.UsableLinearEstimate()); echo_path_variability = EchoPathVariability(true, false); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.UsableLinearEstimate()); x.fill(101.f); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_TRUE(state.ActiveRender()); x.fill(0.f); for (int k = 0; k < 200; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } EXPECT_FALSE(state.ActiveRender()); x.fill(101.f);
; EXPECT_TRUE(state.ActiveRender()); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.EchoLeakageDetected()); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, true); EXPECT_TRUE(state.EchoLeakageDetected()); echo_path_variability = EchoPathVariability(false, false); for (int k = 0; k < 200; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } FftData X; X.re.fill(10000.f); X.im.fill(0.f); for (size_t k = 0; k < X_buffer.Buffer().size(); ++k) { X_buffer.Insert(X); } Y2.fill(10.f * 1000.f * 1000.f); E2_main.fill(100.f * Y2[0]); E2_shadow.fill(100.f * Y2[0]); state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); E2_main.fill(0.1f * Y2[0]); E2_shadow.fill(E2_main[0]); for (size_t k = 0; k < Y2.size(); k += 2) { E2_main[k] = Y2[k]; E2_shadow[k] = Y2[k]; } state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); const std::array<bool, kFftLengthBy2Plus1>& reliable_bands = state.BandsWithReliableFilter(); EXPECT_EQ(reliable_bands[0], reliable_bands[1]); for (size_t k = 1; k < kFftLengthBy2 - 5; ++k) { EXPECT_TRUE(reliable_bands[k]); } for (size_t k = kFftLengthBy2 - 5; k < reliable_bands.size(); ++k) { EXPECT_EQ(reliable_bands[kFftLengthBy2 - 6], reliable_bands[k]); } Y2.fill(10.f * X.re[0] * X.re[0]); for (size_t k = 0; k < 100000; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } ASSERT_TRUE(state.UsableLinearEstimate()); const std::array<float, kFftLengthBy2Plus1>& erl = state.Erl(); std::for_each(erl.begin(), erl.end(), [](float a) { EXPECT_NEAR(10.f, a, 0.1); }); E2_main.fill(1.f * X.re[0] * X.re[0]); Y2.fill(10.f * E2_main[0]); for (size_t k = 0; k < 10000; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } ASSERT_TRUE(state.UsableLinearEstimate()); std::for_each(state.Erle().begin(), state.Erle().end(), [](float a) { EXPECT_NEAR(8.f, a, 0.1); }); E2_main.fill(1.f * X.re[0] * X.re[0]); Y2.fill(5.f * E2_main[0]); for (size_t k = 0; k < 10000; ++k) { state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); } ASSERT_TRUE(state.UsableLinearEstimate()); std::for_each(state.Erle().begin(), state.Erle().end(), [](float a) { EXPECT_NEAR(5.f, a, 0.1); }); } TEST(AecState, NonSignificantDelay) { AecState state; FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; EchoPathVariability echo_path_variability(false, false); x.fill(0.f); std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(30); for (auto& v : frequency_response) { v.fill(0.01f); } state.Update(frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_FALSE(state.FilterDelay()); } TEST(AecState, ConvergedFilterDelay) { constexpr int kFilterLength = 10; AecState state; FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; EchoPathVariability echo_path_variability(false, false); x.fill(0.f); std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response( kFilterLength); for (int k = 0; k < kFilterLength; ++k) { for (auto& v : frequency_response) { v.fill(0.01f); } frequency_response[k].fill(100.f); state.Update(frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false); EXPECT_TRUE(k == (kFilterLength - 1) || state.FilterDelay()); if (k != (kFilterLength - 1)) { EXPECT_EQ(k, state.FilterDelay()); } } } TEST(AecState, ExternalDelay) { AecState state; std::array<float, kFftLengthBy2Plus1> E2_main; std::array<float, kFftLengthBy2Plus1> E2_shadow; std::array<float, kFftLengthBy2Plus1> Y2; std::array<float, kBlockSize> x; E2_main.fill(0.f); E2_shadow.fill(0.f); Y2.fill(0.f); x.fill(0.f); FftBuffer X_buffer(Aec3Optimization::kNone, 30, std::vector<size_t>(1, 30)); std::vector<std::array<float, kFftLengthBy2Plus1>> frequency_response(30); for (auto& v : frequency_response) { v.fill(0.01f); } for (size_t k = 0; k < frequency_response.size() - 1; ++k) { state.Update(frequency_response, rtc::Optional<size_t>(k * kBlockSize + 5), X_buffer, E2_main, E2_shadow, Y2, x, EchoPathVariability(false, false), false); EXPECT_TRUE(state.ExternalDelay()); EXPECT_EQ(k, state.ExternalDelay()); } state.Update(frequency_response, rtc::Optional<size_t>(), X_buffer, E2_main, E2_shadow, Y2, x, EchoPathVariability(false, false), false); EXPECT_FALSE(state.ExternalDelay()); } }
state.Update(converged_filter_frequency_response, rtc::Optional<size_t>(2), X_buffer, E2_main, E2_shadow, Y2, x, echo_path_variability, false)
call_expression
[ { "content": "namespace webrtc {\n\n\n\n// This function sleeps for the specified number of milliseconds.\n\n// It may return early if the thread is woken by some other event,\n\n// such as the delivery of a signal on Unix.\n\nvoid SleepMs(int msecs);\n\n\n", "file_path": "system_wrappers/include/sleep.h", ...
C++
tests/src/memory_operations/interleavelo.cpp
mkeryell/MIPP
f562541b824d7d5a5cdbdecdf2bf357bc7b47f9e
#include <exception> #include <algorithm> #include <numeric> #include <random> #include <cmath> #include <mipp.h> #include <catch.hpp> template <typename T> void test_reg_interleavelo() { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::reg r1 = mipp::load<T>(inputs1); mipp::reg r2 = mipp::load<T>(inputs2); mipp::reg ri = mipp::interleavelo<T>(r1, r2); for (auto i = 0; i < mipp::N<T>(); i++) if (i % 2) REQUIRE(inputs2[i/2] == *((T*)&ri +i)); else REQUIRE(inputs1[i/2] == *((T*)&ri +i)); } #ifndef MIPP_NO #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave low - mipp::reg", "[mipp::interleavelo]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_reg_interleavelo<double>(); } #endif SECTION("datatype = float") { test_reg_interleavelo<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_reg_interleavelo<int64_t>(); } #endif SECTION("datatype = int32_t") { test_reg_interleavelo<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_reg_interleavelo<int16_t>(); } SECTION("datatype = int8_t") { test_reg_interleavelo<int8_t>(); } #endif } #endif #endif template <typename T> void test_Reg_interleavelo() { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::Reg<T> r1 = inputs1; mipp::Reg<T> r2 = inputs2; mipp::Reg<T> ri = mipp::interleavelo(r1, r2); for (auto i = 0; i < mipp::N<T>(); i++) if (i % 2) REQUIRE(ri[i] == inputs2[i/2]); else REQUIRE(ri[i] == inputs1[i/2]); } #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave low - mipp::Reg", "[mipp::interleavelo]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_Reg_interleavelo<double>(); } #endif SECTION("datatype = float") { test_Reg_interleavelo<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_Reg_interleavelo<int64_t>(); } #endif SECTION("datatype = int32_t") { test_Reg_interleavelo<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_Reg_interleavelo<int16_t>(); } SECTION("datatype = int8_t") { test_Reg_interleavelo<int8_t>(); } #endif } #endif template <typename T> void test_reg_interleavelo2() { if (mipp::N<T>() > 2) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::reg r1 = mipp::load<T>(inputs1); mipp::reg r2 = mipp::load<T>(inputs2); mipp::reg ri = mipp::interleavelo2<T>(r1, r2); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(*((T*)&ri +i) == inputs2[i/2]); else REQUIRE(*((T*)&ri +i) == inputs1[i/2]); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(*((T*)&ri + mipp::N<T>()/2 +i) == inputs2[mipp::N<T>()/2 + i/2]); else REQUIRE(*((T*)&ri + mipp::N<T>()/2 +i) == inputs1[mipp::N<T>()/2 + i/2]); } } #ifndef MIPP_NO #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave2 low - mipp::reg", "[mipp::interleavelo2]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_reg_interleavelo2<double>(); } #endif SECTION("datatype = float") { test_reg_interleavelo2<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_reg_interleavelo2<int64_t>(); } #endif SECTION("datatype = int32_t") { test_reg_interleavelo2<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_reg_interleavelo2<int16_t>(); } SECTION("datatype = int8_t") { test_reg_interleavelo2<int8_t>(); } #endif } #endif #endif template <typename T> void test_Reg_interleavelo2() { if (mipp::N<T>() > 2) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::Reg<T> r1 = inputs1; mipp::Reg<T> r2 = inputs2; mipp::Reg<T> ri = mipp::interleavelo2(r1, r2); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(*((T*)&ri +i) == inputs2[i/2]); else REQUIRE(*((T*)&ri +i) == inputs1[i/2]); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(ri[mipp::N<T>()/2 +i] == inputs2[mipp::N<T>()/2 + i/2]); else REQUIRE(ri[mipp::N<T>()/2 +i] == inputs1[mipp::N<T>()/2 + i/2]); } } #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave2 low - mipp::Reg", "[mipp::interleavelo2]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_Reg_interleavelo2<double>(); } #endif SECTION("datatype = float") { test_Reg_interleavelo2<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_Reg_interleavelo2<int64_t>(); } #endif SECTION("datatype = int32_t") { test_Reg_interleavelo2<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_Reg_interleavelo2<int16_t>(); } SECTION("datatype = int8_t") { test_Reg_interleavelo2<int8_t>(); } #endif } #endif template <typename T> void test_reg_interleavelo4() { if (mipp::N<T>() > 4) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::reg r1 = mipp::load<T>(inputs1); mipp::reg r2 = mipp::load<T>(inputs2); mipp::reg ri = mipp::interleavelo4<T>(r1, r2); for (auto j = 0; j < 4; j++) for (auto i = 0; i < mipp::N<T>()/4; i++) if (i % 2) REQUIRE(*((T*)&ri + j*mipp::N<T>()/4 +i) == inputs2[j*mipp::N<T>()/4 + i/2]); else REQUIRE(*((T*)&ri + j*mipp::N<T>()/4 +i) == inputs1[j*mipp::N<T>()/4 + i/2]); } } #ifndef MIPP_NO #if defined(MIPP_AVX512) TEST_CASE("Interleave4 low - mipp::reg", "[mipp::interleavelo4]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_reg_interleavelo4<double>(); } #endif SECTION("datatype = float") { test_reg_interleavelo4<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_reg_interleavelo4<int64_t>(); } #endif SECTION("datatype = int32_t") { test_reg_interleavelo4<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_reg_interleavelo4<int16_t>(); } SECTION("datatype = int8_t") { test_reg_interleavelo4<int8_t>(); } #endif } #endif #endif template <typename T> void test_Reg_interleavelo4() { if (mipp::N<T>() > 4) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::Reg<T> r1 = inputs1; mipp::Reg<T> r2 = inputs2; mipp::Reg<T> ri = mipp::interleavelo4(r1, r2); for (auto j = 0; j < 4; j++) for (auto i = 0; i < mipp::N<T>()/4; i++) if (i % 2) REQUIRE(ri[j*mipp::N<T>()/4 +i] == inputs2[j*mipp::N<T>()/4 + i/2]); else REQUIRE(ri[j*mipp::N<T>()/4 +i] == inputs1[j*mipp::N<T>()/4 + i/2]); } } #if defined(MIPP_AVX512) TEST_CASE("Interleave4 low - mipp::Reg", "[mipp::interleavelo4]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_Reg_interleavelo4<double>(); } #endif SECTION("datatype = float") { test_Reg_interleavelo4<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_Reg_interleavelo4<int64_t>(); } #endif SECTION("datatype = int32_t") { test_Reg_interleavelo4<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_Reg_interleavelo4<int16_t>(); } SECTION("datatype = int8_t") { test_Reg_interleavelo4<int8_t>(); } #endif } #endif
#include <exception> #include <algorithm> #include <numeric> #include <random> #include <cmath> #include <mipp.h> #include <catch.hpp> template <typename T> void test_reg_interleavelo() { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::reg r1 = mipp::load<T>(inputs1); mipp::reg r2 = mipp::load<T>(inputs2); mipp::reg ri = mipp::interleavelo<T>(r1, r2); for (auto i = 0; i < mipp::N<T>(); i++) if (i % 2) REQUIRE(inputs2[i/2] == *((T*)&ri +i)); else REQUIRE(inputs1[i/2] == *((T*)&ri +i)); } #ifndef MIPP_NO #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave low - mipp::reg", "[mipp::interleavelo]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_reg_interleavelo<double>(); } #endif SECTION("datatype = float") { test_reg_interleavelo<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_reg_interleavelo<int64_t>(); } #endif SECTION("datatype = int32_t") { test_reg_interleavelo<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_reg_interleavelo<int16_t>(); } SECTION("datatype = int8_t") { test_reg_interleavelo<int8_t>(); } #endif } #endif #endif template <typename T> void test_Reg_interleavelo() { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::Reg<T> r1 = inputs1; mipp::Reg<T> r2 = inputs2; mipp::Reg<T> ri = mipp::interleavelo(r1, r2); for (auto i = 0; i < mipp::N<T>(); i++) if (i % 2) REQUIRE(ri[i] == inputs2[i/2]); else REQUIRE(ri[i] == inputs1[i/2]); } #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave low - mipp::Reg", "[mipp::interleavelo]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_Reg_interleavelo<double>(); } #endif SECTION("datatype = float") { test_Reg_interleavelo<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_Reg_interleavelo<int64_t>(); } #endif SECTION("datatype = int32_t") { test_Reg_interleavelo<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_Reg_interleavelo<int16_t>(); } SECTION("datatype = int8_t") { test_Reg_interleavelo<int8_t>(); } #endif } #endif template <typename T> void test_reg_interleavelo2() { if (mipp::N<T>() > 2) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::reg r1 = mipp::load<T>(inputs1); mipp::reg r2 = mipp::load<T>(inputs2); mipp::reg ri = mipp::interleavelo2<T>(r1, r2); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(*((T*)&ri +i) == inputs2[i/2]); else REQUIRE(*((T*)&ri +i) == inputs1[i/2]); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(*((T*)&ri + mipp::N<T>()/2 +i) == inputs2[mipp::N<T>()/2 + i/2]); else REQUIRE(*((T*)&ri + mipp::N<T>()/2 +i) == inputs1[mipp::N<T>()/2 + i/2]); } } #ifndef MIPP_NO #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave2 low - mipp::reg", "[mipp::interleavelo2]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_reg_interleavelo2<double>(); } #endif SECTION("datatype = float") { test_reg_interleavelo2<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_reg_interleavelo2<int64_t>(); } #endif SECTION("datatype = int32_t") { test_reg_interleavelo2<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_reg_interleavelo2<int16_t>(); } SECTION("datatype = int8_t") { test_reg_interleavelo2<int8_t>(); } #endif } #endif #endif template <typename T> void test_Reg_interleavelo2() { if (mipp::N<T>() > 2) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::Reg<T> r1 = inputs1; mipp::Reg<T> r2 = inputs2; mipp::Reg<T> ri = mipp::interleavelo2(r1, r2); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(*((T*)&ri +i) == inputs2[i/2]); else REQUIRE(*((T*)&ri +i) == inputs1[i/2]); for (auto i = 0; i < mipp::N<T>()/2; i++) if (i % 2) REQUIRE(ri[mipp::N<T>()/2 +i] == inputs2[mipp::N<T>()/2 + i/2]); else REQUIRE(ri[mipp::N<T>()/2 +i] == inputs1[mipp::N<T>()/2 + i/2]); } } #if !defined(MIPP_AVX) || (defined(MIPP_AVX) && MIPP_INSTR_VERSION >= 2) TEST_CASE("Interleave2 low - mipp::Reg", "[mipp::interleavelo2]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_Reg_interleavelo2<double>(); } #endif SECTION("datatype = float") { test_Reg_interleavelo2<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_Reg_interleavelo2<int64_t>(); } #endif SECTION("datatype = int32_t") { test_Reg_interleavelo2<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_Reg_interleavelo2<int16_t>(); } SECTION("datatype = int8_t") { test_Reg_interleavelo2<int8_t>(); } #endif } #endif template <typename T> void test_reg_interleavelo4() { if (mipp::N<T>() > 4) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + mipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::reg r1 = mipp::load<T>(inputs1); mipp::reg r2 = mipp::load<T>(inputs2); mipp::reg ri = mipp::interleavelo4<T>(r1, r2); for (auto j = 0; j < 4; j++) for (auto i = 0; i < mipp::N<T>()/4; i++) if (i % 2) REQUIRE(*((T*)&ri + j*mipp::N<T>()/4 +i) == inputs2[j*mipp::N<T>()/4 + i/2]); else REQUIRE(*((T*)&ri + j*mipp::N<T>()/4 +i) == inputs1[j*mipp::N<T>()/4 + i/2]); } } #ifndef MIPP_NO #if defined(MIPP_AVX512) TEST_CASE("Interleave4 low - mipp::reg", "[mipp::interleavelo4]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_reg_interleavelo4<double>(); } #endif SECTION("datatype = float") { test_reg_interleavelo4<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_reg_interleavelo4<int64_t>(); } #endif SECTION("datatype = int32_t") { test_reg_interleavelo4<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_reg_interleavelo4<int16_t>(); } SECTION("datatype = int8_t") { test_reg_interleavelo4<int8_t>(); } #endif } #endif #endif template <typename T> void test_Reg_interleavelo4() { if (mipp::N<T>() > 4) { T inputs1[mipp::N<T>()], inputs2[mipp::N<T>()]; std::mt19937 g; std::iota (inputs1, inputs1 + m
#if defined(MIPP_AVX512) TEST_CASE("Interleave4 low - mipp::Reg", "[mipp::interleavelo4]") { #if defined(MIPP_64BIT) SECTION("datatype = double") { test_Reg_interleavelo4<double>(); } #endif SECTION("datatype = float") { test_Reg_interleavelo4<float>(); } #if defined(MIPP_64BIT) SECTION("datatype = int64_t") { test_Reg_interleavelo4<int64_t>(); } #endif SECTION("datatype = int32_t") { test_Reg_interleavelo4<int32_t>(); } #if defined(MIPP_BW) SECTION("datatype = int16_t") { test_Reg_interleavelo4<int16_t>(); } SECTION("datatype = int8_t") { test_Reg_interleavelo4<int8_t>(); } #endif } #endif
ipp::N<T>(), (T)0); std::shuffle(inputs1, inputs1 + mipp::N<T>(), g); std::iota (inputs2, inputs2 + mipp::N<T>(), (T)0); std::shuffle(inputs2, inputs2 + mipp::N<T>(), g); mipp::Reg<T> r1 = inputs1; mipp::Reg<T> r2 = inputs2; mipp::Reg<T> ri = mipp::interleavelo4(r1, r2); for (auto j = 0; j < 4; j++) for (auto i = 0; i < mipp::N<T>()/4; i++) if (i % 2) REQUIRE(ri[j*mipp::N<T>()/4 +i] == inputs2[j*mipp::N<T>()/4 + i/2]); else REQUIRE(ri[j*mipp::N<T>()/4 +i] == inputs1[j*mipp::N<T>()/4 + i/2]); } }
function_block-function_prefixed
[ { "content": "struct Converter<float> {\n\n static_assert(sizeof(float) == sizeof(int32_t), \"Important ULP matcher assumption violated\");\n\n Converter(float f) {\n\n std::memcpy(&i, &f, sizeof(f));\n\n }\n\n int32_t i;\n\n};\n\n\n\ntemplate <>\n", "file_path": "tests/lib/Catch2/include...
C++
MagicSquareAndPipes.cpp
Sigrec/School-Projects
54dec4b6d38eb9b0c020c02d2a7f57b14e52bce2
#include <iostream> #include <unistd.h> #include <sys/utsname.h> #include <math.h> #include <cstring> #include <sys/wait.h> #define SQUARE_SIZE 9 // The max number of characters that can be used for a sequence void DisplaySystemInfo(){ printf("System Info: \n"); char domainname[256]; char hostname[256]; utsname userdata; if (getdomainname(domainname, 256) == 0){ printf("Domain Name: %s\n", domainname); } else { perror("getdomainname() error"); } if (gethostname(hostname, 256) == 0){ printf("Host Name: %s\n", hostname); } else { perror("gethostname() error"); } if (uname(&userdata) == 0){ printf("System Name: %s\n", userdata.sysname); printf("Node Name: %s\n", userdata.nodename); printf("Release: %s\n", userdata.release); printf("Version: %s\n", userdata.version); printf("Machine: %s\n", userdata.machine); printf("Domain Name: %s\n\n", userdata.domainname); } else { perror("uname() error"); } } char GenerateMagicSquare(char *sequence){ int square[3][3]; char answer; int size = sqrt(SQUARE_SIZE); for (int x = 0; x < size; x++){ for (int y = 0; y < size; y++){ square[x][y] = (int) (sequence[y + (x * 3)] - '0'); } } int magicNum = square[0][0] + square[0][1] + square[0][2]; int topLeftToBottomRightDiag = 0, topRightToBottomLeftDiag = 0, rows = 0, cols = 0; for (int x = 0; x < size; x++){ topLeftToBottomRightDiag += square[x][x]; topRightToBottomLeftDiag += square[x][(size - 1) - x]; for (int y = 0; y < size; y++){ rows += square[x][y]; cols += square[y][x]; } if (rows != cols){ answer = 'F'; goto EXIT; } rows = 0; cols = 0; } if ((topLeftToBottomRightDiag == topRightToBottomLeftDiag) && (topRightToBottomLeftDiag == magicNum)){ answer = 'T'; } else{ answer = 'F'; } EXIT: return answer; } bool ValidMagicSquare(char *sequence){ bool validSeq = true; int inputSize = strlen(sequence); for (int x = 0; x < inputSize - 1; x++){ if (!isdigit(sequence[x])){ printf("Input Magic Square Contains Non-Numerical Characters, TRY AGAIN\n"); validSeq = false; goto NEXT; } } NEXT: if (inputSize < SQUARE_SIZE){ printf("Input Magic Square Sequence is too Small, TRY AGAIN\n"); validSeq = false; } else if (inputSize > SQUARE_SIZE) { printf("Input Magic Square Sequence is too Big, TRY AGAIN\n"); validSeq = false; } return validSeq; } int main(int argc, char **argv) { char *inputSquare; do{ printf("Enter 9 Digit Sequence: "); scanf("%s", inputSquare); } while(!ValidMagicSquare(inputSquare)); int client[2]; int server[2]; if (pipe(client) < 0){ fprintf(stderr, "Client Pipe Failed -> %s\n", strerror(errno)); } if (pipe(server) < 0){ fprintf(stderr, "Server Pipe Failed -> %s\n", strerror(errno)); } pid_t pid = fork(); if (pid < 0){ fprintf(stderr, "Fork Failed: %s\n", strerror(errno)); exit(0); } if (pid == 0){ close(client[1]); close(server[0]); char userInputSquare[SQUARE_SIZE + 1]; if (read(client[0], &userInputSquare, sizeof(char) * SQUARE_SIZE + 1) < 0){ fprintf(stderr, "Read From Pipe Failed: %s\n", strerror(errno)); } char answer = GenerateMagicSquare(userInputSquare); if (write(server[1], &answer, sizeof(char) * 2) < 0){ fprintf(stderr, "Write to Pipe Failed: %s\n", strerror(errno)); } close(client[0]); close(server[1]); } else{ system("clear"); close(client[0]); close(server[1]); char answer[2]; if (write(client[1], inputSquare, sizeof(char) * SQUARE_SIZE + 1) < 0){ fprintf(stderr, "Write to Client Failed -> %s", strerror(errno)); } if (read(server[0], answer, sizeof(char) * 2) < 0){ fprintf(stderr, "Read From Pipe Failed: %s", strerror(errno)); } wait(NULL); printf("Sequence Tested: %s\nMagic Square Result: %s\n\n", inputSquare, answer); DisplaySystemInfo(); close(server[0]); close(client[1]); } return 0; }
#include <iostream> #include <unistd.h> #include <sys/utsname.h> #include <math.h> #include <cstring> #include <sys/wait.h> #define SQUARE_SIZE 9 // The max number of characters that can be used for a sequence void DisplaySystemInfo(){ printf("System Info: \n"); char domainname[256]; char hostname[256]; utsname userdata; if (getdomainname(domainname, 256) == 0){ printf("Domain Name: %s\n", domainname); } else { perror("getdomainname() error"); }
if (uname(&userdata) == 0){ printf("System Name: %s\n", userdata.sysname); printf("Node Name: %s\n", userdata.nodename); printf("Release: %s\n", userdata.release); printf("Version: %s\n", userdata.version); printf("Machine: %s\n", userdata.machine); printf("Domain Name: %s\n\n", userdata.domainname); } else { perror("uname() error"); } } char GenerateMagicSquare(char *sequence){ int square[3][3]; char answer; int size = sqrt(SQUARE_SIZE); for (int x = 0; x < size; x++){ for (int y = 0; y < size; y++){ square[x][y] = (int) (sequence[y + (x * 3)] - '0'); } } int magicNum = square[0][0] + square[0][1] + square[0][2]; int topLeftToBottomRightDiag = 0, topRightToBottomLeftDiag = 0, rows = 0, cols = 0; for (int x = 0; x < size; x++){ topLeftToBottomRightDiag += square[x][x]; topRightToBottomLeftDiag += square[x][(size - 1) - x]; for (int y = 0; y < size; y++){ rows += square[x][y]; cols += square[y][x]; } if (rows != cols){ answer = 'F'; goto EXIT; } rows = 0; cols = 0; } if ((topLeftToBottomRightDiag == topRightToBottomLeftDiag) && (topRightToBottomLeftDiag == magicNum)){ answer = 'T'; } else{ answer = 'F'; } EXIT: return answer; } bool ValidMagicSquare(char *sequence){ bool validSeq = true; int inputSize = strlen(sequence); for (int x = 0; x < inputSize - 1; x++){ if (!isdigit(sequence[x])){ printf("Input Magic Square Contains Non-Numerical Characters, TRY AGAIN\n"); validSeq = false; goto NEXT; } } NEXT: if (inputSize < SQUARE_SIZE){ printf("Input Magic Square Sequence is too Small, TRY AGAIN\n"); validSeq = false; } else if (inputSize > SQUARE_SIZE) { printf("Input Magic Square Sequence is too Big, TRY AGAIN\n"); validSeq = false; } return validSeq; } int main(int argc, char **argv) { char *inputSquare; do{ printf("Enter 9 Digit Sequence: "); scanf("%s", inputSquare); } while(!ValidMagicSquare(inputSquare)); int client[2]; int server[2]; if (pipe(client) < 0){ fprintf(stderr, "Client Pipe Failed -> %s\n", strerror(errno)); } if (pipe(server) < 0){ fprintf(stderr, "Server Pipe Failed -> %s\n", strerror(errno)); } pid_t pid = fork(); if (pid < 0){ fprintf(stderr, "Fork Failed: %s\n", strerror(errno)); exit(0); } if (pid == 0){ close(client[1]); close(server[0]); char userInputSquare[SQUARE_SIZE + 1]; if (read(client[0], &userInputSquare, sizeof(char) * SQUARE_SIZE + 1) < 0){ fprintf(stderr, "Read From Pipe Failed: %s\n", strerror(errno)); } char answer = GenerateMagicSquare(userInputSquare); if (write(server[1], &answer, sizeof(char) * 2) < 0){ fprintf(stderr, "Write to Pipe Failed: %s\n", strerror(errno)); } close(client[0]); close(server[1]); } else{ system("clear"); close(client[0]); close(server[1]); char answer[2]; if (write(client[1], inputSquare, sizeof(char) * SQUARE_SIZE + 1) < 0){ fprintf(stderr, "Write to Client Failed -> %s", strerror(errno)); } if (read(server[0], answer, sizeof(char) * 2) < 0){ fprintf(stderr, "Read From Pipe Failed: %s", strerror(errno)); } wait(NULL); printf("Sequence Tested: %s\nMagic Square Result: %s\n\n", inputSquare, answer); DisplaySystemInfo(); close(server[0]); close(client[1]); } return 0; }
if (gethostname(hostname, 256) == 0){ printf("Host Name: %s\n", hostname); } else { perror("gethostname() error"); }
if_condition
[ { "content": "\tprivate final String cityName;\n", "file_path": "Dijkstra Airport Project/City.java", "rank": 0, "score": 20715.04630860246 }, { "content": "#include <iostream>\n\n#include <vector>\n\n#include \"Part3ThreadedModifier.h\"\n\n#include \"FileModifyException.h\"\n\n#include \"Fi...
C++
soundmaker.cpp
increpare/beatio
68fa8400f4d97d85f1df1b0ffe372c6d9b5dae69
#include "soundmaker.h" extern "C" { #include <sndfile.h> } #include <math.h> #include <iostream> #include <QFileInfo> using namespace std; #ifndef M_PI #define M_PI 3.14159265358979323846264338 #endif #define SAMPLE_RATE 44100 #define AMPLITUDE (0.5 * 0x7F000000) #define LEFT_FREQ (344.0 / SAMPLE_RATE) #define RIGHT_FREQ (466.0 / SAMPLE_RATE) SoundMaker::SoundMaker() { } SoundMaker::~SoundMaker() { } bool SoundMaker::SaveWave(QVector<Note> onsets,const QString& filename) { int temp; int* buffer = this->GenerateWave(onsets,temp); int length = onsets.size()>0 ? ceil(onsets.last().onset)+1 : 0; int sample_count = SAMPLE_RATE*length; SNDFILE *file ; SF_INFO sfinfo ; memset (&sfinfo, 0, sizeof (sfinfo)) ; sfinfo.samplerate = SAMPLE_RATE ; sfinfo.frames = sample_count ; sfinfo.channels = 2 ; sfinfo.format = (SF_FORMAT_WAV | SF_FORMAT_PCM_16); if (! (file = sf_open (filename.toLatin1().data(), SFM_WRITE, &sfinfo))) { cout << "Error : Not able to open output file.\n"; return false ; } ; if (sf_write_int (file, buffer, sfinfo.channels * sample_count) != sfinfo.channels * sample_count) puts (sf_strerror (file)) ; sf_close (file) ; std::cout<<"DELETE BUFFER5"<<std::endl; delete [] buffer; buffer=0; return true; } void SoundMaker::unloadInstrument(int i) { instruments.remove(i); } void SoundMaker::unloadInstruments() { instruments.empty(); } bool SoundMaker::loadInstrument(const QString& samplefilename) { SNDFILE *infile; SF_INFO sfinfo; memset (&sfinfo, 0, sizeof (sfinfo)) ; if (! (infile = sf_open (samplefilename.toLatin1(), SFM_READ, &sfinfo))) { printf ("Error : could not open file : %s\n", samplefilename.toLatin1().data()) ; puts (sf_strerror (NULL)) ; exit (1) ; } if (! sf_format_check (&sfinfo) || !(sfinfo.channels==1||sfinfo.channels==2) || (sfinfo.samplerate!=SAMPLE_RATE)) { sf_close (infile) ; printf ("Invalid encoding\n") ; return false; } QVector<int> sample; int *buf = new int[sfinfo.frames*2]; int num = sf_read_int(infile,buf,sfinfo.frames*sfinfo.channels); if (sfinfo.samplerate==2) { for (int i=0;i<num;i++) { sample.push_back(buf[i]); } } else { for (int i=0;i<num;i++) { sample.push_back(buf[i]); sample.push_back(buf[i]); } } std::cout<<"DELETE BUFFER4"<<std::endl; delete [] buf; buf=0; sf_close (infile); this->instruments.push_back(sample); QFileInfo fileInfo = QFileInfo(samplefilename); this->names.push_back(fileInfo.baseName()); return true; } int* SoundMaker::GenerateWave(QVector<Note> onsets, int& framecount) { if (onsets.size()==0) return false; int length = ceil(onsets.last().onset)+1; int frame_count = SAMPLE_RATE*length; framecount=frame_count; SF_INFO sfinfo ; int k ; int *buffer ; buffer = new int[2 * frame_count]; memset (&sfinfo, 0, sizeof (sfinfo)) ; sfinfo.samplerate = SAMPLE_RATE ; sfinfo.frames = frame_count ; sfinfo.channels = 2 ; sfinfo.format = (SF_FORMAT_WAV | SF_FORMAT_PCM_24); int cur=0; QVector< NoteN > notePointers; for (k = 0 ; k < frame_count ; k++) { for (int i=notePointers.size()-1;i>=0;i--) { NoteN& point = notePointers[i]; point.onset++; if (2*notePointers[i].onset>=instruments[point.instrument].size()-1) { notePointers.remove(i); } } while (cur<onsets.size() && (onsets[cur].onset*SAMPLE_RATE)<k) { if (onsets[cur].instrument>=0) { NoteN newNote = onsets[cur]; newNote.onset=0; notePointers.push_back(newNote); } cur++; } int l=0; int r=0; for (int i=notePointers.size()-1;i>=0;i--) { int oldl=l; l+=instruments[notePointers[i].instrument][2*notePointers[i].onset]; if ((l<0)!=(oldl<0) && ((oldl<0) == (instruments[notePointers[i].instrument][2*notePointers[i].onset]<0))) { if (l!=0 && oldl!=0) { if (oldl>0) l=INT_MAX; else l=INT_MIN; } } int oldr=r; r+=instruments[notePointers[i].instrument][2*notePointers[i].onset+1]; if ((r<0)!=(oldr<0) && ((oldr<0) == (instruments[notePointers[i].instrument][2*notePointers[i].onset+1]<0))) { if (r!=0 && oldr!=0) { if (oldr>0) r=INT_MAX; else r=INT_MIN; } } } buffer [2 * k] = l; buffer [2 * k + 1] = r; } std::cout<<"BUFFER4"<<buffer<<std::endl; return buffer; }
#include "soundmaker.h" extern "C" { #include <sndfile.h> } #include <math.h> #include <iostream> #include <QFileInfo> using namespace std; #ifndef M_PI #define M_PI 3.14159265358979323846264338 #endif #define SAMPLE_RATE 44100 #define AMPLITUDE (0.5 * 0x7F000000) #define LEFT_FREQ (344.0 / SAMPLE_RATE) #define RIGHT_FREQ (466.0 / SAMPLE_RATE) SoundMaker::SoundMaker() { } SoundMaker::~SoundMaker() { } bool SoundMaker::SaveWave(QVector<Note> onsets,const QString& filename) { int temp; int* buffer = this->GenerateWave(onsets,temp); int length = onsets.size()>0 ? ceil(onsets.last().onset)+1 : 0; int sample_count = SAMPLE_RATE*length; SNDFILE *file ; SF_INFO sfinfo ; memset (&sfinfo, 0, sizeof (sfinfo)) ; sfinfo.samplerate = SAMPLE_RATE ; sfinfo.frames = sample_count ; sfinfo.channels = 2 ; sfinfo.format = (SF_FORMAT_WAV | SF_FORMAT_PCM_16); if (! (file = sf_open (filename.toLatin1().data(), SFM_WRITE, &sfinfo))) { cout << "Error : Not able to open output file.\n"; return false ; } ; if (sf_write_int (file, buffer, sfinfo.channels * sample_count) != sfinfo.channels * sample_count) puts (sf_strerror (file)) ; sf_close (file) ; std::cout<<"DELETE BUFFER5"<<std::endl; delete [] buffer; buffer=0; return true; } void SoundMaker::unloadInstrument(int i) { instruments.remove(i); } void SoundMaker::unloadInstruments() { instruments.empty(); } bool SoundMaker::loadInstrument(const QString& samplefilename) { SNDFILE *infile; SF_INFO sfinfo; memset (&sfinfo, 0, sizeof (sfinfo)) ; if (! (infile = sf_open (samplefilename.toLatin1(), SFM_READ, &sfinfo))) { printf ("Error : could not open file : %s\n", samplefilename.toLatin1().data()) ; puts (sf_strerror (NULL)) ; exit (1) ; } if (! sf_format_check (&sfinfo) || !(sfinfo.channels==1||sfinfo.channels==2) || (sfinfo.samplerate!=SAMPLE_RATE)) { sf_close (infile) ; printf ("Invalid encoding\n") ; return false; } QVector<int> sample; int *buf = new int[sfinfo.frames*2]; int num = sf_read_int(infile,buf,sfinfo.frames*sfinfo.channels); if (sfinfo.samplerate==2) { for (int i=0;i<num;i++) { sample.push_back(buf[i]); } } else { for (int i=0;i<num;i++) { sample.push_back(buf[i]); sample.push_back(buf[i]); } } std::cout<<"DELETE BUFFER4"<<std::endl; delete [] buf; buf=0; sf_close (infile); this->instruments.push_back(sample); QFileInfo fileInfo = QFileInfo(samplefilename); this->names.push_back(fileInfo.baseName()); return true; }
int* SoundMaker::GenerateWave(QVector<Note> onsets, int& framecount) { if (onsets.size()==0) return false; int length = ceil(onsets.last().onset)+1; int frame_count = SAMPLE_RATE*length; framecount=frame_count; SF_INFO sfinfo ; int k ; int *buffer ; buffer = new int[2 * frame_count]; memset (&sfinfo, 0, sizeof (sfinfo)) ; sfinfo.samplerate = SAMPLE_RATE ; sfinfo.frames = frame_count ; sfinfo.channels = 2 ; sfinfo.format = (SF_FORMAT_WAV | SF_FORMAT_PCM_24); int cur=0; QVector< NoteN > notePointers; for (k = 0 ; k < frame_count ; k++) { for (int i=notePointers.size()-1;i>=0;i--) { NoteN& point = notePointers[i]; point.onset++; if (2*notePointers[i].onset>=instruments[point.instrument].size()-1) { notePointers.remove(i); } } while (cur<onsets.size() && (onsets[cur].onset*SAMPLE_RATE)<k) { if (onsets[cur].instrument>=0) { NoteN newNote = onsets[cur]; newNote.onset=0; notePointers.push_back(newNote); } cur++; } int l=0; int r=0; for (int i=notePointers.size()-1;i>=0;i--) { int oldl=l; l+=instruments[notePointers[i].instrument][2*notePointers[i].onset]; if ((l<0)!=(oldl<0) && ((oldl<0) == (instruments[notePointers[i].instrument][2*notePointers[i].onset]<0))) { if (l!=0 && oldl!=0) { if (oldl>0) l=INT_MAX; else l=INT_MIN; } } int oldr=r; r+=instruments[notePointers[i].instrument][2*notePointers[i].onset+1]; if ((r<0)!=(oldr<0) && ((oldr<0) == (instruments[notePointers[i].instrument][2*notePointers[i].onset+1]<0))) { if (r!=0 && oldr!=0) { if (oldr>0) r=INT_MAX; else r=INT_MIN; } } } buffer [2 * k] = l; buffer [2 * k + 1] = r; } std::cout<<"BUFFER4"<<buffer<<std::endl; return buffer; }
function_block-full_function
[ { "content": " {\n\n //int value=(int)(32767.0*sin(2.0*M_PI*((double)(i))*(double)(400)/SYSTEM_FREQ));\n\n int value = _buffer[i];\n\n //putShort(start, value&65535);\n\n putShort(start, (value/65536)&65535);\n\n start += 2;\n\n }\n\n\n\n std::cout<<\"DELETE BUFFER2\"...
C++
perf_test/blas/blas1/KokkosBlas_team_dot_perf_test.cpp
NexGenAnalytics/kokkos-kernels
8381db0486674c1be943de23974821ddfb9e6c29
#include <Kokkos_Core.hpp> #include <KokkosBlas1_team_dot.hpp> #include <Kokkos_Random.hpp> struct Params { int use_cuda = 0; int use_openmp = 0; int use_threads = 0; int m = 100000; int repeat = 1; }; void print_options() { std::cerr << "Options:\n" << std::endl; std::cerr << "\tBACKEND: '--threads[numThreads]' | '--openmp [numThreads]' | " "'--cuda [cudaDeviceIndex]'" << std::endl; std::cerr << "\tIf no BACKEND selected, serial is the default." << std::endl; std::cerr << "\t[Optional] --repeat :: how many times to repeat overall " "dot (symbolic + repeated numeric)" << std::endl; } int parse_inputs(Params& params, int argc, char** argv) { for (int i = 1; i < argc; ++i) { if (0 == strcasecmp(argv[i], "--help") || 0 == strcasecmp(argv[i], "-h")) { print_options(); exit(0); } else if (0 == strcasecmp(argv[i], "--threads")) { params.use_threads = atoi(argv[++i]); } else if (0 == strcasecmp(argv[i], "--openmp")) { params.use_openmp = atoi(argv[++i]); } else if (0 == strcasecmp(argv[i], "--cuda")) { params.use_cuda = atoi(argv[++i]) + 1; } else if (0 == strcasecmp(argv[i], "--m")) { params.m = atoi(argv[++i]); } else if (0 == strcasecmp(argv[i], "--repeat")) { params.repeat = atoi(argv[++i]); } else { std::cerr << "Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; print_options(); return 1; } } return 0; } template <class Vector, class ExecSpace> struct teamDotFunctor { static_assert(Kokkos::Impl::is_view<Vector>::value, "Vector is not a " "Kokkos::View."); using Scalar = typename Vector::non_const_value_type; using execution_space = ExecSpace; typedef typename Kokkos::TeamPolicy<execution_space> team_policy; typedef typename team_policy::member_type team_member; Vector x; Vector y; KOKKOS_INLINE_FUNCTION void operator()(const team_member& team) const { KokkosBlas::Experimental::dot(team, x, y); } teamDotFunctor(Vector X_, Vector Y_) { x = X_; y = Y_; } }; template <class ExecSpace> void run(int m, int repeat) { using Scalar = double; using MemSpace = typename ExecSpace::memory_space; using policy = Kokkos::TeamPolicy<ExecSpace>; Kokkos::View<Scalar*, MemSpace> x("X", m); Kokkos::View<Scalar*, MemSpace> y("Y", m); Kokkos::deep_copy(x, 3.0); Kokkos::deep_copy(y, 2.0); std::cout << "Running BLAS Level 1 Kokkos Teams-based implementation DOT " "performance experiment (" << ExecSpace::name() << ")\n"; std::cout << "Each test input vector has a length of " << m << std::endl; teamDotFunctor<Kokkos::View<Scalar*, MemSpace>, ExecSpace> teamDotFunctorWarmUpInstance(x, y); Kokkos::parallel_for("TeamDotUsage -- Warm Up Run", policy(1, Kokkos::AUTO), teamDotFunctorWarmUpInstance); Kokkos::fence(); Kokkos::Timer timer; teamDotFunctor<Kokkos::View<Scalar*, MemSpace>, ExecSpace> teamDotFunctorLiveTestInstance(x, y); Kokkos::parallel_for("TeamDotUsage -- Live Test", policy(1, Kokkos::AUTO), teamDotFunctorLiveTestInstance); ExecSpace().fence(); double total = timer.seconds(); double avg = total / repeat; size_t flopsPerRun = (size_t)2 * m; printf("Avg DOT time: %f s.\n", avg); printf("Avg DOT FLOP/s: %.3e\n", flopsPerRun / avg); } int main(int argc, char** argv) { Params params; if (parse_inputs(params, argc, argv)) { return 1; } const int device_id = params.use_cuda - 1; const int num_threads = std::max(params.use_openmp, params.use_threads); Kokkos::initialize(Kokkos::InitArguments(num_threads, -1, device_id)); bool useThreads = params.use_threads != 0; bool useOMP = params.use_openmp != 0; bool useCUDA = params.use_cuda != 0; bool useSerial = !useThreads && !useOMP && !useCUDA; if (useThreads) { #if defined(KOKKOS_ENABLE_THREADS) run<Kokkos::Threads>(params.m, params.repeat); #else std::cout << "ERROR: PThreads requested, but not available.\n"; return 1; #endif } if (useOMP) { #if defined(KOKKOS_ENABLE_OPENMP) run<Kokkos::OpenMP>(params.m, params.repeat); #else std::cout << "ERROR: OpenMP requested, but not available.\n"; return 1; #endif } if (useCUDA) { #if defined(KOKKOS_ENABLE_CUDA) run<Kokkos::Cuda>(params.m, params.repeat); #else std::cout << "ERROR: CUDA requested, but not available.\n"; return 1; #endif } if (useSerial) { #if defined(KOKKOS_ENABLE_SERIAL) run<Kokkos::Serial>(params.m, params.repeat); #else std::cout << "ERROR: Serial device requested, but not available; here, " "implementation of dot is explicitly parallel.\n"; return 1; #endif } Kokkos::finalize(); return 0; }
#include <Kokkos_Core.hpp> #include <KokkosBlas1_team_dot.hpp> #include <Kokkos_Random.hpp> struct Params { int use_cuda = 0; int use_openmp = 0; int use_threads = 0; int m = 100000; int repeat = 1; }; void print_options() { std::cerr << "Options:\n" << std::endl; std::cerr << "\tBACKEND: '--threads[numThreads]' | '--openmp [numThreads]' | " "'--cuda [cudaDeviceIndex]'" << std::endl; std::cerr << "\tIf no BACKEND selected, serial is the default." << std::endl; std:
eturn 1; #endif } if (useSerial) { #if defined(KOKKOS_ENABLE_SERIAL) run<Kokkos::Serial>(params.m, params.repeat); #else std::cout << "ERROR: Serial device requested, but not available; here, " "implementation of dot is explicitly parallel.\n"; return 1; #endif } Kokkos::finalize(); return 0; }
:cerr << "\t[Optional] --repeat :: how many times to repeat overall " "dot (symbolic + repeated numeric)" << std::endl; } int parse_inputs(Params& params, int argc, char** argv) { for (int i = 1; i < argc; ++i) { if (0 == strcasecmp(argv[i], "--help") || 0 == strcasecmp(argv[i], "-h")) { print_options(); exit(0); } else if (0 == strcasecmp(argv[i], "--threads")) { params.use_threads = atoi(argv[++i]); } else if (0 == strcasecmp(argv[i], "--openmp")) { params.use_openmp = atoi(argv[++i]); } else if (0 == strcasecmp(argv[i], "--cuda")) { params.use_cuda = atoi(argv[++i]) + 1; } else if (0 == strcasecmp(argv[i], "--m")) { params.m = atoi(argv[++i]); } else if (0 == strcasecmp(argv[i], "--repeat")) { params.repeat = atoi(argv[++i]); } else { std::cerr << "Unrecognized command line argument #" << i << ": " << argv[i] << std::endl; print_options(); return 1; } } return 0; } template <class Vector, class ExecSpace> struct teamDotFunctor { static_assert(Kokkos::Impl::is_view<Vector>::value, "Vector is not a " "Kokkos::View."); using Scalar = typename Vector::non_const_value_type; using execution_space = ExecSpace; typedef typename Kokkos::TeamPolicy<execution_space> team_policy; typedef typename team_policy::member_type team_member; Vector x; Vector y; KOKKOS_INLINE_FUNCTION void operator()(const team_member& team) const { KokkosBlas::Experimental::dot(team, x, y); } teamDotFunctor(Vector X_, Vector Y_) { x = X_; y = Y_; } }; template <class ExecSpace> void run(int m, int repeat) { using Scalar = double; using MemSpace = typename ExecSpace::memory_space; using policy = Kokkos::TeamPolicy<ExecSpace>; Kokkos::View<Scalar*, MemSpace> x("X", m); Kokkos::View<Scalar*, MemSpace> y("Y", m); Kokkos::deep_copy(x, 3.0); Kokkos::deep_copy(y, 2.0); std::cout << "Running BLAS Level 1 Kokkos Teams-based implementation DOT " "performance experiment (" << ExecSpace::name() << ")\n"; std::cout << "Each test input vector has a length of " << m << std::endl; teamDotFunctor<Kokkos::View<Scalar*, MemSpace>, ExecSpace> teamDotFunctorWarmUpInstance(x, y); Kokkos::parallel_for("TeamDotUsage -- Warm Up Run", policy(1, Kokkos::AUTO), teamDotFunctorWarmUpInstance); Kokkos::fence(); Kokkos::Timer timer; teamDotFunctor<Kokkos::View<Scalar*, MemSpace>, ExecSpace> teamDotFunctorLiveTestInstance(x, y); Kokkos::parallel_for("TeamDotUsage -- Live Test", policy(1, Kokkos::AUTO), teamDotFunctorLiveTestInstance); ExecSpace().fence(); double total = timer.seconds(); double avg = total / repeat; size_t flopsPerRun = (size_t)2 * m; printf("Avg DOT time: %f s.\n", avg); printf("Avg DOT FLOP/s: %.3e\n", flopsPerRun / avg); } int main(int argc, char** argv) { Params params; if (parse_inputs(params, argc, argv)) { return 1; } const int device_id = params.use_cuda - 1; const int num_threads = std::max(params.use_openmp, params.use_threads); Kokkos::initialize(Kokkos::InitArguments(num_threads, -1, device_id)); bool useThreads = params.use_threads != 0; bool useOMP = params.use_openmp != 0; bool useCUDA = params.use_cuda != 0; bool useSerial = !useThreads && !useOMP && !useCUDA; if (useThreads) { #if defined(KOKKOS_ENABLE_THREADS) run<Kokkos::Threads>(params.m, params.repeat); #else std::cout << "ERROR: PThreads requested, but not available.\n"; return 1; #endif } if (useOMP) { #if defined(KOKKOS_ENABLE_OPENMP) run<Kokkos::OpenMP>(params.m, params.repeat); #else std::cout << "ERROR: OpenMP requested, but not available.\n"; return 1; #endif } if (useCUDA) { #if defined(KOKKOS_ENABLE_CUDA) run<Kokkos::Cuda>(params.m, params.repeat); #else std::cout << "ERROR: CUDA requested, but not available.\n"; r
random
[ { "content": "struct MultiGemm<int,int,int,Kokkos::Cuda,Kokkos::LayoutRight,Kokkos::LayoutRight,Kokkos::LayoutRight,int,2>{\n\n static void GEMM(const char transA, const char transB, int alpha,\n\n Kokkos::View<int**,Kokkos::LayoutRight,Kokkos::Cuda> A, Kokkos::View<int**,Kokkos::LayoutRight,Kok...
C++
tools/clang/lib/Analysis/CallGraph.cpp
nettrino/IntFlow
0400aef5da2c154268d8b020e393c950435395b3
#include "clang/Analysis/CallGraph.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/AST/StmtVisitor.h" #include "llvm/Support/GraphWriter.h" using namespace clang; namespace { class CGBuilder : public StmtVisitor<CGBuilder> { CallGraph *G; CallGraphNode *CallerNode; public: CGBuilder(CallGraph *g, CallGraphNode *N) : G(g), CallerNode(N) {} void VisitStmt(Stmt *S) { VisitChildren(S); } void VisitCallExpr(CallExpr *CE) { if (FunctionDecl *CalleeDecl = CE->getDirectCallee()) if (G->includeInGraph(CalleeDecl)) { CallGraphNode *CalleeNode = G->getOrInsertNode(CalleeDecl); CallerNode->addCallee(CalleeNode, G); } } void VisitChildren(Stmt *S) { for (Stmt::child_range I = S->children(); I; ++I) if (*I) static_cast<CGBuilder*>(this)->Visit(*I); } }; } CallGraph::CallGraph() { Root = getOrInsertNode(0); } CallGraph::~CallGraph() { if (!FunctionMap.empty()) { for (FunctionMapTy::iterator I = FunctionMap.begin(), E = FunctionMap.end(); I != E; ++I) delete I->second; FunctionMap.clear(); } } bool CallGraph::includeInGraph(const Decl *D) { if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { if (!FD->isThisDeclarationADefinition() || FD->isDependentContext()) return false; IdentifierInfo *II = FD->getIdentifier(); if (II && II->getName().startswith("__inline")) return false; } if (const ObjCMethodDecl *ID = dyn_cast<ObjCMethodDecl>(D)) { if (!ID->isThisDeclarationADefinition()) return false; } return true; } void CallGraph::addNodeForDecl(Decl* D, bool IsGlobal) { assert(D); if (FunctionMap.find(D) != FunctionMap.end()) return; CallGraphNode *Node = getOrInsertNode(D); if (IsGlobal) Root->addCallee(Node, this); CGBuilder builder(this, Node); if (Stmt *Body = D->getBody()) builder.Visit(Body); } CallGraphNode *CallGraph::getNode(const Decl *F) const { FunctionMapTy::const_iterator I = FunctionMap.find(F); if (I == FunctionMap.end()) return 0; return I->second; } CallGraphNode *CallGraph::getOrInsertNode(Decl *F) { CallGraphNode *&Node = FunctionMap[F]; if (Node) return Node; Node = new CallGraphNode(F); if (F != 0) ParentlessNodes.insert(Node); return Node; } void CallGraph::print(raw_ostream &OS) const { OS << " --- Call graph Dump --- \n"; for (const_iterator I = begin(), E = end(); I != E; ++I) { OS << " Function: "; if (I->second == Root) OS << "< root >"; else I->second->print(OS); OS << " calls: "; for (CallGraphNode::iterator CI = I->second->begin(), CE = I->second->end(); CI != CE; ++CI) { assert(*CI != Root && "No one can call the root node."); (*CI)->print(OS); OS << " "; } OS << '\n'; } OS.flush(); } void CallGraph::dump() const { print(llvm::errs()); } void CallGraph::viewGraph() const { llvm::ViewGraph(this, "CallGraph"); } StringRef CallGraphNode::getName() const { if (const FunctionDecl *D = dyn_cast_or_null<FunctionDecl>(FD)) if (const IdentifierInfo *II = D->getIdentifier()) return II->getName(); return "< >"; } void CallGraphNode::print(raw_ostream &os) const { os << getName(); } void CallGraphNode::dump() const { print(llvm::errs()); } namespace llvm { template <> struct DOTGraphTraits<const CallGraph*> : public DefaultDOTGraphTraits { DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {} static std::string getNodeLabel(const CallGraphNode *Node, const CallGraph *CG) { if (CG->getRoot() == Node) { return "< root >"; } return Node->getName(); } }; }
#include "clang/Analysis/CallGraph.h" #include "clang/AST/ASTContext.h" #include "clang/AST/Decl.h" #include "clang/AST/StmtVisitor.h" #include "llvm/Support/GraphWriter.h" using namespace clang; namespace { class CGBuilder : public StmtVisitor<CGBuilder> { CallGraph *G; CallGraphNode *CallerNode; public: CGBuilder(CallGraph *g, CallGraphNode *N) : G(g), CallerNode(N) {} void VisitStmt(Stmt *S) { VisitChildren(S); } void VisitCallExpr(CallExpr *CE) { if (FunctionDecl *CalleeDecl = CE->getDirectCallee()) if (G->includeInGraph(CalleeDecl)) { CallGraphNode *CalleeNode = G->getOrInsertNode(CalleeDecl); CallerNode->addCallee(CalleeNode, G); } } void VisitChildren(Stmt *S) { for (Stmt::child_range I = S->children(); I; ++I) if (*I) static_cast<CGBuilder*>(this)->Visit(*I); } }; } CallGraph::CallGraph() { Root = getOrInsertNode(0); } CallGraph::~CallGraph() { if (!FunctionMap.empty()) { for (FunctionMapTy::iterator I = FunctionMap.begin(), E = FunctionMap.end(); I != E; ++I) delete I->second; FunctionMap.clear(); } } bool CallGraph::includeInGraph(const Decl *D) { if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { if (!FD->isThisDeclarationADefinition() || FD->isDependentContext()) return false; IdentifierInfo *II = FD->getIdentifier(); if (II && II->getName().startswith("__inline")) return false; } if (const ObjCMethodDecl *ID = dyn_cast<ObjCMethodDecl>(D)) { if (!ID->isThisDeclarationADefinition()) return false; } return true; } void CallGraph::addNodeForDecl(Decl* D, bool IsGlobal) { assert(D); if (FunctionMap.find(D) != FunctionMap.end()) return; CallGraphNode *Node = getOrInsertNode(D); if (IsGlobal) Root->addCallee(Node, this); CGBuilder builder(this, Node); if (Stmt *Body = D->getBody()) builder.Visit(Body); } CallGraphNode *CallGraph::getNode(const Decl *F) const { FunctionMapTy::const_iterator I = FunctionMap.find(F); if (I == FunctionMap.end()) return 0; return I->second; } CallGraphNode *CallGraph::getOrInsertNode(Decl *F) { CallGraphNode *&Node = FunctionMap[F]; if (Node) return Node; Node = new CallGraphNode(F); if (F != 0) ParentlessNodes.insert(Node); return Node; } void CallGraph::print(raw_ostream &OS) const { OS << " --- Call graph Dump --- \n"; for (const_iterator I = begin(), E = end(); I != E; ++I) { OS << " Function: "; if (I->second == Root) OS << "< root >"; else I->second->print(OS); OS << " calls: "; for (CallGraphNode::iterator CI = I->second->begin(), CE = I->second->end(); CI != CE; ++CI) { assert(*CI != Root && "No one can call the root node."); (*CI)->print(OS); OS << " "; } OS << '\n'; } OS.flush(); } void CallGraph::dump() const { print(llvm::errs()); } void CallGraph::viewGraph() const { llvm::ViewGraph(this, "CallGraph"); } StringRef CallGraphNode::getName() const { if (const FunctionDecl *D = dyn_cast_or_null<FunctionDecl>(FD)) if (const IdentifierInfo *II = D->getIdentifier()) return II->getName(); return "< >"; } void CallGraphNode::print(raw_ostream &os) const { os << getName(); } void CallGraphNode::dump() const { print(llvm::errs()); } namespace llvm { template <> struct DOTGraphTraits<const CallGraph*> : public DefaultDOTGraphTraits { DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
}; }
static std::string getNodeLabel(const CallGraphNode *Node, const CallGraph *CG) { if (CG->getRoot() == Node) { return "< root >"; } return Node->getName(); }
function_block-function_prefix_line
[]
C++
source/code/iceshard/iceshard/private/world/iceshard_world.cxx
iceshard-engine/engine
4f2092af8d2d389ea72addc729d0c2c8d944c95c
#include "iceshard_world.hxx" #include <ice/world/world_trait.hxx> #include <ice/engine_runner.hxx> #include <ice/engine_frame.hxx> #include <ice/engine_shards.hxx> #include <ice/pod/hash.hxx> #include <ice/assert.hxx> #include "iceshard_world_portal.hxx" namespace ice { IceshardWorld::IceshardWorld( ice::Allocator& alloc, ice::ecs::EntityStorage* entity_storage ) noexcept : _allocator{ alloc } , _entity_storage{ entity_storage } , _state{ WorldState::Idle } , _traits{ _allocator } , _portals{ _allocator } { } IceshardWorld::~IceshardWorld() noexcept { ICE_ASSERT( ice::pod::array::empty(_portals._data), "Not all traits where removed from this World before destruction!" ); } auto IceshardWorld::allocator() noexcept -> ice::Allocator& { return _allocator; } auto IceshardWorld::entity_storage() noexcept -> ice::ecs::EntityStorage& { return *_entity_storage; } auto IceshardWorld::state_hint() const noexcept -> ice::WorldState { return _state; } void IceshardWorld::set_state( ice::WorldState state ) noexcept { _state = state; } void IceshardWorld::add_trait( ice::StringID_Arg name, ice::WorldTrait* trait ) noexcept { ice::u64 const name_hash = ice::hash(name); ICE_ASSERT( ice::pod::hash::has(_portals, name_hash) == false, "World already contains a trait of name {}", ice::stringid_hint(name) ); ice::pod::array::push_back( _traits, trait ); ice::pod::hash::set( _portals, name_hash, _allocator.make<IceshardWorldPortal>( _allocator, *this, trait, *_entity_storage ) ); } void IceshardWorld::remove_trait( ice::StringID_Arg name ) noexcept { ice::u64 const name_hash = ice::hash(name); ICE_ASSERT( ice::pod::hash::has(_portals, name_hash) == true, "World does not contain a trait with name {}", ice::stringid_hint(name) ); ice::IceshardWorldPortal* const portal = ice::pod::hash::get(_portals, name_hash, nullptr); auto* it = ice::pod::array::begin(_traits); auto* const end = ice::pod::array::end(_traits); while (it != end && (*it) != portal->trait()) { it += 1; } ICE_ASSERT(it != end, "Couldnt find location of the world trait to be removed!"); *it = ice::pod::array::back(_traits); ice::pod::array::pop_back(_traits); ice::pod::hash::remove( _portals, ice::hash(name_hash) ); _allocator.destroy(portal); } void IceshardWorld::activate( ice::Engine& engine, ice::EngineRunner& runner ) noexcept { for (auto& entry : _portals) { entry.value->trait()->on_activate( engine, runner, *entry.value ); } } void IceshardWorld::deactivate( ice::Engine& engine, ice::EngineRunner& runner ) noexcept { for (auto& entry : _portals) { entry.value->trait()->on_deactivate( engine, runner, *entry.value ); } } void IceshardWorld::update( ice::EngineRunner& runner ) noexcept { ice::EngineFrame& current_frame = runner.current_frame(); _entity_storage->execute_operations( runner.previous_frame().entity_operations(), current_frame.shards() ); for (auto& entry : _portals) { entry.value->remove_finished_tasks(); entry.value->trait()->on_update( runner.current_frame(), runner, *entry.value ); } } auto IceshardWorld::traits() noexcept -> ice::pod::Array<ice::WorldTrait*>& { return _traits; } }
#include "iceshard_world.hxx" #include <ice/world/world_trait.hxx> #include <ice/engine_runner.hxx> #include <ice/engine_frame.hxx> #include <ice/engine_shards.hxx> #include <ice/pod/hash.hxx> #include <ice/assert.hxx> #include "iceshard_world_portal.hxx" namespace ice { IceshardWorld::IceshardWorld( ice::Allocator& alloc, ice::ecs::EntityStorage* entity_storage ) noexcept : _allocator{ alloc } , _entity_storage{ entity_storage } , _state{ WorldState::Idle } , _traits{ _allocator } , _portals{ _allocator } { } IceshardWorld::~IceshardWorld() noexcept { ICE_ASSERT( ice::pod::array::empty(_portals._data), "Not all traits where removed from this World before destruction!" ); } auto IceshardWorld::allocator() noexcept -> ice::Allocator& { return _allocator; } auto IceshardWorld::entity_storage() noexcept -> ice::ecs::EntityStorage& { return *_entity_storage; } auto IceshardWorld::state_hint() const noexcept -> ice::WorldState { return _state; } void IceshardWorld::set_state( ice::WorldState state ) noexcept { _state = state; } void IceshardWorld::add_trait( ice::StringID_Arg name, ice::WorldTrait* trait ) noexcept { ice::u64 const name_hash = ice::hash(name); ICE_ASSERT( ice::pod::hash::has(_portals, name_hash) == false, "World already contains a trait of name {}", ice::stringid_hint(name) ); ice::pod::array::push_back( _traits, trait ); ice::pod::hash::set( _portals, name_hash, _allocator.make<IceshardWorldPortal>( _allocator, *this, trait, *_entity_storage ) ); } void IceshardWorld::remove_trait( ice::StringID_Arg name ) noexcept { ice::u64 const name_hash = ice::hash(name); ICE_ASSERT( ice::pod::hash::has(_portals, name_hash) == true, "World does not contain a trait with name {}", ice::stringid_hint(name) ); ice::IceshardWorldPortal* const portal = ice::pod::hash::get(_portals, name_hash, nullptr); auto* it = ice::pod::array::begin(_traits); auto* const end = ice::pod::array::end(_traits); while (it != end && (*it) != portal->trait()) { it += 1; } ICE_ASSERT(it != end, "Couldnt find location of the world trait to be removed!"); *it = ice::pod::array::back(_traits); ice::pod::array::pop_back(_traits); ice::pod::hash::remove( _portals, ice::hash(name_hash) ); _allocator.destroy(portal); } void IceshardWorld::activate( ice::Engine& engine, ice::EngineRunner& runner ) noexcept { for (auto& entry : _portals) { entry.value->trait()->on_activate( engine, runner, *entry.value ); } } void IceshardWorld::deactivate( ice::Engine& engine, ice::EngineRunner& runner ) noexcept { for (auto& entry : _portals) { entry.value->trait()->on_deactivate( engine, runner, *entry.value ); } } void IceshardWorld::update( ice::EngineRunner& runner ) noexcept { ice::EngineFrame& current_frame = runner.current_frame(); _entity_storage->execute_operations( runner.previous_frame().entity_operations(), current_frame.shards() ); for (auto& entry : _portals) { entry.value->remove_finished_tasks();
; } } auto IceshardWorld::traits() noexcept -> ice::pod::Array<ice::WorldTrait*>& { return _traits; } }
entry.value->trait()->on_update( runner.current_frame(), runner, *entry.value )
call_expression
[ { "content": "inline void* b2Alloc(void* alloc, ice::i32 size)\n\n{\n\n return reinterpret_cast<ice::Allocator*>(alloc)->allocate(static_cast<ice::u32>(size));\n", "file_path": "source/code/framework/framework_base/private/traits/physics/b2_user_settings.h", "rank": 0, "score": 39755.43515219723 ...
C++
Src/main.cpp
KuhakuPixel/TempestPixyEngine
929d2952e2b4a83a85287c3030accade5ae449e2
#include <string.h> #include <iostream> #include <string> #include "board.h" #include "CharHelper.h" #include "math.h" #include "chessLib.h" #include "evaluation.h" #include "search.h" #include "stringHelper.h" void StartEngineUci() { std::string startFenPosition = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; std::string command = ""; #pragma region Initializing Engine parameters Board board = Board(); board.LoadFromFen(startFenPosition); Evaluation evaluation = Evaluation(); evaluation.InitializeKnightPeriphery0(-0.51); evaluation.InitializeKnightPeriphery1(-0.18); evaluation.InitializeKnightPeriphery2(+0.54); evaluation.InitializeKnightPeriphery3(+0.1); #pragma endregion while (true) { std::getline(std::cin, command); if (command == "isready") printf("readyok\n"); else if (command.find("position") == 0) { if (command.find("position fen") == 0) { std::string newFenPos = command.substr(strlen("position fen") + 1); board.LoadFromFen(newFenPos); } else if (command.find("position startpos moves") == 0) { board = Board(); board.LoadFromFen(startFenPosition); std::string movesStr = command.substr(strlen("position startpos moves") + 1); std::vector<std::string> moves = StringHelper::SplitString(movesStr, " "); for (int i = 0; i < moves.size(); i++) board.Move(moves.at(i)); } } else if (command.find("go") == 0) { std::string bestMove = ""; Search::SearchPosition(board, evaluation, 0, 4, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &bestMove); printf("bestmove %s\n", bestMove.c_str()); } else if (command == "quit") exit(0); } } void PlayAgainstSelf() { Board board = Board(); board.LoadFromFen("rnbqkb1r/pppp1ppp/5n2/4p3/4PP2/2N5/PPPP2PP/R1BQKBNR b KQkq - 0 3"); Evaluation evaluation = Evaluation(); evaluation.InitializeKnightPeriphery0(-0.51); evaluation.InitializeKnightPeriphery1(-0.18); evaluation.InitializeKnightPeriphery2(+0.54); evaluation.InitializeKnightPeriphery3(+0.1); while (true) { std::string colorToMove = board.GetCurrentTurnStr(); std::string bestMove = ""; printf("Side to move %s \n", colorToMove.c_str()); printf("last move is : %s\n", bestMove.c_str()); board.DisplayBoard('w'); Search::SearchPosition(board, evaluation, 0, 4, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &bestMove); board.Move(bestMove); system("cls"); } } int main(int argc, char *argv[]) { printf("Tempest Pixy engine\n"); while (true) { std::string command = ""; std::cin >> command; if (command == "uci") { printf("id name Tempest-Pixy-Engine 1.0.0\n"); printf("id author Kuhaku Pixel\n"); printf("uciok\n"); StartEngineUci(); } else if (command == "isready") { printf("readyok\n"); } else if (command == "quit") exit(0); } return 0; }
#include <string.h> #include <iostream> #include <string> #include "board.h" #include "CharHelper.h" #include "math.h" #include "chessLib.h" #include "evaluation.h" #include "search.h" #include "stringHelper.h" void StartEngineUci() { std::string startFenPosition = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; std::string command = ""; #pragma region Initializing Engine parameters Board board = Board(); board.LoadFromFen(startFenPosition); Evaluation evaluation = Evaluation(); evaluation.InitializeKnightPeriphery0(-0.51); evaluation.InitializeKnightPeriphery1(-0.18); evaluation.InitializeKnightPeriphery2(+0.54); evaluation.InitializeKnightPeriphery3(+0.1); #pragma endregion while (true) { std::getline(std::cin, command); if (command == "isready") printf("readyok\n"); else if (command.find("position") == 0) { if (command.find("position fen") == 0) { std::string newFenPos = command.substr(strlen("position fen") + 1); board.LoadFromFen(newFenPos); } else if (command.find("position startpos moves") == 0) { board = Board(); board.LoadFromFen(startFenPosition); std::string movesStr = command.substr(strlen("position startpos moves") + 1); std::vector<std::string> moves = StringHelper::SplitString(movesStr, " "); for (int i = 0; i < moves.size(); i++) board.Move(moves.at(i)); } } else if (command.find("go") == 0) { std::string bestMove = ""; Search::SearchPosition(board, evaluation, 0, 4, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &bestMove); printf("bestmove %s\n", bestMove.c_str()); } else if (command == "quit") exit(0); } } void PlayAgainstSelf() { Board board = Board(); board.LoadFromFen("rnbqkb1r/pppp1ppp/5n2/4p3/4PP2/2N5/PPPP2PP/R1BQKBNR b KQkq - 0 3"); Evaluation evaluation = Evaluation(); evaluation.InitializeKnightPeriphery0(-0.5
int main(int argc, char *argv[]) { printf("Tempest Pixy engine\n"); while (true) { std::string command = ""; std::cin >> command; if (command == "uci") { printf("id name Tempest-Pixy-Engine 1.0.0\n"); printf("id author Kuhaku Pixel\n"); printf("uciok\n"); StartEngineUci(); } else if (command == "isready") { printf("readyok\n"); } else if (command == "quit") exit(0); } return 0; }
1); evaluation.InitializeKnightPeriphery1(-0.18); evaluation.InitializeKnightPeriphery2(+0.54); evaluation.InitializeKnightPeriphery3(+0.1); while (true) { std::string colorToMove = board.GetCurrentTurnStr(); std::string bestMove = ""; printf("Side to move %s \n", colorToMove.c_str()); printf("last move is : %s\n", bestMove.c_str()); board.DisplayBoard('w'); Search::SearchPosition(board, evaluation, 0, 4, -std::numeric_limits<double>::infinity(), std::numeric_limits<double>::infinity(), &bestMove); board.Move(bestMove); system("cls"); } }
function_block-function_prefixed
[ { "content": "#pragma once\n\n#include <string>\n\n#include <map>\n\n#include \"CharHelper.h\"\n\n#include <vector>\n\n#include \"chessLib.h\"\n\n#include \"square.h\"\n\nclass Board\n\n{\n\nprivate:\n\n std::vector<MoveFlag> blackCastlingRights = {MoveFlag::shortCastle, MoveFlag::longCastle};\n\n std::ve...
C++
RedeNeural.cpp
AndreSFND/evolutive-agario
cb974d89d413e5db56fda06d6eb18a43aecf1658
#include <iostream> #include <vector> #include <list> #include <cstdlib> #include <math.h> #include <time.h> #include <stdlib.h> #include <stdio.h> #include "RedeNeural.h" using namespace std; RedeNeural::RedeNeural(double _input[], double _biasNeuron, double _biasOutput) { for(int i = 0; i < N_INPUTS; i++) { input[i] = _input[i]; } biasNeuron = _biasNeuron; biasOutput = _biasOutput; populateAxons(); } double* RedeNeural::getInput() { return input; } double* RedeNeural::getOutput() { return output; } RedeNeural::structAxons RedeNeural::getAxons() { return axons; } double* RedeNeural::getNeuron() { return neuron; } double RedeNeural::getBiasNeuron() { return biasNeuron; } double RedeNeural::getBiasOutput() { return biasOutput; } void RedeNeural::setInput(double _input[]) { for(int i = 0; i < N_INPUTS; i++) { input[i] = _input[i]; } } void RedeNeural::setOutput(double _output[]) { for(int i = 0; i < N_OUTPUTS; i++) { output[i] = _output[i]; } } void RedeNeural::setAxonsIn(double _axonsIn[][N_NEURONS]) { for(int i = 0; i < N_INPUTS; i++) { for(int j = 0; j < N_NEURONS; j++) { axons.axonsIn[i][j] = _axonsIn[i][j]; } } } void RedeNeural::setAxonsOut(double _axonsOut[][N_OUTPUTS]) { for(int i = 0; i < N_NEURONS; i++) { for(int j = 0; j < N_OUTPUTS; j++) { axons.axonsOut[i][j] = _axonsOut[i][j]; } } } void RedeNeural::setNeuron(double _neuron[]) { for(int i = 0; i < N_NEURONS; i++) { neuron[i] = _neuron[i]; } } void RedeNeural::setBiasNeuron(double _biasNeuron) { biasNeuron = _biasNeuron; } void RedeNeural::setBiasOutput(double _biasOutput) { biasOutput = _biasOutput; } void RedeNeural::populateAxons() { for(int i = 0; i < N_INPUTS; i++) { for(int j = 0; j < N_NEURONS; j++) { axons.axonsIn[i][j] = ( ((double) rand() / (double) RAND_MAX) * (MAX_AXON - MIN_AXON) ) + MIN_AXON ; } } for(int i = 0; i < N_NEURONS; i++) { for(int j = 0; j < N_OUTPUTS; j++) { axons.axonsOut[i][j] = ( ((double) rand() / (double) RAND_MAX) * (MAX_AXON - MIN_AXON) ) + MIN_AXON ; } } } double RedeNeural::sigmoid(double x) { return 1 / (1 + exp(-x)); } void RedeNeural::activatingFunction(double source[], int size) { for(int i = 0; i < size; i++) { source[i] = sigmoid(source[i]); } } double RedeNeural::feedForward() { for(int i = 0; i < N_NEURONS; i++) { neuron[i] = 0; } for(int i = 0; i < N_NEURONS; i++) { for(int j = 0; j < N_INPUTS; j++) { neuron[i] += input[j] * axons.axonsIn[j][i]; } neuron[i] += biasNeuron; } activatingFunction(neuron, N_NEURONS); for(int i = 0; i < N_OUTPUTS; i++) { for(int j = 0; j < N_NEURONS; j++) { output[i] += neuron[j] * axons.axonsOut[j][i]; } output[i] += biasOutput; } activatingFunction(output, N_OUTPUTS); return 0; } void RedeNeural::printExample() { double _inputs[] = {1, 2}; double _biasNeuron = 0; double _biasOutput = 0; RedeNeural n(_inputs, _biasNeuron, _biasOutput); n.feedForward(); printf("\n\n\tRESUMINDO\n\n"); for(int i = 0; i < N_INPUTS; i++) printf("Input[%d]: %.2f\n", i, n.getInput()[i]); printf("----\n"); for(int i = 0; i < N_INPUTS; i++) for(int j = 0; j < N_NEURONS; j++) printf("AxonIn[%d][%d]: %.2f\n", i, j, n.getAxons().axonsIn[i][j]); printf("----\n"); for(int i = 0; i < N_NEURONS; i++) printf("Neuron[%d]: %.2f\n", i, n.getNeuron()[i]); printf("----\n"); printf("Bias Neuronio (adicionado no neuronio antes da sigmoid): %.2f\n", n.getBiasNeuron()); printf("----\n"); for(int i = 0; i < N_NEURONS; i++) for(int j = 0; j < N_OUTPUTS; j++) printf("AxonOut[%d][%d]: %.2f\n", i, j, n.getAxons().axonsOut[i][j]); printf("----\n"); for(int i = 0; i < N_OUTPUTS; i++) printf("Output[%d]: %.2f\n", i, n.getOutput()[i]); printf("----\n"); printf("Bias Output (adicionado no output antes da sigmoid): %.2f\n", n.getBiasOutput()); printf("----\n"); }
#include <iostream> #include <vector> #include <list> #include <cstdlib> #include <math.h> #include <time.h> #include <stdlib.h> #include <stdio.h> #include "RedeNeural.h" using namespace std; RedeNeural::RedeNeural(double _input[], double _biasNeuron, double _biasOutput) { for(int i = 0; i < N_INPUTS; i++) { input[i] = _input[i]; } biasNeuron = _biasNeuron; biasOutput = _biasOutput; populateAxons(); } double* RedeNeural::getInput() { return input; } double* RedeNeural::getOutput() { return output; } RedeNeural::structAxons RedeNeural::getAxons() { return axons; } double* RedeNeural::getNeuron() { return neuron; } double RedeNeural::getBiasNeuron() { return biasNeuron; } double RedeNeural::getBiasOutput() { return biasOutput; } void RedeNeural::setInput(double _input[]) { for(int i = 0; i < N_INPUTS; i++) { input[i] = _input[i]; } } void RedeNeural::setOutput(double _output[]) { for(int i = 0; i < N_OUTPUTS; i++) { output[i] = _output[i]; } }
void RedeNeural::setAxonsOut(double _axonsOut[][N_OUTPUTS]) { for(int i = 0; i < N_NEURONS; i++) { for(int j = 0; j < N_OUTPUTS; j++) { axons.axonsOut[i][j] = _axonsOut[i][j]; } } } void RedeNeural::setNeuron(double _neuron[]) { for(int i = 0; i < N_NEURONS; i++) { neuron[i] = _neuron[i]; } } void RedeNeural::setBiasNeuron(double _biasNeuron) { biasNeuron = _biasNeuron; } void RedeNeural::setBiasOutput(double _biasOutput) { biasOutput = _biasOutput; } void RedeNeural::populateAxons() { for(int i = 0; i < N_INPUTS; i++) { for(int j = 0; j < N_NEURONS; j++) { axons.axonsIn[i][j] = ( ((double) rand() / (double) RAND_MAX) * (MAX_AXON - MIN_AXON) ) + MIN_AXON ; } } for(int i = 0; i < N_NEURONS; i++) { for(int j = 0; j < N_OUTPUTS; j++) { axons.axonsOut[i][j] = ( ((double) rand() / (double) RAND_MAX) * (MAX_AXON - MIN_AXON) ) + MIN_AXON ; } } } double RedeNeural::sigmoid(double x) { return 1 / (1 + exp(-x)); } void RedeNeural::activatingFunction(double source[], int size) { for(int i = 0; i < size; i++) { source[i] = sigmoid(source[i]); } } double RedeNeural::feedForward() { for(int i = 0; i < N_NEURONS; i++) { neuron[i] = 0; } for(int i = 0; i < N_NEURONS; i++) { for(int j = 0; j < N_INPUTS; j++) { neuron[i] += input[j] * axons.axonsIn[j][i]; } neuron[i] += biasNeuron; } activatingFunction(neuron, N_NEURONS); for(int i = 0; i < N_OUTPUTS; i++) { for(int j = 0; j < N_NEURONS; j++) { output[i] += neuron[j] * axons.axonsOut[j][i]; } output[i] += biasOutput; } activatingFunction(output, N_OUTPUTS); return 0; } void RedeNeural::printExample() { double _inputs[] = {1, 2}; double _biasNeuron = 0; double _biasOutput = 0; RedeNeural n(_inputs, _biasNeuron, _biasOutput); n.feedForward(); printf("\n\n\tRESUMINDO\n\n"); for(int i = 0; i < N_INPUTS; i++) printf("Input[%d]: %.2f\n", i, n.getInput()[i]); printf("----\n"); for(int i = 0; i < N_INPUTS; i++) for(int j = 0; j < N_NEURONS; j++) printf("AxonIn[%d][%d]: %.2f\n", i, j, n.getAxons().axonsIn[i][j]); printf("----\n"); for(int i = 0; i < N_NEURONS; i++) printf("Neuron[%d]: %.2f\n", i, n.getNeuron()[i]); printf("----\n"); printf("Bias Neuronio (adicionado no neuronio antes da sigmoid): %.2f\n", n.getBiasNeuron()); printf("----\n"); for(int i = 0; i < N_NEURONS; i++) for(int j = 0; j < N_OUTPUTS; j++) printf("AxonOut[%d][%d]: %.2f\n", i, j, n.getAxons().axonsOut[i][j]); printf("----\n"); for(int i = 0; i < N_OUTPUTS; i++) printf("Output[%d]: %.2f\n", i, n.getOutput()[i]); printf("----\n"); printf("Bias Output (adicionado no output antes da sigmoid): %.2f\n", n.getBiasOutput()); printf("----\n"); }
void RedeNeural::setAxonsIn(double _axonsIn[][N_NEURONS]) { for(int i = 0; i < N_INPUTS; i++) { for(int j = 0; j < N_NEURONS; j++) { axons.axonsIn[i][j] = _axonsIn[i][j]; } } }
function_block-full_function
[ { "content": "// Leonardo Antonetti da Motta - ICMC USP 11275338\n\n\n\n#include <iostream> \n\n#include <vector>\n\n#include <list>\n\n#include <cstdlib>\n\n#include <math.h>\n\n#include <time.h>\n\n#include <stdlib.h>\n\n#include <stdio.h>\n\n\n\nusing namespace std;\n\n\n\n#define MIN_AXON -1\n\n#define MAX_...
C++
network/gameserver/proto.hpp
hbccdf/network-core
37cbf03829bffd9c0903a1e755ce1f96f46e3dfa
#pragma once #include "network/net/tcp_connect.hpp" #include "msg_pack.hpp" namespace cytx { namespace gameserver { namespace detail { using namespace cytx; using namespace cytx::gameserver; class Proto; class game_server; using game_server_t = game_server; using msg_t = net::server_msg<net::msg_body>; using header_t = typename msg_t::header_t; using connection_t = net::tcp_connection<msg_t>; using connection_ptr = std::shared_ptr<connection_t>; using context_t = typename connection_t::context_t; using msg_ptr = typename connection_t::msg_ptr; using proto_t = Proto; using proto_ptr_t = std::shared_ptr<proto_t>; using proto_map_t = std::map<uint32_t, proto_ptr_t>; template <typename T> struct has_ctx_process_func { private: template <typename P, typename = decltype(std::declval<P>().process(*(msg_ptr)nullptr, *(connection_ptr*)nullptr, *(game_server_t*)nullptr, *(context_t*)nullptr))> static std::true_type test(int); template <typename P> static std::false_type test(...); using result_type = decltype(test<T>(0)); public: static constexpr bool value = result_type::value; }; template<typename T> constexpr bool has_ctx_process_func_v = has_ctx_process_func<T>::value; class Proto : public std::enable_shared_from_this<Proto>, public custom_msg { public: Proto() : protocol_id_(0) , has_ctx_process_(false) {} Proto(const Proto& rhs) : protocol_id_(rhs.protocol_id_) , has_ctx_process_(rhs.has_ctx_process_) { } uint32_t get_protocol_id() const { return protocol_id_; } void set_has_ctx_process(bool has_ctx_process) { has_ctx_process_ = has_ctx_process; } public: virtual proto_ptr_t clone() { return nullptr; } virtual void unpack(msg_ptr& msgp) = 0; void do_process(msg_ptr& msgp, connection_ptr& conn_ptr, game_server_t& server) { if (!has_ctx_process_) { process(msgp, conn_ptr, server); } else { auto& ios = net::get_current_ios(); boost::asio::spawn(ios, [&] (context_t ctx) { this->process(msgp, conn_ptr, server, ctx); }); } } private: virtual void process(msg_ptr& msgp, connection_ptr& conn_ptr, game_server_t& server) { } virtual void process(msg_ptr& msgp, connection_ptr& conn_ptr, game_server_t& server, context_t ctx) { } public: static proto_map_t& GetMap() { static proto_map_t protocols; return protocols; } static proto_ptr_t GetProto(uint32_t protocol_id) { auto& proto_map = GetMap(); auto it = proto_map.find(protocol_id); if (it != proto_map.end()) { return it->second; } return nullptr; } static proto_ptr_t Decode(msg_ptr& msgp) { uint32_t protocol_id = msgp->header().protocol_id; proto_ptr_t proto = Create(protocol_id); if (proto) { proto->unpack(msgp); } return proto; } static proto_ptr_t Create(uint32_t protocol_id) { proto_ptr_t proto = GetProto(protocol_id); return proto ? proto->clone() : nullptr; } static void RegisterProto(proto_ptr_t proto) { uint32_t proto_id = proto->get_protocol_id(); if (!GetProto(proto_id)) { auto& proto_map = GetMap(); proto_map.emplace(proto_id, proto); } } protected: Proto(uint32_t id) : protocol_id_(id) , has_ctx_process_(false) {} uint32_t protocol_id_; bool has_ctx_process_; }; template<typename T> auto make_proto_ptr(uint32_t proto_id) { bool has_ctx_process = has_ctx_process_func_v<T>; std::shared_ptr<T> ptr = std::make_shared<T>(); ptr->set_has_ctx_process(has_ctx_process); proto_t::RegisterProto(ptr); return ptr; } } using Proto = detail::Proto; using proto_t = Proto; using proto_ptr_t = std::shared_ptr<proto_t>; using msg_t = net::server_msg<net::msg_body>; using header_t = typename msg_t::header_t; using connection_t = net::tcp_connection<msg_t>; using context_t = typename connection_t::context_t; using connection_ptr = std::shared_ptr<connection_t>; using msg_ptr = typename connection_t::msg_ptr; } } #define REGISTER_PROTOCOL(type) \ namespace MACRO_CONCAT(___reg_proto_helper_value___ ## type, __LINE__) \ { \ static auto type ## _ptr = cytx::gameserver::detail::make_proto_ptr<type>(type::ProtoId()); \ }
#pragma once #include "network/net/tcp_connect.hpp" #include "msg_pack.hpp" namespace cytx { namespace gameserver { namespace detail { using namespace cytx; using namespace cytx::gameserver; class Proto; class game_server; using game_server_t = game_server; using msg_t = net::server_msg<net::msg_body>; using header_t = typename msg_t::header_t; using connection_t = net::tcp_connection<msg_t>; using connection_ptr = std::shared_ptr<connection_t>; using context_t = typename connection_t::context_t; using msg_ptr = typename connection_t::msg_ptr; using proto_t = Proto; using proto_ptr_t = std::shared_ptr<proto_t>; using proto_map_t = std::map<uint32_t, proto_ptr_t>; template <typename T> struct has_ctx_process_func { private: template <typename P, typename = decltype(std::declval<P>().process(*(msg_ptr)nullptr, *(connection_ptr*)nullptr, *(game_server_t*)nullptr, *(context_t*)nullptr))> static std::true_type test(int); template <typename P> static std::false_type test(...); using result_type = decltype(test<T>(0)); public: static constexpr bool value = result_type::value; }; template<typename T> constexpr bool has_ctx_process_func_v = has_ctx_process_func<T>::value; class Proto : public std::enable_shared_from_this<Proto>, public custom_msg { public: Proto() : protocol_id_(0) , has_ctx_process_(false) {} Proto(const Proto& rhs) : protocol_id_(rhs.protocol_id_) , has_ctx_process_(rhs.has_ctx_process_) { } uint32_t get_protocol_id() const { return protocol_id_; } void set_has_ctx_process(bool has_ctx_process) { has_ctx_process_ = has_ctx_process; } public: virtual proto_ptr_t clone() { return nullptr; } virtual void unpack(msg_ptr& msgp) = 0; void do_process(msg_ptr& msgp, connection_ptr& conn_ptr, game_server_t& server) { if (!has_ctx_process_) { process(msgp, conn_ptr, server); } else { auto& ios = net::get_current_ios(); boost::asio::spawn(ios, [&] (context_t ctx) { this->process(msgp, conn_ptr, server, ctx); }); } } private: virtual void process(msg_ptr& msgp, connection_ptr& conn_ptr, game_server_t& server) { } virtual void process(msg_ptr& msgp, connection_ptr& conn_ptr, game_server_t& server, context_t ctx) { } public: static proto_map_t& GetMap() { static proto_map_t protocols; return protocols; } static proto_ptr_t GetProto(uint32_t protocol_id) { auto& proto_map = GetMap(); auto it = proto_map.find(protocol_id); if (it != proto_map.end()) { return it->second; } return nullptr; } static proto_ptr_t Decode(msg_ptr& msgp) { uint32_t protocol_id = msgp->header().protocol_id; proto_ptr_t proto = Create(protocol_id); if (proto) { proto->unpack(msgp); } return proto; } static proto_ptr_t Create(uint32_t protocol_id) { proto_ptr_t proto = GetProto(protocol_id); return proto ? proto->clone() : nullptr; }
protected: Proto(uint32_t id) : protocol_id_(id) , has_ctx_process_(false) {} uint32_t protocol_id_; bool has_ctx_process_; }; template<typename T> auto make_proto_ptr(uint32_t proto_id) { bool has_ctx_process = has_ctx_process_func_v<T>; std::shared_ptr<T> ptr = std::make_shared<T>(); ptr->set_has_ctx_process(has_ctx_process); proto_t::RegisterProto(ptr); return ptr; } } using Proto = detail::Proto; using proto_t = Proto; using proto_ptr_t = std::shared_ptr<proto_t>; using msg_t = net::server_msg<net::msg_body>; using header_t = typename msg_t::header_t; using connection_t = net::tcp_connection<msg_t>; using context_t = typename connection_t::context_t; using connection_ptr = std::shared_ptr<connection_t>; using msg_ptr = typename connection_t::msg_ptr; } } #define REGISTER_PROTOCOL(type) \ namespace MACRO_CONCAT(___reg_proto_helper_value___ ## type, __LINE__) \ { \ static auto type ## _ptr = cytx::gameserver::detail::make_proto_ptr<type>(type::ProtoId()); \ }
static void RegisterProto(proto_ptr_t proto) { uint32_t proto_id = proto->get_protocol_id(); if (!GetProto(proto_id)) { auto& proto_map = GetMap(); proto_map.emplace(proto_id, proto); } }
function_block-full_function
[ { "content": "class UseSkill : public virtual ::apache::thrift::TBase {\n\n public:\n\n\n\n UseSkill(const UseSkill&);\n\n UseSkill& operator=(const UseSkill&);\n\n UseSkill() : skillId(0) {\n\n }\n\n\n\n virtual ~UseSkill() throw();\n\n int32_t skillId;\n\n std::vector<int32_t> targetIds;\n\n\n\n _Use...
C++
ModuleObstacle.cpp
BravoXavi/Space-Harrier-MVJ-
cfc3d6f392b926faa0b88a2acb8c89db24a626d7
#include <math.h> #include "ModuleObstacle.h" #include "Application.h" #include "ModuleAudio.h" #include "ModuleTextures.h" #include "ModuleRender.h" #include "ModuleCollision.h" #include "ModuleParticles.h" #include "ModuleShadows.h" #include "ModulePlayer.h" #include "SDL/include/SDL_timer.h" ModuleObstacle::ModuleObstacle(bool active) : Module(active) {} ModuleObstacle::~ModuleObstacle() {} bool ModuleObstacle::Start() { LOG("Loading Obstacles"); graphics = App->textures->Load("assets/enemiesobstacles.png"); tree.anim.frames.push_back({ 206, 378, 40, 158 }); tree.worldPosition.z = MAX_Z; tree.colType = D_OBSTACLE; rock.anim.frames.push_back({ 192, 72, 59, 37 }); rock.worldPosition.z = MAX_Z; rock.colType = D_OBSTACLE; rock.shadowCast = true; bush.anim.frames.push_back({ 193, 8, 59, 41 }); bush.worldPosition.z = MAX_Z; bush.colType = NOLETHAL_D_OBSTACLE; return true; } bool ModuleObstacle::CleanUp() { LOG("Unloading particles"); App->textures->Unload(graphics); for (list<Obstacle*>::iterator it = active.begin(); it != active.end(); ++it) RELEASE(*it); active.clear(); return true; } update_status ModuleObstacle::PreUpdate() { for (list<Obstacle*>::iterator it = active.begin(); it != active.end();) { if ((*it)->to_delete == true) { RELEASE(*it); it = active.erase(it); } else ++it; } return UPDATE_CONTINUE; } update_status ModuleObstacle::Update() { for (list<Obstacle*>::iterator it = active.begin(); it != active.end(); ++it) { Obstacle* o = *it; if(!App->renderer->stopUpdating) o->Update(); if (o->shadowCast) App->shadows->DrawShadow(o->screenPosition.x, o->screenPosition.y, o->screenPosition.z, o->dataToBlit->newWidth); App->renderer->depthBuffer[(int)o->dataToBlit->z].push_back(*o->dataToBlit); } return UPDATE_CONTINUE; } void ModuleObstacle::AddObstacle(const Obstacle& obstacle, const float& x, const float& xOffset, const float& y, collisionType type) { Obstacle* o = new Obstacle(obstacle); o->worldPosition = { x, y, (float)MAX_Z}; o->xOffset = xOffset; o->colType = type; o->collider = App->collision->AddCollider({ 0, 0, 0, 0 }, o->colType, (int)o->worldPosition.z, App->obstacles); o->lineToFollow = App->renderer->nextTopLine; active.push_back(o); } const bool ModuleObstacle::onCollision(Collider* moduleOwner, Collider* otherCollider) { bool ret = true; for (std::list<Obstacle*>::iterator it = active.begin(); it != active.end(); ++it) { if ((*it)->collider == moduleOwner) { if (otherCollider->colType != PLAYER) { App->player->playerScore += 1000.0f; (*it)->to_delete = true; (*it)->collider->to_delete = true; if (otherCollider->colType != PLAYER) App->particles->AddParticle(App->particles->explosion, (*it)->screenPosition.x, (*it)->screenPosition.y + (*it)->dataToBlit->newHeight, (*it)->screenPosition.z, EXPLOSION); } } } return ret; } Obstacle::Obstacle() {} Obstacle::Obstacle(const Obstacle& o) : anim(o.anim), worldPosition(o.worldPosition), shadowCast(o.shadowCast) {} Obstacle::~Obstacle() { delete dataToBlit; } void Obstacle::Update() { if (worldPosition.z <= MIN_Z + 1) { collider->to_delete = true; to_delete = true; } float tempY = ((App->renderer->renderLineValues[lineToFollow]) / (float)SCREEN_SIZE); float scaleValue = calculateScaleValue(tempY); float newWidth = (float)anim.GetCurrentFrame().w * scaleValue; float newHeight = (float)anim.GetCurrentFrame().h * scaleValue; if (newHeight < 2.0f) newHeight = 2.0f; if (newWidth < 1.0f) newWidth = 1.0f; worldPosition.z = ((float)SCREEN_HEIGHT - tempY) / (App->renderer->horizonY / (float)MAX_Z); xOffset -= App->renderer->playerSpeed; screenPosition.x = worldPosition.x - (newWidth / 2.0f) + (xOffset * scaleValue); screenPosition.y = tempY - newHeight - (worldPosition.y * scaleValue); screenPosition.z = worldPosition.z; setRect(App->obstacles->graphics, screenPosition.x, screenPosition.y, screenPosition.z, newWidth, newHeight, &(anim.GetCurrentFrame())); collider->SetPos((int)screenPosition.x, (int)screenPosition.y, (int)worldPosition.z, (int)newWidth, (int)newHeight); } const float Obstacle::calculateScaleValue(float yRender) const { float min = (float)SCREEN_HEIGHT - App->renderer->horizonY; float max = (float)SCREEN_HEIGHT; float toReturn = (yRender - min) / (max - min); if (toReturn < 0.0f) toReturn = 0.0f; return toReturn; } void Obstacle::setRect(SDL_Texture* texture, const float& x, const float& y, const float& z, const float& newWidth, const float& newHeight, SDL_Rect* section) const { dataToBlit->x = x; dataToBlit->y = y; dataToBlit->z = z; dataToBlit->newWidth = newWidth; dataToBlit->newHeight = newHeight; dataToBlit->texture = texture; dataToBlit->section = section; }
#include <math.h> #include "ModuleObstacle.h" #include "Application.h" #include "ModuleAudio.h" #include "ModuleTextures.h" #include "ModuleRender.h" #include "ModuleCollision.h" #include "ModuleParticles.h" #include "ModuleShadows.h" #include "ModulePlayer.h" #include "SDL/include/SDL_timer.h" ModuleObstacle::ModuleObstacle(bool active) : Module(active) {} ModuleObstacle::~ModuleObstacle() {} bool ModuleObstacle::Start() { LOG("Loading Obstacles"); graphics = App->textures->Load("assets/enemiesobstacles.png"); tree.anim.frames.push_back({ 206, 378, 40, 158 }); tree.worldPosition.z = MAX_Z; tree.colType = D_OBSTACLE; rock.anim.frames.push_back({ 192, 72, 59, 37 }); rock.worldPosition.z = MAX_Z; rock.colType = D_OBSTACLE; rock.shadowCast = true; bush.anim.frames.push_back({ 193, 8, 59, 41 }); bush.worldPosition.z = MAX_Z; bush.colType = NOLETHAL_D_OBSTACLE; return true; } bool ModuleObstacle::CleanUp() { LOG("Unloading particles"); App->textures->Unload(graphics); for (list<Obstacle*>::iterat
oat)anim.GetCurrentFrame().w * scaleValue; float newHeight = (float)anim.GetCurrentFrame().h * scaleValue; if (newHeight < 2.0f) newHeight = 2.0f; if (newWidth < 1.0f) newWidth = 1.0f; worldPosition.z = ((float)SCREEN_HEIGHT - tempY) / (App->renderer->horizonY / (float)MAX_Z); xOffset -= App->renderer->playerSpeed; screenPosition.x = worldPosition.x - (newWidth / 2.0f) + (xOffset * scaleValue); screenPosition.y = tempY - newHeight - (worldPosition.y * scaleValue); screenPosition.z = worldPosition.z; setRect(App->obstacles->graphics, screenPosition.x, screenPosition.y, screenPosition.z, newWidth, newHeight, &(anim.GetCurrentFrame())); collider->SetPos((int)screenPosition.x, (int)screenPosition.y, (int)worldPosition.z, (int)newWidth, (int)newHeight); } const float Obstacle::calculateScaleValue(float yRender) const { float min = (float)SCREEN_HEIGHT - App->renderer->horizonY; float max = (float)SCREEN_HEIGHT; float toReturn = (yRender - min) / (max - min); if (toReturn < 0.0f) toReturn = 0.0f; return toReturn; } void Obstacle::setRect(SDL_Texture* texture, const float& x, const float& y, const float& z, const float& newWidth, const float& newHeight, SDL_Rect* section) const { dataToBlit->x = x; dataToBlit->y = y; dataToBlit->z = z; dataToBlit->newWidth = newWidth; dataToBlit->newHeight = newHeight; dataToBlit->texture = texture; dataToBlit->section = section; }
or it = active.begin(); it != active.end(); ++it) RELEASE(*it); active.clear(); return true; } update_status ModuleObstacle::PreUpdate() { for (list<Obstacle*>::iterator it = active.begin(); it != active.end();) { if ((*it)->to_delete == true) { RELEASE(*it); it = active.erase(it); } else ++it; } return UPDATE_CONTINUE; } update_status ModuleObstacle::Update() { for (list<Obstacle*>::iterator it = active.begin(); it != active.end(); ++it) { Obstacle* o = *it; if(!App->renderer->stopUpdating) o->Update(); if (o->shadowCast) App->shadows->DrawShadow(o->screenPosition.x, o->screenPosition.y, o->screenPosition.z, o->dataToBlit->newWidth); App->renderer->depthBuffer[(int)o->dataToBlit->z].push_back(*o->dataToBlit); } return UPDATE_CONTINUE; } void ModuleObstacle::AddObstacle(const Obstacle& obstacle, const float& x, const float& xOffset, const float& y, collisionType type) { Obstacle* o = new Obstacle(obstacle); o->worldPosition = { x, y, (float)MAX_Z}; o->xOffset = xOffset; o->colType = type; o->collider = App->collision->AddCollider({ 0, 0, 0, 0 }, o->colType, (int)o->worldPosition.z, App->obstacles); o->lineToFollow = App->renderer->nextTopLine; active.push_back(o); } const bool ModuleObstacle::onCollision(Collider* moduleOwner, Collider* otherCollider) { bool ret = true; for (std::list<Obstacle*>::iterator it = active.begin(); it != active.end(); ++it) { if ((*it)->collider == moduleOwner) { if (otherCollider->colType != PLAYER) { App->player->playerScore += 1000.0f; (*it)->to_delete = true; (*it)->collider->to_delete = true; if (otherCollider->colType != PLAYER) App->particles->AddParticle(App->particles->explosion, (*it)->screenPosition.x, (*it)->screenPosition.y + (*it)->dataToBlit->newHeight, (*it)->screenPosition.z, EXPLOSION); } } } return ret; } Obstacle::Obstacle() {} Obstacle::Obstacle(const Obstacle& o) : anim(o.anim), worldPosition(o.worldPosition), shadowCast(o.shadowCast) {} Obstacle::~Obstacle() { delete dataToBlit; } void Obstacle::Update() { if (worldPosition.z <= MIN_Z + 1) { collider->to_delete = true; to_delete = true; } float tempY = ((App->renderer->renderLineValues[lineToFollow]) / (float)SCREEN_SIZE); float scaleValue = calculateScaleValue(tempY); float newWidth = (fl
random
[ { "content": "struct Obstacle\n\n{\n\n\tObstacle();\n\n\tObstacle(const Obstacle& p);\n\n\t~Obstacle();\n\n\n\n\tvoid Update();\n\n\n\n\tconst float calculateScaleValue(float yRender) const;\n\n\tvoid setRect(SDL_Texture* texture, const float& x, const float& y, const float& z, const float& newWidth, const floa...
C++
Sources/Modules/Core/Logger.cpp
benkaraban/anima-games-engine
8aa7a5368933f1b82c90f24814f1447119346c3b
#include <Core/Logger.h> #include <Core/IO/FileStream.h> #include <Core/System/Files.h> namespace Core { using namespace Core::System; LoggerMessage::LoggerMessage() : _msg(new Core::BufferStream()) { } LoggerMessage::~LoggerMessage() { } String LoggerMessage::getLastLine() { String8 string8; char oneChar; int32 readBytes = _msg->readUpTo(&oneChar, sizeof(char)); bool isEndLine = (oneChar == '\n'); while(readBytes == sizeof(char) && !isEndLine) { if(oneChar != '\r') { string8.push_back(oneChar); } readBytes = _msg->readUpTo(&oneChar, sizeof(char)); isEndLine = (oneChar == '\n'); } return String(string8); } String LoggerMessage::computeMessage (const String& loggerTag) { String str; String line; do { line = getLastLine(); str << loggerTag << _tagContainer << line << L"\n"; } while(!_msg->eof()); _tagContainer = L""; return str; } Logger::Logger(Ptr<OutputStream> stream, String name) { Ptr<TextOutputStream > tos = Ptr<TextOutputStream > (new TextOutputStream (stream, true)); addStream(tos, LOGGER_DEFAULT_STREAM_NAME); _name = name; _nbMsg = 0; _logMsgLevel = Core::L_DEBUG; setDefaultMsgLevel(L_INFO); _showTagIdMsg = true; _showTagAppTime = true; _showTagLocalTime = false; _showTagThreadId = false; _showTagMsgLevel = true; _DBGtoStdOut = true; } Logger::~Logger() { } void Logger::destroyStream(const String& name) { _streamMap.erase(name); } void Logger::addStream(Ptr<TextOutputStream > tos, const String& name) { _streamMap[name] = tos; } String Logger::getLoggerTag() { String str; if (_showTagIdMsg) { str += Core::toString(_nbMsg, 6); str += LOGGER_TAG_SEPARATOR; } if (_showTagAppTime) { str += Clock::applicationTime().toString(false, TD_PRINT_HOURS); str += LOGGER_TAG_SEPARATOR; #ifdef _WIN32 str += Clock::applicationTime().toString(false, TD_PRINT_COUNTER); str += LOGGER_TAG_SEPARATOR; #endif } if (_showTagLocalTime) { String time(Core::Clock::localTime().toString().slice(0, 22)); time[10] = L'_'; str += time; str += LOGGER_TAG_SEPARATOR; } if (_showTagThreadId) { str += Core::toStringHex(Thread::getCurrentThreadID(), 4); str += LOGGER_TAG_SEPARATOR; } if (_showTagMsgLevel) { switch(_msgLevel) { case L_ERROR: str += L"ERR"; break; case L_WARNING: str += L"WAR"; break; case L_INFO: str += L"INF"; break; case L_DEBUG: str += L"DBG"; break; } str += LOGGER_TAG_SEPARATOR; } return str; } void Logger::operator= (LoggerMessage& lm) { String loggerTag = getLoggerTag(); String msg = lm.computeMessage (loggerTag); #if defined _MSC_VER OutputDebugStringW(msg.c_str()); #endif if (_DBGtoStdOut == true && _msgLevel == L_DEBUG) { LM_COUT<<msg; } for(Map<String, Ptr<TextOutputStream > >::iterator it = _streamMap.begin(); it != _streamMap.end(); ++it) { (*it->second)<<msg; it->second->flush(); } _nbMsg++; } Logger& Logger::configMessage(ELogMsgLevel eLevel) { setMsgLevel(eLevel); return *this; } LoggerManager::LoggerManager() { _defautLogger = getFileName(getFileBaseName(getExecutableName())); String defaultFileName = _defautLogger; String ext = L".log"; String pathFile = getUserLocalAppDir() + L"/AnimaGames/"; createDirectory(pathFile); String pathAndFileName = pathFile + defaultFileName; Ptr<Core::FileOutputStream> defaultStreamLog (new Core::FileOutputStream(pathAndFileName + ext)); int32 idLog = 0; while (defaultStreamLog->isOpened() == false) { idLog++; defaultStreamLog->open(pathAndFileName + L"_" + Core::toString(idLog) + ext); } Ptr<Logger > defaultLog = (Ptr<Logger >)new Logger (defaultStreamLog, _defautLogger); defaultLog->setShowTagIdMsg(LOGGER_DEFAULT_TAG_ID_MSG); defaultLog->setShowTagAppTime(LOGGER_DEFAULT_TAG_APP_TIME); defaultLog->setShowTagLocalTime(LOGGER_DEFAULT_TAG_LOCAL_TIME); defaultLog->setShowTagThreadId(LOGGER_DEFAULT_TAG_THREAD_ID); defaultLog->setShowTagMsgLevel(LOGGER_DEFAULT_TAG_MSG_LEVEL); defaultLog->setLogMsgLevel(LM_LOGGER_DEFAULT_MSG_LEVEL); addLogger(defaultLog); defaultLog->addStream(Ptr<TextOutputStream > (new TextOutputStream (LM_COUT_PTR, true)), STDCOUT_STREAM_NAME); defaultLog->setDBGtoStdOut(false); } LoggerManager::~LoggerManager() { } void LoggerManager::destroyLogger(const String& name) { _loggerMap.erase(name); } void LoggerManager::addLogger(Ptr<Logger > log) { _loggerMap[log->getName()] = log; } Ptr<Logger > LoggerManager::getLogger(const String& name) { return _loggerMap[name]; } LoggerManager& LoggerManager::getInstance() { static LoggerManager sInstance; return sInstance; } }
#include <Core/Logger.h> #include <Core/IO/FileStream.h> #include <Core/System/Files.h> namespace Core { using namespace Core::System; LoggerMessage::LoggerMessage() : _msg(new Core::BufferStream()) { } LoggerMessage::~LoggerMessage() { } String LoggerMessage::getLastLine() { String8 string8; char oneChar; int32 readBytes = _msg->readUpTo(&oneChar, sizeof(char)); bool isEndLine = (oneChar == '\n'); while(readBytes == sizeof(char) && !isEndLine) { if(oneChar != '\r') { string8.push_back(oneChar); } readBytes = _msg->readUpTo(&oneChar, sizeof(char)); isEndLine = (oneChar == '\n'); } return String(string8); } String LoggerMessage::computeMessage (const String& loggerTag) { String str; String line; do { line = getLastLine(); str << loggerTag << _tagContainer << line << L"\n"; } while(!_msg->eof()); _tagContainer = L""; return str; } Logger::Logger(Ptr<OutputStream> stream, String name) { Ptr<TextOutputStream > tos = Ptr<TextOutputStream > (new TextOutputStream (stream, true)); addStream(tos, LOGGER_DEFAULT_STREAM_NAME); _name = name; _nbMsg = 0; _logMsgLevel = Core::L_DEBUG; setDefaultMsgLevel(L_INFO); _showTagIdMsg = true; _showTagAppTime = true; _showTagLocalTime = false; _showTagThreadId = false; _showTagMsgLevel = true; _DBGtoStdOut = true; } Logger::~Logger() { } void Logger::destroyStream(const String& name) { _streamMap.erase(name); } void Logger::addStream(Ptr<TextOutputStream > tos, const String& name) { _streamMap[name] = tos; } String Logger::getLoggerTag() { String str; if (_showTagIdMsg) { str += Core::toString(_nbMsg, 6); str += LOGGER_TAG_SEPARATOR; } if (_showTagAppTime) { str += Clock::applicationTime().toString(false, TD_PRINT_HOURS); str += LOGGER_TAG_SEPARATOR; #ifdef _WIN32 str += Clock::applicationTime().toString(false, TD_PRINT_COUNTER); str += LOGGER_TAG_SEPARATOR; #endif } if (_showTagLocalTime) { String time(Core::Clock::localTime().toString().slice(0, 22)); time[10] = L'_'; str += time; str += LOGGER_TAG_SEPARATOR; }
if (_showTagMsgLevel) { switch(_msgLevel) { case L_ERROR: str += L"ERR"; break; case L_WARNING: str += L"WAR"; break; case L_INFO: str += L"INF"; break; case L_DEBUG: str += L"DBG"; break; } str += LOGGER_TAG_SEPARATOR; } return str; } void Logger::operator= (LoggerMessage& lm) { String loggerTag = getLoggerTag(); String msg = lm.computeMessage (loggerTag); #if defined _MSC_VER OutputDebugStringW(msg.c_str()); #endif if (_DBGtoStdOut == true && _msgLevel == L_DEBUG) { LM_COUT<<msg; } for(Map<String, Ptr<TextOutputStream > >::iterator it = _streamMap.begin(); it != _streamMap.end(); ++it) { (*it->second)<<msg; it->second->flush(); } _nbMsg++; } Logger& Logger::configMessage(ELogMsgLevel eLevel) { setMsgLevel(eLevel); return *this; } LoggerManager::LoggerManager() { _defautLogger = getFileName(getFileBaseName(getExecutableName())); String defaultFileName = _defautLogger; String ext = L".log"; String pathFile = getUserLocalAppDir() + L"/AnimaGames/"; createDirectory(pathFile); String pathAndFileName = pathFile + defaultFileName; Ptr<Core::FileOutputStream> defaultStreamLog (new Core::FileOutputStream(pathAndFileName + ext)); int32 idLog = 0; while (defaultStreamLog->isOpened() == false) { idLog++; defaultStreamLog->open(pathAndFileName + L"_" + Core::toString(idLog) + ext); } Ptr<Logger > defaultLog = (Ptr<Logger >)new Logger (defaultStreamLog, _defautLogger); defaultLog->setShowTagIdMsg(LOGGER_DEFAULT_TAG_ID_MSG); defaultLog->setShowTagAppTime(LOGGER_DEFAULT_TAG_APP_TIME); defaultLog->setShowTagLocalTime(LOGGER_DEFAULT_TAG_LOCAL_TIME); defaultLog->setShowTagThreadId(LOGGER_DEFAULT_TAG_THREAD_ID); defaultLog->setShowTagMsgLevel(LOGGER_DEFAULT_TAG_MSG_LEVEL); defaultLog->setLogMsgLevel(LM_LOGGER_DEFAULT_MSG_LEVEL); addLogger(defaultLog); defaultLog->addStream(Ptr<TextOutputStream > (new TextOutputStream (LM_COUT_PTR, true)), STDCOUT_STREAM_NAME); defaultLog->setDBGtoStdOut(false); } LoggerManager::~LoggerManager() { } void LoggerManager::destroyLogger(const String& name) { _loggerMap.erase(name); } void LoggerManager::addLogger(Ptr<Logger > log) { _loggerMap[log->getName()] = log; } Ptr<Logger > LoggerManager::getLogger(const String& name) { return _loggerMap[name]; } LoggerManager& LoggerManager::getInstance() { static LoggerManager sInstance; return sInstance; } }
if (_showTagThreadId) { str += Core::toStringHex(Thread::getCurrentThreadID(), 4); str += LOGGER_TAG_SEPARATOR; }
if_condition
[]
C++
problem/Tree/Shortest distance between two nodes.cpp
mechusatveer/coding-questions
a86b41f753ffd70001357ab059ee0cb63c7914ff
#include<iostream> #include<list> using namespace std; struct Node { int val; Node *plft; Node *prgt; Node(int v) : val(v), plft(NULL), prgt(NULL) {} }; bool GetNodePath(Node *root, Node *node, list<Node*>& path) { if (root == node) return true; path.push_back(root); bool found = false; if (root->plft != NULL) found = getNodePath(root->plft, node, path); if (!found && root->prgt) found = getNodePath(root->prgt, node, path); if (!found) path.pop_back(); return found; } Node* LastCommonNode(const list<Node*>& path1, const list<Node*>& path2) { list<Node*>::const_iterator iterator1 = path1.begin(); list<Node*>::const_iterator iterator2 = path2.begin(); Node *last = NULL; while (iterator1 != path1.end() && iterator2 != path2.end()) { if (*iterator1 == *iterator2) last = *iterator1; iterator1++; iterator2++; } return last; } Node *LastCommonAncestor(Node* root, Node* node1, Node* node2) { if(root == NULL || node1 == NULL || node2 == NULL) return NULL; list<Node*> path1; GetNodePath(root, node1, path1); list<Node*> path2; GetNodePath(root, node2, path2); return LastCommonNode(path1, path2); } int Height(Node *lca, Node *node,bool &found) { int lheight = 0, rheight = 0; if (lca) { if (found == false && lca == node) { found = true; return 0; } else if (found == false) { lheight = Height(lca->plft, node, found); rheight = 0; if(found == false) { rheight = Height(lca->prgt, node, found); } if(found == true) { return lheight > rheight? 1+lheight : 1+rheight; } else { return 0; } } else { return 0; } } else { return 0; } } int ShortestDistance(Node *node1, Node* node2, Node *lca) { if (lca) { bool found = false; int dist1 = Height(lca, node1, found); cout<<"Distance of "<<node1->val<<": "<<dist1<<endl; found = false; int dist2 = Height(lca,node2,found); cout<<"Distance of "<<node2->val<<": "<<dist2<<endl; return dist1 + dist2; } else { return 0; } } int main() { Node *root = new Node(1); root->plft = new Node(2); root->prgt = new Node(3); root->plft->plft = new Node(4); root->plft->prgt = new Node(5); root->prgt->plft = new Node(6); root->prgt->prgt = new Node(7); root->prgt->prgt->plft = new Node(8); root->prgt->prgt->prgt = new Node(9); Node *node1 = root->prgt->prgt->plft; Node *node2 = root->prgt->plft; Node *lca = LastCommonAncestor(root, node1, node2); if (lca) { cout<<"Least Common Ancestor: "<<lca->val<<endl; } cout<<"Total distance: "<<ShortestDistance(node1, node2, lca)<<endl; return 0; }
#include<iostream> #include<list> using namespace std; struct Node { int val; Node *plft; Node *prgt; Node(int v) : val(v), plft(NULL), prgt(NULL) {} }; bool GetNodePath(Node *root, Node *node, list<Node*>& path) { if (root == node) return true; path.push_back(root); bool found = false; if (root->plft != NULL) found = getNodePath(root->plft, node, path); if (!found && root->prgt) found = getNodePath(root->prgt, node, path); if (!found) path.pop_back(); return found; } Node* LastCommonNode(const list<Node*>& path1, const list<Node*>& path2) { list<Node*>::const_iterator iterator1 = path1.begin(); list<Node*>::const_iterator iterator2 = path2.begin(); Node *last = NULL; while (iterator1 != path1.end() && iterator2 != path2.end()) { if (*iterator1 == *iterator2) last = *iterator1; iterator1++; iterator2++; } return last; } Node *LastCommonAncestor(Node* root, Node* node1, Node* node2) { if(root == NULL || node1 == NULL || node2 == NULL) return NULL; list<Node*> path1; GetNodePath(root, node1, path1); list<Node*> path2; GetNodePath(root, node2, path2); return LastCommonNode(path1, path2); } int Height(Node *lca, Node *node,bool &found) { int lheight = 0, rheight = 0; if (lca) { if (found == false && lca == node) { found = true; return 0; } else if (found == false) { lheight = Height(lca->plft, node, found); rheight = 0; if(found == false) { rheight = Height(lca->prgt, node, found); } if(found == true) { return lheight > rheight? 1+lheight : 1+rheight; } else { return 0; } } else { return 0; } } else { return 0; } } int ShortestDistance(Node *node1, Node* node2, Node *lca) {
} int main() { Node *root = new Node(1); root->plft = new Node(2); root->prgt = new Node(3); root->plft->plft = new Node(4); root->plft->prgt = new Node(5); root->prgt->plft = new Node(6); root->prgt->prgt = new Node(7); root->prgt->prgt->plft = new Node(8); root->prgt->prgt->prgt = new Node(9); Node *node1 = root->prgt->prgt->plft; Node *node2 = root->prgt->plft; Node *lca = LastCommonAncestor(root, node1, node2); if (lca) { cout<<"Least Common Ancestor: "<<lca->val<<endl; } cout<<"Total distance: "<<ShortestDistance(node1, node2, lca)<<endl; return 0; }
if (lca) { bool found = false; int dist1 = Height(lca, node1, found); cout<<"Distance of "<<node1->val<<": "<<dist1<<endl; found = false; int dist2 = Height(lca,node2,found); cout<<"Distance of "<<node2->val<<": "<<dist2<<endl; return dist1 + dist2; } else { return 0; }
if_condition
[ { "content": "struct Node {\n\n int val;\n\n Node* plft;\n\n Node* prgt;\n\n\n\n\tNode(int v) : val(v), plft(NULL), prgt(NULL) {}\n\n};\n\n\n\n\n\n//need finish this version\n\n\n\nint main() {\n\n\n\n\t/*\n\n\tNode *root = new Node(1);\n\n\troot->plft = new Node(2);\n\n\troot->prgt = new Node(3);\n\n\...
C++
mindspore/ccsrc/runtime/device/memory_offload_strategy.cc
zhz44/mindspore
6044d34074c8505dd4b02c0a05419cbc32a43f86
#include "runtime/device/memory_offload_strategy.h" #include <vector> #include <map> #include <memory> #include <utility> #include "utils/log_adapter.h" namespace mindspore { namespace device { constexpr size_t kFirstGetMemEventIndex = 1; constexpr size_t kInitOrMallocMemEventIndex = 0; std::vector<std::shared_ptr<MemEvent>> &MemOffloadStrategy::GetPreComputeEvents(size_t step) { if (pre_compute_events_.size() <= step) { MS_LOG_EXCEPTION << "Index out of pre event range, index:" << step << ", event size:" << pre_compute_events_.size(); } return pre_compute_events_[step]; } std::vector<std::shared_ptr<MemEvent>> &MemOffloadStrategy::GetPostComputeEvents(size_t step) { if (post_compute_events_.size() <= step) { MS_LOG_EXCEPTION << "Index out of post event range, index:" << step << ", event size:" << post_compute_events_.size(); } return post_compute_events_[step]; } void MemOffloadStrategy::Execute() { CountMemUsage(); CheckMemSize(); if (need_swap_) { GenEventSpan(); GenSwapEventSet(); } GenComputeMemEvents(); } void MemOffloadStrategy::CountMemUsage() { if (!min_mem_used_.empty()) { return; } if (mem_events_.empty() || total_step_ == 0) { return; } min_mem_used_.resize(total_step_, 0); std::vector<size_t> total_mem_used(total_step_, 0); size_t high_priority_mem_size = 0; for (auto &item : mem_events_) { auto &mem_events = item.second; if (mem_events.empty()) { continue; } auto first_event = mem_events[kInitOrMallocMemEventIndex]; const bool is_high_priority = IsHighPriorityMem(first_event->key); if (is_high_priority) { high_priority_mem_size += first_event->mem_size; } else { auto last_event = mem_events[mem_events.size() - 1]; for (size_t start_index = first_event->index; start_index <= last_event->index; ++start_index) { total_mem_used[start_index] += first_event->mem_size; } } for (const auto &event : mem_events) { MS_EXCEPTION_IF_NULL(event); if (event->type != kGet) { continue; } min_mem_used_[event->index] += first_event->mem_size; } } min_mem_needed_ = *(std::max_element(min_mem_used_.begin(), min_mem_used_.end())); mem_used_without_swap_ = *(std::max_element(total_mem_used.begin(), total_mem_used.end())) + high_priority_mem_size; if (mem_size_ < min_mem_needed_) { MS_LOG(EXCEPTION) << "Out of memory, as available mem size is " << mem_size_ << " while graph needs at least " << min_mem_needed_; } } bool MemOffloadStrategy::IsHighPriorityMem(const void *key) const { auto iter = mem_priority_.find(key); if (iter != mem_priority_.end()) { return iter->second == kMemPriorityHigh; } return false; } void MemOffloadStrategy::CheckMemSize() { if (mem_size_ < mem_used_without_swap_ || !manual_offload_keys_.empty()) { need_swap_ = true; } MS_LOG(INFO) << "Available mem size: " << mem_size_ << ", graph needs mem size: " << mem_used_without_swap_ << " without swap, and needs at least " << min_mem_needed_ << " with swap."; } void MemOffloadStrategy::GenEventSpan() { if (!event_span_.empty()) { return; } for (auto &item : mem_events_) { auto &tensor_events = item.second; if (tensor_events.size() <= 1) { continue; } const bool is_high_priority = IsHighPriorityMem(tensor_events[kInitOrMallocMemEventIndex]->key); for (size_t i = kFirstGetMemEventIndex; i < tensor_events.size(); ++i) { auto &event = tensor_events[i]; MS_EXCEPTION_IF_NULL(event); if (event->type != kGet) { MS_LOG(EXCEPTION) << "Event should be Get except fist event."; } auto latest_event = tensor_events[i - 1]; if (i == kFirstGetMemEventIndex && is_high_priority) { latest_event = tensor_events[tensor_events.size() - 1]; } auto span = GetSpanBetweenMemEvents(latest_event->index, event->index); if (is_high_priority && span == 0 && latest_event == event) { span = total_step_; } if (span > 1) { const size_t span_mul_size = (span - 1) * event->mem_size; (void)event_span_.emplace(std::make_pair(span_mul_size, std::make_pair(event, span))); } } } } void MemOffloadStrategy::GenSwapEventSet() { swap_events_.clear(); if (!manual_offload_keys_.empty()) { for (const auto &iter : event_span_) { auto &event = iter.second.first; if (manual_offload_keys_.find(event->key) != manual_offload_keys_.end()) { (void)swap_events_.emplace(event); } } return; } std::vector<size_t> cur_mem_used(min_mem_used_.begin(), min_mem_used_.end()); for (const auto &iter : event_span_) { auto span = iter.second.second; auto &event = iter.second.first; auto start_index = ((event->index + total_step_ - span + 1) % total_step_); bool revert = false; size_t cur_index = start_index; while (cur_index != event->index) { cur_mem_used[cur_index] += event->mem_size; if (cur_mem_used[cur_index] > mem_size_) { revert = true; } cur_index += 1; if (cur_index >= total_step_) { cur_index = 0; } } if (revert) { cur_index = start_index; while (cur_index != event->index) { cur_mem_used[cur_index] -= event->mem_size; cur_index += 1; if (cur_index >= total_step_) { cur_index = 0; } } (void)swap_events_.emplace(event); } } } void MemOffloadStrategy::GenComputeMemEvents() { pre_compute_events_.clear(); post_compute_events_.clear(); pre_compute_events_.resize(total_step_); post_compute_events_.resize(total_step_); for (auto &item : mem_events_) { auto &mem_events = item.second; if (mem_events.size() <= 1) { continue; } const bool is_high_priority = IsHighPriorityMem(item.first); auto first_event = mem_events[kInitOrMallocMemEventIndex]; MS_EXCEPTION_IF_NULL(first_event); const auto &first_get_event = mem_events[kFirstGetMemEventIndex]; MS_EXCEPTION_IF_NULL(first_get_event); if (is_high_priority && swap_events_.find(first_get_event) != swap_events_.end()) { first_event->index = first_get_event->index; } if ((first_event->type == kInit || first_event->type == kMalloc) && first_event->index < total_step_) { pre_compute_events_[first_event->index].emplace_back(first_event); } else { MS_LOG_EXCEPTION << "First event should be init or malloc!"; } const auto &last_event = mem_events[mem_events.size() - 1]; size_t pre_index = is_high_priority ? last_event->index : first_event->index; const auto &swap_out_event_index = GetSwapOutEventIndex(item.first, mem_events); for (size_t i = kFirstGetMemEventIndex; i < mem_events.size(); ++i) { auto &event = mem_events[i]; MS_EXCEPTION_IF_NULL(event); if (need_swap_ && swap_events_.find(event) != swap_events_.end()) { MemEventType event_type = kSwapOut; if (is_high_priority && swap_out_event_index.count(i) == 0) { event_type = kFree; } auto free_or_swap_out_event = std::make_shared<MemEvent>(event_type, pre_index); free_or_swap_out_event->key = item.first; free_or_swap_out_event->mem_size = first_event->mem_size; post_compute_events_[pre_index].emplace_back(free_or_swap_out_event); if (i != kFirstGetMemEventIndex || first_event->type != kInit) { auto swap_in_event = std::make_shared<MemEvent>(kSwapIn, event->index); swap_in_event->key = item.first; swap_in_event->mem_size = first_event->mem_size; (void)pre_compute_events_[event->index].emplace_back(swap_in_event); } } if (event->index < pre_compute_events_.size()) { (void)pre_compute_events_[event->index].emplace_back(event); } pre_index = event->index; } if (!is_high_priority) { GenFreeEvent(last_event); } } } void MemOffloadStrategy::GenFreeEvent(const std::shared_ptr<MemEvent> &last_event) { MS_EXCEPTION_IF_NULL(last_event); auto free_event = std::make_shared<MemEvent>(kFree, last_event->index); free_event->key = last_event->key; if (last_event->index < post_compute_events_.size()) { (void)post_compute_events_[last_event->index].emplace_back(free_event); } } std::set<size_t> MemOffloadStrategy::GetSwapOutEventIndex(const void *key, const std::vector<std::shared_ptr<MemEvent>> &mem_events) { const auto &update_step_iter = high_priority_updated_step_.find(key); if (update_step_iter == high_priority_updated_step_.end() || update_step_iter->second.empty()) { return std::set<size_t>(); } const auto &update_steps = update_step_iter->second; size_t update_steps_index = 0; std::set<size_t> swap_out_event_index; size_t min_swap_index_before_update = SIZE_MAX; size_t max_swap_out_step = 0; for (size_t i = 0; i < mem_events.size(); ++i) { const auto &mem_event = mem_events[i]; if (swap_events_.count(mem_event) == 0) { continue; } if (mem_event->index <= update_steps[update_steps_index]) { if (i <= min_swap_index_before_update) { min_swap_index_before_update = i; } } else { swap_out_event_index.insert(i); max_swap_out_step = mem_event->index; while (update_steps_index < update_steps.size() && update_steps[update_steps_index] < mem_event->index) { ++update_steps_index; } } } if (max_swap_out_step <= update_steps[update_steps.size() - 1]) { swap_out_event_index.insert(min_swap_index_before_update); } return swap_out_event_index; } } }
#include "runtime/device/memory_offload_strategy.h" #include <vector> #include <map> #include <memory> #include <utility> #include "utils/log_adapter.h" namespace mindspore { namespace device { constexpr size_t kFirstGetMemEventIndex = 1; constexpr size_t kInitOrMallocMemEventIndex = 0; std::vector<std::shared_ptr<MemEvent>> &MemOffloadStrategy::GetPreComputeEvents(size_t step) { if (pre_compute_events_.size() <= step) { MS_LOG_EXCEPTION << "Index out of pre event range, index:" << step << ", event size:" << pre_compute_events_.size(); } return pre_compute_events_[step]; } std::vector<std::shared_ptr<MemEvent>> &MemOffloadStrategy::GetPostComputeEvents(size_t step) { if (post_compute_events_.size() <= step) { MS_LOG_EXCEPTION << "Index out of post event range, index:" << step << ", event size:" << post_compute_events_.size(); } return post_compute_events_[step]; } void MemOffloadStrategy::Execute() { CountMemUsage(); CheckMemSize(); if (need_swap_) { GenEventSpan(); GenSwapEventSet(); } GenComputeMemEvents(); } void MemOffloadStrategy::CountMemUsage() { if (!min_mem_used_.empty()) { return; } if (mem_events_.empty() || total_step_ == 0) { return; } min_mem_used_.resize(total_step_, 0); std::vector<size_t> total_mem_used(total_step_, 0); size_t high_priority_mem_size = 0; for (auto &item : mem_events_) { auto &mem_events = item.second; if (mem_events.empty()) { continue; } auto first_event = mem_events[kInitOrMallocMemEventIndex]; const bool is_high_priority = IsHighPriorityMem(first_event->key); if (is_high_priority) { high_priority_mem_size += first_event->mem_size; } else { auto last_event = mem_events[mem_events.size() - 1]; for (size_t start_index = first_event->index; start_index <= last_event->index; ++start_index) { total_mem_used[start_index] += first_event->mem_size; } } for (const auto &event : mem_events) { MS_EXCEPTION_IF_NULL(event); if (event->type != kGet) { continue; } min_mem_used_[event->index] += first_event->mem_size; } } min_mem_needed_ = *(std::max_element(min_mem_used_.begin(), min_mem_used_.end())); mem_used_without_swap_ = *(std::max_element(total_mem_used.begin(), total_mem_used.end())) + high_priority_mem_size; if (mem_size_ < min_mem_needed_) { MS_LOG(EXCEPTION) << "Out of memory, as available mem size is " << mem_size_ << " while graph needs at least " << min_mem_needed_; } } bool MemOffloadStrategy::IsHighPriorityMem(const void *key) const { auto iter = mem_priority_.find(key); if (iter != mem_priority_.end()) { return iter->second == kMemPriorityHigh; } return false; } void MemOffloadStrategy::CheckMemSize() { if (mem_size_ < mem_used_without_swap_ || !manual_offload_keys_.empty()) { need_swap_ = true; } MS_LOG(INFO) << "Available mem size: " << mem_size_ << ", graph needs mem size: " << mem_used_without_swap_ << " without swap, and needs at least " << min_mem_needed_ << " with swap."; } void MemOffloadStrategy::GenEventSpan() { if (!event_span_.empty()) { return; } for (auto &item : mem_events_) { auto &tensor_events = item.second; if (tensor_events.size() <= 1) { continue; } const bool is_high_priority = IsHighPriorityMem(tensor_events[kInitOrMallocMemEventIndex]->key); for (size_t i = kFirstGetMemEventIndex; i < tensor_events.size(); ++i) { auto &event = tensor_events[i]; MS_EXCEPTION_IF_NULL(event); if (event->type != kGet) { MS_LOG(EXCEPTION) << "Event should be Get except fist event."; } auto latest_event = tensor_events[i - 1]; if (i == kFirstGetMemEventIndex && is_high_priority) { latest_event = tensor_events[tensor_events.size() - 1]; } auto span = GetSpanBetweenMemEvents(latest_event->index, event->index); if (is_high_priority && span == 0 && latest_event == event) { span = total_step_; } if (span > 1) { const size_t span_mul_size = (span - 1) * event->mem_size; (void)event_span_.emplace(std::make_pair(span_mul_size, std::make_pair(event, span))); } } } } void MemOffloadStrategy::GenSwapEventSet() { swap_events_.clear(); if (!manual_offload_keys_.empty()) { for (const auto &iter : event_span_) { auto &event = iter.second.first; if (manual_offload_keys_.find(event->key) != manual_offload_keys_.end()
rt(min_swap_index_before_update); } return swap_out_event_index; } } }
) { (void)swap_events_.emplace(event); } } return; } std::vector<size_t> cur_mem_used(min_mem_used_.begin(), min_mem_used_.end()); for (const auto &iter : event_span_) { auto span = iter.second.second; auto &event = iter.second.first; auto start_index = ((event->index + total_step_ - span + 1) % total_step_); bool revert = false; size_t cur_index = start_index; while (cur_index != event->index) { cur_mem_used[cur_index] += event->mem_size; if (cur_mem_used[cur_index] > mem_size_) { revert = true; } cur_index += 1; if (cur_index >= total_step_) { cur_index = 0; } } if (revert) { cur_index = start_index; while (cur_index != event->index) { cur_mem_used[cur_index] -= event->mem_size; cur_index += 1; if (cur_index >= total_step_) { cur_index = 0; } } (void)swap_events_.emplace(event); } } } void MemOffloadStrategy::GenComputeMemEvents() { pre_compute_events_.clear(); post_compute_events_.clear(); pre_compute_events_.resize(total_step_); post_compute_events_.resize(total_step_); for (auto &item : mem_events_) { auto &mem_events = item.second; if (mem_events.size() <= 1) { continue; } const bool is_high_priority = IsHighPriorityMem(item.first); auto first_event = mem_events[kInitOrMallocMemEventIndex]; MS_EXCEPTION_IF_NULL(first_event); const auto &first_get_event = mem_events[kFirstGetMemEventIndex]; MS_EXCEPTION_IF_NULL(first_get_event); if (is_high_priority && swap_events_.find(first_get_event) != swap_events_.end()) { first_event->index = first_get_event->index; } if ((first_event->type == kInit || first_event->type == kMalloc) && first_event->index < total_step_) { pre_compute_events_[first_event->index].emplace_back(first_event); } else { MS_LOG_EXCEPTION << "First event should be init or malloc!"; } const auto &last_event = mem_events[mem_events.size() - 1]; size_t pre_index = is_high_priority ? last_event->index : first_event->index; const auto &swap_out_event_index = GetSwapOutEventIndex(item.first, mem_events); for (size_t i = kFirstGetMemEventIndex; i < mem_events.size(); ++i) { auto &event = mem_events[i]; MS_EXCEPTION_IF_NULL(event); if (need_swap_ && swap_events_.find(event) != swap_events_.end()) { MemEventType event_type = kSwapOut; if (is_high_priority && swap_out_event_index.count(i) == 0) { event_type = kFree; } auto free_or_swap_out_event = std::make_shared<MemEvent>(event_type, pre_index); free_or_swap_out_event->key = item.first; free_or_swap_out_event->mem_size = first_event->mem_size; post_compute_events_[pre_index].emplace_back(free_or_swap_out_event); if (i != kFirstGetMemEventIndex || first_event->type != kInit) { auto swap_in_event = std::make_shared<MemEvent>(kSwapIn, event->index); swap_in_event->key = item.first; swap_in_event->mem_size = first_event->mem_size; (void)pre_compute_events_[event->index].emplace_back(swap_in_event); } } if (event->index < pre_compute_events_.size()) { (void)pre_compute_events_[event->index].emplace_back(event); } pre_index = event->index; } if (!is_high_priority) { GenFreeEvent(last_event); } } } void MemOffloadStrategy::GenFreeEvent(const std::shared_ptr<MemEvent> &last_event) { MS_EXCEPTION_IF_NULL(last_event); auto free_event = std::make_shared<MemEvent>(kFree, last_event->index); free_event->key = last_event->key; if (last_event->index < post_compute_events_.size()) { (void)post_compute_events_[last_event->index].emplace_back(free_event); } } std::set<size_t> MemOffloadStrategy::GetSwapOutEventIndex(const void *key, const std::vector<std::shared_ptr<MemEvent>> &mem_events) { const auto &update_step_iter = high_priority_updated_step_.find(key); if (update_step_iter == high_priority_updated_step_.end() || update_step_iter->second.empty()) { return std::set<size_t>(); } const auto &update_steps = update_step_iter->second; size_t update_steps_index = 0; std::set<size_t> swap_out_event_index; size_t min_swap_index_before_update = SIZE_MAX; size_t max_swap_out_step = 0; for (size_t i = 0; i < mem_events.size(); ++i) { const auto &mem_event = mem_events[i]; if (swap_events_.count(mem_event) == 0) { continue; } if (mem_event->index <= update_steps[update_steps_index]) { if (i <= min_swap_index_before_update) { min_swap_index_before_update = i; } } else { swap_out_event_index.insert(i); max_swap_out_step = mem_event->index; while (update_steps_index < update_steps.size() && update_steps[update_steps_index] < mem_event->index) { ++update_steps_index; } } } if (max_swap_out_step <= update_steps[update_steps.size() - 1]) { swap_out_event_index.inse
random
[]
C++
example-ofxDownloadCentral/src/ofApp.cpp
hushstudios/ofxSimpleHttp
5dd8f761381a5abb05913d0a7c50f5611a7aebcf
#include "ofApp.h" void ofApp::setup(){ ofSetFrameRate(60); ofBackground(22); ofSetWindowPosition(20, 20); downloader.setNeedsChecksumMatchToSkipDownload(true); downloader.setIdleTimeAfterEachDownload(0.2); downloader.setVerbose(false); downloader.setMaxConcurrentDownloads(3); } void ofApp::downloadFinished(ofxBatchDownloaderReport &report){ cout << "#################################################" << endl; cout << "#### download finished!!" << endl; cout << "#### [ " << report.attemptedDownloads.size() << " attempted | " ; if(report.wasCanceled){ cout << "#### Download Was CANCELED BY USER!" << endl; } cout << report.failedDownloads.size() << " failed | "; cout << report.successfulDownloads.size() << " ok ]" << endl; for(int i = 0; i < report.responses.size(); i++){ ofxSimpleHttpResponse r = report.responses[i]; r.print(); } bool ok = false; int i = 0; while (!ok && i < report.responses.size()){ if (report.responses[i].ok){ } i++; } } void ofApp::update(){ downloader.update(); } void ofApp::draw(){ ofSetColor(255); drawClock(); downloader.draw(30,30, true, false); string msg = "press 1 to download a file and supply a correct SHA1\n"; msg += "press 2 to download a file and supply an incorrect SHA1\n"; msg += "press 3 to download a few files without supplying a SHA1\n"; msg += "press c to cancel current download\n"; msg += "press C to cancel all downloads\n"; ofDrawBitmapString(msg, 20, ofGetHeight() - 70); } void ofApp::drawClock(){ ofPushMatrix(); ofTranslate(ofGetWidth() - 60,60, 0); ofRotate( ofGetFrameNum() * 3, 0,0,1); ofSetColor(255,255,255); float h = 5; ofRect(-h/2,h/2, h,50); ofPopMatrix(); } void ofApp::keyPressed(int key){ vector<string> allURLS; vector<string> allSha1s; if(key == '1'){ allURLS.push_back("http://farm3.staticflickr.com/2875/9481775605_ea43f5d4f3_o_d.jpg"); allSha1s.push_back("852a7952aabcbf3479974d5350f973b005b23c4a"); } if(key == '2'){ allURLS.push_back("http://farm8.staticflickr.com/7454/9481666291_40f7c00b80_o_d.jpg"); allSha1s.push_back("my_Sha1_Is_Garbage_And_It_Should_Trigger_An_Error"); } if(key == '3'){ allURLS.push_back("http://farm8.staticflickr.com/7420/10032530563_86ff701d19_o.jpg"); allURLS.push_back("http://farm3.staticflickr.com/2877/9481432451_c74c649515_o_d.jpg"); allURLS.push_back("http://farm4.staticflickr.com/3702/9484220536_8f5a866b4d_o_d.jpg"); allURLS.push_back("http://farm4.staticflickr.com/3667/9484488930_2c6527ee35_o_d.jpg"); allURLS.push_back("http://farm3.staticflickr.com/2857/9481682413_5f251ba22d_o_d.jpg"); allURLS.push_back("http://farm8.staticflickr.com/7438/9481688475_e83f92e8b5_o_d.jpg"); } if (key >= '1' && key <= '2'){ downloader.downloadResources(allURLS, allSha1s, this, &ofApp::downloadFinished, "downloads_" ); downloader.startDownloading(); }else if(key == '3'){ for(int i = 0; i < allURLS.size(); i++){ downloader.downloadResources(allURLS[i], this, &ofApp::downloadFinished, "downloads_" ); } downloader.startDownloading(); } if(key == 'c'){ downloader.cancelCurrentDownload(); } if(key == 'C'){ downloader.cancelAllDownloads(); } }
#include "ofApp.h" void ofApp::setup(){ ofSetFrameRate(60); ofBackground(22); ofSetWindowPosition(20, 20); downloader.setNeedsChecksumMatchToSkipDownload(true); downloader.setIdleTimeAfterEachDownload(0.2); downloader.setVerbose(false); downloader.setMaxConcurrentDownloads(3); } void ofApp::downloadFinished(ofxBatchDownloaderReport &report){ cout << "#################################################" << endl; cout << "#### download finished!!" << endl; cout << "#### [ " << report.attemptedDownloads.size() << " attempted | " ; if(report.wasCanceled){ cout << "#### Download Was CANCELED BY USER!" << endl; } cout << report.failedDownloads.size() << " failed | "; cout << report.successfulDownloads.size() << " ok ]" << endl; for(int i = 0; i < report.responses.size(); i++){ ofxSimpleHttpResponse r = report.responses[i]; r.print(); } bool ok = false; int i = 0; while (!ok && i < rep
allURLS, allSha1s, this, &ofApp::downloadFinished, "downloads_" ); downloader.startDownloading(); }else if(key == '3'){ for(int i = 0; i < allURLS.size(); i++){ downloader.downloadResources(allURLS[i], this, &ofApp::downloadFinished, "downloads_" ); } downloader.startDownloading(); } if(key == 'c'){ downloader.cancelCurrentDownload(); } if(key == 'C'){ downloader.cancelAllDownloads(); } }
ort.responses.size()){ if (report.responses[i].ok){ } i++; } } void ofApp::update(){ downloader.update(); } void ofApp::draw(){ ofSetColor(255); drawClock(); downloader.draw(30,30, true, false); string msg = "press 1 to download a file and supply a correct SHA1\n"; msg += "press 2 to download a file and supply an incorrect SHA1\n"; msg += "press 3 to download a few files without supplying a SHA1\n"; msg += "press c to cancel current download\n"; msg += "press C to cancel all downloads\n"; ofDrawBitmapString(msg, 20, ofGetHeight() - 70); } void ofApp::drawClock(){ ofPushMatrix(); ofTranslate(ofGetWidth() - 60,60, 0); ofRotate( ofGetFrameNum() * 3, 0,0,1); ofSetColor(255,255,255); float h = 5; ofRect(-h/2,h/2, h,50); ofPopMatrix(); } void ofApp::keyPressed(int key){ vector<string> allURLS; vector<string> allSha1s; if(key == '1'){ allURLS.push_back("http://farm3.staticflickr.com/2875/9481775605_ea43f5d4f3_o_d.jpg"); allSha1s.push_back("852a7952aabcbf3479974d5350f973b005b23c4a"); } if(key == '2'){ allURLS.push_back("http://farm8.staticflickr.com/7454/9481666291_40f7c00b80_o_d.jpg"); allSha1s.push_back("my_Sha1_Is_Garbage_And_It_Should_Trigger_An_Error"); } if(key == '3'){ allURLS.push_back("http://farm8.staticflickr.com/7420/10032530563_86ff701d19_o.jpg"); allURLS.push_back("http://farm3.staticflickr.com/2877/9481432451_c74c649515_o_d.jpg"); allURLS.push_back("http://farm4.staticflickr.com/3702/9484220536_8f5a866b4d_o_d.jpg"); allURLS.push_back("http://farm4.staticflickr.com/3667/9484488930_2c6527ee35_o_d.jpg"); allURLS.push_back("http://farm3.staticflickr.com/2857/9481682413_5f251ba22d_o_d.jpg"); allURLS.push_back("http://farm8.staticflickr.com/7438/9481688475_e83f92e8b5_o_d.jpg"); } if (key >= '1' && key <= '2'){ downloader.downloadResources(
random
[ { "content": "struct ofxBatchDownloaderReport{\n\n\tstd::string downloadPath;\t\t\t\t\t\t//full path to the directory that holds the downloads\n\n\tofxBatchDownloader* owner;\t\t\t\t\t//pointer to the object in charge of the downloads\n\n\tstd::vector<std::string> attemptedDownloads;\t\t\t//this vector contains...
C++
lizy1.kurisu/include/lizy1/impl/kurisu/BuiltInCase.hpp
li-zhong-yuan/lizy1.kurisu
dba9136bfc966e2e81bee2b469ae4cc3a8157ca4
namespace lizy1::kurisu::impl_K { template<class T> constexpr std::uint64_t fundamental_digest() { if constexpr(std::same_as<T, std::nullptr_t>) return 0x0000000000000000; if constexpr(_in<T, _P<signed char, unsigned char>>::value) return 0x3CFE619CFCD8B82B; if constexpr(_in<T, _P<std::int64_t, std::uint64_t>>::value) return 0x66128932B8AD5CC4; if constexpr(std::same_as<T, float>) return 0x7610A451BF5CF3B4; if constexpr(std::same_as<T, double>) return 0x811C5E393414342A; if constexpr(std::same_as<T, long double>) return 0x4B0070DF621771A5; } } template<lizy1::kurisu::Nullptr T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { static constexpr std::uint64_t __digest__() { return fundamental_digest<T>(); } template<class Os> static void __dump__(Os &, T const&) {} template<class Is> static void __load__(Is &, T &) {} }; template<lizy1::kurisu::Integral T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { protected: using bA = typename std::is_signed<T>::type; using bB = _in<T, type::_P<bool, char, signed char, \ unsigned char, std::int8_t, std::uint8_t>>; using tC = _C<bA::value, signed char, unsigned char>; using tD = _C<bA::value, std::int64_t, std::uint64_t>; using tE = _C<bB::value, tC, tD>; public: static constexpr std::uint64_t __digest__() { return fundamental_digest<tE>(); } template<OStream Os> static void __dump__(Os &os, T const& t) { dump_machine_bytes(os, static_cast<tE>(t)); } template<IStream Is> static void __load__(Is &is, T & t) { t = static_cast<T>(load_machine_bytes<tE>(is)); } }; template<lizy1::kurisu::FloatingPoint T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { static constexpr std::uint64_t __digest__() { return fundamental_digest<T>(); } template<OStream Os> static void __dump__(Os &os, T const& t) { dump_machine_bytes(os, t); } template<IStream Is> static void __load__(Is &is, T & t) { load_machine_bytes(is, t); } }; template<lizy1::kurisu::Enumeration T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { using U = std::underlying_type_t<T>; static constexpr std::uint64_t __digest__() { return digest<U>(); } template<OStream Os> static void __dump__(Os &os, T const& t) { dump(os, static_cast<U>(t)); } template<IStream Is> static void __load__(Is &is, T & t) { t = T{ construct<U>(is) }; } }; template<lizy1::kurisu::Array T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { using U = type::_Ur<decltype(std::declval<T &>()[0])>; static constexpr std::uint64_t __digest__() { constexpr std::uint64_t feature_code = 0xDEBB5C656EBA9F75; constexpr std::uint64_t element_digest = digest<U>(); constexpr std::uint64_t size = sizeof(T) / sizeof(U); return combine_digests({ feature_code, element_digest, size }); } template<class Os> requires Dumpable<const U, Os> static void __dump__(Os &os, T const& t) { for(auto &x : t) dump(os, x); } template<class Os> requires Dumpable<U , Os> static void __dump__(Os &os, T & t) { for(auto &x : t) dump(os, x); } template<class Is> requires Loadable<U , Is> static void __load__(Is &is, T & t) { for(auto &x : t) load(is, x); } }; namespace lizy1::kurisu::impl_K { template<class Is, class... Ts> \ constexpr bool is_aggregate_constructible(std::tuple<Ts...> *) \ { return (Constructible<_Ucr<Ts>, Is> && ...); } template<class T, class Is, class... Ts> \ inline T construct_aggregate(Is &is, std::tuple<Ts...> *) \ { return T{ construct<_A<Ts>>(is)... }; } } template<lizy1::kurisu::Aggregate T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { static constexpr std::uint64_t __digest__() \ { return digest<decltype(unpack(std::declval<T &>()))>(); } template<class Os> \ requires requires(T const& t) { { unpack(t) } -> Dumpable<Os>; } \ static void __dump__(Os &os, T const& t) { dump(os, unpack(t)); } template<class Os> \ requires requires(T &t) { { unpack(t) } -> Dumpable<Os>; } \ static void __dump__(Os &os, T &t) { dump(os, unpack(t)); } template<class Is> \ requires requires(T &t) { { unpack(t) } -> Loadable<Is>; } \ static void __load__(Is &is, T &t) { load(is, unpack(t)); } template<class Is> requires (is_aggregate_constructible<Is>((decltype(unpack(std::declval<T &>())) *)0)) static T __construct__(Is &is) { return construct_aggregate<T>(is, (decltype(unpack(std::declval<T &>())) *)0); } };
namespace lizy1::kurisu::impl_K { template<class T> constexpr std::uint64_t fundamental_digest() { if constexpr(std::same_as<T, std::nullptr_t>) return 0x0000000000000000; if constexpr(_in<T, _P<signed char, unsigned char>>::value) return 0x3CFE619CFCD8B82B; if constexpr(_in<T, _P<std::int64_t, std::uint64_t>>::value) return 0x66128932B8AD5CC4; if constexpr(std::same_as<T, float>) return 0x7610A451BF5CF3B4; if constexpr(std::same_as<T, double>) return 0x811C5E393414342A; if constexpr(std::same_as<T, long double>) return 0x4B0070DF621771A5; } } template<lizy1::kurisu::Nullptr T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { static constexpr std::uint64_t __digest__() { return fundamental_digest<T>(); } template<class Os> static void __dump__(Os &, T const&) {} template<class Is> static void __load__(Is &, T &) {} }; template<lizy1::kurisu::Integral T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { protected: using bA = typename std::is_signed<T>::type; using bB = _in<T, type::_P<bool, char, signed char, \ unsigned char, std::int8_t, std::uint8_t>>; using tC = _C<bA::value, signed char, unsigned char>; using tD = _C<bA::value, std::int64_t, std::uint64_t>; using tE = _C<bB::value, tC, tD>; public: static constexpr std::uint64_t __digest__() { return fundamental_digest<tE>(); } template<OStream Os> static void __dump__(Os &os, T const& t) { dump_machine_bytes(os, static_cast<tE>(t)); } template<IStream Is> static void __load__(Is &is, T & t) { t = static_cast<T>(load_machine_bytes<tE>(is)); } }; template<lizy1::kurisu::FloatingPoint T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { static constexpr std::uint64_t __digest__() { return fundamental_digest<T>(
constexpr std::uint64_t size = sizeof(T) / sizeof(U); return combine_digests({ feature_code, element_digest, size }); } template<class Os> requires Dumpable<const U, Os> static void __dump__(Os &os, T const& t) { for(auto &x : t) dump(os, x); } template<class Os> requires Dumpable<U , Os> static void __dump__(Os &os, T & t) { for(auto &x : t) dump(os, x); } template<class Is> requires Loadable<U , Is> static void __load__(Is &is, T & t) { for(auto &x : t) load(is, x); } }; namespace lizy1::kurisu::impl_K { template<class Is, class... Ts> \ constexpr bool is_aggregate_constructible(std::tuple<Ts...> *) \ { return (Constructible<_Ucr<Ts>, Is> && ...); } template<class T, class Is, class... Ts> \ inline T construct_aggregate(Is &is, std::tuple<Ts...> *) \ { return T{ construct<_A<Ts>>(is)... }; } } template<lizy1::kurisu::Aggregate T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { static constexpr std::uint64_t __digest__() \ { return digest<decltype(unpack(std::declval<T &>()))>(); } template<class Os> \ requires requires(T const& t) { { unpack(t) } -> Dumpable<Os>; } \ static void __dump__(Os &os, T const& t) { dump(os, unpack(t)); } template<class Os> \ requires requires(T &t) { { unpack(t) } -> Dumpable<Os>; } \ static void __dump__(Os &os, T &t) { dump(os, unpack(t)); } template<class Is> \ requires requires(T &t) { { unpack(t) } -> Loadable<Is>; } \ static void __load__(Is &is, T &t) { load(is, unpack(t)); } template<class Is> requires (is_aggregate_constructible<Is>((decltype(unpack(std::declval<T &>())) *)0)) static T __construct__(Is &is) { return construct_aggregate<T>(is, (decltype(unpack(std::declval<T &>())) *)0); } };
); } template<OStream Os> static void __dump__(Os &os, T const& t) { dump_machine_bytes(os, t); } template<IStream Is> static void __load__(Is &is, T & t) { load_machine_bytes(is, t); } }; template<lizy1::kurisu::Enumeration T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { using U = std::underlying_type_t<T>; static constexpr std::uint64_t __digest__() { return digest<U>(); } template<OStream Os> static void __dump__(Os &os, T const& t) { dump(os, static_cast<U>(t)); } template<IStream Is> static void __load__(Is &is, T & t) { t = T{ construct<U>(is) }; } }; template<lizy1::kurisu::Array T> struct lizy1::kurisu::impl_K::BuiltInCase<T> { using U = type::_Ur<decltype(std::declval<T &>()[0])>; static constexpr std::uint64_t __digest__() { constexpr std::uint64_t feature_code = 0xDEBB5C656EBA9F75; constexpr std::uint64_t element_digest = digest<U>();
random
[]
C++
ttk/core/vtk/ttkFiberSurface/ttkFiberSurface.cpp
julesvidal/wasserstein-pd-barycenter
1f62a5e1c40700030357b2bfb9a2f86fe4736861
#include <ttkFiberSurface.h> using namespace std; using namespace ttk; vtkStandardNewMacro(ttkFiberSurface) ttkFiberSurface::ttkFiberSurface(){ UseAllCores = true; RangeCoordinates = true; EdgeParameterization = true; EdgeIds = true; TetIds = true; CaseIds = true; PointMerge = false; RangeOctree = true; PointMergeDistanceThreshold = 0.000001; SetNumberOfInputPorts(2); } ttkFiberSurface::~ttkFiberSurface(){ } int ttkFiberSurface::doIt(vector<vtkDataSet *> &inputs, vector<vtkDataSet *> &outputs){ Memory m; Timer t; vtkDataSet *input = inputs[0]; vtkUnstructuredGrid *polygon = vtkUnstructuredGrid::SafeDownCast(inputs[1]); vtkPolyData *output = vtkPolyData::SafeDownCast(outputs[0]); vtkDataArray *dataUfield = NULL, *dataVfield = NULL, *polygonUfield = NULL, *polygonVfield = NULL; if(DataUcomponent.length()){ dataUfield = input->GetPointData()->GetArray(DataUcomponent.data()); } else{ dataUfield = input->GetPointData()->GetArray(0); } if(!dataUfield){ stringstream msg; msg << "[ttkFiberSurface] Error1: Could not find data array '" << DataUcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -1; } if(DataVcomponent.length()){ dataVfield = input->GetPointData()->GetArray(DataVcomponent.data()); } else{ dataVfield = input->GetPointData()->GetArray(0); } if(!dataVfield){ stringstream msg; msg << "[ttkFiberSurface] Error2: Could not find data array '" << DataVcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -2; } if(PolygonUcomponent.length()){ polygonUfield = polygon->GetPointData()->GetArray(PolygonUcomponent.data()); } else{ polygonUfield = polygon->GetPointData()->GetArray(0); } if(!polygonUfield){ stringstream msg; msg << "[ttkFiberSurface] Error3: Could not find data array '" << PolygonUcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -3; } if(PolygonVcomponent.length()){ polygonVfield = polygon->GetPointData()->GetArray(PolygonVcomponent.data()); } else{ polygonVfield = polygon->GetPointData()->GetArray(0); } if(!polygonVfield){ stringstream msg; msg << "[ttkFiberSurface] Error4: Could not find data array '" << PolygonVcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -4; } if(!((input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID) ||(input->GetDataObjectType() == VTK_IMAGE_DATA))){ stringstream msg; msg << "[ttkFiberSurface] Error5: Unsupported VTK data-structure (" << input->GetDataObjectType() << ")" << endl; dMsg(cerr, msg.str(), fatalMsg); return -5; } Triangulation *triangulation = ttkTriangulation::getTriangulation(input); if(!triangulation) return -1; triangulation->setWrapper(this); fiberSurface_.setupTriangulation(triangulation); fiberSurface_.setWrapper(this); outputVertexList_.clear(); fiberSurface_.setGlobalVertexList(&outputVertexList_); fiberSurface_.setInputField( dataUfield->GetVoidPointer(0), dataVfield->GetVoidPointer(0)); fiberSurface_.setPolygonEdgeNumber(polygon->GetNumberOfCells()); threadedTriangleList_.resize(polygon->GetNumberOfCells()); threadedVertexList_.resize(polygon->GetNumberOfCells()); fiberSurface_.setPolygon(&inputPolygon_); fiberSurface_.setPointMerging(PointMerge); fiberSurface_.setPointMergingThreshold(PointMergeDistanceThreshold); #ifdef TTK_ENABLE_FIBER_SURFACE_WITH_RANGE_OCTREE if((!RangeOctree) ||(dataUfield->GetMTime() > GetMTime()) ||(dataVfield->GetMTime() > GetMTime())){ { stringstream msg; msg << "[ttkFiberSurface] Resetting octree..." << endl; dMsg(cout, msg.str(), infoMsg); } fiberSurface_.flushOctree(); Modified(); } #endif inputPolygon_.clear(); #if !defined(_WIN32) || defined(_WIN32) && defined(VTK_USE_64BIT_IDS) const long long int *cellArray = polygon->GetCells()->GetPointer(); #else int* pt = polygon->GetCells()->GetPointer(); long long extra_pt = *pt; const long long int *cellArray = &extra_pt; #endif SimplexId cellNumber = polygon->GetNumberOfCells(); SimplexId vertexId0, vertexId1; pair<pair<double, double>, pair<double, double> > rangeEdge; for(SimplexId i = 0; i < cellNumber; i++){ vertexId0 = cellArray[3*i + 1]; vertexId1 = cellArray[3*i + 2]; rangeEdge.first.first = polygonUfield->GetTuple1(vertexId0); rangeEdge.first.second = polygonVfield->GetTuple1(vertexId0); rangeEdge.second.first = polygonUfield->GetTuple1(vertexId1); rangeEdge.second.second = polygonVfield->GetTuple1(vertexId1); inputPolygon_.push_back(rangeEdge); } for(SimplexId i = 0; i < (SimplexId) threadedTriangleList_.size(); i++){ threadedTriangleList_[i].clear(); fiberSurface_.setTriangleList(i, &(threadedTriangleList_[i])); threadedVertexList_[i].clear(); fiberSurface_.setVertexList(i, &(threadedVertexList_[i])); } #ifdef TTK_ENABLE_FIBER_SURFACE_WITH_RANGE_OCTREE switch(vtkTemplate2PackMacro(dataUfield->GetDataType(), dataVfield->GetDataType())){ ttkTemplate2Macro({ if (RangeOctree) fiberSurface_.buildOctree<VTK_T1 TTK_COMMA VTK_T2>(); fiberSurface_.computeSurface<VTK_T1 TTK_COMMA VTK_T2>(); }); } #else switch(vtkTemplate2PackMacro(dataUfield->GetDataType(), dataVfield->GetDataType())){ ttkTemplate2Macro(fiberSurface_.computeSurface<VTK_T1 TTK_COMMA VTK_T2>()); } #endif SimplexId triangleNumber = 0; for(SimplexId i = 0; i < (SimplexId) threadedTriangleList_.size(); i++){ triangleNumber += threadedTriangleList_[i].size(); } vtkSmartPointer<vtkPoints> outputVertexList = vtkSmartPointer<vtkPoints>::New(); vtkSmartPointer<vtkDoubleArray> outputU = vtkSmartPointer<vtkDoubleArray>::New(); vtkSmartPointer<vtkDoubleArray> outputV = vtkSmartPointer<vtkDoubleArray>::New(); vtkSmartPointer<vtkDoubleArray> outputParameterization = vtkSmartPointer<vtkDoubleArray>::New(); vtkSmartPointer<vtkCellArray> outputTriangleList = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<ttkSimplexIdTypeArray> outputEdgeIds = vtkSmartPointer<ttkSimplexIdTypeArray>::New(); vtkSmartPointer<ttkSimplexIdTypeArray> outputTetIds = vtkSmartPointer<ttkSimplexIdTypeArray>::New(); vtkSmartPointer<ttkSimplexIdTypeArray> outputCaseIds = vtkSmartPointer<ttkSimplexIdTypeArray>::New(); if(RangeCoordinates){ outputU->SetName(DataUcomponent.data()); outputU->SetNumberOfTuples(outputVertexList_.size()); outputV->SetName(DataVcomponent.data()); outputV->SetNumberOfTuples(outputVertexList_.size()); } if(EdgeParameterization){ outputParameterization->SetName("EdgeParameterization"); outputParameterization->SetNumberOfTuples(outputVertexList_.size()); } outputVertexList->SetNumberOfPoints(outputVertexList_.size()); output->SetPoints(outputVertexList); #ifdef TTK_ENABLE_OPENMP #pragma omp parallel for num_threads(threadNumber_) #endif for(SimplexId i = 0; i < (SimplexId) outputVertexList_.size(); i++){ outputVertexList->SetPoint(i, outputVertexList_[i].p_[0], outputVertexList_[i].p_[1], outputVertexList_[i].p_[2]); if(RangeCoordinates){ outputU->SetTuple1(i, outputVertexList_[i].uv_.first); outputV->SetTuple1(i, outputVertexList_[i].uv_.second); } if(EdgeParameterization){ outputParameterization->SetTuple1(i, outputVertexList_[i].t_); } } if(RangeCoordinates){ output->GetPointData()->AddArray(outputU); output->GetPointData()->AddArray(outputV); } else{ output->GetPointData()->RemoveArray(DataUcomponent.data()); output->GetPointData()->RemoveArray(DataVcomponent.data()); } if(EdgeParameterization){ output->GetPointData()->AddArray(outputParameterization); } else{ output->GetPointData()->RemoveArray("EdgeParameterization"); } if(EdgeIds){ outputEdgeIds->SetName("EdgeIds"); outputEdgeIds->SetNumberOfTuples(triangleNumber); } if(TetIds){ outputTetIds->SetName("TetIds"); outputTetIds->SetNumberOfTuples(triangleNumber); } if(CaseIds){ outputCaseIds->SetName("CaseIds"); outputCaseIds->SetNumberOfTuples(triangleNumber); } vtkSmartPointer<vtkIdList> idList = vtkSmartPointer<vtkIdList>::New(); idList->SetNumberOfIds(3); triangleNumber = 0; for(SimplexId i = 0; i < (SimplexId) threadedTriangleList_.size(); i++){ for(SimplexId j = 0; j < (SimplexId) threadedTriangleList_[i].size(); j++){ for(int k = 0; k < 3; k++){ idList->SetId(k, threadedTriangleList_[i][j].vertexIds_[k]); } outputTriangleList->InsertNextCell(idList); if(EdgeIds){ outputEdgeIds->SetTuple1(triangleNumber, i); } if(TetIds){ outputTetIds->SetTuple1(triangleNumber, threadedTriangleList_[i][j].tetId_); } if(CaseIds){ outputCaseIds->SetTuple1(triangleNumber, threadedTriangleList_[i][j].caseId_); } triangleNumber++; } } output->SetPolys(outputTriangleList); if(EdgeIds){ output->GetCellData()->AddArray(outputEdgeIds); } else{ output->GetCellData()->RemoveArray("EdgeIds"); } if(TetIds){ output->GetCellData()->AddArray(outputTetIds); } else{ output->GetCellData()->RemoveArray("TetIds"); } if(CaseIds){ output->GetCellData()->AddArray(outputCaseIds); } else{ output->GetCellData()->RemoveArray("CaseIds"); } { stringstream msg; msg << "[ttkFiberSurface] Memory usage: " << m.getElapsedUsage() << " MB." << endl; dMsg(cout, msg.str(), memoryMsg); } return 0; }
#include <ttkFiberSurface.h> using namespace std; using namespace ttk; vtkStandardNewMacro(ttkFiberSurface) ttkFiberSurface::ttkFiberSurface(){ UseAllCores = true; RangeCoordinates = true; EdgeParameterization = true; EdgeIds = true; TetIds = true; CaseIds =
ttkFiberSurface::~ttkFiberSurface(){ } int ttkFiberSurface::doIt(vector<vtkDataSet *> &inputs, vector<vtkDataSet *> &outputs){ Memory m; Timer t; vtkDataSet *input = inputs[0]; vtkUnstructuredGrid *polygon = vtkUnstructuredGrid::SafeDownCast(inputs[1]); vtkPolyData *output = vtkPolyData::SafeDownCast(outputs[0]); vtkDataArray *dataUfield = NULL, *dataVfield = NULL, *polygonUfield = NULL, *polygonVfield = NULL; if(DataUcomponent.length()){ dataUfield = input->GetPointData()->GetArray(DataUcomponent.data()); } else{ dataUfield = input->GetPointData()->GetArray(0); } if(!dataUfield){ stringstream msg; msg << "[ttkFiberSurface] Error1: Could not find data array '" << DataUcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -1; } if(DataVcomponent.length()){ dataVfield = input->GetPointData()->GetArray(DataVcomponent.data()); } else{ dataVfield = input->GetPointData()->GetArray(0); } if(!dataVfield){ stringstream msg; msg << "[ttkFiberSurface] Error2: Could not find data array '" << DataVcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -2; } if(PolygonUcomponent.length()){ polygonUfield = polygon->GetPointData()->GetArray(PolygonUcomponent.data()); } else{ polygonUfield = polygon->GetPointData()->GetArray(0); } if(!polygonUfield){ stringstream msg; msg << "[ttkFiberSurface] Error3: Could not find data array '" << PolygonUcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -3; } if(PolygonVcomponent.length()){ polygonVfield = polygon->GetPointData()->GetArray(PolygonVcomponent.data()); } else{ polygonVfield = polygon->GetPointData()->GetArray(0); } if(!polygonVfield){ stringstream msg; msg << "[ttkFiberSurface] Error4: Could not find data array '" << PolygonVcomponent << "'!" << endl; dMsg(cerr, msg.str(), fatalMsg); return -4; } if(!((input->GetDataObjectType() == VTK_UNSTRUCTURED_GRID) ||(input->GetDataObjectType() == VTK_IMAGE_DATA))){ stringstream msg; msg << "[ttkFiberSurface] Error5: Unsupported VTK data-structure (" << input->GetDataObjectType() << ")" << endl; dMsg(cerr, msg.str(), fatalMsg); return -5; } Triangulation *triangulation = ttkTriangulation::getTriangulation(input); if(!triangulation) return -1; triangulation->setWrapper(this); fiberSurface_.setupTriangulation(triangulation); fiberSurface_.setWrapper(this); outputVertexList_.clear(); fiberSurface_.setGlobalVertexList(&outputVertexList_); fiberSurface_.setInputField( dataUfield->GetVoidPointer(0), dataVfield->GetVoidPointer(0)); fiberSurface_.setPolygonEdgeNumber(polygon->GetNumberOfCells()); threadedTriangleList_.resize(polygon->GetNumberOfCells()); threadedVertexList_.resize(polygon->GetNumberOfCells()); fiberSurface_.setPolygon(&inputPolygon_); fiberSurface_.setPointMerging(PointMerge); fiberSurface_.setPointMergingThreshold(PointMergeDistanceThreshold); #ifdef TTK_ENABLE_FIBER_SURFACE_WITH_RANGE_OCTREE if((!RangeOctree) ||(dataUfield->GetMTime() > GetMTime()) ||(dataVfield->GetMTime() > GetMTime())){ { stringstream msg; msg << "[ttkFiberSurface] Resetting octree..." << endl; dMsg(cout, msg.str(), infoMsg); } fiberSurface_.flushOctree(); Modified(); } #endif inputPolygon_.clear(); #if !defined(_WIN32) || defined(_WIN32) && defined(VTK_USE_64BIT_IDS) const long long int *cellArray = polygon->GetCells()->GetPointer(); #else int* pt = polygon->GetCells()->GetPointer(); long long extra_pt = *pt; const long long int *cellArray = &extra_pt; #endif SimplexId cellNumber = polygon->GetNumberOfCells(); SimplexId vertexId0, vertexId1; pair<pair<double, double>, pair<double, double> > rangeEdge; for(SimplexId i = 0; i < cellNumber; i++){ vertexId0 = cellArray[3*i + 1]; vertexId1 = cellArray[3*i + 2]; rangeEdge.first.first = polygonUfield->GetTuple1(vertexId0); rangeEdge.first.second = polygonVfield->GetTuple1(vertexId0); rangeEdge.second.first = polygonUfield->GetTuple1(vertexId1); rangeEdge.second.second = polygonVfield->GetTuple1(vertexId1); inputPolygon_.push_back(rangeEdge); } for(SimplexId i = 0; i < (SimplexId) threadedTriangleList_.size(); i++){ threadedTriangleList_[i].clear(); fiberSurface_.setTriangleList(i, &(threadedTriangleList_[i])); threadedVertexList_[i].clear(); fiberSurface_.setVertexList(i, &(threadedVertexList_[i])); } #ifdef TTK_ENABLE_FIBER_SURFACE_WITH_RANGE_OCTREE switch(vtkTemplate2PackMacro(dataUfield->GetDataType(), dataVfield->GetDataType())){ ttkTemplate2Macro({ if (RangeOctree) fiberSurface_.buildOctree<VTK_T1 TTK_COMMA VTK_T2>(); fiberSurface_.computeSurface<VTK_T1 TTK_COMMA VTK_T2>(); }); } #else switch(vtkTemplate2PackMacro(dataUfield->GetDataType(), dataVfield->GetDataType())){ ttkTemplate2Macro(fiberSurface_.computeSurface<VTK_T1 TTK_COMMA VTK_T2>()); } #endif SimplexId triangleNumber = 0; for(SimplexId i = 0; i < (SimplexId) threadedTriangleList_.size(); i++){ triangleNumber += threadedTriangleList_[i].size(); } vtkSmartPointer<vtkPoints> outputVertexList = vtkSmartPointer<vtkPoints>::New(); vtkSmartPointer<vtkDoubleArray> outputU = vtkSmartPointer<vtkDoubleArray>::New(); vtkSmartPointer<vtkDoubleArray> outputV = vtkSmartPointer<vtkDoubleArray>::New(); vtkSmartPointer<vtkDoubleArray> outputParameterization = vtkSmartPointer<vtkDoubleArray>::New(); vtkSmartPointer<vtkCellArray> outputTriangleList = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<ttkSimplexIdTypeArray> outputEdgeIds = vtkSmartPointer<ttkSimplexIdTypeArray>::New(); vtkSmartPointer<ttkSimplexIdTypeArray> outputTetIds = vtkSmartPointer<ttkSimplexIdTypeArray>::New(); vtkSmartPointer<ttkSimplexIdTypeArray> outputCaseIds = vtkSmartPointer<ttkSimplexIdTypeArray>::New(); if(RangeCoordinates){ outputU->SetName(DataUcomponent.data()); outputU->SetNumberOfTuples(outputVertexList_.size()); outputV->SetName(DataVcomponent.data()); outputV->SetNumberOfTuples(outputVertexList_.size()); } if(EdgeParameterization){ outputParameterization->SetName("EdgeParameterization"); outputParameterization->SetNumberOfTuples(outputVertexList_.size()); } outputVertexList->SetNumberOfPoints(outputVertexList_.size()); output->SetPoints(outputVertexList); #ifdef TTK_ENABLE_OPENMP #pragma omp parallel for num_threads(threadNumber_) #endif for(SimplexId i = 0; i < (SimplexId) outputVertexList_.size(); i++){ outputVertexList->SetPoint(i, outputVertexList_[i].p_[0], outputVertexList_[i].p_[1], outputVertexList_[i].p_[2]); if(RangeCoordinates){ outputU->SetTuple1(i, outputVertexList_[i].uv_.first); outputV->SetTuple1(i, outputVertexList_[i].uv_.second); } if(EdgeParameterization){ outputParameterization->SetTuple1(i, outputVertexList_[i].t_); } } if(RangeCoordinates){ output->GetPointData()->AddArray(outputU); output->GetPointData()->AddArray(outputV); } else{ output->GetPointData()->RemoveArray(DataUcomponent.data()); output->GetPointData()->RemoveArray(DataVcomponent.data()); } if(EdgeParameterization){ output->GetPointData()->AddArray(outputParameterization); } else{ output->GetPointData()->RemoveArray("EdgeParameterization"); } if(EdgeIds){ outputEdgeIds->SetName("EdgeIds"); outputEdgeIds->SetNumberOfTuples(triangleNumber); } if(TetIds){ outputTetIds->SetName("TetIds"); outputTetIds->SetNumberOfTuples(triangleNumber); } if(CaseIds){ outputCaseIds->SetName("CaseIds"); outputCaseIds->SetNumberOfTuples(triangleNumber); } vtkSmartPointer<vtkIdList> idList = vtkSmartPointer<vtkIdList>::New(); idList->SetNumberOfIds(3); triangleNumber = 0; for(SimplexId i = 0; i < (SimplexId) threadedTriangleList_.size(); i++){ for(SimplexId j = 0; j < (SimplexId) threadedTriangleList_[i].size(); j++){ for(int k = 0; k < 3; k++){ idList->SetId(k, threadedTriangleList_[i][j].vertexIds_[k]); } outputTriangleList->InsertNextCell(idList); if(EdgeIds){ outputEdgeIds->SetTuple1(triangleNumber, i); } if(TetIds){ outputTetIds->SetTuple1(triangleNumber, threadedTriangleList_[i][j].tetId_); } if(CaseIds){ outputCaseIds->SetTuple1(triangleNumber, threadedTriangleList_[i][j].caseId_); } triangleNumber++; } } output->SetPolys(outputTriangleList); if(EdgeIds){ output->GetCellData()->AddArray(outputEdgeIds); } else{ output->GetCellData()->RemoveArray("EdgeIds"); } if(TetIds){ output->GetCellData()->AddArray(outputTetIds); } else{ output->GetCellData()->RemoveArray("TetIds"); } if(CaseIds){ output->GetCellData()->AddArray(outputCaseIds); } else{ output->GetCellData()->RemoveArray("CaseIds"); } { stringstream msg; msg << "[ttkFiberSurface] Memory usage: " << m.getElapsedUsage() << " MB." << endl; dMsg(cout, msg.str(), memoryMsg); } return 0; }
true; PointMerge = false; RangeOctree = true; PointMergeDistanceThreshold = 0.000001; SetNumberOfInputPorts(2); }
function_block-function_prefixed
[ { "content": " class AtomicVector : public std::vector<type>\n\n {\n\n private:\n\n std::size_t nextId;\n\n // for initialization\n\n const type defaultValue;\n\n\n\n public:\n\n AtomicVector(const std::size_t initSize = 1, const type &dv = type{})\n\n : std::vector<type...
C++
src/GrainViewer/Ui/Gui.cpp
eliemichel/GrainViewer
91d4922b3185ada90508f0944f2691ba8eba45e3
#include <OpenGL> #include "Logger.h" #include "Gui.h" #include "Window.h" #include "Scene.h" #include "Dialog.h" #include "RuntimeObject.h" #include "ShaderPool.h" #include "GlobalTimer.h" #include "Ui/SceneDialog.h" #include "Ui/DeferredShadingDialog.h" #include "Ui/WorldDialog.h" #include "Ui/GlobalTimerDialog.h" #include <GLFW/glfw3.h> #include <imgui.h> #include "imgui_impl_glfw.h" #include "imgui_impl_opengl3.h" #include <iostream> using namespace std; #include "LightGizmoDialog.h" #include "FarGrainRendererDialog.h" #include "TransformDialog.h" #include "PointCloudSplitterDialog.h" #include "InstanceGrainRendererDialog.h" #include "ImpostorGrainRendererDialog.h" #include "GrainBehaviorDialog.h" #include "MeshRendererDialog.h" #include "QuadMeshDataDialog.h" static std::shared_ptr<Dialog> makeComponentDialog(std::string type, std::shared_ptr<Behavior> component) { #define handleBehavior(T) \ if (type == BehaviorRegistryEntry<T>::Name()) { \ auto dialog = DialogFactory<T>().MakeShared(); \ dialog->setControlledBehavior(std::dynamic_pointer_cast<T>(component)); \ return std::dynamic_pointer_cast<Dialog>(dialog); \ } handleBehavior(LightGizmo); handleBehavior(FarGrainRenderer); handleBehavior(TransformBehavior); handleBehavior(PointCloudSplitter); handleBehavior(InstanceGrainRenderer); handleBehavior(ImpostorGrainRenderer); handleBehavior(GrainBehavior); handleBehavior(MeshRenderer); handleBehavior(QuadMeshData); return nullptr; #undef handleType } void Gui::Init(const Window & window) { IMGUI_CHECKVERSION(); ImGui::CreateContext(); ImGuiIO& io = ImGui::GetIO(); (void)io; ImGui_ImplGlfw_InitForOpenGL(window.glfw(), true); ImGui_ImplOpenGL3_Init("#version 150"); ImGui::GetStyle().WindowRounding = 0.0f; } void Gui::NewFrame() { ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame(); } void Gui::DrawFrame() { ImGui::Render(); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); } void Gui::Shutdown() { ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); } static void printUsage() { cerr << "GrainViewer -- real time grain viewer" << endl << "Author : Élie Michel (http://perso.telecom-paristech.fr/~emichel)" << endl << endl << "Keyboard commands" << endl << "------------------" << endl << " r: Reload shaders" << endl << " ctrl+r: Reload scene" << endl << " p: Toggle panel" << endl << " a: Tilt camera left" << endl << " e: Tilt camera right" << endl << " d: Switch deferred shading on/off" << endl << " c: Print camera matrix (row major)" << endl << " <space>: Pause physics" << endl << " ?: Print help" << endl << " q, <esc>: Quit" << endl << endl; } static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onKey(key, scancode, action, mode); } static void cursor_pos_callback(GLFWwindow* window, double x, double y) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onCursorPosition(x, y); } static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onMouseButton(button, action, mods); } static void window_size_callback(GLFWwindow* window, int width, int height) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onResize(width, height); } static void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onScroll(xoffset, yoffset); } void Gui::setupCallbacks() { if (auto window = m_window.lock()) { glfwSetWindowUserPointer(window->glfw(), static_cast<void*>(this)); glfwSetKeyCallback(window->glfw(), key_callback); glfwSetCursorPosCallback(window->glfw(), cursor_pos_callback); glfwSetMouseButtonCallback(window->glfw(), mouse_button_callback); glfwSetWindowSizeCallback(window->glfw(), window_size_callback); glfwSetScrollCallback(window->glfw(), scroll_callback); } } Gui::Gui(std::shared_ptr<Window> window) : m_window(window) , m_scene(nullptr) { setupCallbacks(); Init(*window); int width, height; glfwGetFramebufferSize(window->glfw(), &width, &height); onResize(width, height); } Gui::~Gui() { Shutdown(); } void Gui::setScene(std::shared_ptr<Scene> scene) { m_scene = scene; setupDialogs(); } void Gui::beforeLoading() { NewFrame(); ImGui::SetNextWindowSize(ImVec2(m_windowWidth, m_windowHeight)); ImGui::SetNextWindowPos(ImVec2(0.f, 0.f)); ImGui::Begin("Reload", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar); ImGui::Text(" "); ImGui::Text(" "); ImGui::Text("Loading scene..."); ImGui::End(); DrawFrame(); if (auto window = m_window.lock()) { glfwSwapBuffers(window->glfw()); } } void Gui::afterLoading() { if (auto window = m_window.lock()) { int width, height; glfwGetFramebufferSize(window->glfw(), &width, &height); onResize(width, height); } m_startTime = static_cast<float>(glfwGetTime()); setupDialogs(); } void Gui::setupDialogs() { m_dialogGroups.clear(); if (m_scene) { addDialogGroup<DeferredShadingDialog>("Deferred Shading", m_scene->deferredShader()); addDialogGroup<WorldDialog>("World", m_scene->world()); addDialogGroup<GlobalTimerDialog>("Timers", GlobalTimer::GetInstance()); addDialogGroup<SceneDialog>("Scene:", m_scene); for (const auto& obj : m_scene->objects()) { DialogGroup group; group.title = " - " + obj->name; IBehaviorHolder::ConstBehaviorIterator it, end; for (it = obj->cbeginBehaviors(), end = obj->cendBehaviors(); it != end; ++it) { auto dialog = makeComponentDialog(it->first, it->second); if (dialog) { group.dialogs.push_back(dialog); } } m_dialogGroups.push_back(group); } } } void Gui::update() { updateImGui(); if (m_scene) { m_scene->update(static_cast<float>(glfwGetTime()) - m_startTime); if (auto window = m_window.lock()) { if (m_scene->mustQuit()) { glfwSetWindowShouldClose(window->glfw(), GL_TRUE); } } } } void Gui::updateImGui() { NewFrame(); ImVec4 clear_color = ImColor(114, 144, 154); static float f = 0.0f; ImGui::SetNextWindowPos(ImVec2(0.f, 0.f)); ImGui::SetNextWindowSize(ImVec2(420.f, 0.f)); ImGui::Begin("Framerate", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar); int frame = m_scene ? m_scene->frame() : 0; ImGui::Text("Application average %.3f ms/frame (%.1f FPS) | #%d", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate, frame); ImGui::End(); int dialogId = 0; for (auto & dg : m_dialogGroups) { ImGui::PushID(dialogId++); for (auto d : dg.dialogs) { d->drawHandles(0, 0, m_windowWidth, m_windowHeight); } ImGui::PopID(); } if (m_showPanel) { ImGui::SetNextWindowSize(ImVec2(m_panelWidth, m_windowHeight)); ImGui::SetNextWindowPos(ImVec2(m_windowWidth - m_panelWidth, 0.f)); ImGui::Begin("Dialogs", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar); ImGui::PushID(0); int dialogId = 0; bool pressed; for (auto & dg : m_dialogGroups) { ImGui::PushID(dialogId); dialogId += static_cast<int>(dg.dialogs.size()); pressed = ImGui::Selectable(dg.title.c_str(), &dg.enabled); if (pressed && m_isControlPressed == 0) { for (auto & other : m_dialogGroups) { other.enabled = &other == &dg; } } ImGui::PopID(); } ImGui::PopID(); ImGui::PushID(1); dialogId = 0; for (auto & dg : m_dialogGroups) { if (dg.enabled) { for (auto d : dg.dialogs) { ImGui::PushID(dialogId++); d->draw(); ImGui::PopID(); } } else { dialogId += static_cast<int>(dg.dialogs.size()); } } ImGui::PopID(); ImGui::End(); } } void Gui::render() { if (m_scene) { m_scene->render(); } if (!m_scene || m_scene->properties().ui) { glBindFramebuffer(GL_FRAMEBUFFER, 0); DrawFrame(); } if (m_scene) { m_scene->onPostRender(static_cast<float>(glfwGetTime()) - m_startTime); } } void Gui::onResize(int width, int height) { m_windowWidth = static_cast<float>(width); m_windowHeight = static_cast<float>(height); if (auto window = m_window.lock()) { int fbWidth, fbHeight; glfwGetFramebufferSize(window->glfw(), &fbWidth, &fbHeight); glViewport(0, 0, fbWidth, fbHeight); if (m_scene) { m_scene->setResolution(fbWidth, fbHeight); } } } #define forAllCameras(method) \ for (auto& camera : m_scene->cameras()) { \ if (camera->properties().controlInViewport) { \ camera->method(); \ } \ } void Gui::onMouseButton(int button, int action, int mods) { if (m_imguiFocus || !m_scene) { return; } m_isMouseMoveStarted = action == GLFW_PRESS; switch (button) { case GLFW_MOUSE_BUTTON_LEFT: if (action == GLFW_PRESS) { forAllCameras(startMouseRotation); } else { forAllCameras(stopMouseRotation); } break; case GLFW_MOUSE_BUTTON_MIDDLE: if (action == GLFW_PRESS) { forAllCameras(startMouseZoom); } else { forAllCameras(stopMouseZoom); } break; case GLFW_MOUSE_BUTTON_RIGHT: if (action == GLFW_PRESS) { forAllCameras(startMousePanning); } else { forAllCameras(stopMousePanning); } break; } } void Gui::onCursorPosition(double x, double y) { double limit = static_cast<double>(m_windowWidth) - static_cast<double>(m_panelWidth); m_imguiFocus = x >= limit && m_showPanel && !m_isMouseMoveStarted; if (m_imguiFocus) { return; } if (m_scene) { for (auto& camera : m_scene->cameras()) { if (camera->properties().controlInViewport) { camera->updateMousePosition(static_cast<float>(x), static_cast<float>(y)); } } } } void Gui::onScroll(double xoffset, double yoffset) { if (m_imguiFocus) { return; } if (m_scene) { for (auto& camera : m_scene->cameras()) { if (camera->properties().controlInViewport) { camera->zoom(- 2 * static_cast<float>(yoffset)); } } } } void Gui::onKey(int key, int scancode, int action, int mods) { if (action == GLFW_PRESS) { switch (key) { case GLFW_KEY_ESCAPE: if (auto window = getWindow().lock()) { glfwSetWindowShouldClose(window->glfw(), GL_TRUE); } break; case GLFW_KEY_LEFT_CONTROL: case GLFW_KEY_RIGHT_CONTROL: ++m_isControlPressed; break; } } if (action == GLFW_RELEASE) { switch (key) { case GLFW_KEY_LEFT_CONTROL: case GLFW_KEY_RIGHT_CONTROL: m_isControlPressed = 0; break; } } if (action == GLFW_PRESS && !m_imguiFocus) { switch (key) { case GLFW_KEY_ESCAPE: if (auto window = m_window.lock()) { glfwSetWindowShouldClose(window->glfw(), GL_TRUE); } break; case GLFW_KEY_P: m_showPanel = !m_showPanel; break; case GLFW_KEY_LEFT_CONTROL: case GLFW_KEY_RIGHT_CONTROL: ++m_isControlPressed; break; } } if (action == GLFW_PRESS && !m_imguiFocus && m_scene) { switch (key) { case GLFW_KEY_R: if (mods & GLFW_MOD_CONTROL) { beforeLoading(); ShaderPool::Clear(); m_scene->load(m_scene->filename()); afterLoading(); } else { m_scene->reloadShaders(); } break; case GLFW_KEY_U: m_scene->properties().ui = !m_scene->properties().ui; break; case GLFW_KEY_A: forAllCameras(tiltLeft); break; case GLFW_KEY_E: forAllCameras(tiltRight); break; case GLFW_KEY_C: if (mods & GLFW_MOD_CONTROL) { ShaderPool::Clear(); m_scene->clear(); } else { if (m_scene->viewportCamera()) { glm::mat4 m = m_scene->viewportCamera()->viewMatrix(); DEBUG_LOG << "View Matrix: \n" << "[" << m[0][0] << "," << m[0][1] << "," << m[0][2] << "," << m[0][3] << "," << m[1][0] << "," << m[1][1] << "," << m[1][2] << "," << m[1][3] << "," << m[2][0] << "," << m[2][1] << "," << m[2][2] << "," << m[2][3] << "," << m[3][0] << "," << m[3][1] << "," << m[3][2] << "," << m[3][3] << "]"; std::ostringstream ss; m_scene->viewportCamera()->serialize(ss); DEBUG_LOG << ss.str(); } } break; case GLFW_KEY_SPACE: m_scene->togglePause(); break; } } } #undef forAllCameras
#include <OpenGL> #include "Logger.h" #include "Gui.h" #include "Window.h" #include "Scene.h" #include "Dialog.h" #include "RuntimeObject.h" #include "ShaderPool.h" #include "GlobalTimer.h" #include "Ui/SceneDialog.h" #include "Ui/DeferredShadingDialog.h" #include "Ui/WorldDialog.h" #include "Ui/GlobalTimerDialog.h" #include <GLFW/glfw3.h> #include <imgui.h> #include "imgui_impl_glfw.h" #include "imgui_impl_opengl3.h" #include <iostream> using namespace std; #include "LightGizmoDialog.h" #include "FarGrainRendererDialog.h" #include "TransformDialog.h" #include "PointCloudSplitterDialog.h" #include "InstanceGrainRendererDialog.h" #include "ImpostorGrainRendererDialog.h" #include "GrainBehaviorDialog.h" #include "MeshRendererDialog.h" #include "QuadMeshDataDialog.h" static std::shared_ptr<Dialog> makeComponentDialog(std::string type, std::shared_ptr<Behavior> component) { #define handleBehavior(T) \ if (type == BehaviorRegistryEntry<T>::Name()) { \ auto dialog = DialogFactory<T>().MakeShared(); \ dialog->setControlledBehavior(std::dynamic_pointer_cast<T>(component)); \ return std::dynamic_pointer_cast<Dialog>(dialog); \ } handleBehavior(LightGizmo); handleBehavior(FarGrainRenderer); handleBehavior(TransformBehavior); handleBehavior(PointCloudSplitter); handleBehavior(InstanceGrainRenderer); handleBehavior(ImpostorGrainRenderer); handleBehavior(GrainBehavior); handleBehavior(MeshRenderer); handleBehavior(QuadMeshData); return nullptr; #undef handleType } void Gui::Init(const Window & window) { IMGUI_CHECKVERSION(); ImGui::CreateContext(); ImGuiIO& io = ImGui::GetIO(); (void)io; ImGui_ImplGlfw_InitForOpenGL(window.glfw(), true); ImGui_ImplOpenGL3_Init("#version 150"); ImGui::GetStyle().WindowRounding = 0.0f; } void Gui::NewFrame() { ImGui_ImplOpenGL3_NewFrame(); ImGui_ImplGlfw_NewFrame(); ImGui::NewFrame(); } void Gui::DrawFrame() { ImGui::Render(); ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData()); } void Gui::Shutdown() { ImGui_ImplOpenGL3_Shutdown(); ImGui_ImplGlfw_Shutdown(); ImGui::DestroyContext(); } static void printUsage() { cerr << "GrainViewer -- real time grain viewer" << endl << "Author : Élie Michel (http://perso.telecom-paristech.fr/~emichel)" << endl << endl << "Keyboard commands" << endl << "------------------" << endl << " r: Reload shaders" << endl << " ctrl+r: Reload scene" << endl << " p: Toggle panel" << endl << " a: Tilt camera left" << endl << " e: Tilt camera right" << endl << " d: Switch deferred shading on/off" << endl << " c: Print camera matrix (row major)" << endl << " <space>: Pause physics" << endl << " ?: Print help" << endl << " q, <esc>: Quit" << endl << endl; } static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onKey(key, scancode, action, mode); } static void cursor_pos_callback(GLFWwindow* window, double x, double y) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onCursorPosition(x, y); } static void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onMouseButton(button, action, mods); } static void window_size_callback(GLFWwindow* window, int width, int height) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onResize(width, height); } static void scroll_callback(GLFWwindow* window, double xoffset, double yoffset) { Gui* gui = static_cast<Gui*>(glfwGetWindowUserPointer(window)); gui->onScroll(xoffset, yoffset); } void Gui::setupCallbacks() { if (auto window = m_window.lock()) { glfwSetWindowUserPointer(window->glfw(), static_cast<void*>(this)); glfwSetKeyCallback(window->glfw(), key_callback); glfwSetCursorPosCallback(window->glfw(), cursor_pos_callback); glfwSetMouseButtonCallback(window->glfw(), mouse_button_callback); glfwSetWindowSizeCallback(window->glfw(), window_size_callback); glfwSetScrollCallback(window->glfw(), scroll_callback); } } Gui::Gui(std::shared_ptr<Window> window) : m_window(window) , m_scene(nullptr) { setupCallbacks(); Init(*window); int width, height; glfwGetFramebufferSize(window->glfw(), &width, &height); onResize(width, height); } Gui::~Gui() { Shutdown(); } void Gui::setScene(std::shared_ptr<Scene> scene) { m_scene = scene; setupDialogs(); } void Gui::beforeLoading() { NewFrame(); ImGui::SetNextWindowSize(ImVec2(m_windowWidth, m_windowHeight)); ImGui::SetNextWindowPos(ImVec2(0.f, 0.f)); ImGui::Begin("Reload", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar); ImGui::Text(" "); ImGui::Text(" "); ImGui::Text("Loading scene..."); ImGui::End(); DrawFrame(); if (auto window = m_window.lock()) { glfwSwapBuffers(window->glfw()); } } void Gui::afterLoading() { if (auto window = m_window.lock()) { int width, height; glfwGetFramebufferSize(window->glfw(), &width, &height); onResize(width, height); } m_startTime = static_cast<float>(glfwGetTime()); setupDialogs(); } void Gui::setupDialogs() { m_dialogGroups.clear(); if (m_scene) { addDialogGroup<DeferredShadingDialog>("Deferred Shading", m_scene->deferredShader()); addDialogGroup<WorldDialog>("World", m_scene->world()); addDialogGroup<GlobalTimerDialo
void Gui::update() { updateImGui(); if (m_scene) { m_scene->update(static_cast<float>(glfwGetTime()) - m_startTime); if (auto window = m_window.lock()) { if (m_scene->mustQuit()) { glfwSetWindowShouldClose(window->glfw(), GL_TRUE); } } } } void Gui::updateImGui() { NewFrame(); ImVec4 clear_color = ImColor(114, 144, 154); static float f = 0.0f; ImGui::SetNextWindowPos(ImVec2(0.f, 0.f)); ImGui::SetNextWindowSize(ImVec2(420.f, 0.f)); ImGui::Begin("Framerate", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar); int frame = m_scene ? m_scene->frame() : 0; ImGui::Text("Application average %.3f ms/frame (%.1f FPS) | #%d", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate, frame); ImGui::End(); int dialogId = 0; for (auto & dg : m_dialogGroups) { ImGui::PushID(dialogId++); for (auto d : dg.dialogs) { d->drawHandles(0, 0, m_windowWidth, m_windowHeight); } ImGui::PopID(); } if (m_showPanel) { ImGui::SetNextWindowSize(ImVec2(m_panelWidth, m_windowHeight)); ImGui::SetNextWindowPos(ImVec2(m_windowWidth - m_panelWidth, 0.f)); ImGui::Begin("Dialogs", nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoTitleBar); ImGui::PushID(0); int dialogId = 0; bool pressed; for (auto & dg : m_dialogGroups) { ImGui::PushID(dialogId); dialogId += static_cast<int>(dg.dialogs.size()); pressed = ImGui::Selectable(dg.title.c_str(), &dg.enabled); if (pressed && m_isControlPressed == 0) { for (auto & other : m_dialogGroups) { other.enabled = &other == &dg; } } ImGui::PopID(); } ImGui::PopID(); ImGui::PushID(1); dialogId = 0; for (auto & dg : m_dialogGroups) { if (dg.enabled) { for (auto d : dg.dialogs) { ImGui::PushID(dialogId++); d->draw(); ImGui::PopID(); } } else { dialogId += static_cast<int>(dg.dialogs.size()); } } ImGui::PopID(); ImGui::End(); } } void Gui::render() { if (m_scene) { m_scene->render(); } if (!m_scene || m_scene->properties().ui) { glBindFramebuffer(GL_FRAMEBUFFER, 0); DrawFrame(); } if (m_scene) { m_scene->onPostRender(static_cast<float>(glfwGetTime()) - m_startTime); } } void Gui::onResize(int width, int height) { m_windowWidth = static_cast<float>(width); m_windowHeight = static_cast<float>(height); if (auto window = m_window.lock()) { int fbWidth, fbHeight; glfwGetFramebufferSize(window->glfw(), &fbWidth, &fbHeight); glViewport(0, 0, fbWidth, fbHeight); if (m_scene) { m_scene->setResolution(fbWidth, fbHeight); } } } #define forAllCameras(method) \ for (auto& camera : m_scene->cameras()) { \ if (camera->properties().controlInViewport) { \ camera->method(); \ } \ } void Gui::onMouseButton(int button, int action, int mods) { if (m_imguiFocus || !m_scene) { return; } m_isMouseMoveStarted = action == GLFW_PRESS; switch (button) { case GLFW_MOUSE_BUTTON_LEFT: if (action == GLFW_PRESS) { forAllCameras(startMouseRotation); } else { forAllCameras(stopMouseRotation); } break; case GLFW_MOUSE_BUTTON_MIDDLE: if (action == GLFW_PRESS) { forAllCameras(startMouseZoom); } else { forAllCameras(stopMouseZoom); } break; case GLFW_MOUSE_BUTTON_RIGHT: if (action == GLFW_PRESS) { forAllCameras(startMousePanning); } else { forAllCameras(stopMousePanning); } break; } } void Gui::onCursorPosition(double x, double y) { double limit = static_cast<double>(m_windowWidth) - static_cast<double>(m_panelWidth); m_imguiFocus = x >= limit && m_showPanel && !m_isMouseMoveStarted; if (m_imguiFocus) { return; } if (m_scene) { for (auto& camera : m_scene->cameras()) { if (camera->properties().controlInViewport) { camera->updateMousePosition(static_cast<float>(x), static_cast<float>(y)); } } } } void Gui::onScroll(double xoffset, double yoffset) { if (m_imguiFocus) { return; } if (m_scene) { for (auto& camera : m_scene->cameras()) { if (camera->properties().controlInViewport) { camera->zoom(- 2 * static_cast<float>(yoffset)); } } } } void Gui::onKey(int key, int scancode, int action, int mods) { if (action == GLFW_PRESS) { switch (key) { case GLFW_KEY_ESCAPE: if (auto window = getWindow().lock()) { glfwSetWindowShouldClose(window->glfw(), GL_TRUE); } break; case GLFW_KEY_LEFT_CONTROL: case GLFW_KEY_RIGHT_CONTROL: ++m_isControlPressed; break; } } if (action == GLFW_RELEASE) { switch (key) { case GLFW_KEY_LEFT_CONTROL: case GLFW_KEY_RIGHT_CONTROL: m_isControlPressed = 0; break; } } if (action == GLFW_PRESS && !m_imguiFocus) { switch (key) { case GLFW_KEY_ESCAPE: if (auto window = m_window.lock()) { glfwSetWindowShouldClose(window->glfw(), GL_TRUE); } break; case GLFW_KEY_P: m_showPanel = !m_showPanel; break; case GLFW_KEY_LEFT_CONTROL: case GLFW_KEY_RIGHT_CONTROL: ++m_isControlPressed; break; } } if (action == GLFW_PRESS && !m_imguiFocus && m_scene) { switch (key) { case GLFW_KEY_R: if (mods & GLFW_MOD_CONTROL) { beforeLoading(); ShaderPool::Clear(); m_scene->load(m_scene->filename()); afterLoading(); } else { m_scene->reloadShaders(); } break; case GLFW_KEY_U: m_scene->properties().ui = !m_scene->properties().ui; break; case GLFW_KEY_A: forAllCameras(tiltLeft); break; case GLFW_KEY_E: forAllCameras(tiltRight); break; case GLFW_KEY_C: if (mods & GLFW_MOD_CONTROL) { ShaderPool::Clear(); m_scene->clear(); } else { if (m_scene->viewportCamera()) { glm::mat4 m = m_scene->viewportCamera()->viewMatrix(); DEBUG_LOG << "View Matrix: \n" << "[" << m[0][0] << "," << m[0][1] << "," << m[0][2] << "," << m[0][3] << "," << m[1][0] << "," << m[1][1] << "," << m[1][2] << "," << m[1][3] << "," << m[2][0] << "," << m[2][1] << "," << m[2][2] << "," << m[2][3] << "," << m[3][0] << "," << m[3][1] << "," << m[3][2] << "," << m[3][3] << "]"; std::ostringstream ss; m_scene->viewportCamera()->serialize(ss); DEBUG_LOG << ss.str(); } } break; case GLFW_KEY_SPACE: m_scene->togglePause(); break; } } } #undef forAllCameras
g>("Timers", GlobalTimer::GetInstance()); addDialogGroup<SceneDialog>("Scene:", m_scene); for (const auto& obj : m_scene->objects()) { DialogGroup group; group.title = " - " + obj->name; IBehaviorHolder::ConstBehaviorIterator it, end; for (it = obj->cbeginBehaviors(), end = obj->cendBehaviors(); it != end; ++it) { auto dialog = makeComponentDialog(it->first, it->second); if (dialog) { group.dialogs.push_back(dialog); } } m_dialogGroups.push_back(group); } } }
function_block-function_prefixed
[ { "content": "class DeferredShadingDialog : public Dialog {\n\npublic:\n\n\tvoid draw() override;\n\n\tvoid drawHandles(float x, float y, float w, float h) override;\n\n\tvoid setController(std::weak_ptr<GlDeferredShader> shading) { m_cont = shading; }\n\n\n\nprivate:\n\n\tstd::weak_ptr<GlDeferredShader> m_cont...
C++
main/main.cpp
jmautari/playsound
5885c693d486c5a417a9ec1a96465d83f5492b1c
#include "shared/platform.h" #include <mmdeviceapi.h> #include <Endpointvolume.h> #include <audioclient.h> #include <atlbase.h> #include <Mmsystem.h> #include <string> #include <iostream> #include <filesystem> constexpr wchar_t kEventName[] = L"PlaySoundEvent"; constexpr wchar_t kOptRepeat[] = L"-r"; constexpr wchar_t kOptStop[] = L"-s"; constexpr wchar_t kOptTime[] = L"-t"; constexpr wchar_t kOptMuteMic[] = L"-m"; constexpr int kGetTimeValue = -1; bool PickDevice(IMMDevice** device_to_use, EDataFlow which_end_point = eCapture) { HRESULT hr; CComPtr<IMMDeviceEnumerator> device_enumerator; hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&device_enumerator)); if (FAILED(hr)) { return false; } hr = device_enumerator->GetDefaultAudioEndpoint( which_end_point, eConsole, device_to_use); return SUCCEEDED(hr) ? true : false; } bool SetMicMute(bool mute, bool& muted) { if (FAILED(::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED))) { return false; } HRESULT hr; CComPtr<IMMDevice> endPoint; CComPtr<IAudioClient> audioClient; CComPtr<IAudioEndpointVolume> volumeControl; float current_volume = 0.0f; bool res = false; do { if (!PickDevice(&endPoint)) { break; } hr = endPoint->Activate(__uuidof(IAudioClient), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&audioClient)); if (FAILED(hr)) { break; } hr = endPoint->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER, NULL, (LPVOID*)&volumeControl); if (FAILED(hr)) { break; } BOOL mute_status; hr = volumeControl->GetMute(&mute_status); if (FAILED(hr)) { break; } hr = volumeControl->SetMute(mute, nullptr); if (FAILED(hr)) { break; } muted = !!mute_status; res = true; } while (false); volumeControl.Release(); endPoint.Release(); audioClient.Release(); ::CoUninitialize(); return res; } int wmain(int argc, wchar_t* argv[]) { if (argc < 2) { std::cout << "Usage:" << std::endl << "playsound [options] [path-to-file]" << std::endl << "Where options can be:" << std::endl << "-r repeat the sound until playsound is called again with -s option" << std::endl << std::endl << "-s stop a sound that was previously played with -r option" << std::endl << std::endl << "-t X play the sound for up to X seconds. This option has no effect " "if the sound file duration is shorter than X seconds" << std::endl << std::endl << "-m mute default microphone until playsound is called again with -m " "-s options" << std::endl << std::endl << "All options but -m are mutually exclusive" << std::endl; return 1; } HANDLE event_handle = nullptr; bool repeat = false; bool stop = false; bool mute = false; int time = 0; const auto get_opt = [&] { for (int i = 1; i < argc; i++) { if (wcsncmp(argv[i], kOptRepeat, _TRUNCATE) == 0) { if (!stop) repeat = true; } else if (wcsncmp(argv[i], kOptStop, _TRUNCATE) == 0) { if (!repeat) stop = true; } else if (wcsncmp(argv[i], kOptTime, _TRUNCATE) == 0) { time = kGetTimeValue; } else if (time == kGetTimeValue) { time = std::stoi(argv[i]); } else if (wcsncmp(argv[i], kOptMuteMic, _TRUNCATE) == 0) { mute = true; } } }; const auto get_filename = [&]() -> std::filesystem::path { return argv[argc - 1]; }; get_opt(); if (stop) { event_handle = OpenEventW(EVENT_MODIFY_STATE, false, kEventName); if (event_handle == nullptr) { std::cout << "Sound event not found. Make sure a sound was being played" << std::endl; return 1; } std::cout << "Stopping sound" << std::endl; SetEvent(event_handle); PlaySound(nullptr, 0, 0); return 0; } const auto filename = get_filename(); std::error_code ec; if (!std::filesystem::exists(filename, ec)) { std::cout << "File not found" << std::endl; return 1; } if (mute) { event_handle = OpenEventW(EVENT_MODIFY_STATE, false, kEventName); if (event_handle != nullptr) { CloseHandle(event_handle); return 1; } } DWORD flags = SND_FILENAME; bool muted = false; bool reset_mic = false; if (repeat || mute) { std::cout << "Repeating sound " << (mute ? "and muting default mic" : "") << " until playsound is started with -s option" << std::endl; flags |= SND_LOOP | SND_ASYNC; event_handle = CreateEventW(nullptr, false, false, kEventName); if (mute) { reset_mic = SetMicMute(true, muted); if (!reset_mic) { std::cout << "Couldn't get current mic volume. Not muting mic" << std::endl; } } } else if (time > 0) { flags |= SND_ASYNC; } PlaySoundW(filename.native().c_str(), nullptr, flags); if (event_handle != nullptr) { WaitForSingleObject(event_handle, INFINITE); CloseHandle(event_handle); if (mute && reset_mic) SetMicMute(false, muted); } else if (time > 0) { Sleep(time * 1000); } return 0; }
#include "shared/platform.h" #include <mmdeviceapi.h> #include <Endpointvolume.h> #include <audioclient.h> #include <atlbase.h> #include <Mmsystem.h> #include <string> #include <iostream> #include <filesystem> constexpr wchar_t kEventName[] = L"PlaySoundEvent"; constexpr wchar_t kOptRepeat[] = L"-r"; constexpr wchar_t kOptStop[] = L"-s"; constexpr wchar_t kOptTime[] = L"-t"; constexpr wchar_t kOptMuteMic[] = L"-m"; constexpr int kGetTimeValue = -1; bool PickDevice(IMMDevice** device_to_use, EDataFlow which_end_point = eCapture) { HRESULT hr; CComPtr<IMMDeviceEnumerator> device_enumerator; hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&device_enumerator)); if (FAILED(hr)) { return false; } hr = device_enumerator->GetDefaultAudioEndpoint( which_end_point, eConsole, device_to_use); return SUCCEEDED(hr) ? true : false; } bool SetMicMute(bool mute, bool& muted) { if (FAILED(::CoInitializeEx(NULL, COINIT_APARTMENTTHREADED))) { return false; } HRESULT hr; CComPtr<IMMDevice> endPoint; CComPtr<IAudioClient> audioClient; CComPtr<IAudioEndpointVolume> volumeControl; float current_volume = 0.0f; bool re
rue, muted); if (!reset_mic) { std::cout << "Couldn't get current mic volume. Not muting mic" << std::endl; } } } else if (time > 0) { flags |= SND_ASYNC; } PlaySoundW(filename.native().c_str(), nullptr, flags); if (event_handle != nullptr) { WaitForSingleObject(event_handle, INFINITE); CloseHandle(event_handle); if (mute && reset_mic) SetMicMute(false, muted); } else if (time > 0) { Sleep(time * 1000); } return 0; }
s = false; do { if (!PickDevice(&endPoint)) { break; } hr = endPoint->Activate(__uuidof(IAudioClient), CLSCTX_ALL, NULL, reinterpret_cast<void**>(&audioClient)); if (FAILED(hr)) { break; } hr = endPoint->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER, NULL, (LPVOID*)&volumeControl); if (FAILED(hr)) { break; } BOOL mute_status; hr = volumeControl->GetMute(&mute_status); if (FAILED(hr)) { break; } hr = volumeControl->SetMute(mute, nullptr); if (FAILED(hr)) { break; } muted = !!mute_status; res = true; } while (false); volumeControl.Release(); endPoint.Release(); audioClient.Release(); ::CoUninitialize(); return res; } int wmain(int argc, wchar_t* argv[]) { if (argc < 2) { std::cout << "Usage:" << std::endl << "playsound [options] [path-to-file]" << std::endl << "Where options can be:" << std::endl << "-r repeat the sound until playsound is called again with -s option" << std::endl << std::endl << "-s stop a sound that was previously played with -r option" << std::endl << std::endl << "-t X play the sound for up to X seconds. This option has no effect " "if the sound file duration is shorter than X seconds" << std::endl << std::endl << "-m mute default microphone until playsound is called again with -m " "-s options" << std::endl << std::endl << "All options but -m are mutually exclusive" << std::endl; return 1; } HANDLE event_handle = nullptr; bool repeat = false; bool stop = false; bool mute = false; int time = 0; const auto get_opt = [&] { for (int i = 1; i < argc; i++) { if (wcsncmp(argv[i], kOptRepeat, _TRUNCATE) == 0) { if (!stop) repeat = true; } else if (wcsncmp(argv[i], kOptStop, _TRUNCATE) == 0) { if (!repeat) stop = true; } else if (wcsncmp(argv[i], kOptTime, _TRUNCATE) == 0) { time = kGetTimeValue; } else if (time == kGetTimeValue) { time = std::stoi(argv[i]); } else if (wcsncmp(argv[i], kOptMuteMic, _TRUNCATE) == 0) { mute = true; } } }; const auto get_filename = [&]() -> std::filesystem::path { return argv[argc - 1]; }; get_opt(); if (stop) { event_handle = OpenEventW(EVENT_MODIFY_STATE, false, kEventName); if (event_handle == nullptr) { std::cout << "Sound event not found. Make sure a sound was being played" << std::endl; return 1; } std::cout << "Stopping sound" << std::endl; SetEvent(event_handle); PlaySound(nullptr, 0, 0); return 0; } const auto filename = get_filename(); std::error_code ec; if (!std::filesystem::exists(filename, ec)) { std::cout << "File not found" << std::endl; return 1; } if (mute) { event_handle = OpenEventW(EVENT_MODIFY_STATE, false, kEventName); if (event_handle != nullptr) { CloseHandle(event_handle); return 1; } } DWORD flags = SND_FILENAME; bool muted = false; bool reset_mic = false; if (repeat || mute) { std::cout << "Repeating sound " << (mute ? "and muting default mic" : "") << " until playsound is started with -s option" << std::endl; flags |= SND_LOOP | SND_ASYNC; event_handle = CreateEventW(nullptr, false, false, kEventName); if (mute) { reset_mic = SetMicMute(t
random
[ { "content": "# Playsound\n\n\n\nSimple utility program to play a wav file.\n\n\n\nPrimarily used by [Widgets][1]\n\n\n\n## Usage\n\n\n\n```\n\nplaysound [options] [path-to-file]\n\n```\n\n\n\nWhere `options` can be:\n\n\n\n`-r` repeat the sound until `playsound` is called again with `-s` option\n\n\n\n`-m` sam...
C++
CODE_S1_Wed_Friday/CODE_S1_Wed_Friday/theMainFunction.cpp
Freethetan/INFO3111-S21
b0526d641c5e744c38e6a48d1b66a47f0d8dd592
#include "globalStuff.h" #include <glm/glm.hpp> #include <glm/vec3.hpp> #include <glm/vec4.hpp> #include <glm/mat4x4.hpp> #include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/type_ptr.hpp> #include <stdlib.h> #include <stdio.h> #include <string> #include <iostream> #include <vector> #include <sstream> #include "cShaderManager.h" #include "cVAOManager.h" #include "cMeshObject.h" static void error_callback(int error, const char* description) { fprintf(stderr, "Error: %s\n", description); } bool generateQnDHeaderFileFromPLY(std::string plyFileName, std::string headerFileName, unsigned int& numVertices); float getRandFloat(float LO, float HI) { float r3 = LO + static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / (HI - LO))); return r3; } void DrawObject( cMeshObject& curMesh, glm::mat4& matModel, glm::mat4& matProjection, glm::mat4& matView, float ratio, cVAOManager* pVAOMan, GLuint program); int main(void) { GLFWwindow* window = NULL; GLuint vertex_buffer = 0; GLuint program = 0; GLint vpos_location = 0; GLint vcol_location = 0; glfwSetErrorCallback(error_callback); if (!glfwInit()) { exit(EXIT_FAILURE); } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); glfwSwapInterval(1); cShaderManager* pShaderManager = new cShaderManager(); cShaderManager::cShader myVertexShader; cShaderManager::cShader myFragmentShader; pShaderManager->setBasePath("assets/shaders/"); myVertexShader.fileName = "myVertShad.glsl"; myFragmentShader.fileName = "myFragShad.glsl"; if (pShaderManager->createProgramFromFile("SimpleShader", myVertexShader, myFragmentShader)) { std::cout << "Compiled the shader program OK" << std::endl; } else { std::cout << "Oh NO!: Here's why: " << pShaderManager->getLastError() << std::endl; } program = pShaderManager->getIDFromFriendlyName("SimpleShader"); cVAOManager* pVAOMan = new cVAOManager(); sModelDrawInfo mdoBunny; if (pVAOMan->LoadModelIntoVAO("assets/models/bun_zipper_res2_xyz_rgba.ply", mdoBunny, program)) { std::cout << "Bunny loaded OK" << std::endl; std::cout << "Has: " << mdoBunny.numberOfVertices << " vertices" << std::endl; } sModelDrawInfo mdoFish; pVAOMan->LoadModelIntoVAO("assets/models/PacificCod0_xyz_rgba.ply",mdoFish, program); sModelDrawInfo mdoEagleShaceShip; pVAOMan->LoadModelIntoVAO("assets/models/Eagle_xyz_rgba.ply", mdoEagleShaceShip, program); sModelDrawInfo mdoOcto; pVAOMan->LoadModelIntoVAO("assets/models/Santa_Octopus_xyz_rgba.ply", mdoOcto, program); sModelDrawInfo mdoCube; pVAOMan->LoadModelIntoVAO("assets/models/1x1x1Cube.ply", mdoCube, program); cMeshObject bunny; bunny.meshName = "assets/models/bun_zipper_res2_xyz_rgba.ply"; bunny.scale = 6.43f; bunny.position.x = 1.0f; bunny.orientation.y = 0.5f; bunny.orientation.z = 0.1f; bunny.wholeObjectColour = glm::vec4(0.0f, 0.5f, 1.0f, 1.0f); bunny.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(bunny); cMeshObject spaceShip; spaceShip.meshName = "assets/models/Eagle_xyz_rgba.ply"; spaceShip.scale = 0.03994727f; spaceShip.position.y = -0.5f; spaceShip.wholeObjectColour = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f); spaceShip.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(spaceShip); cMeshObject spaceShip2; spaceShip2.meshName = "assets/models/Eagle_xyz_rgba.ply"; spaceShip2.scale = 0.03994727f * 2.0f; spaceShip2.position.y = 0.75f; spaceShip2.wholeObjectColour = glm::vec4(1.0f, 1.0f, 0.0f, 1.0f); spaceShip2.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(spaceShip2); cMeshObject santaOcto; santaOcto.meshName = "assets/models/Santa_Octopus_xyz_rgba.ply"; santaOcto.position.x = +2.0f; santaOcto.position.z = +2.0f; santaOcto.wholeObjectColour = glm::vec4(1.0f,0.6f, 0.3f, 1.0f); santaOcto.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(santaOcto); ::g_DebugCube.meshName = "assets/models/1x1x1Cube.ply"; ::g_DebugCube.isWireframe = true; ::g_DebugCube.wholeObjectColour = glm::vec4(1.0f,1.0f, 1.0f, 1.0f); ::g_DebugCube.bUseWholeObjectColour = true; itSelectedObject = g_vecObjectsToDraw.begin(); while ( ! glfwWindowShouldClose(window) ) { float ratio; int width, height; glm::mat4 matModel; glm::mat4 matProjection; glm::mat4 matView; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float)height; glViewport(0, 0, width, height); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); for (unsigned int index = 0; index != ::g_vecObjectsToDraw.size(); index++) { cMeshObject curMesh = ::g_vecObjectsToDraw[index]; DrawObject( curMesh, matModel, matProjection, matView, ratio, pVAOMan, program ); } std::stringstream ssTitle; switch (::g_CurrentMode) { case EDIT_VIEW: ssTitle << "(EDIT MODE) "; ::g_DebugCube.position = itSelectedObject->position; DrawObject(::g_DebugCube, matModel, matProjection, matView, ratio, pVAOMan, program); break; case CAMERA_VIEW: ssTitle << "(CAMERA MODE) "; ssTitle << ::g_cameraEye.x << ", " << ::g_cameraEye.y << ", " << ::g_cameraEye.z; break; } glfwSetWindowTitle(window, ssTitle.str().c_str()); glfwSwapBuffers(window); glfwPollEvents(); doKeyboardMouseStuffAsync(window); } delete pShaderManager; delete pVAOMan; glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); } void DrawObject( cMeshObject &curMesh, glm::mat4 &matModel, glm::mat4 &matProjection, glm::mat4 &matView, float ratio, cVAOManager* pVAOMan, GLuint program) { matModel = glm::mat4(1.0f); glm::mat4 matRotateZ; glm::mat4 matRotateY; glm::mat4 matRotateX; glm::mat4 matScale; glm::mat4 matTranslate; matRotateZ = glm::rotate(glm::mat4(1.0f), curMesh.orientation.z, glm::vec3(0.0f, 0.0f, 1.0f)); matRotateY = glm::rotate(glm::mat4(1.0f), curMesh.orientation.y, glm::vec3(0.0f, 1.0, 0.0f)); matRotateX = glm::rotate(glm::mat4(1.0f), curMesh.orientation.x, glm::vec3(1.0f, 0.0, 0.0f)); float uniformScale = curMesh.scale; matScale = glm::scale(glm::mat4(1.0f), glm::vec3(uniformScale, uniformScale, uniformScale)); matTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(curMesh.position.x, curMesh.position.y, curMesh.position.z)); matModel = matModel * matTranslate; matModel = matModel * matRotateX; matModel = matModel * matRotateY; matModel = matModel * matRotateZ; matModel = matModel * matScale; matProjection = glm::perspective(0.6f, ratio, 0.1f, 1000.0f); matView = glm::mat4(1.0f); glm::vec3 upVector = glm::vec3(0.0f, 1.0f, 0.0f); matView = glm::lookAt(::g_cameraEye, ::g_cameraTarget, upVector); GLint mView_UniLocID = glGetUniformLocation(program, "mView"); glUniformMatrix4fv(mView_UniLocID, 1, GL_FALSE, glm::value_ptr(matView)); GLint mModel_UniLocID = glGetUniformLocation(program, "mModel"); glUniformMatrix4fv(mModel_UniLocID, 1, GL_FALSE, glm::value_ptr(matModel)); GLint mProj_UniLocID = glGetUniformLocation(program, "mProj"); glUniformMatrix4fv(mProj_UniLocID, 1, GL_FALSE, glm::value_ptr(matProjection)); GLint wholeObjCol_UniLocID = glGetUniformLocation(program, "wholeObjCol"); glUniform4f(wholeObjCol_UniLocID, curMesh.wholeObjectColour.r, curMesh.wholeObjectColour.g, curMesh.wholeObjectColour.b, curMesh.wholeObjectColour.a); GLint bUseVertColour_UniLocID = glGetUniformLocation(program, "bUseVertColour"); if (curMesh.bUseWholeObjectColour) { glUniform1i(bUseVertColour_UniLocID, GL_FALSE); } else { glUniform1i(bUseVertColour_UniLocID, GL_TRUE); } glUseProgram(program); if (curMesh.isWireframe) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); } else { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); } sModelDrawInfo mdoMesh; if (pVAOMan->FindDrawInfoByModelName(curMesh.meshName, mdoMesh)) { glBindVertexArray(mdoMesh.VAO_ID); glDrawElements(GL_TRIANGLES, mdoMesh.numberOfIndices, GL_UNSIGNED_INT, 0); glBindVertexArray(0); } return; }
#include "globalStuff.h" #include <glm/glm.hpp> #include <glm/vec3.hpp> #include <glm/vec4.hpp> #include <glm/mat4x4.hpp> #include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/type_ptr.hpp> #include <stdlib.h> #include <stdio.h> #include <string> #include <iostream> #include <vector> #include <sstream> #include "cShaderManager.h" #include "cVAOManager.h" #include "cMeshObject.h" static void error_callback(int error, const char* description) { fprintf(stderr, "Error: %s\n", description); } bool generateQnDHeaderFileFromPLY(std::string plyFileName, std::string headerFileName, unsigned int& numVertices); float getRandFloat(float LO, float HI) { float r3 = LO + static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / (HI - LO))); return r3; } void DrawObject( cMeshObject& curMesh, glm::mat4& matModel, glm::mat4& matProjection, glm::mat4& matView, float ratio, cVAOManager* pVAOMan, GLuint program); int main(void) { GLFWwindow* window = NULL; GLuint vertex_buffer = 0; GLuint program = 0; GLint vpos_location = 0; GLint vcol_location = 0; glfwSetErrorCallback(error_callback); if (!glfwInit()) { exit(EXIT_FAILURE); } glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL); if (!window) { glfwTerminate(); exit(EXIT_FAILURE); } glfwSetKeyCallback(window, key_callback); glfwMakeContextCurrent(window); gladLoadGLLoader((GLADloadproc)glfwGetProcAddress); glfwSwapInterval(1); cShaderManager* pShaderManager = new cShaderManager(); cShaderManager::cShader myVertexShader; cShaderManager::cShader myFragmentShader; pShaderManager->setBasePath("assets/shaders/"); myVertexShader.fileName = "myVertShad.glsl"; myFragmentShader.fileName = "myFragShad.glsl"; if (pShaderManager->createProgramFromFile("SimpleShader", myVertexShader, myFragmentShader)) { std::cout << "Compiled the shader program OK" << std::endl; } else { std::cout << "Oh NO!: Here's why: " << pShaderManager->getLastError() << std::endl; } program = pShaderManager->getIDFromFriendlyName("SimpleShader"); cVAOManager* pVAOMan = new cVAOManager(); sModelDrawInfo mdoBunny; if (pVAOMan->LoadModelIntoVAO("assets/models/bun_zipper_res2_xyz_rgba.ply", mdoBunny, program)) { std::cout << "Bunny loaded OK" << std::endl; std::cout << "Has: " << mdoBunny.numberOfVertices << " vertices" << std::endl; } sModelDrawInfo mdoFish; pVAOMan->LoadModelIntoVAO("assets/models/PacificCod0_xyz_rgba.ply",mdoFish, program); sModelDrawInfo mdoEagleShaceShip; pVAOMan->LoadModelIntoVAO("assets/models/Eagle_xyz_rgba.ply", mdoEagleShaceShip, program); sModelDrawInfo mdoOcto; pVAOMan->LoadModelIntoVAO("assets/models/Santa_Octopus_xyz_rgba.ply", mdoOcto, program); sModelDrawInfo mdoCube; pVAOMan->LoadModelIntoVAO("assets/models/1x1x1Cube.ply", mdoCube, program); cMeshObject bunny; bunny.meshName = "assets/models/bun_zipper_res2_xyz_rgba.ply"; bunny.scale = 6.43f; bunny.position.x = 1.0f; bunny.orientation.y = 0.5f; bunny.orientation.z = 0.1f; bunny.wholeObjectColour = glm::vec4(0.0f, 0.5f, 1.0f, 1.0f); bunny.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(bunny); cMeshObject spaceShip; spaceShip.meshName = "assets/models/Eagle_xyz_rgba.ply"; spaceShip.scale = 0.03994727f; spaceShip.position.y = -0.5f; spaceShip.wholeObjectColour = glm::vec4(1.0f, 0.0f, 0.0f, 1.0f); spaceShip.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(spaceShip); cMeshObject spaceShip2; spaceShip2.meshName = "assets/models/Eagle_xyz_rgba.ply"; spaceShip2.scale = 0.03994727f * 2.0f; spaceShip2.position.y = 0.75f; spaceShip2.wholeObjectColour = glm::vec4(1.0f, 1.0f, 0.0f, 1.0f); spaceShip2.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(spaceShip2); cMeshObject santaOcto; santaOcto.meshName = "assets/models/Santa_Octopus_xyz_rgba.ply"; santaOcto.position.x = +2.0f; santaOcto.position.z = +2.0f; santaOcto.wholeObjectColour = glm::vec4(1.0f,0.6f, 0.3f, 1.0f); santaOcto.bUseWholeObjectColour = true; ::g_vecObjectsToDraw.push_back(santaOcto); ::g_DebugCube.meshName = "assets/models/1x1x1Cube.ply"; ::g_DebugCube.isWireframe = true; ::g_DebugCube.wholeObjectColour = glm::vec4(1.0f,1.0f, 1.0f, 1.0f); ::g_DebugCube.bUseWholeObjectColour = true; itSelectedObject = g_vecObjectsToDraw.begin(); while ( ! glfwWindowShouldClose(window) ) { float ratio; int width, height; glm::mat4 matModel; glm::mat4 matProjection; glm::mat4 matView; glfwGetFramebufferSize(window, &width, &height); ratio = width / (float)height; glViewport(0, 0, width, height); glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); for (unsigned int index = 0; index != ::g_vecObjectsToDraw.size(); index++) { cMeshObject curMesh = ::g_vecObjectsToDraw[index]; DrawObject( curMesh, matModel, matProjection, matView, ratio, pVAOMan, program ); } std::stringstream ssTitle; switch (::g_CurrentMode) { case EDIT_VIEW: ssTitle << "(EDIT MODE) "; ::g_DebugCube.position = itSelectedObject->position; DrawObject(::g_DebugCube, matModel, matProjection, matView, ratio, pVAOMan, program); break; case CAMERA_VIEW: ssTitle << "(CAMERA MODE) "; ssTitle << ::g_cameraEye.x << ", " << ::g_cameraEye.y << ", " << ::g_cameraEye.z;
eX = glm::rotate(glm::mat4(1.0f), curMesh.orientation.x, glm::vec3(1.0f, 0.0, 0.0f)); float uniformScale = curMesh.scale; matScale = glm::scale(glm::mat4(1.0f), glm::vec3(uniformScale, uniformScale, uniformScale)); matTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(curMesh.position.x, curMesh.position.y, curMesh.position.z)); matModel = matModel * matTranslate; matModel = matModel * matRotateX; matModel = matModel * matRotateY; matModel = matModel * matRotateZ; matModel = matModel * matScale; matProjection = glm::perspective(0.6f, ratio, 0.1f, 1000.0f); matView = glm::mat4(1.0f); glm::vec3 upVector = glm::vec3(0.0f, 1.0f, 0.0f); matView = glm::lookAt(::g_cameraEye, ::g_cameraTarget, upVector); GLint mView_UniLocID = glGetUniformLocation(program, "mView"); glUniformMatrix4fv(mView_UniLocID, 1, GL_FALSE, glm::value_ptr(matView)); GLint mModel_UniLocID = glGetUniformLocation(program, "mModel"); glUniformMatrix4fv(mModel_UniLocID, 1, GL_FALSE, glm::value_ptr(matModel)); GLint mProj_UniLocID = glGetUniformLocation(program, "mProj"); glUniformMatrix4fv(mProj_UniLocID, 1, GL_FALSE, glm::value_ptr(matProjection)); GLint wholeObjCol_UniLocID = glGetUniformLocation(program, "wholeObjCol"); glUniform4f(wholeObjCol_UniLocID, curMesh.wholeObjectColour.r, curMesh.wholeObjectColour.g, curMesh.wholeObjectColour.b, curMesh.wholeObjectColour.a); GLint bUseVertColour_UniLocID = glGetUniformLocation(program, "bUseVertColour"); if (curMesh.bUseWholeObjectColour) { glUniform1i(bUseVertColour_UniLocID, GL_FALSE); } else { glUniform1i(bUseVertColour_UniLocID, GL_TRUE); } glUseProgram(program); if (curMesh.isWireframe) { glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); } else { glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); } sModelDrawInfo mdoMesh; if (pVAOMan->FindDrawInfoByModelName(curMesh.meshName, mdoMesh)) { glBindVertexArray(mdoMesh.VAO_ID); glDrawElements(GL_TRIANGLES, mdoMesh.numberOfIndices, GL_UNSIGNED_INT, 0); glBindVertexArray(0); } return; }
break; } glfwSetWindowTitle(window, ssTitle.str().c_str()); glfwSwapBuffers(window); glfwPollEvents(); doKeyboardMouseStuffAsync(window); } delete pShaderManager; delete pVAOMan; glfwDestroyWindow(window); glfwTerminate(); exit(EXIT_SUCCESS); } void DrawObject( cMeshObject &curMesh, glm::mat4 &matModel, glm::mat4 &matProjection, glm::mat4 &matView, float ratio, cVAOManager* pVAOMan, GLuint program) { matModel = glm::mat4(1.0f); glm::mat4 matRotateZ; glm::mat4 matRotateY; glm::mat4 matRotateX; glm::mat4 matScale; glm::mat4 matTranslate; matRotateZ = glm::rotate(glm::mat4(1.0f), curMesh.orientation.z, glm::vec3(0.0f, 0.0f, 1.0f)); matRotateY = glm::rotate(glm::mat4(1.0f), curMesh.orientation.y, glm::vec3(0.0f, 1.0, 0.0f)); matRotat
random
[]
C++
tools/trainers/retargetTrainer/src/RetargetArguments.cpp
kernhanda/ELL
370c0de4e4c190ca0cb43654b4246b3686bca464
#include "RetargetArguments.h" namespace ell { void ParsedRetargetArguments::AddArgs(utilities::CommandLineParser& parser) { using namespace common; parser.AddOption(inputModelFilename, "inputModelFilename", "imf", "Name of the pre-trained ELL model file (e.g. model1.ell) that will be used as a featurizer for a linear predictor", ""); parser.AddOption(outputModelFilename, "outputModelFilename", "omf", "Name of the output file that will hold the saved retargeted model (e.g. retargetedModel.ell)", ""); parser.AddOption(refineIterations, "refineIterations", "ri", "If cutting the neural network using a node id, specifies the maximum number of refinement iterations", 1); parser.AddOption(targetPortElements, "targetPortElements", "tpe", "The port elements of the pre-trained model to use as input to the subsequent linear predictor e.g. \"1115.output\" to use the full output from Node 1115", ""); parser.AddOption(removeLastLayers, "removeLastLayers", "rem", "Instead of using a node id, a neural network model can be retargeted by removing the last N layers", 0); parser.AddOption( inputDataFilename, "inputDataFilename", "idf", "Path to the input dataset file", ""); parser.AddOption( multiClass, "multiClass", "mc", "Indicates whether the input dataset is multi-class or binary.", false); parser.AddOption(normalize, "normalize", "n", "Perform sparsity-preserving normalization", false); parser.AddOption(regularization, "regularization", "r", "The L2 regularization parameter", 0.005); parser.AddOption(desiredPrecision, "desiredPrecision", "de", "The desired duality gap at which to stop optimizing", 1.0e-5); parser.AddOption(maxEpochs, "maxEpochs", "me", "The maximum number of optimization epochs to run", 1000); parser.AddOption(permute, "permute", "p", "Whether or not to randomly permute the training data before each epoch", true); parser.AddOption(randomSeedString, "randomSeedString", "seed", "The random seed string", "ABCDEFG"); parser.AddOption( verbose, "verbose", "v", "Print diagnostic output during the execution of the tool to stdout", false); parser.AddOption( lossFunctionArguments.lossFunction, "lossFunction", "lf", "Choice of loss function", { { "squared", LossFunctionArguments::LossFunction::squared }, { "log", LossFunctionArguments::LossFunction::log }, {"smoothHinge", LossFunctionArguments::LossFunction::smoothHinge} }, "log"); parser.AddOption( useBlas, "blas", "", "Emit code that calls BLAS, used when compiling the input model to create mapped datasets", true); } }
#include "RetargetArguments.h" namespace ell { void ParsedRetargetArguments::AddArgs(utilities::CommandLineParser& parser) { using namespace common; parser.AddOption(inputModelFilename, "inputModelFilename", "imf", "Name of the pre-trained ELL model file (e.g. model1.ell) that will be used as a featurizer for a linear predictor", ""); parser.AddOption(outputModelFilename, "outputModelFilename", "omf", "Name of the output file that will hold the saved retargeted model (e.g. retargetedModel.ell)", ""); parser.AddOption(refineIterations, "refineIterations", "ri", "If cutting the neural network using a node id, specifies the maximum number of refinement iterations", 1); parser.AddOption(targetPortElements, "targetPortElements", "tpe", "The port elements of the pre-trained model to use as input to the subsequent linear predictor e.g. \"1115.output\" to use the full output from Node 1115", ""); parser.AddOption(removeLastLayers, "removeLastLayers", "rem", "Instead of using a node id, a neural network model can be retargeted by removing the last N layers", 0); parser.AddOption( inputDataFilename, "inputDataFilename", "idf", "Path to the input dataset file", ""); parser.AddOption( multiClass, "multiClass", "mc", "Indicates whether the input dataset is multi-class or binary.", false); parser.AddOption(normalize, "normalize", "n", "Perform sparsity-preserving normalization", false); parser.AddOption(regularization, "regularization", "r", "The L2 regularization parameter", 0.005); parser.AddOption(desiredPrecision, "desiredP
}
recision", "de", "The desired duality gap at which to stop optimizing", 1.0e-5); parser.AddOption(maxEpochs, "maxEpochs", "me", "The maximum number of optimization epochs to run", 1000); parser.AddOption(permute, "permute", "p", "Whether or not to randomly permute the training data before each epoch", true); parser.AddOption(randomSeedString, "randomSeedString", "seed", "The random seed string", "ABCDEFG"); parser.AddOption( verbose, "verbose", "v", "Print diagnostic output during the execution of the tool to stdout", false); parser.AddOption( lossFunctionArguments.lossFunction, "lossFunction", "lf", "Choice of loss function", { { "squared", LossFunctionArguments::LossFunction::squared }, { "log", LossFunctionArguments::LossFunction::log }, {"smoothHinge", LossFunctionArguments::LossFunction::smoothHinge} }, "log"); parser.AddOption( useBlas, "blas", "", "Emit code that calls BLAS, used when compiling the input model to create mapped datasets", true); }
function_block-function_prefixed
[ { "content": "class NeuralNetworkPredictorNode : public model::Node\n\n{\n\npublic:\n\n /// @name Input and Output Ports\n\n /// @{\n\n const model::InputPort<ValueType>& input = _input;\n\n const model::OutputPort<ValueType>& output = _output;\n\n /// @}\n\n\n\n using PredictorType = typename...
C++
src/Titon/Io/Node.hh
ciklon-z/framework
cbf44729173d3a83b91a2b0a217c6b3827512e44
<?hh namespace Titon\Io; use Titon\Io\Exception\MissingFileException; use Titon\Io\Exception\ExistingFileException; use Titon\Utility\Path; abstract class Node { const int OVERWRITE = 0; const int MERGE = 1; const int SKIP = 2; protected ?Folder $parent; protected string $path = ''; public function __construct(string $path, bool $create = false, int $mode = 0755) { $this->reset($path); if ($create) { $this->create($mode); } } public function accessTime(): int { if ($this->exists()) { return fileatime($this->path()); } return 0; } public function basename(): string { return pathinfo($this->path(), PATHINFO_BASENAME); } public function changeTime(): int { if ($this->exists()) { return filectime($this->path()); } return 0; } public function chgrp(int $group, bool $recursive = false): bool { if (!$this->exists()) { return false; } $path = $this->path(); $this->reset(); if (is_link($path)) { return lchgrp($path, $group); } return chgrp($path, $group); } public function chmod(int $mode, bool $recursive = false): bool { if (!$this->exists()) { return false; } $this->reset(); return chmod($this->path(), $mode); } public function chown(int $user, bool $recursive = false): bool { if (!$this->exists()) { return false; } $path = $this->path(); $this->reset(); if (is_link($path)) { return lchown($path, $user); } return chown($path, $user); } abstract public function copy(string $target, int $process = self::OVERWRITE, int $mode = 0755): ?Node; abstract public function create(int $mode = 0755): bool; abstract public function delete(): bool; public static function destroy(string $path): bool { if (!file_exists($path)) { return false; } return static::load($path)->delete(); } public function dir(): string { return dirname($this->path()) . '/'; } public function executable(): bool { return is_executable($this->path()); } public function exists(): bool { return file_exists($this->path()); } public function group(): int { if ($this->exists()) { return filegroup($this->path()); } return 0; } public function isAbsolute(): bool { return Path::isAbsolute($this->path()); } public function isRelative(): bool { return Path::isRelative($this->path()); } public static function load(string $path): Node { if (!file_exists($path)) { throw new MissingFileException(sprintf('No file or folder found at %s', $path)); } if (is_dir($path)) { return new Folder($path); } return new File($path); } public function modifyTime(): int { if ($this->exists()) { return filemtime($this->path()); } return 0; } public function move(string $target, bool $overwrite = true): bool { if (!$this->exists()) { return false; } if (file_exists($target)) { if ($overwrite) { static::destroy($target); } else { throw new ExistingFileException('Cannot move file as the target already exists'); } } if (rename($this->path(), $target)) { $this->reset($target); return true; } return false; } public function name(): string { return pathinfo($this->path(), PATHINFO_FILENAME); } public function owner(): int { if ($this->exists()) { return fileowner($this->path()); } return 0; } public function path(): string { return $this->pwd(); } public function parent(): ?Folder { if ($this->parent) { return $this->parent; } $folder = str_replace('\\', '/', dirname($this->path())); if ($folder !== '.' && $folder !== '/') { $this->parent = new Folder($folder); } return $this->parent; } public function permissions(): string { if ($this->exists()) { return substr(sprintf('%o', fileperms($this->path())), -4); } return ''; } public function pwd(): string { return $this->path; } public function readable(): bool { return is_readable($this->path()); } public function rename(string $name, bool $overwrite = true): bool { if (!$this->exists()) { return false; } $name = preg_replace('/[^_\-\p{Ll}\p{Lm}\p{Lo}\p{Lt}\p{Lu}\p{Nd}]/imu', '-', basename($name)); if ($name === $this->name()) { return true; } $target = $this->dir() . $name; if (file_exists($target)) { if ($overwrite) { static::destroy($target); } else { throw new ExistingFileException('Cannot rename file as the target already exists'); } } if (rename($this->path(), $target)) { $this->reset($target); return true; } return false; } public function reset(string $path = ''): this { if ($path) { $this->path = str_replace('\\', '/', $path); } clearstatcache(); return $this; } abstract public function size(): int; public function writable(): bool { return is_writable($this->path()); } }
<?hh namespace Titon\Io; use Titon\Io\Exception\MissingFileException; use Titon\Io\Exception\ExistingFileException; use Titon\Utility\Path; abstract class Node { const int OVERWRITE = 0; const int MERGE = 1; const int SKIP = 2; protected ?Folder $parent; protected string $path = ''; public function __construct(string $path, bool $create = false, int $mode = 0755) { $this->reset($path); if ($create) { $this->create($mode); } } public function accessTime(): int { if ($this->exists()) { return fileatime($this->path()); } return 0; } public function basename(): string { return pathinfo($this->path(), PATHINFO_BASENAME); } public function changeTime(): int { if ($this->exists()) { return filectime($this->path()); } return 0; } public function chgrp(int $group, bool $recursive = false): bool { if (!$this->exists()) { return false; } $path = $this->path(); $this->reset(); if (is_link($path)) { return lchgrp($path, $group); } return chgrp($path, $group); } public function chmod(int $mode, bool $recursive = false): bool { if (!$this->exists()) { return false; } $this->reset(); return chmod($this
public function modifyTime(): int { if ($this->exists()) { return filemtime($this->path()); } return 0; } public function move(string $target, bool $overwrite = true): bool { if (!$this->exists()) { return false; } if (file_exists($target)) { if ($overwrite) { static::destroy($target); } else { throw new ExistingFileException('Cannot move file as the target already exists'); } } if (rename($this->path(), $target)) { $this->reset($target); return true; } return false; } public function name(): string { return pathinfo($this->path(), PATHINFO_FILENAME); } public function owner(): int { if ($this->exists()) { return fileowner($this->path()); } return 0; } public function path(): string { return $this->pwd(); } public function parent(): ?Folder { if ($this->parent) { return $this->parent; } $folder = str_replace('\\', '/', dirname($this->path())); if ($folder !== '.' && $folder !== '/') { $this->parent = new Folder($folder); } return $this->parent; } public function permissions(): string { if ($this->exists()) { return substr(sprintf('%o', fileperms($this->path())), -4); } return ''; } public function pwd(): string { return $this->path; } public function readable(): bool { return is_readable($this->path()); } public function rename(string $name, bool $overwrite = true): bool { if (!$this->exists()) { return false; } $name = preg_replace('/[^_\-\p{Ll}\p{Lm}\p{Lo}\p{Lt}\p{Lu}\p{Nd}]/imu', '-', basename($name)); if ($name === $this->name()) { return true; } $target = $this->dir() . $name; if (file_exists($target)) { if ($overwrite) { static::destroy($target); } else { throw new ExistingFileException('Cannot rename file as the target already exists'); } } if (rename($this->path(), $target)) { $this->reset($target); return true; } return false; } public function reset(string $path = ''): this { if ($path) { $this->path = str_replace('\\', '/', $path); } clearstatcache(); return $this; } abstract public function size(): int; public function writable(): bool { return is_writable($this->path()); } }
->path(), $mode); } public function chown(int $user, bool $recursive = false): bool { if (!$this->exists()) { return false; } $path = $this->path(); $this->reset(); if (is_link($path)) { return lchown($path, $user); } return chown($path, $user); } abstract public function copy(string $target, int $process = self::OVERWRITE, int $mode = 0755): ?Node; abstract public function create(int $mode = 0755): bool; abstract public function delete(): bool; public static function destroy(string $path): bool { if (!file_exists($path)) { return false; } return static::load($path)->delete(); } public function dir(): string { return dirname($this->path()) . '/'; } public function executable(): bool { return is_executable($this->path()); } public function exists(): bool { return file_exists($this->path()); } public function group(): int { if ($this->exists()) { return filegroup($this->path()); } return 0; } public function isAbsolute(): bool { return Path::isAbsolute($this->path()); } public function isRelative(): bool { return Path::isRelative($this->path()); } public static function load(string $path): Node { if (!file_exists($path)) { throw new MissingFileException(sprintf('No file or folder found at %s', $path)); } if (is_dir($path)) { return new Folder($path); } return new File($path); }
random
[ { "content": " public function copy(string $target, int $process = self::MERGE, int $mode = 0755): ?Node {\n\n if (!$this->exists()) {\n\n return null;\n\n }\n\n\n\n // Delete the target folder if overwrite is true\n\n if ($process === self::OVERWRITE && file_exists($ta...
C++
net/instaweb/rewriter/webp_optimizer.cc
dimitrilongo/mod_pagespeed
d0d3bc51aa4feddf010b7085872c64cc46b5aae0
#include "net/instaweb/rewriter/public/webp_optimizer.h" #include <csetjmp> #include <cstddef> #include "base/logging.h" #include "pagespeed/kernel/base/basictypes.h" #include "pagespeed/kernel/base/string.h" #include "pagespeed/kernel/image/jpeg_reader.h" #include "pagespeed/kernel/image/jpeg_utils.h" extern "C" { #ifdef USE_SYSTEM_LIBWEBP #include "webp/encode.h" #include "webp/decode.h" #else #include "third_party/libwebp/src/webp/encode.h" #include "third_party/libwebp/src/webp/decode.h" #endif } extern "C" { #ifdef USE_SYSTEM_LIBJPEG #include "jpeglib.h" #else #include "third_party/libjpeg_turbo/src/jpeglib.h" #endif } using pagespeed::image_compression::JpegUtils; namespace net_instaweb { class MessageHandler; namespace { const bool kUseYUV = false; const int kYPlane = 0; const int kUPlane = 1; const int kVPlane = 2; const int kPlanes = 3; #ifdef DCT_IFAST_SUPPORTED const J_DCT_METHOD fastest_dct_method = JDCT_IFAST; #else #ifdef DCT_FLOAT_SUPPORTED #else #endif #endif int GoogleStringWebpWriter(const uint8_t* data, size_t data_size, const WebPPicture* const picture) { GoogleString* compressed_webp = static_cast<GoogleString*>(picture->custom_ptr); compressed_webp->append(reinterpret_cast<const char*>(data), data_size); return 1; } class WebpOptimizer { public: explicit WebpOptimizer(MessageHandler* handler); ~WebpOptimizer(); bool CreateOptimizedWebp(const GoogleString& original_jpeg, int configured_quality, WebpProgressHook progress_hook, void* progress_hook_data, GoogleString* compressed_webp); private: size_t PixelOffset(size_t x, size_t y) const { return (kPlanes * x + y * row_stride_); } int SampleAt(int plane, int source_offset, int x_offset, int y_offset) const { return static_cast<int>(pixels_[plane + source_offset + PixelOffset(x_offset, y_offset)]); } bool DoReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg); bool ReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg); bool WebPImportYUV(WebPPicture* const picture); static int ProgressHook(int percent, const WebPPicture* picture); MessageHandler* message_handler_; pagespeed::image_compression::JpegReader reader_; uint8* pixels_; uint8** rows_; unsigned int width_, height_; size_t row_stride_; WebpProgressHook progress_hook_; void* progress_hook_data_; DISALLOW_COPY_AND_ASSIGN(WebpOptimizer); }; WebpOptimizer::WebpOptimizer(MessageHandler* handler) : message_handler_(handler), reader_(handler), pixels_(NULL), rows_(NULL), width_(0), height_(0), row_stride_(0), progress_hook_(NULL), progress_hook_data_(NULL) { } WebpOptimizer::~WebpOptimizer() { delete[] pixels_; DCHECK(rows_ == NULL); } bool WebpOptimizer::DoReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg) { jmp_buf env; if (setjmp(env)) { return false; } jpeg_decompress_struct* jpeg_decompress = reader_.decompress_struct(); jpeg_decompress->client_data = static_cast<void*>(&env); reader_.PrepareForRead(original_jpeg.data(), original_jpeg.size()); if (jpeg_read_header(jpeg_decompress, TRUE) != JPEG_HEADER_OK) { return false; } jpeg_decompress->out_color_space = color_space; jpeg_decompress->do_fancy_upsampling = TRUE; if (!jpeg_start_decompress(jpeg_decompress) || jpeg_decompress->output_components != kPlanes) { return false; } width_ = jpeg_decompress->output_width; height_ = jpeg_decompress->output_height; row_stride_ = width_ * jpeg_decompress->output_components * sizeof(*pixels_); pixels_ = new uint8[row_stride_ * height_]; rows_ = new uint8*[height_]; for (unsigned int i = 0; i < height_; ++i) { rows_[i] = pixels_ + PixelOffset(0, i); } while (jpeg_decompress->output_scanline < height_) { int rows_read = jpeg_read_scanlines(jpeg_decompress, rows_ + jpeg_decompress->output_scanline, height_ - jpeg_decompress->output_scanline); if (rows_read == 0) { return false; } } return jpeg_finish_decompress(jpeg_decompress); } bool WebpOptimizer::ReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg) { bool read_ok = DoReadJpegPixels(color_space, original_jpeg); delete[] rows_; rows_ = NULL; jpeg_decompress_struct* jpeg_decompress = reader_.decompress_struct(); jpeg_decompress->client_data = NULL; jpeg_destroy_decompress(jpeg_decompress); return read_ok; } bool WebpOptimizer::WebPImportYUV(WebPPicture* const picture) { if (!WebPPictureAlloc(picture)) { return false; } for (size_t y = 0; y < height_; ++y) { for (size_t x = 0; x < width_; ++x) { picture->y[x + y * picture->y_stride] = pixels_[kYPlane + PixelOffset(x, y)]; } } unsigned int half_height = height_ >> 1; unsigned int half_width = width_ >> 1; unsigned int extra_height = height_ & 1; unsigned int extra_width = width_ & 1; size_t x, y; for (y = 0; y < half_height; ++y) { for (x = 0; x < half_width; ++x) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0) + SampleAt(kUPlane, source_offset, 1, 0) + SampleAt(kUPlane, source_offset, 0, 1) + SampleAt(kUPlane, source_offset, 1, 1); picture->u[picture_offset] = (2 + pixel_sum_u) >> 2; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0) + SampleAt(kVPlane, source_offset, 1, 0) + SampleAt(kVPlane, source_offset, 0, 1) + SampleAt(kVPlane, source_offset, 1, 1); picture->v[picture_offset] = (2 + pixel_sum_v) >> 2; } if (extra_width != 0) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0) + SampleAt(kUPlane, source_offset, 0, 1); picture->u[picture_offset] = (1 + pixel_sum_u) >> 1; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0) + SampleAt(kVPlane, source_offset, 0, 1); picture->v[picture_offset] = (1 + pixel_sum_v) >> 1; } } if (extra_height != 0) { for (x = 0; x < half_width; ++x) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0) + SampleAt(kUPlane, source_offset, 1, 0); picture->u[picture_offset] = (1 + pixel_sum_u) >> 1; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0) + SampleAt(kVPlane, source_offset, 1, 0); picture->v[picture_offset] = (1 + pixel_sum_v) >> 1; } if (extra_width != 0) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0); picture->u[picture_offset] = pixel_sum_u; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0); picture->v[picture_offset] = pixel_sum_v; } } return true; } int WebpOptimizer::ProgressHook(int percent, const WebPPicture* picture) { const WebpOptimizer* webp_optimizer = static_cast<WebpOptimizer*>(picture->user_data); return webp_optimizer->progress_hook_(percent, webp_optimizer->progress_hook_data_); } bool WebpOptimizer::CreateOptimizedWebp( const GoogleString& original_jpeg, int configured_quality, WebpProgressHook progress_hook, void* progress_hook_data, GoogleString* compressed_webp) { WebPPicture picture; WebPConfig config; int input_quality = JpegUtils::GetImageQualityFromImage(original_jpeg.data(), original_jpeg.size(), message_handler_); if (!WebPPictureInit(&picture) || !WebPConfigInit(&config)) { return false; } if (configured_quality == kNoQualityGiven) { configured_quality = config.quality; } int output_quality = configured_quality; if (input_quality != kNoQualityGiven && input_quality < configured_quality) { output_quality = input_quality; } else { output_quality = configured_quality; } if (!WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, output_quality)) { return false; } else { config.method = 3; if (!WebPValidateConfig(&config)) { return false; } } J_COLOR_SPACE color_space = kUseYUV ? JCS_YCbCr : JCS_RGB; if (!ReadJpegPixels(color_space, original_jpeg)) { return false; } picture.writer = &GoogleStringWebpWriter; picture.custom_ptr = static_cast<void*>(compressed_webp); picture.width = width_; picture.height = height_; if (progress_hook != NULL) { picture.progress_hook = ProgressHook; picture.user_data = this; progress_hook_ = progress_hook; progress_hook_data_ = progress_hook_data; } if (kUseYUV) { if (!WebPImportYUV(&picture)) { return false; } } else if (!WebPPictureImportRGB(&picture, pixels_, row_stride_)) { return false; } delete[] pixels_; pixels_ = NULL; bool result = WebPEncode(&config, &picture); WebPPictureFree(&picture); return result; } } bool OptimizeWebp(const GoogleString& original_jpeg, int configured_quality, WebpProgressHook progress_hook, void* progress_hook_data, GoogleString* compressed_webp, MessageHandler* message_handler) { WebpOptimizer optimizer(message_handler); return optimizer.CreateOptimizedWebp(original_jpeg, configured_quality, progress_hook, progress_hook_data, compressed_webp); } static bool WebPDecBufferToPicture(const WebPDecBuffer* const buf, WebPPicture* const picture) { const WebPYUVABuffer* const yuva = &buf->u.YUVA; if ((yuva->u_stride != yuva->v_stride) || (buf->colorspace != MODE_YUVA)) { return false; } picture->width = buf->width; picture->height = buf->height; picture->y = yuva->y; picture->u = yuva->u; picture->v = yuva->v; picture->a = yuva->a; picture->y_stride = yuva->y_stride; picture->uv_stride = yuva->u_stride; picture->a_stride = yuva->a_stride; picture->colorspace = WEBP_YUV420A; return true; } bool ReduceWebpImageQuality(const GoogleString& original_webp, int quality, GoogleString* compressed_webp) { if (quality < 1) { *compressed_webp = original_webp; return true; } else if (quality > 100) { quality = 100; } const uint8* webp = reinterpret_cast<const uint8*>(original_webp.data()); const int webp_size = original_webp.size(); WebPConfig config; if (WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, quality) == 0) { return false; } WebPPicture picture; if (WebPPictureInit(&picture) == 0) { return false; } WebPDecoderConfig dec_config; WebPInitDecoderConfig(&dec_config); WebPDecBuffer* const output_buffer = &dec_config.output; output_buffer->colorspace = MODE_YUVA; bool success = ((WebPDecode(webp, webp_size, &dec_config) == VP8_STATUS_OK) && WebPDecBufferToPicture(output_buffer, &picture)); if (success) { picture.writer = &GoogleStringWebpWriter; picture.custom_ptr = reinterpret_cast<void*>(compressed_webp); success = WebPEncode(&config, &picture); } WebPFreeDecBuffer(output_buffer); return success; } }
#include "net/instaweb/rewriter/public/webp_optimizer.h" #include <csetjmp> #include <cstddef> #include "base/logging.h" #include "pagespeed/kernel/base/basictypes.h" #include "pagespeed/kernel/base/string.h" #include "pagespeed/kernel/image/jpeg_reader.h" #include "pagespeed/kernel/image/jpeg_utils.h" extern "C" { #ifdef USE_SYSTEM_LIBWEBP #include "webp/encode.h" #include "webp/decode.h" #else #include "third_party/libwebp/src/webp/encode.h" #include "third_party/libwebp/src/webp/decode.h" #endif } extern "C" { #ifdef USE_SYSTEM_LIBJPEG #include "jpeglib.h" #else #include "third_party/libjpeg_turbo/src/jpeglib.h" #endif } using pagespeed::image_compression::JpegUtils; namespace net_instaweb { class MessageHandler; namespace { const bool kUseYUV = false; const int kYPlane = 0; const int kUPlane = 1; const int kVPlane = 2; const int kPlanes = 3; #ifdef DCT_IFAST_SUPPORTED const J_DCT_METHOD fastest_dct_method = JDCT_IFAST; #else #ifdef DCT_FLOAT_SUPPORTED #else #endif #endif
class WebpOptimizer { public: explicit WebpOptimizer(MessageHandler* handler); ~WebpOptimizer(); bool CreateOptimizedWebp(const GoogleString& original_jpeg, int configured_quality, WebpProgressHook progress_hook, void* progress_hook_data, GoogleString* compressed_webp); private: size_t PixelOffset(size_t x, size_t y) const { return (kPlanes * x + y * row_stride_); } int SampleAt(int plane, int source_offset, int x_offset, int y_offset) const { return static_cast<int>(pixels_[plane + source_offset + PixelOffset(x_offset, y_offset)]); } bool DoReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg); bool ReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg); bool WebPImportYUV(WebPPicture* const picture); static int ProgressHook(int percent, const WebPPicture* picture); MessageHandler* message_handler_; pagespeed::image_compression::JpegReader reader_; uint8* pixels_; uint8** rows_; unsigned int width_, height_; size_t row_stride_; WebpProgressHook progress_hook_; void* progress_hook_data_; DISALLOW_COPY_AND_ASSIGN(WebpOptimizer); }; WebpOptimizer::WebpOptimizer(MessageHandler* handler) : message_handler_(handler), reader_(handler), pixels_(NULL), rows_(NULL), width_(0), height_(0), row_stride_(0), progress_hook_(NULL), progress_hook_data_(NULL) { } WebpOptimizer::~WebpOptimizer() { delete[] pixels_; DCHECK(rows_ == NULL); } bool WebpOptimizer::DoReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg) { jmp_buf env; if (setjmp(env)) { return false; } jpeg_decompress_struct* jpeg_decompress = reader_.decompress_struct(); jpeg_decompress->client_data = static_cast<void*>(&env); reader_.PrepareForRead(original_jpeg.data(), original_jpeg.size()); if (jpeg_read_header(jpeg_decompress, TRUE) != JPEG_HEADER_OK) { return false; } jpeg_decompress->out_color_space = color_space; jpeg_decompress->do_fancy_upsampling = TRUE; if (!jpeg_start_decompress(jpeg_decompress) || jpeg_decompress->output_components != kPlanes) { return false; } width_ = jpeg_decompress->output_width; height_ = jpeg_decompress->output_height; row_stride_ = width_ * jpeg_decompress->output_components * sizeof(*pixels_); pixels_ = new uint8[row_stride_ * height_]; rows_ = new uint8*[height_]; for (unsigned int i = 0; i < height_; ++i) { rows_[i] = pixels_ + PixelOffset(0, i); } while (jpeg_decompress->output_scanline < height_) { int rows_read = jpeg_read_scanlines(jpeg_decompress, rows_ + jpeg_decompress->output_scanline, height_ - jpeg_decompress->output_scanline); if (rows_read == 0) { return false; } } return jpeg_finish_decompress(jpeg_decompress); } bool WebpOptimizer::ReadJpegPixels(J_COLOR_SPACE color_space, const GoogleString& original_jpeg) { bool read_ok = DoReadJpegPixels(color_space, original_jpeg); delete[] rows_; rows_ = NULL; jpeg_decompress_struct* jpeg_decompress = reader_.decompress_struct(); jpeg_decompress->client_data = NULL; jpeg_destroy_decompress(jpeg_decompress); return read_ok; } bool WebpOptimizer::WebPImportYUV(WebPPicture* const picture) { if (!WebPPictureAlloc(picture)) { return false; } for (size_t y = 0; y < height_; ++y) { for (size_t x = 0; x < width_; ++x) { picture->y[x + y * picture->y_stride] = pixels_[kYPlane + PixelOffset(x, y)]; } } unsigned int half_height = height_ >> 1; unsigned int half_width = width_ >> 1; unsigned int extra_height = height_ & 1; unsigned int extra_width = width_ & 1; size_t x, y; for (y = 0; y < half_height; ++y) { for (x = 0; x < half_width; ++x) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0) + SampleAt(kUPlane, source_offset, 1, 0) + SampleAt(kUPlane, source_offset, 0, 1) + SampleAt(kUPlane, source_offset, 1, 1); picture->u[picture_offset] = (2 + pixel_sum_u) >> 2; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0) + SampleAt(kVPlane, source_offset, 1, 0) + SampleAt(kVPlane, source_offset, 0, 1) + SampleAt(kVPlane, source_offset, 1, 1); picture->v[picture_offset] = (2 + pixel_sum_v) >> 2; } if (extra_width != 0) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0) + SampleAt(kUPlane, source_offset, 0, 1); picture->u[picture_offset] = (1 + pixel_sum_u) >> 1; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0) + SampleAt(kVPlane, source_offset, 0, 1); picture->v[picture_offset] = (1 + pixel_sum_v) >> 1; } } if (extra_height != 0) { for (x = 0; x < half_width; ++x) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0) + SampleAt(kUPlane, source_offset, 1, 0); picture->u[picture_offset] = (1 + pixel_sum_u) >> 1; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0) + SampleAt(kVPlane, source_offset, 1, 0); picture->v[picture_offset] = (1 + pixel_sum_v) >> 1; } if (extra_width != 0) { int source_offset = PixelOffset(2 * x, 2 * y); int picture_offset = x + y * picture->uv_stride; int pixel_sum_u = SampleAt(kUPlane, source_offset, 0, 0); picture->u[picture_offset] = pixel_sum_u; int pixel_sum_v = SampleAt(kVPlane, source_offset, 0, 0); picture->v[picture_offset] = pixel_sum_v; } } return true; } int WebpOptimizer::ProgressHook(int percent, const WebPPicture* picture) { const WebpOptimizer* webp_optimizer = static_cast<WebpOptimizer*>(picture->user_data); return webp_optimizer->progress_hook_(percent, webp_optimizer->progress_hook_data_); } bool WebpOptimizer::CreateOptimizedWebp( const GoogleString& original_jpeg, int configured_quality, WebpProgressHook progress_hook, void* progress_hook_data, GoogleString* compressed_webp) { WebPPicture picture; WebPConfig config; int input_quality = JpegUtils::GetImageQualityFromImage(original_jpeg.data(), original_jpeg.size(), message_handler_); if (!WebPPictureInit(&picture) || !WebPConfigInit(&config)) { return false; } if (configured_quality == kNoQualityGiven) { configured_quality = config.quality; } int output_quality = configured_quality; if (input_quality != kNoQualityGiven && input_quality < configured_quality) { output_quality = input_quality; } else { output_quality = configured_quality; } if (!WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, output_quality)) { return false; } else { config.method = 3; if (!WebPValidateConfig(&config)) { return false; } } J_COLOR_SPACE color_space = kUseYUV ? JCS_YCbCr : JCS_RGB; if (!ReadJpegPixels(color_space, original_jpeg)) { return false; } picture.writer = &GoogleStringWebpWriter; picture.custom_ptr = static_cast<void*>(compressed_webp); picture.width = width_; picture.height = height_; if (progress_hook != NULL) { picture.progress_hook = ProgressHook; picture.user_data = this; progress_hook_ = progress_hook; progress_hook_data_ = progress_hook_data; } if (kUseYUV) { if (!WebPImportYUV(&picture)) { return false; } } else if (!WebPPictureImportRGB(&picture, pixels_, row_stride_)) { return false; } delete[] pixels_; pixels_ = NULL; bool result = WebPEncode(&config, &picture); WebPPictureFree(&picture); return result; } } bool OptimizeWebp(const GoogleString& original_jpeg, int configured_quality, WebpProgressHook progress_hook, void* progress_hook_data, GoogleString* compressed_webp, MessageHandler* message_handler) { WebpOptimizer optimizer(message_handler); return optimizer.CreateOptimizedWebp(original_jpeg, configured_quality, progress_hook, progress_hook_data, compressed_webp); } static bool WebPDecBufferToPicture(const WebPDecBuffer* const buf, WebPPicture* const picture) { const WebPYUVABuffer* const yuva = &buf->u.YUVA; if ((yuva->u_stride != yuva->v_stride) || (buf->colorspace != MODE_YUVA)) { return false; } picture->width = buf->width; picture->height = buf->height; picture->y = yuva->y; picture->u = yuva->u; picture->v = yuva->v; picture->a = yuva->a; picture->y_stride = yuva->y_stride; picture->uv_stride = yuva->u_stride; picture->a_stride = yuva->a_stride; picture->colorspace = WEBP_YUV420A; return true; } bool ReduceWebpImageQuality(const GoogleString& original_webp, int quality, GoogleString* compressed_webp) { if (quality < 1) { *compressed_webp = original_webp; return true; } else if (quality > 100) { quality = 100; } const uint8* webp = reinterpret_cast<const uint8*>(original_webp.data()); const int webp_size = original_webp.size(); WebPConfig config; if (WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, quality) == 0) { return false; } WebPPicture picture; if (WebPPictureInit(&picture) == 0) { return false; } WebPDecoderConfig dec_config; WebPInitDecoderConfig(&dec_config); WebPDecBuffer* const output_buffer = &dec_config.output; output_buffer->colorspace = MODE_YUVA; bool success = ((WebPDecode(webp, webp_size, &dec_config) == VP8_STATUS_OK) && WebPDecBufferToPicture(output_buffer, &picture)); if (success) { picture.writer = &GoogleStringWebpWriter; picture.custom_ptr = reinterpret_cast<void*>(compressed_webp); success = WebPEncode(&config, &picture); } WebPFreeDecBuffer(output_buffer); return success; } }
int GoogleStringWebpWriter(const uint8_t* data, size_t data_size, const WebPPicture* const picture) { GoogleString* compressed_webp = static_cast<GoogleString*>(picture->custom_ptr); compressed_webp->append(reinterpret_cast<const char*>(data), data_size); return 1; }
function_block-full_function
[ { "content": "// Bool that is auto-initialized to false\n\nclass Bool {\n\n public:\n\n Bool() : value_(false) {}\n\n Bool(bool value) : value_(value) {} // Copy constructor // NOLINT\n\n const bool Test() const { return value_; }\n\n\n\n private:\n\n bool value_;\n\n};\n\n\n", "file_path": "pagespeed/...
C++
lite/tnn/cv/tnn_rvm.cpp
azuredsky/lite.ai
2751a7f0cf0970c1ab94b865b96c2f53ee28d545
#include "tnn_rvm.h" using tnncv::TNNRobustVideoMatting; TNNRobustVideoMatting::TNNRobustVideoMatting( const std::string &_proto_path, const std::string &_model_path, unsigned int _num_threads ) : proto_path(_proto_path.data()), model_path(_model_path.data()), log_id(_proto_path.data()), num_threads(_num_threads) { initialize_instance(); initialize_context(); } TNNRobustVideoMatting::~TNNRobustVideoMatting() { net = nullptr; src_mat = nullptr; r1i_mat = nullptr; r2i_mat = nullptr; r3i_mat = nullptr; r4i_mat = nullptr; instance = nullptr; } void TNNRobustVideoMatting::initialize_instance() { std::string proto_content_buffer, model_content_buffer; proto_content_buffer = BasicTNNHandler::content_buffer_from(proto_path); model_content_buffer = BasicTNNHandler::content_buffer_from(model_path); tnn::ModelConfig model_config; model_config.model_type = tnn::MODEL_TYPE_TNN; model_config.params = {proto_content_buffer, model_content_buffer}; tnn::Status status; net = std::make_shared<tnn::TNN>(); status = net->Init(model_config); if (status != tnn::TNN_OK || !net) { #ifdef LITETNN_DEBUG std::cout << "net->Init failed!\n"; #endif return; } #ifdef __ANDROID__ network_device_type = tnn::DEVICE_ARM; input_device_type = tnn::DEVICE_ARM; output_device_type = tnn::DEVICE_ARM; #else network_device_type = tnn::DEVICE_X86; input_device_type = tnn::DEVICE_X86; output_device_type = tnn::DEVICE_X86; #endif tnn::NetworkConfig network_config; network_config.library_path = {""}; network_config.device_type = network_device_type; instance = net->CreateInst(network_config, status); if (status != tnn::TNN_OK || !instance) { #ifdef LITETNN_DEBUG std::cout << "CreateInst failed!" << status.description().c_str() << "\n"; #endif return; } instance->SetCpuNumThreads((int) num_threads); for (auto &name: input_names) input_shapes[name] = BasicTNNHandler::get_input_shape(instance, name); auto src_shape = input_shapes.at("src"); if (src_shape.size() != 4) { #ifdef LITETNN_DEBUG throw std::runtime_error("Found src_shape.size()!=4, but " "src input only support 4 dims." "Such as NCHW, NHWC ..."); #else return; #endif } input_mat_type = BasicTNNHandler::get_input_mat_type(instance, "src"); input_data_format = BasicTNNHandler::get_input_data_format(instance, "src"); if (input_data_format == tnn::DATA_FORMAT_NCHW) { input_height = src_shape.at(2); input_width = src_shape.at(3); } else if (input_data_format == tnn::DATA_FORMAT_NHWC) { input_height = src_shape.at(1); input_width = src_shape.at(2); } else { #ifdef LITETNN_DEBUG std::cout << "src input only support NCHW and NHWC " "input_data_format, but found others.\n"; #endif return; } src_size = 1 * 3 * input_height * input_width; for (auto &name: output_names) output_shapes[name] = BasicTNNHandler::get_output_shape(instance, name); #ifdef LITETNN_DEBUG this->print_debug_string(); #endif } int TNNRobustVideoMatting::value_size_of(tnn::DimsVector &shape) { if (shape.empty()) return 0; int _size = 1; for (auto &s: shape) _size *= s; return _size; } void TNNRobustVideoMatting::print_debug_string() { std::cout << "LITETNN_DEBUG LogId: " << log_id << "\n"; std::cout << "=============== Input-Dims ==============\n"; for (auto &in: input_shapes) BasicTNNHandler::print_name_shape(in.first, in.second); std::string data_format_string = (input_data_format == tnn::DATA_FORMAT_NCHW) ? "NCHW" : "NHWC"; std::cout << "Input Data Format: " << data_format_string << "\n"; std::cout << "=============== Output-Dims ==============\n"; for (auto &out: output_shapes) BasicTNNHandler::print_name_shape(out.first, out.second); std::cout << "========================================\n"; } void TNNRobustVideoMatting::initialize_context() { r1i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r1i") ); r2i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r2i") ); r3i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r3i") ); r4i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r4i") ); r1i_size = this->value_size_of(input_shapes.at("r1i")); r2i_size = this->value_size_of(input_shapes.at("r2i")); r3i_size = this->value_size_of(input_shapes.at("r3i")); r4i_size = this->value_size_of(input_shapes.at("r4i")); std::fill_n((float *) r1i_mat->GetData(), r1i_size, 0.f); std::fill_n((float *) r2i_mat->GetData(), r2i_size, 0.f); std::fill_n((float *) r3i_mat->GetData(), r3i_size, 0.f); std::fill_n((float *) r4i_mat->GetData(), r4i_size, 0.f); context_is_initialized = true; } void TNNRobustVideoMatting::transform(const cv::Mat &mat) { cv::Mat canvas; cv::resize(mat, canvas, cv::Size(input_width, input_height)); cv::cvtColor(canvas, canvas, cv::COLOR_BGR2RGB); src_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::N8UC3, input_shapes.at("src"), (void *) canvas.data ); if (!src_mat->GetData()) { #ifdef LITETNN_DEBUG std::cout << "input_mat == nullptr! transform failed\n"; #endif } } void TNNRobustVideoMatting::detect(const cv::Mat &mat, types::MattingContent &content, bool video_mode) { if (mat.empty()) return; int img_h = mat.rows; int img_w = mat.cols; if (!context_is_initialized) return; this->transform(mat); tnn::MatConvertParam src_cvt_param, ctx_cvt_param; src_cvt_param.scale = scale_vals; src_cvt_param.bias = bias_vals; tnn::Status status_src, status_r1i, status_r2i, status_r3i, status_r4i; status_src = instance->SetInputMat(src_mat, src_cvt_param, "src"); status_r1i = instance->SetInputMat(r1i_mat, ctx_cvt_param, "r1i"); status_r2i = instance->SetInputMat(r2i_mat, ctx_cvt_param, "r2i"); status_r3i = instance->SetInputMat(r3i_mat, ctx_cvt_param, "r3i"); status_r4i = instance->SetInputMat(r4i_mat, ctx_cvt_param, "r4i"); if (status_src != tnn::TNN_OK || status_r1i != tnn::TNN_OK || status_r2i != tnn::TNN_OK || status_r3i != tnn::TNN_OK || status_r4i != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->SetInputMat failed!:" << status_src.description().c_str() << ": " << status_r1i.description().c_str() << ": " << status_r2i.description().c_str() << ": " << status_r3i.description().c_str() << ": " << status_r4i.description().c_str() << "\n"; #endif return; } auto status = instance->Forward(); if (status != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->Forward failed!:" << status.description().c_str() << "\n"; #endif return; } this->generate_matting(instance, content, img_h, img_w); if (video_mode) { context_is_update = false; this->update_context(instance); } } void TNNRobustVideoMatting::detect_video( const std::string &video_path, const std::string &output_path, std::vector<types::MattingContent> &contents, bool save_contents, unsigned int writer_fps) { cv::VideoCapture video_capture(video_path); const unsigned int width = video_capture.get(cv::CAP_PROP_FRAME_WIDTH); const unsigned int height = video_capture.get(cv::CAP_PROP_FRAME_HEIGHT); const unsigned int frame_count = video_capture.get(cv::CAP_PROP_FRAME_COUNT); if (!video_capture.isOpened()) { std::cout << "Can not open video: " << video_path << "\n"; return; } cv::VideoWriter video_writer(output_path, cv::VideoWriter::fourcc('m', 'p', '4', 'v'), writer_fps, cv::Size(width, height)); if (!video_writer.isOpened()) { std::cout << "Can not open writer: " << output_path << "\n"; return; } cv::Mat mat; unsigned int i = 0; while (video_capture.read(mat)) { i += 1; types::MattingContent content; this->detect(mat, content, true); if (content.flag) { if (save_contents) contents.push_back(content); if (!content.merge_mat.empty()) video_writer.write(content.merge_mat); } if (!context_is_update) break; #ifdef LITETNN_DEBUG std::cout << i << "/" << frame_count << " done!" << "\n"; #endif } video_capture.release(); video_writer.release(); } void TNNRobustVideoMatting::generate_matting(std::shared_ptr<tnn::Instance> &_instance, types::MattingContent &content, int img_h, int img_w) { std::shared_ptr<tnn::Mat> fgr_mat; std::shared_ptr<tnn::Mat> pha_mat; tnn::MatConvertParam cvt_param; tnn::Status status_fgr, status_pha; status_fgr = _instance->GetOutputMat(fgr_mat, cvt_param, "fgr", output_device_type); status_pha = _instance->GetOutputMat(pha_mat, cvt_param, "pha", output_device_type); if (status_fgr != tnn::TNN_OK || status_pha != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->GetOutputMat failed!:" << status_fgr.description().c_str() << ": " << status_pha.description().c_str() << "\n"; #endif return; } float *fgr_ptr = (float *) fgr_mat->GetData(); float *pha_ptr = (float *) pha_mat->GetData(); const unsigned int channel_step = input_height * input_width; cv::Mat rmat(input_height, input_width, CV_32FC1, fgr_ptr); cv::Mat gmat(input_height, input_width, CV_32FC1, fgr_ptr + channel_step); cv::Mat bmat(input_height, input_width, CV_32FC1, fgr_ptr + 2 * channel_step); cv::Mat pmat(input_height, input_width, CV_32FC1, pha_ptr); rmat *= 255.f; bmat *= 255.f; gmat *= 255.f; cv::Mat rest = 1.f - pmat; cv::Mat mbmat = bmat.mul(pmat) + rest * 153.f; cv::Mat mgmat = gmat.mul(pmat) + rest * 255.f; cv::Mat mrmat = rmat.mul(pmat) + rest * 120.f; std::vector<cv::Mat> fgr_channel_mats, merge_channel_mats; fgr_channel_mats.push_back(bmat); fgr_channel_mats.push_back(gmat); fgr_channel_mats.push_back(rmat); merge_channel_mats.push_back(mbmat); merge_channel_mats.push_back(mgmat); merge_channel_mats.push_back(mrmat); content.pha_mat = pmat; cv::merge(fgr_channel_mats, content.fgr_mat); cv::merge(merge_channel_mats, content.merge_mat); content.fgr_mat.convertTo(content.fgr_mat, CV_8UC3); content.merge_mat.convertTo(content.merge_mat, CV_8UC3); if (img_w != input_width || img_h != input_height) { cv::resize(content.pha_mat, content.pha_mat, cv::Size(img_w, img_h)); cv::resize(content.fgr_mat, content.fgr_mat, cv::Size(img_w, img_h)); cv::resize(content.merge_mat, content.merge_mat, cv::Size(img_w, img_h)); } content.flag = true; } void TNNRobustVideoMatting::update_context(std::shared_ptr<tnn::Instance> &_instance) { std::shared_ptr<tnn::Mat> r1o_mat; std::shared_ptr<tnn::Mat> r2o_mat; std::shared_ptr<tnn::Mat> r3o_mat; std::shared_ptr<tnn::Mat> r4o_mat; tnn::MatConvertParam cvt_param; tnn::Status status_r1o; tnn::Status status_r2o; tnn::Status status_r3o; tnn::Status status_r4o; status_r1o = _instance->GetOutputMat(r1o_mat, cvt_param, "r1o", output_device_type); status_r2o = _instance->GetOutputMat(r2o_mat, cvt_param, "r2o", output_device_type); status_r3o = _instance->GetOutputMat(r3o_mat, cvt_param, "r3o", output_device_type); status_r4o = _instance->GetOutputMat(r4o_mat, cvt_param, "r4o", output_device_type); if (status_r1o != tnn::TNN_OK || status_r2o != tnn::TNN_OK || status_r3o != tnn::TNN_OK || status_r4o != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->GetOutputMat context failed!:" << status_r1o.description().c_str() << ": " << status_r2o.description().c_str() << ": " << status_r3o.description().c_str() << ": " << status_r4o.description().c_str() << "\n"; #endif return; } void *command_queue = nullptr; auto status_cmd = _instance->GetCommandQueue(&command_queue); if (status_cmd != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->GetCommandQueue failed!:" << status_cmd.description().c_str() << "\n"; #endif return; } tnn::MatUtils::Copy(*r1o_mat, *r1i_mat, command_queue); tnn::MatUtils::Copy(*r2o_mat, *r2i_mat, command_queue); tnn::MatUtils::Copy(*r3o_mat, *r3i_mat, command_queue); tnn::MatUtils::Copy(*r4o_mat, *r4i_mat, command_queue); context_is_update = true; }
#include "tnn_rvm.h" using tnncv::TNNRobustVideoMatting; TNNRobustVideoMatting::TNNRobustVideoMatting( const std::string &_proto_path, const std::string &_model_path, unsigned int _num_threads ) : proto_path(_proto_path.data()), model_path(_model_path.data()), log_id(_proto_path.data()), num_threads(_num_threads) { initialize_instance(); initialize_context(); } TNNRobustVideoMatting::~TNNRobustVideoMatting() { net = nullptr; src_mat = nullptr; r1i_mat = nullptr; r2i_mat = nullptr; r3i_mat = nullptr; r4i_mat = nullptr; instance = nullptr; } void TNNRobustVideoMatting::initialize_instance() { std::string proto_content_buffer, model_content_buffer; proto_content_buffer = BasicTNNHandler::content_buffer_from(proto_path); model_content_buffer = BasicTNNHandler::content_buffer_from(model_path); tnn::ModelConfig model_config; model_config.model_type = tnn::MODEL_TYPE_TNN; model_config.params = {proto_content_buffer, model_content_buffer}; tnn::Status status; net = std::make_shared<tnn::TNN>(); status = net->Init(model_config); if (status != tnn::TNN_OK || !net) { #ifdef LITETNN_DEBUG std::cout << "net->Init failed!\n"; #endif return; } #ifdef __ANDROID__ network_device_type = tnn::DEVICE_ARM; input_device_type = tnn::DEVICE_ARM; output_device_type = tnn::DEVICE_ARM; #else network_device_type = tnn::DEVICE_X86; input_device_type = tnn::DEVICE_X86; output_device_type = tnn::DEVICE_X86; #endif tnn::NetworkConfig network_config; network_config.library_path = {""}; network_config.device_type = network_device_type; instance = net->CreateInst(network_config, status); if (status != tnn::TNN_OK || !instance) { #ifdef LITETNN_DEBUG std::cout << "CreateInst failed!" << status.description().c_str() << "\n"; #endif return; } instance->SetCpuNumThreads((int) num_threads); for (auto &name: input_names) input_shapes[name] = BasicTNNHandler::get_input_shape(instance, name); auto src_shape = input_shapes.at("src"); if (src_shape.size() != 4) { #ifdef LITETNN_DEBUG throw std::runtime_error("Found src_shape.size()!=4, but " "src input only support 4 dims." "Such as NCHW, NHWC ..."); #else return; #endif } input_mat_type = BasicTNNHandler::get_input_mat_type(instance, "src"); input_data_format = BasicTNNHandler::get_input_data_format(instance, "src"); if (input_data_format == tnn::DATA_FORMAT_NCHW) { input_height = src_shape.at(2); input_width = src_shape.at(3); } else if (input_data_format == tnn::DATA_FORMAT_NHWC) { input_height = src_shape.at(1); input_width = src_shape.at(2); }
int TNNRobustVideoMatting::value_size_of(tnn::DimsVector &shape) { if (shape.empty()) return 0; int _size = 1; for (auto &s: shape) _size *= s; return _size; } void TNNRobustVideoMatting::print_debug_string() { std::cout << "LITETNN_DEBUG LogId: " << log_id << "\n"; std::cout << "=============== Input-Dims ==============\n"; for (auto &in: input_shapes) BasicTNNHandler::print_name_shape(in.first, in.second); std::string data_format_string = (input_data_format == tnn::DATA_FORMAT_NCHW) ? "NCHW" : "NHWC"; std::cout << "Input Data Format: " << data_format_string << "\n"; std::cout << "=============== Output-Dims ==============\n"; for (auto &out: output_shapes) BasicTNNHandler::print_name_shape(out.first, out.second); std::cout << "========================================\n"; } void TNNRobustVideoMatting::initialize_context() { r1i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r1i") ); r2i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r2i") ); r3i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r3i") ); r4i_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::NCHW_FLOAT, input_shapes.at("r4i") ); r1i_size = this->value_size_of(input_shapes.at("r1i")); r2i_size = this->value_size_of(input_shapes.at("r2i")); r3i_size = this->value_size_of(input_shapes.at("r3i")); r4i_size = this->value_size_of(input_shapes.at("r4i")); std::fill_n((float *) r1i_mat->GetData(), r1i_size, 0.f); std::fill_n((float *) r2i_mat->GetData(), r2i_size, 0.f); std::fill_n((float *) r3i_mat->GetData(), r3i_size, 0.f); std::fill_n((float *) r4i_mat->GetData(), r4i_size, 0.f); context_is_initialized = true; } void TNNRobustVideoMatting::transform(const cv::Mat &mat) { cv::Mat canvas; cv::resize(mat, canvas, cv::Size(input_width, input_height)); cv::cvtColor(canvas, canvas, cv::COLOR_BGR2RGB); src_mat = std::make_shared<tnn::Mat>( input_device_type, tnn::N8UC3, input_shapes.at("src"), (void *) canvas.data ); if (!src_mat->GetData()) { #ifdef LITETNN_DEBUG std::cout << "input_mat == nullptr! transform failed\n"; #endif } } void TNNRobustVideoMatting::detect(const cv::Mat &mat, types::MattingContent &content, bool video_mode) { if (mat.empty()) return; int img_h = mat.rows; int img_w = mat.cols; if (!context_is_initialized) return; this->transform(mat); tnn::MatConvertParam src_cvt_param, ctx_cvt_param; src_cvt_param.scale = scale_vals; src_cvt_param.bias = bias_vals; tnn::Status status_src, status_r1i, status_r2i, status_r3i, status_r4i; status_src = instance->SetInputMat(src_mat, src_cvt_param, "src"); status_r1i = instance->SetInputMat(r1i_mat, ctx_cvt_param, "r1i"); status_r2i = instance->SetInputMat(r2i_mat, ctx_cvt_param, "r2i"); status_r3i = instance->SetInputMat(r3i_mat, ctx_cvt_param, "r3i"); status_r4i = instance->SetInputMat(r4i_mat, ctx_cvt_param, "r4i"); if (status_src != tnn::TNN_OK || status_r1i != tnn::TNN_OK || status_r2i != tnn::TNN_OK || status_r3i != tnn::TNN_OK || status_r4i != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->SetInputMat failed!:" << status_src.description().c_str() << ": " << status_r1i.description().c_str() << ": " << status_r2i.description().c_str() << ": " << status_r3i.description().c_str() << ": " << status_r4i.description().c_str() << "\n"; #endif return; } auto status = instance->Forward(); if (status != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->Forward failed!:" << status.description().c_str() << "\n"; #endif return; } this->generate_matting(instance, content, img_h, img_w); if (video_mode) { context_is_update = false; this->update_context(instance); } } void TNNRobustVideoMatting::detect_video( const std::string &video_path, const std::string &output_path, std::vector<types::MattingContent> &contents, bool save_contents, unsigned int writer_fps) { cv::VideoCapture video_capture(video_path); const unsigned int width = video_capture.get(cv::CAP_PROP_FRAME_WIDTH); const unsigned int height = video_capture.get(cv::CAP_PROP_FRAME_HEIGHT); const unsigned int frame_count = video_capture.get(cv::CAP_PROP_FRAME_COUNT); if (!video_capture.isOpened()) { std::cout << "Can not open video: " << video_path << "\n"; return; } cv::VideoWriter video_writer(output_path, cv::VideoWriter::fourcc('m', 'p', '4', 'v'), writer_fps, cv::Size(width, height)); if (!video_writer.isOpened()) { std::cout << "Can not open writer: " << output_path << "\n"; return; } cv::Mat mat; unsigned int i = 0; while (video_capture.read(mat)) { i += 1; types::MattingContent content; this->detect(mat, content, true); if (content.flag) { if (save_contents) contents.push_back(content); if (!content.merge_mat.empty()) video_writer.write(content.merge_mat); } if (!context_is_update) break; #ifdef LITETNN_DEBUG std::cout << i << "/" << frame_count << " done!" << "\n"; #endif } video_capture.release(); video_writer.release(); } void TNNRobustVideoMatting::generate_matting(std::shared_ptr<tnn::Instance> &_instance, types::MattingContent &content, int img_h, int img_w) { std::shared_ptr<tnn::Mat> fgr_mat; std::shared_ptr<tnn::Mat> pha_mat; tnn::MatConvertParam cvt_param; tnn::Status status_fgr, status_pha; status_fgr = _instance->GetOutputMat(fgr_mat, cvt_param, "fgr", output_device_type); status_pha = _instance->GetOutputMat(pha_mat, cvt_param, "pha", output_device_type); if (status_fgr != tnn::TNN_OK || status_pha != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->GetOutputMat failed!:" << status_fgr.description().c_str() << ": " << status_pha.description().c_str() << "\n"; #endif return; } float *fgr_ptr = (float *) fgr_mat->GetData(); float *pha_ptr = (float *) pha_mat->GetData(); const unsigned int channel_step = input_height * input_width; cv::Mat rmat(input_height, input_width, CV_32FC1, fgr_ptr); cv::Mat gmat(input_height, input_width, CV_32FC1, fgr_ptr + channel_step); cv::Mat bmat(input_height, input_width, CV_32FC1, fgr_ptr + 2 * channel_step); cv::Mat pmat(input_height, input_width, CV_32FC1, pha_ptr); rmat *= 255.f; bmat *= 255.f; gmat *= 255.f; cv::Mat rest = 1.f - pmat; cv::Mat mbmat = bmat.mul(pmat) + rest * 153.f; cv::Mat mgmat = gmat.mul(pmat) + rest * 255.f; cv::Mat mrmat = rmat.mul(pmat) + rest * 120.f; std::vector<cv::Mat> fgr_channel_mats, merge_channel_mats; fgr_channel_mats.push_back(bmat); fgr_channel_mats.push_back(gmat); fgr_channel_mats.push_back(rmat); merge_channel_mats.push_back(mbmat); merge_channel_mats.push_back(mgmat); merge_channel_mats.push_back(mrmat); content.pha_mat = pmat; cv::merge(fgr_channel_mats, content.fgr_mat); cv::merge(merge_channel_mats, content.merge_mat); content.fgr_mat.convertTo(content.fgr_mat, CV_8UC3); content.merge_mat.convertTo(content.merge_mat, CV_8UC3); if (img_w != input_width || img_h != input_height) { cv::resize(content.pha_mat, content.pha_mat, cv::Size(img_w, img_h)); cv::resize(content.fgr_mat, content.fgr_mat, cv::Size(img_w, img_h)); cv::resize(content.merge_mat, content.merge_mat, cv::Size(img_w, img_h)); } content.flag = true; } void TNNRobustVideoMatting::update_context(std::shared_ptr<tnn::Instance> &_instance) { std::shared_ptr<tnn::Mat> r1o_mat; std::shared_ptr<tnn::Mat> r2o_mat; std::shared_ptr<tnn::Mat> r3o_mat; std::shared_ptr<tnn::Mat> r4o_mat; tnn::MatConvertParam cvt_param; tnn::Status status_r1o; tnn::Status status_r2o; tnn::Status status_r3o; tnn::Status status_r4o; status_r1o = _instance->GetOutputMat(r1o_mat, cvt_param, "r1o", output_device_type); status_r2o = _instance->GetOutputMat(r2o_mat, cvt_param, "r2o", output_device_type); status_r3o = _instance->GetOutputMat(r3o_mat, cvt_param, "r3o", output_device_type); status_r4o = _instance->GetOutputMat(r4o_mat, cvt_param, "r4o", output_device_type); if (status_r1o != tnn::TNN_OK || status_r2o != tnn::TNN_OK || status_r3o != tnn::TNN_OK || status_r4o != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->GetOutputMat context failed!:" << status_r1o.description().c_str() << ": " << status_r2o.description().c_str() << ": " << status_r3o.description().c_str() << ": " << status_r4o.description().c_str() << "\n"; #endif return; } void *command_queue = nullptr; auto status_cmd = _instance->GetCommandQueue(&command_queue); if (status_cmd != tnn::TNN_OK) { #ifdef LITETNN_DEBUG std::cout << "instance->GetCommandQueue failed!:" << status_cmd.description().c_str() << "\n"; #endif return; } tnn::MatUtils::Copy(*r1o_mat, *r1i_mat, command_queue); tnn::MatUtils::Copy(*r2o_mat, *r2i_mat, command_queue); tnn::MatUtils::Copy(*r3o_mat, *r3i_mat, command_queue); tnn::MatUtils::Copy(*r4o_mat, *r4i_mat, command_queue); context_is_update = true; }
else { #ifdef LITETNN_DEBUG std::cout << "src input only support NCHW and NHWC " "input_data_format, but found others.\n"; #endif return; } src_size = 1 * 3 * input_height * input_width; for (auto &name: output_names) output_shapes[name] = BasicTNNHandler::get_output_shape(instance, name); #ifdef LITETNN_DEBUG this->print_debug_string(); #endif }
function_block-function_prefixed
[ { "content": "enum Dimensionformat { NHWC, NC4HW4, NCHW };\n", "file_path": "MNN/expr/Expr.hpp", "rank": 0, "score": 159329.26997513027 }, { "content": "function should be prototyped as void Foo(int,void\\*); , where the first parameter is the trackbar\n\nposition and the second parameter is...
C++
stlio.hpp
legokangpalla/FileSTL
675b2cc1364e8d70be43ec09423dbc45b7b574b0
#pragma once #include <vector> #include <type_traits> #include <utility> #include <fstream> #include <boost/config/warning_disable.hpp> #include <boost/spirit/include/qi.hpp> #include <boost/spirit/include/phoenix_core.hpp> #include <boost/spirit/include/phoenix_operator.hpp> #include <boost/spirit/include/phoenix_fusion.hpp> #include <boost/spirit/include/phoenix_stl.hpp> #include <boost/spirit/include/phoenix_object.hpp> #include <boost/fusion/include/adapt_struct.hpp> namespace tyti { namespace stl { template<typename T> struct basic_vec3 { using scalar_type = T; static_assert(std::is_floating_point<scalar_type>::value, "T must be a floating point"); T data[3]; basic_vec3():data{T(0),T(0),T(0)}{} basic_vec3(T x, T y, T z):data{x,y,z}{} T operator[](size_t i)const {return data[i];} const T &operator[](size_t i) { return data[i]; } }; using dvec3 = basic_vec3<double>; using vec3 = basic_vec3<float>; template<typename T> struct basic_solid { using vec3 = basic_vec3<T>; using scalar_type = T; std::string header; std::vector<vec3> normals; std::vector<vec3> vertices; std::vector<std::uint16_t> attributes; }; using dsolid = basic_solid<double>; using solid = basic_solid<float>; template <typename T, typename Iterator> struct stl_parser_ascii : boost::spirit::qi::grammar<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> { stl_parser_ascii() : stl_parser_ascii::base_type(start) { namespace qi = boost::spirit::qi; namespace ql = qi::labels; namespace ascii = boost::spirit::ascii; namespace fusion = boost::fusion; namespace px = boost::phoenix; startSolid %= qi::lexeme[qi::lit("solid ") >> (+(ascii::char_ - qi::eol) | qi::attr(""))]; endSolid = qi::lexeme[qi::lit("endsolid ") >> ascii::string(ql::_r1)]; vector %= qi::float_ >> qi::float_ >> qi::float_; start = startSolid[px::at_c<0>(ql::_val) = ql::_1] >> *(qi::lit("facet") >> qi::lit("normal") >> vector[px::push_back(px::at_c<1>(ql::_val), ql::_1)] >> qi::lit("outer loop") >> qi::repeat(3)[qi::lit("vertex") >> vector[px::push_back(px::at_c<2>(ql::_val), ql::_1)]] >> qi::lit("endloop") >> qi::lit("endfacet") ) >> endSolid(px::at_c<0>(ql::_val)) ; } boost::spirit::qi::rule<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> start; boost::spirit::qi::rule<Iterator, std::string(), boost::spirit::ascii::space_type> startSolid; boost::spirit::qi::rule<Iterator, basic_vec3<T>(), boost::spirit::ascii::space_type> vector; boost::spirit::qi::rule<Iterator, void(std::string), boost::spirit::ascii::space_type> endSolid; }; template <typename T, typename Iterator> struct stl_parser_binary : boost::spirit::qi::grammar<Iterator, basic_solid<T>()> { stl_parser_binary() : stl_parser_binary::base_type(start) { namespace spirit = boost::spirit; namespace qi = boost::spirit::qi; namespace ql = qi::labels; namespace ascii = boost::spirit::ascii; namespace px = boost::phoenix; vector %= spirit::little_bin_float >> spirit::little_bin_float >> spirit::little_bin_float; start = qi::repeat(80)[spirit::byte_[px::at_c<0>(ql::_val) += ql::_1]] >> spirit::little_dword[px::reserve(px::at_c<1>(ql::_val), ql::_1), px::reserve(px::at_c<2>(ql::_val), 3 * ql::_1), px::reserve(px::at_c<3>(ql::_val), ql::_1)] >> *(vector[px::push_back(px::at_c<1>(ql::_val), ql::_1)] >> spirit::repeat(3)[vector[px::push_back(px::at_c<2>(ql::_val), ql::_1)]] >> spirit::little_word[px::push_back(px::at_c<3>(ql::_val), ql::_1)] ) ; } boost::spirit::qi::rule<Iterator, basic_solid<T>()> start; boost::spirit::qi::rule<Iterator, basic_vec3<T>()> vector; boost::spirit::qi::rule<Iterator, void(std::string)> endSolid; }; template <typename T, typename Iterator> struct stl_parser : boost::spirit::qi::grammar<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> { stl_parser() : stl_parser::base_type(start) { start %= stl_ascii_ | boost::spirit::qi::lexeme[stl_binary_]; } stl_parser_ascii<T, Iterator> stl_ascii_; stl_parser_binary<T, Iterator> stl_binary_; boost::spirit::qi::rule<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> start; }; template<typename T, typename IterT> inline bool read(basic_solid<T>& out, IterT begin, IterT end) { stl_parser< T, IterT > p; return boost::spirit::qi::phrase_parse(begin, end, p, boost::spirit::ascii::space, out); } template<typename T, typename IterT> inline std::pair< basic_solid<T>, bool > read(IterT begin, IterT end) { basic_solid<T> o; bool r = read(o, begin, end); return std::make_pair<basic_solid<T>, bool>(std::move(o), std::move(r)); } template<typename IterT> inline std::pair< solid, bool > read(IterT begin, IterT end) { return read<float>(begin, end); } template<typename T> inline bool read(basic_solid<T>& out, const std::string& fileName) { std::ifstream f(fileName, std::ios::binary); std::string str; f.seekg(0, std::ios::end); str.resize((unsigned)f.tellg()); f.seekg(0, std::ios::beg); f.read(&str[0], str.size()); f.close(); return read<T>(out, str.cbegin(), str.cend()); } template<typename T> inline std::pair<basic_solid<T>, bool> read(const std::string& fileName) { basic_solid<T> out; bool r = read(out, fileName); return std::make_pair<basic_solid<T>, bool>(std::move(out), std::move(r)); } inline std::pair<solid, bool> read(const std::string& fileName) { return read<float>(fileName); } template<typename T, typename streamT> void write_ascii(streamT& out, const basic_solid<T>&s) { out << "solid " << s.header << "\n"; for (size_t i = 0; i < s.normals.size(); ++i) { out << "\tfacet normal " << s.normals[i][0] << " " << s.normals[i][1] << " " << s.normals[i][2] << " " << "\n"; out << "\t\touter loop\n"; for (size_t j = 0; j < 3; ++j) { out << "\t\t\tvertex " << s.vertices[3 * i + j][0] << " " << s.vertices[3 * i + j][1] << " " << s.vertices[3 * i + j][2] << " " << "\n"; } out << "\t\tendloop\n" << "\tendfacet\n"; } out << "endsolid " << s.header << "\n"; } namespace detail { template<typename streamT> inline void write_vectorF32(streamT& out, const double* p) { for (size_t i = 0; i < 3; ++i) { const float f = static_cast<float>(p[i]); out.write(reinterpret_cast<const char *>(p), sizeof(float)); } } template<typename streamT> inline void write_vectorF32(streamT& out, const float* p) { out.write(reinterpret_cast<const char*>(p), sizeof(float) * 3); } } template<typename T, typename streamT> void write_binary(streamT& out, basic_solid<T>&s) { s.header.resize(80); out.write(&s.header[0], 80); const size_t num_triangles{ s.normals.size() }; s.attributes.resize(num_triangles); out.write(reinterpret_cast<const char*>(&num_triangles), 4); out << num_triangles; for (size_t i = 0; i < num_triangles; ++i) { detail::write_vectorF32(out, s.normals[i].data); for (size_t j = 0; j < 3; ++j) detail::write_vectorF32(out, s.vertices[3 * i + j].data); out.write(reinterpret_cast<const char*>(&s.attributes[i]), sizeof(uint16_t)); } } template<typename T, typename streamT> void write(streamT& out, basic_solid<T>& s, bool binary) { s.vertices.resize(3 * s.normals.size()); if (binary) write_binary(out, s); else write_ascii(out, s); } } } BOOST_FUSION_ADAPT_TPL_STRUCT( (T), (tyti::stl::basic_solid)(T), (std::string, header), (std::vector< tyti::stl::basic_vec3<T> >, normals), (std::vector< tyti::stl::basic_vec3<T> >, vertices), (std::vector<std::uint16_t>, attributes) ); BOOST_FUSION_ADAPT_TPL_STRUCT( (T), (tyti::stl::basic_vec3)(T), (T, data[0]) (T, data[1]) (T, data[2]) );
#pragma once #include <vector> #include <type_traits> #include <utility> #include <fstream> #include <boost/config/warning_disable.hpp> #include <boost/spirit/include/qi.hpp> #include <boost/spirit/include/phoenix_core.hpp> #include <boost/spirit/include/phoenix_operator.hpp> #include <boost/spirit/include/phoenix_fusion.hpp> #include <boost/spirit/include/phoenix_stl.hpp> #include <boost/spirit/include/phoenix_object.hpp> #include <boost/fusion/include/adapt_struct.hpp> namespace tyti { namespace stl { template<typename T> struct basic_vec3 { using scalar_type = T; static_assert(std::is_floating_point<scalar_type>::value, "T must be a floating point"); T data[3]; basic_vec3():data{T(0),T(0),T(0)}{} basic_vec3(T x, T y, T z):data{x,y,z}{} T operator[](size_t i)const {return data[i];} const T &operator[](size_t i) { return data[i]; } }; using dvec3 = basic_vec3<double>; using vec3 = basic_vec3<float>; template<typename T> struct basic_solid { using vec3 = basic_vec3<T>; using scalar_type = T; std::string header; std::vector<vec3> normals; std::vector<vec3> vertices; std::vector<std::uint16_t> attributes; }; using dsolid = basic_solid<double>; using solid = basic_solid<float>; template <typename T, typename Iterator> struct stl_parser_ascii : boost::spirit::qi::grammar<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> { stl_parser_ascii() : stl_parser_ascii::base_type(start) { namespace qi = boost::spirit::qi; namespace ql = qi::labels; namespace ascii = boost::spirit::ascii; namespace fusion = boost::fusion; namespace px = boost::phoenix; startSolid %= qi::lexeme[qi::lit("solid ") >> (+(ascii::char_ - qi::eol) | qi::attr(""))]; endSolid = qi::lexeme[qi::lit("endsolid ") >> ascii::string(ql::_r1)]; vector %= qi::float_ >> qi::float_ >> qi::float_; start = startSolid[px::at_c<0>(ql::_val) = ql::_1] >> *(qi::lit("facet") >> qi::lit("normal") >> vector[px::push_back(px::at_c<1>(ql::_val), ql::_1)] >> qi::lit("outer loop") >> qi::repeat(3)[qi::lit("vertex") >> vector[px::push_back(px::at_c<2>(ql::_val), ql::_1)]] >> qi::lit("endloop") >> qi::lit("endfacet") ) >> endSolid(px::at_c<0>(ql::_val)) ; } boost::spirit::qi::rule<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> start; boost::spirit::qi::rule<Iterator, std::string(), boost::spirit::ascii::space_type> startSolid; boost::spirit::qi::rule<Iterator, basic_vec3<T>(), boost::spirit::ascii::space_type> vector; boost::spirit::qi::rule<Iterator, void(std::string), boost::spirit::ascii::space_type> endSolid; }; template <typename T, typename Iterator> struct stl_parser_binary : boost::spirit::qi::grammar<Iterator, basic_solid<T>()> { stl_parser_binary() : stl_parser_binary::base_type(start) { namespace spirit = boost::spirit; namespace qi = boost::spirit::qi; namespace ql = qi::labels; namespace ascii = boost::spirit::ascii; namespace px = boost::phoenix; vector %= spirit::little_bin_float >> spirit::little_bin_float >> spirit::little_bin_float; start = qi::repeat(80)[spirit::byte_[px::at_c<0>(ql::_val) += ql::_1]] >> spirit::little_dword[px::reserve(px::at_c<1>(ql::_val), ql::_1), px::reserve(px::at_c<2>(ql::_val), 3 * ql::_1), px::reserve(px::at_c<3>(ql::_val), ql::_1)] >> *(vector[px::push_back(px::at_c<1>(ql::_val), ql::_1)] >> spirit::repeat(3)[vector[px::push_back(px::at_c<2>(ql::_val), ql::_1)]] >> spirit::little_word[px::push_back(px::at_c<3>(ql::_val), ql::_1)] ) ; } boost::spirit::qi::rule<Iterator, basic_solid<T>()> start; boost::spirit::qi::rule<Iterator, basic_vec3<T>()> vector; boost::spirit::qi::rule<Iterator, void(std::string)> endSolid; }; template <typename T, typename Iterator> struct stl_parser : boost::spirit::qi::grammar<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> { stl_parser() : stl_parser::base_type(start) { start %= stl_ascii_ | boost::spirit::qi::lexeme[stl_binary_]; } stl_parser_ascii<T, Iterator> stl_ascii_; stl_parser_binary<T, Iterator> stl_binary_; boost::spirit::qi::rule<Iterator, basic_solid<T>(), boost::spirit::ascii::space_type> start; }; template<typename T, typename IterT> inline bool read(basic_solid<T>& out, IterT begin, IterT end) { stl_parser< T, IterT > p; return boost::spirit::qi::phrase_parse(begin, end, p, boost::spirit::ascii::space, out); } template<typename T, typename IterT> inline std::pair< basic_solid<T>, bool > read(IterT begin, IterT end) { basic_solid<T> o; bool r = read(o, begin, end); return std::make_pair<basic_solid<T>, bool>(std::move(o), std::move(r)); } template<typename IterT>
const size_t num_triangles{ s.normals.size() }; s.attributes.resize(num_triangles); out.write(reinterpret_cast<const char*>(&num_triangles), 4); out << num_triangles; for (size_t i = 0; i < num_triangles; ++i) { detail::write_vectorF32(out, s.normals[i].data); for (size_t j = 0; j < 3; ++j) detail::write_vectorF32(out, s.vertices[3 * i + j].data); out.write(reinterpret_cast<const char*>(&s.attributes[i]), sizeof(uint16_t)); } } template<typename T, typename streamT> void write(streamT& out, basic_solid<T>& s, bool binary) { s.vertices.resize(3 * s.normals.size()); if (binary) write_binary(out, s); else write_ascii(out, s); } } } BOOST_FUSION_ADAPT_TPL_STRUCT( (T), (tyti::stl::basic_solid)(T), (std::string, header), (std::vector< tyti::stl::basic_vec3<T> >, normals), (std::vector< tyti::stl::basic_vec3<T> >, vertices), (std::vector<std::uint16_t>, attributes) ); BOOST_FUSION_ADAPT_TPL_STRUCT( (T), (tyti::stl::basic_vec3)(T), (T, data[0]) (T, data[1]) (T, data[2]) );
inline std::pair< solid, bool > read(IterT begin, IterT end) { return read<float>(begin, end); } template<typename T> inline bool read(basic_solid<T>& out, const std::string& fileName) { std::ifstream f(fileName, std::ios::binary); std::string str; f.seekg(0, std::ios::end); str.resize((unsigned)f.tellg()); f.seekg(0, std::ios::beg); f.read(&str[0], str.size()); f.close(); return read<T>(out, str.cbegin(), str.cend()); } template<typename T> inline std::pair<basic_solid<T>, bool> read(const std::string& fileName) { basic_solid<T> out; bool r = read(out, fileName); return std::make_pair<basic_solid<T>, bool>(std::move(out), std::move(r)); } inline std::pair<solid, bool> read(const std::string& fileName) { return read<float>(fileName); } template<typename T, typename streamT> void write_ascii(streamT& out, const basic_solid<T>&s) { out << "solid " << s.header << "\n"; for (size_t i = 0; i < s.normals.size(); ++i) { out << "\tfacet normal " << s.normals[i][0] << " " << s.normals[i][1] << " " << s.normals[i][2] << " " << "\n"; out << "\t\touter loop\n"; for (size_t j = 0; j < 3; ++j) { out << "\t\t\tvertex " << s.vertices[3 * i + j][0] << " " << s.vertices[3 * i + j][1] << " " << s.vertices[3 * i + j][2] << " " << "\n"; } out << "\t\tendloop\n" << "\tendfacet\n"; } out << "endsolid " << s.header << "\n"; } namespace detail { template<typename streamT> inline void write_vectorF32(streamT& out, const double* p) { for (size_t i = 0; i < 3; ++i) { const float f = static_cast<float>(p[i]); out.write(reinterpret_cast<const char *>(p), sizeof(float)); } } template<typename streamT> inline void write_vectorF32(streamT& out, const float* p) { out.write(reinterpret_cast<const char*>(p), sizeof(float) * 3); } } template<typename T, typename streamT> void write_binary(streamT& out, basic_solid<T>&s) { s.header.resize(80); out.write(&s.header[0], 80);
random
[ { "content": "#define BOOST_TEST_MODULE STL_IO\n\n\n\n#include <boost/test/included/unit_test.hpp>\n\n#include <boost/mpl/list.hpp>\n\n\n\n#include <sstream>\n\n\n\n#include \"../stlio.hpp\"\n\n\n\nusing test_types = boost::mpl::list<float, double>;\n\n\n\nusing namespace tyti;\n\n\n\nBOOST_AUTO_TEST_CASE_TEMPL...
C++
mxflib/vbi.cpp
Jamaika1/mxflib
7eefe6da1f76f7de4f2de48322311533369f8ba5
#include <mxflib/mxflib.h> using namespace mxflib; int ANCVBISource::Field2Offset(void) { if(F2Offset >= 0) return F2Offset; MDObjectPtr Descriptor = MasterSource->GetDescriptor(); if(!Descriptor) { error("EssenceDescriptor not defined for master source of ANCVBISource before calling Field2Offset()\n"); F2Offset = 0; return F2Offset; } if(Descriptor->IsA(MultipleDescriptor_UL)) { MDObject::iterator it = Descriptor->begin(); while(it != Descriptor->end()) { if((*it).second->IsA(GenericPictureEssenceDescriptor_UL)) { Descriptor = (*it).second; break; } it++; } } if(Descriptor->IsDValue(FrameLayout_UL)) { warning("EssenceDescriptor for ANCVBISource does not have a valid FrameLayout\n"); F2Offset = 0; return F2Offset; } if(Descriptor->GetInt(FrameLayout_UL) != 1) { F2Offset = 0; return F2Offset; } MDObjectPtr VideoLineMap = Descriptor->Child(VideoLineMap_UL); if(!VideoLineMap) { error("EssenceDescriptor for ANCVBISource does not have a valid VideoLineMap\n"); F2Offset = 0; return F2Offset; } MDObjectPtr F1Entry = VideoLineMap->Child(0); MDObjectPtr F2Entry = VideoLineMap->Child(1); if((!F1Entry) || (!F2Entry)) { error("EssenceDescriptor for ANCVBISource does not have a valid VideoLineMap\n"); F2Offset = 0; return F2Offset; } F2Offset = static_cast<int>(F2Entry->GetInt() - F1Entry->GetInt()); return F2Offset; } DataChunkPtr ANCVBISource::BuildChunk(void) { ANCVBILineSourceList::iterator LS_it = Sources.begin(); while(LS_it != Sources.end()) { int LineNumber = (*LS_it)->GetLineNumber(); if((*LS_it)->GetField() == 2) LineNumber += Field2Offset(); Lines.insert(ANCLineMap::value_type( LineNumber, new ANCLine(LineNumber, (*LS_it)->GetWrappingType(), (*LS_it)->GetSampleCoding(), (*LS_it)->GetLineData(), (*LS_it)->GetDID(), (*LS_it)->GetSDID()))); LS_it++; } if(Lines.empty()) { DataChunkPtr Ret = new DataChunk(2); PutU16(0, Ret->Data); return Ret; } VBILineMap::iterator it = Lines.begin(); size_t BufferSize = ((*it).second->GetFullDataSize() * Lines.size()) + 2; DataChunkPtr Ret = new DataChunk(BufferSize); UInt8 *pBuffer = Ret->Data; PutU16(static_cast<UInt16>(Lines.size()), Ret->Data); pBuffer += 2; BufferSize -= 2; while(it != Lines.end()) { size_t RequiredBytes = (*it).second->GetFullDataSize(); if(RequiredBytes > BufferSize) { size_t CurrentPos = pBuffer - Ret->Data; Ret->Resize(static_cast<UInt32>(CurrentPos + RequiredBytes)); BufferSize = RequiredBytes; pBuffer = &Ret->Data[CurrentPos]; } (*it).second->WriteData(pBuffer); pBuffer += RequiredBytes; BufferSize -= RequiredBytes; it++; } Ret->Resize(static_cast<UInt32>(pBuffer - Ret->Data)); Lines.clear(); return Ret; } void ANCVBILine::WriteData(UInt8 *Buffer) { PutU16( LineNumber, Buffer); Buffer[2] = static_cast<UInt8>(WrappingType); Buffer[3] = static_cast<UInt8>(SampleCoding); PutU16(static_cast<UInt16>(SampleCount), &Buffer[4]); if(Data.Data) { PutU32(static_cast<UInt32>(Data.Size), &Buffer[6]); PutU32(1, &Buffer[10]); memcpy(&Buffer[14], Data.Data, Data.Size); } else { PutU32(0, &Buffer[6]); PutU32(1, &Buffer[10]); } } bool ANCVBISource::EndSignalled(void) { if(EndAtPosition < 0) { if(!MasterSource) return true; if(MasterSource->EndOfData()) EndAtPosition = MasterSource->GetCurrentPosition(); else EndAtPosition = 0; CurrentPosition = 0; } if(EndAtPosition) { if(CurrentPosition >= EndAtPosition) return true; else return false; } return MasterSource->EndOfData(); } size_t ANCVBISource::GetEssenceDataSize(void) { if(BufferedData.empty()) { if(EndSignalled()) return 0; BufferedData.push_back(BuildChunk()); } return static_cast<size_t>(BufferedData.front()->Size); } DataChunkPtr ANCVBISource::GetEssenceData(size_t Size , size_t MaxSize ) { if(BodyParent) CurrentPosition = BodyParent->GetPosition(); else if(MasterSource) CurrentPosition = MasterSource->GetCurrentPosition() - 1; if(BufferedData.empty()) { if(EndSignalled()) return NULL; BufferedData.push_back(BuildChunk()); } if(IndexMan) IndexMan->OfferEditUnit(IndexStreamID, CurrentPosition, 0, 0x80); CurrentPosition++; if((BufferOffset == 0) && ((MaxSize == 0) || (BufferedData.front()->Size <= MaxSize))) { DataChunkPtr Ret = BufferedData.front(); BufferedData.pop_front(); return Ret; } size_t Bytes = BufferedData.front()->Size - BufferOffset; if(Bytes <= MaxSize) { DataChunkPtr Ret = new DataChunk(Bytes); Ret->Set(static_cast<UInt32>(Bytes), BufferedData.front()->Data); BufferedData.pop_front(); BufferOffset = 0; return Ret; } DataChunkPtr Ret = new DataChunk(MaxSize); Ret->Set(static_cast<UInt32>(MaxSize), BufferedData.front()->Data); BufferOffset -= MaxSize; return Ret; } EssenceParser::WrappingConfigPtr ANCVBISource::MakeWrappingConfig(WrappingConfigPtr MasterCfg) { EssenceParser::WrappingConfigPtr SubCfg; if(MasterCfg->WrapOpt->ThisWrapType != WrappingOption::Frame) return SubCfg; if(Sources.empty()) return SubCfg; std::string Description; ANCVBILineSourceList::iterator it = Sources.begin(); while(it != Sources.end()) { std::string ThisDesc = (*it)->ValidateConfig(MasterCfg); if(ThisDesc.empty()) return SubCfg; if(!Description.empty()) Description += ", plus "; Description += ThisDesc; it++; } SubCfg = new EssenceParser::WrappingConfig(); SubCfg->Parser = MasterCfg->Parser; SubCfg->WrapOpt = new WrappingOption(); SubCfg->WrapOpt->Handler = SubCfg->Parser; SubCfg->WrapOpt->Name = ""; SubCfg->WrapOpt->Description = Description; SubCfg->WrapOpt->GCEssenceType = GetGCEssenceType(); SubCfg->WrapOpt->GCElementType = GetGCElementType(); SubCfg->WrapOpt->ThisWrapType = MasterCfg->WrapOpt->ThisWrapType; SubCfg->WrapOpt->CanSlave = false; SubCfg->WrapOpt->CanIndex = true; SubCfg->WrapOpt->CBRIndex = false; SubCfg->WrapOpt->BERSize = 4; SubCfg->WrapOpt->BytesPerEditUnit = 0; SubCfg->WrapOpt->WrappingUL = GetWrappingUL(); SubCfg->EssenceDescriptor = new MDObject(ANCDataDescriptor_UL); MDObjectPtr SampleRate = SubCfg->EssenceDescriptor->AddChild(SampleRate_UL); SampleRate->SetInt("Numerator", MasterCfg->EditRate.Numerator); SampleRate->SetInt("Denominator", MasterCfg->EditRate.Denominator); SubCfg->EssenceDescriptor->SetValue(EssenceContainer_UL, DataChunk(16,SubCfg->WrapOpt->WrappingUL->GetValue())); SubCfg->Stream = 0; SubCfg->EditRate = MasterCfg->EditRate; SubCfg->StartTimecode = 0; return SubCfg; } std::string SimpleAFDSource::ValidateConfig(WrappingConfigPtr MasterCfg) { if(FieldNum == 1) return "Fixed F1 AFD of 0x" + Int64toHexString(CurrentAFD); return "Fixed F2 AFD of 0x" + Int64toHexString(CurrentAFD); } UInt8 SimpleAFDSource::TextToAFD(std::string Text) { bool Wide = false; UInt8 Ret = 0; std::string::iterator it = Text.begin(); while(it != Text.end()) { if(*it == '1') Ret = (Ret << 1) | 1; else if(*it == '0') Ret = (Ret << 1); else if(tolower(*it) == 'w') Wide = true; it++; } return Wide ? (Ret << 3) | 4 : (Ret << 3); }
#include <mxflib/mxflib.h> using namespace mxflib; int ANCVBISource::Field2Offset(void) { if(F2Offset >= 0) return F2Offset; MDObjectPtr Descriptor = MasterSource->GetDescriptor(); if(!Descriptor) { error("EssenceDescriptor not defined for master source of ANCVBISource before calling Field2Offset()\n"); F2Offset = 0; return F2Offset; } if(Descriptor->IsA(MultipleDescriptor_UL)) { MDObject::iterator it = Descriptor->begin(); while(it != Descriptor->end()) { if((*it).second->IsA(GenericPictureEssenceDescriptor_UL)) { Descriptor = (*it).second; break; } it++; } } if(Descriptor->IsDValue(FrameLayout_UL)) { warning("EssenceDescriptor for ANCVBISource does not have a valid FrameLayout\n"); F2Offset = 0; return F2Offset; } if(Descriptor->GetInt(FrameLayout_UL) != 1) { F2Offset = 0; return F2Offset; } MDObjectPtr VideoLineMap = Descriptor->Child(VideoLineMap_UL); if(!VideoLineMap) { error("EssenceDescriptor for ANCVBISource does not have a valid VideoLineMap\n"); F2Offset = 0; return F2Offset; } MDObjectPtr F1Entry = VideoLineMap->Child(0); MDObjectPtr F2Entry = VideoLineMap->Child(1); if((!F1Entry) || (!F2Entry)) { error("EssenceDescriptor for ANCVBISource does not have a valid VideoLineMap\n"); F2Offset = 0; return F2Offset; } F2Offset = static_cast<int>(F2Entry->GetInt() - F1Entry->GetInt()); return F2Offset; } DataChunkPtr ANCVBISource::BuildChunk(void) { ANCVBILineSourceList::iterator LS_it = Sources.begin(); while(LS_it != Sources.end()) { int LineNumber = (*LS_it)->GetLineNumber(); if((*LS_it)->GetField() == 2) LineNumber += Field2Offset(); Lines.insert(
); LS_it++; } if(Lines.empty()) { DataChunkPtr Ret = new DataChunk(2); PutU16(0, Ret->Data); return Ret; } VBILineMap::iterator it = Lines.begin(); size_t BufferSize = ((*it).second->GetFullDataSize() * Lines.size()) + 2; DataChunkPtr Ret = new DataChunk(BufferSize); UInt8 *pBuffer = Ret->Data; PutU16(static_cast<UInt16>(Lines.size()), Ret->Data); pBuffer += 2; BufferSize -= 2; while(it != Lines.end()) { size_t RequiredBytes = (*it).second->GetFullDataSize(); if(RequiredBytes > BufferSize) { size_t CurrentPos = pBuffer - Ret->Data; Ret->Resize(static_cast<UInt32>(CurrentPos + RequiredBytes)); BufferSize = RequiredBytes; pBuffer = &Ret->Data[CurrentPos]; } (*it).second->WriteData(pBuffer); pBuffer += RequiredBytes; BufferSize -= RequiredBytes; it++; } Ret->Resize(static_cast<UInt32>(pBuffer - Ret->Data)); Lines.clear(); return Ret; } void ANCVBILine::WriteData(UInt8 *Buffer) { PutU16( LineNumber, Buffer); Buffer[2] = static_cast<UInt8>(WrappingType); Buffer[3] = static_cast<UInt8>(SampleCoding); PutU16(static_cast<UInt16>(SampleCount), &Buffer[4]); if(Data.Data) { PutU32(static_cast<UInt32>(Data.Size), &Buffer[6]); PutU32(1, &Buffer[10]); memcpy(&Buffer[14], Data.Data, Data.Size); } else { PutU32(0, &Buffer[6]); PutU32(1, &Buffer[10]); } } bool ANCVBISource::EndSignalled(void) { if(EndAtPosition < 0) { if(!MasterSource) return true; if(MasterSource->EndOfData()) EndAtPosition = MasterSource->GetCurrentPosition(); else EndAtPosition = 0; CurrentPosition = 0; } if(EndAtPosition) { if(CurrentPosition >= EndAtPosition) return true; else return false; } return MasterSource->EndOfData(); } size_t ANCVBISource::GetEssenceDataSize(void) { if(BufferedData.empty()) { if(EndSignalled()) return 0; BufferedData.push_back(BuildChunk()); } return static_cast<size_t>(BufferedData.front()->Size); } DataChunkPtr ANCVBISource::GetEssenceData(size_t Size , size_t MaxSize ) { if(BodyParent) CurrentPosition = BodyParent->GetPosition(); else if(MasterSource) CurrentPosition = MasterSource->GetCurrentPosition() - 1; if(BufferedData.empty()) { if(EndSignalled()) return NULL; BufferedData.push_back(BuildChunk()); } if(IndexMan) IndexMan->OfferEditUnit(IndexStreamID, CurrentPosition, 0, 0x80); CurrentPosition++; if((BufferOffset == 0) && ((MaxSize == 0) || (BufferedData.front()->Size <= MaxSize))) { DataChunkPtr Ret = BufferedData.front(); BufferedData.pop_front(); return Ret; } size_t Bytes = BufferedData.front()->Size - BufferOffset; if(Bytes <= MaxSize) { DataChunkPtr Ret = new DataChunk(Bytes); Ret->Set(static_cast<UInt32>(Bytes), BufferedData.front()->Data); BufferedData.pop_front(); BufferOffset = 0; return Ret; } DataChunkPtr Ret = new DataChunk(MaxSize); Ret->Set(static_cast<UInt32>(MaxSize), BufferedData.front()->Data); BufferOffset -= MaxSize; return Ret; } EssenceParser::WrappingConfigPtr ANCVBISource::MakeWrappingConfig(WrappingConfigPtr MasterCfg) { EssenceParser::WrappingConfigPtr SubCfg; if(MasterCfg->WrapOpt->ThisWrapType != WrappingOption::Frame) return SubCfg; if(Sources.empty()) return SubCfg; std::string Description; ANCVBILineSourceList::iterator it = Sources.begin(); while(it != Sources.end()) { std::string ThisDesc = (*it)->ValidateConfig(MasterCfg); if(ThisDesc.empty()) return SubCfg; if(!Description.empty()) Description += ", plus "; Description += ThisDesc; it++; } SubCfg = new EssenceParser::WrappingConfig(); SubCfg->Parser = MasterCfg->Parser; SubCfg->WrapOpt = new WrappingOption(); SubCfg->WrapOpt->Handler = SubCfg->Parser; SubCfg->WrapOpt->Name = ""; SubCfg->WrapOpt->Description = Description; SubCfg->WrapOpt->GCEssenceType = GetGCEssenceType(); SubCfg->WrapOpt->GCElementType = GetGCElementType(); SubCfg->WrapOpt->ThisWrapType = MasterCfg->WrapOpt->ThisWrapType; SubCfg->WrapOpt->CanSlave = false; SubCfg->WrapOpt->CanIndex = true; SubCfg->WrapOpt->CBRIndex = false; SubCfg->WrapOpt->BERSize = 4; SubCfg->WrapOpt->BytesPerEditUnit = 0; SubCfg->WrapOpt->WrappingUL = GetWrappingUL(); SubCfg->EssenceDescriptor = new MDObject(ANCDataDescriptor_UL); MDObjectPtr SampleRate = SubCfg->EssenceDescriptor->AddChild(SampleRate_UL); SampleRate->SetInt("Numerator", MasterCfg->EditRate.Numerator); SampleRate->SetInt("Denominator", MasterCfg->EditRate.Denominator); SubCfg->EssenceDescriptor->SetValue(EssenceContainer_UL, DataChunk(16,SubCfg->WrapOpt->WrappingUL->GetValue())); SubCfg->Stream = 0; SubCfg->EditRate = MasterCfg->EditRate; SubCfg->StartTimecode = 0; return SubCfg; } std::string SimpleAFDSource::ValidateConfig(WrappingConfigPtr MasterCfg) { if(FieldNum == 1) return "Fixed F1 AFD of 0x" + Int64toHexString(CurrentAFD); return "Fixed F2 AFD of 0x" + Int64toHexString(CurrentAFD); } UInt8 SimpleAFDSource::TextToAFD(std::string Text) { bool Wide = false; UInt8 Ret = 0; std::string::iterator it = Text.begin(); while(it != Text.end()) { if(*it == '1') Ret = (Ret << 1) | 1; else if(*it == '0') Ret = (Ret << 1); else if(tolower(*it) == 'w') Wide = true; it++; } return Wide ? (Ret << 3) | 4 : (Ret << 3); }
ANCLineMap::value_type( LineNumber, new ANCLine(LineNumber, (*LS_it)->GetWrappingType(), (*LS_it)->GetSampleCoding(), (*LS_it)->GetLineData(), (*LS_it)->GetDID(), (*LS_it)->GetSDID()))
call_expression
[ { "content": "namespace mxflib {}\n", "file_path": "mxflib/mxflib.h", "rank": 0, "score": 89973.22926212748 }, { "content": "namespace mxflib\n\n{\n\n\n\n\t//! Load classes and types from a Metadictionary object\n\n\t/*! At the point where this function is called, you need to have all the co...
C++
include/ftk/mesh/lattice_partitioner.hh
hguo/FTT
f1d5387d6353cf2bd165c51fc717eb5d6b2675ef
#ifndef _FTK_LATTICE_PARTITIONER_HH #define _FTK_LATTICE_PARTITIONER_HH #include <ftk/mesh/lattice.hh> namespace ftk { struct lattice_partitioner { lattice_partitioner(const lattice& l_) : l(l_) {} friend std::ostream& operator<<(std::ostream& os, const lattice_partitioner&); size_t nd() const {return l.nd();} size_t np() const {return cores.size();} public: void partition(size_t np); void partition(size_t np, const std::vector<size_t> &given); void partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost); void partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost_low, const std::vector<size_t> &ghost_high); const lattice& get_core(size_t i) const {return cores[i];} const lattice& get_ext(size_t i) const {return extents[i];} size_t partition_id(const std::vector<size_t> &p) const; lattice add_ghost(const lattice& b, const std::vector<size_t>&, const std::vector<size_t>&) const; private: void partition(std::vector<std::vector<size_t>> prime_factors_dims); template<typename uint = size_t> static std::vector<uint> prime_factorization(uint n); protected: const lattice &l; std::vector<lattice> cores, extents; }; template<typename uint> inline std::vector<uint> lattice_partitioner::prime_factorization(uint n) { std::vector<uint> factors; while (n % 2 == 0) { factors.push_back(2); n = n/2; } for (int i = 3; i <= sqrt(n); i += 2) { while (n % i == 0) { factors.push_back(i); n = n / i; } } if(n > 1) { factors.push_back(n); } std::reverse(factors.begin(), factors.end()); return factors; } inline bool is_vector_zero(const std::vector<size_t> vec) { if(vec.size() == 0 || (vec.size() == 1 && vec[0] == 0)) { return true; } return false; } inline void lattice_partitioner::partition(size_t np) { std::vector<size_t> vector_zero(0, nd()); partition(np, vector_zero, vector_zero, vector_zero); } inline void lattice_partitioner::partition(size_t np, const std::vector<size_t> &given) { std::vector<size_t> vector_zero(0, nd()); partition(np, given, vector_zero, vector_zero); } inline void lattice_partitioner::partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost) { partition(np, given, ghost, ghost); } inline void lattice_partitioner::partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost_low, const std::vector<size_t> &ghost_high) { if(np <= 0) { return ; } int ndim = l.nd_cuttable(); std::vector<std::vector<size_t>> prime_factors_dims(ndim, std::vector<size_t>()); if(!is_vector_zero(given)) { bool has_zero = false; for(size_t nslice: given) { if(nslice != 0) { if(np % nslice != 0) { return ; } np /= nslice; } else { has_zero = true; } } if(!has_zero && np > 1) { return ; } for(auto i = 0; i < given.size(); ++i) { size_t nslice = given[i]; if(nslice > 1) { std::vector<size_t> prime_factors_dim = prime_factorization(nslice); prime_factors_dims[i] = prime_factors_dim; } } } if(np > 1) { std::vector<size_t> prime_factors_all = prime_factorization(np); int curr = 0; for(size_t& prime : prime_factors_all) { while(!is_vector_zero(given) && given[curr] != 0) { curr = (curr + 1) % ndim; } prime_factors_dims[curr].push_back(prime); curr = (curr + 1) % ndim; } } partition(prime_factors_dims); if (cores.size() == 0) return; for(const auto& core : cores) { #if 0 auto starts = core.starts(), sizes = core.sizes(); for(int d = 0; d < ndim; ++d) { { size_t offset = starts[d] - l.start(d); if(ghost_low[d] < offset) { offset = ghost_low[d]; } starts[d] -= offset; sizes[d] += offset; } { size_t offset = (l.start(d) + l.size(d)) - (starts[d] + sizes[d]); if(ghost_high[d] < offset) { offset = ghost_high[d]; } sizes[d] += offset; } } #endif lattice ext = add_ghost(core, ghost_low, ghost_high); extents.push_back(ext); } } inline void lattice_partitioner::partition(std::vector<std::vector<size_t>> prime_factors_dims) { int ndim = l.nd_cuttable(); std::queue<lattice> lattice_queue; lattice_queue.push(l); for(int curr = 0; curr < ndim; ++curr) { for(size_t& nslice : prime_factors_dims[curr]) { int n = lattice_queue.size(); for (int j = 0; j < n; ++j) { auto p = lattice_queue.front(); if(p.size(curr) < nslice) { return ; } size_t ns = p.size(curr) / nslice; std::vector<size_t> starts(p.starts()); std::vector<size_t> sizes(p.sizes()); sizes[curr] = ns; for(int k = 0; k < nslice - 1; ++k) { lattice_queue.push(lattice(starts, sizes)); starts[curr] += ns; } sizes[curr] = p.size(curr) - ns * (nslice - 1); lattice_queue.push(lattice(starts, sizes)); lattice_queue.pop(); } } } while (!lattice_queue.empty()) { lattice core = lattice_queue.front(); lattice ghost(core.starts(), core.sizes()); cores.push_back(core); lattice_queue.pop(); } } inline std::ostream& operator<<(std::ostream& os, const lattice_partitioner& partitioner) { os << "lattice.nd=" << partitioner.nd() << ", np=" << partitioner.np() << std::endl; for (auto i = 0; i < partitioner.np(); i ++) { os << "--" << "id=" << i <<", " << "core: " << partitioner.cores[i] << "; " << "ext: " << partitioner.extents[i]; if (i < partitioner.np() - 1) os << std::endl; } return os; } inline lattice lattice_partitioner::add_ghost(const lattice& b, const std::vector<size_t>& ghost_low, const std::vector<size_t>& ghost_high) const { if (ghost_low.empty() || ghost_high.empty()) return b; auto starts = b.starts(), sizes = b.sizes(); for(int d = 0; d < l.nd_cuttable(); ++d) { { size_t offset = starts[d] - l.start(d); if(ghost_low[d] < offset) { offset = ghost_low[d]; } starts[d] -= offset; sizes[d] += offset; } { size_t offset = (l.start(d) + l.size(d)) - (starts[d] + sizes[d]); if(ghost_high[d] < offset) { offset = ghost_high[d]; } sizes[d] += offset; } } return lattice(starts, sizes); } }; #endif
#ifndef _FTK_LATTICE_PARTITIONER_HH #define _FTK_LATTICE_PARTITIONER_HH #include <ftk/mesh/lattice.hh> namespace ftk { struct lattice_partitioner { lattice_partitioner(const lattice& l_) : l(l_) {} friend std::ostream& operator<<(std::ostream& os, const lattice_partitioner&); size_t nd() const {return l.nd();} size_t np() const {return cores.size();} public: void partition(size_t np); void partition(size_t np, const std::vector<size_t> &given); void partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost); void partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost_low, const std::vector<size_t> &ghost_high); const lattice& get_core(size_t i) const {return cores[i];} const lattice& get_ext(size_t i) const {return extents[i];} size_t partition_id(const std::vector<size_t> &p) const; lattice add_ghost(const lattice& b, const std::vector<size_t>&, const std::vector<size_t>&) const; private: void partition(std::vector<std::vector<size_t>> prime_factors_dims); template<typename uint = size_t> static std::vector<uint> prime_factorization(uint n); protected: const lattice &l; std::vector<lattice> cores, extents; }; template<typename uint> inline std::vector<uint> lattice_partitioner::prime_factorization(uint n) { std::vector<uint> factors; while (n % 2 == 0) { factors.push_back(2); n = n/2; } for (int i = 3; i <= sqrt(n); i += 2) { while (n % i == 0) { factors.push_back(i); n = n / i; } } if(n > 1) { factors.push_back(n); } std::reverse(factors.begin(), factors.end());
(curr + 1) % ndim; } } partition(prime_factors_dims); if (cores.size() == 0) return; for(const auto& core : cores) { #if 0 auto starts = core.starts(), sizes = core.sizes(); for(int d = 0; d < ndim; ++d) { { size_t offset = starts[d] - l.start(d); if(ghost_low[d] < offset) { offset = ghost_low[d]; } starts[d] -= offset; sizes[d] += offset; } { size_t offset = (l.start(d) + l.size(d)) - (starts[d] + sizes[d]); if(ghost_high[d] < offset) { offset = ghost_high[d]; } sizes[d] += offset; } } #endif lattice ext = add_ghost(core, ghost_low, ghost_high); extents.push_back(ext); } } inline void lattice_partitioner::partition(std::vector<std::vector<size_t>> prime_factors_dims) { int ndim = l.nd_cuttable(); std::queue<lattice> lattice_queue; lattice_queue.push(l); for(int curr = 0; curr < ndim; ++curr) { for(size_t& nslice : prime_factors_dims[curr]) { int n = lattice_queue.size(); for (int j = 0; j < n; ++j) { auto p = lattice_queue.front(); if(p.size(curr) < nslice) { return ; } size_t ns = p.size(curr) / nslice; std::vector<size_t> starts(p.starts()); std::vector<size_t> sizes(p.sizes()); sizes[curr] = ns; for(int k = 0; k < nslice - 1; ++k) { lattice_queue.push(lattice(starts, sizes)); starts[curr] += ns; } sizes[curr] = p.size(curr) - ns * (nslice - 1); lattice_queue.push(lattice(starts, sizes)); lattice_queue.pop(); } } } while (!lattice_queue.empty()) { lattice core = lattice_queue.front(); lattice ghost(core.starts(), core.sizes()); cores.push_back(core); lattice_queue.pop(); } } inline std::ostream& operator<<(std::ostream& os, const lattice_partitioner& partitioner) { os << "lattice.nd=" << partitioner.nd() << ", np=" << partitioner.np() << std::endl; for (auto i = 0; i < partitioner.np(); i ++) { os << "--" << "id=" << i <<", " << "core: " << partitioner.cores[i] << "; " << "ext: " << partitioner.extents[i]; if (i < partitioner.np() - 1) os << std::endl; } return os; } inline lattice lattice_partitioner::add_ghost(const lattice& b, const std::vector<size_t>& ghost_low, const std::vector<size_t>& ghost_high) const { if (ghost_low.empty() || ghost_high.empty()) return b; auto starts = b.starts(), sizes = b.sizes(); for(int d = 0; d < l.nd_cuttable(); ++d) { { size_t offset = starts[d] - l.start(d); if(ghost_low[d] < offset) { offset = ghost_low[d]; } starts[d] -= offset; sizes[d] += offset; } { size_t offset = (l.start(d) + l.size(d)) - (starts[d] + sizes[d]); if(ghost_high[d] < offset) { offset = ghost_high[d]; } sizes[d] += offset; } } return lattice(starts, sizes); } }; #endif
return factors; } inline bool is_vector_zero(const std::vector<size_t> vec) { if(vec.size() == 0 || (vec.size() == 1 && vec[0] == 0)) { return true; } return false; } inline void lattice_partitioner::partition(size_t np) { std::vector<size_t> vector_zero(0, nd()); partition(np, vector_zero, vector_zero, vector_zero); } inline void lattice_partitioner::partition(size_t np, const std::vector<size_t> &given) { std::vector<size_t> vector_zero(0, nd()); partition(np, given, vector_zero, vector_zero); } inline void lattice_partitioner::partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost) { partition(np, given, ghost, ghost); } inline void lattice_partitioner::partition(size_t np, const std::vector<size_t> &given, const std::vector<size_t> &ghost_low, const std::vector<size_t> &ghost_high) { if(np <= 0) { return ; } int ndim = l.nd_cuttable(); std::vector<std::vector<size_t>> prime_factors_dims(ndim, std::vector<size_t>()); if(!is_vector_zero(given)) { bool has_zero = false; for(size_t nslice: given) { if(nslice != 0) { if(np % nslice != 0) { return ; } np /= nslice; } else { has_zero = true; } } if(!has_zero && np > 1) { return ; } for(auto i = 0; i < given.size(); ++i) { size_t nslice = given[i]; if(nslice > 1) { std::vector<size_t> prime_factors_dim = prime_factorization(nslice); prime_factors_dims[i] = prime_factors_dim; } } } if(np > 1) { std::vector<size_t> prime_factors_all = prime_factorization(np); int curr = 0; for(size_t& prime : prime_factors_all) { while(!is_vector_zero(given) && given[curr] != 0) { curr = (curr + 1) % ndim; } prime_factors_dims[curr].push_back(prime); curr =
random
[ { "content": "struct formatter<void*, Char> : formatter<const void*, Char> {\n\n template <typename FormatContext>\n\n auto format(void* val, FormatContext& ctx) -> decltype(ctx.out()) {\n\n return formatter<const void*, Char>::format(val, ctx);\n\n }\n\n};\n\n\n\ntemplate <typename Char, size_t N>\n", ...
C++
src/menu.cpp
WMXZ-EU/basicSoundRecorder
3ff2fd5aad50dcd8c29580a05a9247f079a28cc3
#include "config.h" #include "filing.h" #include "utils.h" #include "mTime.h" #include "menu.h" #define CONFIG_FILE "/Config.txt" #define LOCK_FILE "/cVAS.lock" extern SDClass sdx[]; uint16_t store[16]; extern int t_acq; void storeConfig(uint16_t *store, int ns) { File configFile; char text[32]; configFile=sdx[0].open(CONFIG_FILE,FILE_WRITE_BEGIN); for(int ii=0; ii<ns; ii++) { sprintf(text,"%10d\r\n",(int) store[ii]); configFile.write((uint8_t*)text,strlen(text)); } configFile.close(); } void loadConfig(uint16_t *store, int ns) { File configFile; char text[32]; if(!(configFile=sdx[0].open(CONFIG_FILE,FILE_READ))) { store[0]=0; return; } for(int ii=0; ii<ns; ii++) { if(configFile.readBytesUntil('\n',text,32)<=0) { store[0]=0; return;} int x; sscanf(text, "%d",&x); store[ii]=(int16_t) x; } configFile.close(); } void saveParameters(void) { store[0]= 1; store[2]= t_acq; storeConfig(store, 16); } void loadParameters(void) { loadConfig(store,16); if(store[0]==1) { t_acq=store[2]; } } void printMenu(void) { Serial.println("\n Menu"); Serial.println(" ':h' : print help"); Serial.println(" ':s' : start acquisition"); Serial.println(" ':e' : stop acquisition"); Serial.println(" ':w' : write parameters to microSD card"); Serial.println(" ':l' : list disks"); Serial.println(" ':r' : reset MTP"); Serial.println(" ':b' : reboot CPU"); Serial.println(); Serial.println(" '?p' : show all parameters"); Serial.println(" '?d' : get date"); Serial.println(" '?t' : get time"); Serial.println(" '?a' : get file duration (s)"); Serial.println(); Serial.println(" '!d yyyy/mm/dd<cr>' : set date"); Serial.println(" '!t hh:mm:ss<cr>' : set time"); Serial.println(" '!a val<cr>' : set file duration (s)"); Serial.println(); } void printMenuEntries(void) { tmElements_t tm; breakTime(rtc_get(), tm); Serial.println("CVAS_V3 Version: " __DATE__ " " __TIME__ ); Serial.printf("Teensy: %d: %06x\n",teensy,SerNum); Serial.printf("Date d = %04d/%02d/%02d\n",tmYearToCalendar(tm.Year), tm.Month, tm.Day); Serial.printf("Time t = %02d:%02d:%02d\n",tm.Hour, tm.Minute, tm.Second); Serial.printf("T_acq a = %d\n",t_acq); } int menuGetInt(int *val) { char buffer[40]; while(!Serial.available()); int count = Serial.readBytesUntil('\r',buffer,40); buffer[count]=0; return sscanf(buffer,"%d",val); } int menuGet3Int(int *val1, int *val2, int *val3) { char buffer[40]; while(!Serial.available()); int count = Serial.readBytesUntil('\r',buffer,40); buffer[count]=0; char c1,c2; return sscanf(buffer,"%d%c%d%c%d",val1,&c1,val2,&c2,val3); } void listDisks(void); void resetMTP(void) ; void dumpMTP(void) ; #if defined (KINETISK) #define CPU_RESTART #endif int16_t menu(void) { if(!Serial.available()) return 0; char ch=Serial.read(); if(ch==':') { while(!Serial.available()) ; ch=Serial.read(); if(ch=='s') { Serial.print("\n"); Serial.print("start"); return +1;} else if(ch=='e') { Serial.print("\n"); Serial.print("stop"); return -1;} else if(ch=='h') { printMenu(); return 0;} else if(ch=='w') { saveParameters(); return 0;} else if(ch=='l') { listDisks(); return 0;} else if(ch=='b') { Serial.print("\n"); Serial.print("rebooting CPU"); Serial.flush(); delay(100); CPU_RESTART; return 0;} } else if(ch=='?') { while(!Serial.available()) ; ch=Serial.read(); tmElements_t tm; breakTime(rtc_get(), tm); if(ch=='p') { printMenuEntries(); return 0;} else if(ch=='d') { Serial.printf("%04d/%02d/%02d\n",tmYearToCalendar(tm.Year), tm.Month, tm.Day); return 0;} else if(ch=='t') { Serial.printf("%02d:%02d:%02d\n",tm.Hour, tm.Minute, tm.Second); return 0;} else if(ch=='a') { Serial.printf("%d\n",t_acq); return 0;} } else if(ch=='!') { while(!Serial.available()) ; ch=Serial.read(); if(ch=='d') { int year,month,day; menuGet3Int(&year,&month,&day); tmElements_t tm; breakTime(rtc_get(), tm); setRTCTime(tm.Hour, tm.Minute, tm.Second, day, month, year); return 0; } else if(ch=='t') { int hour,minutes,seconds; menuGet3Int(&hour,&minutes,&seconds); tmElements_t tm; breakTime(rtc_get(), tm); setRTCTime(hour, minutes, seconds, tm.Day, tm.Month, tmYearToCalendar(tm.Year)); return 0; } else if(ch=='a') { menuGetInt(&t_acq); return 0;} } return 0; }
#include "config.h" #include "filing.h" #include "utils.h" #include "mTime.h" #include "menu.h" #define CONFIG_FILE "/Config.txt" #define LOCK_FILE "/cVAS.lock" extern SDClass sdx[]; uint16_t store[16]; extern int t_acq; void storeConfig(uint16_t *store, int ns) { File configFile; char text[32]; configFile=sdx[0].open(CONFIG_FILE,FILE_WRITE_BEGIN); for(int ii=0; ii<ns; ii++) { sprintf(text,"%10d\r\n",(int) store[ii]); configFile.write((uint8_t*)text,strlen(text)); } configFile.close(); } void loadConfig(uint16_t *store, int ns) { File configFile; char text[32]; if(!(configFile=sdx[0].open(CONFIG_FILE,FILE_READ))) { store[0]=0; return; } for(int ii=0; ii<ns; ii++) { if(configFile.readBytesUntil('\n',text,32)<=0) { store[0]=0; return;} int x; sscanf(text, "%d",&x); store[ii]=(int16_t) x; } configFile.close(); } void saveParameters(void) { store[0]= 1; store[2]= t_acq; storeConfig(store, 16); } void loadParameters(void) { loadConfig(store,16); if(store[0]==1) { t_acq=store[2]; } } void printMenu(void) { Serial.println("\n Menu"); Serial.println(" ':h' : print help"); Serial.println(" ':s' : start acquisition"); Serial.println(" ':e' : stop acquisition"); Serial.println(" ':w' : write parameters to microSD card"); Serial.println(" ':l' : list disks"); Serial.println(" ':r' : reset MTP"); Serial.println(" ':b' : reboot CPU"); Serial.println(); Serial.println(" '?p' : show all parameters"); Serial.println(" '?d' : get date"); Serial.println(" '?t' : get time"); Serial.println(" '?a' : get file duration (s)"); Serial.println(); Serial.println(" '!d yyyy/mm/dd<cr>' : set date"); Serial.println(" '!t hh:mm:ss<cr>' : set time"); Serial.println(" '!a val<cr>' : set file duration (s)"); Serial.println(); } void printMenuEntries(void) { tmElements_t tm; breakTime(rtc_get(), tm); Serial.println("CVAS_V3 Version: " __DATE__ " " __TIME__ ); Serial.printf("Teensy: %d: %06x\n",teensy,SerNum); Serial.printf("Date d = %04d/%02d/%02d\n",tmYearToCalendar(tm.Year), tm.Month, tm.Day); Serial.printf("Time t = %02d:%02d:%02d\n",tm.Hour, tm.Minute, tm.Second); Serial.printf("T_acq a = %d\n",t_acq); } int menuGetInt(int *val) { char buffer[40]; while(!Serial.available()); int count = Serial.readBytesUntil('\r',buffer,40); buffer[count]=0; return sscanf(buffer,"%d",val); } int menuGet3Int(int *val1, int *val2, int *val3) { char buffer[40]; while(!Serial.available()); int count = Serial.readBytesUntil('\r',buffer,40); buffer[count]=0; char c1,c2; return sscanf(buffer,"%d%c%d%c%d",val1,&c1,val2,&c2,val3); } void listDisks(void); void resetMTP(void) ; void dumpMTP(void) ; #if defined (KINETISK) #define CPU_RESTART #endif int16_t menu(void) { if(!Serial.available()) return 0; char ch=Serial.read(); if(ch==':') { while(!Serial.availabl
e()) ; ch=Serial.read(); if(ch=='s') { Serial.print("\n"); Serial.print("start"); return +1;} else if(ch=='e') { Serial.print("\n"); Serial.print("stop"); return -1;} else if(ch=='h') { printMenu(); return 0;} else if(ch=='w') { saveParameters(); return 0;} else if(ch=='l') { listDisks(); return 0;} else if(ch=='b') { Serial.print("\n"); Serial.print("rebooting CPU"); Serial.flush(); delay(100); CPU_RESTART; return 0;} } else if(ch=='?') { while(!Serial.available()) ; ch=Serial.read(); tmElements_t tm; breakTime(rtc_get(), tm); if(ch=='p') { printMenuEntries(); return 0;} else if(ch=='d') { Serial.printf("%04d/%02d/%02d\n",tmYearToCalendar(tm.Year), tm.Month, tm.Day); return 0;} else if(ch=='t') { Serial.printf("%02d:%02d:%02d\n",tm.Hour, tm.Minute, tm.Second); return 0;} else if(ch=='a') { Serial.printf("%d\n",t_acq); return 0;} } else if(ch=='!') { while(!Serial.available()) ; ch=Serial.read(); if(ch=='d') { int year,month,day; menuGet3Int(&year,&month,&day); tmElements_t tm; breakTime(rtc_get(), tm); setRTCTime(tm.Hour, tm.Minute, tm.Second, day, month, year); return 0; } else if(ch=='t') { int hour,minutes,seconds; menuGet3Int(&hour,&minutes,&seconds); tmElements_t tm; breakTime(rtc_get(), tm); setRTCTime(hour, minutes, seconds, tm.Day, tm.Month, tmYearToCalendar(tm.Year)); return 0; } else if(ch=='a') { menuGetInt(&t_acq); return 0;} } return 0; }
function_block-function_prefixed
[ { "content": "void resetMTP(void) ;\n", "file_path": "src/menu.h", "rank": 0, "score": 67831.51723899825 }, { "content": "void listDisks(void);\n", "file_path": "src/menu.h", "rank": 1, "score": 67804.58596994064 }, { "content": " void listDisks(void);\n", "file_pa...
C++
alljoyn_c/samples/about/about_service.cc
liuxiang88/core-alljoyn
549c966482d9b89da84aa528117584e7049916cb
#include <alljoyn_c/AboutData.h> #include <alljoyn_c/AboutListener.h> #include <alljoyn_c/AboutObj.h> #include <alljoyn_c/AboutObjectDescription.h> #include <alljoyn_c/AboutProxy.h> #include <alljoyn_c/BusAttachment.h> #include <alljoyn_c/Init.h> #include <alljoyn/BusAttachment.h> #include <alljoyn/BusListener.h> #include <alljoyn/BusObject.h> #include <alljoyn/AboutObj.h> #include <signal.h> #include <stdio.h> #include <stdlib.h> #define ArraySize(a) (sizeof(a) / sizeof(a[0])) using namespace ajn; static volatile sig_atomic_t s_interrupt = QCC_FALSE; static void CDECL_CALL sig_int_handler(int sig) { QCC_UNUSED(sig); s_interrupt = QCC_TRUE; } static alljoyn_sessionport ASSIGNED_SESSION_PORT = 900; static const char INTERFACE_NAME[] = "com.example.about.feature.interface.sample"; static void AJ_CALL sessionportlistener_sessionjoined_cb(const void* context, alljoyn_sessionport sessionPort, alljoyn_sessionid id, const char* joiner) { QCC_UNUSED(context); QCC_UNUSED(sessionPort); QCC_UNUSED(joiner); printf("Session Joined SessionId = %u\n", id); } static QCC_BOOL AJ_CALL sessionportlistener_acceptsessionjoiner_cb(const void* context, alljoyn_sessionport sessionPort, const char* joiner, const alljoyn_sessionopts opts) { QCC_UNUSED(context); QCC_UNUSED(joiner); QCC_UNUSED(opts); if (sessionPort != ASSIGNED_SESSION_PORT) { printf("Rejecting join attempt on unexpected session port %d\n", sessionPort); return QCC_FALSE; } return QCC_TRUE; } static alljoyn_sessionportlistener create_my_alljoyn_sessionportlistener() { alljoyn_sessionportlistener_callbacks* callbacks = (alljoyn_sessionportlistener_callbacks*) malloc(sizeof(alljoyn_sessionportlistener_callbacks)); callbacks->accept_session_joiner = sessionportlistener_acceptsessionjoiner_cb; callbacks->session_joined = sessionportlistener_sessionjoined_cb; return alljoyn_sessionportlistener_create(callbacks, NULL); } static void AJ_CALL echo_cb(alljoyn_busobject object, const alljoyn_interfacedescription_member* member, alljoyn_message msg) { alljoyn_msgarg arg = alljoyn_message_getarg(msg, 0); QCC_UNUSED(member); printf("Echo method called %s\n", ((ajn::MsgArg*)arg)->v_string.str); QStatus status = alljoyn_busobject_methodreply_args(object, msg, arg, 1); if (status != ER_OK) { printf("Failed to created MethodReply.\n"); } } static alljoyn_busobject create_my_alljoyn_busobject(alljoyn_busattachment bus, const char* path) { QStatus status = ER_FAIL; alljoyn_busobject result = NULL; result = alljoyn_busobject_create(path, QCC_FALSE, NULL, NULL); alljoyn_interfacedescription iface = alljoyn_busattachment_getinterface(bus, INTERFACE_NAME); QCC_ASSERT(iface != NULL); status = alljoyn_busobject_addinterface(result, iface); alljoyn_busobject_setannounceflag(result, iface, ANNOUNCED); if (status != ER_OK) { printf("Failed to add %s interface to the BusObject\n", INTERFACE_NAME); } alljoyn_interfacedescription_member echomember; alljoyn_interfacedescription_getmember(iface, "Echo", &echomember); const alljoyn_busobject_methodentry methodEntries[] = { { &echomember, echo_cb } }; status = alljoyn_busobject_addmethodhandlers(result, methodEntries, sizeof(methodEntries) / sizeof(methodEntries[0])); return result; } int CDECL_CALL main(void) { signal(SIGINT, sig_int_handler); QStatus status = alljoyn_init(); if (ER_OK != status) { printf("alljoyn_init failed (%s)\n", QCC_StatusText(status)); return 1; } #ifdef ROUTER status = alljoyn_routerinit(); if (ER_OK != status) { printf("alljoyn_routerinit failed (%s)\n", QCC_StatusText(status)); alljoyn_shutdown(); return 1; } #endif alljoyn_busattachment bus = alljoyn_busattachment_create("About Service Example", QCC_TRUE); status = alljoyn_busattachment_start(bus); if (ER_OK == status) { printf("BusAttachment started.\n"); } else { printf("FAILED to start BusAttachment (%s)\n", QCC_StatusText(status)); return 1; } status = alljoyn_busattachment_connect(bus, NULL); if (ER_OK == status) { printf("BusAttachment connect succeeded. BusName %s\n", alljoyn_busattachment_getuniquename(bus)); } else { printf("FAILED to connect to router node (%s)\n", QCC_StatusText(status)); return 1; } alljoyn_sessionopts opts = alljoyn_sessionopts_create(ALLJOYN_TRAFFIC_TYPE_MESSAGES, QCC_FALSE, ALLJOYN_PROXIMITY_ANY, ALLJOYN_TRANSPORT_ANY); alljoyn_sessionport sessionPort = ASSIGNED_SESSION_PORT; alljoyn_sessionportlistener listener = create_my_alljoyn_sessionportlistener(); status = alljoyn_busattachment_bindsessionport(bus, &sessionPort, opts, listener); if (ER_OK != status) { printf("Failed to BindSessionPort (%s)", QCC_StatusText(status)); return 1; } alljoyn_aboutdata aboutData = alljoyn_aboutdata_create("en"); uint8_t appId[] = { 0x01, 0xB3, 0xBA, 0x14, 0x1E, 0x82, 0x11, 0xE4, 0x86, 0x51, 0xD1, 0x56, 0x1D, 0x5D, 0x46, 0xB0 }; status = alljoyn_aboutdata_setappid(aboutData, appId, 16); status = alljoyn_aboutdata_setdevicename(aboutData, "My Device Name", "en"); status = alljoyn_aboutdata_setdeviceid(aboutData, "93c06771-c725-48c2-b1ff-6a2a59d445b8"); status = alljoyn_aboutdata_setappname(aboutData, "Application", "en"); status = alljoyn_aboutdata_setmanufacturer(aboutData, "Manufacturer", "en"); status = alljoyn_aboutdata_setmodelnumber(aboutData, "123456"); status = alljoyn_aboutdata_setdescription(aboutData, "A poetic description of this application", "en"); status = alljoyn_aboutdata_setdateofmanufacture(aboutData, "2014-03-24"); status = alljoyn_aboutdata_setsoftwareversion(aboutData, "0.1.2"); status = alljoyn_aboutdata_sethardwareversion(aboutData, "0.0.1"); status = alljoyn_aboutdata_setsupporturl(aboutData, "http://www.example.org"); status = alljoyn_aboutdata_setdevicename(aboutData, "Mi dispositivo Nombre", "es"); status = alljoyn_aboutdata_setappname(aboutData, "aplicación", "es"); status = alljoyn_aboutdata_setmanufacturer(aboutData, "fabricante", "es"); status = alljoyn_aboutdata_setdescription(aboutData, "Una descripción poética de esta aplicación", "es"); if (!alljoyn_aboutdata_isvalid(aboutData, "en")) { printf("failed to setup about data.\n"); } char interface[256] = { 0 }; #if defined(QCC_OS_GROUP_WINDOWS) _snprintf( #else snprintf( #endif interface, ArraySize(interface), "<node>" \ "<interface name='%s'>" \ " <method name='Echo'>" \ " <arg name='out_arg' type='s' direction='in' />" \ " <arg name='return_arg' type='s' direction='out' />" \ " </method>" \ "</interface>" \ "</node>", INTERFACE_NAME); interface[ArraySize(interface) - 1] = '\0'; printf("Interface = %s\n", interface); status = alljoyn_busattachment_createinterfacesfromxml(bus, interface); if (ER_OK != status) { printf("Failed to parse the xml interface definition (%s)", QCC_StatusText(status)); return 1; } alljoyn_busobject busObject = create_my_alljoyn_busobject(bus, "/example/path"); status = alljoyn_busattachment_registerbusobject(bus, busObject); if (ER_OK != status) { printf("Failed to register BusObject (%s)", QCC_StatusText(status)); return 1; } alljoyn_aboutobj aboutObj = alljoyn_aboutobj_create(bus, UNANNOUNCED); status = alljoyn_aboutobj_announce(aboutObj, sessionPort, aboutData); if (ER_OK == status) { printf("AboutObj Announce Succeeded.\n"); } else { printf("AboutObj Announce failed (%s)\n", QCC_StatusText(status)); return 1; } if (ER_OK == status) { while (s_interrupt == QCC_FALSE) { #ifdef _WIN32 Sleep(100); #else usleep(100 * 1000); #endif } } alljoyn_aboutobj_unannounce(aboutObj); alljoyn_sessionportlistener_destroy(listener); alljoyn_busattachment_stop(bus); alljoyn_busattachment_join(bus); alljoyn_sessionopts_destroy(opts); alljoyn_aboutdata_destroy(aboutData); alljoyn_busobject_destroy(busObject); alljoyn_aboutobj_destroy(aboutObj); alljoyn_busattachment_destroy(bus); #ifdef ROUTER alljoyn_routershutdown(); #endif alljoyn_shutdown(); return 0; }
#include <alljoyn_c/AboutData.h> #include <alljoyn_c/AboutListener.h> #include <alljoyn_c/AboutObj.h> #include <alljoyn_c/AboutObjectDescription.h> #include <alljoyn_c/AboutProxy.h> #include <alljoyn_c/BusAttachment.h> #include <alljoyn_c/Init.h> #include <alljoyn/BusAttachment.h> #include <alljoyn/BusListener.h> #include <alljoyn/BusObject.h> #include <alljoyn/AboutObj.h> #include <signal.h> #include <stdio.h> #include <stdlib.h> #define ArraySize(a) (sizeof(a) / sizeof(a[0])) using namespace ajn; static volatile sig_atomic_t s_interrupt = QCC_FALSE; static void CDECL_CALL sig_int_handler(int sig) { QCC_UNUSED(sig); s_interrupt = QCC_TRUE; } static alljoyn_sessionport ASSIGNED_SESSION_PORT = 900; static const char INTERFACE_NAME[] = "com.example.about.feature.interface.sample"; static void AJ_CALL sessionportlistener_sessionjoined_cb(const void* context, alljoyn_sessionport sessionPort, alljoyn_sessionid id, const char* joiner) { QCC_UNUSED(context); QCC_UNUSED(sessionPort); QCC_UNUSED(joiner); printf("Session Joined SessionId = %u\n", id); } static QCC_BOOL AJ_CALL sessionportlistener_acceptsessionjoiner_cb(const void* context, alljoyn_sessionport sessionPort, const char* joiner, const alljoyn_sessionopts opts) { QCC_UNUSED(context); QCC_UNUSED(joiner); QCC_UNUSED(opts); if (sessionPort != ASSIGNED_SESSION_PORT) { printf("Rejecting join attempt on unexpected session port %d\n", sessionPort); return QCC_FALSE; } return QCC_TRUE; } static alljoyn_sessionportlistener create_my_alljoyn_sessionportlistener() { alljoyn_sessionportlistener_callbacks* callbacks = (alljoyn_sessionportlistener_callbacks*) malloc(sizeof(alljoyn_sessionportlistener_callbacks)); callbacks->accept_session_joiner = sessionportlistener_acceptsessionjoiner_cb; callbacks->session_joined = sessionportlistener_sessionjoined_cb; return alljoyn_sessionportlistener_create(callbacks, NULL); } static void AJ_CALL echo_cb(alljoyn_busobject object, const alljoyn_interfacedescription_member* member, alljoyn_message msg) { alljoyn_msgarg arg = alljoyn_message_getarg(msg, 0); QCC_UNUSED(member); printf("Echo method called %s\n", ((ajn::MsgArg*)arg)->v_string.str); QStatus status = alljoyn_busobject_methodreply_args(object, msg, arg, 1); if (status != ER_OK) { printf("Failed to created MethodReply.\n"); } } static alljoyn_busobject create_my_alljoyn_busobject(alljoyn_busattachment bus, const char* path) { QStatus status = ER_FAIL; alljoyn_busobject result = NULL; result = alljoyn_busobject_create(path, QCC_FALSE, NULL, NULL); alljoyn_interfacedescription iface = alljoyn_busattachment_getinterface(bus, INTERFACE_NAME); QCC_ASSERT(iface != NULL); status = alljoyn_busobject_addinterface(result, iface); alljoyn_busobject_setannounceflag(result, iface, ANNOUNCED); if (status != ER_OK) { printf("Failed to add %s interface to the BusObject\n", INTERFACE_NAME); } alljoyn_interfacedescription_member echomember; alljoyn_interfacedescription_getmember(iface, "Echo", &echomember); const alljoyn_busobject_methodentry methodEntries[] = { { &echomember, echo_cb } }; status = alljoyn_busobject_addmethodhandlers(result, methodEntries, sizeof(methodEntries) / sizeof(methodEntries[0])); return result; } int CDECL_CALL main(void) { signal(SIGINT, sig_int_handler); QStatus status = alljoyn_init(); if (ER_OK != status) { printf("alljoyn_init failed (%s)\n", QCC_StatusText(status)); return 1; } #ifdef ROUTER status = alljoyn_routerinit(); if (ER_OK != status) { printf("alljoyn_routerinit failed (%s)\n", QCC_StatusText(status)); alljoyn_shutdown(); return 1; } #endif alljoyn_busattachment bus = alljoyn_busattachment_create("About Service Example", QCC_TRUE); status = alljoyn_busattachment_start(bus); if (ER_OK == status) { printf("BusAttachment started.\n"); } else { printf("FAILED to start BusAttachment (%s)\n", QCC_StatusText(status)); return 1; } status = alljoyn_busattachment_connect(bus, NULL); if (ER_OK == status) { printf("BusAttachment connect succeeded. BusName %s\n", alljoyn_busattachment_getuniquename(bus)); } else { printf("FAILED to connect to router node (%s)\n", QCC_StatusText(status)); return 1; } alljoyn_sessionopts opts = alljoyn_sessionopts_create(ALLJOYN_TRAFFIC_TYPE_MESSAGES, QCC_FALSE, ALLJOYN_PROXIMITY_ANY, ALLJOYN_TRANSPORT_ANY); alljoyn_sessionport sessionPort = ASSIGNED_SESSION_PORT; alljoyn_sessionportlistener listener = create_my_alljoyn_sessionportlistener(); status = alljoyn_busattachment_bindsessionport(bus, &sessionPort, opts, listener); if (ER_OK != status) { printf("Failed to BindSessionPort (%s)", QCC_StatusText(status)); return 1; } alljoyn_aboutdata aboutData = alljoyn_aboutdata_create("en"); uint8_t appId[] = { 0x01, 0xB3, 0xBA, 0x14, 0x1E, 0x82, 0x11, 0xE4, 0x86, 0x51, 0xD1, 0x56, 0x1D, 0x5D, 0x46, 0xB0 }; status = alljoyn_aboutdata_setappid(aboutData, appId, 16); status = alljoyn_aboutdata_setdevicename(aboutData, "My Device Name", "en"); status = alljoyn_aboutdata_setdeviceid(aboutData, "93c06771-c725-48c2-b1ff-6a2a59d445b8"); status = alljoyn_aboutdata_setappname(aboutData, "Application", "en"); status = alljoyn_aboutdata_setmanufacturer(aboutData, "Manufacturer", "en"); status = alljoyn_aboutdata_setmodelnumber(aboutData, "123456"); status = alljoyn_aboutdata_setdescription(aboutData, "A poetic description of this application", "en"); status = alljoyn_aboutdata_setdateofmanufacture(aboutData, "2014-03-24"); status = alljoyn_aboutdata_setsoftwareversion(aboutData, "0.1.2"); status = alljoyn_aboutdata_sethardwareversion(aboutData, "0.0.1"); status = alljoyn_aboutdata_setsupporturl(aboutData, "http://www.example.org"); status = alljoyn_aboutdata_setdevicename(aboutData, "Mi dispositivo Nombre", "es"); status = alljoyn_aboutdata_setappname(aboutData, "aplicación", "es"); status = alljoyn_aboutdata_setmanufacturer(aboutData, "fabricante", "es"); status = alljoyn_aboutdata_setdescription(aboutData, "Una descripción poética de esta aplicación", "es"); if (!alljoyn_aboutdata_isvalid(aboutData, "en")) { printf("failed to setup about data.\n"); } char interface[
256] = { 0 }; #if defined(QCC_OS_GROUP_WINDOWS) _snprintf( #else snprintf( #endif interface, ArraySize(interface), "<node>" \ "<interface name='%s'>" \ " <method name='Echo'>" \ " <arg name='out_arg' type='s' direction='in' />" \ " <arg name='return_arg' type='s' direction='out' />" \ " </method>" \ "</interface>" \ "</node>", INTERFACE_NAME); interface[ArraySize(interface) - 1] = '\0'; printf("Interface = %s\n", interface); status = alljoyn_busattachment_createinterfacesfromxml(bus, interface); if (ER_OK != status) { printf("Failed to parse the xml interface definition (%s)", QCC_StatusText(status)); return 1; } alljoyn_busobject busObject = create_my_alljoyn_busobject(bus, "/example/path"); status = alljoyn_busattachment_registerbusobject(bus, busObject); if (ER_OK != status) { printf("Failed to register BusObject (%s)", QCC_StatusText(status)); return 1; } alljoyn_aboutobj aboutObj = alljoyn_aboutobj_create(bus, UNANNOUNCED); status = alljoyn_aboutobj_announce(aboutObj, sessionPort, aboutData); if (ER_OK == status) { printf("AboutObj Announce Succeeded.\n"); } else { printf("AboutObj Announce failed (%s)\n", QCC_StatusText(status)); return 1; } if (ER_OK == status) { while (s_interrupt == QCC_FALSE) { #ifdef _WIN32 Sleep(100); #else usleep(100 * 1000); #endif } } alljoyn_aboutobj_unannounce(aboutObj); alljoyn_sessionportlistener_destroy(listener); alljoyn_busattachment_stop(bus); alljoyn_busattachment_join(bus); alljoyn_sessionopts_destroy(opts); alljoyn_aboutdata_destroy(aboutData); alljoyn_busobject_destroy(busObject); alljoyn_aboutobj_destroy(aboutObj); alljoyn_busattachment_destroy(bus); #ifdef ROUTER alljoyn_routershutdown(); #endif alljoyn_shutdown(); return 0; }
function_block-function_prefixed
[ { "content": "class BasicService: NSObject, AJNBusListener, AJNSessionPortListener, AJNSessionListener {\n\n\n\n weak var delegate: BasicServiceDelegate?\n\n\n\n private var bus: AJNBusAttachment?\n\n private var basicObject: BasicObject?\n\n\n\n func startServiceAsync() {\n\n DispatchQueue.g...
C++
src/Sound/AttenuationShapes.cpp
SparkyStudios/AmplitudeSDK
bcfb9d9c2fcea8ecd3a540576508f062fb3d5e21
#include <Sound/AttenuationShapes.h> #include <SparkyStudios/Audio/Amplitude/Core/Engine.h> #include <SparkyStudios/Audio/Amplitude/Core/Log.h> #include <Core/EngineInternalState.h> namespace SparkyStudios::Audio::Amplitude { AttenuationShape::AttenuationShape() : m_maxAttenuationFactor(1.0f) {} float AttenuationShape::GetAttenuationFactor(const Attenuation*, const hmm_vec3&, const ListenerInternalState*) { return m_maxAttenuationFactor; } float AttenuationShape::GetAttenuationFactor(const Attenuation*, const EntityInternalState*, const ListenerInternalState*) { return m_maxAttenuationFactor; } AttenuationShape* AttenuationShape::Create(const AttenuationShapeDefinition* definition) { if (definition == nullptr) return nullptr; AttenuationShape* shape = nullptr; switch (definition->model()) { default: case AttenuationShapeModel_Default: shape = new AttenuationShape(); break; case AttenuationShapeModel_Cone: shape = new ConeAttenuationShape(definition->settings_as_Cone()); break; case AttenuationShapeModel_Sphere: shape = new SphereAttenuationShape(definition->settings_as_Sphere()); break; case AttenuationShapeModel_Box: shape = new BoxAttenuationShape(definition->settings_as_Box()); break; case AttenuationShapeModel_Capsule: shape = new CapsuleAttenuationShape(definition->settings_as_Capsule()); break; } shape->m_maxAttenuationFactor = definition->max_attenuation_factor(); return shape; } float ConeAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { if (const hmm_vec3& soundToListener = listener->GetLocation() - soundLocation; AM_Length(soundToListener) >= attenuation->GetMaxDistance()) return 0.0f; return 1.0f; } float ConeAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - entity->GetLocation(); const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); const float coneDist = AM_Dot(soundToListener, entity->GetDirection()); if (coneDist < 0.0f || coneDist > _outerHeight) return gain * m_maxAttenuationFactor; if (coneDist > _innerHeight) return gain * AM_Lerp(1.0f, (coneDist - _innerHeight) / (_outerHeight - _innerHeight), m_maxAttenuationFactor); const float innerConeRadius = coneDist / _innerHeight * _innerRadius; const float outerConeRadius = coneDist / _outerHeight * _outerRadius; const float d = AM_Length(soundToListener - coneDist * entity->GetDirection()); if (d <= innerConeRadius) return gain * 1.0f; if (d >= outerConeRadius) return gain * m_maxAttenuationFactor; const float delta = (distance - innerConeRadius) / (outerConeRadius - innerConeRadius); return gain * AM_Lerp(1.0f, AM_CLAMP(delta, 0.0f, 1.0f), m_maxAttenuationFactor); } float ConeAttenuationShape::GetOuterRadius() const { return _outerRadius; } float ConeAttenuationShape::GetInnerRadius() const { return _innerRadius; } float ConeAttenuationShape::GetInnerHeight() const { return _innerHeight; } float ConeAttenuationShape::GetOuterHeight() const { return _outerHeight; } float SphereAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - soundLocation; const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); const float delta = (distance - _innerRadius) / (_outerRadius - _innerRadius); return gain * AM_Lerp(1.0f, AM_CLAMP(delta, 0.0f, 1.0f), m_maxAttenuationFactor); } float SphereAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { return GetAttenuationFactor(attenuation, entity->GetLocation(), listener); } float BoxAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - soundLocation; const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); return gain * _getFactor(soundLocation, listener, AM_Mat4d(1.0f)); } float BoxAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - entity->GetLocation(); const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); return gain * _getFactor(entity->GetLocation(), listener, AM_LookAt(AM_Vec3(0, 0, 0), entity->GetDirection(), entity->GetUp())); } float BoxAttenuationShape::_getFactor(const hmm_vec3& soundLocation, const ListenerInternalState* listener, hmm_mat4 lookAt) { lookAt = AM_Multiply(AM_Translate(soundLocation), lookAt); const hmm_vec3& x = listener->GetLocation(); hmm_vec3 iP1, iP2, iP3, iP4, oP1, oP2, oP3, oP4; switch (amEngine->GetState()->up_axis) { default: case GameEngineUpAxis_Y: iP1 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfHeight, -_innerHalfDepth, 1.0f)).XYZ; iP2 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfHeight, _innerHalfDepth, 1.0f)).XYZ; iP3 = AM_Multiply(lookAt, AM_Vec4(_innerHalfWidth, -_innerHalfHeight, -_innerHalfDepth, 1.0f)).XYZ; iP4 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, _innerHalfHeight, -_innerHalfDepth, 1.0f)).XYZ; oP1 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfHeight, -_outerHalfDepth, 1.0f)).XYZ; oP2 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfHeight, _outerHalfDepth, 1.0f)).XYZ; oP3 = AM_Multiply(lookAt, AM_Vec4(_outerHalfWidth, -_outerHalfHeight, -_outerHalfDepth, 1.0f)).XYZ; oP4 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, _outerHalfHeight, -_outerHalfDepth, 1.0f)).XYZ; break; case GameEngineUpAxis_Z: iP1 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfDepth, -_innerHalfHeight, 1.0f)).XYZ; iP2 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, _innerHalfDepth, -_innerHalfHeight, 1.0f)).XYZ; iP3 = AM_Multiply(lookAt, AM_Vec4(_innerHalfWidth, -_innerHalfDepth, -_innerHalfHeight, 1.0f)).XYZ; iP4 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfDepth, _innerHalfHeight, 1.0f)).XYZ; oP1 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfDepth, -_outerHalfHeight, 1.0f)).XYZ; oP2 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, _outerHalfDepth, -_outerHalfHeight, 1.0f)).XYZ; oP3 = AM_Multiply(lookAt, AM_Vec4(_outerHalfWidth, -_outerHalfDepth, -_outerHalfHeight, 1.0f)).XYZ; oP4 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfDepth, _outerHalfHeight, 1.0f)).XYZ; break; } hmm_vec3 iU = AM_Normalize(iP2 - iP1); hmm_vec3 iV = AM_Normalize(iP3 - iP1); hmm_vec3 iW = AM_Normalize(iP4 - iP1); hmm_vec3 oU = AM_Normalize(oP2 - oP1); hmm_vec3 oV = AM_Normalize(oP3 - oP1); hmm_vec3 oW = AM_Normalize(oP4 - oP1); const float iUX = AM_Dot(iU, x); const float iVX = AM_Dot(iV, x); const float iWX = AM_Dot(iW, x); const float oUX = AM_Dot(oU, x); const float oVX = AM_Dot(oV, x); const float oWX = AM_Dot(oW, x); const float iUP1 = AM_Dot(iU, iP1); const float iVP1 = AM_Dot(iV, iP1); const float iWP1 = AM_Dot(iW, iP1); const float iUP2 = AM_Dot(iU, iP2); const float iVP3 = AM_Dot(iV, iP3); const float iWP4 = AM_Dot(iW, iP4); const float oUP1 = AM_Dot(oU, oP1); const float oVP1 = AM_Dot(oV, oP1); const float oWP1 = AM_Dot(oW, oP1); const float oUP2 = AM_Dot(oU, oP2); const float oVP3 = AM_Dot(oV, oP3); const float oWP4 = AM_Dot(oW, oP4); if (AM_BETWEEN(iUX, iUP1, iUP2) && AM_BETWEEN(iVX, iVP1, iVP3) && AM_BETWEEN(iWX, iWP1, iWP4)) return 1.0f; if (!(AM_BETWEEN(oUX, oUP1, oUP2) && AM_BETWEEN(oVX, oVP1, oVP3) && AM_BETWEEN(oWX, oWP1, oWP4))) return m_maxAttenuationFactor; const float dP1 = HMM_ABS(AM_Dot(x - oP1, AM_Normalize(oP2 - oP1))) / (_outerHalfDepth - _innerHalfDepth); const float dP2 = HMM_ABS(AM_Dot(x - oP2, AM_Normalize(oP1 - oP2))) / (_outerHalfDepth - _innerHalfDepth); const float dP3 = HMM_ABS(AM_Dot(x - oP3, AM_Normalize(oP1 - oP3))) / (_outerHalfWidth - _innerHalfWidth); const float dP4 = HMM_ABS(AM_Dot(x - oP4, AM_Normalize(oP1 - oP4))) / (_outerHalfHeight - _innerHalfHeight); const float dP5 = HMM_ABS(AM_Dot(x - oP1, AM_Normalize(oP3 - oP1))) / (_outerHalfWidth - _innerHalfWidth); const float dP6 = HMM_ABS(AM_Dot(x - oP1, AM_Normalize(oP4 - oP1))) / (_outerHalfHeight - _innerHalfHeight); const float shortestRoad = AM_MIN(dP1, AM_MIN(dP2, AM_MIN(dP3, AM_MIN(dP4, AM_MIN(dP5, dP6))))); return AM_Lerp(m_maxAttenuationFactor, AM_CLAMP(shortestRoad, 0.0f, 1.0f), 1.0f); } float CapsuleAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { return _getFactor(attenuation, soundLocation, listener, AM_Mat4d(1.0f)); } float CapsuleAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { return _getFactor( attenuation, entity->GetLocation(), listener, AM_LookAt(AM_Vec3(0, 0, 0), entity->GetDirection(), entity->GetUp())); } float CapsuleAttenuationShape::_getFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener, hmm_mat4 lookAt) { lookAt = AM_Multiply(AM_Translate(soundLocation), lookAt); const hmm_vec3& x = listener->GetLocation(); const float distanceToOrigin = AM_Length(x - soundLocation); const float innerHalfHeight = _innerHalfHeight - _innerRadius; const float outerHalfHeight = _outerHalfHeight - _outerRadius; hmm_vec3 iA, iB, oA, oB; switch (amEngine->GetState()->up_axis) { default: case GameEngineUpAxis_Y: iA = AM_Multiply(lookAt, AM_Vec4(0.0f, innerHalfHeight, 0.0f, 1.0f)).XYZ; iB = AM_Multiply(lookAt, AM_Vec4(0.0f, -innerHalfHeight, 0.0f, 1.0f)).XYZ; oA = AM_Multiply(lookAt, AM_Vec4(0.0f, outerHalfHeight, 0.0f, 1.0f)).XYZ; oB = AM_Multiply(lookAt, AM_Vec4(0.0f, -outerHalfHeight, 0.0f, 1.0f)).XYZ; break; case GameEngineUpAxis_Z: iA = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, innerHalfHeight, 1.0f)).XYZ; iB = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, -innerHalfHeight, 1.0f)).XYZ; oA = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, outerHalfHeight, 1.0f)).XYZ; oB = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, -outerHalfHeight, 1.0f)).XYZ; break; } hmm_vec3 iE = iB - iA; hmm_vec3 iM = AM_Cross(iA, iB); hmm_vec3 oE = oB - oA; hmm_vec3 oM = AM_Cross(oA, oB); const float iDistanceToAxis = AM_Length(iM + AM_Cross(iE, x)) / AM_Length(iE); const float oDistanceToAxis = AM_Length(oM + AM_Cross(oE, x)) / AM_Length(oE); if (oDistanceToAxis >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(iDistanceToAxis); const float iDistanceToA = AM_Length(x - iA); const float iDistanceToB = AM_Length(x - iB); const float oDistanceToA = AM_Length(x - oA); const float oDistanceToB = AM_Length(x - oB); if (iDistanceToAxis <= _innerRadius && distanceToOrigin <= innerHalfHeight) return gain * 1.0f; if (oDistanceToAxis >= _outerRadius && distanceToOrigin >= outerHalfHeight) return gain * m_maxAttenuationFactor; const float rDelta = 1.0f - (oDistanceToAxis - _innerRadius) / (_outerRadius - _innerRadius); const float hDelta = 1.0f - (distanceToOrigin - _innerHalfHeight) / (_outerHalfHeight - _innerHalfHeight); const float delta = AM_MIN(rDelta, hDelta); return gain * AM_Lerp(m_maxAttenuationFactor, AM_CLAMP(delta, 0.0f, 1.0f), 1.0f); } }
#include <Sound/AttenuationShapes.h> #include <SparkyStudios/Audio/Amplitude/Core/Engine.h> #include <SparkyStudios/Audio/Amplitude/Core/Log.h> #include <Core/EngineInternalState.h> namespace SparkyStudios::Audio::Amplitude { AttenuationShape::AttenuationShape() : m_maxAttenuationFactor(1.0f) {} float AttenuationShape::GetAttenuationFactor(const Attenuation*, const hmm_vec3&, const ListenerInternalState*) { return m_maxAttenuationFactor; } float AttenuationShape::GetAttenuationFactor(const Attenuation*, const EntityInternalState*, const ListenerInternalState*) { return m_maxAttenuationFactor; } AttenuationShape* AttenuationShape::Create(const AttenuationShapeDefinition* definition) { if (definition == nullptr) return nullptr; AttenuationShape* shape = nullptr; switch (definition->model()) { default: case AttenuationShapeModel_Default: shape = new AttenuationShape(); break; case AttenuationShapeModel_Cone: shape = new ConeAttenuationShape(definition->settings_as_Cone()); break; case AttenuationShapeModel_Sphere: shape = new SphereAttenuationShape(definition->settings_as_Sphere()); break; case AttenuationShapeModel_Box: shape = new BoxAttenuationShape(definition->settings_as_Box()); break; case AttenuationShapeModel_Capsule: shape = new CapsuleAttenuationShape(definition->settings_as_Capsule()); break; } shape->m_maxAttenuationFactor = definition->max_attenuation_factor(); return shape; } float ConeAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { if (const hmm_vec3& soundToListener = listener->GetLocation() - soundLocation; AM_Length(soundToListener) >= attenuation->GetMaxDistance()) return 0.0f; return 1.0f; } float ConeAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - entity->GetLocation(); const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); const float coneDist = AM_Dot(soundToListener, entity->GetDirection()); if (coneDist < 0.0f || coneDist > _outerHeight) return gain * m_maxAttenuationFactor; if (coneDist > _innerHeight) return gain * AM_Lerp(1.0f, (coneDist - _innerHeight) / (_outerHeight - _innerHeight), m_maxAttenuationFactor); const float innerConeRadius = coneDist / _innerHeight * _innerRadius; const float outerConeRadius = coneDist / _outerHeight * _outerRadius; const float d = AM_Length(soundToListener - coneDist * entity->GetDirection()); if (d <= innerConeRadius) return gain * 1.0f; if (d >= outerConeRadius) return gain * m_maxAttenuationFactor; const float delta = (distance - innerConeRadius) / (outerConeRadius - innerConeRadius); return gain * AM_Lerp(1.0f, AM_CLAMP(delta, 0.0f, 1.0f), m_maxAttenuationFactor); } float ConeAttenuationShape::GetOuterRadius() const { return _outerRadius; } float ConeAttenuationShape::GetInnerRadius() const { return _innerRadius; } float ConeAttenuationShape::GetInnerHeight() const { return _innerHeight; } float ConeAttenuationShape::GetOuterHeight() const { return _outerHeight; } float SphereAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - soundLocation; const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); const float delta = (distance - _innerRadius) / (_outerRadius - _innerRadius); return gain * AM_Lerp(1.0f, AM_CLAMP(delta, 0.0f, 1.0f), m_maxAttenuationFactor); } float SphereAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { return GetAttenuationFactor(attenuation, entity->GetLocation(), listener); } float BoxAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - soundLocation; const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); return gain * _getFactor(soundLocation, listener, AM_Mat4d(1.0f)); } float BoxAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { const hmm_vec3& soundToListener = listener->GetLocation() - entity->GetLocation(); const float distance = AM_Length(soundToListener); if (distance >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(distance); return gain * _getFactor(entity->GetLocation(), listener, AM_LookAt(AM_Vec3(0, 0, 0), entity->GetDirection(), entity->GetUp())); } float BoxAttenuationShape::_getFactor(const hmm_vec3& soundLocation, const ListenerInternalState* listener, hmm_mat4 lookAt) { lookAt = AM_Multiply(AM_Translate(soundLocation), lookAt); const hmm_vec3& x = listener->GetLocation(); hmm_vec3 iP1, iP2, iP3, iP4, oP1, oP2, oP3, oP4; switch (amEngine->GetState()->up_axis) { default: case GameEngineUpAxis_Y: iP1 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfHeight, -_innerHalfDepth, 1.0f)).XYZ; iP2 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfHeight, _innerHalfDepth, 1.0f)).XYZ; iP3 = AM_Multiply(lookAt, AM_Vec4(_innerHalfWidth, -_innerHalfHeight, -_innerHalfDepth, 1.0f)).XYZ; iP4 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, _innerHalfHeight, -_innerHalfDepth, 1.0f)).XYZ; oP1 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfHeight, -_outerHalfDepth, 1.0f)).XYZ; oP2 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfHeight, _outerHalfDepth, 1.0f)).XYZ; oP3 = AM_Multiply(lookAt, AM_Vec4(_outerHalfWidth, -_outerHalfHeight, -_outerHalfDepth, 1.0f)).XYZ; oP4 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, _outerHalfHeight, -_outerHalfDepth, 1.0f)).XYZ; break; case GameEngineUpAxis_Z: iP1 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfDepth, -_innerHalfHeight, 1.0f)).XYZ; iP2 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, _innerHalfDepth, -_innerHalfHeight, 1.0f)).XYZ; iP3 = AM_Multiply(lookAt, AM_Vec4(_innerHalfWidth, -_innerHalfDepth, -_innerHalfHeight, 1.0f)).XYZ; iP4 = AM_Multiply(lookAt, AM_Vec4(-_innerHalfWidth, -_innerHalfDepth, _innerHalfHeight, 1.0f)).XYZ; oP1 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfDepth, -_outerHalfHeight, 1.0f)).XYZ; oP2 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, _outerHalfDepth, -_outerHalfHeight, 1.0f)).XYZ; oP3 = AM_Multiply(lookAt, AM_Vec4(_outerHalfWidth, -_outerHalfDepth, -_outerHalfHeight, 1.0f)).XYZ; oP4 = AM_Multiply(lookAt, AM_Vec4(-_outerHalfWidth, -_outerHalfDepth, _outerHalfHeight, 1.0f)).XYZ; break; } hmm_vec3 iU = AM_Normalize(iP2 - iP1); hmm_vec3 iV = AM_Normalize(iP3 - iP1); hmm_vec3 iW = AM_Normalize(iP4 - iP1); hmm_vec3 oU = AM_Normalize(oP2 - oP1); hmm_vec3 oV = AM_Normalize(oP3 - oP1); hmm_vec3 oW = AM_Normalize(oP4 - oP1); const float iUX = AM_Dot(iU, x); const float iVX = AM_Dot(iV, x); const float iWX = AM_Dot(iW, x); const float oUX = AM_Dot(oU, x); const float oVX = AM_Dot(oV, x); const float oWX = AM_Dot(oW, x); const float iUP1 = AM_Dot(iU, iP1); const float iVP1 = AM_Dot(iV, iP1); const float iWP1 = AM_Dot(iW, iP1); const float iUP2 = AM_Dot(iU, iP2); const float iVP3 = AM_Dot(iV, iP3); const float iWP4 = AM_Dot(iW, iP4); const float oUP1 = AM_Dot(oU, oP1); const float oVP1 = AM_Dot(oV, oP1); const float oWP1 = AM_Dot(oW, oP1); const float oUP2 = AM_Dot(oU, oP2); const float oVP3 = AM_Dot(oV, oP3); const float oWP4 = AM_Dot(oW, oP4); if (AM_BETWEEN(iUX, iUP1, iUP2) && AM_BETWEEN(iVX, iVP1, iVP3) && AM_BETWEEN(iWX, iWP1, iWP4)) return 1.0f; if (!(AM_BETWEEN(oUX, oUP1, oUP2) && AM_BETWEEN(oVX, oVP1, oVP3) && AM_BETWEEN(oWX, oWP1, oWP4))) return m_maxAttenuationFactor; const float dP1 = HMM_ABS(AM_Dot(x - oP1, AM_Normalize(oP2 - oP1))) / (_outerHalfDepth - _innerHalfDepth); const float dP2 = HMM_ABS(AM_Dot(x - oP2, AM_Normalize(oP1 - oP2))) / (_outerHalfDepth - _innerHalfDepth); const float dP3 = HMM_ABS(AM_Dot(x - oP3, AM_Normalize(oP1 - oP3))) / (_outerHalfWidth - _innerHalfWidth); const float dP4 = HMM_ABS(AM_Dot(x - oP4, AM_Normalize(oP1 - oP4))) / (_outerHalfHeight - _innerHalfHeight); const float dP5 = HMM_ABS(AM_Dot(x - oP1, AM_Normalize(oP3 - oP1))) / (_outerHalfWidth - _innerHalfWidth); const float dP6 = HMM_ABS(AM_Dot(x - oP1, AM_Normalize(oP4 - oP1))) / (_outerHalfHeight - _innerHalfHeight); const float shortestRoad = AM_MIN(dP1, AM_MIN(dP2, AM_MIN(dP3, AM_MIN(dP4, AM_MIN(dP5, dP6))))); return AM_Lerp(m_maxAttenuationFactor, AM_CLAMP(shortestRoad, 0.0f, 1.0f), 1.0f); } float CapsuleAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener) { return _getFactor(attenuation, soundLocation, listener, AM_Mat4d(1.0f)); } float CapsuleAttenuationShape::GetAttenuationFactor( const Attenuation* attenuation, const EntityInternalState* entity, const ListenerInternalState* listener) { return _getFactor( attenuation, entity->GetLocation(), listener, AM_LookAt(AM_Vec3(0, 0, 0), entity->GetDirection(), entity->GetUp())); } float CapsuleAttenuationShape::_getFactor( const Attenuation* attenuation, const hmm_vec3& soundLocation, const ListenerInternalState* listener, hmm_mat4 lookAt) { lookAt = AM_Multiply(AM_Translate(soundLocation),
const float outerHalfHeight = _outerHalfHeight - _outerRadius; hmm_vec3 iA, iB, oA, oB; switch (amEngine->GetState()->up_axis) { default: case GameEngineUpAxis_Y: iA = AM_Multiply(lookAt, AM_Vec4(0.0f, innerHalfHeight, 0.0f, 1.0f)).XYZ; iB = AM_Multiply(lookAt, AM_Vec4(0.0f, -innerHalfHeight, 0.0f, 1.0f)).XYZ; oA = AM_Multiply(lookAt, AM_Vec4(0.0f, outerHalfHeight, 0.0f, 1.0f)).XYZ; oB = AM_Multiply(lookAt, AM_Vec4(0.0f, -outerHalfHeight, 0.0f, 1.0f)).XYZ; break; case GameEngineUpAxis_Z: iA = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, innerHalfHeight, 1.0f)).XYZ; iB = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, -innerHalfHeight, 1.0f)).XYZ; oA = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, outerHalfHeight, 1.0f)).XYZ; oB = AM_Multiply(lookAt, AM_Vec4(0.0f, 0.0f, -outerHalfHeight, 1.0f)).XYZ; break; } hmm_vec3 iE = iB - iA; hmm_vec3 iM = AM_Cross(iA, iB); hmm_vec3 oE = oB - oA; hmm_vec3 oM = AM_Cross(oA, oB); const float iDistanceToAxis = AM_Length(iM + AM_Cross(iE, x)) / AM_Length(iE); const float oDistanceToAxis = AM_Length(oM + AM_Cross(oE, x)) / AM_Length(oE); if (oDistanceToAxis >= attenuation->GetMaxDistance()) return 0.0f; const float gain = attenuation->GetGainCurve().Get(iDistanceToAxis); const float iDistanceToA = AM_Length(x - iA); const float iDistanceToB = AM_Length(x - iB); const float oDistanceToA = AM_Length(x - oA); const float oDistanceToB = AM_Length(x - oB); if (iDistanceToAxis <= _innerRadius && distanceToOrigin <= innerHalfHeight) return gain * 1.0f; if (oDistanceToAxis >= _outerRadius && distanceToOrigin >= outerHalfHeight) return gain * m_maxAttenuationFactor; const float rDelta = 1.0f - (oDistanceToAxis - _innerRadius) / (_outerRadius - _innerRadius); const float hDelta = 1.0f - (distanceToOrigin - _innerHalfHeight) / (_outerHalfHeight - _innerHalfHeight); const float delta = AM_MIN(rDelta, hDelta); return gain * AM_Lerp(m_maxAttenuationFactor, AM_CLAMP(delta, 0.0f, 1.0f), 1.0f); } }
lookAt); const hmm_vec3& x = listener->GetLocation(); const float distanceToOrigin = AM_Length(x - soundLocation); const float innerHalfHeight = _innerHalfHeight - _innerRadius;
random
[ { "content": " class AttenuationShape\n\n {\n\n public:\n\n /**\n\n * @brief Returns the attenuation factor.\n\n *\n\n * This method is used only for position based sound sources.\n\n *\n\n * @param attenuation The Attenuator object to use for distance att...
C++
LargeBarrelAnalysis/tests/TimeWindowCreatorToolsTest.cpp
kdulski/j-pet-framework-examples
ab2592a2c6cf8f901f5732f8878b750b9a7b6a49
#define BOOST_TEST_DYN_LINK #define BOOST_TEST_MODULE TimeWindowCreatorToolsTest #include "../TimeWindowCreatorTools.h" #include <boost/test/unit_test.hpp> BOOST_AUTO_TEST_SUITE(TimeWindowCreatorToolsTestSuite) BOOST_AUTO_TEST_CASE(sortByValue_test) { JPetPM pm1(1, "first"); JPetSigCh sigCh1(JPetSigCh::Leading, 1.0); JPetSigCh sigCh2(JPetSigCh::Trailing, 4.0); JPetSigCh sigCh3(JPetSigCh::Leading, 2.0); JPetSigCh sigCh4(JPetSigCh::Leading, 6.0); JPetSigCh sigCh5(JPetSigCh::Trailing, 5.0); JPetSigCh sigCh6(JPetSigCh::Leading, 3.0); sigCh1.setPM(pm1); sigCh2.setPM(pm1); sigCh3.setPM(pm1); sigCh4.setPM(pm1); sigCh5.setPM(pm1); sigCh6.setPM(pm1); std::vector<JPetSigCh> sigChs; sigChs.push_back(sigCh1); sigChs.push_back(sigCh2); sigChs.push_back(sigCh3); sigChs.push_back(sigCh4); sigChs.push_back(sigCh5); sigChs.push_back(sigCh6); BOOST_REQUIRE_EQUAL(sigChs.at(0).getValue(), 1.0); BOOST_REQUIRE_EQUAL(sigChs.at(1).getValue(), 4.0); BOOST_REQUIRE_EQUAL(sigChs.at(2).getValue(), 2.0); BOOST_REQUIRE_EQUAL(sigChs.at(3).getValue(), 6.0); BOOST_REQUIRE_EQUAL(sigChs.at(4).getValue(), 5.0); BOOST_REQUIRE_EQUAL(sigChs.at(5).getValue(), 3.0); TimeWindowCreatorTools::sortByValue(sigChs); BOOST_REQUIRE_EQUAL(sigChs.at(0).getValue(), 1.0); BOOST_REQUIRE_EQUAL(sigChs.at(1).getValue(), 2.0); BOOST_REQUIRE_EQUAL(sigChs.at(2).getValue(), 3.0); BOOST_REQUIRE_EQUAL(sigChs.at(3).getValue(), 4.0); BOOST_REQUIRE_EQUAL(sigChs.at(4).getValue(), 5.0); BOOST_REQUIRE_EQUAL(sigChs.at(5).getValue(), 6.0); } BOOST_AUTO_TEST_CASE(generateSigCh_test) { JPetFEB feb(1, true, "just great", "very nice front-end board", 1, 1, 4, 4); JPetTRB trb(2, 555, 333); std::pair<float, float> hvGains(23.4, 43.2); JPetPM pm(JPetPM::SideA, 23, 123, 321, hvGains, "average pm"); JPetTOMBChannel channel(123); channel.setFEB(feb); channel.setTRB(trb); channel.setPM(pm); channel.setThreshold(34.5); channel.setLocalChannelNumber(1); std::map<unsigned int, std::vector<double>> thresholdsMap; std::map<unsigned int, std::vector<double>> timeCalibrationMap; std::vector<double> calibVec; calibVec.push_back(22.0); calibVec.push_back(33.0); calibVec.push_back(44.0); timeCalibrationMap[123] = calibVec; auto sigCh = TimeWindowCreatorTools::generateSigCh( 50.0, channel, timeCalibrationMap, thresholdsMap, JPetSigCh::Trailing, true); auto epsilon = 0.0001; BOOST_REQUIRE_EQUAL(sigCh.getType(), JPetSigCh::Trailing); BOOST_REQUIRE_EQUAL(sigCh.getPM().getID(), 23); BOOST_REQUIRE_EQUAL(sigCh.getFEB().getID(), 1); BOOST_REQUIRE_EQUAL(sigCh.getTRB().getID(), 2); BOOST_REQUIRE_EQUAL(sigCh.getDAQch(), 123); BOOST_REQUIRE_EQUAL(sigCh.getThresholdNumber(), 1); BOOST_REQUIRE_CLOSE(sigCh.getThreshold(), 34.5, epsilon); BOOST_REQUIRE_CLOSE(sigCh.getValue(), 1000.0 * (50.0 + 22.0), epsilon); } BOOST_AUTO_TEST_CASE(flagSigChs_test) { JPetSigCh sigCh00(JPetSigCh::Leading, 10.0); JPetSigCh sigCh01(JPetSigCh::Trailing, 11.0); JPetSigCh sigCh02(JPetSigCh::Leading, 12.0); JPetSigCh sigCh03(JPetSigCh::Leading, 13.0); JPetSigCh sigCh04(JPetSigCh::Trailing, 14.0); JPetSigCh sigCh05(JPetSigCh::Leading, 15.0); JPetSigCh sigCh06(JPetSigCh::Trailing, 16.0); JPetSigCh sigCh07(JPetSigCh::Leading, 17.0); JPetSigCh sigCh08(JPetSigCh::Trailing, 18.0); JPetSigCh sigCh09(JPetSigCh::Leading, 19.0); JPetSigCh sigCh10(JPetSigCh::Trailing, 20.0); JPetSigCh sigCh11(JPetSigCh::Trailing, 21.0); JPetSigCh sigCh12(JPetSigCh::Leading, 22.0); JPetSigCh sigCh13(JPetSigCh::Trailing, 23.0); JPetSigCh sigCh14(JPetSigCh::Leading, 24.0); JPetSigCh sigCh15(JPetSigCh::Leading, 25.0); JPetSigCh sigCh16(JPetSigCh::Leading, 26.0); JPetSigCh sigCh17(JPetSigCh::Trailing, 27.0); JPetSigCh sigCh18(JPetSigCh::Leading, 28.0); JPetSigCh sigCh19(JPetSigCh::Trailing, 29.0); JPetSigCh sigCh20(JPetSigCh::Leading, 30.0); JPetSigCh sigCh21(JPetSigCh::Trailing, 31.0); JPetSigCh sigCh22(JPetSigCh::Trailing, 32.0); JPetSigCh sigCh23(JPetSigCh::Trailing, 33.0); JPetSigCh sigCh24(JPetSigCh::Trailing, 33.0); JPetSigCh sigCh25(JPetSigCh::Leading, 34.0); JPetSigCh sigCh26(JPetSigCh::Trailing, 35.0); JPetSigCh sigCh27(JPetSigCh::Leading, 36.0); JPetPM pm1(1, "first"); sigCh00.setPM(pm1); sigCh01.setPM(pm1); sigCh02.setPM(pm1); sigCh03.setPM(pm1); sigCh04.setPM(pm1); sigCh05.setPM(pm1); sigCh06.setPM(pm1); sigCh07.setPM(pm1); sigCh08.setPM(pm1); sigCh09.setPM(pm1); sigCh10.setPM(pm1); sigCh11.setPM(pm1); sigCh12.setPM(pm1); sigCh13.setPM(pm1); sigCh14.setPM(pm1); sigCh15.setPM(pm1); sigCh16.setPM(pm1); sigCh17.setPM(pm1); sigCh18.setPM(pm1); sigCh19.setPM(pm1); sigCh20.setPM(pm1); sigCh21.setPM(pm1); sigCh22.setPM(pm1); sigCh23.setPM(pm1); sigCh24.setPM(pm1); sigCh25.setPM(pm1); sigCh26.setPM(pm1); sigCh27.setPM(pm1); std::vector<JPetSigCh> thrSigCh; thrSigCh.push_back(sigCh00); thrSigCh.push_back(sigCh01); thrSigCh.push_back(sigCh02); thrSigCh.push_back(sigCh03); thrSigCh.push_back(sigCh04); thrSigCh.push_back(sigCh05); thrSigCh.push_back(sigCh06); thrSigCh.push_back(sigCh07); thrSigCh.push_back(sigCh08); thrSigCh.push_back(sigCh09); thrSigCh.push_back(sigCh10); thrSigCh.push_back(sigCh11); thrSigCh.push_back(sigCh12); thrSigCh.push_back(sigCh13); thrSigCh.push_back(sigCh14); thrSigCh.push_back(sigCh15); thrSigCh.push_back(sigCh16); thrSigCh.push_back(sigCh17); thrSigCh.push_back(sigCh18); thrSigCh.push_back(sigCh19); thrSigCh.push_back(sigCh20); thrSigCh.push_back(sigCh21); thrSigCh.push_back(sigCh22); thrSigCh.push_back(sigCh23); thrSigCh.push_back(sigCh24); thrSigCh.push_back(sigCh25); thrSigCh.push_back(sigCh26); thrSigCh.push_back(sigCh27); JPetStatistics stats; TimeWindowCreatorTools::flagSigChs(thrSigCh, stats, false); BOOST_REQUIRE_EQUAL(thrSigCh.at(0).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(1).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(2).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(3).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(4).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(5).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(6).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(7).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(8).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(9).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(10).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(11).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(12).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(13).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(14).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(15).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(16).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(17).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(18).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(19).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(20).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(21).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(22).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(23).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(24).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(25).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(26).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(27).getRecoFlag(), JPetSigCh::Good); } BOOST_AUTO_TEST_SUITE_END()
#define BOOST_TEST_DYN_LINK #define BOOST_TEST_MODULE TimeWindowCreatorToolsTest #include "../TimeWindowCreatorTools.h" #include <boost/test/unit_test.hpp> BOOST_AUTO_TEST_SUITE(TimeWindowCreatorToolsTestSuite) BOOST_AUTO_TEST_CASE(sortByValue_test) { JPetPM pm1(1, "first"); JPetSigCh sigCh1(JPetSigCh::Leading, 1.0); JPetSigCh sigCh2(JPetSigCh::Trailing, 4.0); JPetSigCh sigCh3(JPetSigCh::Leading, 2.0); JPetSigCh sigCh4(JPetSigCh::Leading, 6.0); JPetSigCh sigCh5(JPetSigCh::Trailing, 5.0); JPetSigCh sigCh6(JPetSigCh::Leading, 3.0); sigCh1.setPM(pm1); sigCh2.setPM(pm1); sigCh3.setPM(pm1); sigCh4.setPM(pm1); sigCh5.setPM(pm1); sigCh6.setPM(pm1); std::vector<JPetSigCh> sigChs; sigChs.push_back(sigCh1); sigChs.push_back(sigCh2); sigChs.push_back(sigCh3); sigChs.push_back(sigCh4); sigChs.push_back(sigCh5); sigChs.push_back(sigCh6); BOOST_REQUIRE_EQUAL(sigChs.at(0).getValue(), 1.0); BOOST_REQUIRE_EQUAL(sigChs.at(1).getValue(), 4.0); BOOST_REQUIRE_EQUAL(sigChs.at(2).getValue(), 2.0); BOOST_REQUIRE_EQUAL(sigChs.at(3).getValue(), 6.0); BOOST_REQUIRE_EQUAL(sigChs.at(4).getValue(), 5.0); BOOST_REQUIRE_EQUAL(sigChs.at(5).getValue(), 3.0); TimeWindowCreatorTools::sortByValue(sigChs); BOOST_REQUIRE_EQUAL(sigChs.at(0).getValue(), 1.0); BOOST_REQUIRE_EQUAL(sigChs.at(1).getValue(), 2.0); BOOST_REQUIRE_EQUAL(sigChs.at(2).getValue(), 3.0); BOOST_REQUIRE_EQUAL(sigChs.at(3).getValue(), 4.0); BOOST_REQUIRE_EQUAL(sigChs.at(4).getValue(), 5.0); BOOST_REQUIRE_EQUAL(sigChs.at(5).getValue(), 6.0); } BOOST_AUTO_TEST_CASE(generateSigCh_test) { JPetFEB feb(1, true, "just great", "very nice front-end board", 1, 1, 4, 4); JPetTRB trb(2, 555, 333); std::pair<float, float> hvGains(23.4, 43.2); JPetPM pm(JPetPM::SideA, 23, 123, 321, hvGains, "average pm"); JPetTOMBChannel channel(123); channel.setFEB(feb); channel.setTRB(trb); channel.setPM(pm); channel.setThreshold(34.5); channel.setLocalChannelNumber(1); std::map<unsigned int, std::vector<double>> thresholdsMap; std::map<unsigned int, std::vector<double>> timeCalibrationMap; std::vector<double> calibVec; calibVec.push_back(22.0); calibVec.push_back(33.0); calibVec.push_back(44.0); timeCalibrationMap[123] = calibVec; auto sigCh = TimeWindowCreatorTools::generateSigCh( 50.0, channel, timeCalibrationMap, thresholdsMap, JPetSigCh::Trai
BOOST_AUTO_TEST_CASE(flagSigChs_test) { JPetSigCh sigCh00(JPetSigCh::Leading, 10.0); JPetSigCh sigCh01(JPetSigCh::Trailing, 11.0); JPetSigCh sigCh02(JPetSigCh::Leading, 12.0); JPetSigCh sigCh03(JPetSigCh::Leading, 13.0); JPetSigCh sigCh04(JPetSigCh::Trailing, 14.0); JPetSigCh sigCh05(JPetSigCh::Leading, 15.0); JPetSigCh sigCh06(JPetSigCh::Trailing, 16.0); JPetSigCh sigCh07(JPetSigCh::Leading, 17.0); JPetSigCh sigCh08(JPetSigCh::Trailing, 18.0); JPetSigCh sigCh09(JPetSigCh::Leading, 19.0); JPetSigCh sigCh10(JPetSigCh::Trailing, 20.0); JPetSigCh sigCh11(JPetSigCh::Trailing, 21.0); JPetSigCh sigCh12(JPetSigCh::Leading, 22.0); JPetSigCh sigCh13(JPetSigCh::Trailing, 23.0); JPetSigCh sigCh14(JPetSigCh::Leading, 24.0); JPetSigCh sigCh15(JPetSigCh::Leading, 25.0); JPetSigCh sigCh16(JPetSigCh::Leading, 26.0); JPetSigCh sigCh17(JPetSigCh::Trailing, 27.0); JPetSigCh sigCh18(JPetSigCh::Leading, 28.0); JPetSigCh sigCh19(JPetSigCh::Trailing, 29.0); JPetSigCh sigCh20(JPetSigCh::Leading, 30.0); JPetSigCh sigCh21(JPetSigCh::Trailing, 31.0); JPetSigCh sigCh22(JPetSigCh::Trailing, 32.0); JPetSigCh sigCh23(JPetSigCh::Trailing, 33.0); JPetSigCh sigCh24(JPetSigCh::Trailing, 33.0); JPetSigCh sigCh25(JPetSigCh::Leading, 34.0); JPetSigCh sigCh26(JPetSigCh::Trailing, 35.0); JPetSigCh sigCh27(JPetSigCh::Leading, 36.0); JPetPM pm1(1, "first"); sigCh00.setPM(pm1); sigCh01.setPM(pm1); sigCh02.setPM(pm1); sigCh03.setPM(pm1); sigCh04.setPM(pm1); sigCh05.setPM(pm1); sigCh06.setPM(pm1); sigCh07.setPM(pm1); sigCh08.setPM(pm1); sigCh09.setPM(pm1); sigCh10.setPM(pm1); sigCh11.setPM(pm1); sigCh12.setPM(pm1); sigCh13.setPM(pm1); sigCh14.setPM(pm1); sigCh15.setPM(pm1); sigCh16.setPM(pm1); sigCh17.setPM(pm1); sigCh18.setPM(pm1); sigCh19.setPM(pm1); sigCh20.setPM(pm1); sigCh21.setPM(pm1); sigCh22.setPM(pm1); sigCh23.setPM(pm1); sigCh24.setPM(pm1); sigCh25.setPM(pm1); sigCh26.setPM(pm1); sigCh27.setPM(pm1); std::vector<JPetSigCh> thrSigCh; thrSigCh.push_back(sigCh00); thrSigCh.push_back(sigCh01); thrSigCh.push_back(sigCh02); thrSigCh.push_back(sigCh03); thrSigCh.push_back(sigCh04); thrSigCh.push_back(sigCh05); thrSigCh.push_back(sigCh06); thrSigCh.push_back(sigCh07); thrSigCh.push_back(sigCh08); thrSigCh.push_back(sigCh09); thrSigCh.push_back(sigCh10); thrSigCh.push_back(sigCh11); thrSigCh.push_back(sigCh12); thrSigCh.push_back(sigCh13); thrSigCh.push_back(sigCh14); thrSigCh.push_back(sigCh15); thrSigCh.push_back(sigCh16); thrSigCh.push_back(sigCh17); thrSigCh.push_back(sigCh18); thrSigCh.push_back(sigCh19); thrSigCh.push_back(sigCh20); thrSigCh.push_back(sigCh21); thrSigCh.push_back(sigCh22); thrSigCh.push_back(sigCh23); thrSigCh.push_back(sigCh24); thrSigCh.push_back(sigCh25); thrSigCh.push_back(sigCh26); thrSigCh.push_back(sigCh27); JPetStatistics stats; TimeWindowCreatorTools::flagSigChs(thrSigCh, stats, false); BOOST_REQUIRE_EQUAL(thrSigCh.at(0).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(1).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(2).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(3).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(4).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(5).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(6).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(7).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(8).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(9).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(10).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(11).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(12).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(13).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(14).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(15).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(16).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(17).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(18).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(19).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(20).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(21).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(22).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(23).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(24).getRecoFlag(), JPetSigCh::Corrupted); BOOST_REQUIRE_EQUAL(thrSigCh.at(25).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(26).getRecoFlag(), JPetSigCh::Good); BOOST_REQUIRE_EQUAL(thrSigCh.at(27).getRecoFlag(), JPetSigCh::Good); } BOOST_AUTO_TEST_SUITE_END()
ling, true); auto epsilon = 0.0001; BOOST_REQUIRE_EQUAL(sigCh.getType(), JPetSigCh::Trailing); BOOST_REQUIRE_EQUAL(sigCh.getPM().getID(), 23); BOOST_REQUIRE_EQUAL(sigCh.getFEB().getID(), 1); BOOST_REQUIRE_EQUAL(sigCh.getTRB().getID(), 2); BOOST_REQUIRE_EQUAL(sigCh.getDAQch(), 123); BOOST_REQUIRE_EQUAL(sigCh.getThresholdNumber(), 1); BOOST_REQUIRE_CLOSE(sigCh.getThreshold(), 34.5, epsilon); BOOST_REQUIRE_CLOSE(sigCh.getValue(), 1000.0 * (50.0 + 22.0), epsilon); }
function_block-function_prefixed
[ { "content": "Description of available parameters in TimeCalibration example.\n\nNote that configuration/calibration filed can be obtained from PetWiki:\n\nhttp://koza.if.uj.edu.pl/petwiki/index.php/Default_settings_and_parameters_used_in_the_analyses\n\n--------\n\n\n\nSave_Control_Histograms_bool\n\n--- Commo...
C++
UnitTests/Physics/HeightFieldShapeTests.cpp
All8Up/JoltPhysics
751d13891f5bd8850863ad236eaa3c340e90de9a
#include "UnitTestFramework.h" #include "PhysicsTestContext.h" #include <Physics/Collision/RayCast.h> #include <Physics/Collision/CastResult.h> #include <Physics/Collision/Shape/HeightFieldShape.h> #include <Physics/Collision/PhysicsMaterialSimple.h> TEST_SUITE("HeightFieldShapeTests") { static void sRandomizeMaterials(HeightFieldShapeSettings &ioSettings, uint inMaxMaterials) { for (uint i = 0; i < inMaxMaterials; ++i) ioSettings.mMaterials.push_back(new PhysicsMaterialSimple("Material " + ConvertToString(i), Color::sGetDistinctColor(i))); if (inMaxMaterials > 1) { UnitTestRandom random; uniform_int_distribution<uint> index_distribution(0, inMaxMaterials - 1); ioSettings.mMaterialIndices.resize(Square(ioSettings.mSampleCount - 1)); for (uint y = 0; y < ioSettings.mSampleCount - 1; ++y) for (uint x = 0; x < ioSettings.mSampleCount - 1; ++x) ioSettings.mMaterialIndices[y * (ioSettings.mSampleCount - 1) + x] = uint8(index_distribution(random)); } } static Ref<HeightFieldShape> sValidateGetPosition(const HeightFieldShapeSettings &inSettings, float inMaxError) { Ref<HeightFieldShape> shape = static_cast<HeightFieldShape *>(inSettings.Create().Get().GetPtr()); float max_diff = -1.0f; for (uint y = 0; y < inSettings.mSampleCount; ++y) for (uint x = 0; x < inSettings.mSampleCount; ++x) { RayCast ray { inSettings.mOffset + inSettings.mScale * Vec3((float)x, 100.0f, (float)y), inSettings.mScale.GetY() * Vec3(0, -200, 0) }; RayCastResult hit; shape->CastRay(ray, SubShapeIDCreator(), hit); float height = inSettings.mHeightSamples[y * inSettings.mSampleCount + x]; if (height != HeightFieldShapeConstants::cNoCollisionValue) { CHECK(!shape->IsNoCollision(x, y)); Vec3 original_pos = inSettings.mOffset + inSettings.mScale * Vec3((float)x, height, (float)y); Vec3 shape_pos = shape->GetPosition(x, y); float diff = (original_pos - shape_pos).Length(); max_diff = max(max_diff, diff); if (x < inSettings.mSampleCount - 1 && y < inSettings.mSampleCount - 1) { const PhysicsMaterial *m1 = PhysicsMaterial::sDefault; if (!inSettings.mMaterialIndices.empty()) m1 = inSettings.mMaterials[inSettings.mMaterialIndices[y * (inSettings.mSampleCount - 1) + x]]; else if (!inSettings.mMaterials.empty()) m1 = inSettings.mMaterials.front(); const PhysicsMaterial *m2 = shape->GetMaterial(x, y); CHECK(m1 == m2); } if (x > 0 && y > 0 && x < inSettings.mSampleCount - 1 && y < inSettings.mSampleCount - 1) { Vec3 hit_pos = ray.mOrigin + ray.mDirection * hit.mFraction; CHECK_APPROX_EQUAL(hit_pos, shape_pos, 1.0e-3f); } } else { CHECK(shape->IsNoCollision(x, y)); CHECK(hit.mFraction > 1.0f); } } CHECK(max_diff <= inMaxError); return shape; } TEST_CASE("TestPlane") { HeightFieldShapeSettings settings; settings.mOffset = Vec3(3, 5, 7); settings.mScale = Vec3(9, 13, 17); settings.mSampleCount = 32; settings.mBitsPerSample = 1; settings.mBlockSize = 4; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = 1.0f; UnitTestRandom random; uniform_int_distribution<uint> index_distribution(0, (uint)settings.mHeightSamples.size() - 1); for (int i = 0; i < 10; ++i) settings.mHeightSamples[index_distribution(random)] = HeightFieldShapeConstants::cNoCollisionValue; CHECK(settings.CalculateBitsPerSampleForError(0.0f) == 1); sRandomizeMaterials(settings, 256); sValidateGetPosition(settings, 0.0f); } TEST_CASE("TestPlaneCloseToOrigin") { HeightFieldShapeSettings settings; settings.mSampleCount = 32; settings.mBitsPerSample = 1; settings.mBlockSize = 4; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = 1.0e-6f; CHECK(settings.CalculateBitsPerSampleForError(0.0f) == 1); sRandomizeMaterials(settings, 50); sValidateGetPosition(settings, 0.0f); } TEST_CASE("TestRandomHeightField") { const float cMinHeight = -5.0f; const float cMaxHeight = 10.0f; UnitTestRandom random; uniform_real_distribution<float> height_distribution(cMinHeight, cMaxHeight); HeightFieldShapeSettings settings; settings.mOffset = Vec3(0.3f, 0.5f, 0.7f); settings.mScale = Vec3(1.1f, 1.2f, 1.3f); settings.mSampleCount = 32; settings.mBitsPerSample = 8; settings.mBlockSize = 4; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = height_distribution(random); for (uint32 bits_per_sample = 1; bits_per_sample <= 8; ++bits_per_sample) { float max_error = 0.5f * (cMaxHeight - cMinHeight) / ((1 << bits_per_sample) - 1); uint32 calculated_bits_per_sample = settings.CalculateBitsPerSampleForError(max_error); CHECK(calculated_bits_per_sample <= bits_per_sample); } sRandomizeMaterials(settings, 1); sValidateGetPosition(settings, settings.mScale.GetY() * (cMaxHeight - cMinHeight) / ((1 << settings.mBitsPerSample) - 1)); } TEST_CASE("TestEmptyHeightField") { HeightFieldShapeSettings settings; settings.mSampleCount = 32; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = HeightFieldShapeConstants::cNoCollisionValue; CHECK(settings.CalculateBitsPerSampleForError(0.0f) == 1); sRandomizeMaterials(settings, 50); Ref<HeightFieldShape> shape = sValidateGetPosition(settings, 0.0f); Shape::Stats stats = shape->GetStats(); CHECK(stats.mNumTriangles == 0); CHECK(stats.mSizeBytes == sizeof(HeightFieldShape)); } }
#include "UnitTestFramework.h" #include "PhysicsTestContext.h" #include <Physics/Collision/RayCast.h> #include <Physics/Collision/CastResult.h> #include <Physics/Collision/Shape/HeightFieldShape.h> #include <Physics/Collision/PhysicsMaterialSimple.h> TEST_SUITE("HeightFieldShapeTests") { static void sRandomizeMaterials(HeightFieldShapeSettings &ioSettings, uint inMaxMaterials) { for (uint i = 0; i < inMaxMaterials; ++i) ioSettings.mMaterials.push_back(new PhysicsMaterialSimple("Material " + ConvertToString(i), Color::sGetDistinctColor(i))); if (inMaxMaterials > 1) { UnitTestRandom random; uniform_int_distribution<uint> index_distribution(0, inMaxMaterials - 1); ioSettings.mMaterialIndices.resize(Square(ioSettings.mSampleCount - 1)); for (uint y = 0; y < ioSettings.mSampleCount - 1; ++y) for (uint x = 0; x < ioSettings.mSampleCount - 1; ++x) ioSettings.mMaterialIndices[y * (ioSettings.mSampleCount - 1) + x] = uint8(index_distribution(random)); } } static Ref<HeightFieldShape> sValidateGetPosition(const HeightFieldShapeSettings &inSettings, float inMaxError) { Ref<HeightFieldShape> shape = static_cast<HeightFieldShape *>(inSettings.Create().Get().GetPtr()); float max_diff = -1.0f; for (uint y = 0; y < inSettings.mSampleCount; ++y) for (uint x = 0; x < inSettings.mSampleCount; ++x) { RayCast ray { inSettings.mOffset + inSettings.mScale * Vec3((float)x, 100.0f, (float)y), inSettings.mScale.GetY() * Vec3(0, -200, 0) }; RayCastResult hit; shape->CastRay(ray, SubShapeIDCreator(), hit); float height = inSettings.mHeightSamples[y * inSettings.mSampleCount + x]; if (height != HeightFieldShapeConstants::cNoCollisionValue) { CHECK(!shape->IsNoCollision(x, y)); Vec3 original_pos = inSettings.mOffset + inSettings.mScale * Vec3((float)x, height, (float)y); Vec3 shape_pos = shape->GetPosition(x, y); float diff = (original_pos - shape_pos).Length(); max_diff = max(max_diff, diff); if (x < inSettings.mSampleCount - 1 && y < inSettings.mSampleCount - 1) { const PhysicsMaterial *m1 = PhysicsMaterial::sDefault; if (!inSettings.mMaterialIndices.empty()) m1 = inSettings.mMaterials[inSettings.mMaterialIndices[y * (inSettings.mSampleCount - 1) + x]];
TEST_CASE("TestPlane") { HeightFieldShapeSettings settings; settings.mOffset = Vec3(3, 5, 7); settings.mScale = Vec3(9, 13, 17); settings.mSampleCount = 32; settings.mBitsPerSample = 1; settings.mBlockSize = 4; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = 1.0f; UnitTestRandom random; uniform_int_distribution<uint> index_distribution(0, (uint)settings.mHeightSamples.size() - 1); for (int i = 0; i < 10; ++i) settings.mHeightSamples[index_distribution(random)] = HeightFieldShapeConstants::cNoCollisionValue; CHECK(settings.CalculateBitsPerSampleForError(0.0f) == 1); sRandomizeMaterials(settings, 256); sValidateGetPosition(settings, 0.0f); } TEST_CASE("TestPlaneCloseToOrigin") { HeightFieldShapeSettings settings; settings.mSampleCount = 32; settings.mBitsPerSample = 1; settings.mBlockSize = 4; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = 1.0e-6f; CHECK(settings.CalculateBitsPerSampleForError(0.0f) == 1); sRandomizeMaterials(settings, 50); sValidateGetPosition(settings, 0.0f); } TEST_CASE("TestRandomHeightField") { const float cMinHeight = -5.0f; const float cMaxHeight = 10.0f; UnitTestRandom random; uniform_real_distribution<float> height_distribution(cMinHeight, cMaxHeight); HeightFieldShapeSettings settings; settings.mOffset = Vec3(0.3f, 0.5f, 0.7f); settings.mScale = Vec3(1.1f, 1.2f, 1.3f); settings.mSampleCount = 32; settings.mBitsPerSample = 8; settings.mBlockSize = 4; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = height_distribution(random); for (uint32 bits_per_sample = 1; bits_per_sample <= 8; ++bits_per_sample) { float max_error = 0.5f * (cMaxHeight - cMinHeight) / ((1 << bits_per_sample) - 1); uint32 calculated_bits_per_sample = settings.CalculateBitsPerSampleForError(max_error); CHECK(calculated_bits_per_sample <= bits_per_sample); } sRandomizeMaterials(settings, 1); sValidateGetPosition(settings, settings.mScale.GetY() * (cMaxHeight - cMinHeight) / ((1 << settings.mBitsPerSample) - 1)); } TEST_CASE("TestEmptyHeightField") { HeightFieldShapeSettings settings; settings.mSampleCount = 32; settings.mHeightSamples.resize(Square(settings.mSampleCount)); for (float &h : settings.mHeightSamples) h = HeightFieldShapeConstants::cNoCollisionValue; CHECK(settings.CalculateBitsPerSampleForError(0.0f) == 1); sRandomizeMaterials(settings, 50); Ref<HeightFieldShape> shape = sValidateGetPosition(settings, 0.0f); Shape::Stats stats = shape->GetStats(); CHECK(stats.mNumTriangles == 0); CHECK(stats.mSizeBytes == sizeof(HeightFieldShape)); } }
else if (!inSettings.mMaterials.empty()) m1 = inSettings.mMaterials.front(); const PhysicsMaterial *m2 = shape->GetMaterial(x, y); CHECK(m1 == m2); } if (x > 0 && y > 0 && x < inSettings.mSampleCount - 1 && y < inSettings.mSampleCount - 1) { Vec3 hit_pos = ray.mOrigin + ray.mDirection * hit.mFraction; CHECK_APPROX_EQUAL(hit_pos, shape_pos, 1.0e-3f); } } else { CHECK(shape->IsNoCollision(x, y)); CHECK(hit.mFraction > 1.0f); } } CHECK(max_diff <= inMaxError); return shape; }
function_block-function_prefix_line
[ { "content": "/// A height field shape. Cannot be used as a dynamic object.\n\nclass HeightFieldShape final : public Shape\n\n{\n\npublic:\n\n\t/// Constructor\n\n\t\t\t\t\t\t\t\t\tHeightFieldShape() : Shape(EShapeType::HeightField, EShapeSubType::HeightField) { }\n\n\t\t\t\t\t\t\t\t\tHeightFieldShape(const Hei...
C++
include/sharpen/MemoryTable.hpp
TalexDreamSoul/Sharpen
9167c4080438a1f150232d733c4da878639d6f66
#pragma once #ifndef _SHARPEN_MEMORYTABLE_HPP #define _SHARPEN_MEMORYTABLE_HPP #include <stdexcept> #include <map> #include <cassert> #include "ByteBuffer.hpp" #include "CompressedPair.hpp" #include "MemoryTableConcepts.hpp" #include "Noncopyable.hpp" #include "Optional.hpp" namespace sharpen { class MemoryTableItem { private: using Self = sharpen::MemoryTableItem; sharpen::Optional<sharpen::ByteBuffer> value_; public: MemoryTableItem() = default; explicit MemoryTableItem(sharpen::ByteBuffer value) :value_(std::move(value)) {} MemoryTableItem(const Self &other) = default; MemoryTableItem(Self &&other) noexcept = default; inline Self &operator=(const Self &other) { Self tmp{other}; std::swap(tmp,*this); return *this; } Self &operator=(Self &&other) noexcept = default; ~MemoryTableItem() noexcept = default; inline sharpen::ByteBuffer &Value() noexcept { assert(this->value_.Exist()); return this->value_.Get(); } inline const sharpen::ByteBuffer &Value() const noexcept { assert(this->value_.Exist()); return this->value_.Get(); } inline bool IsDeleted() const noexcept { return !this->value_.Exist(); } void Delete() noexcept { this->value_.Reset(); } }; template<typename _Logger,typename _Check = void> class InternalMemoryTable; template<typename _Logger> class InternalMemoryTable<_Logger,sharpen::EnableIf<sharpen::IsMemoryTableLogger<_Logger>::Value>>:public sharpen::Noncopyable { private: using Self = sharpen::InternalMemoryTable<_Logger,sharpen::EnableIf<sharpen::IsMemoryTableLogger<_Logger>::Value>>; using StoreItem = sharpen::MemoryTableItem; using MapType = std::map<sharpen::ByteBuffer,StoreItem>; using ConstIterator = typename MapType::const_iterator; sharpen::CompressedPair<_Logger,MapType> pair_; _Logger &Logger() noexcept { return this->pair_.First(); } const _Logger &Logger() const noexcept { return this->pair_.First(); } MapType &Map() noexcept { return this->pair_.Second(); } const MapType &Map() const noexcept { return this->pair_.Second(); } void InternalPut(sharpen::ByteBuffer key,sharpen::ByteBuffer value) { this->Map()[std::move(key)] = StoreItem{std::move(value)}; } void InternalDelete(sharpen::ByteBuffer key) { auto ite = this->Map().find(key); if(ite != this->Map().end()) { ite->second.Delete(); } else { this->Map().emplace(std::move(key),StoreItem{}); } } void InternalAction(sharpen::WriteBatch &batch) { for (auto begin = batch.Begin(),end = batch.End(); begin != end; ++begin) { if (begin->type_ == sharpen::WriteBatch::ActionType::Put) { this->InternalPut(std::move(begin->key_),std::move(begin->value_)); } else { this->InternalDelete(std::move(begin->key_)); } } batch.Clear(); } void InternalAction(const sharpen::WriteBatch &batch) { for (auto begin = batch.Begin(),end = batch.End(); begin != end; ++begin) { if (begin->type_ == sharpen::WriteBatch::ActionType::Put) { this->InternalPut(begin->key_,begin->value_); } else { this->InternalDelete(begin->key_); } } } public: enum class ExistStatus { Exist, Deleted, NotFound }; template<typename ..._Args,typename _Check = decltype(_Logger{std::declval<_Args>()...})> explicit InternalMemoryTable(_Args &&...args) :pair_(_Logger{std::forward<_Args>(args)...},MapType{}) {} InternalMemoryTable(Self &&other) noexcept = default; Self &operator=(Self &&other) noexcept { if(this != std::addressof(other)) { this->pair_ = std::move(other.pair_); } return *this; } ~InternalMemoryTable() noexcept = default; inline void Restore() { auto batchs = this->Logger().GetWriteBatchs(); for (auto begin = batchs.begin(),end = batchs.end(); begin != end; ++begin) { sharpen::WriteBatch &batch = *begin; this->InternalAction(batch); } } inline void Action(sharpen::WriteBatch &batch) { this->Logger().Log(batch); this->InternalAction(batch); } inline void Action(sharpen::WriteBatch &&batch) { this->Action(batch); } inline void Action(const sharpen::WriteBatch &batch) { this->Logger().Log(batch); this->InternalAction(batch); } inline void Put(sharpen::ByteBuffer key,sharpen::ByteBuffer value) { sharpen::WriteBatch batch; batch.Put(std::move(key),std::move(value)); this->Action(std::move(batch)); } inline void Delete(sharpen::ByteBuffer key) { sharpen::WriteBatch batch; batch.Delete(std::move(key)); this->Action(std::move(batch)); } void ClearLogs() { this->Logger().Clear(); } void RemoveLogs() { this->Logger().Remove(); } Self::ExistStatus Exist(const sharpen::ByteBuffer &key) const noexcept { auto ite = this->Map().find(key); if(ite == this->Map().end()) { return Self::ExistStatus::NotFound; } else if(ite->second.IsDeleted()) { return Self::ExistStatus::Deleted; } return Self::ExistStatus::Exist; } sharpen::ByteBuffer &Get(const sharpen::ByteBuffer &key) { auto &item = this->Map().at(key); if(item.IsDeleted()) { throw std::out_of_range("key doesn't exists"); } return item.Value(); } const sharpen::ByteBuffer &Get(const sharpen::ByteBuffer &key) const { auto &item = this->Map().at(key); if(item.deleteTag_) { throw std::out_of_range("key doesn't exists"); } return item.value_; } sharpen::ByteBuffer &operator[](const sharpen::ByteBuffer &key) { return this->Get(key); } const sharpen::ByteBuffer &operator[](const sharpen::ByteBuffer &key) const { return this->Get(key); } inline ConstIterator Begin() const noexcept { return this->Map().begin(); } inline ConstIterator End() const noexcept { return this->Map().end(); } }; template<typename _Logger> using MemoryTable = sharpen::InternalMemoryTable<_Logger>; } #endif
#pragma once #ifndef _SHARPEN_MEMORYTABLE_HPP #define _SHARPEN_MEMORYTABLE_HPP #include <stdexcept> #include <map> #include <cassert> #include "ByteBuffer.hpp" #include "CompressedPair.hpp" #include "MemoryTableConcepts.hpp" #include "Noncopyable.hpp" #include "Optional.hpp" namespace sharpen { class MemoryTableItem { private: using Self = sharpen::MemoryTableItem; sharpen::Optional<sharpen::ByteBuffer> value_; public: MemoryTableItem() = default; explicit MemoryTableItem(sharpen::ByteBuffer value) :value_(std::move(value)) {} MemoryTableItem(const Self &other) = default; MemoryTableItem(Self &&other) noexcept = default; inline Self &operator=(const Self &other) { Self tmp{other}; std::swap(tmp,*this); return *this; } Self &operator=(Self &&other) noexcept = default; ~MemoryTableItem() noexcept = default; inline sharpen::ByteBuffer &Value() noexcept { assert(this->value_.Exist()); return this->value_.Get(); } inline const sharpen::ByteBuffer &Value() const noexcept { assert(this->value_.Exist()); return this->value_.Get(); } inline bool IsDeleted() const noexcept { return !this->value_.Exist(); } void Delete() noexcept { this->value_.Reset(); } }; template<typename _Logger,typename _Check = void> class InternalMemoryTable; template<typename _Logger> class InternalMemoryTable<_Logger,sharpen::EnableIf<sharpen::IsMemoryTableLogger<_Logger>::Value>>:public sharpen::Noncopyable { private: using Self = sharpen::InternalMemoryTable<_Logger,sharpen::EnableIf<sharpen::IsMemoryTableLogger<_Logger>::Value>>; using StoreItem = sharpen::MemoryTableItem; using MapType = std::map<sharpen::ByteBuffer,StoreItem>; using ConstIterator = typename MapType::const_iterator; sharpen::CompressedPair<_Logger,MapType> pair_; _Logger &Logger() noexcept { return this->pair_.First(); } const _Logger &Logger() const noexcept { return this->pair_.First(); } MapType &Map() noexcept { return this->pair_.Second(); } const MapType &Map() const noexcept { return this->pair_.Second(); } void InternalPut(sharpen::ByteBuffer key,sharpen::ByteBuffer value) { this->Map()[std::move(key)] = StoreItem{std::move(value)}; } void InternalDelete(sharpen::ByteBuffer key) { auto ite = this->Map().find(key); if(ite != this->Map().end()) { ite->second.Delete(); } else { this->Map().emplace(std::move(key),StoreItem{}); } } void InternalAction(sharpen::WriteBatch &batch) { for (auto begin = batch.Begin(),end = batch.End(); begin != end; ++begin) { if (begin->type_ == sharpen::WriteBatch::ActionType::Put) { this->InternalPut(std::move(begin->key_),std::move(begin->value_)); } else { this->InternalDelete(std::move(begin->key_)); } } batch.Clear(); } void InternalAction(const sharpen::WriteBatch &batch) { for (auto begin = batch.Begin(),end = batch.End(); begin != end;
key_,begin->value_); } else { this->InternalDelete(begin->key_); } } } public: enum class ExistStatus { Exist, Deleted, NotFound }; template<typename ..._Args,typename _Check = decltype(_Logger{std::declval<_Args>()...})> explicit InternalMemoryTable(_Args &&...args) :pair_(_Logger{std::forward<_Args>(args)...},MapType{}) {} InternalMemoryTable(Self &&other) noexcept = default; Self &operator=(Self &&other) noexcept { if(this != std::addressof(other)) { this->pair_ = std::move(other.pair_); } return *this; } ~InternalMemoryTable() noexcept = default; inline void Restore() { auto batchs = this->Logger().GetWriteBatchs(); for (auto begin = batchs.begin(),end = batchs.end(); begin != end; ++begin) { sharpen::WriteBatch &batch = *begin; this->InternalAction(batch); } } inline void Action(sharpen::WriteBatch &batch) { this->Logger().Log(batch); this->InternalAction(batch); } inline void Action(sharpen::WriteBatch &&batch) { this->Action(batch); } inline void Action(const sharpen::WriteBatch &batch) { this->Logger().Log(batch); this->InternalAction(batch); } inline void Put(sharpen::ByteBuffer key,sharpen::ByteBuffer value) { sharpen::WriteBatch batch; batch.Put(std::move(key),std::move(value)); this->Action(std::move(batch)); } inline void Delete(sharpen::ByteBuffer key) { sharpen::WriteBatch batch; batch.Delete(std::move(key)); this->Action(std::move(batch)); } void ClearLogs() { this->Logger().Clear(); } void RemoveLogs() { this->Logger().Remove(); } Self::ExistStatus Exist(const sharpen::ByteBuffer &key) const noexcept { auto ite = this->Map().find(key); if(ite == this->Map().end()) { return Self::ExistStatus::NotFound; } else if(ite->second.IsDeleted()) { return Self::ExistStatus::Deleted; } return Self::ExistStatus::Exist; } sharpen::ByteBuffer &Get(const sharpen::ByteBuffer &key) { auto &item = this->Map().at(key); if(item.IsDeleted()) { throw std::out_of_range("key doesn't exists"); } return item.Value(); } const sharpen::ByteBuffer &Get(const sharpen::ByteBuffer &key) const { auto &item = this->Map().at(key); if(item.deleteTag_) { throw std::out_of_range("key doesn't exists"); } return item.value_; } sharpen::ByteBuffer &operator[](const sharpen::ByteBuffer &key) { return this->Get(key); } const sharpen::ByteBuffer &operator[](const sharpen::ByteBuffer &key) const { return this->Get(key); } inline ConstIterator Begin() const noexcept { return this->Map().begin(); } inline ConstIterator End() const noexcept { return this->Map().end(); } }; template<typename _Logger> using MemoryTable = sharpen::InternalMemoryTable<_Logger>; } #endif
++begin) { if (begin->type_ == sharpen::WriteBatch::ActionType::Put) { this->InternalPut(begin->
function_block-random_span
[]
C++
Code/Components/swcorrelator/current/swcorrelator/BasicMonitor.cc
rtobar/askapsoft
6bae06071d7d24f41abe3f2b7f9ee06cb0a9445e
#include <askap_swcorrelator.h> #include <swcorrelator/BasicMonitor.h> #include <askap/AskapLogging.h> #include <askap/AskapError.h> #include <askap/AskapUtil.h> #include <utils/DelayEstimator.h> #include <fstream> ASKAP_LOGGER(logger, ".basicmonitor"); namespace askap { namespace swcorrelator { BasicMonitor::BasicMonitor() : itsLastHistPosition(-1), itsWrapped(false) {} boost::shared_ptr<IMonitor> BasicMonitor::setup(const LOFAR::ParameterSet &) { ASKAPLOG_INFO_STR(logger, "Setting up Basic Data Monitor"); boost::shared_ptr<BasicMonitor> result(new BasicMonitor); return result; } void BasicMonitor::initialise(const int nAnt, const int nBeam, const int nChan) { if (itsHistory.nelements() == 0) { const int nHistory = 620; ASKAPDEBUGASSERT(nAnt > 1); ASKAPDEBUGASSERT(nBeam > 0); ASKAPDEBUGASSERT(nChan > 0); const int nBaselines = nAnt * (nAnt - 1) / 2; itsLastHistPosition = -1; itsWrapped = false; itsHistory.resize(nHistory,nBeam,nBaselines); itsHistory.set(casa::Complex(0.,0.)); itsDelayHistory.resize(nHistory, nBeam, nBaselines); itsDelayHistory.set(0.); itsControlHistory.resize(nHistory, nBeam, nBaselines); itsControlHistory.set(0u); itsBATs.resize(nHistory); itsBATs.set(0); } ASKAPDEBUGASSERT(itsHistory.shape() == itsDelayHistory.shape()); ASKAPDEBUGASSERT(itsHistory.nrow() == itsBATs.nelements()); } void BasicMonitor::advanceHistoryCursor(const uint64_t bat) { if (itsLastHistPosition >= 0) { if (bat == itsBATs[itsLastHistPosition]) { return; } else if (bat < itsBATs[itsLastHistPosition]) { ASKAPLOG_DEBUG_STR(logger, "New BAT = "<<bat<<" is earlier than the last history item BAT="<< itsBATs[itsLastHistPosition]); } } ++itsLastHistPosition; if (itsLastHistPosition >= int(itsHistory.nrow())) { itsLastHistPosition = 0; itsWrapped = true; } ASKAPDEBUGASSERT(itsLastHistPosition >= 0); ASKAPDEBUGASSERT(itsLastHistPosition < int(itsBATs.nelements())); itsBATs[itsLastHistPosition] = bat; } void BasicMonitor::publish(const CorrProducts &buf) { advanceHistoryCursor(buf.itsBAT); { const std::string fname = "spc_beam" + utility::toString<int>(buf.itsBeam) + ".dat"; std::ofstream os(fname.c_str()); for (casa::uInt chan=0; chan < buf.itsVisibility.ncolumn(); ++chan) { os<<chan<<" "; for (casa::uInt baseline = 0; baseline < buf.itsVisibility.nrow(); ++baseline) { os<<abs(buf.itsVisibility(baseline,chan))<<" "<<arg(buf.itsVisibility(baseline,chan))/casa::C::pi*180.<<" "; } os<<std::endl; } } const casa::Vector<casa::Float> delays = estimateDelays(buf.itsVisibility); ASKAPLOG_DEBUG_STR(logger, "Beam "<<buf.itsBeam<<": delays (s) = "<<delays); ASKAPDEBUGASSERT(delays.nelements() == buf.itsVisibility.nrow()); if (buf.itsBeam >= int(itsHistory.ncolumn())) { ASKAPLOG_DEBUG_STR(logger, "Receive buffer corresponding to beam "<<buf.itsBeam<< " which exceeds the maximum number of beams "<<itsHistory.ncolumn()); return; } for (casa::uInt baseline = 0; baseline < buf.itsVisibility.nrow(); ++baseline) { itsDelayHistory(itsLastHistPosition, buf.itsBeam, baseline) = delays[baseline]; itsControlHistory(itsLastHistPosition, buf.itsBeam, baseline) = buf.itsControl[baseline]; casa::Complex temp(0.,0.); for (casa::uInt chan=0; chan < buf.itsVisibility.ncolumn(); ++chan) { temp += buf.itsVisibility(baseline,chan); } itsHistory(itsLastHistPosition,buf.itsBeam,baseline) = temp / float(buf.itsVisibility.ncolumn()); } } void BasicMonitor::finalise() { std::ofstream os("visplot.dat"); const int nHistory = int(itsBATs.nelements()); for (int i=0, curPos = itsWrapped ? itsLastHistPosition + 1 : 0; i<nHistory; ++i,++curPos) { if (curPos >= nHistory) { curPos = 0; if (!itsWrapped) { break; } } os<<itsBATs[curPos]<<" "; for (int beam=0; beam < int(itsHistory.ncolumn()); ++beam) { for (casa::uInt baseline = 0; baseline < itsHistory.nplane(); ++baseline) { os<<abs(itsHistory(curPos,beam,baseline))<<" "<<arg(itsHistory(curPos,beam,baseline))/casa::C::pi*180.<<" " <<itsDelayHistory(curPos,beam,baseline)*1e9<<" "; } } for (casa::uInt baseline = 0; baseline < itsHistory.nplane(); ++baseline) { os<<itsControlHistory(curPos,0,baseline)<<" "; } os<<std::endl; if (curPos == itsLastHistPosition) { break; } } } casa::Vector<casa::Float> BasicMonitor::estimateDelays(const casa::Matrix<casa::Complex> &vis) { casa::Vector<casa::Float> result(vis.nrow(),0.); if (vis.ncolumn() >= 2) { scimath::DelayEstimator de(1e6); for (casa::uInt row = 0; row < vis.nrow(); ++row) { result[row] = float(de.getDelay(vis.row(row))); } } return result; } } }
#include <askap_swcorrelator.h> #include <swcorrelator/BasicMonitor.h> #include <askap/AskapLogging.h> #include <askap/AskapError.h> #include <askap/AskapUtil.h> #include <utils/DelayEstimator.h> #include <fstream> ASKAP_LOGGER(logger, ".basicmonitor"); namespace askap { namespace swcorrelator { BasicMonitor::BasicMonitor() : itsLastHistPosition(-1), itsWrapped(false) {} boost::shared_ptr<IMonitor> BasicMonitor::setup(const LOFAR::ParameterSet &) { ASKAPLOG_INFO_STR(logger, "Setting up Basic Data Monitor"); boost::shared_ptr<BasicMonitor> result(new BasicMonitor); return result; } void BasicMonitor::initialise(const int nAnt, const int nBeam, const int nChan) { if (itsHistory.nelements() == 0) { const int nHistory = 620; ASKAPDEBUGASSERT(nAnt > 1); ASKAPDEBUGASSERT(nBeam > 0); ASKAPDEBUGASSERT(nChan > 0); const int nBaselines = nAnt * (nAnt - 1) / 2; itsLastHistPosition = -1; itsWrapped = false; itsHistory.resize(nHistory,nBeam,nBaselines); itsHistory.set(casa::Complex(0.,0.)); itsDelayHistory.resize(nHistory, nBeam, nBaselines); itsDelayHistory.set(0.); itsControlHistory.resize(nHistory, nBeam, nBaselines); itsControlHistory.set(0u); itsBATs.resize(nHistory); itsBATs.set(0); } ASKAPDEBUGASSERT(itsHistory.shape() == itsDelayHistory.shape()); ASKAPDEBUGASSERT(itsHistory.nrow() == itsBATs.nelements()); } void BasicMonitor::advanceHistoryCursor(const uint64_t bat) { if (itsLastHistPosition >= 0) { if (bat == itsBATs[itsLastHistPosition]) { return; } else if (bat < itsBATs[itsLastHistPosition]) { ASKAPLOG_DEBUG_STR(logger, "New BAT = "<<bat<<" is earlier than the last history item BAT="<< itsBATs[itsLastHistPosition]); } } ++itsLastHistPosition; if (itsLastHistPosition >= int(itsHistory.nrow())) { itsLastHistPosition = 0; itsWrapped = true; } ASKAPDEBUGASSERT(itsLastHistPosition >= 0); ASKAPDEBUGASSERT(itsLastHistPosition < int(itsBATs.nelements())); itsBATs[itsLastHistPosition] = bat; } void BasicMonitor::publish(const CorrProducts &buf) { advanceHistoryCursor(buf.itsBAT); { const std::string fname = "spc_beam" + utility::toString<int>(buf.itsBeam) + ".dat"; std::ofstream os(fname.c_str()); for (casa::uInt chan=0; chan < buf.itsVisibility.ncolumn(); ++chan) { os<<chan<<" "; for (casa::uInt baseline = 0; baseline < buf.itsVisibility.nrow(); ++baseline) { os<<abs(buf.itsVisibility(baseline,chan))<<" "<<arg(buf.itsVisibility(baseline,chan))/casa::C::pi*180.<<" "; } os<<std::endl; } } const casa::Vector<casa::Float> delays = estimateDelays(buf.itsVisibility); ASKAPLOG_DEBUG_STR(logger, "Beam "<<buf.itsBeam<<": delays (s) = "<<delays); ASKAPDEBUGASSERT(delays.nelements() == buf.itsVisibility.nrow()); if (buf.itsBeam >= int(itsHistory.ncolumn())) { ASKAPLOG_DEBUG_STR(logger, "Receive buffer corresponding to beam "<<buf.itsBeam<< " which exceeds the maximum number of beams "<<itsHistory.ncolumn()); return; } for (casa::uInt baseline = 0; baseline < buf.itsVisibility.nrow(); ++baseline) { itsDelayHistory(itsLastHistPosition, buf.itsBeam, baseline) = delays[baseline]; itsControlHistory(itsLastHistPosition, buf.itsBeam, baseline) = buf.itsControl[baseline]; casa::Complex temp(0.,0.); for (casa::uInt chan=0; chan < buf.itsVisibility.ncolumn(); ++chan) { temp += buf.itsVisibility(baseline,chan); } itsHistory(itsLastHistPosition,buf.itsBeam,baseline) = temp / float(buf.itsVisibility.ncolumn()); } } void BasicMonitor::finalise() { std::ofstream os("visplot.dat"); const int nHistory = int(itsBATs.nelements()); for (int i=0, curPos = itsWrapped ? itsLastHistPosition + 1 : 0; i<nHistory; ++i,++curPos) { if (curPos >= nHistory) { curPos = 0; if (!itsWrapped) { break; } } os<<itsBATs[curPos]<<" "; for (int beam=0; beam < int(itsHistory.ncolumn()); ++beam) { for (casa::uInt baseline = 0; baseline < itsHistory.nplane(); ++baseline) { os<<abs(itsHistory(curPos,beam,baseline))<<" "<<arg(itsHistory(curPos,beam,baseline))/casa::C::pi*180.<<" " <<itsDelayHistory(curPos,beam,baseline)*1e9<<" "; } } for (casa::uInt baseline = 0; baseline < itsHistory.nplane(); ++baseline) { os<<itsControlHistory(curPos,0,baseline)<<" "; } os<<std::endl; if (curPos == itsLastHistPosition) { break; } } }
} }
casa::Vector<casa::Float> BasicMonitor::estimateDelays(const casa::Matrix<casa::Complex> &vis) { casa::Vector<casa::Float> result(vis.nrow(),0.); if (vis.ncolumn() >= 2) { scimath::DelayEstimator de(1e6); for (casa::uInt row = 0; row < vis.nrow(); ++row) { result[row] = float(de.getDelay(vis.row(row))); } } return result; }
function_block-full_function
[ { "content": "namespace askap {\n\n\n\nnamespace swcorrelator {\n\n\n\n/// @brief a collection of data monitors\n\n/// @details This class is just a container of data monitors. It implements basic calls\n\n/// of the IMonitor interface and translates them to each monitor held in the container.\n\n/// @ingroup s...
C++
src/core/net/netif.cpp
jjzhang166/openthread
e68e38b8e85fe4eeb3810727cd3583b5f87a4e70
#include <common/code_utils.hpp> #include <common/debug.hpp> #include <common/message.hpp> #include <net/netif.hpp> namespace Thread { namespace Ip6 { Netif *Netif::sNetifListHead = NULL; int Netif::sNextInterfaceId = 1; Netif::Netif() : mUnicastChangedTask(&HandleUnicastChangedTask, this) { mHandlers = NULL; mUnicastAddresses = NULL; mMulticastAddresses = NULL; mInterfaceId = -1; mAllRoutersSubscribed = false; mNext = NULL; } ThreadError Netif::RegisterHandler(NetifHandler &aHandler) { ThreadError error = kThreadError_None; for (NetifHandler *cur = mHandlers; cur; cur = cur->mNext) { if (cur == &aHandler) { ExitNow(error = kThreadError_Busy); } } aHandler.mNext = mHandlers; mHandlers = &aHandler; exit: return error; } ThreadError Netif::AddNetif() { ThreadError error = kThreadError_None; Netif *netif; if (sNetifListHead == NULL) { sNetifListHead = this; } else { netif = sNetifListHead; do { if (netif == this) { ExitNow(error = kThreadError_Busy); } } while (netif->mNext); netif->mNext = this; } mNext = NULL; if (mInterfaceId < 0) { mInterfaceId = sNextInterfaceId++; } exit: return error; } ThreadError Netif::RemoveNetif() { ThreadError error = kThreadError_None; VerifyOrExit(sNetifListHead != NULL, error = kThreadError_Busy); if (sNetifListHead == this) { sNetifListHead = mNext; } else { for (Netif *netif = sNetifListHead; netif->mNext; netif = netif->mNext) { if (netif->mNext != this) { continue; } netif->mNext = mNext; break; } } mNext = NULL; exit: return error; } Netif *Netif::GetNext() const { return mNext; } Netif *Netif::GetNetifById(uint8_t aInterfaceId) { Netif *netif; for (netif = sNetifListHead; netif; netif = netif->mNext) { if (netif->mInterfaceId == aInterfaceId) { ExitNow(); } } exit: return netif; } Netif *Netif::GetNetifByName(char *aName) { Netif *netif; for (netif = sNetifListHead; netif; netif = netif->mNext) { if (strcmp(netif->GetName(), aName) == 0) { ExitNow(); } } exit: return netif; } int Netif::GetInterfaceId() const { return mInterfaceId; } bool Netif::IsMulticastSubscribed(const Address &aAddress) const { bool rval = false; if (aAddress.IsLinkLocalAllNodesMulticast() || aAddress.IsRealmLocalAllNodesMulticast()) { ExitNow(rval = true); } else if (aAddress.IsLinkLocalAllRoutersMulticast() || aAddress.IsRealmLocalAllRoutersMulticast()) { ExitNow(rval = mAllRoutersSubscribed); } for (NetifMulticastAddress *cur = mMulticastAddresses; cur; cur = cur->mNext) { if (memcmp(&cur->mAddress, &aAddress, sizeof(cur->mAddress)) == 0) { ExitNow(rval = true); } } exit: return rval; } void Netif::SubscribeAllRoutersMulticast() { mAllRoutersSubscribed = true; } void Netif::UnsubscribeAllRoutersMulticast() { mAllRoutersSubscribed = false; } ThreadError Netif::SubscribeMulticast(NetifMulticastAddress &aAddress) { ThreadError error = kThreadError_None; for (NetifMulticastAddress *cur = mMulticastAddresses; cur; cur = cur->mNext) { if (cur == &aAddress) { ExitNow(error = kThreadError_Busy); } } aAddress.mNext = mMulticastAddresses; mMulticastAddresses = &aAddress; exit: return error; } ThreadError Netif::UnsubscribeMulticast(const NetifMulticastAddress &aAddress) { ThreadError error = kThreadError_None; if (mMulticastAddresses == &aAddress) { mMulticastAddresses = mMulticastAddresses->mNext; ExitNow(); } else if (mMulticastAddresses != NULL) { for (NetifMulticastAddress *cur = mMulticastAddresses; cur->mNext; cur = cur->mNext) { if (cur->mNext == &aAddress) { cur->mNext = aAddress.mNext; ExitNow(); } } } ExitNow(error = kThreadError_Error); exit: return error; } const NetifUnicastAddress *Netif::GetUnicastAddresses() const { return mUnicastAddresses; } ThreadError Netif::AddUnicastAddress(NetifUnicastAddress &aAddress) { ThreadError error = kThreadError_None; for (NetifUnicastAddress *cur = mUnicastAddresses; cur; cur = cur->GetNext()) { if (cur == &aAddress) { ExitNow(error = kThreadError_Busy); } } aAddress.mNext = mUnicastAddresses; mUnicastAddresses = &aAddress; mUnicastChangedTask.Post(); exit: return error; } ThreadError Netif::RemoveUnicastAddress(const NetifUnicastAddress &aAddress) { ThreadError error = kThreadError_None; if (mUnicastAddresses == &aAddress) { mUnicastAddresses = mUnicastAddresses->GetNext(); ExitNow(); } else if (mUnicastAddresses != NULL) { for (NetifUnicastAddress *cur = mUnicastAddresses; cur->GetNext(); cur = cur->GetNext()) { if (cur->mNext == &aAddress) { cur->mNext = aAddress.mNext; ExitNow(); } } } ExitNow(error = kThreadError_Error); exit: mUnicastChangedTask.Post(); return error; } Netif *Netif::GetNetifList() { return sNetifListHead; } bool Netif::IsUnicastAddress(const Address &aAddress) { bool rval = false; for (Netif *netif = sNetifListHead; netif; netif = netif->mNext) { for (NetifUnicastAddress *cur = netif->mUnicastAddresses; cur; cur = cur->GetNext()) { if (cur->GetAddress() == aAddress) { ExitNow(rval = true); } } } exit: return rval; } const NetifUnicastAddress *Netif::SelectSourceAddress(MessageInfo &aMessageInfo) { Address *destination = &aMessageInfo.GetPeerAddr(); int interfaceId = aMessageInfo.mInterfaceId; const NetifUnicastAddress *rvalAddr = NULL; const Address *candidateAddr; uint8_t candidateId; uint8_t rvalIface = 0; for (Netif *netif = GetNetifList(); netif; netif = netif->mNext) { candidateId = netif->GetInterfaceId(); for (const NetifUnicastAddress *addr = netif->GetUnicastAddresses(); addr; addr = addr->GetNext()) { candidateAddr = &addr->GetAddress(); if (destination->IsLinkLocal() || destination->IsMulticast()) { if (interfaceId != candidateId) { continue; } } if (rvalAddr == NULL) { rvalAddr = addr; rvalIface = candidateId; } else if (*candidateAddr == *destination) { rvalAddr = addr; rvalIface = candidateId; goto exit; } else if (candidateAddr->GetScope() < rvalAddr->GetAddress().GetScope()) { if (candidateAddr->GetScope() >= destination->GetScope()) { rvalAddr = addr; rvalIface = candidateId; } } else if (candidateAddr->GetScope() > rvalAddr->GetAddress().GetScope()) { if (rvalAddr->GetAddress().GetScope() < destination->GetScope()) { rvalAddr = addr; rvalIface = candidateId; } } else if (addr->mPreferredLifetime != 0 && rvalAddr->mPreferredLifetime == 0) { rvalAddr = addr; rvalIface = candidateId; } else if (aMessageInfo.mInterfaceId != 0 && aMessageInfo.mInterfaceId == candidateId && rvalIface != candidateId) { rvalAddr = addr; rvalIface = candidateId; } else if (destination->PrefixMatch(*candidateAddr) > destination->PrefixMatch(rvalAddr->GetAddress())) { rvalAddr = addr; rvalIface = candidateId; } } } exit: aMessageInfo.mInterfaceId = rvalIface; return rvalAddr; } int Netif::GetOnLinkNetif(const Address &aAddress) { int rval = -1; for (Netif *netif = sNetifListHead; netif; netif = netif->mNext) { for (NetifUnicastAddress *cur = netif->mUnicastAddresses; cur; cur = cur->GetNext()) { if (cur->GetAddress().PrefixMatch(aAddress) >= cur->mPrefixLength) { ExitNow(rval = netif->mInterfaceId); } } } exit: return rval; } void Netif::HandleUnicastChangedTask(void *aContext) { Netif *obj = reinterpret_cast<Netif *>(aContext); obj->HandleUnicastChangedTask(); } void Netif::HandleUnicastChangedTask() { for (NetifHandler *handler = mHandlers; handler; handler = handler->mNext) { handler->HandleUnicastAddressesChanged(); } } } }
#include <common/code_utils.hpp> #include <common/debug.hpp> #include <common/message.hpp> #include <net/netif.hpp> namespace Thread { namespace Ip6 { Netif *Netif::sNetifListHead = NULL; int Netif::sNextInterfaceId = 1; Netif::Netif() : mUnicastChangedTask(&HandleUnicastChangedTask, this) { mHandlers = NULL; mUnicastAddresses = NULL; mMulticastAddresses = NULL; mInterfaceId = -1; mAllRoutersSubscribed = false; mNext = NULL; } ThreadError Netif::RegisterHandler(NetifHandler &aHandler) { ThreadError error = kThreadError_None; for (NetifHandler *cur = mHandlers; cur; cur = cur->mNext) { if (cur == &aHandler) { ExitNow(error = kThreadError_Busy); } } aHandler.mNext = mHandlers; mHandlers = &aHandler; exit: return error; } ThreadError Netif::AddNetif() { ThreadError error = kThreadError_None; Netif *netif; if (sNetifListHead == NULL) { sNetifListHead = this; } else { netif = sNetifListHead; do { if (netif == this) { ExitNow(error = kThreadError_Busy); } } while (netif->mNext); netif->mNext = this; } mNext = NULL; if (mInterfaceId < 0) { mInterfaceId = sNextInterfaceId++; } exit: return error; } ThreadError Netif::RemoveNetif() { ThreadError error = kThreadError_None; VerifyOrExit(sNetifListHead != NULL, error = kThreadError_Busy); if (sNetifListHead == this) { sNetifListHead = mNext; } else { for (Netif *netif = sNetifListHead; netif->mNext; netif = netif->mNext) { if (netif->mNext != this) { continue; } netif->mNext = mNext; break; } } mNext = NULL; exit: return error; } Netif *Netif::GetNext() const { return mNext; } Netif *Netif::GetNetifById(uint8_t aInterfaceId) { Netif *netif; for (netif = sNetifListHead; netif; netif = netif->mNext) { if (netif->mInterfaceId == aInterfaceId) { ExitNow(); } } exit: return netif; } Netif *Netif::GetNetifByName(char *aName) { Netif *netif; for (netif = sNetifListHead; netif; netif = netif->mNext) { if (strcmp(netif->GetName(), aName) == 0) { ExitNow(); } } exit: return netif; } int Netif::GetInterfaceId() const { return mInterfaceId; } bool Netif::IsMulticastSubscribed(const Address &aAddress) const { bool rval = false; if (aAddress.IsLinkLocalAllNodesMulticast() || aAddress.IsRealmLocalAllNodesMulticast()) { ExitNow(rval = true); } else if (aAddress.IsLinkLocalAllRoutersMulticast() || aAddress.IsRealmLocalAllRoutersMulticast()) { ExitNow(rval = mAllRoutersSubscribed); } for (NetifMulticastAddress *cur = mMulticastAddresses; cur; cur = cur->mNext) { if (memcmp(&cur->mAddress, &aAddress, sizeof(cur->mAddress)) == 0) { ExitNow(rval = true); } } exit: return rval; } void Netif::SubscribeAllRoutersMulticast() { mAllRoutersSubscribed = true; } void Netif::UnsubscribeAllRoutersMulticast() { mAllRoutersSubscribed = false; } ThreadError Netif::SubscribeMulticast(NetifMulticastAddress &aAddress) { ThreadError error = kThreadError_None; for (NetifMulticastAddress *cur = mMulticastAddresses; cur; cur = cur->mNext) { if (cur == &aAddress) { ExitNow(error = kThreadError_Busy); } } aAddress.mNext = mMulticastAddresses; mMulticastAddresses = &aAddress; exit: return error; } ThreadError Netif::UnsubscribeMulticast(const NetifMulticastAddress &aAddress) { ThreadError error = kThreadError_None; if (mMulticastAddresses == &aAddress) { mMulticastAddresses = mMulticastAddresses->mNext; ExitNow(); } else if (mMulticastAddresses != NULL) { for (NetifMulticastAddress *cur = mMulticastAddresses; cur->mNext; cur = cur->mNext) { if (cur->mNext == &aAddress) { cur->mNext = aAddress.mNext; ExitNow(); } } } ExitNow(error = kThreadError_Error); exit: return error; } const NetifUnicastAddress *Netif::GetUnicastAddresses() const { return mUnicastAddresses; } ThreadError Netif::AddUnicastAddress(NetifUnicastAddress &aAddress) { ThreadError error = kThreadError_None; for (NetifUnicastAddress *cur = mUnicastAddresses; cur; cur = cur->GetNext()) { if (cur == &aAddress) { ExitNow(error = kThreadError_Busy); } } aAddress.mNext = mUnicastAddresses; mUnicastAddresses = &aAddress; mUnicastChangedTask.Post(); exit: return error; } ThreadError Netif::RemoveUnicastAddress(const NetifUnicastAddress &aAddress) { ThreadError error = kThreadError_None; if (mUnicastAddresses == &aAddress) { mUnicastAddresses = mUnicastAddresses->GetNext(); ExitNow(); } else if (mUnicastAddresses != NULL) { for (NetifUnicastAddress *cur = mUnicastAddresses; cur->GetNext(); cur = cur->GetNext()) { if (cur->mNext == &aAddress) { cur->mNext = aAddress.mNext; ExitNow(); } } } ExitNow(error = kThreadError_Error); exit: mUnicastChangedTask.Post(); return error; } Netif *Netif::GetNetifList() { return sNetifListHead; } bool Netif::IsUnicastAddress(const Address &aAddress) { bool rval = false; for (Netif *netif = sNetifListHead; netif; netif = netif->mNext) { for (NetifUnicastAddress *cur = netif->mUnicastAddresses; cur; cur = cur->GetNext()) { if (cur->GetAddress() == aAddress) { ExitNow(rval = true); } } } exit: return rval; } const NetifUnicastAddress *Netif::SelectSourceAddress(MessageInfo &aMessageInfo) { Address *destination = &aMessageInfo.GetPeerAddr(); int interfaceId = aMessageInfo.mInterfaceId; const NetifUnicastAddress *rvalAddr = NULL; const Address *candidateAddr; uint8_t candidateId; uint8_t rvalIface = 0; for (Netif *netif = GetNetifList(); netif; netif = netif->mNext) { candidateId = netif->GetInterfaceId(); for (const NetifUnicastAddress *addr = netif->GetUnicastAddresses(); addr; addr = addr->GetNext()) { candidateAddr = &addr->GetAddress(); if (destination->IsLinkLocal() || destination->IsMulticast()) { if (interfaceId != candidateId) { continue; } } if (rvalAddr == NULL) { rvalAddr = addr; rvalIface = candidateId; } else if (*candidateAddr == *destination) { rvalAddr = addr; rvalIface = candidateId; goto exit; } else if (candidateAddr->GetScope() < rvalAddr->GetAddress().GetScope()) { if (candidateAddr->GetScope() >= destination->GetScope()) { rvalAddr = addr; rvalIface = candidateId; } } else if (candidateAddr->GetScope() > rvalAddr->GetAddress().GetScope()) { if (rvalAddr->
int Netif::GetOnLinkNetif(const Address &aAddress) { int rval = -1; for (Netif *netif = sNetifListHead; netif; netif = netif->mNext) { for (NetifUnicastAddress *cur = netif->mUnicastAddresses; cur; cur = cur->GetNext()) { if (cur->GetAddress().PrefixMatch(aAddress) >= cur->mPrefixLength) { ExitNow(rval = netif->mInterfaceId); } } } exit: return rval; } void Netif::HandleUnicastChangedTask(void *aContext) { Netif *obj = reinterpret_cast<Netif *>(aContext); obj->HandleUnicastChangedTask(); } void Netif::HandleUnicastChangedTask() { for (NetifHandler *handler = mHandlers; handler; handler = handler->mNext) { handler->HandleUnicastAddressesChanged(); } } } }
GetAddress().GetScope() < destination->GetScope()) { rvalAddr = addr; rvalIface = candidateId; } } else if (addr->mPreferredLifetime != 0 && rvalAddr->mPreferredLifetime == 0) { rvalAddr = addr; rvalIface = candidateId; } else if (aMessageInfo.mInterfaceId != 0 && aMessageInfo.mInterfaceId == candidateId && rvalIface != candidateId) { rvalAddr = addr; rvalIface = candidateId; } else if (destination->PrefixMatch(*candidateAddr) > destination->PrefixMatch(rvalAddr->GetAddress())) { rvalAddr = addr; rvalIface = candidateId; } } } exit: aMessageInfo.mInterfaceId = rvalIface; return rvalAddr; }
function_block-function_prefixed
[ { "content": "class ThreadNetif: public Ip6::Netif\n\n{\n\npublic:\n\n /**\n\n * This constructor initializes the Thread network interface.\n\n *\n\n */\n\n ThreadNetif(void);\n\n\n\n /**\n\n * This method enables the Thread network interface.\n\n *\n\n */\n\n ThreadError Up(...
C++
MUON/MUONgraphics/AliMUONPCBPainter.cxx
AllaMaevskaya/AliRoot
c53712645bf1c7d5f565b0d3228e3a6b9b09011a
#include "AliMUONPCBPainter.h" #include "AliMUONManuPainter.h" #include "AliMUONContour.h" #include "AliMUONPainterHelper.h" #include "AliMUONVCalibParam.h" #include "AliMUONVTrackerData.h" #include "AliMpDEManager.h" #include "AliMpMotifPosition.h" #include "AliMpPCB.h" #include "AliMpPlaneType.h" #include "AliMpSlat.h" #include "AliLog.h" ClassImp(AliMUONPCBPainter) AliMUONPCBPainter::AliMUONPCBPainter(TRootIOCtor* ioCtor) : AliMUONVPainter(ioCtor), fDetElemId(-1), fPCBIndex(-1) { } AliMUONPCBPainter::AliMUONPCBPainter() : AliMUONVPainter(), fDetElemId(-1), fPCBIndex(-1) { } AliMUONPCBPainter::AliMUONPCBPainter(const AliMUONAttPainter& att, Int_t detElemId, Int_t pcbNumber) : AliMUONVPainter("PCB"), fDetElemId(detElemId), fPCBIndex(pcbNumber) { SetAttributes(att); AliMUONPainterHelper* h = AliMUONPainterHelper::Instance(); AliMp::PlaneType planeType = ( att.IsBendingPlane() ? AliMp::kBendingPlane : AliMp::kNonBendingPlane ); const AliMpSlat* slat = AliMUONPainterHelper::Instance()->GetSlat(fDetElemId,planeType); SetID(detElemId,pcbNumber); SetName(h->PCBName(pcbNumber)); SetPathName(h->PCBPathName(detElemId,pcbNumber)); AliMpPCB* pcb = slat->GetPCB(fPCBIndex); AliMUONContour* contour = h->GetContour(ContourName()); TObjArray contourArray; for ( Int_t imp = 0 ; imp < pcb->GetSize(); ++imp ) { AliMpMotifPosition* mp = pcb->GetMotifPosition(imp); AliMUONVPainter* painter = new AliMUONManuPainter(Attributes(),fDetElemId,mp->GetID()); Add(painter); if (!contour) { contourArray.Add(painter->Contour()); } } Double_t x,y,z; h->Local2Global(fDetElemId, pcb->X()-slat->GetPositionX(), pcb->Y()-slat->GetPositionY(), 0.0, x,y,z); if (!contour) { contour = h->MergeContours(contourArray,ContourName()); } SetContour(contour); } AliMUONPCBPainter::~AliMUONPCBPainter() { } AliMUONPCBPainter::AliMUONPCBPainter(const AliMUONPCBPainter& rhs) : AliMUONVPainter(rhs), fDetElemId(-1), fPCBIndex(-1) { rhs.Copy(*this); } AliMUONPCBPainter& AliMUONPCBPainter::operator=(const AliMUONPCBPainter& rhs) { if ( this != &rhs ) { rhs.Copy(*this); } return *this; } void AliMUONPCBPainter::ComputeDataRange(const AliMUONVTrackerData& data, Int_t dataIndex, Double_t& dataMin, Double_t& dataMax) const { dataMin = dataMax = data.PCB(fDetElemId, fPCBIndex,dataIndex); } void AliMUONPCBPainter::Copy(TObject& object) const { AliMUONVPainter::Copy((AliMUONVPainter&)(object)); ((AliMUONPCBPainter&)(object)).fDetElemId = fDetElemId; ((AliMUONPCBPainter&)(object)).fPCBIndex = fPCBIndex; } TString AliMUONPCBPainter::Describe(const AliMUONVTrackerData& data, Int_t dataIndex, Double_t, Double_t) { if (!data.HasPCB(fDetElemId,fPCBIndex)) return ""; Double_t value = data.PCB(fDetElemId,fPCBIndex,dataIndex); return AliMUONPainterHelper::Instance()->FormatValue(data.DimensionName(dataIndex).Data(),value); } Bool_t AliMUONPCBPainter::IsIncluded() const { return ( InteractiveReadOutConfig()->PCB(fDetElemId,fPCBIndex) > 0 ); } void AliMUONPCBPainter::PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex, Double_t min, Double_t max) { if (!data.HasPCB(fDetElemId,fPCBIndex)) return; Double_t value = data.PCB(fDetElemId,fPCBIndex,dataIndex); if ( value >= AliMUONVCalibParam::InvalidFloatValue() ) return; Int_t color = AliMUONPainterHelper::Instance()->ColorFromValue(value,min,max); PaintArea(color); }
#include "AliMUONPCBPainter.h" #include "AliMUONManuPainter.h" #include "AliMUONContour.h" #include "AliMUONPainterHelper.h" #include "AliMUONVCalibParam.h" #include "AliMUONVTrackerData.h" #include "AliMpDEManager.h" #include "AliMpMotifPosition.h" #include "AliMpPCB.h" #include "AliMpPlaneType.h" #include "AliMpSlat.h" #include "AliLog.h" ClassImp(AliMUONPCBPainter) AliMUONPCBPainter::AliMUONPCBPainter(TRootIOCtor* ioCtor) : AliMUONVPainter(ioCtor), fDetElemId(-1), fPCBIndex(-1) { } AliMUONPCBPainter::AliMUONPCBPainter() : AliMUONVPainter(), fDetElemId(-1), fPCBIndex(-1) { } AliMUONPCBPainter::AliMUONPCBPainter(const AliMUONAttPainter& att, Int_t detElemId, Int_t pcbNumber) : AliMUONVPainter("PCB"), fDetElemId(detElemId), fPCBIndex(pcbNumber) { SetAttributes(att); AliMUONPainterHelper* h = AliMUONPainterHelper::Instance(); AliMp::PlaneType planeType = ( att.IsBendingPlane() ? AliMp::kBendingPlane : AliMp::kNonBendingPlane ); const AliMpSlat* slat = AliMUONPainterHelper::Instance()->GetSlat(fDetElemId,planeType); SetID(detElemId,pcbNumber); SetName(h->PCBName(pcbNumber)); SetPathName(h->PCBPathName(detElemId,pcbNumber)); AliMpPCB* pcb = slat->GetPCB(fPCBIndex); AliMUONContour* contour = h->GetContour(ContourName()); TObjArray contourArray; for ( Int_t imp = 0 ; imp < pcb->GetSize(); ++imp ) { AliMpMotifPosition* mp = pcb->GetMotifPosition(imp); AliMUONVPainter* painter = new AliMUONManuPainter(Attributes(),fDetElemId,mp->GetID()); Add(painter); if (!contour) { contourArray.Add(painter->Contour()); } } Double_t x,y,z;
; if (!contour) { contour = h->MergeContours(contourArray,ContourName()); } SetContour(contour); } AliMUONPCBPainter::~AliMUONPCBPainter() { } AliMUONPCBPainter::AliMUONPCBPainter(const AliMUONPCBPainter& rhs) : AliMUONVPainter(rhs), fDetElemId(-1), fPCBIndex(-1) { rhs.Copy(*this); } AliMUONPCBPainter& AliMUONPCBPainter::operator=(const AliMUONPCBPainter& rhs) { if ( this != &rhs ) { rhs.Copy(*this); } return *this; } void AliMUONPCBPainter::ComputeDataRange(const AliMUONVTrackerData& data, Int_t dataIndex, Double_t& dataMin, Double_t& dataMax) const { dataMin = dataMax = data.PCB(fDetElemId, fPCBIndex,dataIndex); } void AliMUONPCBPainter::Copy(TObject& object) const { AliMUONVPainter::Copy((AliMUONVPainter&)(object)); ((AliMUONPCBPainter&)(object)).fDetElemId = fDetElemId; ((AliMUONPCBPainter&)(object)).fPCBIndex = fPCBIndex; } TString AliMUONPCBPainter::Describe(const AliMUONVTrackerData& data, Int_t dataIndex, Double_t, Double_t) { if (!data.HasPCB(fDetElemId,fPCBIndex)) return ""; Double_t value = data.PCB(fDetElemId,fPCBIndex,dataIndex); return AliMUONPainterHelper::Instance()->FormatValue(data.DimensionName(dataIndex).Data(),value); } Bool_t AliMUONPCBPainter::IsIncluded() const { return ( InteractiveReadOutConfig()->PCB(fDetElemId,fPCBIndex) > 0 ); } void AliMUONPCBPainter::PaintArea(const AliMUONVTrackerData& data, Int_t dataIndex, Double_t min, Double_t max) { if (!data.HasPCB(fDetElemId,fPCBIndex)) return; Double_t value = data.PCB(fDetElemId,fPCBIndex,dataIndex); if ( value >= AliMUONVCalibParam::InvalidFloatValue() ) return; Int_t color = AliMUONPainterHelper::Instance()->ColorFromValue(value,min,max); PaintArea(color); }
h->Local2Global(fDetElemId, pcb->X()-slat->GetPositionX(), pcb->Y()-slat->GetPositionY(), 0.0, x,y,z)
call_expression
[ { "content": "class AliMpPCB;\n\n\n", "file_path": "MUON/MUONmpgraphics/AliMpPCBPainter.h", "rank": 0, "score": 278175.9464289656 }, { "content": "class AliMpSlat;\n\n\n", "file_path": "MUON/MUONmpgraphics/AliMpSlatPainter.h", "rank": 1, "score": 278174.1546947528 }, { "c...