Ejemplo n.º 1
0
// DataSet_Modes::ReduceVectors() 
int DataSet_Modes::ReduceVectors() {
  if (evectors_ == 0) {
    mprintf("Warning: Cannot 'reduce', no eigenvectors present.\n");
    return 0;
  }
  if ( Meta().ScalarType() == MetaData::COVAR || Meta().ScalarType() == MetaData::MWCOVAR )
    return ReduceCovar();
  else if ( Meta().ScalarType() == MetaData::DISTCOVAR )
    return ReduceDistCovar();
  else
    mprintf("Warning: 'reduce' not supported for matrix type %s\n", Meta().TypeString());
  return 0;
}
Ejemplo n.º 2
0
void CWidget::Init()
{
    m_pNCursWin = derwin(GetParentWin(), Height(), Width(), Y(), X());
    
    if (!m_pNCursWin)
        throw Exceptions::CExFrontend("Could not create derived window");
    
    m_bSizeChanged = false;
    
    leaveok(m_pNCursWin, false);
    KeyPad(m_pNCursWin, true);
    Meta(m_pNCursWin, true);
    
    if (m_pParent)
    {
        if (!m_bSetFColors)
        {
            TColorPair colors = m_pParent->GetFColors();
            SetFColors(colors);
        }
        
        if (!m_bSetDFColors)
        {
            TColorPair colors = m_pParent->GetDFColors();
            SetDFColors(colors);
        }
    }
    
    CoreInit();
}
Ejemplo n.º 3
0
void CTUI::InitNCurses()
{
    EndWin();
    initscr();
    
    NoEcho();
    CBreak();
    leaveok(GetRootWin(), false);
    KeyPad(GetRootWin(), true);
    Meta(GetRootWin(), true);
    
    if (has_colors())
        StartColor();
    
    m_pMainBox = new CBox(CBox::VERTICAL, false);
    m_pMainBox->SetParent(GetRootWin());
    m_pMainBox->Init();
    m_pMainBox->SetSize(0, 0, GetWWidth(GetRootWin()), GetWHeight(GetRootWin()));
    m_pMainBox->SetFocus(true);
    
    m_pButtonBar = new CButtonBar(GetWWidth(GetRootWin()));
    
    // Focused colors are used for keys, defocused colors for descriptions
    m_pButtonBar->SetFColors(COLOR_YELLOW, COLOR_RED);
    m_pButtonBar->SetDFColors(COLOR_WHITE, COLOR_RED);
    
    m_pMainBox->EndPack(m_pButtonBar, false, false, 0, 0);
    
    m_pWinManager = new CWindowManager;
    m_pMainBox->AddWidget(m_pWinManager);
    m_pWinManager->ReqFocus();
    
    m_pMainBox->RequestQueuedDraw();
}
Ejemplo n.º 4
0
void FileImporter::getSubset(string metapath){
    
    vector < std::pair<float,string> > tmpsubset(0);
    BaseFileLoader::attrSubset.clear();
    
    
    ofFile Meta(metapath);
    if(Meta.exists()){
        ofxJSONElement json;
        json.open(metapath);
        Json::Value val = json.get("InfoGain", "");
        for( Json::Value::iterator iit = val.begin();iit != val.end(); ++iit){
            tmpsubset.push_back(std::pair<float,string>((*iit).asFloat(),iit.memberName()));
        }
        std::sort(tmpsubset.begin(), tmpsubset.end());
        vector< std::pair<float,string> >::iterator startiit = tmpsubset.begin();
        if(tmpsubset.size()>numBest){
            startiit = tmpsubset.end() - numBest;
        }
        ofLogWarning("FileImporter","getting subset :");
        for( vector< std::pair<float,string> >::iterator iit = startiit ; iit < tmpsubset.end() ; ++iit ){
            BaseFileLoader::attrSubset.push_back(iit->second);
            
            ofLogWarning("FileImporter", "\t" +iit->second );
        }
        
        
    }
    
}
Ejemplo n.º 5
0
void Stb::Read(SoyPixelsImpl& Pixels,const ArrayBridge<char>& ArrayBuffer,TReadFunction ReadFunction)
{
#if defined(USE_STB)
	const stbi_uc* Buffer = reinterpret_cast<const stbi_uc*>( ArrayBuffer.GetArray() );
	auto BufferSize = size_cast<int>( ArrayBuffer.GetDataSize() );
	int Width = 0;
	int Height = 0;
	int Channels = 0;
	int RequestedChannels = 4;
	auto* DecodedPixels = stbi_load_from_memory( Buffer, BufferSize, &Width, &Height, &Channels, RequestedChannels );
	if ( !DecodedPixels )
	{
		//	gr: as this is not thread safe, it could come out mangled :( maybe add a lock around error popping before read (maybe have to lock around the whole thing)
		auto* StbError = stbi_failure_reason();
		if ( !StbError )
			StbError = "Unknown error";
		std::stringstream Error;
		Error << "Failed to read image pixels; " << StbError;
		
		throw Soy::AssertException( Error.str() );
	}
	
	//	convert output into pixels
	//	gr: have to assume size
	auto Format = SoyPixelsFormat::GetFormatFromChannelCount( Channels );
	SoyPixelsMeta Meta( Width, Height, Format );
	SoyPixelsRemote OutputPixels( DecodedPixels, Meta.GetDataSize(), Meta );
	Pixels.Copy( OutputPixels );
#else
	throw Soy::AssertException("No STB support, no image reading");
#endif
}
Ejemplo n.º 6
0
void Stb::Read(SoyPixelsImpl& Pixels,TStreamBuffer& Buffer,TReadFunction ReadFunction)
{
	StbContext Context( Buffer, true );
	int Width = 0;
	int Height = 0;
	int Channels = 0;
	//	gr: use 0 for "defaults"
	int RequestedChannels = 0;
	auto* DecodedPixels = ReadFunction( &Context.mContext, &Width, &Height, &Channels, RequestedChannels );
	if ( !DecodedPixels )
	{
		throw Soy::AssertException( Context.GetError() );
	}
		
	//	convert output into pixels
	//	gr: have to assume size
	auto Format = SoyPixelsFormat::GetFormatFromChannelCount( Channels );
	SoyPixelsMeta Meta( Width, Height, Format );
	SoyPixelsRemote OutputPixels( DecodedPixels, Meta.GetDataSize(), Meta );
	Pixels.Copy( OutputPixels );
	
	//	success, don't let context unpop data
	Context.Flush();

}
Ejemplo n.º 7
0
PlaceHolder::Data * PlaceHolder::Data::create() {

   const std::string name = Shm::the().createObjectID();
   Data *p = shm<Data>::construct(name)(name, "", Meta(), Object::UNKNOWN);
   publish(p);

   return p;
}
Ejemplo n.º 8
0
/// Reads the header at the given file position.
/// If the packet could not be read for any reason, the reason is printed.
/// Reading the header means the file position is moved to after the header.
void DTSC::File::readHeader(int pos) {
  fseek(F, pos, SEEK_SET);
  if (fread(buffer, 4, 1, F) != 1) {
    if (feof(F)) {
      DEBUG_MSG(DLVL_DEVEL, "End of file reached while reading header @ %d", pos);
    } else {
      DEBUG_MSG(DLVL_ERROR, "Could not read header @ %d", pos);
    }
    metadata = Meta();
    return;
  }
  if (memcmp(buffer, DTSC::Magic_Header, 4) != 0) {
    DEBUG_MSG(DLVL_ERROR, "Invalid header - %.4s != %.4s  @ %i", (char *)buffer, DTSC::Magic_Header, pos);
    metadata = Meta();
    return;
  }
  if (fread(buffer, 4, 1, F) != 1) {
    DEBUG_MSG(DLVL_ERROR, "Could not read header size @ %i", pos);
    metadata = Meta();
    return;
  }
  long packSize = ntohl(((unsigned long *)buffer)[0]) + 8;
  std::string strBuffer;
  strBuffer.resize(packSize);
  if (packSize) {
    fseek(F, pos, SEEK_SET);
    if (fread((void *)strBuffer.c_str(), packSize, 1, F) != 1) {
      DEBUG_MSG(DLVL_ERROR, "Could not read header packet @ %i", pos);
      metadata = Meta();
      return;
    }
    metadata = Meta(DTSC::Packet(strBuffer.data(), strBuffer.size(),true));
  }
  //if there is another header, read it and replace metadata with that one.
  if (metadata.moreheader) {
    if (metadata.moreheader < getBytePosEOF()) {
      readHeader(metadata.moreheader);
      return;
    }
  }
  if (!metadata.live){
    metadata.vod = true;
  }
}
Ejemplo n.º 9
0
bool DataSet_RemLog::ValidEnsemble() const {
  ReplicaEnsemble::const_iterator member = ensemble_.begin();
  size_t first_size = (*member).size();
  for (; member != ensemble_.end(); ++member) {
    if ((*member).size() != first_size) {
      mprinterr("Error: In remlog data set %s size of ensemble member %zu (%zu) !="
                " size of first member (%zu)\n", Meta().Name().c_str(), // TODO: Change to legend
                member - ensemble_.begin() + 1, (*member).size(), first_size);
      return false;
    }
  }
  return true;
}
Ejemplo n.º 10
0
#define Meta(x)     ((x) | META)
#define Marker(x)   ((x) | MARKER)

