size_t PolyRegions::read(const std::string& location) {
fs::path directory;
try {
directory = SC_FS_PATH(location);
}
catch ( ... ) {
SEISCOMP_ERROR("Invalid path '%s'", location.c_str());
return 0;
}
if ( !fs::exists(directory) )
return regionCount();
fs::directory_iterator end_itr;
std::vector<std::string> files;
try {
for ( fs::directory_iterator itr(directory); itr != end_itr; ++itr ) {
if ( fs::is_directory(*itr) )
continue;
if ( boost::regex_match(SC_FS_IT_LEAF(itr), boost::regex(".*\\.(?:fep)")) )
files.push_back(SC_FS_IT_STR(itr));
}
}
catch ( const std::exception &ex ) {
SEISCOMP_ERROR("Reading regions: %s", ex.what());
return regionCount();
}
std::sort(files.begin(), files.end());
for ( size_t i = 0; i < files.size(); ++i ) {
if ( !readFepBoundaries(files[i]) )
SEISCOMP_ERROR("Error reading file: %s", files[i].c_str());
}
info();
// Sort the features according to their rank
std::sort(_regions.begin(), _regions.end(), compareByRank);
// store directory path the data was read from
_dataDir = directory.string();
return regionCount();
}
GeoFeature *PolyRegions::findRegion(double lat, double lon) const {
while ( lon < -180 ) lon += 180;
while ( lon > 180 ) lon -= 180;
for ( size_t i = 0; i < regionCount(); ++i ) {
if ( region(i)->contains(Vertex(lat, lon)) )
return region(i);
}
return NULL;
}
QString VESPERSEXAFSScanConfiguration::headerText() const
{
QString header("Configuration of the Scan\n\n");
header.append("Scanned Edge:\t" + edge() + "\n");
header.append(fluorescenceHeaderString(fluorescenceDetector()));
header.append(incomingChoiceHeaderString(incomingChoice()));
header.append(transmissionChoiceHeaderString(transmissionChoice()));
header.append(QString("Automatically moved to a specific location (used when setting up the workflow)?\t%1").arg(goToPosition() ? "Yes\n" : "No\n\n"));
if (goToPosition()){
header.append(QString("Horizontal Position:\t%1 mm\n").arg(x()));
header.append(QString("Vertical Position:\t%1 mm\n\n").arg(y()));
}
header.append(regionOfInterestHeaderString(roiList()));
header.append("\n");
header.append("Regions Scanned\n");
for (int i = 0; i < regionCount(); i++){
if (exafsRegions()->type(i) == AMEXAFSRegion::kSpace && useFixedTime())
header.append(QString("Start: %1 eV\tDelta: %2 k\tEnd: %3 k\tTime: %4 s\n")
.arg(exafsRegions()->startByType(i, AMEXAFSRegion::Energy))
.arg(exafsRegions()->delta(i))
.arg(exafsRegions()->endByType(i, AMEXAFSRegion::kSpace))
.arg(regions_->time(i)));
else if (exafsRegions()->type(i) == AMEXAFSRegion::kSpace && !useFixedTime())
header.append(QString("Start: %1 eV\tDelta: %2 k\tEnd: %3 k\tMaximum time (used with variable integration time): %4 s\n")
.arg(exafsRegions()->startByType(i, AMEXAFSRegion::Energy))
.arg(exafsRegions()->delta(i))
.arg(exafsRegions()->endByType(i, AMEXAFSRegion::kSpace))
.arg(exafsRegions()->time(i)));
else
header.append(QString("Start: %1 eV\tDelta: %2 eV\tEnd: %3 eV\tTime: %4 s\n")
.arg(regionStart(i))
.arg(regionDelta(i))
.arg(regionEnd(i))
.arg(regionTime(i)));
}
return header;
}
void G2DRegionGraph::makeCoarserRegions(G2DRegionGraph* pFineRegions)
{
// Find every region's closest neighbor
GImage* pFineRegionMask = pFineRegions->regionMask();
GImage* pCoarseRegionMask = regionMask();
GAssert(pCoarseRegionMask->width() == pFineRegionMask->width() && pCoarseRegionMask->height() == pFineRegionMask->height()); // size mismatch
int* pBestNeighborMap = new int[pFineRegions->regionCount()];
ArrayHolder<int> hBestNeighborMap(pBestNeighborMap);
for(size_t i = 0; i < pFineRegions->regionCount(); i++)
{
struct GRegion* pRegion = pFineRegions->m_regions[i];
struct GRegionEdge* pEdge;
double d;
double dBestDiff = 1e200;
int nBestNeighbor = -1;
for(pEdge = pRegion->m_pNeighbors; pEdge; pEdge = pEdge->GetNext(i))
{
size_t j = pEdge->GetOther(i);
struct GRegion* pOtherRegion = pFineRegions->m_regions[j];
d = MeasureRegionDifference(pRegion, pOtherRegion);
if(d < dBestDiff)
{
dBestDiff = d;
nBestNeighbor = (int)j;
}
}
GAssert(nBestNeighbor != -1 || pFineRegions->regionCount() == 1); // failed to find a neighbor
pBestNeighborMap[i] = nBestNeighbor;
}
// Create a mapping to new regions numbers
int* pNewRegionMap = new int[pFineRegions->regionCount()];
ArrayHolder<int> hNewRegionMap(pNewRegionMap);
memset(pNewRegionMap, 0xff, sizeof(int) * pFineRegions->regionCount());
int nNewRegionCount = 0;
for(size_t i = 0; i < pFineRegions->regionCount(); i++)
{
size_t nNewRegion = -1;
size_t j = i;
while(pNewRegionMap[j] == -1)
{
pNewRegionMap[j] = -2;
j = pBestNeighborMap[j];
}
if(pNewRegionMap[j] == -2)
nNewRegion = nNewRegionCount++;
else
nNewRegion = pNewRegionMap[j];
j = i;
while(pNewRegionMap[j] == -2)
{
pNewRegionMap[j] = (int)nNewRegion;
j = pBestNeighborMap[j];
}
}
// Make the new regions
for(size_t i = 0; i < pFineRegions->regionCount(); i++)
{
struct GRegion* pRegion = pFineRegions->m_regions[i];
size_t j = pNewRegionMap[i];
if(regionCount() <= j)
{
GAssert(regionCount() == j); // how'd it get two behind?
addRegion();
}
struct GRegion* pCoarseRegion = m_regions[j];
pCoarseRegion->m_nSumRed += pRegion->m_nSumRed;
pCoarseRegion->m_nSumGreen += pRegion->m_nSumGreen;
pCoarseRegion->m_nSumBlue += pRegion->m_nSumBlue;
pCoarseRegion->m_nPixels += pRegion->m_nPixels;
}
for(size_t i = 0; i < pFineRegions->regionCount(); i++)
{
struct GRegion* pRegion = pFineRegions->m_regions[i];
size_t j = pNewRegionMap[i];
struct GRegionEdge* pEdge;
for(pEdge = pRegion->m_pNeighbors; pEdge; pEdge = pEdge->GetNext(i))
{
size_t k = pNewRegionMap[pEdge->GetOther(i)];
if(j != k)
makeNeighbors(j, k);
}
}
// Make the fine region mask
unsigned int nOldRegion;
int x, y;
for(y = 0; y < (int)pFineRegionMask->height(); y++)
{
for(x = 0; x < (int)pFineRegionMask->width(); x++)
{
nOldRegion = pFineRegionMask->pixel(x, y);
pCoarseRegionMask->setPixel(x, y, pNewRegionMap[nOldRegion]);
}
}
}
QString SGMXASScanConfiguration::detailedDescription() const{
double exitSlit;
double grating;
double harmonic;
for(int x = 0; x < fluxResolutionGroup_.count(); x++){
if(fluxResolutionGroup_.at(x).name() == SGMBeamline::sgm()->exitSlitGap()->name())
exitSlit = fluxResolutionGroup_.at(x).value();
if(fluxResolutionGroup_.at(x).name() == SGMBeamline::sgm()->grating()->name())
grating = fluxResolutionGroup_.at(x).value();
if(fluxResolutionGroup_.at(x).name() == SGMBeamline::sgm()->harmonic()->name())
harmonic = fluxResolutionGroup_.at(x).value();
}
return QString("XAS Scan from %1 to %2\nExit Slit: %3\nGrating: %4\nHarmonic: %5").arg(regionStart(0)).arg(regionEnd(regionCount()-1)).arg(exitSlit, 0, 'f', 1).arg(SGMBeamlineInfo::sgmInfo()->sgmGratingDescription(SGMBeamlineInfo::sgmGrating(grating))).arg(SGMBeamlineInfo::sgmInfo()->sgmHarmonicDescription(SGMBeamlineInfo::sgmHarmonic(harmonic)));
}