/*
This function is actually somewhat wasteful since it
allocates a large buffer for the bitmap and then writes that
out a byte at a time. This can definintely be done better.
*/
void Bitmap::WriteFile(const std::string &filename) const
{
std::vector<uint8_t> rawdata(filesize_);
uint8_t *raw = &rawdata[0];
int len = 0;
memcpy(raw, &bf_, sizeof(bfheader_t));
len += sizeof(bfheader_t);
memcpy(raw + len, &bi_, sizeof(biheader_t));
len += sizeof(biheader_t);
for (int y = 0; y < height_; y++) {
int c = 0;
for (int x = 0; x < width_; x++) {
memcpy(raw + len, &data_[y * bi_.width + x], sizeof(b24bitpixel_t));
c += sizeof(b24bitpixel_t);
len += sizeof(b24bitpixel_t);
}
if (c % 4 != 0) {
memset(raw + len, 0xFF, 4 - (c % 4));
len += (4 - (c % 4));
}
}
// Actually write the huge buffer we made.
std::ofstream file(filename, std::ios::out | std::ios::binary);
for (int i = 0; i < filesize_; i++) {
file << raw[i];
}
file.close();
return;
}
int main() {
arma::mat rawdata;
rawdata.load(data.c_str());
arma::mat X;
X=rawdata(arma::span(0, numExp-1), arma::span(0, numFeat-1));
int m = numExp;
int n = numFeat;
arma::mat mu(nCl,n);
mu.randu();
//bring inital mu into correct range
for (int i=0; i<n; i++) {
mu.col(i) = X.col(i).min() + (X.col(i).max()-X.col(i).min())*mu.col(i);
}
arma::mat cinit(nCl,1);
cinit.zeros();
arma::mat cloop;
arma::mat c(m,1); //vector which assign each example to a cluster
int numC;
for (int k=0; k<numIter; k++) {
//E-Step:
c.zeros();
for (int i=0; i<m; i++) {
cloop = cinit;
for (int j=0; j<nCl; j++) {
cloop.row(j) = (X.row(i)-mu.row(j))*trans(X.row(i)-mu.row(j));
}
c.row(i) = cloop.index_min();
}
//M-Step:
mu.zeros();
for (int j=0; j<nCl; j++) {
numC=0;
for (int i=0; i<m; i++) {
if (c(i,0)==j) {
numC += 1;
mu.row(j) += X.row(i);
}
}
if(numC==0) {mu.row(j).zeros();} //no training examples were assigned to this cluster (maybe too many clusters?)
mu.row(j) = mu.row(j)/numC;
}
}
//output data files to be used for plotting
std::ofstream of_X("X_kMeans.out");
std::ofstream of_c("c_kMeans.out");
std::ofstream of_mu("mu_kMeans.out");
for (int i=0;i<X.n_rows;i++) {
of_X << X.row(i) << std::endl;
of_c << c.row(i) << std::endl;
}
for (int i=0;i<mu.n_rows;i++) {
of_mu << mu.row(i) << std::endl;
}
}
void StringData::append(const char* s, int len) {
assert(!isStatic() && getCount() <= 1);
if (len == 0) return;
if (UNLIKELY(uint32_t(len) > MaxSize)) {
throw InvalidArgumentException("len > 2^31-2", len);
}
if (UNLIKELY(size_t(m_len) + size_t(len) > MaxSize)) {
throw FatalErrorException(0, "String length exceeded 2^31-2: %zu",
size_t(len) + size_t(m_len));
}
const uint32_t newLen = m_len + len;
/*
* In case we're being to asked to append our own string, we need to
* load the old pointer value (it might change when we reserve
* below).
*
* We don't allow appending with an interior pointers here, although
* we may be asked to append less than the whole string.
*/
auto const oldDataPtr = rawdata();
assert(uintptr_t(s) <= uintptr_t(rawdata()) ||
uintptr_t(s) >= uintptr_t(rawdata() + capacity()));
assert(s != rawdata() || len <= m_len);
auto const mslice = UNLIKELY(isShared()) ? escalate(newLen)
: reserve(newLen);
if (UNLIKELY(s == oldDataPtr)) s = mslice.ptr;
/*
* memcpy is safe even if it's a self append---the regions will be
* disjoint, since s can't point past our oldDataPtr, and len is
* smaller than the old length.
*/
memcpy(mslice.ptr + m_len, s, len);
setSize(newLen);
assert(checkSane());
}
HOT_FUNC
StringData::StringData(SharedVariant *shared)
: _count(0) {
ASSERT(shared);
shared->incRef();
m_hash = 0;
m_len = shared->stringLength();
m_cdata = shared->stringData();
m_big.shared = shared;
m_big.cap = m_len | IsShared;
TAINT_OBSERVER_REGISTER_MUTATED(m_taint_data, rawdata());
}
void StringData::initLiteral(const char* data, int len) {
if (uint32_t(len) > MaxSize) {
throw InvalidArgumentException("len>=2^30", len);
}
// Do not copy literals, this StringData can have a shorter lifetime than
// the literal, and the client can count on this->data() giving back
// the literal ptr with the longer lifetime. Sketchy!
m_hash = 0;
_count = 0;
m_len = len;
m_cdata = data;
m_big.cap = len | IsLiteral;
ASSERT(checkSane());
TAINT_OBSERVER_REGISTER_MUTATED(m_taint_data, rawdata());
}
void StringData::initAttachDeprecated(const char* data, int len) {
if (uint32_t(len) > MaxSize) {
throw InvalidArgumentException("len>=2^30", len);
}
// Don't copy small strings here either because the caller sometimes
// assumes he can mess with data while this string is still alive,
// and we want to free it eagerly. Sketchy!
m_hash = 0;
_count = 0;
m_len = len;
m_cdata = data;
m_big.cap = len | IsMalloc;
ASSERT(checkSane());
TAINT_OBSERVER_REGISTER_MUTATED(m_taint_data, rawdata());
}
set<string> LoadAllTokens(string& filename)
{
ifstream rawdata(filename.c_str());
set<string> tokens;
istream_iterator<string> rawitr(rawdata);
istream_iterator<string> eos;
insert_iterator<set<string> > tkitr(tokens,tokens.begin());
while(rawitr!=eos)
{
*tkitr=*rawitr;
++tkitr;
++rawitr;
}
return tokens;
}
bool StringData::checkSane() const {
static_assert(sizeof(Format) == 8, "enum Format is wrong size");
static_assert(offsetof(StringData, _count) == FAST_REFCOUNT_OFFSET,
"_count at wrong offset");
static_assert(MaxSmallSize == sizeof(StringData) -
offsetof(StringData, m_small) - 1, "layout bustage");
ASSERT(uint32_t(size()) <= MaxSize);
ASSERT(uint32_t(capacity()) <= MaxSize);
ASSERT(size() <= capacity());
ASSERT(rawdata()[size()] == 0); // all strings must be null-terminated
if (isSmall()) {
ASSERT(m_data == m_small && m_len <= MaxSmallSize);
} else {
ASSERT(m_data && m_data != m_small);
}
return true;
}
HOT_FUNC
int StringData::compare(const StringData *v2) const {
assert(v2);
if (v2 == this) return 0;
int ret = numericCompare(v2);
if (ret < -1) {
int len1 = size();
int len2 = v2->size();
int len = len1 < len2 ? len1 : len2;
ret = memcmp(rawdata(), v2->rawdata(), len);
if (ret) return ret;
if (len1 == len2) return 0;
return len < len1 ? 1 : -1;
}
return ret;
}
HOT_FUNC
int StringData::compare(const StringData *v2) const {
ASSERT(v2);
if (v2 == this) return 0;
int ret = numericCompare(v2);
if (ret < -1) {
int len1 = size();
int len2 = v2->size();
int len = len1 < len2 ? len1 : len2;
// No taint absorption on self-contained string ops like compare
ret = memcmp(rawdata(), v2->rawdata(), len);
if (ret) return ret;
if (len1 == len2) return 0;
return len < len1 ? 1 : -1;
}
return ret;
}
bool Vehicle::read_params(string file) {
std::ifstream stream(file);
if(!stream) {
return false;
}
std::string rawdata((std::istreambuf_iterator<char>(stream)), std::istreambuf_iterator<char>());
nlohmann::json data = nlohmann::json::parse(rawdata);
if(data.count("gains")) {
params.gains.p = Point(data["gains"]["p"][0], data["gains"]["p"][1], data["gains"]["p"][2]);
params.gains.i = Point(data["gains"]["i"][0], data["gains"]["i"][1], data["gains"]["i"][2]);
params.gains.d = Point(data["gains"]["d"][0], data["gains"]["d"][1], data["gains"]["d"][2]);
}
if(data.count("hoverPoint")) {
params.hoverPoint = data["hoverPoint"];
}
if(data.count("latency")) {
params.latency = data["latency"];
}
if(data.count("mocapYawOffset")) {
params.mocapYawOffset = ((double) data["mocapYawOffset"]) * (M_PI / 180.0);
}
else {
params.mocapYawOffset = 0;
}
if(data.count("orientationMismatchCorrection")) {
params.orientationMismatchCorrection = (bool) data["orientationMismatchCorrection"];
}
else {
params.orientationMismatchCorrection = false;
}
return true;
}
HOT_FUNC
void StringData::initAttach(const char* data, int len) {
if (uint32_t(len) > MaxSize) {
throw InvalidArgumentException("len>=2^30", len);
}
m_hash = 0;
_count = 0;
if (uint32_t(len) <= MaxSmallSize) {
memcpy(m_small, data, len);
m_len = len;
m_data = m_small;
m_small[len] = 0;
m_small[MaxSmallSize] = 0;
free((void*)data);
} else {
m_len = len;
m_cdata = data;
m_big.cap = len | IsMalloc;
}
ASSERT(checkSane());
TAINT_OBSERVER_REGISTER_MUTATED(m_taint_data, rawdata());
}
void StringData::append(const char *s, int len) {
ASSERT(!isStatic()); // never mess around with static strings!
if (len == 0) return;
if (UNLIKELY(uint32_t(len) > MaxSize)) {
throw InvalidArgumentException("len>=2^30", len);
}
if (UNLIKELY(len + m_len > MaxSize)) {
throw FatalErrorException(0, "String length exceeded 2^30 - 1: %u",
len + m_len);
}
int newlen;
// TODO: t1122987: in any of the cases below where we need a bigger buffer,
// we can probably assume we're in a concat-loop and pick a good buffer
// size to avoid O(N^2) copying cost.
if (isShared() || isLiteral()) {
// buffer is immutable, don't modify it.
// We are mutating, so we don't need to repropagate our own taint
StringSlice r = slice();
char* newdata = string_concat(r.ptr, r.len, s, len, newlen);
if (isShared()) m_big.shared->decRef();
m_len = newlen;
m_data = newdata;
m_big.cap = newlen | IsMalloc;
m_hash = 0;
} else if (rawdata() == s) {
// appending ourself to ourself, be conservative.
// We are mutating, so we don't need to repropagate our own taint
StringSlice r = slice();
char *newdata = string_concat(r.ptr, r.len, s, len, newlen);
releaseData();
m_len = newlen;
m_data = newdata;
m_big.cap = newlen | IsMalloc;
m_hash = 0;
} else if (isSmall()) {
// we're currently small but might not be after append.
// We are mutating, so we don't need to repropagate our own taint
int oldlen = m_len;
newlen = oldlen + len;
if (unsigned(newlen) <= MaxSmallSize) {
// win.
memcpy(&m_small[oldlen], s, len);
m_small[newlen] = 0;
m_small[MaxSmallSize] = 0;
m_len = newlen;
m_data = m_small;
m_hash = 0;
} else {
// small->big string transition.
char *newdata = string_concat(m_small, oldlen, s, len, newlen);
m_len = newlen;
m_data = newdata;
m_big.cap = newlen | IsMalloc;
m_hash = 0;
}
} else {
// generic "big string concat" path. realloc buffer.
int oldlen = m_len;
char* oldp = m_data;
ASSERT((oldp > s && oldp - s > len) ||
(oldp < s && s - oldp > oldlen)); // no overlapping
newlen = oldlen + len;
char* newdata = (char*) realloc(oldp, newlen + 1);
memcpy(newdata + oldlen, s, len);
newdata[newlen] = 0;
m_len = newlen;
m_data = newdata;
m_big.cap = newlen | IsMalloc;
m_hash = 0;
}
ASSERT(uint32_t(newlen) <= MaxSize);
TAINT_OBSERVER_REGISTER_MUTATED(m_taint_data, rawdata());
ASSERT(checkSane());
}
int64_t StringData::toInt64(int base /* = 10 */) const {
return strtoll(rawdata(), nullptr, base);
}
bool UIDirect3D9Window::HandleRawInput(MSG *Message, long *Result)
{
// check the raw data size
UINT size = 0;
GetRawInputData((HRAWINPUT)Message->lParam, RID_INPUT, NULL, &size, sizeof(RAWINPUTHEADER));
if (size < 2)
{
LOG(VB_GENERAL, LOG_ERR, "Failed to get raw input data");
return false;
}
// retrieve the raw data
QByteArray buffer(size, 0);
if (size == GetRawInputData((HRAWINPUT)Message->lParam, RID_INPUT, buffer.data(), &size, sizeof(RAWINPUTHEADER)))
{
RAWINPUT* rawinput = (RAWINPUT*)buffer.data();
// HID and valid data size
if (rawinput->header.dwType == RIM_TYPEHID && rawinput->data.hid.dwCount > 0)
{
// retrieve the device info to filter on usage page
RID_DEVICE_INFO deviceinfo;
memset(&deviceinfo, 0, sizeof(RID_DEVICE_INFO));
uint devsize = sizeof(RID_DEVICE_INFO);
deviceinfo.cbSize = devsize;
if (GetRawInputDeviceInfo(rawinput->header.hDevice, RIDI_DEVICEINFO, (void*)&deviceinfo, &devsize) > 0 &&
deviceinfo.dwType == RIM_TYPEHID)
{
bool mcebutton = deviceinfo.hid.usUsagePage == 0xFFBC && deviceinfo.hid.usUsage == 0x88;
bool consumer = deviceinfo.hid.usUsagePage == 0x000C && deviceinfo.hid.usUsage == 0x01;
if (mcebutton || consumer)
{
LOG(VB_GUI, LOG_DEBUG, QString("HID device: vendor %1 product %2 version %3 page 0x%4 usage 0x%5")
.arg(deviceinfo.hid.dwVendorId).arg(deviceinfo.hid.dwProductId).arg(deviceinfo.hid.dwVersionNumber)
.arg(deviceinfo.hid.usUsagePage, 0, 16).arg(deviceinfo.hid.usUsage, 0,16));
QByteArray rawdata((const char*)&rawinput->data.hid.bRawData, (int)rawinput->data.hid.dwSizeHid);
int button = 0;
// first byte contains other info
for (int i = 1; i < rawdata.size(); ++i)
button += ((quint8)rawdata[i]) << ((i -1) * 8);
if (button && consumer && (button != AC_PROGRAM_GUIDE && button != AC_PROPERTIES))
{
LOG(VB_GENERAL, LOG_INFO, QString("Ignoring consumer control button 0x%1")
.arg(button, 0, 16));
button = 0;
}
int key = 0;
QString context;
if (button && mcebutton)
{
context = "HID Vendor Control";
switch (button)
{
case MS_GREENBUTTON: key = Qt::Key_OfficeHome; break;
case MS_DVDMENU: key = Qt::Key_Menu; break;
case MS_LIVETV: key = Qt::Key_Messenger; break;
case MS_ZOOM: key = Qt::Key_Zoom; break;
case MS_EJECT: key = Qt::Key_Eject; break;
case MS_CLOSEDCAPTION: key = Qt::Key_Subtitle; break;
case MS_RESERVED3: key = Qt::Key_F27; break;
case MS_SUBAUDIO: key = Qt::Key_AudioCycleTrack; break;
case MS_EXT0: key = Qt::Key_Launch5; break;
case MS_EXT1: key = Qt::Key_Launch6; break;
case MS_EXT2: key = Qt::Key_Launch7; break;
case MS_EXT3: key = Qt::Key_Launch8; break;
case MS_EXT4: key = Qt::Key_Launch9; break;
case MS_EXT5: key = Qt::Key_LaunchA; break;
case MS_EXT6: key = Qt::Key_LaunchB; break;
case MS_EXT7: key = Qt::Key_LaunchC; break;
case MS_EXT8: key = Qt::Key_LaunchD; break;
case MS_EXTRAS: key = Qt::Key_AudioForward; break;
case MS_EXTRASAPP: key = Qt::Key_AudioRepeat; break;
case MS_10: key = Qt::Key_Flip; break;
case MS_11: key = Qt::Key_Hangup; break;
case MS_12: key = Qt::Key_VoiceDial; break;
case MS_RESERVED5: key = Qt::Key_F29; break;
case MS_CHANNELINPUT: key = Qt::Key_C; break; // see TorcCECDevice for consistency
case MS_DVDTOPMENU: key = Qt::Key_TopMenu; break;
case MS_MUSIC: key = Qt::Key_Music; break;
case MS_RECORDEDTV: key = Qt::Key_Execute; break;
case MS_PICTURES: key = Qt::Key_Pictures; break;
case MS_VIDEOS: key = Qt::Key_Video; break;
case MS_DVDANGLE: key = Qt::Key_F24; break; // see TorcCECDevice for consistency
case MS_DVDAUDIO: key = Qt::Key_Plus; break; // see TorcCECDevice for consistency
case MS_DVDSUBTITLE: key = Qt::Key_Time; break;
case MS_RESERVED1: key = Qt::Key_F25; break;
case MS_FMRADIO: key = Qt::Key_LastNumberRedial; break;
case MS_TELETEXT: key = Qt::Key_F7; break;
case MS_TELETEXT_RED: key = Qt::Key_F2; break; // see TorcCECDevice for consistency
case MS_TELETEXT_GREEN: key = Qt::Key_F3; break;
case MS_TELETEXT_YELLOW: key = Qt::Key_F4; break;
case MS_TELETEXT_BLUE: key = Qt::Key_F5; break;
case MS_RESERVED2: key = Qt::Key_F26; break;
case MS_EXT11: key = Qt::Key_LaunchG; break;
case MS_RESERVED4: key = Qt::Key_F28; break;
case MS_EXT9: key = Qt::Key_LaunchE; break;
case MS_EXT10: key = Qt::Key_LaunchF; break;
}
}
else if (button && consumer)
{
context = "HID Consumer Control";
switch (button)
{
case AC_PROPERTIES: key = Qt::Key_I; break;
case AC_PROGRAM_GUIDE: key = Qt::Key_S; break;
}
}
if (key)
{
QKeyEvent *keyevent = new QKeyEvent(QEvent::KeyPress, key, TORC_KEYEVENT_MODIFIERS, context);
if (gLocalContext->GetUIObject())
QApplication::postEvent(gLocalContext->GetUIObject(), keyevent);
*Result = 0;
LOG(VB_GENERAL, LOG_INFO, QString("WM_INPUT: button 0x%1").arg(button, 0, 16));
return true;
}
}
}
else
{
LOG(VB_GENERAL, LOG_ERR, "Failed to get device info");
}
}
}
else
{
LOG(VB_GENERAL, LOG_ERR, "Failed to retrieve raw input data");
}
return false;
}
void StringData::setChar(int offset, char ch) {
ASSERT(offset >= 0 && offset < size() && !isStatic());
if (isImmutable()) escalate();
((char*)rawdata())[offset] = ch;
m_hash = 0;
}
int64 StringData::toInt64(int base /* = 10 */) const {
// Taint absorbtion unnecessary; taint is recreated later for numerics
return strtoll(rawdata(), NULL, base);
}
