Exemplo n.º 1
0
// Function to filter sentences out of a stream
static inline bool parsesentence( const char*& seek, Sentence& out )
{
	std::string content;

	while ( true )
	{
		const char c = *seek++;

		switch( c )
		{
		// End of the stream
		case 0:
			seek--;

			// If there is no new sentence and the stream ended, we have to quit reading
			if ( content.empty() )
				return false; // ... indicated by false

			out = Sentence( content, SENTENCE_NORMAL );
			return true;
		// Some standard sentence.
		case '.':
			// We should not care about empty sentences
			if ( content.empty() )
				break;

			out = Sentence( content, SENTENCE_NORMAL );
			return true;
		// The guy wants to express something!
		case '!':
			if ( content.empty() )
				break;

			out = Sentence( content, SENTENCE_COMMAND );
			return true;
		// We are getting some question!
		case '?':
			if ( content.empty() )
				break;

			out = Sentence( content, SENTENCE_QUESTION );
			return true;
		}

		content += c;
	}

	return true;
}
Exemplo n.º 2
0
void VoiceEndpoint::timerEvent(QTimerEvent *event)
{
    if(m_sesTimer > 0 && event && event->timerId() == m_sesTimer) {
        killTimer(m_sesTimer);
        m_sesTimer = 0;
        switch (m_sesPhase) {
        case PhSetupRequest:
            sessionSetupResponse(ResTimeout,QUuid());
            break;
        case PhSetupComplete:
            sessionSetupResponse(ResInvalidMessage,QUuid());
            break;
        case PhAudioStarted:
            stopAudioStream(m_sessId);
            break;
        case PhAudioStopped:
            //transcriptionResponse(ResTimeout,QList<Sentence>(),QUuid()); // We should actualy reply like this but lets do...
            transcriptionResponse(ResSuccess,
                            QList<Sentence>({
                                Sentence({8,QList<Word>({{1,2,"No"},{1,3,"one"},{1,5,"dared"},{1,2,"to"},{1,5,"reply"},{1,1,"."},{1,7,"Service"},{1,7,"Timeout"}})})
                            }),
                            m_appUuid); // Example transcription - for the reference
            break;
        case PhResultReceived:
            sendDictationResults();
            sessionDestroy();
            break;
        default:
            qDebug() << "Unhandled timer event for phase" << m_sesPhase;
        }
    }
}
Exemplo n.º 3
0
int XML4NLP::SetSentencesToParagraph(const vector<string> &vecSentence, int paragraphIdx) {
  if (0 != CheckRange(paragraphIdx)) {
    return -1;
  }

  if (!document.paragraphs[paragraphIdx].sentences.empty()) {
    return -1;
  }

  Paragraph & paragraph     = document.paragraphs[paragraphIdx];
  TiXmlElement * paragraphPtr   = paragraph.paragraphPtr;
  vector<Sentence> &sentences   = paragraph.sentences;

  TiXmlText *textPtr = paragraphPtr->FirstChild()->ToText();
  if (textPtr == NULL) {
    return -1;
  } else {
    paragraphPtr->RemoveChild(textPtr);
  }

  for (int i = 0; i < vecSentence.size(); ++i) {
    TiXmlElement *sentencePtr = new TiXmlElement(TAG_SENT);
    sentencePtr->SetAttribute(TAG_ID, static_cast<int>(i));
    sentencePtr->SetAttribute(TAG_CONT, vecSentence[i].c_str());
    paragraphPtr->LinkEndChild(sentencePtr);

    sentences.push_back( Sentence() );
    sentences[sentences.size()-1].sentencePtr = sentencePtr;
  }

  return 0;
}
Exemplo n.º 4
0
Sentence Paragraph::first(){
    if(head){
	return head->data;
    }else{
	Sentence s = Sentence();
	return s;
    }
}
Exemplo n.º 5
0
int XML4NLP::InitXmlSentence(vector<Sentence> &sentences, TiXmlElement *stnsPtr)
{
  sentences.push_back( Sentence() );
  Sentence &sentence = sentences[sentences.size()-1];
  sentence.sentencePtr = stnsPtr;

  TiXmlElement *wordPtr = stnsPtr->FirstChildElement(TAG_WORD);
  if (wordPtr == NULL) return 0;  // have not done word segment

  do
  {
    if (0 != InitXmlWord(sentence.words, wordPtr)) return -1;
    wordPtr = wordPtr->NextSiblingElement(TAG_WORD);
  } while(wordPtr != NULL);

  return 0;
}
Exemplo n.º 6
0
static Bitmap read_bmp_or_throw(const FilePath& filePath){
  BinaryReader in(filePath);
  if (!in.good()){
    throw ReadBmpError(error_open_file_read(filePath));
  }

  auto bitmapFileHeader = read_struct_or_throw_bmp<BitmapFileHeader>(in);

  if (bitmapFileHeader.fileType != BITMAP_SIGNATURE){
    throw ReadBmpError(error_bitmap_signature(bitmapFileHeader.fileType));
  }

  auto bitmapInfoHeader = read_struct_or_throw_bmp<BitmapInfoHeader>(in);

  if (invalid_header_length(bitmapInfoHeader.headerLen)){
    throw ReadBmpError(error_truncated_bmp_header(bitmapInfoHeader.headerLen));
  }

  if (bitmapInfoHeader.compression != Compression::BI_RGB){
    throw ReadBmpError(error_compression(bitmapInfoHeader.compression));
  }

  if (bitmapInfoHeader.colorPlanes != 1){
    throw ReadBmpError(error_color_planes(bitmapInfoHeader.colorPlanes));
  }

  auto bmpSize = get_size_and_order(bitmapInfoHeader);

  if (bitmapInfoHeader.paletteColors != 0){
    if (bitmapInfoHeader.bitsPerPixel != 8){ // Fixme: Maybe support?
      throw ReadBmpError("Palette for non 8-bpp bitmaps unsupported by Faint.");
    }
    auto colorList = or_throw(read_color_table(in, bitmapInfoHeader.paletteColors),
      "Failed reading color table.");
    in.seekg(bitmapFileHeader.dataOffset);

    auto alphaMap = or_throw(read_8bipp_BI_RGB(in, bmpSize),
      "Failed reading 8-bits-per-pixel data");

    return bitmap_from_indexed_colors(alphaMap, colorList);
  }
  else{
    // No palette
    in.seekg(bitmapFileHeader.dataOffset);
    if (bitmapInfoHeader.bitsPerPixel == 8){
      auto alphaMap = or_throw(read_8bipp_BI_RGB(in, bmpSize),
        "Failed reading 8-bits-per-pixel data");
      return bitmap_from_indexed_colors(alphaMap, grayscale_color_table());
    }
    else if (bitmapInfoHeader.bitsPerPixel == 24){
      return or_throw(read_24bipp_BI_RGB(in, bmpSize),
        "Failed reading 24-bits-per-pixel data.");
    }
    else if (bitmapInfoHeader.bitsPerPixel == 32){
      return or_throw(read_32bipp_BI_RGB(in, bmpSize),
        "Failed reading 32-bits-per-pixel data.");
    }
  }
  throw ReadBmpError(Sentence("Unsupported bits-per-pixel",
    bracketed(str_int(bitmapInfoHeader.bitsPerPixel))));
}