mirror of
https://github.com/OpenSpace/OpenSpace.git
synced 2026-01-14 16:01:30 -06:00
394 lines
14 KiB
C++
394 lines
14 KiB
C++
/*****************************************************************************************
|
|
* *
|
|
* OpenSpace *
|
|
* *
|
|
* Copyright (c) 2014-2019 *
|
|
* *
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy of this *
|
|
* software and associated documentation files (the "Software"), to deal in the Software *
|
|
* without restriction, including without limitation the rights to use, copy, modify, *
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software, and to *
|
|
* permit persons to whom the Software is furnished to do so, subject to the following *
|
|
* conditions: *
|
|
* *
|
|
* The above copyright notice and this permission notice shall be included in all copies *
|
|
* or substantial portions of the Software. *
|
|
* *
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, *
|
|
* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A *
|
|
* PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT *
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF *
|
|
* CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE *
|
|
* OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. *
|
|
****************************************************************************************/
|
|
|
|
#include <modules/base/rendering/suntexturemanager.h>
|
|
|
|
#include <openspace/util/timemanager.h>
|
|
#include <openspace/engine/globals.h>
|
|
#include <modules/fitsfilereader/include/fitsfilereader.h>
|
|
#include <openspace/util/httprequest.h>
|
|
#include <modules/sync/syncs/httpsynchronization.h>
|
|
#include <ghoul/filesystem/filesystem.h>
|
|
#include <ghoul/logging/logmanager.h>
|
|
#include <cctype>
|
|
#include <modules/base/basemodule.h>
|
|
|
|
namespace
|
|
{
|
|
constexpr const char *_loggerCat = "SunTextureManager";
|
|
} // namespace
|
|
|
|
namespace openspace
|
|
{
|
|
|
|
SunTextureManager::SunTextureManager()
|
|
{
|
|
_syncDir = "../../../../../sync/magnetograms/"; //mac
|
|
//_syncDir = absPath("../../../sync/magnetograms/"); //pc;
|
|
}
|
|
void SunTextureManager::update(std::unique_ptr<ghoul::opengl::Texture> &texture)
|
|
{
|
|
std::string currentTime = getOpenSpaceDateTime();
|
|
|
|
if (_textureToUpload.empty() && currentTime != _activeTextureDate && (_textureListGPU.find(currentTime) != _textureListGPU.end()))
|
|
{
|
|
_textureToUpload = currentTime;
|
|
}
|
|
if ((global::timeManager.deltaTime() * _direction) < 0)
|
|
{
|
|
_textureToUpload = "";
|
|
}
|
|
|
|
_direction = global::timeManager.deltaTime();
|
|
|
|
switch (_stage)
|
|
{
|
|
//This stage just checks what the next image applied should be,
|
|
case 0:
|
|
{
|
|
_current = getOpenSpaceDateTime();
|
|
|
|
if (!_textureToUpload.empty())
|
|
{
|
|
_stage = 3;
|
|
break;
|
|
}
|
|
if (_counter % 150 == 0 && !_working && !_dldthread.joinable())
|
|
{
|
|
_dldthread = std::thread([=] { getNextTexture(_current, 1.0f, &_next); });
|
|
}
|
|
if (!_working && _dldthread.joinable())
|
|
{
|
|
_dldthread.join();
|
|
if (_next != "Not found!")
|
|
{
|
|
if (std::find(_textureListDisk.begin(), _textureListDisk.end(), _next) == _textureListDisk.end())
|
|
{
|
|
// We didn't find it on disk, proceed to download
|
|
_stage = 1;
|
|
}
|
|
else
|
|
{
|
|
if (_textureListGPU.find("20" + parseMagnetogramDate(_next).substr(0, 10)) == _textureListGPU.end())
|
|
{
|
|
// Found on disk but not on GPU, proceed to upload to GPU
|
|
_stage = 2;
|
|
}
|
|
else
|
|
{
|
|
// Found on disk, and on the GPU, all we wanted, all week was to swap the texture
|
|
_stage = 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
//LERROR("in case 1");
|
|
if (!_working && !_dldthread.joinable())
|
|
{
|
|
_dldthread = std::thread([=] { downloadTexture(_next); });
|
|
}
|
|
|
|
if (!_working && _dldthread.joinable())
|
|
{
|
|
_dldthread.join();
|
|
_textureListDisk.push_back(_next);
|
|
_stage = 2;
|
|
}
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
|
|
if (!_working && !_dldthread.joinable())
|
|
{
|
|
_dldthread = std::thread([=] { processTextureFromName(_next, &_fitsImageToUpload, &_dateIDToUpload); });
|
|
}
|
|
|
|
if (!_working && _dldthread.joinable())
|
|
{
|
|
_dldthread.join();
|
|
//LERROR(std::to_string(_textureListGPU.size()));
|
|
uploadTexture(_fitsImageToUpload, _dateIDToUpload);
|
|
_fitsImageToUpload.clear();
|
|
_dateIDToUpload.clear();
|
|
_stage = 3;
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
//LERROR("in case 3");
|
|
if (((_textureListGPU.find(_textureToUpload) != _textureListGPU.end())))
|
|
{
|
|
LERROR("changing to texture " + _textureToUpload);
|
|
_textureListGPU[_activeTextureDate] = std::move(texture);
|
|
texture = std::move(_textureListGPU[_textureToUpload]);
|
|
_activeTextureDate = _textureToUpload;
|
|
_textureToUpload = "";
|
|
}
|
|
_stage = 0;
|
|
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
_counter++;
|
|
}
|
|
|
|
void SunTextureManager::startDownloadTexture(std::string textureId)
|
|
{
|
|
std::string url = "http://localhost:3000/get/" + textureId;
|
|
std::string destinationpath = absPath(_syncDir + textureId);
|
|
AsyncHttpFileDownload ashd = AsyncHttpFileDownload(url, absPath(destinationpath), HttpFileDownload::Overwrite::Yes);
|
|
HttpRequest::RequestOptions opt = {};
|
|
opt.requestTimeoutSeconds = 0;
|
|
ashd.start(opt);
|
|
ashd.wait();
|
|
//LERROR("Texture " + textureId + " downloaded to disk to " + destinationpath);
|
|
}
|
|
|
|
// The same as startDownloadTexture, but uses lock_guard and flags _working
|
|
void SunTextureManager::downloadTexture(std::string textureId)
|
|
{
|
|
_working = true;
|
|
std::lock_guard<std::mutex> guard(_GPUListBlock);
|
|
std::string url = "http://localhost:3000/get/" + textureId;
|
|
std::string destinationpath = absPath(_syncDir + textureId);
|
|
AsyncHttpFileDownload ashd = AsyncHttpFileDownload(url, destinationpath, HttpFileDownload::Overwrite::Yes);
|
|
HttpRequest::RequestOptions opt = {};
|
|
opt.requestTimeoutSeconds = 0;
|
|
ashd.start(opt);
|
|
ashd.wait();
|
|
//LERROR("Texture " + textureId + " downloaded to disk to " + destinationpath);
|
|
_working = false;
|
|
}
|
|
|
|
std::string SunTextureManager::checkNextTextureId(std::string current, float dir)
|
|
{
|
|
SyncHttpMemoryDownload mmryDld = SyncHttpMemoryDownload("http://localhost:3000/getmenextfitsimage/" + current + "/" + std::to_string(dir));
|
|
HttpRequest::RequestOptions opt = {};
|
|
opt.requestTimeoutSeconds = 0;
|
|
mmryDld.download(opt);
|
|
std::string s;
|
|
std::transform(mmryDld.downloadedData().begin(), mmryDld.downloadedData().end(), std::back_inserter(s),
|
|
[](char c) {
|
|
return c;
|
|
});
|
|
return s;
|
|
}
|
|
|
|
void SunTextureManager::getNextTexture(std::string current, float dir, std::string *toReturn)
|
|
{
|
|
_working = true;
|
|
std::lock_guard<std::mutex> guard(_GPUListBlock);
|
|
std::string url = "http://localhost:3000/getmenextfitsimage/" + current + "/" + std::to_string(dir);
|
|
AsyncHttpMemoryDownload ashd = AsyncHttpMemoryDownload(url);
|
|
HttpRequest::RequestOptions opt = {};
|
|
opt.requestTimeoutSeconds = 0;
|
|
ashd.start(opt);
|
|
ashd.wait();
|
|
std::string s;
|
|
std::transform(ashd.downloadedData().begin(), ashd.downloadedData().end(), std::back_inserter(s),
|
|
[](char c) {
|
|
return c;
|
|
});
|
|
*toReturn = std::move(s);
|
|
//LERROR("Texture mrzqs190511t1514c2217_226.fits.gz downloaded to disk");
|
|
_working = false;
|
|
}
|
|
|
|
void SunTextureManager::startUploadTextures()
|
|
{
|
|
|
|
checkFilesInDirectory();
|
|
|
|
uploadTexturesFromList(_textureListDisk);
|
|
}
|
|
|
|
// Scans directory and append all FILENAMES to the _textureListDisk member vector
|
|
void SunTextureManager::checkFilesInDirectory()
|
|
{
|
|
// Creating a deep copy of the filevector, so we can do whatever we want with it
|
|
std::vector<std::string> temp = ghoul::filesystem::Directory(_syncDir).readFiles();
|
|
_textureListDisk.clear();
|
|
std::copy(temp.begin(), temp.end(), std::back_inserter(_textureListDisk));
|
|
// To match both Mac and PC
|
|
std::transform(begin(_textureListDisk), end(_textureListDisk), begin(_textureListDisk), [](std::string s) -> std::string { if (s.find("\\") != std::string::npos) return s.substr(s.rfind("\\") + 1); else return s.substr(s.rfind("/") + 1); });
|
|
|
|
//remove annoying mac file. might want to use a different strategy here
|
|
_textureListDisk.erase(std::remove(_textureListDisk.begin(), _textureListDisk.end(), ".DS_STORE"), _textureListDisk.end());
|
|
}
|
|
|
|
void SunTextureManager::uploadTexture(std::vector<float> imagedata, std::string id)
|
|
{
|
|
//LERROR("laddar upp texture till GPU med id: " + id);
|
|
auto textureFits = std::make_unique<ghoul::opengl::Texture>(std::move(imagedata.data()), glm::vec3(360, 180, 1), ghoul::opengl::Texture::Format::Red, GL_R32F, GL_FLOAT);
|
|
textureFits->setDataOwnership(ghoul::opengl::Texture::TakeOwnership::No);
|
|
textureFits->uploadTexture();
|
|
//textureFits->setName(id);
|
|
//textureFits->setFilter(ghoul::opengl::Texture::FilterMode::Nearest);
|
|
_textureQueueGPU.push(id);
|
|
_textureListGPU[id] = std::move(textureFits);
|
|
trimGPUList();
|
|
}
|
|
|
|
void SunTextureManager::processTextureFromName(std::string filename, std::vector<float> *imagedata, std::string *id)
|
|
{
|
|
_working = true;
|
|
std::lock_guard<std::mutex> guard(_GPUListBlock);
|
|
FitsFileReader fitsFileReader(false);
|
|
|
|
const auto tempBild = fitsFileReader.readImageFloat(_syncDir + filename);
|
|
|
|
*id = parseMagnetogramDate(*fitsFileReader.readHeaderValueString("DATE"));
|
|
|
|
const float minvalue = *fitsFileReader.readHeaderValueFloat("IMGMIN01");
|
|
const float maxvalue = *fitsFileReader.readHeaderValueFloat("IMGMAX01");
|
|
const int long0 = *fitsFileReader.readHeaderValueFloat("LONG0");
|
|
//const float stdvalue = *fitsFileReader.readHeaderValueFloat("IMGRMS01");
|
|
|
|
for (float c : tempBild->contents)
|
|
{
|
|
imagedata->push_back((c - minvalue) / (maxvalue - minvalue)); // Normalized
|
|
//imagedata->push_back((c + stdvalue) / stdvalue); // Standard Deviation
|
|
}
|
|
for (int i = 0; i < 180; i++)
|
|
{
|
|
std::rotate(imagedata->begin() + (i * 360), imagedata->begin() + ((i * 360) + (360 - long0)), imagedata->begin() + (i * 360) + 359);
|
|
}
|
|
|
|
_working = false;
|
|
}
|
|
|
|
void SunTextureManager::uploadTexturesFromList(std::vector<std::string> &filelist)
|
|
{
|
|
|
|
for (const auto &entry : filelist)
|
|
{
|
|
uploadTextureFromName(entry);
|
|
}
|
|
//LERROR("Laddat upp texturerna till GPU:n");
|
|
}
|
|
|
|
void SunTextureManager::uploadTextureFromName(std::string filename)
|
|
{
|
|
FitsFileReader fitsFileReader(false);
|
|
const auto tempBild = fitsFileReader.readImageFloat(_syncDir + filename);
|
|
|
|
std::string dateID = parseMagnetogramDate(*fitsFileReader.readHeaderValueString("DATE"));
|
|
|
|
const float minvalue = *fitsFileReader.readHeaderValueFloat("IMGMIN01");
|
|
const float maxvalue = *fitsFileReader.readHeaderValueFloat("IMGMAX01");
|
|
const int long0 = *fitsFileReader.readHeaderValueFloat("LONG0");
|
|
const float stdvalue = *fitsFileReader.readHeaderValueFloat("IMGRMS01");
|
|
std::vector<float> fitsImage;
|
|
for (float c : tempBild->contents)
|
|
{
|
|
//fitsImage.push_back((c - minvalue) / (maxvalue - minvalue)); // Normalized
|
|
fitsImage.push_back((c + stdvalue) / stdvalue); // Standard Deviation
|
|
}
|
|
for (int i = 0; i < 180; i++)
|
|
{
|
|
std::rotate(fitsImage.begin() + (i * 360), fitsImage.begin() + ((i * 360) + (360 - long0)), fitsImage.begin() + (i * 360) + 359);
|
|
}
|
|
|
|
//LERROR("laddar upp texture till GPU med id: " + dateID + "från filväg " + absPath(_syncDir + filename));
|
|
auto textureFits = std::make_unique<ghoul::opengl::Texture>(std::move(fitsImage.data()), glm::vec3(360, 180, 1), ghoul::opengl::Texture::Format::Red, GL_R32F, GL_FLOAT);
|
|
|
|
textureFits->setDataOwnership(ghoul::opengl::Texture::TakeOwnership::No);
|
|
textureFits->uploadTexture();
|
|
textureFits->setName(dateID);
|
|
_textureQueueGPU.push(dateID);
|
|
_textureListGPU[dateID] = std::move(textureFits);
|
|
trimGPUList();
|
|
}
|
|
|
|
std::string SunTextureManager::getOpenSpaceDateTime()
|
|
{
|
|
std::string datetime = global::timeManager.time().ISO8601();
|
|
datetime.erase(4, 1);
|
|
datetime.erase(6, 1);
|
|
datetime.erase(8, 1);
|
|
datetime.erase(10, 1);
|
|
datetime.erase(12);
|
|
return datetime;
|
|
}
|
|
|
|
std::string SunTextureManager::parseMagnetogramDate(std::string name)
|
|
{
|
|
|
|
std::string dateID;
|
|
int magicalCounter = 0;
|
|
for (char c : name)
|
|
{
|
|
if (std::isdigit(c))
|
|
{
|
|
if (magicalCounter >= 0 && magicalCounter < 12)
|
|
{
|
|
dateID += c;
|
|
}
|
|
magicalCounter++;
|
|
}
|
|
}
|
|
return dateID;
|
|
}
|
|
|
|
bool SunTextureManager::checkServerAliveness()
|
|
{
|
|
SyncHttpMemoryDownload mmryDld = SyncHttpMemoryDownload("http://localhost:3000/");
|
|
HttpRequest::RequestOptions opt = {};
|
|
opt.requestTimeoutSeconds = 0;
|
|
mmryDld.download(opt);
|
|
std::string s;
|
|
std::transform(mmryDld.downloadedData().begin(), mmryDld.downloadedData().end(), std::back_inserter(s),
|
|
[](char c) {
|
|
return c;
|
|
});
|
|
return s == "You are at ROOT";
|
|
}
|
|
|
|
void SunTextureManager::trimGPUList()
|
|
{
|
|
if (_textureQueueGPU.size() > _maxTexturesOnGPU)
|
|
{
|
|
|
|
std::string dateId = _textureQueueGPU.front();
|
|
_textureQueueGPU.pop();
|
|
//LERROR("popped dateId : " + dateId);
|
|
_textureListGPU.at(dateId).release();
|
|
//BaseModule::TextureManager.release(_textureListGPU.at(dateId).get());
|
|
_textureListGPU.erase(dateId);
|
|
}
|
|
}
|
|
|
|
} // namespace openspace
|