Hx711::Hx711(uint8_t pin_dout, uint8_t pin_slk) :
_pin_dout(pin_dout), _pin_slk(pin_slk)
{
pinMode(_pin_slk, OUTPUT);
pinMode(_pin_dout, INPUT);
digitalWrite(_pin_slk, HIGH);
delayMicroseconds(100);
digitalWrite(_pin_slk, LOW);
averageValue();
this->setOffset(averageValue());
this->setScale();
}
void mitk::RegionGrowingTool::GetNeighborhoodAverage(itk::Image<TPixel, imageDimension>* itkImage, itk::Index<imageDimension> index, ScalarType* result, unsigned int neighborhood)
{
// maybe assert that image dimension is only 2 or 3?
int neighborhoodInt = (int) neighborhood;
TPixel averageValue(0);
unsigned int numberOfPixels = (2*neighborhood + 1) * (2*neighborhood + 1);
if (imageDimension == 3)
{
numberOfPixels *= (2*neighborhood + 1);
}
MITK_DEBUG << "Getting neighborhood of " << numberOfPixels << " pixels around " << index;
itk::Index<imageDimension> currentIndex;
for (int i = (0 - neighborhoodInt); i <= neighborhoodInt; ++i)
{
currentIndex[0] = index[0] + i;
for (int j = (0 - neighborhoodInt); j <= neighborhoodInt; ++j)
{
currentIndex[1] = index[1] + j;
if (imageDimension == 3)
{
for (int k = (0 - neighborhoodInt); k <= neighborhoodInt; ++k)
{
currentIndex[2] = index[2] + k;
if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
{
averageValue += itkImage->GetPixel(currentIndex);
}
else
{
numberOfPixels -= 1;
}
}
}
else
{
if (itkImage->GetLargestPossibleRegion().IsInside(currentIndex))
{
averageValue += itkImage->GetPixel(currentIndex);
}
else
{
numberOfPixels -= 1;
}
}
}
}
*result = (ScalarType) averageValue;
*result /= numberOfPixels;
}
QVector<double> CrustalModel::calculate(const QVector<double> &freq) const
{
QVector<double> amp(freq.size());
// Slowness (inverse of the crustal velocity
QVector<double> slowness(m_velocity.size());
for (int i = 0; i < slowness.size(); ++i) {
slowness[i] = 1./m_velocity.at(i);
}
// average slowness over a depth range (1/velocity)
QVector<double> avgSlow(freq.size(), slowness.first());
// Frequency dependent depth
QVector<double> depth_f(freq.size(), 0.);
for (int i = 0; i < freq.size(); ++i) {
double error = 0;
int count = 0;
do {
++count;
depth_f[i] = 1. / (4 * freq.at(i) * avgSlow.at(i));
const double oldValue = avgSlow.at(i);
avgSlow[i] = averageValue(m_thickness, slowness, depth_f.at(i));
error = fabs((oldValue - avgSlow.at(i)) / avgSlow.at(i));
} while (error > 0.005 && count < 10);
}
for (int i = 0; i < freq.size(); ++i) {
// Average density for the depth range
const double avgDensity = averageValue(m_thickness, m_density, depth_f.at(i));
amp[i] = sqrt((m_velocity.at(i) * m_density.at(i)) / (avgDensity / avgSlow.at(i)));
}
return amp;
}
void Benchmark::test(const int algorithm, vector<deque<int>> &out, int n, int m)
{
out.clear(); out.resize(queries.size());
size_t memoryUsed;
int preparingTime;
vector<int> searchingTimes(numberOfTestingCycles);
ms start, end;
string algorithmName = "Unkown";
switch (algorithm)
{
case 0:
{
algorithmName = "MinHash (UM)";
start = getTime();
memoryUsed = getCurrentMemoryUsed();
MinHashUM index(text, n, m);
index.prepare();
memoryUsed = getCurrentMemoryUsed() - memoryUsed;
end = getTime();
preparingTime = (end - start).count();
for (int i = 0; i < numberOfTestingCycles; i++)
{
out.clear(); out.resize(queries.size());
start = getTime();
index.query(queries, out);
end = getTime();
searchingTimes[i] = (end - start).count();
}
break;
}
case 1:
{
algorithmName = "MinHash (VP)";
start = getTime();
memoryUsed = getCurrentMemoryUsed();
MinHashVP index(text, n, m);
index.prepare();
memoryUsed = getCurrentMemoryUsed() - memoryUsed;
end = getTime();
preparingTime = (end - start).count();
for (int i = 0; i < numberOfTestingCycles; i++)
{
out.clear(); out.resize(queries.size());
start = getTime();
index.query(queries, out);
end = getTime();
searchingTimes[i] = (end - start).count();
}
break;
}
case 2:
{
algorithmName = "HashTable";
start = getTime();
memoryUsed = getCurrentMemoryUsed();
HashTable index(text);
index.prepare();
memoryUsed = getCurrentMemoryUsed() - memoryUsed;
end = getTime();
preparingTime = (end - start).count();
for (int i = 0; i < numberOfTestingCycles; i++)
{
out.clear(); out.resize(queries.size());
start = getTime();
index.query(queries, out);
end = getTime();
searchingTimes[i] = (end - start).count();
}
break;
}
case 3:
{
algorithmName = "FMIndex";
start = getTime();
memoryUsed = getCurrentMemoryUsed();
FMIndex index(text);
index.prepare();
memoryUsed = getCurrentMemoryUsed() - memoryUsed;
end = getTime();
preparingTime = (end - start).count();
for (int i = 0; i < numberOfTestingCycles; i++)
{
out.clear(); out.resize(queries.size());
start = getTime();
index.query(queries, out);
end = getTime();
searchingTimes[i] = (end - start).count();
}
break;
}
default:
cout << "Unkown algorithm." << endl;
return;
}
printTestResults(algorithmName, pair<int, int>(n, m),
vector<int>({ numberOfElements(out),
(int)(memoryUsed / 1024 / 1024),
preparingTime,
averageValue(searchingTimes) })
);
}
float Hx711::getGram()
{
long val = (averageValue() - _offset);
return (float) val / _scale;
}
void mitk::RegionGrowingTool::OnMousePressedOutside(StateMachineAction*, InteractionEvent* interactionEvent)
{
mitk::InteractionPositionEvent* positionEvent = dynamic_cast<mitk::InteractionPositionEvent*>(interactionEvent);
if (positionEvent)
{
// Get geometry and indices
mitk::BaseGeometry::Pointer workingSliceGeometry;
workingSliceGeometry = m_WorkingSlice->GetTimeGeometry()->GetGeometryForTimeStep(m_LastEventSender->GetTimeStep());
itk::Index<2> indexInWorkingSlice2D;
indexInWorkingSlice2D[0] = m_SeedPoint[0];
indexInWorkingSlice2D[1] = m_SeedPoint[1];
mitk::BaseGeometry::Pointer referenceSliceGeometry;
referenceSliceGeometry = m_ReferenceSlice->GetTimeGeometry()->GetGeometryForTimeStep(m_LastEventSender->GetTimeStep());
itk::Index<3> indexInReferenceSlice;
itk::Index<2> indexInReferenceSlice2D;
referenceSliceGeometry->WorldToIndex(positionEvent->GetPositionInWorld(), indexInReferenceSlice);
indexInReferenceSlice2D[0] = indexInReferenceSlice[0];
indexInReferenceSlice2D[1] = indexInReferenceSlice[1];
// Get seed neighborhood
ScalarType averageValue(0);
AccessFixedDimensionByItk_3(m_ReferenceSlice, GetNeighborhoodAverage, 2, indexInReferenceSlice2D, &averageValue, 1);
m_SeedValue = averageValue;
MITK_DEBUG << "Seed value is " << m_SeedValue;
// Get level window settings
LevelWindow lw(0, 500); // default window 0 to 500, can we do something smarter here?
m_ToolManager->GetReferenceData(0)->GetLevelWindow(lw); // will fill lw if levelwindow property is present, otherwise won't touch it.
ScalarType currentVisibleWindow = lw.GetWindow();
MITK_DEBUG << "Level window width is " << currentVisibleWindow;
m_InitialThresholds[0] = m_SeedValue - currentVisibleWindow / 20.0; // 20 is arbitrary (though works reasonably well), is there a better alternative (maybe option in preferences)?
m_InitialThresholds[1] = m_SeedValue + currentVisibleWindow / 20.0;
m_Thresholds[0] = m_InitialThresholds[0];
m_Thresholds[1] = m_InitialThresholds[1];
// Perform region growing
mitk::Image::Pointer resultImage = mitk::Image::New();
AccessFixedDimensionByItk_3(m_ReferenceSlice, StartRegionGrowing, 2, indexInWorkingSlice2D, m_Thresholds, resultImage);
resultImage->SetGeometry(workingSliceGeometry);
// Extract contour
if (resultImage.IsNotNull() && m_ConnectedComponentValue >= 1)
{
mitk::ImageToContourModelFilter::Pointer contourExtractor = mitk::ImageToContourModelFilter::New();
contourExtractor->SetInput(resultImage);
contourExtractor->SetContourValue(m_ConnectedComponentValue - 0.5);
contourExtractor->Update();
ContourModel::Pointer resultContour = ContourModel::New();
resultContour = contourExtractor->GetOutput();
// Show contour
if (resultContour.IsNotNull())
{
ContourModel::Pointer resultContourWorld = FeedbackContourTool::BackProjectContourFrom2DSlice(workingSliceGeometry, FeedbackContourTool::ProjectContourTo2DSlice(m_WorkingSlice, resultContour));
FeedbackContourTool::SetFeedbackContour(resultContourWorld);
FeedbackContourTool::SetFeedbackContourVisible(true);
mitk::RenderingManager::GetInstance()->RequestUpdate(m_LastEventSender->GetRenderWindow());
}
}
}
}
