// SkipString //------------------------------------------------------------------------------ void BFFIterator::SkipString( char quote ) { // start on open char (first ++ will handle this) ASSERT( *m_Pos == quote ); while ( !IsAtEnd() ) { m_Pos++; const char c = *m_Pos; // escape char? if ( c == '^' ) { m_Pos++; // extra increment to skip escaped char continue; } // closing quote? if ( *m_Pos == quote ) { return; } } }
// ParseExactString //------------------------------------------------------------------------------ bool BFFIterator::ParseExactString( const char * string ) { const char * const originalPos = m_Pos; const char * stringPos = string; // stores pointer to the next character to be checked for presence in our sequence while ( !IsAtEnd() && ( *stringPos != '\000' ) ) { if ( *m_Pos != *stringPos ) { break; } m_Pos++; stringPos++; } if ( *stringPos == '\000' ) { // we are at the end of string, that means all characters have successfuly matched return true; } else { // we are not at the end of string, that means either our sequence ended, or there is non matching character // restore our pos before returning m_Pos = originalPos; return false; } }
// SkipVariableName //------------------------------------------------------------------------------ void BFFIterator::SkipVariableName() { while ( !IsAtEnd() ) { if ( !IsAtValidVariableNameCharacter() ) { return; } // character still part of variable name (*this)++; } }
// SkipComment //------------------------------------------------------------------------------ void BFFIterator::SkipComment() { // keep going until we hit the end of a line while ( !IsAtEnd() ) { bool atLineEnd = (*m_Pos == '\n' ); (*this)++; if ( atLineEnd ) { break; } } }
// SkipWhiteSpace //------------------------------------------------------------------------------ void BFFIterator::SkipWhiteSpace() { while ( !IsAtEnd() ) { if ( IsAtWhitespace() ) { (*this)++; } else { break; } } }
// ParseToNext //------------------------------------------------------------------------------ bool BFFIterator::ParseToNext( char c ) { if ( IsAtEnd() ) { return false; } char prev = '\000'; do { (*this)++; if ( *m_Pos == c ) { if ( prev != '^' ) { return true; } } prev = *m_Pos; } while ( !IsAtEnd() ); return false; }
// SkipDirectiveName //------------------------------------------------------------------------------ void BFFIterator::SkipDirectiveName() { while ( !IsAtEnd() ) { if ( IsAtValidDirectiveNameCharacter() ) { // character still part of directive name (*this)++; continue; } break; // hit the end of a non-valid character for a directive name } }
// SkipFunctionName //------------------------------------------------------------------------------ void BFFIterator::SkipFunctionName() { while ( !IsAtEnd() ) { if ( IsAtValidFunctionNameCharacter() ) { // character still part of variable name (*this)++; continue; } break; // hit the end of a non-valid character for a function name } }
// Determines whether move conflicts with other pegs in end slots bool Player::PossibleMove(int i, int adv) const { if ((peg[i] + adv) > endPosition + (NUM_PEGS - 1)) return false; // Can't go past the four end slots for (int p = 0; p < NUM_PEGS; p++) { if (i == p) continue; // Doesn't compare with itself if (IsAtEnd(p) && peg[p] == (peg[i] + adv)) // Prevents peg from landing on space occupied by another peg in end slots return false; } return true; }
cv::Mat LogReaderImageSource::GetNextImage() { cv::Mat imageDist; if (IsAtEnd()) { return imageDist; } logReader->getNext(); cv::Mat3b img(h, w, (cv::Vec3b *) logReader->rgb); cv::cvtColor(img, imageDist, CV_RGB2GRAY); index++; return img; }
cv::Mat FileListImageSource::GetNextImage() { cv::Mat imageDist; if (IsAtEnd()) { return imageDist; } imageDist = cv::imread(files[index], CV_LOAD_IMAGE_GRAYSCALE); if (imageDist.rows != h || imageDist.cols != w) { if (imageDist.rows * imageDist.cols == 0) { printf("failed to load image %s! skipping.\n", files[index].c_str()); } else { printf("image %s has wrong dimensions - expecting %d x %d, found %d x %d. Skipping.\n", files[index].c_str(), w, h, imageDist.cols, imageDist.rows); } } index++; return imageDist; }
// ParseToMatchingBrace //------------------------------------------------------------------------------ bool BFFIterator::ParseToMatchingBrace( char openBrace, char closeBrace ) { ASSERT( *m_Pos == openBrace ); do { m_Pos++; SkipWhiteSpaceAndComments(); // hit a nested brace? if ( *m_Pos == openBrace ) { if ( ParseToMatchingBrace( openBrace, closeBrace ) == false ) { return false; } continue; } // hit a string? if ( ( *m_Pos == '\'' ) || ( *m_Pos == '"' ) ) { SkipString( *m_Pos ); } // hit the close brace? if ( *m_Pos == closeBrace ) { return true; } // a regular charater.... keep searching } while ( !IsAtEnd() ); return false; }
void mitk::CLUtil::itkInterpolateCheckerboardPrediction(TImageType * checkerboard_prediction, Image::Pointer &checkerboard_mask, mitk::Image::Pointer & outimage) { typename TImageType::Pointer itk_checkerboard_mask; mitk::CastToItkImage(checkerboard_mask,itk_checkerboard_mask); typename TImageType::Pointer itk_outimage = TImageType::New(); itk_outimage->SetRegions(checkerboard_prediction->GetLargestPossibleRegion()); itk_outimage->SetDirection(checkerboard_prediction->GetDirection()); itk_outimage->SetOrigin(checkerboard_prediction->GetOrigin()); itk_outimage->SetSpacing(checkerboard_prediction->GetSpacing()); itk_outimage->Allocate(); itk_outimage->FillBuffer(0); //typedef typename itk::ShapedNeighborhoodIterator<TImageType>::SizeType SizeType; typedef itk::Size<3> SizeType; SizeType size; size.Fill(1); itk::ShapedNeighborhoodIterator<TImageType> iit(size,checkerboard_prediction,checkerboard_prediction->GetLargestPossibleRegion()); itk::ShapedNeighborhoodIterator<TImageType> mit(size,itk_checkerboard_mask,itk_checkerboard_mask->GetLargestPossibleRegion()); itk::ImageRegionIterator<TImageType> oit(itk_outimage,itk_outimage->GetLargestPossibleRegion()); typedef typename itk::ShapedNeighborhoodIterator<TImageType>::OffsetType OffsetType; OffsetType offset; offset.Fill(0); offset[0] = 1; // {1,0,0} iit.ActivateOffset(offset); mit.ActivateOffset(offset); offset[0] = -1; // {-1,0,0} iit.ActivateOffset(offset); mit.ActivateOffset(offset); offset[0] = 0; offset[1] = 1; //{0,1,0} iit.ActivateOffset(offset); mit.ActivateOffset(offset); offset[1] = -1; //{0,-1,0} iit.ActivateOffset(offset); mit.ActivateOffset(offset); // iit.ActivateOffset({{0,0,1}}); // iit.ActivateOffset({{0,0,-1}}); // mit.ActivateOffset({{0,0,1}}); // mit.ActivateOffset({{0,0,-1}}); while(!iit.IsAtEnd()) { if(mit.GetCenterPixel() == 0) { typename TImageType::PixelType mean = 0; for (auto i = iit.Begin(); ! i.IsAtEnd(); i++) { mean += i.Get(); } //std::sort(list.begin(),list.end(),[](const typename TImageType::PixelType x,const typename TImageType::PixelType y){return x<=y;}); oit.Set((mean+0.5)/6.0); } else { oit.Set(iit.GetCenterPixel()); } ++iit; ++mit; ++oit; } mitk::CastToMitkImage(itk_outimage,outimage); }