static struct mitem mitems[] = {
    { "Note_on_c", Event(NoteOn) },
    { "Note_off_c", Event(NoteOff) },
    { "Pitch_bend_c", Event(PitchBend) },
    { "Control_c", Event(ControlChange) },
    { "Program_c", Event(ProgramChange) },
    { "Poly_aftertouch_c", Event(PolyphonicKeyPressure) },
    { "Channel_aftertouch_c", Event(ChannelPressure) },

    { "System_exclusive", Event(SystemExclusive) },
    { "System_exclusive_packet", Event(SystemExclusivePacket) },

    { "Sequence_number", Meta(SequenceNumberMetaEvent) },
    { "Text_t", Meta(TextMetaEvent) },
    { "Copyright_t", Meta(CopyrightMetaEvent) },
    { "Title_t", Meta(TrackTitleMetaEvent) },
    { "Instrument_name_t", Meta(TrackInstrumentNameMetaEvent) },
    { "Lyric_t", Meta(LyricMetaEvent) },
    { "Marker_t", Meta(MarkerMetaEvent) },
    { "Cue_point_t", Meta(CuePointMetaEvent) },
    { "Channel_prefix", Meta(ChannelPrefixMetaEvent) },
    { "MIDI_port", Meta(PortMetaEvent) } ,
    { "End_track", Meta(EndTrackMetaEvent) },
    { "Tempo", Meta(SetTempoMetaEvent) },
    { "SMPTE_offset", Meta(SMPTEOffsetMetaEvent) },
    { "Time_signature", Meta(TimeSignatureMetaEvent) },
    { "Key_signature", Meta(KeySignatureMetaEvent) },
    { "Sequencer_specific", Meta(SequencerSpecificMetaEvent) },
Ejemplo n.º 11
0
void ProfilerGraph::draw(s32 x_left, s32 y_bottom, video::IVideoDriver *driver,
		gui::IGUIFont *font) const
{
	// Do *not* use UNORDERED_MAP here as the order needs
	// to be the same for each call to prevent flickering
	std::map<std::string, Meta> m_meta;

	for (const Piece &piece : m_log) {
		for (const auto &i : piece.values) {
			const std::string &id = i.first;
			const float &value = i.second;
			std::map<std::string, Meta>::iterator j = m_meta.find(id);

			if (j == m_meta.end()) {
				m_meta[id] = Meta(value);
				continue;
			}

			if (value < j->second.min)
				j->second.min = value;

			if (value > j->second.max)
				j->second.max = value;
		}
	}

	// Assign colors
	static const video::SColor usable_colors[] = {video::SColor(255, 255, 100, 100),
			video::SColor(255, 90, 225, 90),
			video::SColor(255, 100, 100, 255),
			video::SColor(255, 255, 150, 50),
			video::SColor(255, 220, 220, 100)};
	static const u32 usable_colors_count =
			sizeof(usable_colors) / sizeof(*usable_colors);
	u32 next_color_i = 0;

	for (auto &i : m_meta) {
		Meta &meta = i.second;
		video::SColor color(255, 200, 200, 200);

		if (next_color_i < usable_colors_count)
			color = usable_colors[next_color_i++];

		meta.color = color;
	}

	s32 graphh = 50;
	s32 textx = x_left + m_log_max_size + 15;
	s32 textx2 = textx + 200 - 15;
	s32 meta_i = 0;

	for (const auto &p : m_meta) {
		const std::string &id = p.first;
		const Meta &meta = p.second;
		s32 x = x_left;
		s32 y = y_bottom - meta_i * 50;
		float show_min = meta.min;
		float show_max = meta.max;

		if (show_min >= -0.0001 && show_max >= -0.0001) {
			if (show_min <= show_max * 0.5)
				show_min = 0;
		}

		s32 texth = 15;
		char buf[10];
		porting::mt_snprintf(buf, sizeof(buf), "%.3g", show_max);
		font->draw(utf8_to_wide(buf).c_str(),
				core::rect<s32>(textx, y - graphh, textx2,
						y - graphh + texth),
				meta.color);
		porting::mt_snprintf(buf, sizeof(buf), "%.3g", show_min);
		font->draw(utf8_to_wide(buf).c_str(),
				core::rect<s32>(textx, y - texth, textx2, y), meta.color);
		font->draw(utf8_to_wide(id).c_str(),
				core::rect<s32>(textx, y - graphh / 2 - texth / 2, textx2,
						y - graphh / 2 + texth / 2),
				meta.color);
		s32 graph1y = y;
		s32 graph1h = graphh;
		bool relativegraph = (show_min != 0 && show_min != show_max);
		float lastscaledvalue = 0.0;
		bool lastscaledvalue_exists = false;

		for (const Piece &piece : m_log) {
			float value = 0;
			bool value_exists = false;
			Profiler::GraphValues::const_iterator k = piece.values.find(id);

			if (k != piece.values.end()) {
				value = k->second;
				value_exists = true;
			}

			if (!value_exists) {
				x++;
				lastscaledvalue_exists = false;
				continue;
			}

			float scaledvalue = 1.0;

			if (show_max != show_min)
				scaledvalue = (value - show_min) / (show_max - show_min);

			if (scaledvalue == 1.0 && value == 0) {
				x++;
				lastscaledvalue_exists = false;
				continue;
			}

			if (relativegraph) {
				if (lastscaledvalue_exists) {
					s32 ivalue1 = lastscaledvalue * graph1h;
					s32 ivalue2 = scaledvalue * graph1h;
					driver->draw2DLine(
							v2s32(x - 1, graph1y - ivalue1),
							v2s32(x, graph1y - ivalue2),
							meta.color);
				}

				lastscaledvalue = scaledvalue;
				lastscaledvalue_exists = true;
			} else {
				s32 ivalue = scaledvalue * graph1h;
				driver->draw2DLine(v2s32(x, graph1y),
						v2s32(x, graph1y - ivalue), meta.color);
			}

			x++;
		}

		meta_i++;
	}
}
Ejemplo n.º 12
0
void DocumentTemplate::addMeta(const std::string& sMetaName,
                               const std::string& sFieldName)
{
    m_metadata.push_back(Meta(sMetaName, sFieldName));
}
Ejemplo n.º 13
0
llvm::Expected<IndexFileIn> readRIFF(llvm::StringRef Data) {
  auto RIFF = riff::readFile(Data);
  if (!RIFF)
    return RIFF.takeError();
  if (RIFF->Type != riff::fourCC("CdIx"))
    return makeError("wrong RIFF type");
  llvm::StringMap<llvm::StringRef> Chunks;
  for (const auto &Chunk : RIFF->Chunks)
    Chunks.try_emplace(llvm::StringRef(Chunk.ID.data(), Chunk.ID.size()),
                       Chunk.Data);

  for (llvm::StringRef RequiredChunk : {"meta", "stri"})
    if (!Chunks.count(RequiredChunk))
      return makeError("missing required chunk " + RequiredChunk);

  Reader Meta(Chunks.lookup("meta"));
  if (Meta.consume32() != Version)
    return makeError("wrong version");

  auto Strings = readStringTable(Chunks.lookup("stri"));
  if (!Strings)
    return Strings.takeError();

  IndexFileIn Result;
  if (Chunks.count("srcs")) {
    Reader SrcsReader(Chunks.lookup("srcs"));
    Result.Sources.emplace();
    while (!SrcsReader.eof()) {
      auto IGN = readIncludeGraphNode(SrcsReader, Strings->Strings);
      auto Entry = Result.Sources->try_emplace(IGN.URI).first;
      Entry->getValue() = std::move(IGN);
      // We change all the strings inside the structure to point at the keys in
      // the map, since it is the only copy of the string that's going to live.
      Entry->getValue().URI = Entry->getKey();
      for (auto &Include : Entry->getValue().DirectIncludes)
        Include = Result.Sources->try_emplace(Include).first->getKey();
    }
    if (SrcsReader.err())
      return makeError("malformed or truncated include uri");
  }

  if (Chunks.count("symb")) {
    Reader SymbolReader(Chunks.lookup("symb"));
    SymbolSlab::Builder Symbols;
    while (!SymbolReader.eof())
      Symbols.insert(readSymbol(SymbolReader, Strings->Strings));
    if (SymbolReader.err())
      return makeError("malformed or truncated symbol");
    Result.Symbols = std::move(Symbols).build();
  }
  if (Chunks.count("refs")) {
    Reader RefsReader(Chunks.lookup("refs"));
    RefSlab::Builder Refs;
    while (!RefsReader.eof()) {
      auto RefsBundle = readRefs(RefsReader, Strings->Strings);
      for (const auto &Ref : RefsBundle.second) // FIXME: bulk insert?
        Refs.insert(RefsBundle.first, Ref);
    }
    if (RefsReader.err())
      return makeError("malformed or truncated refs");
    Result.Refs = std::move(Refs).build();
  }
  return std::move(Result);
}
Ejemplo n.º 14
0
/// Attempts to parse a packet from the given std::string buffer.
/// Returns true if successful, removing the parsed part from the buffer string.
/// Returns false if invalid or not enough data is in the buffer.
/// \arg buffer The std::string buffer to attempt to parse.
bool DTSC::Stream::parsePacket(std::string & buffer) {
  uint32_t len;
  static bool syncing = false;
  if (buffer.length() > 8) {
    if (memcmp(buffer.c_str(), DTSC::Magic_Header, 4) == 0) {
      len = ntohl(((uint32_t *)buffer.c_str())[1]);
      if (buffer.length() < len + 8) {
        return false;
      }
      unsigned int i = 0;
      JSON::Value meta;
      JSON::fromDTMI((unsigned char *)buffer.c_str() + 8, len, i, meta);
      metadata = Meta(meta);
      buffer.erase(0, len + 8);
      if (buffer.length() <= 8) {
        return false;
      }
    }
    int version = 0;
    if (memcmp(buffer.c_str(), DTSC::Magic_Packet, 4) == 0) {
      version = 1;
    }
    if (memcmp(buffer.c_str(), DTSC::Magic_Packet2, 4) == 0) {
      version = 2;
    }
    if (version) {
      len = ntohl(((uint32_t *)buffer.c_str())[1]);
      if (buffer.length() < len + 8) {
        return false;
      }
      JSON::Value newPack;
      unsigned int i = 0;
      if (version == 1) {
        JSON::fromDTMI((unsigned char *)buffer.c_str() + 8, len, i, newPack);
      }
      if (version == 2) {
        JSON::fromDTMI2((unsigned char *)buffer.c_str() + 8, len, i, newPack);
      }
      buffer.erase(0, len + 8);
      addPacket(newPack);
      syncing = false;
      return true;
    }
#if DEBUG >= DLVL_WARN
    if (!syncing) {
      DEBUG_MSG(DLVL_WARN, "Invalid DTMI data detected - re-syncing");
      syncing = true;
    }
#endif
    size_t magic_search = buffer.find(Magic_Packet);
    size_t magic_search2 = buffer.find(Magic_Packet2);
    if (magic_search2 == std::string::npos) {
      if (magic_search == std::string::npos) {
        buffer.clear();
      } else {
        buffer.erase(0, magic_search);
      }
    } else {
      buffer.erase(0, magic_search2);
    }
  }
  return false;
}
Ejemplo n.º 15
0
/// Adds a set of metadata to the steam.
/// This is implemented by simply replacing the current metadata.
/// This effectively resets the stream.
void DTSC::Stream::addMeta(JSON::Value & newMeta) {
  metadata = Meta(newMeta);
}